git 1.5.0 → 1.8.1

data/lib/git/base/factory.rb

@@ -3,71 +3,97 @@ module Git
   class Base
 
     module Factory
-      
-      # returns a Git::Branch object for branch_name
+
+      # @return [Git::Branch] an object for branch_name
       def branch(branch_name = 'master')
         Git::Branch.new(self, branch_name)
       end
 
-      # returns a Git::Branches object of all the Git::Branch 
-      # objects for this repo
+      # @return [Git::Branches] a collection of all the branches in the repository.
+      #   Each branch is represented as a {Git::Branch}.
       def branches
         Git::Branches.new(self)
       end
-      
+
+      # returns a Git::Worktree object for dir, commitish
+      def worktree(dir, commitish = nil)
+        Git::Worktree.new(self, dir, commitish)
+      end
+
+      # returns a Git::worktrees object of all the Git::Worktrees
+      # objects for this repo
+      def worktrees
+        Git::Worktrees.new(self)
+      end
+
+      # @return [Git::Object::Commit] a commit object
       def commit_tree(tree = nil, opts = {})
         Git::Object::Commit.new(self, self.lib.commit_tree(tree, opts))
       end
 
-      # returns a Git::Diff object
+      # @return [Git::Diff] a Git::Diff object
       def diff(objectish = 'HEAD', obj2 = nil)
         Git::Diff.new(self, objectish, obj2)
       end
-      
+
+      # @return [Git::Object] a Git object
       def gblob(objectish)
         Git::Object.new(self, objectish, 'blob')
       end
-      
+
+      # @return [Git::Object] a Git object
       def gcommit(objectish)
         Git::Object.new(self, objectish, 'commit')
       end
 
+      # @return [Git::Object] a Git object
       def gtree(objectish)
         Git::Object.new(self, objectish, 'tree')
       end
-      
-      # returns a Git::Log object with count commits
+
+      # @return [Git::Log] a log with the specified number of commits
       def log(count = 30)
         Git::Log.new(self, count)
       end
-      
+
       # returns a Git::Object of the appropriate type
-      # you can also call @git.gtree('tree'), but that's 
+      # you can also call @git.gtree('tree'), but that's
       # just for readability.  If you call @git.gtree('HEAD') it will
-      # still return a Git::Object::Commit object.  
+      # still return a Git::Object::Commit object.
       #
-      # @git.object calls a factory method that will run a rev-parse 
-      # on the objectish and determine the type of the object and return 
-      # an appropriate object for that type 
+      # object calls a factory method that will run a rev-parse
+      # on the objectish and determine the type of the object and return
+      # an appropriate object for that type
+      #
+      # @return [Git::Object] an instance of the appropriate type of Git::Object
       def object(objectish)
         Git::Object.new(self, objectish)
       end
-  
-      # returns a Git::Remote object
+
+      # @return [Git::Remote] a remote of the specified name
       def remote(remote_name = 'origin')
         Git::Remote.new(self, remote_name)
       end
 
-      # returns a Git::Status object
+      # @return [Git::Status] a status object
       def status
         Git::Status.new(self)
       end
-    
-      # returns a Git::Tag object
+
+      # @return [Git::Object::Tag] a tag object
       def tag(tag_name)
         Git::Object.new(self, tag_name, 'tag', true)
       end
 
+      # Find as good common ancestors as possible for a merge
+      # example: g.merge_base('master', 'some_branch', 'some_sha', octopus: true)
+      #
+      # @return [Array<Git::Object::Commit>] a collection of common ancestors
+      def merge_base(*args)
+        shas = self.lib.merge_base(*args)
+        shas.map { |sha| gcommit(sha) }
+      end
+
     end
 
   end

data/lib/git/branch.rb

@@ -37,7 +37,7 @@ module Git
     #   # do other stuff
     #   return true # auto commits and switches back
     # end
-    def in_branch (message = 'in branch work')
+    def in_branch(message = 'in branch work')
       old_current = @base.lib.branch_current
       checkout
       if yield

data/lib/git/config.rb

@@ -10,7 +10,7 @@ module Git
     end
 
     def binary_path
-      @binary_path || 'git'
+      @binary_path || ENV['GIT_PATH'] && File.join(ENV['GIT_PATH'], 'git') || 'git'
     end
 
     def git_ssh

data/lib/git/diff.rb

@@ -72,6 +72,7 @@ module Git
     class DiffFile
       attr_accessor :patch, :path, :mode, :src, :dst, :type
       @base = nil
+      NIL_BLOB_REGEXP = /\A0{4,40}\z/.freeze
 
       def initialize(base, hash)
         @base = base
@@ -89,10 +90,10 @@ module Git
       end
 
       def blob(type = :dst)
-        if type == :src
-          @base.object(@src) if @src != '0000000'
-        else
-          @base.object(@dst) if @dst != '0000000'
+        if type == :src && !NIL_BLOB_REGEXP.match(@src)
+          @base.object(@src)
+        elsif !NIL_BLOB_REGEXP.match(@dst)
+          @base.object(@dst)
         end
       end
     end
@@ -127,17 +128,12 @@ module Git
         }
         final = {}
         current_file = nil
-        if @full_diff.encoding.name != "UTF-8"
-          full_diff_utf8_encoded = @full_diff.encode("UTF-8", "binary", { :invalid => :replace, :undef => :replace })
-        else
-          full_diff_utf8_encoded = @full_diff
-        end
-        full_diff_utf8_encoded.split("\n").each do |line|
+        @full_diff.split("\n").each do |line|
           if m = /^diff --git a\/(.*?) b\/(.*?)/.match(line)
             current_file = m[1]
             final[current_file] = defaults.merge({:patch => line, :path => current_file})
           else
-            if m = /^index (.......)\.\.(.......)( ......)*/.match(line)
+            if m = /^index ([0-9a-f]{4,40})\.\.([0-9a-f]{4,40})( ......)*/.match(line)
               final[current_file][:src] = m[1]
               final[current_file][:dst] = m[2]
               final[current_file][:mode] = m[3].strip if m[3]

data/lib/git/lib.rb

@@ -1,4 +1,6 @@
+require 'rchardet'
 require 'tempfile'
+require 'zlib'
 
 module Git
 
@@ -9,6 +11,43 @@ module Git
 
     @@semaphore = Mutex.new
 
+    # The path to the Git working copy.  The default is '"./.git"'.
+    #
+    # @return [Pathname] the path to the Git working copy.
+    #
+    # @see [Git working tree](https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefworkingtreeaworkingtree)
+    #
+    attr_reader :git_work_dir
+
+    # The path to the Git repository directory.  The default is
+    # `"#{git_work_dir}/.git"`.
+    #
+    # @return [Pathname] the Git repository directory.
+    #
+    # @see [Git repository](https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefrepositoryarepository)
+    #
+    attr_reader :git_dir
+
+    # The Git index file used to stage changes (using `git add`) before they
+    # are committed.
+    #
+    # @return [Pathname] the Git index file
+    #
+    # @see [Git index file](https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefindexaindex)
+    #
+    attr_reader :git_index_file
+
+    # Create a new Git::Lib object
+    #
+    # @param [Git::Base, Hash] base An object that passes in values for
+    #   @git_work_dir, @git_dir, and @git_index_file
+    #
+    # @param [Logger] logger
+    #
+    # @option base [Pathname] :working_directory
+    # @option base [Pathname] :repository
+    # @option base [Pathname] :index
+    #
     def initialize(base = nil, logger = nil)
       @git_dir = nil
       @git_index_file = nil
@@ -37,14 +76,11 @@ module Git
       arr_opts = []
       arr_opts << '--bare' if opts[:bare]
 
-      command('init', arr_opts, false)
+      command('init', arr_opts)
     end
 
     # tries to clone the given repo
     #
-    # returns {:repository} (if bare)
-    #         {:working_directory} otherwise
-    #
     # accepts options:
     #  :bare::      no working directory
     #  :branch::    name of branch to track (rather than 'master')
@@ -56,6 +92,8 @@ module Git
     #
     # TODO - make this work with SSH password or auth_key
     #
+    # @return [Hash] the options to pass to {Git::Base.new}
+    #
     def clone(repository, name, opts = {})
       @path = opts[:path] || '.'
       clone_dir = opts[:path] ? File.join(@path, name) : name
@@ -76,9 +114,16 @@ module Git
 
       command('clone', arr_opts)
 
-      (opts[:bare] or opts[:mirror]) ? {:repository => clone_dir} : {:working_directory => clone_dir}
+      return_base_opts_from_clone(clone_dir, opts)
     end
 
+    def return_base_opts_from_clone(clone_dir, opts)
+      base_opts = {}
+      base_opts[:repository] = clone_dir if (opts[:bare] || opts[:mirror])
+      base_opts[:working_directory] = clone_dir unless (opts[:bare] || opts[:mirror])
+      base_opts[:log] = opts[:log] if opts[:log]
+      base_opts
+    end
 
     ## READ COMMANDS ##
 
@@ -113,12 +158,12 @@ module Git
       arr_opts << '--always' if opts[:always]
       arr_opts << '--exact-match' if opts[:exact_match] || opts[:"exact-match"]
 
-      arr_opts << '--dirty' if opts['dirty'] == true
-      arr_opts << "--dirty=#{opts['dirty']}" if opts['dirty'].is_a?(String)
+      arr_opts << '--dirty' if opts[:dirty] == true
+      arr_opts << "--dirty=#{opts[:dirty]}" if opts[:dirty].is_a?(String)
 
-      arr_opts << "--abbrev=#{opts['abbrev']}" if opts[:abbrev]
-      arr_opts << "--candidates=#{opts['candidates']}" if opts[:candidates]
-      arr_opts << "--match=#{opts['match']}" if opts[:match]
+      arr_opts << "--abbrev=#{opts[:abbrev]}" if opts[:abbrev]
+      arr_opts << "--candidates=#{opts[:candidates]}" if opts[:candidates]
+      arr_opts << "--match=#{opts[:match]}" if opts[:match]
 
       arr_opts << committish if committish
 
@@ -132,7 +177,7 @@ module Git
 
       arr_opts += log_path_options(opts)
 
-      command_lines('log', arr_opts, true).map { |l| l.split.first }
+      command_lines('log', arr_opts).map { |l| l.split.first }
     end
 
     def full_log_commits(opts={})
@@ -143,7 +188,7 @@ module Git
 
       arr_opts += log_path_options(opts)
 
-      full_log = command_lines('log', arr_opts, true)
+      full_log = command_lines('log', arr_opts)
 
       process_commit_log_data(full_log)
     end
@@ -164,17 +209,17 @@ module Git
     end
 
     def object_type(sha)
-      command('cat-file', ['-t', sha])
+      command('cat-file', '-t', sha)
     end
 
     def object_size(sha)
-      command('cat-file', ['-s', sha]).to_i
+      command('cat-file', '-s', sha).to_i
     end
 
     # returns useful array of raw commit object data
     def commit_data(sha)
       sha = sha.to_s
-      cdata = command_lines('cat-file', ['commit', sha])
+      cdata = command_lines('cat-file', 'commit', sha)
       process_commit_data(cdata, sha, 0)
     end
 
@@ -204,7 +249,7 @@ module Git
 
     def tag_data(name)
       sha = sha.to_s
-      tdata = command_lines('cat-file', ['tag', name])
+      tdata = command_lines('cat-file', 'tag', name)
       process_tag_data(tdata, name, 0)
     end
 
@@ -242,6 +287,8 @@ module Git
           next
         end
 
+        in_message = false if in_message && line[0..3] != "    "
+
         if in_message
           hsh['message'] << "#{line[4..-1]}\n"
           next
@@ -267,7 +314,7 @@ module Git
     end
 
     def object_contents(sha, &block)
-      command('cat-file', ['-p', sha], &block)
+      command('cat-file', '-p', sha, &block)
     end
 
     def ls_tree(sha)
@@ -283,11 +330,11 @@ module Git
     end
 
     def mv(file1, file2)
-      command_lines('mv', ['--', file1, file2])
+      command_lines('mv', '--', file1, file2)
     end
 
     def full_tree(sha)
-      command_lines('ls-tree', ['-r', sha])
+      command_lines('ls-tree', '-r', sha)
     end
 
     def tree_depth(sha)
@@ -295,7 +342,7 @@ module Git
     end
 
     def change_head_branch(branch_name)
-      command('symbolic-ref', ['HEAD', "refs/heads/#{branch_name}"])
+      command('symbolic-ref', 'HEAD', "refs/heads/#{branch_name}")
     end
 
     def branches_all
@@ -307,6 +354,39 @@ module Git
       arr
     end
 
+    def worktrees_all
+      arr = []
+      directory = ''
+      # Output example for `worktree list --porcelain`:
+      # worktree /code/public/ruby-git
+      # HEAD 4bef5abbba073c77b4d0ccc1ffcd0ed7d48be5d4
+      # branch refs/heads/master
+      #
+      # worktree /tmp/worktree-1
+      # HEAD b8c63206f8d10f57892060375a86ae911fad356e
+      # detached
+      #
+      command_lines('worktree',['list', '--porcelain']).each do |w|
+        s = w.split("\s")
+        directory = s[1] if s[0] == 'worktree'
+        arr << [directory, s[1]] if s[0] == 'HEAD'
+      end
+      arr
+    end
+
+    def worktree_add(dir, commitish = nil)
+      return command('worktree', ['add', dir, commitish]) if !commitish.nil?
+      command('worktree', ['add', dir])
+    end
+
+    def worktree_remove(dir)
+      command('worktree', ['remove', dir])
+    end
+
+    def worktree_prune
+      command('worktree', ['prune'])
+    end
+
     def list_files(ref_dir)
       dir = File.join(@git_dir, 'refs', ref_dir)
       files = []
@@ -402,7 +482,7 @@ module Git
     def ls_files(location=nil)
       location ||= '.'
       hsh = {}
-      command_lines('ls-files', ['--stage', location]).each do |line|
+      command_lines('ls-files', '--stage', location).each do |line|
         (info, file) = line.split("\t")
         (mode, sha, stage) = info.split
         file = eval(file) if file =~ /^\".*\"$/ # This takes care of quoted strings returned from git
@@ -411,10 +491,13 @@ module Git
       hsh
     end
 
-    def ls_remote(location=nil)
-      location ||= '.'
+    def ls_remote(location=nil, opts={})
+      arr_opts = []
+      arr_opts << ['--refs'] if opts[:refs]
+      arr_opts << (location || '.')
+
       Hash.new{ |h,k| h[k] = {} }.tap do |hsh|
-        command_lines('ls-remote', [location], false).each do |line|
+        command_lines('ls-remote', arr_opts).each do |line|
           (sha, info) = line.split("\t")
           (ref, type, name) = info.split('/', 3)
           type ||= 'head'
@@ -426,7 +509,7 @@ module Git
     end
 
     def ignored_files
-      command_lines('ls-files', ['--others', '-i', '--exclude-standard'])
+      command_lines('ls-files', '--others', '-i', '--exclude-standard')
     end
 
 
@@ -441,8 +524,8 @@ module Git
     end
 
     def config_get(name)
-      do_get = lambda do |path|
-        command('config', ['--get', name])
+      do_get = Proc.new do |path|
+        command('config', '--get', name)
       end
 
       if @git_dir
@@ -453,12 +536,12 @@ module Git
     end
 
     def global_config_get(name)
-      command('config', ['--global', '--get', name], false)
+      command('config', '--global', '--get', name)
     end
 
     def config_list
-      build_list = lambda do |path|
-        parse_config_list command_lines('config', ['--list'])
+      build_list = Proc.new do |path|
+        parse_config_list command_lines('config', '--list')
       end
 
       if @git_dir
@@ -469,7 +552,7 @@ module Git
     end
 
     def global_config_list
-      parse_config_list command_lines('config', ['--global', '--list'], false)
+      parse_config_list command_lines('config', '--global', '--list')
     end
 
     def parse_config_list(lines)
@@ -482,7 +565,7 @@ module Git
     end
 
     def parse_config(file)
-      parse_config_list command_lines('config', ['--list', '--file', file], false)
+      parse_config_list command_lines('config', '--list', '--file', file)
     end
 
     # Shows objects
@@ -495,17 +578,17 @@ module Git
 
       arr_opts << (path ? "#{objectish}:#{path}" : objectish)
 
-      command('show', arr_opts.compact)
+      command('show', arr_opts.compact, chomp: false)
     end
 
     ## WRITE COMMANDS ##
 
     def config_set(name, value)
-      command('config', [name, value])
+      command('config', name, value)
     end
 
     def global_config_set(name, value)
-      command('config', ['--global', name, value], false)
+      command('config', '--global', name, value)
     end
 
     # updates the repository index using the working directory content
@@ -549,6 +632,19 @@ module Git
       command('rm', arr_opts)
     end
 
+    # Takes the commit message with the options and executes the commit command
+    #
+    # accepts options:
+    #  :amend
+    #  :all
+    #  :allow_empty
+    #  :author
+    #  :date
+    #  :no_verify
+    #  :allow_empty_message
+    #
+    # @param [String] message the commit message to be used
+    # @param [Hash] opts the commit options to be used
     def commit(message, opts = {})
       arr_opts = []
       arr_opts << "--message=#{message}" if message
@@ -557,6 +653,8 @@ module Git
       arr_opts << '--allow-empty' if opts[:allow_empty]
       arr_opts << "--author=#{opts[:author]}" if opts[:author]
       arr_opts << "--date=#{opts[:date]}" if opts[:date].is_a? String
+      arr_opts << '--no-verify' if opts[:no_verify]
+      arr_opts << '--allow-empty-message' if opts[:allow_empty_message]
 
       command('commit', arr_opts)
     end
@@ -615,13 +713,13 @@ module Git
     end
 
     def stash_save(message)
-      output = command('stash save', ['--', message])
+      output = command('stash save', message)
       output =~ /HEAD is now at/
     end
 
     def stash_apply(id = nil)
       if id
-        command('stash apply', [id])
+        command('stash apply', id)
       else
         command('stash apply')
       end
@@ -640,7 +738,7 @@ module Git
     end
 
     def branch_delete(branch)
-      command('branch', ['-D', branch])
+      command('branch', '-D', branch)
     end
 
     def checkout(branch, opts = {})
@@ -659,16 +757,32 @@ module Git
       command('checkout', arr_opts)
     end
 
-    def merge(branch, message = nil)
+    def merge(branch, message = nil, opts = {})
       arr_opts = []
+      arr_opts << '--no-ff' if opts[:no_ff]
       arr_opts << '-m' << message if message
       arr_opts += [branch]
       command('merge', arr_opts)
     end
 
+    def merge_base(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+
+      arg_opts = []
+
+      arg_opts << '--octopus' if opts[:octopus]
+      arg_opts << '--independent' if opts[:independent]
+      arg_opts << '--fork-point' if opts[:fork_point]
+      arg_opts << '--all' if opts[:all]
+
+      arg_opts += args
+
+      command('merge-base', arg_opts).lines.map(&:strip)
+    end
+
     def unmerged
       unmerged = []
-      command_lines('diff', ["--cached"]).each do |line|
+      command_lines('diff', "--cached").each do |line|
         unmerged << $1 if line =~ /^\* Unmerged path (.*)/
       end
       unmerged
@@ -676,11 +790,15 @@ module Git
 
     def conflicts # :yields: file, your, their
       self.unmerged.each do |f|
-        your = Tempfile.new("YOUR-#{File.basename(f)}").path
-        command('show', ":2:#{f}", true, "> #{escape your}")
-
-        their = Tempfile.new("THEIR-#{File.basename(f)}").path
-        command('show', ":3:#{f}", true, "> #{escape their}")
+        your_tempfile = Tempfile.new("YOUR-#{File.basename(f)}")
+        your = your_tempfile.path
+        your_tempfile.close # free up file for git command process
+        command('show', ":2:#{f}", redirect: "> #{escape your}")
+
+        their_tempfile = Tempfile.new("THEIR-#{File.basename(f)}")
+        their = their_tempfile.path
+        their_tempfile.close # free up file for git command process
+        command('show', ":3:#{f}", redirect: "> #{escape their}")
         yield(f, your, their)
       end
     end
@@ -705,7 +823,7 @@ module Git
     end
 
     def remote_remove(name)
-      command('remote', ['rm', name])
+      command('remote', 'rm', name)
     end
 
     def remotes
@@ -747,6 +865,7 @@ module Git
       arr_opts << opts[:ref] if opts[:ref]
       arr_opts << '--tags' if opts[:t] || opts[:tags]
       arr_opts << '--prune' if opts[:p] || opts[:prune]
+      arr_opts << '--unshallow' if opts[:unshallow]
 
       command('fetch', arr_opts)
     end
@@ -770,22 +889,22 @@ module Git
     end
 
     def pull(remote='origin', branch='master')
-      command('pull', [remote, branch])
+      command('pull', remote, branch)
     end
 
     def tag_sha(tag_name)
       head = File.join(@git_dir, 'refs', 'tags', tag_name)
       return File.read(head).chomp if File.exist?(head)
 
-      command('show-ref',  ['--tags', '-s', tag_name])
+      command('show-ref',  '--tags', '-s', tag_name)
     end
 
     def repack
-      command('repack', ['-a', '-d'])
+      command('repack', '-a', '-d')
     end
 
     def gc
-      command('gc', ['--prune', '--aggressive', '--auto'])
+      command('gc', '--prune', '--aggressive', '--auto')
     end
 
     # reads a tree into the current index file
@@ -810,11 +929,11 @@ module Git
       arr_opts << tree
       arr_opts << '-p' << opts[:parent] if opts[:parent]
       arr_opts += [opts[:parents]].map { |p| ['-p', p] }.flatten if opts[:parents]
-      command('commit-tree', arr_opts, true, "< #{escape t.path}")
+      command('commit-tree', arr_opts, redirect: "< #{escape t.path}")
     end
 
     def update_ref(branch, commit)
-      command('update-ref', [branch, commit])
+      command('update-ref', branch, commit)
     end
 
     def checkout_index(opts = {})
@@ -856,13 +975,19 @@ module Git
       arr_opts << "--remote=#{opts[:remote]}" if opts[:remote]
       arr_opts << sha
       arr_opts << '--' << opts[:path] if opts[:path]
-      command('archive', arr_opts, true, (opts[:add_gzip] ? '| gzip' : '') + " > #{escape file}")
+      command('archive', arr_opts, redirect: " > #{escape file}")
+      if opts[:add_gzip]
+        file_content = File.read(file)
+        Zlib::GzipWriter.open(file) do |gz|
+          gz.write(file_content)
+        end
+      end
       return file
     end
 
     # returns the current version of git, as an Array of Fixnums.
     def current_command_version
-      output = command('version', [], false)
+      output = command('version')
       version = output[/\d+\.\d+(\.\d+)+/]
       version.split('.').collect {|i| i.to_i}
     end
@@ -883,13 +1008,10 @@ module Git
     # @return [<String>] the names of the EVN variables involved in the git commands
     ENV_VARIABLE_NAMES = ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_INDEX_FILE', 'GIT_SSH']
 
-    def command_lines(cmd, opts = [], chdir = true, redirect = '')
-      cmd_op = command(cmd, opts, chdir)
+    def command_lines(cmd, *opts)
+      cmd_op = command(cmd, *opts)
       if cmd_op.encoding.name != "UTF-8"
-        op = cmd_op.encode("UTF-8", "binary", {
-          :invalid => :replace,
-          :undef => :replace
-        })
+        op = cmd_op.encode("UTF-8", "binary", :invalid => :replace, :undef => :replace)
       else
         op = cmd_op
       end
@@ -933,16 +1055,25 @@ module Git
       restore_git_system_env_variables()
     end
 
-    def command(cmd, opts = [], chdir = true, redirect = '', &block)
+    def command(cmd, *opts, &block)
+      command_opts = { chomp: true, redirect: '' }
+      if opts.last.is_a?(Hash)
+        command_opts.merge!(opts.pop)
+      end
+      command_opts.keys.each do |k|
+        raise ArgumentError.new("Unsupported option: #{k}") unless [:chomp, :redirect].include?(k)
+      end
+
       global_opts = []
       global_opts << "--git-dir=#{@git_dir}" if !@git_dir.nil?
       global_opts << "--work-tree=#{@git_work_dir}" if !@git_work_dir.nil?
+      global_opts << ["-c", "color.ui=false"]
 
       opts = [opts].flatten.map {|s| escape(s) }.join(' ')
 
       global_opts = global_opts.flatten.map {|s| escape(s) }.join(' ')
 
-      git_cmd = "#{Git::Base.config.binary_path} #{global_opts} #{cmd} #{opts} #{redirect} 2>&1"
+      git_cmd = "#{Git::Base.config.binary_path} #{global_opts} #{cmd} #{opts} #{command_opts[:redirect]} 2>&1"
 
       output = nil
 
@@ -963,11 +1094,12 @@ module Git
         @logger.debug(output)
       end
 
-      if exitstatus > 1 || (exitstatus == 1 && output != '')
-        raise Git::GitExecuteError.new(git_cmd + ':' + output.to_s)
-      end
+      raise Git::GitExecuteError, "#{git_cmd}:#{output}" if
+        exitstatus > 1 || (exitstatus == 1 && output != '')
+
+      output.chomp! if output && command_opts[:chomp] && !block_given?
 
-      return output
+      output
     end
 
     # Takes the diff command line output (as Array) and parse it into a Hash
@@ -976,6 +1108,8 @@ module Git
     # @param [Array] opts the diff options to be used
     # @return [Hash] the diff as Hash
     def diff_as_hash(diff_command, opts=[])
+      # update index before diffing to avoid spurious diffs
+      command('status')
       command_lines(diff_command, opts).inject({}) do |memo, line|
         info, file = line.split("\t")
         mode_src, mode_dest, sha_src, sha_dest, type = info.split
@@ -1002,6 +1136,7 @@ module Git
 
       arr_opts << "-#{opts[:count]}" if opts[:count]
       arr_opts << "--no-color"
+      arr_opts << "--cherry" if opts[:cherry]
       arr_opts << "--since=#{opts[:since]}" if opts[:since].is_a? String
       arr_opts << "--until=#{opts[:until]}" if opts[:until].is_a? String
       arr_opts << "--grep=#{opts[:grep]}" if opts[:grep].is_a? String
@@ -1023,18 +1158,54 @@ module Git
       arr_opts
     end
 
+    def default_encoding
+      __ENCODING__.name
+    end
+
+    def best_guess_encoding
+      # Encoding::ASCII_8BIT.name
+      Encoding::UTF_8.name
+    end
+
+    def detected_encoding(str)
+      CharDet.detect(str)['encoding'] || best_guess_encoding
+    end
+
+    def encoding_options
+      { invalid: :replace, undef: :replace }
+    end
+
+    def normalize_encoding(str)
+      return str if str.valid_encoding? && str.encoding.name == default_encoding
+
+      return str.encode(default_encoding, str.encoding, **encoding_options) if str.valid_encoding?
+
+      str.encode(default_encoding, detected_encoding(str), **encoding_options)
+    end
+
     def run_command(git_cmd, &block)
       return IO.popen(git_cmd, &block) if block_given?
 
-      `#{git_cmd}`.chomp
+      `#{git_cmd}`.lines.map { |l| normalize_encoding(l) }.join
     end
 
     def escape(s)
-      return "'#{s && s.to_s.gsub('\'','\'"\'"\'')}'" if RUBY_PLATFORM !~ /mingw|mswin/
+      windows_platform? ? escape_for_windows(s) : escape_for_sh(s)
+    end
+
+    def escape_for_sh(s)
+      "'#{s && s.to_s.gsub('\'','\'"\'"\'')}'"
+    end
+
+    def escape_for_windows(s)
+      # Windows does not need single quote escaping inside double quotes
+      %Q{"#{s}"}
+    end
 
-      # Keeping the old escape format for windows users
-      escaped = s.to_s.gsub('\'', '\'\\\'\'')
-      return %Q{"#{escaped}"}
+    def windows_platform?
+      # Check if on Windows via RUBY_PLATFORM (CRuby) and RUBY_DESCRIPTION (JRuby)
+      win_platform_regex = /mingw|mswin/
+      RUBY_PLATFORM =~ win_platform_regex || RUBY_DESCRIPTION =~ win_platform_regex
     end
 
   end