jro_apps/redmine Commit - r12478:f2ec6f8d77ec

back out r12752 (#14361)...

Toshi MARUYAMA -

r12478:f2ec6f8d77ec

parent child

Context file:

r12478:f2ec6f8d77ec

Collapse all files

app/models/repository/mercurial.rb +3 -11

             # Redmine - project management software
             # Copyright (C) 2006-2014  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/mercurial_adapter'
             class Repository::Mercurial < Repository
               # sort changesets by revision number
               has_many :changesets,
                        :order       => "#{Changeset.table_name}.id DESC",
                        :foreign_key => 'repository_id'
               attr_protected        :root_url
               validates_presence_of :url
               # number of changesets to fetch at once
               FETCH_AT_ONCE = 100
               def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name.to_s
                 if attr_name == "url"
                   attr_name = "path_to_repository"
                 end
                 super(attr_name, *args)
               end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::MercurialAdapter
               end
               def self.scm_name
                 'Mercurial'
               end
               def supports_directory_revisions?
                 true
               end
               def supports_revision_graph?
                 true
               end
               def repo_log_encoding
                 'UTF-8'
               end
               # Returns the readable identifier for the given mercurial changeset
               def self.format_changeset_identifier(changeset)
                 "#{changeset.revision}:#{changeset.scmid[0, 12]}"
               end
               # Returns the identifier for the given Mercurial changeset
               def self.changeset_identifier(changeset)
                 changeset.scmid
               end
               def diff_format_revisions(cs, cs_to, sep=':')
                 super(cs, cs_to, ' ')
               end
               # Finds and returns a revision with a number or the beginning of a hash
               def find_changeset_by_name(name)
                 return nil if name.blank?
                 s = name.to_s
                 if /[^\d]/ =~ s or s.size > 8
                   cs = changesets.where(:scmid => s).first
                 else
                   cs = changesets.where(:revision => s).first
                 end
                 return cs if cs
                 changesets.where('scmid LIKE ?', "#{s}%").first
               end
               # Returns the latest changesets for +path+; sorted by revision number
               #
               # Because :order => 'id DESC' is defined at 'has_many',
               # there is no need to set 'order'.
               # But, MySQL test fails.
               # Sqlite3 and PostgreSQL pass.
               # Is this MySQL bug?
               def latest_changesets(path, rev, limit=10)
                 changesets.
                   includes(:user).
                   where(latest_changesets_cond(path, rev, limit)).
                   limit(limit).
                   order("#{Changeset.table_name}.id DESC").
                   all
               end
               def nodes_in_branch(rev, branch_limit)
                 scm.nodes_in_branch(rev, :limit => branch_limit).collect do |b|
                   b[0, 12]
                 end
               end
               def tag_scmid(rev)
                 scmid = scm.tagmap[rev]
                 scmid.nil? ? nil : scmid[0, 12]
               end
               def latest_changesets_cond(path, rev, limit)
                 cond, args = [], []
                 if scm.branchmap.member? rev
                   # Mercurial named branch is *stable* in each revision.
                   # So, named branch can be stored in database.
                   # Mercurial provides *bookmark* which is equivalent with git branch.
                   # But, bookmark is not implemented.
                   cond << "#{Changeset.table_name}.scmid IN (?)"
                   # Revisions in root directory and sub directory are not equal.
                   # So, in order to get correct limit, we need to get all revisions.
                   # But, it is very heavy.
                   # Mercurial does not treat direcotry.
                   # So, "hg log DIR" is very heavy.
                   branch_limit = path.blank? ? limit : ( limit * 5 )
                   args << nodes_in_branch(rev, branch_limit)
                 elsif last = rev ? find_changeset_by_name(tag_scmid(rev) || rev) : nil
                   cond << "#{Changeset.table_name}.id <= ?"
                   args << last.id
                 end
                 unless path.blank?
                   cond << "EXISTS (SELECT * FROM #{Change.table_name}
                              WHERE #{Change.table_name}.changeset_id = #{Changeset.table_name}.id
                              AND (#{Change.table_name}.path = ?
                                    OR #{Change.table_name}.path LIKE ? ESCAPE ?))"
                   args << path.with_leading_slash
                   args << "#{path.with_leading_slash.gsub(%r{[%_\\]}) { |s| "\\#{s}" }}/%" << '\\'
                 end
                 [cond.join(' AND '), *args] unless cond.empty?
               end
               private :latest_changesets_cond
               def fetch_changesets
                 return if scm.info.nil?
                 scm_rev = scm.info.lastrev.revision.to_i
                 db_rev  = latest_changeset ? latest_changeset.revision.to_i : -1
                 return unless db_rev < scm_rev  # already up-to-date
                 logger.debug "Fetching changesets for repository #{url}" if logger
                 (db_rev + 1).step(scm_rev, FETCH_AT_ONCE) do |i|
                   scm.each_revision('', i, [i + FETCH_AT_ONCE - 1, scm_rev].min) do |re|
                     transaction do
-                      scmid = re.scmid[0, 12]
+                      parents = (re.parents || []).collect{|rp| find_changeset_by_name(rp)}.compact
-                      parents = (re.parents || []).collect do |rp|
-                        find_changeset_by_name(rp[0, 12])
-                      end.compact
                       cs = Changeset.create(:repository   => self,
                                             :revision     => re.revision,
-                                            :scmid        => scmid,
+                                            :scmid        => re.scmid,
                                             :committer    => re.author,
                                             :committed_on => re.time,
                                             :comments     => re.message,
                                             :parents      => parents)
                       unless cs.new_record?
-                        re.paths.each do |e|
+                        re.paths.each { |e| cs.create_change(e) }
-                          if from_revision = e[:from_revision]
-                            e[:from_revision] = from_revision[0, 12]
-                          end
-                          cs.create_change(e)
-                        end
                       end
                     end
                   end
                 end
               end
             end

lib/redmine/scm/adapters/mercurial/hg-template-1.0.tmpl +2 -2

             changeset = 'This template must be used with --debug option\n'
             changeset_quiet =  'This template must be used with --debug option\n'
             changeset_verbose = 'This template must be used with --debug option\n'
-            changeset_debug = '<logentry revision="{rev}" node="{node}">\n<author>{author|escape}</author>\n<date>{date|isodatesec}</date>\n<paths>\n{file_mods}{file_adds}{file_dels}{file_copies}</paths>\n<msg>{desc|escape}</msg>\n<parents>\n{parents}</parents>\n</logentry>\n\n'
+            changeset_debug = '<logentry revision="{rev}" node="{node|short}">\n<author>{author|escape}</author>\n<date>{date|isodatesec}</date>\n<paths>\n{file_mods}{file_adds}{file_dels}{file_copies}</paths>\n<msg>{desc|escape}</msg>\n<parents>\n{parents}</parents>\n</logentry>\n\n'
             file_mod = '<path action="M">{file_mod|urlescape}</path>\n'
             file_add = '<path action="A">{file_add|urlescape}</path>\n'
             file_del = '<path action="D">{file_del|urlescape}</path>\n'
             file_copy = '<path-copied copyfrom-path="{source|urlescape}">{name|urlescape}</path-copied>\n'
-            parent = '<parent>{node}</parent>\n'
+            parent = '<parent>{node|short}</parent>\n'
             header='<?xml version="1.0" encoding="UTF-8" ?>\n<log>\n\n'
             # footer="</log>"

lib/redmine/scm/adapters/mercurial/redminehelper.py +5 -5

             # redminehelper: Redmine helper extension for Mercurial
             #
             # Copyright 2010 Alessio Franceschelli (alefranz.net)
             # Copyright 2010-2011 Yuya Nishihara <yuya@tcha.org>
             #
             # This software may be used and distributed according to the terms of the
             # GNU General Public License version 2 or any later version.
             """helper commands for Redmine to reduce the number of hg calls
             To test this extension, please try::
                 $ hg --config extensions.redminehelper=redminehelper.py rhsummary
             I/O encoding:
             :file path: urlencoded, raw string
             :tag name: utf-8
             :branch name: utf-8
-            :node: hex string
+            :node: 12-digits (short) hex string
             Output example of rhsummary::
                 <?xml version="1.0"?>
                 <rhsummary>
                   <repository root="/foo/bar">
                     <tip revision="1234" node="abcdef0123..."/>
                     <tag revision="123" node="34567abc..." name="1.1.1"/>
                     <branch .../>
                     ...
                   </repository>
                 </rhsummary>
             Output example of rhmanifest::
                 <?xml version="1.0"?>
                 <rhmanifest>
                   <repository root="/foo/bar">
                     <manifest revision="1234" path="lib">
                       <file name="diff.rb" revision="123" node="34567abc..." time="12345"
                              size="100"/>
                       ...
                       <dir name="redmine"/>
                       ...
                     </manifest>
                   </repository>
                 </rhmanifest>
             """
             import re, time, cgi, urllib
             from mercurial import cmdutil, commands, node, error, hg
             _x = cgi.escape
             _u = lambda s: cgi.escape(urllib.quote(s))
             def _tip(ui, repo):
                 # see mercurial/commands.py:tip
                 def tiprev():
                     try:
                         return len(repo) - 1
                     except TypeError:  # Mercurial < 1.1
                         return repo.changelog.count() - 1
                 tipctx = repo.changectx(tiprev())
                 ui.write('<tip revision="%d" node="%s"/>\n'
-                         % (tipctx.rev(), _x(node.hex(tipctx.node()))))
+                         % (tipctx.rev(), _x(node.short(tipctx.node()))))
             _SPECIAL_TAGS = ('tip',)
             def _tags(ui, repo):
                 # see mercurial/commands.py:tags
                 for t, n in reversed(repo.tagslist()):
                     if t in _SPECIAL_TAGS:
                         continue
                     try:
                         r = repo.changelog.rev(n)
                     except error.LookupError:
                         continue
                     ui.write('<tag revision="%d" node="%s" name="%s"/>\n'
-                             % (r, _x(node.hex(n)), _x(t)))
+                             % (r, _x(node.short(n)), _x(t)))
             def _branches(ui, repo):
                 # see mercurial/commands.py:branches
                 def iterbranches():
                     for t, n in repo.branchtags().iteritems():
                         yield t, n, repo.changelog.rev(n)
                 def branchheads(branch):
                     try:
                         return repo.branchheads(branch, closed=False)
                     except TypeError:  # Mercurial < 1.2
                         return repo.branchheads(branch)
                 for t, n, r in sorted(iterbranches(), key=lambda e: e[2], reverse=True):
                     if repo.lookup(r) in branchheads(t):
                         ui.write('<branch revision="%d" node="%s" name="%s"/>\n'
-                                 % (r, _x(node.hex(n)), _x(t)))
+                                 % (r, _x(node.short(n)), _x(t)))
             def _manifest(ui, repo, path, rev):
                 ctx = repo.changectx(rev)
                 ui.write('<manifest revision="%d" path="%s">\n'
                          % (ctx.rev(), _u(path)))
                 known = set()
                 pathprefix = (path.rstrip('/') + '/').lstrip('/')
                 for f, n in sorted(ctx.manifest().iteritems(), key=lambda e: e[0]):
                     if not f.startswith(pathprefix):
                         continue
                     name = re.sub(r'/.*', '/', f[len(pathprefix):])
                     if name in known:
                         continue
                     known.add(name)
                     if name.endswith('/'):
                         ui.write('<dir name="%s"/>\n'
                                  % _x(urllib.quote(name[:-1])))
                     else:
                         fctx = repo.filectx(f, fileid=n)
                         tm, tzoffset = fctx.date()
                         ui.write('<file name="%s" revision="%d" node="%s" '
                                  'time="%d" size="%d"/>\n'
-                                 % (_u(name), fctx.rev(), _x(node.hex(fctx.node())),
+                                 % (_u(name), fctx.rev(), _x(node.short(fctx.node())),
                                     tm, fctx.size(), ))
                 ui.write('</manifest>\n')
             def rhannotate(ui, repo, *pats, **opts):
                 rev = urllib.unquote_plus(opts.pop('rev', None))
                 opts['rev'] = rev
                 return commands.annotate(ui, repo, *map(urllib.unquote_plus, pats), **opts)
             def rhcat(ui, repo, file1, *pats, **opts):
                 rev = urllib.unquote_plus(opts.pop('rev', None))
                 opts['rev'] = rev
                 return commands.cat(ui, repo, urllib.unquote_plus(file1), *map(urllib.unquote_plus, pats), **opts)
             def rhdiff(ui, repo, *pats, **opts):
                 """diff repository (or selected files)"""
                 change = opts.pop('change', None)
                 if change:  # add -c option for Mercurial<1.1
                     base = repo.changectx(change).parents()[0].rev()
                     opts['rev'] = [str(base), change]
                 opts['nodates'] = True
                 return commands.diff(ui, repo, *map(urllib.unquote_plus, pats), **opts)
             def rhlog(ui, repo, *pats, **opts):
                 rev      = opts.pop('rev')
                 bra0     = opts.pop('branch')
                 from_rev = urllib.unquote_plus(opts.pop('from', None))
                 to_rev   = urllib.unquote_plus(opts.pop('to'  , None))
                 bra      = urllib.unquote_plus(opts.pop('rhbranch', None))
                 from_rev = from_rev.replace('"', '\\"')
                 to_rev   = to_rev.replace('"', '\\"')
                 if hg.util.version() >= '1.6':
                   opts['rev'] = ['"%s":"%s"' % (from_rev, to_rev)]
                 else:
                   opts['rev'] = ['%s:%s' % (from_rev, to_rev)]
                 opts['branch'] = [bra]
                 return commands.log(ui, repo, *map(urllib.unquote_plus, pats), **opts)
             def rhmanifest(ui, repo, path='', **opts):
                 """output the sub-manifest of the specified directory"""
                 ui.write('<?xml version="1.0"?>\n')
                 ui.write('<rhmanifest>\n')
                 ui.write('<repository root="%s">\n' % _u(repo.root))
                 try:
                     _manifest(ui, repo, urllib.unquote_plus(path), urllib.unquote_plus(opts.get('rev')))
                 finally:
                     ui.write('</repository>\n')
                     ui.write('</rhmanifest>\n')
             def rhsummary(ui, repo, **opts):
                 """output the summary of the repository"""
                 ui.write('<?xml version="1.0"?>\n')
                 ui.write('<rhsummary>\n')
                 ui.write('<repository root="%s">\n' % _u(repo.root))
                 try:
                     _tip(ui, repo)
                     _tags(ui, repo)
                     _branches(ui, repo)
                     # TODO: bookmarks in core (Mercurial>=1.8)
                 finally:
                     ui.write('</repository>\n')
                     ui.write('</rhsummary>\n')
             cmdtable = {
                 'rhannotate': (rhannotate,
                      [('r', 'rev', '', 'revision'),
                       ('u', 'user', None, 'list the author (long with -v)'),
                       ('n', 'number', None, 'list the revision number (default)'),
                       ('c', 'changeset', None, 'list the changeset'),
                      ],
                      'hg rhannotate [-r REV] [-u] [-n] [-c] FILE...'),
                 'rhcat': (rhcat,
                            [('r', 'rev', '', 'revision')],
                            'hg rhcat ([-r REV] ...) FILE...'),
                 'rhdiff': (rhdiff,
                            [('r', 'rev', [], 'revision'),
                             ('c', 'change', '', 'change made by revision')],
                            'hg rhdiff ([-c REV] | [-r REV] ...) [FILE]...'),
                 'rhlog': (rhlog,
                                [
                                 ('r', 'rev', [], 'show the specified revision'),
                                 ('b', 'branch', [],
                                    'show changesets within the given named branch'),
                                 ('l', 'limit', '',
                                      'limit number of changes displayed'),
                                 ('d', 'date', '',
                                      'show revisions matching date spec'),
                                 ('u', 'user', [],
                                   'revisions committed by user'),
                                 ('', 'from', '',
                                   ''),
                                 ('', 'to', '',
                                   ''),
                                 ('', 'rhbranch', '',
                                   ''),
                                 ('', 'template', '',
                                    'display with template')],
                                'hg rhlog [OPTION]... [FILE]'),
                 'rhmanifest': (rhmanifest,
                                [('r', 'rev', '', 'show the specified revision')],
                                'hg rhmanifest [-r REV] [PATH]'),
                 'rhsummary': (rhsummary, [], 'hg rhsummary'),
             }

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

             # Redmine - project management software
             # Copyright (C) 2006-2014  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 = Redmine::Configuration['scm_mercurial_command'] || "hg"
                     HELPERS_DIR = File.dirname(__FILE__) + "/mercurial"
                     HG_HELPER_EXT = "#{HELPERS_DIR}/redminehelper.py"
                     TEMPLATE_NAME = "hg-template"
                     TEMPLATE_EXTENSION = "tmpl"
                     # raised if hg command exited with error, e.g. unknown revision.
                     class HgCommandAborted < CommandFailed; end
                     class << self
                       def client_command
                         @@bin    ||= HG_BIN
                       end
                       def sq_bin
                         @@sq_bin ||= shell_quote_command
                       end
                       def client_version
                         @@client_version ||= (hgversion || [])
                       end
                       def client_available
                         client_version_above?([1, 2])
                       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.dup
                         if theversion.respond_to?(:force_encoding)
                           theversion.force_encoding('ASCII-8BIT')
                         end
                         if m = theversion.match(%r{\A(.*?)((\d+\.)+\d+)})
                           m[2].scan(%r{\d+}).collect(&:to_i)
                         end
                       end
                       def hgversion_from_command_line
                         shellout("#{sq_bin} --version") { |io| io.read }.to_s
                       end
                       def template_path
                         @@template_path ||= template_path_for(client_version)
                       end
                       def template_path_for(version)
                         "#{HELPERS_DIR}/#{TEMPLATE_NAME}-1.0.#{TEMPLATE_EXTENSION}"
                       end
                     end
                     def initialize(url, root_url=nil, login=nil, password=nil, path_encoding=nil)
                       super
                       @path_encoding = path_encoding.blank? ? 'UTF-8' : path_encoding
                     end
                     def path_encoding
                       @path_encoding
                     end
                     def info
                       tip = summary['repository']['tip']
                       Info.new(:root_url => CGI.unescape(summary['repository']['root']),
                                :lastrev => Revision.new(:revision => tip['revision'],
                                                         :scmid => tip['node']))
                     # rescue HgCommandAborted
                     rescue Exception => e
                       logger.error "hg: error during getting info: #{e.message}"
                       nil
                     end
                     def tags
                       as_ary(summary['repository']['tag']).map { |e| e['name'] }
                     end
                     # Returns map of {'tag' => 'nodeid', ...}
                     def tagmap
                       alist = as_ary(summary['repository']['tag']).map do |e|
                         e.values_at('name', 'node')
                       end
                       Hash[*alist.flatten]
                     end
                     def branches
                       brs = []
                       as_ary(summary['repository']['branch']).each do |e|
                         br = Branch.new(e['name'])
                         br.revision =  e['revision']
                         br.scmid    =  e['node']
                         brs << br
                       end
                       brs
                     end
                     # Returns map of {'branch' => 'nodeid', ...}
                     def branchmap
                       alist = as_ary(summary['repository']['branch']).map do |e|
                         e.values_at('name', 'node')
                       end
                       Hash[*alist.flatten]
                     end
                     def summary
                       return @summary if @summary
                       hg 'rhsummary' do |io|
                         output = io.read
                         if output.respond_to?(:force_encoding)
                           output.force_encoding('UTF-8')
                         end
                         begin
                           @summary = parse_xml(output)['rhsummary']
                         rescue
                         end
                       end
                     end
                     private :summary
                     def entries(path=nil, identifier=nil, options={})
                       p1 = scm_iconv(@path_encoding, 'UTF-8', path)
                       manifest = hg('rhmanifest', '-r', CGI.escape(hgrev(identifier)),
                                     CGI.escape(without_leading_slash(p1.to_s))) do |io|
                         output = io.read
                         if output.respond_to?(:force_encoding)
                           output.force_encoding('UTF-8')
                         end
                         begin
                           parse_xml(output)['rhmanifest']['repository']['manifest']
                         rescue
                         end
                       end
                       path_prefix = path.blank? ? '' : with_trailling_slash(path)
                       entries = Entries.new
                       as_ary(manifest['dir']).each do |e|
                         n = scm_iconv('UTF-8', @path_encoding, CGI.unescape(e['name']))
                         p = "#{path_prefix}#{n}"
                         entries << Entry.new(:name => n, :path => p, :kind => 'dir')
                       end
                       as_ary(manifest['file']).each do |e|
                         n = scm_iconv('UTF-8', @path_encoding, CGI.unescape(e['name']))
                         p = "#{path_prefix}#{n}"
                         lr = Revision.new(:revision => e['revision'], :scmid => e['node'],
                                           :identifier => e['node'],
                                           :time => Time.at(e['time'].to_i))
                         entries << Entry.new(:name => n, :path => p, :kind => 'file',
                                              :size => e['size'].to_i, :lastrev => lr)
                       end
                       entries
                     rescue HgCommandAborted
                       nil  # means not found
                     end
                     def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       revs = Revisions.new
                       each_revision(path, identifier_from, identifier_to, options) { |e| revs << e }
                       revs
                     end
                     # Iterates the revisions by using a template file that
                     # makes Mercurial produce a xml output.
                     def each_revision(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       hg_args = ['log', '--debug', '-C', '--style', self.class.template_path]
                       hg_args << '-r' << "#{hgrev(identifier_from)}:#{hgrev(identifier_to)}"
                       hg_args << '--limit' << options[:limit] if options[:limit]
                       hg_args << hgtarget(path) unless path.blank?
                       log = hg(*hg_args) do |io|
                         output = io.read
                         if output.respond_to?(:force_encoding)
                           output.force_encoding('UTF-8')
                         end
                         begin
                           # Mercurial < 1.5 does not support footer template for '</log>'
                           parse_xml("#{output}</log>")['log']
                         rescue
                         end
                       end
                       as_ary(log['logentry']).each do |le|
                         cpalist = as_ary(le['paths']['path-copied']).map do |e|
                           [e['__content__'], e['copyfrom-path']].map do |s|
                             scm_iconv('UTF-8', @path_encoding, CGI.unescape(s))
                           end
                         end
                         cpmap = Hash[*cpalist.flatten]
                         paths = as_ary(le['paths']['path']).map do |e|
                           p = scm_iconv('UTF-8', @path_encoding, CGI.unescape(e['__content__']) )
                           {:action        => e['action'],
                            :path          => with_leading_slash(p),
                            :from_path     => (cpmap.member?(p) ? with_leading_slash(cpmap[p]) : nil),
                            :from_revision => (cpmap.member?(p) ? le['node'] : nil)}
                         end.sort { |a, b| a[:path] <=> b[:path] }
                         parents_ary = []
                         as_ary(le['parents']['parent']).map do |par|
-                          parents_ary << par['__content__'] if par['__content__'] != "0000000000000000000000000000000000000000"
+                          parents_ary << par['__content__'] if par['__content__'] != "000000000000"
                         end
                         yield Revision.new(:revision => le['revision'],
                                            :scmid    => le['node'],
                                            :author   => (le['author']['__content__'] rescue ''),
                                            :time     => Time.parse(le['date']['__content__']),
                                            :message  => le['msg']['__content__'],
                                            :paths    => paths,
                                            :parents  => parents_ary)
                       end
                       self
                     end
                     # Returns list of nodes in the specified branch
                     def nodes_in_branch(branch, options={})
-                      hg_args = ['rhlog', '--template', '{node}\n', '--rhbranch', CGI.escape(branch)]
+                      hg_args = ['rhlog', '--template', '{node|short}\n', '--rhbranch', CGI.escape(branch)]
                       hg_args << '--from' << CGI.escape(branch)
                       hg_args << '--to'   << '0'
                       hg_args << '--limit' << options[:limit] if options[:limit]
                       hg(*hg_args) { |io| io.readlines.map { |e| e.chomp } }
                     end
                     def diff(path, identifier_from, identifier_to=nil)
                       hg_args = %w|rhdiff|
                       if identifier_to
                         hg_args << '-r' << hgrev(identifier_to) << '-r' << hgrev(identifier_from)
                       else
                         hg_args << '-c' << hgrev(identifier_from)
                       end
                       unless path.blank?
                         p = scm_iconv(@path_encoding, 'UTF-8', path)
                         hg_args << CGI.escape(hgtarget(p))
                       end
                       diff = []
                       hg *hg_args do |io|
                         io.each_line do |line|
                           diff << line
                         end
                       end
                       diff
                     rescue HgCommandAborted
                       nil  # means not found
                     end
                     def cat(path, identifier=nil)
                       p = CGI.escape(scm_iconv(@path_encoding, 'UTF-8', path))
                       hg 'rhcat', '-r', CGI.escape(hgrev(identifier)), hgtarget(p) do |io|
                         io.binmode
                         io.read
                       end
                     rescue HgCommandAborted
                       nil  # means not found
                     end
                     def annotate(path, identifier=nil)
                       p = CGI.escape(scm_iconv(@path_encoding, 'UTF-8', path))
                       blame = Annotate.new
                       hg 'rhannotate', '-ncu', '-r', CGI.escape(hgrev(identifier)), hgtarget(p) do |io|
                         io.each_line do |line|
                           line.force_encoding('ASCII-8BIT') if line.respond_to?(:force_encoding)
                           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
                       blame
                     rescue HgCommandAborted
                       # means not found or cannot be annotated
                       Annotate.new
                     end
                     class Revision < Redmine::Scm::Adapters::Revision
                       # Returns the readable identifier
                       def format_identifier
                         "#{revision}:#{scmid}"
                       end
                     end
                     # Runs 'hg' command with the given args
                     def hg(*args, &block)
                       repo_path = root_url || url
                       full_args = ['-R', repo_path, '--encoding', 'utf-8']
                       full_args << '--config' << "extensions.redminehelper=#{HG_HELPER_EXT}"
                       full_args << '--config' << 'diff.git=false'
                       full_args += args
                       ret = shellout(
                                self.class.sq_bin + ' ' + full_args.map { |e| shell_quote e.to_s }.join(' '),
                                &block
                                )
                       if $? && $?.exitstatus != 0
                         raise HgCommandAborted, "hg exited with non-zero status: #{$?.exitstatus}"
                       end
                       ret
                     end
                     private :hg
                     # Returns correct revision identifier
                     def hgrev(identifier, sq=false)
                       rev = identifier.blank? ? 'tip' : identifier.to_s
                       rev = shell_quote(rev) if sq
                       rev
                     end
                     private :hgrev
                     def hgtarget(path)
                       path ||= ''
                       root_url + '/' + without_leading_slash(path)
                     end
                     private :hgtarget
                     def as_ary(o)
                       return [] unless o
                       o.is_a?(Array) ? o : Array[o]
                     end
                     private :as_ary
                   end
                 end
               end
             end

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

             # Redmine - project management software
             # Copyright (C) 2006-2014  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.expand_path('../../../../../../test_helper', __FILE__)
             begin
               require 'mocha/setup'
               class MercurialAdapterTest < ActiveSupport::TestCase
                 HELPERS_DIR        = Redmine::Scm::Adapters::MercurialAdapter::HELPERS_DIR
                 TEMPLATE_NAME      = Redmine::Scm::Adapters::MercurialAdapter::TEMPLATE_NAME
                 TEMPLATE_EXTENSION = Redmine::Scm::Adapters::MercurialAdapter::TEMPLATE_EXTENSION
                 REPOSITORY_PATH = Rails.root.join('tmp/test/mercurial_repository').to_s
                 CHAR_1_HEX = "\xc3\x9c"
                 if File.directory?(REPOSITORY_PATH)
                   def setup
                     adapter_class = Redmine::Scm::Adapters::MercurialAdapter
                     assert adapter_class
                     assert adapter_class.client_command
                     assert_equal true, adapter_class.client_available
                     assert_equal true, adapter_class.client_version_above?([0, 9, 5])
                     @adapter = Redmine::Scm::Adapters::MercurialAdapter.new(
                                           REPOSITORY_PATH,
                                           nil,
                                           nil,
                                           nil,
                                          'ISO-8859-1')
                     @diff_c_support = true
                     @char_1        = CHAR_1_HEX.dup
                     @tag_char_1    = "tag-#{CHAR_1_HEX}-00"
                     @branch_char_0 = "branch-#{CHAR_1_HEX}-00"
                     @branch_char_1 = "branch-#{CHAR_1_HEX}-01"
                     if @tag_char_1.respond_to?(:force_encoding)
                       @char_1.force_encoding('UTF-8')
                       @tag_char_1.force_encoding('UTF-8')
                       @branch_char_0.force_encoding('UTF-8')
                       @branch_char_1.force_encoding('UTF-8')
                     end
                   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 = {
                                 [1,2]    => "1.0",
                                 []       => "1.0",
                                 [1,2,1]  => "1.0",
                                 [1,7]    => "1.0",
                                 [1,7,1]  => "1.0",
                                 [2,0]    => "1.0",
                                }
                     to_test.each do |v, template|
                       test_template_path_for(v, template)
                     end
                   end
                   def test_info
                     [REPOSITORY_PATH, REPOSITORY_PATH + "/",
                          REPOSITORY_PATH + "//"].each do |repo|
                       adp = Redmine::Scm::Adapters::MercurialAdapter.new(repo)
                       repo_path =  adp.info.root_url.gsub(/\\/, "/")
                       assert_equal REPOSITORY_PATH, repo_path
                       assert_equal '31', adp.info.lastrev.revision
-                      assert_equal '31eeee7395c8c78e66dd54c50addd078d10b2355',adp.info.lastrev.scmid
+                      assert_equal '31eeee7395c8',adp.info.lastrev.scmid
                     end
                   end
                   def test_revisions
                     revisions = @adapter.revisions(nil, 2, 4)
                     assert_equal 3, revisions.size
                     assert_equal '2', revisions[0].revision
-                    assert_equal '400bb86721098697c7d17b3724c794c57636de70', revisions[0].scmid
+                    assert_equal '400bb8672109', revisions[0].scmid
                     assert_equal '4', revisions[2].revision
-                    assert_equal 'def6d2f1254a56fb8fbe9ec3b5c0451674dbd8b8', revisions[2].scmid
+                    assert_equal 'def6d2f1254a', revisions[2].scmid
                     revisions = @adapter.revisions(nil, 2, 4, {:limit => 2})
                     assert_equal 2, revisions.size
                     assert_equal '2', revisions[0].revision
-                    assert_equal '400bb86721098697c7d17b3724c794c57636de70', revisions[0].scmid
+                    assert_equal '400bb8672109', revisions[0].scmid
                   end
                   def test_parents
                     revs1 = @adapter.revisions(nil, 0, 0)
                     assert_equal 1, revs1.size
                     assert_equal [], revs1[0].parents
                     revs2 = @adapter.revisions(nil, 1, 1)
                     assert_equal 1, revs2.size
                     assert_equal 1, revs2[0].parents.size
-                    assert_equal "0885933ad4f68d77c2649cd11f8311276e7ef7ce", revs2[0].parents[0]
+                    assert_equal "0885933ad4f6", revs2[0].parents[0]
                     revs3 = @adapter.revisions(nil, 30, 30)
                     assert_equal 1, revs3.size
                     assert_equal 2, revs3[0].parents.size
-                    assert_equal "a94b0528f24fe05ebaef496ae0500bb050772e36", revs3[0].parents[0]
+                    assert_equal "a94b0528f24f", revs3[0].parents[0]
-                    assert_equal "3a330eb329586ea2adb3f83237c23310e744ebe9", revs3[0].parents[1]
+                    assert_equal "3a330eb32958", revs3[0].parents[1]
                   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 @diff_c_support
                         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 49, diff2.size
                         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
                         diff4 = @adapter.diff(nil, r2, r1)
                         assert_equal 49, diff4.size
                         buf =  diff4[41].gsub(/\r\n|\r|\n/, "")
                         assert_equal "-class WelcomeController < ApplicationController", buf
                         diff5 = @adapter.diff('sources/watchers_controller.rb', r2, r1)
                         assert_equal 20, diff5.size
                         buf =  diff5[9].gsub(/\r\n|\r|\n/, "")
                         assert_equal "-    @watched.remove_watcher(user)", buf
                       end
                     end
                   end
                   def test_diff_made_by_revision
                     if @diff_c_support
                       [24, '24', '4cddb4e45f52'].each do |r1|
                         diff1 = @adapter.diff(nil, r1)
                         assert_equal 5, diff1.size
                         buf = diff1[4].gsub(/\r\n|\r|\n/, "")
                         assert_equal '+0885933ad4f68d77c2649cd11f8311276e7ef7ce tag-init-revision', 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_entries
                     assert_nil @adapter.entries(nil, '100000')
                     assert_equal 1, @adapter.entries("sources", 3).size
                     assert_equal 1, @adapter.entries("sources", 'b3a615152df8').size
                     [2, '400bb8672109', '400', 400].each do |r|
                       entries1 = @adapter.entries(nil, r)
                       assert entries1
                       assert_equal 3, entries1.size
                       assert_equal 'sources', entries1[1].name
                       assert_equal 'sources', entries1[1].path
                       assert_equal 'dir', entries1[1].kind
                       readme = entries1[2]
                       assert_equal 'README', readme.name
                       assert_equal 'README', readme.path
                       assert_equal 'file', readme.kind
                       assert_equal 27, readme.size
                       assert_equal '1', readme.lastrev.revision
-                      assert_equal '9d5b5b00419901478496242e0768deba1ce8c51e', readme.lastrev.identifier
+                      assert_equal '9d5b5b004199', readme.lastrev.identifier
                       # 2007-12-14 10:24:01 +0100
                       assert_equal Time.gm(2007, 12, 14, 9, 24, 1), readme.lastrev.time
                       entries2 = @adapter.entries('sources', r)
                       assert entries2
                       assert_equal 2, entries2.size
                       assert_equal 'watchers_controller.rb', entries2[0].name
                       assert_equal 'sources/watchers_controller.rb', entries2[0].path
                       assert_equal 'file', entries2[0].kind
                       assert_equal 'welcome_controller.rb', entries2[1].name
                       assert_equal 'sources/welcome_controller.rb', entries2[1].path
                       assert_equal 'file', entries2[1].kind
                     end
                   end
                   def test_entries_tag
                     entries1 = @adapter.entries(nil, 'tag_test.00')
                     assert entries1
                     assert_equal 3, entries1.size
                     assert_equal 'sources', entries1[1].name
                     assert_equal 'sources', entries1[1].path
                     assert_equal 'dir', entries1[1].kind
                     readme = entries1[2]
                     assert_equal 'README', readme.name
                     assert_equal 'README', readme.path
                     assert_equal 'file', readme.kind
                     assert_equal 21, readme.size
                     assert_equal '0', readme.lastrev.revision
-                    assert_equal '0885933ad4f68d77c2649cd11f8311276e7ef7ce', readme.lastrev.identifier
+                    assert_equal '0885933ad4f6', readme.lastrev.identifier
                     # 2007-12-14 10:22:52 +0100
                     assert_equal Time.gm(2007, 12, 14, 9, 22, 52), readme.lastrev.time
                   end
                   def test_entries_branch
                     entries1 = @adapter.entries(nil, 'test-branch-00')
                     assert entries1
                     assert_equal 5, entries1.size
                     assert_equal 'sql_escape', entries1[2].name
                     assert_equal 'sql_escape', entries1[2].path
                     assert_equal 'dir', entries1[2].kind
                     readme = entries1[4]
                     assert_equal 'README', readme.name
                     assert_equal 'README', readme.path
                     assert_equal 'file', readme.kind
                     assert_equal 365, readme.size
                     assert_equal '8', readme.lastrev.revision
-                    assert_equal 'c51f5bb613cd60793c2a9fe9df29332e74bb949f', readme.lastrev.identifier
+                    assert_equal 'c51f5bb613cd', readme.lastrev.identifier
                     # 2001-02-01 00:00:00 -0900
                     assert_equal Time.gm(2001, 2, 1, 9, 0, 0), readme.lastrev.time
                   end
                   def test_locate_on_outdated_repository
                     assert_equal 1, @adapter.entries("images", 0).size
                     assert_equal 2, @adapter.entries("images").size
                     assert_equal 2, @adapter.entries("images", 2).size
                   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
                   def test_tags
                     assert_equal [@tag_char_1, 'tag_test.00', 'tag-init-revision'], @adapter.tags
                   end
                   def test_tagmap
                     tm = {
-                      @tag_char_1         => 'adf805632193500ad3b615cd04f58f9b0769f576',
+                      @tag_char_1         => 'adf805632193',
-                      'tag_test.00'       => '6987191f453a5f6557018d522feea2c450d5588d',
+                      'tag_test.00'       => '6987191f453a',
-                      'tag-init-revision' => '0885933ad4f68d77c2649cd11f8311276e7ef7ce',
+                      'tag-init-revision' => '0885933ad4f6',
                       }
                     assert_equal tm, @adapter.tagmap
                   end
                   def test_branches
                     brs = []
                     @adapter.branches.each do |b|
                       brs << b
                     end
                     assert_equal 7, brs.length
                     assert_equal 'default', brs[0].to_s
                     assert_equal '31', brs[0].revision
-                    assert_equal '31eeee7395c8c78e66dd54c50addd078d10b2355', brs[0].scmid
+                    assert_equal '31eeee7395c8', brs[0].scmid
                     assert_equal 'test-branch-01', brs[1].to_s
                     assert_equal '30', brs[1].revision
-                    assert_equal 'ad4dc4f80284a4f9168b77e0b6de288e5d207ee7', brs[1].scmid
+                    assert_equal 'ad4dc4f80284', brs[1].scmid
                     assert_equal @branch_char_1, brs[2].to_s
                     assert_equal '27', brs[2].revision
-                    assert_equal '7bbf4c738e7145149d2e5eb1eed1d3a8ddd3b914', brs[2].scmid
+                    assert_equal '7bbf4c738e71', brs[2].scmid
                     assert_equal 'branch (1)[2]&,%.-3_4', brs[3].to_s
                     assert_equal '25', brs[3].revision
-                    assert_equal 'afc61e85bde74de930e5846c8451bd55b5bafc9c', brs[3].scmid
+                    assert_equal 'afc61e85bde7', brs[3].scmid
                     assert_equal @branch_char_0, brs[4].to_s
                     assert_equal '23', brs[4].revision
-                    assert_equal 'c8d3e4887474af6a589190140508037ebaa9d9c3', brs[4].scmid
+                    assert_equal 'c8d3e4887474', brs[4].scmid
                     assert_equal 'test_branch.latin-1', brs[5].to_s
                     assert_equal '22', brs[5].revision
-                    assert_equal 'c2ffe7da686aa3d956e59f2a2854cf8980a8b768', brs[5].scmid
+                    assert_equal 'c2ffe7da686a', brs[5].scmid
                     assert_equal 'test-branch-00', brs[6].to_s
                     assert_equal '13', brs[6].revision
-                    assert_equal '3a330eb329586ea2adb3f83237c23310e744ebe9', brs[6].scmid
+                    assert_equal '3a330eb32958', brs[6].scmid
                   end
                   def test_branchmap
                     bm = {
-                       'default'               => '31eeee7395c8c78e66dd54c50addd078d10b2355',
+                       'default'               => '31eeee7395c8',
-                       'test_branch.latin-1'   => 'c2ffe7da686aa3d956e59f2a2854cf8980a8b768',
+                       'test_branch.latin-1'   => 'c2ffe7da686a',
-                       'branch (1)[2]&,%.-3_4' => 'afc61e85bde74de930e5846c8451bd55b5bafc9c',
+                       'branch (1)[2]&,%.-3_4' => 'afc61e85bde7',
-                       'test-branch-00'        => '3a330eb329586ea2adb3f83237c23310e744ebe9',
+                       'test-branch-00'        => '3a330eb32958',
-                       "test-branch-01"        => 'ad4dc4f80284a4f9168b77e0b6de288e5d207ee7',
+                       "test-branch-01"        => 'ad4dc4f80284',
-                       @branch_char_0          => 'c8d3e4887474af6a589190140508037ebaa9d9c3',
+                       @branch_char_0          => 'c8d3e4887474',
-                       @branch_char_1          => '7bbf4c738e7145149d2e5eb1eed1d3a8ddd3b914',
+                       @branch_char_1          => '7bbf4c738e71',
                      }
                     assert_equal bm, @adapter.branchmap
                   end
                   def test_path_space
                     p = 'README (1)[2]&,%.-3_4'
                     [15, '933ca60293d7'].each do |r1|
                       assert @adapter.diff(p, r1)
                       assert @adapter.cat(p, r1)
                       assert_equal 1, @adapter.annotate(p, r1).lines.length
                       [25, 'afc61e85bde7'].each do |r2|
                         assert @adapter.diff(p, r1, r2)
                       end
                     end
                   end
                   def test_tag_non_ascii
                     p = "latin-1-dir/test-#{@char_1}-1.txt"
                     assert @adapter.cat(p, @tag_char_1)
                     assert_equal 1, @adapter.annotate(p, @tag_char_1).lines.length
                   end
                   def test_branch_non_ascii
                     p = "latin-1-dir/test-#{@char_1}-subdir/test-#{@char_1}-1.txt"
                     assert @adapter.cat(p, @branch_char_1)
                     assert_equal 1, @adapter.annotate(p, @branch_char_1).lines.length
                   end
                   def test_nodes_in_branch
                      [
                         'default',
                         @branch_char_1,
                         'branch (1)[2]&,%.-3_4',
                         @branch_char_0,
                         'test_branch.latin-1',
                         'test-branch-00',
                            ].each do |bra|
                       nib0 = @adapter.nodes_in_branch(bra)
                       assert nib0
                       nib1 = @adapter.nodes_in_branch(bra, :limit => 1)
                       assert_equal 1, nib1.size
                       case bra
                         when 'branch (1)[2]&,%.-3_4'
                           if @adapter.class.client_version_above?([1, 6])
                             assert_equal 3, nib0.size
-                            assert_equal 'afc61e85bde74de930e5846c8451bd55b5bafc9c', nib0[0]
+                            assert_equal nib0[0], 'afc61e85bde7'
                             nib2 = @adapter.nodes_in_branch(bra, :limit => 2)
                             assert_equal 2, nib2.size
-                            assert_equal '933ca60293d78f7c7979dd123cc0c02431683575', nib2[1]
+                            assert_equal nib2[1], '933ca60293d7'
                           end
                         when @branch_char_1
                           if @adapter.class.client_version_above?([1, 6])
                             assert_equal 2, nib0.size
-                            assert_equal '08ff3227303ec0dfcc818efa8e9cc652fe81859f', nib0[1]
+                            assert_equal nib0[1], '08ff3227303e'
                             nib2 = @adapter.nodes_in_branch(bra, :limit => 1)
                             assert_equal 1, nib2.size
-                            assert_equal '7bbf4c738e7145149d2e5eb1eed1d3a8ddd3b914', nib2[0]
+                            assert_equal nib2[0], '7bbf4c738e71'
                           end
                       end
                     end
                   end
                   def test_path_encoding_default_utf8
                     adpt1 = Redmine::Scm::Adapters::MercurialAdapter.new(
                                               REPOSITORY_PATH
                                             )
                     assert_equal "UTF-8", adpt1.path_encoding
                     adpt2 = Redmine::Scm::Adapters::MercurialAdapter.new(
                                               REPOSITORY_PATH,
                                               nil,
                                               nil,
                                               nil,
                                               ""
                                             )
                     assert_equal "UTF-8", adpt2.path_encoding
                   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 "#{HELPERS_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