jro_apps/redmine Commit - r1485:aa9d04a4a7ec

Mercurial adapter improvements (patch #1199 by Pierre Paysant-Le Roux)....

Jean-Philippe Lang -

r1485:aa9d04a4a7ec

parent child

Context file:

r1485:aa9d04a4a7ec

Collapse all files

lib/redmine/scm/adapters/mercurial/hg-template-0.9.5.tmpl created 644 +12 0

@@ -0,0 +1,12
	1	changeset = 'This template must be used with --debug option\n'
	2	changeset_quiet = 'This template must be used with --debug option\n'
	3	changeset_verbose = 'This template must be used with --debug option\n'
	4	changeset_debug = '<logentry revision="{rev}" node="{node\|short}">\n<author>{author\|escape}</author>\n<date>{date\|isodate}</date>\n<paths>\n{files}{file_adds}{file_dels}{file_copies}</paths>\n<msg>{desc\|escape}</msg>\n{tags}</logentry>\n\n'
	5
	6	file = '<path action="M">{file\|escape}</path>\n'
	7	file_add = '<path action="A">{file_add\|escape}</path>\n'
	8	file_del = '<path action="D">{file_del\|escape}</path>\n'
	9	file_copy = '<path-copied copyfrom-path="{source\|escape}">{name\|urlescape}</path-copied>\n'
	10	tag = '<tag>{tag\|escape}</tag>\n'
	11	header='<?xml version="1.0" encoding="UTF-8" ?>\n<log>\n\n'
	12	# footer="</log>" No newline at end of file

lib/redmine/scm/adapters/mercurial/hg-template-1.0.tmpl created 644 +12 0

@@ -0,0 +1,12
	1	changeset = 'This template must be used with --debug option\n'
	2	changeset_quiet = 'This template must be used with --debug option\n'
	3	changeset_verbose = 'This template must be used with --debug option\n'
	4	changeset_debug = '<logentry revision="{rev}" node="{node\|short}">\n<author>{author\|escape}</author>\n<date>{date\|isodate}</date>\n<paths>\n{file_mods}{file_adds}{file_dels}{file_copies}</paths>\n<msg>{desc\|escape}</msg>\n{tags}</logentry>\n\n'
	5
	6	file_mod = '<path action="M">{file_mod\|escape}</path>\n'
	7	file_add = '<path action="A">{file_add\|escape}</path>\n'
	8	file_del = '<path action="D">{file_del\|escape}</path>\n'
	9	file_copy = '<path-copied copyfrom-path="{source\|escape}">{name\|urlescape}</path-copied>\n'
	10	tag = '<tag>{tag\|escape}</tag>\n'
	11	header='<?xml version="1.0" encoding="UTF-8" ?>\n<log>\n\n'
	12	# footer="</log>"

test/unit/mercurial_adapter_test.rb created 644 +49 0

@@ -0,0 +1,49
	1	require File.dirname(__FILE__) + '/../test_helper'
	2	begin
	3	require 'mocha'
	4
	5	class MercurialAdapterTest < Test::Unit::TestCase
	6
	7	TEMPLATES_DIR = "#{RAILS_ROOT}/extra/mercurial"
	8	TEMPLATE_NAME = "hg-template"
	9	TEMPLATE_EXTENSION = "tmpl"
	10
	11	REPOSITORY_PATH = RAILS_ROOT.gsub(%r{config\/\.\.}, '') + '/tmp/test/mercurial_repository'
	12
	13
	14	def test_version_template_0_9_5
	15	# 0.9.5
	16	test_version_template_for("0.9.5", [0,9,5], "0.9.5")
	17	end
	18
	19	def test_version_template_1_0
	20	# 1.0
	21	test_version_template_for("1.0", [1,0], "1.0")
	22	end
	23
	24	def test_version_template_1_0_win
	25	test_version_template_for("1e4ddc9ac9f7+20080325", "Unknown version", "1.0")
	26	end
	27
	28	def test_version_template_1_0_1_win
	29	test_version_template_for("1.0.1+20080525", [1,0,1], "1.0")
	30	end
	31
	32	def test_version_template_changeset_id
	33	test_version_template_for("1916e629a29d", "Unknown version", "1.0")
	34	end
	35
	36	private
	37
	38	def test_version_template_for(hgversion, version, templateversion)
	39	Redmine::Scm::Adapters::MercurialAdapter.any_instance.stubs(:hgversion_from_command_line).returns(hgversion)
	40	adapter = Redmine::Scm::Adapters::MercurialAdapter.new(REPOSITORY_PATH)
	41	assert_equal version, adapter.hgversion
	42	assert_equal "#{TEMPLATES_DIR}/#{TEMPLATE_NAME}-#{templateversion}.#{TEMPLATE_EXTENSION}", adapter.template_path
	43	assert File.exist?(adapter.template_path)
	44	end
	45	end
	46
	47	rescue LoadError
	48	def test_fake; assert(false, "Requires mocha to run those tests") end
	49	end

lib/redmine/scm/adapters/abstract_adapter.rb +6 -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 'cgi'
             module Redmine
               module Scm
                 module Adapters
                   class CommandFailed < StandardError #:nodoc:
                   end
                   class AbstractAdapter #:nodoc:
                     def initialize(url, root_url=nil, login=nil, password=nil)
                       @url = url
                       @login = login if login && !login.empty?
                       @password = (password || "") if @login
                       @root_url = root_url.blank? ? retrieve_root_url : root_url
                     end
                     def adapter_name
                       'Abstract'
                     end
                     def supports_cat?
                       true
                     end
                     def supports_annotate?
                       respond_to?('annotate')
                     end
                     def root_url
                       @root_url
                     end
                     def url
                       @url
                     end
                     # get info about the svn repository
                     def info
                       return nil
                     end
                     # Returns the entry identified by path and revision identifier
                     # or nil if entry doesn't exist in the repository
                     def entry(path=nil, identifier=nil)
                       parts = path.to_s.split(%r{[\/\\]}).select {|n| !n.blank?}
                       search_path = parts[0..-2].join('/')
                       search_name = parts[-1]
                       if search_path.blank? && search_name.blank?
                         # Root entry
                         Entry.new(:path => '', :kind => 'dir')
                       else
                         # Search for the entry in the parent directory
                         es = entries(search_path, identifier)
                         es ? es.detect {|e| e.name == search_name} : nil
                       end
                     end
                     # Returns an Entries collection
                     # or nil if the given path doesn't exist in the repository
                     def entries(path=nil, identifier=nil)
                       return nil
                     end
                     def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       return nil
                     end
                     def diff(path, identifier_from, identifier_to=nil, type="inline")
                       return nil
                     end
                     def cat(path, identifier=nil)
                       return nil
                     end
                     def with_leading_slash(path)
                       path ||= ''
                       (path[0,1]!="/") ? "/#{path}" : path
                     end
+                    def with_trailling_slash(path)
+                      path ||= ''
+                      (path[-1,1] == "/") ? path : "#{path}/"
+                    end
                     def shell_quote(str)
                       if RUBY_PLATFORM =~ /mswin/
                         '"' + str.gsub(/"/, '\\"') + '"'
                       else
                         "'" + str.gsub(/'/, "'\"'\"'") + "'"
                       end
                     end
                   private
                     def retrieve_root_url
                       info = self.info
                       info ? info.root_url : nil
                     end
                     def target(path)
                       path ||= ''
                       base = path.match(/^\//) ? root_url : url
                       shell_quote("#{base}/#{path}".gsub(/[?<>\*]/, ''))
                     end
                     def logger
                       RAILS_DEFAULT_LOGGER
                     end
                     def shellout(cmd, &block)
                       logger.debug "Shelling out: #{cmd}" if logger && logger.debug?
                       begin
                         IO.popen(cmd, "r+") do |io|
                           io.close_write
                           block.call(io) if block_given?
                         end
                       rescue Errno::ENOENT => e
                         msg = strip_credential(e.message)
                         # The command failed, log it and re-raise
                         logger.error("SCM command failed: #{strip_credential(cmd)}\n  with: #{msg}")
                         raise CommandFailed.new(msg)
                       end
                     end
                     # Hides username/password in a given command
                     def self.hide_credential(cmd)
                       q = (RUBY_PLATFORM =~ /mswin/ ? '"' : "'")
                       cmd.to_s.gsub(/(\-\-(password|username))\s+(#{q}[^#{q}]+#{q}|[^#{q}]\S+)/, '\\1 xxxx')
                     end
                     def strip_credential(cmd)
                       self.class.hide_credential(cmd)
                     end
                   end
                   class Entries < Array
                     def sort_by_name
                       sort {|x,y|
                         if x.kind == y.kind
                           x.name <=> y.name
                         else
                           x.kind <=> y.kind
                         end
                       }
                     end
                     def revisions
                       revisions ||= Revisions.new(collect{|entry| entry.lastrev}.compact)
                     end
                   end
                   class Info
                     attr_accessor :root_url, :lastrev
                     def initialize(attributes={})
                       self.root_url = attributes[:root_url] if attributes[:root_url]
                       self.lastrev = attributes[:lastrev]
                     end
                   end
                   class Entry
                     attr_accessor :name, :path, :kind, :size, :lastrev
                     def initialize(attributes={})
                       self.name = attributes[:name] if attributes[:name]
                       self.path = attributes[:path] if attributes[:path]
                       self.kind = attributes[:kind] if attributes[:kind]
                       self.size = attributes[:size].to_i if attributes[:size]
                       self.lastrev = attributes[:lastrev]
                     end
                     def is_file?
                       'file' == self.kind
                     end
                     def is_dir?
                       'dir' == self.kind
                     end
                     def is_text?
                       Redmine::MimeType.is_type?('text', name)
                     end
                   end
                   class Revisions < Array
                     def latest
                       sort {|x,y|
                         unless x.time.nil? or y.time.nil?
                           x.time <=> y.time
                         else
                         end
                       }.last
                     end
                   end
                   class Revision
                     attr_accessor :identifier, :scmid, :name, :author, :time, :message, :paths, :revision, :branch
                     def initialize(attributes={})
                       self.identifier = attributes[:identifier]
                       self.scmid = attributes[:scmid]
                       self.name = attributes[:name] || self.identifier
                       self.author = attributes[:author]
                       self.time = attributes[:time]
                       self.message = attributes[:message] || ""
                       self.paths = attributes[:paths]
                       self.revision = attributes[:revision]
                       self.branch = attributes[:branch]
                     end
                   end
                   # A line of Diff
                   class Diff
                     attr_accessor :nb_line_left
                     attr_accessor :line_left
                     attr_accessor :nb_line_right
                     attr_accessor :line_right
                     attr_accessor :type_diff_right
                     attr_accessor :type_diff_left
                     def initialize ()
                       self.nb_line_left = ''
                       self.nb_line_right = ''
                       self.line_left = ''
                       self.line_right = ''
                       self.type_diff_right = ''
                       self.type_diff_left = ''
                     end
                     def inspect
                       puts '### Start Line Diff ###'
                       puts self.nb_line_left
                       puts self.line_left
                       puts self.nb_line_right
                       puts self.line_right
                     end
                   end
                   class DiffTableList < Array
                     def initialize (diff, type="inline")
                         diff_table = DiffTable.new type
                         diff.each do |line|
                             if line =~ /^(---|\+\+\+) (.*)$/
                                 self << diff_table if diff_table.length > 1
                                 diff_table = DiffTable.new type
                             end
                             a = diff_table.add_line line
                         end
                         self << diff_table unless diff_table.empty?
                         self
                     end
                   end
                   # Class for create a Diff
                   class DiffTable < Hash
                     attr_reader :file_name, :line_num_l, :line_num_r
                     # Initialize with a Diff file and the type of Diff View
                     # The type view must be inline or sbs (side_by_side)
                     def initialize(type="inline")
                       @parsing = false
                       @nb_line = 1
                       @start = false
                       @before = 'same'
                       @second = true
                       @type = type
                     end
                     # Function for add a line of this Diff
                     def add_line(line)
                       unless @parsing
                         if line =~ /^(---|\+\+\+) (.*)$/
                           @file_name = $2
                           return false
                         elsif line =~ /^@@ (\+|\-)(\d+)(,\d+)? (\+|\-)(\d+)(,\d+)? @@/
                           @line_num_l = $5.to_i
                           @line_num_r = $2.to_i
                           @parsing = true
                         end
                       else
                         if line =~ /^[^\+\-\s@\\]/
                           @parsing = false
                           return false
                         elsif line =~ /^@@ (\+|\-)(\d+)(,\d+)? (\+|\-)(\d+)(,\d+)? @@/
                           @line_num_l = $5.to_i
                           @line_num_r = $2.to_i
                         else
                           @nb_line += 1 if parse_line(line, @type)
                         end
                       end
                       return true
                     end
                     def inspect
                       puts '### DIFF TABLE ###'
                       puts "file : #{file_name}"
                       self.each do |d|
                         d.inspect
                       end
                     end
                   private
                     # Test if is a Side By Side type
                     def sbs?(type, func)
                       if @start and type == "sbs"
                         if @before == func and @second
                           tmp_nb_line = @nb_line
                           self[tmp_nb_line] = Diff.new
                         else
                             @second = false
                             tmp_nb_line = @start
                             @start += 1
                             @nb_line -= 1
                         end
                       else
                         tmp_nb_line = @nb_line
                         @start = @nb_line
                         self[tmp_nb_line] = Diff.new
                         @second = true
                       end
                       unless self[tmp_nb_line]
                         @nb_line += 1
                         self[tmp_nb_line] = Diff.new
                       else
                         self[tmp_nb_line]
                       end
                     end
                     # Escape the HTML for the diff
                     def escapeHTML(line)
                         CGI.escapeHTML(line)
                     end
                     def parse_line(line, type="inline")
                       if line[0, 1] == "+"
                         diff = sbs? type, 'add'
                         @before = 'add'
                         diff.line_left = escapeHTML line[1..-1]
                         diff.nb_line_left = @line_num_l
                         diff.type_diff_left = 'diff_in'
                         @line_num_l += 1
                         true
                       elsif line[0, 1] == "-"
                         diff = sbs? type, 'remove'
                         @before = 'remove'
                         diff.line_right = escapeHTML line[1..-1]
                         diff.nb_line_right = @line_num_r
                         diff.type_diff_right = 'diff_out'
                         @line_num_r += 1
                         true
                       elsif line[0, 1] =~ /\s/
                         @before = 'same'
                         @start = false
                         diff = Diff.new
                         diff.line_right = escapeHTML line[1..-1]
                         diff.nb_line_right = @line_num_r
                         diff.line_left = escapeHTML line[1..-1]
                         diff.nb_line_left = @line_num_l
                         self[@nb_line] = diff
                         @line_num_l += 1
                         @line_num_r += 1
                         true
                       elsif line[0, 1] = "\\"
                         true
                       else
                         false
                       end
                     end
                   end
                   class Annotate
                     attr_reader :lines, :revisions
                     def initialize
                       @lines = []
                       @revisions = []
                     end
                     def add_line(line, revision)
                       @lines << line
                       @revisions << revision
                     end
                     def content
                       content = lines.join("\n")
                     end
                     def empty?
                       lines.empty?
                     end
                   end
                 end
               end
             end

lib/redmine/scm/adapters/mercurial_adapter.rb +81 -77

             # 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'
             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"
                     def info
                       cmd = "#{HG_BIN} -R #{target('')} root"
                       root_url = nil
                       shellout(cmd) do |io|
                         root_url = io.gets
                       end
                       return nil if $? && $?.exitstatus != 0
                       info = Info.new({:root_url => root_url.chomp,
-                                       :lastrev => revisions(nil,nil,nil,{:limit => 1}).last
+                                        :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(path)} locate"
+                      cmd = "#{HG_BIN} -R #{target('')} --cwd #{target('')} locate"
-                      cmd << " -r #{identifier.to_i}" if identifier
+                      cmd << " -r " + (identifier ? identifier.to_s : "tip")
-                      cmd << " " + shell_quote('glob:**')
+                      cmd << " " + shell_quote("path:#{path}") unless path.empty?
                       shellout(cmd) do |io|
                         io.each_line do |line|
-                          e = line.chomp.split(%r{[\/\\]})
+                          # HG uses antislashs as separator on Windows
-                          entries << Entry.new({:name => e.first,
+                          line = line.gsub(/\\/, "/")
-                                                :path => (path.empty? ? e.first : "#{path}/#{e.first}"),
+                          if path.empty? or e = line.gsub!(%r{^#{with_trailling_slash(path)}},'')
-                                                :kind => (e.size > 1 ? 'dir' : 'file'),
+                            e ||= line
-                                                :lastrev => Revision.new
+                            e = e.chomp.split(%r{[\/\\]})
-                                                }) unless entries.detect{|entry| entry.name == e.first}
+                            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 entries.detect{|entry| entry.name == e.first}
+                          end
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       entries.sort_by_name
                     end
-                    def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
+                    # 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} -v --encoding utf8 -R #{target('')} log"
+                      cmd = "#{HG_BIN} --debug --encoding utf8 -R #{target('')} log -C --style #{self.template_path}"
                       if identifier_from && identifier_to
                         cmd << " -r #{identifier_from.to_i}:#{identifier_to.to_i}"
                       elsif identifier_from
                         cmd << " -r #{identifier_from.to_i}:"
                       end
                       cmd << " --limit #{options[:limit].to_i}" if options[:limit]
+                      cmd << " #{path}" if path
                       shellout(cmd) do |io|
-                        changeset = {}
+                        begin
-                        parsing_descr = false
+                          # HG doesn't close the XML Document...
-                        line_feeds = 0
+                          doc = REXML::Document.new(io.read << "</log>")
+                          doc.elements.each("log/logentry") do |logentry|
-                        io.each_line do |line|
+                            paths = []
-                          if line =~ /^(\w+):\s*(.*)$/
+                            copies = logentry.get_elements('paths/path-copied')
-                            key = $1
+                            logentry.elements.each("paths/path") do |path|
-                            value = $2
+                              # Detect if the added file is a copy
-                            if parsing_descr && line_feeds > 1
+                              if path.attributes['action'] == 'A' and c = copies.find{ |e| e.text == path.text }
-                              parsing_descr = false
+                                from_path = c.attributes['copyfrom-path']
-                              revisions << build_revision_from_changeset(changeset)
+                                from_rev = logentry.attributes['revision']
-                              changeset = {}
-                            end
-                            if !parsing_descr
-                              changeset.store key.to_sym, value
-                              if $1 == "description"
-                                parsing_descr = true
-                                line_feeds = 0
-                                next
                               end
+                              paths << {:action => path.attributes['action'],
+                                :path => "/#{path.text}",
+                                :from_path => from_path ? "/#{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
-                          if parsing_descr
+                        rescue
-                            changeset[:description] << line
+                          logger.debug($!)
-                            line_feeds += 1 if line.chomp.empty?
-                          end
                         end
-                        # Add the last changeset if there is one left
-                        revisions << build_revision_from_changeset(changeset) if changeset[:date]
                       end
                       return nil if $? && $?.exitstatus != 0
                       revisions
                     end
                     def diff(path, identifier_from, identifier_to=nil, type="inline")
                       path ||= ''
                       if identifier_to
                         identifier_to = identifier_to.to_i
                       else
                         identifier_to = identifier_from.to_i - 1
                       end
                       cmd = "#{HG_BIN} -R #{target('')} diff -r #{identifier_to} -r #{identifier_from} --nodates"
                       cmd << " -I #{target(path)}" unless path.empty?
                       diff = []
                       shellout(cmd) do |io|
                         io.each_line do |line|
                           diff << line
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       DiffTableList.new diff, type
                     end
                     def cat(path, identifier=nil)
                       cmd = "#{HG_BIN} -R #{target('')} cat"
-                      cmd << " -r #{identifier.to_i}" if identifier
+                      cmd << " -r " + (identifier ? identifier.to_s : "tip")
                       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 -n -u"
+                      cmd << " -r " + (identifier ? identifier.to_s : "tip")
                       cmd << " -r #{identifier.to_i}" if identifier
                       cmd << " #{target(path)}"
                       blame = Annotate.new
                       shellout(cmd) do |io|
                         io.each_line do |line|
                           next unless line =~ %r{^([^:]+)\s(\d+):(.*)$}
                           blame.add_line($3.rstrip, Revision.new(:identifier => $2.to_i, :author => $1.strip))
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       blame
                     end
-                    private
+                    # The hg version 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.
+                    def hgversion
+                      theversion = hgversion_from_command_line
+                      if theversion.match(/^\d+(\.\d+)+/)
+                        theversion.split(".").collect(&:to_i)
+                        #            elsif match = theversion.match(/[[:xdigit:]]{12}/)
+                        #               match[0]
+                      else
+                        "Unknown version"
+                      end
+                    end
-                    # Builds a revision objet from the changeset returned by hg command
+                    def template_path
-                    def build_revision_from_changeset(changeset)
+                      @template ||= begin
-                      rev_id = changeset[:changeset].to_s.split(':').first.to_i
+                                      if hgversion.is_a?(String) or ((hgversion <=> [0,9,5]) > 0)
+                                        ver = "1.0"
-                      # Changes
+                                      else
-                      paths = (rev_id == 0) ?
+                                        ver = "0.9.5"
-                        # Can't get changes for revision 0 with hg status
+                                      end
-                        changeset[:files].to_s.split.collect{|path| {:action => 'A', :path => "/#{path}"}} :
+                                      "#{TEMPLATES_DIR}/#{TEMPLATE_NAME}-#{ver}.#{TEMPLATE_EXTENSION}"
-                        status(rev_id)
+                                    end
-                      Revision.new({:identifier => rev_id,
-                                    :scmid => changeset[:changeset].to_s.split(':').last,
-                                    :author => changeset[:user],
-                                    :time => Time.parse(changeset[:date]),
-                                    :message => changeset[:description],
-                                    :paths => paths
-                                   })
                     end
-                    # Returns the file changes for a given revision
+                    private
-                    def status(rev_id)
-                      cmd = "#{HG_BIN} -R #{target('')} status --rev #{rev_id.to_i - 1}:#{rev_id.to_i}"
+                    def hgversion_from_command_line
-                      result = []
+                      @hgversion ||= %x{#{HG_BIN} --version}.match(/\(version (.*)\)/)[1]
-                      shellout(cmd) do |io|
-                        io.each_line do |line|
-                          action, file = line.chomp.split
-                          next unless action && file
-                          file.gsub!("\\", "/")
-                          case action
-                          when 'R'
-                            result << { :action => 'D' , :path => "/#{file}" }
-                          else
-                            result << { :action => action, :path => "/#{file}" }
-                          end
-                        end
-                      end
-                      result
                     end
                   end
                 end
               end
             end

test/unit/repository_mercurial_test.rb +20 0

             # 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 File.dirname(__FILE__) + '/../test_helper'
             class RepositoryMercurialTest < Test::Unit::TestCase
               fixtures :projects
               # No '..' in the repository path
               REPOSITORY_PATH = RAILS_ROOT.gsub(%r{config\/\.\.}, '') + '/tmp/test/mercurial_repository'
               def setup
                 @project = Project.find(1)
                 assert @repository = Repository::Mercurial.create(:project => @project, :url => REPOSITORY_PATH)
               end
               if File.directory?(REPOSITORY_PATH)
                 def test_fetch_changesets_from_scratch
                   @repository.fetch_changesets
                   @repository.reload
                   assert_equal 6, @repository.changesets.count
                   assert_equal 11, @repository.changes.count
                   assert_equal "Initial import.\nThe repository contains 3 files.", @repository.changesets.find_by_revision('0').comments
                 end
                 def test_fetch_changesets_incremental
                   @repository.fetch_changesets
                   # Remove changesets with revision > 2
                   @repository.changesets.find(:all).each {|c| c.destroy if c.revision.to_i > 2}
                   @repository.reload
                   assert_equal 3, @repository.changesets.count
                   @repository.fetch_changesets
                   assert_equal 6, @repository.changesets.count
                 end
+                def test_entries
+                  assert_equal 2, @repository.entries("sources", 2).size
+                  assert_equal 1, @repository.entries("sources", 3).size
+                end
+                def test_locate_on_outdated_repository
+                  # Change the working dir state
+                  %x{hg -R #{REPOSITORY_PATH} up -r 0}
+                  assert_equal 1, @repository.entries("images", 0).size
+                  assert_equal 2, @repository.entries("images").size
+                  assert_equal 2, @repository.entries("images", 2).size
+                end
+                def test_cat
+                  assert @repository.scm.cat("sources/welcome_controller.rb", 2)
+                  assert_nil @repository.scm.cat("sources/welcome_controller.rb")
+                end
               else
                 puts "Mercurial test repository NOT FOUND. Skipping unit tests !!!"
                 def test_fake; assert true 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