Redmine

    content_tag('p', form.text_field(:url, :label => 'Root directory', :size => 60, :required => true, :disabled => (repository && !repository.root_url.blank?))) +

    content_tag('p', form.select(:path_encoding, [nil] + Setting::ENCODINGS,

                                 :label => 'Path encoding'))

require 'redmine/scm/adapters/path_encodable_wrapper'

    @scm ||= new_scm

      changesets.find(:all, :include => :user, :limit => limit)

      changesets.find(:all, :select => "DISTINCT #{Changeset.table_name}.*",

                      :joins => :changes,

                      :conditions => ["#{Change.table_name}.path = ? OR #{Change.table_name}.path LIKE ? ESCAPE ?",

                                      path.with_leading_slash,

                                      "#{path.with_leading_slash.gsub(/[%_\\]/) { |s| "\\#{s}" }}/%", '\\'],

                      :include => :user, :limit => limit)

  def new_scm

    scm = self.scm_adapter.new url, root_url, login, password

    scm = Redmine::Scm::Adapters::PathEncodableWrapper.new(scm, path_encoding) unless path_encoding.blank?

    scm

  end

  # sort changesets by revision number

  has_many :changesets, :order => "#{Changeset.table_name}.id DESC", :foreign_key => 'repository_id'

class AddRepositoriesPathEncoding < ActiveRecord::Migration

  def self.up

    add_column :repositories, :path_encoding, :string, :limit => 64, :default => nil

  end

  def self.down

    remove_column :repositories, :path_encoding

  end

end

file = '<path action="M">{file|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'

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'

require 'cgi'

                    :path => "/#{CGI.unescape(path.text)}",

                    :from_path => from_path ? "/#{CGI.unescape(from_path)}" : nil,

# redMine - project management software

# Copyright (C) 2006-2010  Jean-Philippe Lang

# Copyright (C) 2010 Yuya Nishihara <yuya@tcha.org>

#

# 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 'delegate'

require 'iconv'

module Redmine

  module Scm

    module Adapters

      # wraps scm adapter to convert path encodings

      class PathEncodableWrapper < SimpleDelegator  # :nodoc:

        def initialize(scm, path_encoding)

          super(scm)

          @path_encoding = path_encoding

        end

        def entry(path=nil, identifier=nil)

          convert_entry!(super(to_scm_path(path), identifier))

        end

        def entries(path=nil, identifier=nil)

          convert_entries!(super(to_scm_path(path), identifier))

        end

        def properties(path, identifier=nil)

          super(to_scm_path(path), identifier)

        end

        def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})

          convert_revisions!(super(to_scm_path(path), identifier_from, identifier_to, options))

        end

        def diff(path, identifier_from, identifier_to=nil)

          super(to_scm_path(path), identifier_from, identifier_to)

        end

        def cat(path, identifier=nil)

          super(to_scm_path(path), identifier)

        end

        def annotate(path, identifier=nil)

          super(to_scm_path(path), identifier)

        end

        private

        def convert_entry!(entry)

          return unless entry

          entry.name = from_scm_path(entry.name)

          entry.path = from_scm_path(entry.path)

          entry

        end

        def convert_entries!(entries)

          return unless entries

          entries.each { |e| convert_entry!(e) }

          entries

        end

        def convert_revisions!(revisions)

          return unless revisions

          revisions.each do |rev|

            next unless rev.paths

            rev.paths.each do |e|

              e[:path] = from_scm_path(e[:path])

              e[:from_path] = from_scm_path(e[:from_path])

            end

          end

          revisions

        end

        # convert repository path string to utf-8

        def from_scm_path(s)

          return unless s

          begin

            Iconv.conv('UTF-8', @path_encoding, s)

          rescue Iconv::Failure => err

            raise CommandFailed, "failed to convert path from #{@path_encoding} to UTF-8. #{err}"

          end

        end

        # convert utf-8 path string to repository encoding

        def to_scm_path(s)

          return unless s

          begin

            Iconv.conv(@path_encoding, 'UTF-8', s)

          rescue Iconv::Failure => err

            raise CommandFailed, "failed to convert path from UTF-8 to #{@path_encoding}. #{err}"

          end

        end

      end

    end

  end

end

    assert @repository = Repository::Mercurial.create(

                            :project       => Project.find(3),

                            :url           => REPOSITORY_PATH,

                            :path_encoding => 'ISO-8859-1'

                            )

    @repository.fetch_changesets

    @repository.reload

      assert_equal 4, assigns(:entries).size

    def test_show_directory_sql_escape_percent

      get :show, :id => 3, :path => ['sql_escape', 'percent%dir'], :rev => 13

      assert_response :success

      assert_template 'show'

      assert_not_nil assigns(:entries)

      assert_equal ['percent%file1.txt', 'percentfile1.txt'], assigns(:entries).collect(&:name)

      changesets = assigns(:changesets)

      assert_not_nil changesets

      assert_equal %w(13 11 10 9), changesets.collect(&:revision)

    end

    def test_show_directory_latin_1

      get :show, :id => 3, :path => ['latin-1-dir'], :rev => 19

      assert_response :success

      assert_template 'show'

      assert_not_nil assigns(:entries)

      assert_equal ["make-latin-1-file.rb", "test-\xc3\x9c-1.txt","test-\xc3\x9c-2.txt", "test-\xc3\x9c.txt"], assigns(:entries).collect(&:name)

      changesets = assigns(:changesets)

      assert_not_nil changesets

      assert_equal %w(19 18 17 16 15), changesets.collect(&:revision)

    end

                 :content => '10',

                 :attributes => { :class => 'line-num' },

    def test_entry_show_latin_1

      get :entry, :id => 3, :path => ['latin-1-dir', "test-\xc3\x9c-2.txt"], :rev => 19

      assert_response :success

      assert_template 'entry'

      # Line 19

      assert_tag :tag => 'th',

                 :content => '1',

                 :attributes => { :class => 'line-num' },

                 :sibling => { :tag => 'td', :content => /Mercurial is a distributed version control system/ }

    end

                 :content => '22',

    def test_diff_latin_1

      get :diff, :id => 3, :rev => 19

      assert_response :success

      assert_template 'diff'

      assert_tag :tag => 'th',

                 :content => '2',

                 :sibling => { :tag => 'td', 

                               :attributes => { :class => /diff_in/ },

                               :content => /It is written in Python/ }

    end

      # Line 23, revision 4:def6d2f1254a

      assert_tag :tag => 'th',

                 :content => '23',

                 :attributes => { :class => 'line-num' },

                 :sibling =>

                       {

                         :tag => 'td',

                         :attributes => { :class => 'revision' },

                         :child => { :tag => 'a', :content => '4' }

                         # :child => { :tag => 'a', :content => /4:def6d2f1/ }

                       }

      assert_tag :tag => 'th',

                 :content => '23',

                 :attributes => { :class => 'line-num' },

                 :sibling =>

                       {

                          :tag     => 'td'    ,

                          :content => 'jsmith' ,

                          :attributes => { :class   => 'author' },

                        }

      assert_tag :tag => 'th',

                 :content => '23',

                 :attributes => { :class => 'line-num' },

    def test_annotate_latin_1

      get :annotate, :id => 3, :path => ['latin-1-dir', "test-\xc3\x9c-2.txt"], :rev => 19

      assert_response :success

      assert_template 'annotate'

      assert_tag :tag => 'th',

                 :content => '1',

                 :attributes => { :class => 'line-num' },

                 :sibling =>

                       {

                         :tag => 'td',

                         :attributes => { :class => 'revision' },

                         :child => { :tag => 'a', :content => '18' }

                       }

      assert_tag :tag => 'th',

                 :content => '1',

                 :attributes => { :class => 'line-num' },

                 :sibling =>

                       {

                          :tag     => 'td'    ,

                          :content => 'jsmith' ,

                          :attributes => { :class   => 'author' },

                        }

      assert_tag :tag => 'th',

                 :content => '1',

                 :attributes => { :class => 'line-num' },

                 :sibling => { :tag => 'td', :content => /Mercurial is a distributed version control system/ }

    end

    if File.directory?(REPOSITORY_PATH)  

      def setup

        @adapter = Redmine::Scm::Adapters::MercurialAdapter.new(REPOSITORY_PATH)

      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

      def test_template_path

        to_test = { [0,9,5] => "0.9.5",

                       [1,0]    => "1.0",

                       []       => "1.0",

                       [1,0,1]  => "1.0",

                       [1,7]    => "1.0",

                       [1,7,1]  => "1.0"}

        to_test.each do |v, template|

          test_template_path_for(v, template)

        end

      end

      def test_cat

        assert     @adapter.cat("sources/welcome_controller.rb", 2)

        assert_nil @adapter.cat("sources/welcome_controller.rb")

      end

      private

      def test_hgversion_for(hgversion, version)

        @adapter.class.expects(:hgversion_from_command_line).returns(hgversion)

        assert_equal version, @adapter.class.hgversion

      end

      def test_template_path_for(version, template)

        assert_equal "#{TEMPLATES_DIR}/#{TEMPLATE_NAME}-#{template}.#{TEMPLATE_EXTENSION}",

                     @adapter.class.template_path_for(version)

        assert File.exist?(@adapter.class.template_path_for(version))

      end

    else

      puts "Mercurial test repository NOT FOUND. Skipping unit tests !!!"

      def test_fake; assert true end

    assert @repository = Repository::Mercurial.create(

                            :project       => @project,

                            :url           => REPOSITORY_PATH,

                            :path_encoding => 'ISO-8859-1'

                            )

      assert_equal 21, @repository.changesets.count

      assert_equal 30, @repository.changes.count

      assert_equal "Initial import.\nThe repository contains 3 files.",

                   @repository.changesets.find_by_revision('0').comments

      assert_equal 21, @repository.changesets.count

      # For bare repository; that is, a repository without a working copy

      # $ hg update null

      # See http://mercurial.selenic.com/wiki/GitConcepts?action=recall&rev=46#Bare_repositories

    def test_changeset_order_by_revision

      @repository.fetch_changesets

      @repository.reload

      c0 = @repository.latest_changeset

      c1 = @repository.changesets.find_by_revision('0')

      # sorted by revision (id), not by date

      assert c0.revision.to_i > c1.revision.to_i

      assert c0.committed_on  < c1.committed_on

    def test_latest_changesets

      @repository.fetch_changesets

      @repository.reload

      # with_limit

      changesets = @repository.latest_changesets('', nil, 2)

      assert_equal @repository.latest_changesets('', nil)[0, 2], changesets

      # with_filepath

      changesets = @repository.latest_changesets('sql_escape/percent%dir/percent%file1.txt', nil)

      assert_equal %w|11 10 9|, changesets.collect(&:revision)

      changesets = @repository.latest_changesets('/sql_escape/underscore_dir/understrike_file.txt', nil)

      assert_equal %w|12 9|, changesets.collect(&:revision)

      # with_dirpath

      changesets = @repository.latest_changesets('sql_escape/percent%dir', nil)

      assert_equal %w|13 11 10 9|, changesets.collect(&:revision)

    end

    def test_copied_files

      @repository.fetch_changesets

      @repository.reload

      cs1 = @repository.changesets.find_by_revision('13')

      c1  = cs1.changes

      assert_equal 2, c1.size

      assert_equal 'A', c1[0].action

      assert_equal '/sql_escape/percent%dir/percentfile1.txt',  c1[0].path

      assert_equal '/sql_escape/percent%dir/percent%file1.txt', c1[0].from_path

      assert_equal 'A', c1[1].action

      assert_equal '/sql_escape/underscore_dir/understrike-file.txt', c1[1].path

      assert_equal '/sql_escape/underscore_dir/understrike_file.txt', c1[1].from_path

      cs2 = @repository.changesets.find_by_revision('17')

      c2  = cs2.changes

      assert_equal 1, c2.size

      assert_equal 'A', c2[0].action

      assert_equal "/latin-1-dir/test-\xc3\x9c-1.txt",  c2[0].path

      assert_equal "/latin-1-dir/test-\xc3\x9c.txt",    c2[0].from_path

    end