comparison lib/redmine/scm/adapters/darcs_adapter.rb @ 245:051f544170fe

* Update to SVN trunk revision 4993

 require 'redmine/scm/adapters/abstract_adapter'
 require 'rexml/document'
 
 module Redmine
   module Scm
-    module Adapters    
-      class DarcsAdapter < AbstractAdapter      
+    module Adapters
+      class DarcsAdapter < AbstractAdapter
         # Darcs executable name
         DARCS_BIN = Redmine::Configuration['scm_darcs_command'] || "darcs"
-        
+
         class << self
+          def client_command
+            @@bin    ||= DARCS_BIN
+          end
+
+          def sq_bin
+            @@sq_bin ||= shell_quote(DARCS_BIN)
+          end
+
           def client_version
             @@client_version ||= (darcs_binary_version || [])
           end
-  	  
+
+          def client_available
+            !client_version.empty?
+          end
+
           def darcs_binary_version
-            darcsversion = darcs_binary_version_from_command_line
+            darcsversion = darcs_binary_version_from_command_line.dup
+            if darcsversion.respond_to?(:force_encoding)
+              darcsversion.force_encoding('ASCII-8BIT')
+            end
             if m = darcsversion.match(%r{\A(.*?)((\d+\.)+\d+)})
               m[2].scan(%r{\d+}).collect(&:to_i)
             end
           end
 
           def darcs_binary_version_from_command_line
-            shellout("#{DARCS_BIN} --version") { |io| io.read }.to_s
-          end
-        end
-
-        def initialize(url, root_url=nil, login=nil, password=nil)
+            shellout("#{sq_bin} --version") { |io| io.read }.to_s
+          end
+        end
+
+        def initialize(url, root_url=nil, login=nil, password=nil,
+                       path_encoding=nil)
           @url = url
           @root_url = url
         end
 
         def supports_cat?

         # Get info about the darcs repository
         def info
           rev = revisions(nil,nil,nil,{:limit => 1})
           rev ? Info.new({:root_url => @url, :lastrev => rev.last}) : 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_prefix = (path.blank? ? '' : "#{path}/")
           if path.blank?
             path = ( self.class.client_version_above?([2, 2, 0]) ? @url : '.' )
           end
-          entries = Entries.new          
-          cmd = "#{DARCS_BIN} annotate --repodir #{shell_quote @url} --xml-output"
+          entries = Entries.new
+          cmd = "#{self.class.sq_bin} annotate --repodir #{shell_quote @url} --xml-output"
           cmd << " --match #{shell_quote("hash #{identifier}")}" if identifier
           cmd << " #{shell_quote path}"
           shellout(cmd) do |io|
             begin
               doc = REXML::Document.new(io)

             end
           end
           return nil if $? && $?.exitstatus != 0
           entries.compact.sort_by_name
         end
-    
+
         def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
           path = '.' if path.blank?
           revisions = Revisions.new
-          cmd = "#{DARCS_BIN} changes --repodir #{shell_quote @url} --xml-output"
+          cmd = "#{self.class.sq_bin} changes --repodir #{shell_quote @url} --xml-output"
           cmd << " --from-match #{shell_quote("hash #{identifier_from}")}" if identifier_from
           cmd << " --last #{options[:limit].to_i}" if options[:limit]
           shellout(cmd) do |io|
             begin
               doc = REXML::Document.new(io)

             end
           end
           return nil if $? && $?.exitstatus != 0
           revisions
         end
-        
+
         def diff(path, identifier_from, identifier_to=nil)
           path = '*' if path.blank?
-          cmd = "#{DARCS_BIN} diff --repodir #{shell_quote @url}"
+          cmd = "#{self.class.sq_bin} diff --repodir #{shell_quote @url}"
           if identifier_to.nil?
             cmd << " --match #{shell_quote("hash #{identifier_from}")}"
           else
             cmd << " --to-match #{shell_quote("hash #{identifier_from}")}"
             cmd << " --from-match #{shell_quote("hash #{identifier_to}")}"

             end
           end
           return nil if $? && $?.exitstatus != 0
           diff
         end
-        
+
         def cat(path, identifier=nil)
-          cmd = "#{DARCS_BIN} show content --repodir #{shell_quote @url}"
+          cmd = "#{self.class.sq_bin} show content --repodir #{shell_quote @url}"
           cmd << " --match #{shell_quote("hash #{identifier}")}" if identifier
           cmd << " #{shell_quote path}"
           cat = nil
           shellout(cmd) do |io|
             io.binmode

           return nil if $? && $?.exitstatus != 0
           cat
         end
 
         private
-        
+
         # Returns an Entry from the given XML element
         # or nil if the entry was deleted
         def entry_from_xml(element, path_prefix)
           modified_element = element.elements['modified']
           if modified_element.elements['modified_how'].text.match(/removed/)
             return nil
           end
-          
+
           Entry.new({:name => element.attributes['name'],
                      :path => path_prefix + element.attributes['name'],
                      :kind => element.name == 'file' ? 'file' : 'dir',
                      :size => nil,
                      :lastrev => Revision.new({
                        :identifier => nil,
                        :scmid => modified_element.elements['patch'].attributes['hash']
                        })
-                     })        
+                     })
         end
 
         def get_paths_for_patch(hash)
           paths = get_paths_for_patch_raw(hash)
           if self.class.client_version_above?([2, 4])

             paths.concat mod_paths
             paths.concat other_paths
           end
           paths
         end
-        
+
         # Retrieve changed paths for a single patch
         def get_paths_for_patch_raw(hash)
-          cmd = "#{DARCS_BIN} annotate --repodir #{shell_quote @url} --summary --xml-output"
+          cmd = "#{self.class.sq_bin} annotate --repodir #{shell_quote @url} --summary --xml-output"
           cmd << " --match #{shell_quote("hash #{hash}")} "
           paths = []
           shellout(cmd) do |io|
             begin
               # Darcs xml output has multiple root elements in this case (tested with darcs 1.0.7)