jro_apps/redmine Commit - r4568:80b329d031dc

scm: mercurial: change diff option from --git to --config diff.git=false (#7253)....

Toshi MARUYAMA -

r4568:80b329d031dc

parent child

Context file:

r4568:80b329d031dc

Collapse all files

lib/redmine/scm/adapters/mercurial_adapter.rb +1 -1

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/abstract_adapter'
             require 'cgi'
             module Redmine
               module Scm
                 module Adapters
                   class MercurialAdapter < AbstractAdapter
                     # Mercurial executable name
                     HG_BIN = "hg"
                     TEMPLATES_DIR = File.dirname(__FILE__) + "/mercurial"
                     TEMPLATE_NAME = "hg-template"
                     TEMPLATE_EXTENSION = "tmpl"
                     class << self
                       def client_version
                         @@client_version ||= (hgversion || [])
                       end
                       def hgversion
                         # The hg version is expressed either as a
                         # release number (eg 0.9.5 or 1.0) or as a revision
                         # id composed of 12 hexa characters.
                         theversion = hgversion_from_command_line
                         if m = theversion.match(%r{\A(.*?)((\d+\.)+\d+)})
                           m[2].scan(%r{\d+}).collect(&:to_i)
                         end
                       end
                       def hgversion_from_command_line
                         shellout("#{HG_BIN} --version") { |io| io.read }.to_s
                       end
                       def template_path
                         @@template_path ||= template_path_for(client_version)
                       end
                       def template_path_for(version)
                         if ((version <=> [0,9,5]) > 0) || version.empty?
                           ver = "1.0"
                         else
                           ver = "0.9.5"
                         end
                         "#{TEMPLATES_DIR}/#{TEMPLATE_NAME}-#{ver}.#{TEMPLATE_EXTENSION}"
                       end
                     end
                     def info
                       cmd = "#{HG_BIN} -R #{target('')} root"
                       root_url = nil
                       shellout(cmd) do |io|
                         root_url = io.read
                       end
                       return nil if $? && $?.exitstatus != 0
                       info = Info.new({:root_url => root_url.chomp,
                                         :lastrev => revisions(nil,nil,nil,{:limit => 1}).last
                                       })
                       info
                     rescue CommandFailed
                       return nil
                     end
                     def entries(path=nil, identifier=nil)
                       path ||= ''
                       entries = Entries.new
                       cmd = "#{HG_BIN} -R #{target('')} --cwd #{target('')} locate"
                       cmd << " -r #{hgrev(identifier)}"
                       cmd << " " + shell_quote("path:#{path}") unless path.empty?
                       shellout(cmd) do |io|
                         io.each_line do |line|
                           # HG uses antislashs as separator on Windows
                           line = line.gsub(/\\/, "/")
                           if path.empty? or e = line.gsub!(%r{^#{with_trailling_slash(path)}},'')
                             e ||= line
                             e = e.chomp.split(%r{[\/\\]})
                             entries << Entry.new({:name => e.first,
                                                    :path => (path.nil? or path.empty? ? e.first : "#{with_trailling_slash(path)}#{e.first}"),
                                                    :kind => (e.size > 1 ? 'dir' : 'file'),
                                                    :lastrev => Revision.new
                                                  }) unless e.empty? || entries.detect{|entry| entry.name == e.first}
                           end
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       entries.sort_by_name
                     end
                     # Fetch the revisions by using a template file that
                     # makes Mercurial produce a xml output.
                     def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       revisions = Revisions.new
                       cmd = "#{HG_BIN} --debug --encoding utf8 -R #{target('')} log -C --style #{shell_quote self.class.template_path}"
                       if identifier_from && identifier_to
                         cmd << " -r #{hgrev(identifier_from)}:#{hgrev(identifier_to)}"
                       elsif identifier_from
                         cmd << " -r #{hgrev(identifier_from)}:"
                       end
                       cmd << " --limit #{options[:limit].to_i}" if options[:limit]
                       cmd << " #{shell_quote path}" unless path.blank?
                       shellout(cmd) do |io|
                         begin
                           # HG doesn't close the XML Document...
                           doc = REXML::Document.new(io.read << "</log>")
                           doc.elements.each("log/logentry") do |logentry|
                             paths = []
                             copies = logentry.get_elements('paths/path-copied')
                             logentry.elements.each("paths/path") do |path|
                               # Detect if the added file is a copy
                               if path.attributes['action'] == 'A' and c = copies.find{ |e| e.text == path.text }
                                 from_path = c.attributes['copyfrom-path']
                                 from_rev = logentry.attributes['revision']
                               end
                               paths << {:action => path.attributes['action'],
                                 :path => "/#{CGI.unescape(path.text)}",
                                 :from_path => from_path ? "/#{CGI.unescape(from_path)}" : nil,
                                 :from_revision => from_rev ? from_rev : nil
                               }
                             end
                             paths.sort! { |x,y| x[:path] <=> y[:path] }
                             revisions << Revision.new({:identifier => logentry.attributes['revision'],
                                                         :scmid => logentry.attributes['node'],
                                                         :author => (logentry.elements['author'] ? logentry.elements['author'].text : ""),
                                                         :time => Time.parse(logentry.elements['date'].text).localtime,
                                                         :message => logentry.elements['msg'].text,
                                                         :paths => paths
                                                       })
                           end
                         rescue
                           logger.debug($!)
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       revisions
                     end
                     def diff(path, identifier_from, identifier_to=nil)
                       path ||= ''
                       diff_args = ''
                       diff = []
                       if identifier_to
                         diff_args = "-r #{hgrev(identifier_to)} -r #{hgrev(identifier_from)}"
                       else
                         if self.class.client_version_above?([1, 2])
                           diff_args = "-c #{hgrev(identifier_from)}"
                         else
                           return []
                         end
                       end
-                      cmd = "#{HG_BIN} -R #{target('')} diff --nodates --git #{diff_args}"
+                      cmd = "#{HG_BIN} -R #{target('')} --config diff.git=false diff --nodates #{diff_args}"
                       cmd << " -I #{target(path)}" unless path.empty?
                       shellout(cmd) do |io|
                         io.each_line do |line|
                           diff << line
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       diff
                     end
                     def cat(path, identifier=nil)
                       cmd = "#{HG_BIN} -R #{target('')} cat"
                       cmd << " -r #{hgrev(identifier)}"
                       cmd << " #{target(path)}"
                       cat = nil
                       shellout(cmd) do |io|
                         io.binmode
                         cat = io.read
                       end
                       return nil if $? && $?.exitstatus != 0
                       cat
                     end
                     def annotate(path, identifier=nil)
                       path ||= ''
                       cmd = "#{HG_BIN} -R #{target('')}"
                       cmd << " annotate -ncu"
                       cmd << " -r #{hgrev(identifier)}"
                       cmd << " #{target(path)}"
                       blame = Annotate.new
                       shellout(cmd) do |io|
                         io.each_line do |line|
                           next unless line =~ %r{^([^:]+)\s(\d+)\s([0-9a-f]+):\s(.*)$}
                           r = Revision.new(:author => $1.strip, :revision => $2, :scmid => $3,
                                            :identifier => $3)
                           blame.add_line($4.rstrip, r)
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       blame
                     end
                     class Revision < Redmine::Scm::Adapters::Revision
                       # Returns the readable identifier
                       def format_identifier
                         "#{revision}:#{scmid}"
                       end
                     end
                     # Returns correct revision identifier
                     def hgrev(identifier)
                       shell_quote(identifier.blank? ? 'tip' : identifier.to_s)
                     end
                     private :hgrev
                   end
                 end
               end
             end

test/unit/lib/redmine/scm/adapters/mercurial_adapter_test.rb +2 -2

             require File.expand_path('../../../../../../test_helper', __FILE__)
             begin
               require 'mocha'
               class MercurialAdapterTest < ActiveSupport::TestCase
                 TEMPLATES_DIR = Redmine::Scm::Adapters::MercurialAdapter::TEMPLATES_DIR
                 TEMPLATE_NAME = Redmine::Scm::Adapters::MercurialAdapter::TEMPLATE_NAME
                 TEMPLATE_EXTENSION = Redmine::Scm::Adapters::MercurialAdapter::TEMPLATE_EXTENSION
                 REPOSITORY_PATH = RAILS_ROOT.gsub(%r{config\/\.\.}, '') + '/tmp/test/mercurial_repository'
                 if File.directory?(REPOSITORY_PATH)
                   def setup
                     @adapter = Redmine::Scm::Adapters::MercurialAdapter.new(REPOSITORY_PATH)
                   end
                   def test_hgversion
                     to_test = { "Mercurial Distributed SCM (version 0.9.5)\n"  => [0,9,5],
                                 "Mercurial Distributed SCM (1.0)\n"            => [1,0],
                                 "Mercurial Distributed SCM (1e4ddc9ac9f7+20080325)\n" => nil,
                                 "Mercurial Distributed SCM (1.0.1+20080525)\n" => [1,0,1],
                                 "Mercurial Distributed SCM (1916e629a29d)\n"   => nil,
                                 "Mercurial SCM Distribuito (versione 0.9.5)\n" => [0,9,5],
                                 "(1.6)\n(1.7)\n(1.8)"                          => [1,6],
                                 "(1.7.1)\r\n(1.8.1)\r\n(1.9.1)"                => [1,7,1]}
                     to_test.each do |s, v|
                       test_hgversion_for(s, v)
                     end
                   end
                   def test_template_path
                     to_test = { [0,9,5]  => "0.9.5",
                                 [1,0]    => "1.0",
                                 []       => "1.0",
                                 [1,0,1]  => "1.0",
                                 [1,7]    => "1.0",
                                 [1,7,1]  => "1.0" }
                     to_test.each do |v, template|
                       test_template_path_for(v, template)
                     end
                   end
                   def test_diff
                     if @adapter.class.client_version_above?([1, 2])
                       assert_nil @adapter.diff(nil, '100000')
                     end
                     assert_nil @adapter.diff(nil, '100000', '200000')
                     [2, '400bb8672109', '400', 400].each do |r1|
                       diff1 = @adapter.diff(nil, r1)
                       if @adapter.class.client_version_above?([1, 2])
                         assert_equal 28, diff1.size
                         buf = diff1[24].gsub(/\r\n|\r|\n/, "")
                         assert_equal "+    return true unless klass.respond_to?('watched_by')", buf
                       else
                         assert_equal 0, diff1.size
                       end
                       [4, 'def6d2f1254a'].each do |r2|
                         diff2 = @adapter.diff(nil,r1,r2)
-                        assert_equal 50, diff2.size
+                        assert_equal 49, diff2.size
-                        buf =  diff2[42].gsub(/\r\n|\r|\n/, "")
+                        buf =  diff2[41].gsub(/\r\n|\r|\n/, "")
                         assert_equal "+class WelcomeController < ApplicationController", buf
                         diff3 = @adapter.diff('sources/watchers_controller.rb', r1, r2)
                         assert_equal 20, diff3.size
                         buf =  diff3[12].gsub(/\r\n|\r|\n/, "")
                         assert_equal "+    @watched.remove_watcher(user)", buf
                       end
                     end
                   end
                   def test_cat
                     [2, '400bb8672109', '400', 400].each do |r|
                       buf = @adapter.cat('sources/welcome_controller.rb', r)
                       assert buf
                       lines = buf.split("\r\n")
                       assert_equal 25, lines.length
                       assert_equal 'class WelcomeController < ApplicationController', lines[17]
                     end
                     assert_nil @adapter.cat('sources/welcome_controller.rb')
                   end
                   def test_annotate
                     assert_equal [], @adapter.annotate("sources/welcome_controller.rb").lines
                     [2, '400bb8672109', '400', 400].each do |r|
                       ann = @adapter.annotate('sources/welcome_controller.rb', r)
                       assert ann
                       assert_equal '1', ann.revisions[17].revision
                       assert_equal '9d5b5b004199', ann.revisions[17].identifier
                       assert_equal 'jsmith', ann.revisions[0].author
                       assert_equal 25, ann.lines.length
                       assert_equal 'class WelcomeController < ApplicationController', ann.lines[17]
                     end
                   end
                   def test_access_by_nodeid
                     path = 'sources/welcome_controller.rb'
                     assert_equal @adapter.cat(path, 2), @adapter.cat(path, '400bb8672109')
                   end
                   def test_access_by_fuzzy_nodeid
                     path = 'sources/welcome_controller.rb'
                     # falls back to nodeid
                     assert_equal @adapter.cat(path, 2), @adapter.cat(path, '400')
                   end
                   private
                   def test_hgversion_for(hgversion, version)
                     @adapter.class.expects(:hgversion_from_command_line).returns(hgversion)
                     assert_equal version, @adapter.class.hgversion
                   end
                   def test_template_path_for(version, template)
                     assert_equal "#{TEMPLATES_DIR}/#{TEMPLATE_NAME}-#{template}.#{TEMPLATE_EXTENSION}",
                                  @adapter.class.template_path_for(version)
                     assert File.exist?(@adapter.class.template_path_for(version))
                   end
                 else
                   puts "Mercurial test repository NOT FOUND. Skipping unit tests !!!"
                   def test_fake; assert true end
                 end
               end
             rescue LoadError
               class MercurialMochaFake < ActiveSupport::TestCase
                 def test_fake; assert(false, "Requires mocha to run those tests")  end
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages