jro_apps/redmine Commit - r1638:622b6121f48f

Fixes nil error when svn binary version is unknown (#1607)....

Jean-Philippe Lang -

r1638:622b6121f48f

parent child

Context file:

r1638:622b6121f48f

Collapse all files

lib/redmine/scm/adapters/abstract_adapter.rb +13 -4

             # 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:
                     class << self
                       # Returns the version of the scm client
-                      # Eg: [1, 5, 0]
+                      # Eg: [1, 5, 0] or [] if unknown
                       def client_version
-                        'Unknown version'
+                        []
                       end
                       # Returns the version string of the scm client
-                      # Eg: '1.5.0'
+                      # Eg: '1.5.0' or 'Unknown version' if unknown
                       def client_version_string
-                        client_version.is_a?(Array) ? client_version.join('.') : client_version.to_s
+                        v = client_version || 'Unknown version'
+                        v.is_a?(Array) ? v.join('.') : v.to_s
+                      end
+                      # Returns true if the current client version is above
+                      # or equals the given one
+                      # If option is :unknown is set to true, it will return
+                      # true if the client version is unknown
+                      def client_version_above?(v, options={})
+                        ((client_version <=> v) >= 0) || (client_version.empty? && options[:unknown])
                       end
                     end
                     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 properties(path, 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)
                       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 without_leading_slash(path)
                       path ||= ''
                       path.gsub(%r{^/+}, '')
                     end
                     def without_trailling_slash(path)
                       path ||= ''
                       (path[-1,1] == "/") ? path[0..-2] : 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
                       self.class.logger
                     end
                     def shellout(cmd, &block)
                       self.class.shellout(cmd, &block)
                     end
                     def self.logger
                       RAILS_DEFAULT_LOGGER
                     end
                     def self.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
                   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 +2 -2

             # 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"
                     class << self
                       def client_version
-                        @@client_version ||= (hgversion || 'Unknown version')
+                        @@client_version ||= (hgversion || [])
                       end
                       def hgversion
                         # The hg version is expressed either as a
                         # release number (eg 0.9.5 or 1.0) or as a revision
                         # id composed of 12 hexa characters.
                         theversion = hgversion_from_command_line
                         if theversion.match(/^\d+(\.\d+)+/)
                           theversion.split(".").collect(&:to_i)
                         end
                       end
                       def hgversion_from_command_line
                         %x{#{HG_BIN} --version}.match(/\(version (.*)\)/)[1]
                       end
                       def template_path
                         @@template_path ||= template_path_for(client_version)
                       end
                       def template_path_for(version)
-                        if version.is_a?(String) or ((version <=> [0,9,5]) > 0)
+                        if ((version <=> [0,9,5]) > 0) || version.empty?
                           ver = "1.0"
                         else
                           ver = "0.9.5"
                         end
                         "#{TEMPLATES_DIR}/#{TEMPLATE_NAME}-#{ver}.#{TEMPLATE_EXTENSION}"
                       end
                     end
                     def info
                       cmd = "#{HG_BIN} -R #{target('')} root"
                       root_url = nil
                       shellout(cmd) do |io|
                         root_url = io.gets
                       end
                       return nil if $? && $?.exitstatus != 0
                       info = Info.new({:root_url => root_url.chomp,
                                         :lastrev => revisions(nil,nil,nil,{:limit => 1}).last
                                       })
                       info
                     rescue CommandFailed
                       return nil
                     end
                     def entries(path=nil, identifier=nil)
                       path ||= ''
                       entries = Entries.new
                       cmd = "#{HG_BIN} -R #{target('')} --cwd #{target('')} locate"
                       cmd << " -r " + (identifier ? identifier.to_s : "tip")
                       cmd << " " + shell_quote("path:#{path}") unless path.empty?
                       shellout(cmd) do |io|
                         io.each_line do |line|
                           # HG uses antislashs as separator on Windows
                           line = line.gsub(/\\/, "/")
                           if path.empty? or e = line.gsub!(%r{^#{with_trailling_slash(path)}},'')
                             e ||= line
                             e = e.chomp.split(%r{[\/\\]})
                             entries << Entry.new({:name => e.first,
                                                    :path => (path.nil? or path.empty? ? e.first : "#{with_trailling_slash(path)}#{e.first}"),
                                                    :kind => (e.size > 1 ? 'dir' : 'file'),
                                                    :lastrev => Revision.new
                                                  }) unless entries.detect{|entry| entry.name == e.first}
                           end
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       entries.sort_by_name
                     end
                     # Fetch the revisions by using a template file that
                     # makes Mercurial produce a xml output.
                     def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       revisions = Revisions.new
                       cmd = "#{HG_BIN} --debug --encoding utf8 -R #{target('')} log -C --style #{self.class.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|
                         begin
                           # HG doesn't close the XML Document...
                           doc = REXML::Document.new(io.read << "</log>")
                           doc.elements.each("log/logentry") do |logentry|
                             paths = []
                             copies = logentry.get_elements('paths/path-copied')
                             logentry.elements.each("paths/path") do |path|
                               # Detect if the added file is a copy
                               if path.attributes['action'] == 'A' and c = copies.find{ |e| e.text == path.text }
                                 from_path = c.attributes['copyfrom-path']
                                 from_rev = logentry.attributes['revision']
                               end
                               paths << {:action => path.attributes['action'],
                                 :path => "/#{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
                         rescue
                           logger.debug($!)
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       revisions
                     end
                     def diff(path, identifier_from, identifier_to=nil)
                       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
                       diff
                     end
                     def cat(path, identifier=nil)
                       cmd = "#{HG_BIN} -R #{target('')} cat"
                       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
                   end
                 end
               end
             end

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

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/abstract_adapter'
             require 'rexml/document'
             module Redmine
               module Scm
                 module Adapters
                   class SubversionAdapter < AbstractAdapter
                     # SVN executable name
                     SVN_BIN = "svn"
                     class << self
                       def client_version
-                        @@client_version ||= (svn_binary_version || 'Unknown version')
+                        @@client_version ||= (svn_binary_version || [])
                       end
                       def svn_binary_version
                         cmd = "#{SVN_BIN} --version"
                         version = nil
                         shellout(cmd) do |io|
                           # Read svn version in first returned line
                           if m = io.gets.match(%r{((\d+\.)+\d+)})
                             version = m[0].scan(%r{\d+}).collect(&:to_i)
                           end
                         end
                         return nil if $? && $?.exitstatus != 0
                         version
                       end
                     end
                     # Get info about the svn repository
                     def info
                       cmd = "#{SVN_BIN} info --xml #{target('')}"
                       cmd << credentials_string
                       info = nil
                       shellout(cmd) do |io|
                         begin
                           doc = REXML::Document.new(io)
                           #root_url = doc.elements["info/entry/repository/root"].text
                           info = Info.new({:root_url => doc.elements["info/entry/repository/root"].text,
                                            :lastrev => Revision.new({
                                              :identifier => doc.elements["info/entry/commit"].attributes['revision'],
                                              :time => Time.parse(doc.elements["info/entry/commit/date"].text).localtime,
                                              :author => (doc.elements["info/entry/commit/author"] ? doc.elements["info/entry/commit/author"].text : "")
                                            })
                                          })
                         rescue
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       info
                     rescue CommandFailed
                       return nil
                     end
                     # Returns an Entries collection
                     # or nil if the given path doesn't exist in the repository
                     def entries(path=nil, identifier=nil)
                       path ||= ''
                       identifier = (identifier and identifier.to_i > 0) ? identifier.to_i : "HEAD"
                       entries = Entries.new
                       cmd = "#{SVN_BIN} list --xml #{target(path)}@#{identifier}"
                       cmd << credentials_string
                       shellout(cmd) do |io|
                         output = io.read
                         begin
                           doc = REXML::Document.new(output)
                           doc.elements.each("lists/list/entry") do |entry|
                             # Skip directory if there is no commit date (usually that
                             # means that we don't have read access to it)
                             next if entry.attributes['kind'] == 'dir' && entry.elements['commit'].elements['date'].nil?
                             entries << Entry.new({:name => entry.elements['name'].text,
                                         :path => ((path.empty? ? "" : "#{path}/") + entry.elements['name'].text),
                                         :kind => entry.attributes['kind'],
                                         :size => (entry.elements['size'] and entry.elements['size'].text).to_i,
                                         :lastrev => Revision.new({
                                           :identifier => entry.elements['commit'].attributes['revision'],
                                           :time => Time.parse(entry.elements['commit'].elements['date'].text).localtime,
                                           :author => (entry.elements['commit'].elements['author'] ? entry.elements['commit'].elements['author'].text : "")
                                           })
                                         })
                           end
                         rescue Exception => e
                           logger.error("Error parsing svn output: #{e.message}")
                           logger.error("Output was:\n #{output}")
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       logger.debug("Found #{entries.size} entries in the repository for #{target(path)}") if logger && logger.debug?
                       entries.sort_by_name
                     end
                     def properties(path, identifier=nil)
                       # proplist xml output supported in svn 1.5.0 and higher
-                      return nil if (self.class.client_version <=> [1, 5, 0]) < 0
+                      return nil unless self.class.client_version_above?([1, 5, 0])
                       identifier = (identifier and identifier.to_i > 0) ? identifier.to_i : "HEAD"
                       cmd = "#{SVN_BIN} proplist --verbose --xml #{target(path)}@#{identifier}"
                       cmd << credentials_string
                       properties = {}
                       shellout(cmd) do |io|
                         output = io.read
                         begin
                           doc = REXML::Document.new(output)
                           doc.elements.each("properties/target/property") do |property|
                             properties[ property.attributes['name'] ] = property.text
                           end
                         rescue
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       properties
                     end
                     def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       path ||= ''
                       identifier_from = (identifier_from and identifier_from.to_i > 0) ? identifier_from.to_i : "HEAD"
                       identifier_to = (identifier_to and identifier_to.to_i > 0) ? identifier_to.to_i : 1
                       revisions = Revisions.new
                       cmd = "#{SVN_BIN} log --xml -r #{identifier_from}:#{identifier_to}"
                       cmd << credentials_string
                       cmd << " --verbose " if  options[:with_paths]
                       cmd << ' ' + target(path)
                       shellout(cmd) do |io|
                         begin
                           doc = REXML::Document.new(io)
                           doc.elements.each("log/logentry") do |logentry|
                             paths = []
                             logentry.elements.each("paths/path") do |path|
                               paths << {:action => path.attributes['action'],
                                         :path => path.text,
                                         :from_path => path.attributes['copyfrom-path'],
                                         :from_revision => path.attributes['copyfrom-rev']
                                         }
                             end
                             paths.sort! { |x,y| x[:path] <=> y[:path] }
                             revisions << Revision.new({:identifier => logentry.attributes['revision'],
                                           :author => (logentry.elements['author'] ? logentry.elements['author'].text : ""),
                                           :time => Time.parse(logentry.elements['date'].text).localtime,
                                           :message => logentry.elements['msg'].text,
                                           :paths => paths
                                         })
                           end
                         rescue
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       revisions
                     end
                     def diff(path, identifier_from, identifier_to=nil, type="inline")
                       path ||= ''
                       identifier_from = (identifier_from and identifier_from.to_i > 0) ? identifier_from.to_i : ''
                       identifier_to = (identifier_to and identifier_to.to_i > 0) ? identifier_to.to_i : (identifier_from.to_i - 1)
                       cmd = "#{SVN_BIN} diff -r "
                       cmd << "#{identifier_to}:"
                       cmd << "#{identifier_from}"
                       cmd << " #{target(path)}@#{identifier_from}"
                       cmd << credentials_string
                       diff = []
                       shellout(cmd) do |io|
                         io.each_line do |line|
                           diff << line
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       diff
                     end
                     def cat(path, identifier=nil)
                       identifier = (identifier and identifier.to_i > 0) ? identifier.to_i : "HEAD"
                       cmd = "#{SVN_BIN} cat #{target(path)}@#{identifier}"
                       cmd << credentials_string
                       cat = nil
                       shellout(cmd) do |io|
                         io.binmode
                         cat = io.read
                       end
                       return nil if $? && $?.exitstatus != 0
                       cat
                     end
                     def annotate(path, identifier=nil)
                       identifier = (identifier and identifier.to_i > 0) ? identifier.to_i : "HEAD"
                       cmd = "#{SVN_BIN} blame #{target(path)}@#{identifier}"
                       cmd << credentials_string
                       blame = Annotate.new
                       shellout(cmd) do |io|
                         io.each_line do |line|
                           next unless line =~ %r{^\s*(\d+)\s*(\S+)\s(.*)$}
                           blame.add_line($3.rstrip, Revision.new(:identifier => $1.to_i, :author => $2.strip))
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       blame
                     end
                     private
                     def credentials_string
                       str = ''
                       str << " --username #{shell_quote(@login)}" unless @login.blank?
                       str << " --password #{shell_quote(@password)}" unless @login.blank? || @password.blank?
                       str
                     end
                   end
                 end
               end
             end

test/unit/mercurial_adapter_test.rb +1 -1

             require File.dirname(__FILE__) + '/../test_helper'
             begin
               require 'mocha'
               class MercurialAdapterTest < Test::Unit::TestCase
                 TEMPLATES_DIR = Redmine::Scm::Adapters::MercurialAdapter::TEMPLATES_DIR
                 TEMPLATE_NAME = Redmine::Scm::Adapters::MercurialAdapter::TEMPLATE_NAME
                 TEMPLATE_EXTENSION = Redmine::Scm::Adapters::MercurialAdapter::TEMPLATE_EXTENSION
                 REPOSITORY_PATH = RAILS_ROOT.gsub(%r{config\/\.\.}, '') + '/tmp/test/mercurial_repository'
                 def test_hgversion
                   to_test = { "0.9.5" => [0,9,5],
                               "1.0" => [1,0],
                               "1e4ddc9ac9f7+20080325" => nil,
                               "1.0.1+20080525" => [1,0,1],
                               "1916e629a29d" => nil}
                   to_test.each do |s, v|
                     test_hgversion_for(s, v)
                   end
                 end
                 def test_template_path
                   to_test = { [0,9,5] => "0.9.5",
                               [1,0] => "1.0",
-                              "Unknown version" => "1.0",
+                              [] => "1.0",
                               [1,0,1] => "1.0"}
                   to_test.each do |v, template|
                     test_template_path_for(v, template)
                   end
                 end
                 private
                 def test_hgversion_for(hgversion, version)
                   Redmine::Scm::Adapters::MercurialAdapter.expects(:hgversion_from_command_line).returns(hgversion)
                   adapter = Redmine::Scm::Adapters::MercurialAdapter
                   assert_equal version, adapter.hgversion
                 end
                 def test_template_path_for(version, template)
                   adapter = Redmine::Scm::Adapters::MercurialAdapter
                   assert_equal "#{TEMPLATES_DIR}/#{TEMPLATE_NAME}-#{template}.#{TEMPLATE_EXTENSION}", adapter.template_path_for(version)
                   assert File.exist?(adapter.template_path_for(version))
                 end
               end
             rescue LoadError
               def test_fake; assert(false, "Requires mocha to run those tests")  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