git 1.0.5 → 1.1.1

data/README

@@ -1,6 +1,6 @@
 == Git Library for Ruby
 
-Library for using Git in Ruby.
+Library for using Git in Ruby. Test.
 
 = Homepage
 
@@ -12,6 +12,12 @@ Git public hosting of the project source code is at:
 
 http://github/schacon/ruby-git
 
+= Install
+
+You can install Ruby/Git like this:
+
+$ sudo gem install schacon-git --source=http://gems.github.com
+
 = Major Objects
 
 Git::Base - this is the object returned from a Git.open or Git.clone.  

data/lib/git.rb

@@ -92,5 +92,19 @@ module Git
   def self.clone(repository, name, options = {})
     Base.clone(repository, name, options)
   end
+  
+  # Export the current HEAD (or a branch, if <tt>options[:branch]</tt>
+  # is specified) into the +name+ directory, then remove all traces of git from the
+  # directory.
+  #
+  # See +clone+ for options.  Does not obey the <tt>:remote</tt> option,
+  # since the .git info will be deleted anyway; always uses the default
+  # remote, 'origin.'
+  def self.export(repository, name, options = {})
+    options.delete(:remote)
+    repo = clone(repository, name, {:depth => 1}.merge(options))
+    repo.checkout("origin/#{options[:branch]}") if options[:branch]
+    Dir.chdir(repo.dir.to_s) { FileUtils.rm_r '.git' }
+  end
     
 end

data/lib/git/base.rb

@@ -2,28 +2,15 @@ module Git
   
   class Base
 
-    @working_directory = nil
-    @repository = nil
-    @index = nil
-
-    @lib = nil
-    @logger = nil
-    
     # opens a bare Git Repository - no working directory options
     def self.bare(git_dir, opts = {})
-      default = {:repository => git_dir}
-      git_options = default.merge(opts)
-      
-      self.new(git_options)
+      self.new({:repository => git_dir}.merge(opts))
     end
     
     # opens a new Git Project from a working directory
     # you can specify non-standard git_dir and index file in the options
-    def self.open(working_dir, opts={})    
-      default = {:working_directory => working_dir}
-      git_options = default.merge(opts)
-      
-      self.new(git_options)
+    def self.open(working_dir, opts={})
+      self.new({:working_directory => working_dir}.merge(opts))
     end
 
     # initializes a git repository
@@ -33,19 +20,17 @@ module Git
     #  :index_file
     #
     def self.init(working_dir, opts = {})
-      default = {:working_directory => working_dir,
-                 :repository => File.join(working_dir, '.git')}
-      git_options = default.merge(opts)
+      opts = {
+        :working_directory => working_dir,
+        :repository => File.join(working_dir, '.git')
+      }.merge(opts)
       
-      if git_options[:working_directory]
-        # if !working_dir, make it
-        FileUtils.mkdir_p(git_options[:working_directory]) if !File.directory?(git_options[:working_directory])
-      end
+      FileUtils.mkdir_p(opts[:working_directory]) if opts[:working_directory] && !File.directory?(opts[:working_directory])
       
       # run git_init there
-      Git::Lib.new(git_options).init
+      Git::Lib.new(opts).init
        
-      self.new(git_options)
+      self.new(opts)
     end
 
     # clones a git repository locally
@@ -68,17 +53,19 @@ module Git
         
     def initialize(options = {})
       if working_dir = options[:working_directory]
-        options[:repository] = File.join(working_dir, '.git') if !options[:repository]
-        options[:index] = File.join(working_dir, '.git', 'index') if !options[:index]
+        options[:repository] ||= File.join(working_dir, '.git')
+        options[:index] ||= File.join(working_dir, '.git', 'index')
       end
       if options[:log]
         @logger = options[:log]
         @logger.info("Starting Git")
+      else
+        @logger = nil
       end
-      
-      @working_directory = Git::WorkingDirectory.new(options[:working_directory]) if options[:working_directory]
-      @repository = Git::Repository.new(options[:repository]) if options[:repository]
-      @index = Git::Index.new(options[:index], false) if options[:index]
+     
+      @working_directory = options[:working_directory] ? Git::WorkingDirectory.new(options[:working_directory]) : nil
+      @repository = options[:repository] ? Git::Repository.new(options[:repository]) : nil 
+      @index = options[:index] ? Git::Index.new(options[:index], false) : nil
     end
   
   
@@ -120,7 +107,7 @@ module Git
     #    @git.add
     #    @git.commit('message')
     #  end
-    def chdir
+    def chdir # :yields: the Git::Path
       Dir.chdir(dir.path) do
         yield dir.path
       end
@@ -197,6 +184,24 @@ module Git
     def branch(branch_name = 'master')
       Git::Branch.new(self, branch_name)
     end
+    
+    # returns +true+ if the branch exists locally
+    def is_local_branch?(branch)
+      branch_names = self.branches.local.map {|b| b.name}
+      branch_names.include?(branch)
+    end
+
+    # returns +true+ if the branch exists remotely
+    def is_remote_branch?(branch)
+      branch_names = self.branches.local.map {|b| b.name}
+      branch_names.include?(branch)
+    end
+
+    # returns +true+ if the branch exists
+    def is_branch?(branch)
+      branch_names = self.branches.map {|b| b.name}
+      branch_names.include?(branch)
+    end
 
     # returns a Git::Remote object
     def remote(remote_name = 'origin')
@@ -229,8 +234,8 @@ module Git
     #       puts "\t line #{match[0]}: '#{match[1]}'"
     #     end
     #   end
-    def grep(string)
-      self.object('HEAD').grep(string)
+    def grep(string, path_limiter = nil, opts = {})
+      self.object('HEAD').grep(string, path_limiter, opts)
     end
     
     # returns a Git::Diff object
@@ -260,6 +265,11 @@ module Git
     end
 
     # commits all pending changes in the index file to the git repository
+    # 
+    # options:
+    #   :add_all
+    #   :allow_empty
+    #   :author
     def commit(message, opts = {})
       self.lib.commit(message, opts)
     end
@@ -293,8 +303,8 @@ module Git
     #
     #  @git.config('remote.remote-name.push', 'refs/heads/master:refs/heads/master')
     #
-    def push(remote = 'origin', branch = 'master')
-      self.lib.push(remote, branch)
+    def push(remote = 'origin', branch = 'master', tags = false)
+      self.lib.push(remote, branch, tags)
     end
     
     # merges one or more branches into the current working branch
@@ -305,9 +315,7 @@ module Git
     end
 
     # iterates over the files which are unmerged
-    #
-    # yields file, your_version, their_version
-    def each_conflict(&block)
+    def each_conflict(&block) # :yields: file, your_version, their_version
       self.lib.conflicts(&block)
     end
 
@@ -330,9 +338,7 @@ module Git
     #  @git.merge('scotts_git/master')
     #
     def add_remote(name, url, opts = {})
-      if url.is_a?(Git::Base)
-        url = url.repo.path
-      end
+      url = url.repo.path if url.is_a?(Git::Base)
       self.lib.remote_add(name, url, opts)
       Git::Remote.new(self, name)
     end
@@ -367,10 +373,19 @@ module Git
       self.lib.gc
     end
     
+    def apply(file)
+      if File.exists?(file)
+        self.lib.apply(file)
+      end
+    end
+    
+    def apply_mail(file)
+      self.lib.apply_mail(file) if File.exists?(file)
+    end
     
     ## LOWER LEVEL INDEX OPERATIONS ##
     
-    def with_index(new_index)
+    def with_index(new_index) # :yields: new_index
       old_index = @index
       set_index(new_index, false)
       return_value = yield @index
@@ -415,7 +430,7 @@ module Git
       self.lib.ls_files
     end
 
-    def with_working(work_dir)
+    def with_working(work_dir) # :yields: the Git::WorkingDirectory
       return_value = false
       old_working = @working_directory
       set_working(work_dir) 

data/lib/git/branch.rb

@@ -3,14 +3,12 @@ module Git
     
     attr_accessor :full, :remote, :name
     
-    @base = nil
-    @gcommit = nil
-    @stashes = nil
-    
     def initialize(base, name)
       @remote = nil
       @full = name
       @base = base
+      @gcommit = nil
+      @stashes = nil
       
       parts = name.split('/')
       if parts[1]
@@ -22,7 +20,7 @@ module Git
     end
     
     def gcommit
-      @gcommit = @base.gcommit(@full) if !@gcommit
+      @gcommit ||= @base.gcommit(@full)
       @gcommit
     end
     

data/lib/git/branches.rb

@@ -4,9 +4,6 @@ module Git
   class Branches
     include Enumerable
     
-    @base = nil
-    @branches = nil
-    
     def initialize(base)
       @branches = {}
       
@@ -31,10 +28,8 @@ module Git
       @branches.size
     end    
     
-    def each
-      @branches.each do |k, b|
-        yield b
-      end
+    def each(&block)
+      @branches.values.each(&block)
     end
     
     def [](symbol)
@@ -44,14 +39,10 @@ module Git
     def to_s
       out = ''
       @branches.each do |k, b|
-        if b.current
-          out += "* " + b.to_s + "\n"
-        else
-          out += "  " + b.to_s + "\n"
-        end
+        out << (b.current ? '* ' : '  ') << b.to_s << "\n"
       end
       out
     end
     
   end
-end
+end

data/lib/git/diff.rb

@@ -4,20 +4,17 @@ module Git
   class Diff
     include Enumerable
     
-    @base = nil
-    @from = nil
-    @to = nil
-    @path = nil
-    
-    @full_diff = nil
-    @full_diff_files = nil
-    @stats = nil
-    
     def initialize(base, from = nil, to = nil)
       @base = base
       @from = from.to_s
       @to = to.to_s
+
+      @path = nil
+      @full_diff = nil
+      @full_diff_files = nil
+      @stats = nil
     end
+    attr_reader :from, :to
     
     def path(path)
       @path = path
@@ -63,11 +60,9 @@ module Git
       @full_diff_files.assoc(key)[1]
     end
     
-    def each
+    def each(&block) # :yields: each Git::DiffFile in turn
       process_full
-      @full_diff_files.each do |file|
-        yield file[1]
-      end
+      @full_diff_files.map { |file| file[1] }.each(&block)
     end
     
     class DiffFile
@@ -82,6 +77,11 @@ module Git
         @src = hash[:src]
         @dst = hash[:dst]
         @type = hash[:type]
+        @binary = hash[:binary]
+      end
+
+      def binary?
+        !!@binary
       end
       
       def blob(type = :dst)
@@ -96,20 +96,20 @@ module Git
     private
     
       def cache_full
-        if !@full_diff
+        unless @full_diff
           @full_diff = @base.lib.diff_full(@from, @to, {:path_limiter => @path})
         end
       end
       
       def process_full
-        if !@full_diff_files
+        unless @full_diff_files
           cache_full
           @full_diff_files = process_full_diff
         end
       end
       
       def cache_stats
-        if !@stats
+        unless @stats
           @stats = @base.lib.diff_stats(@from, @to, {:path_limiter => @path})
         end
       end
@@ -133,6 +133,9 @@ module Git
               final[current_file][:type] = m[1]
               final[current_file][:mode] = m[2]
             end
+            if m = /^Binary files /.match(line)
+              final[current_file][:binary] = true
+            end
             final[current_file][:patch] << "\n" + line 
           end
         end
@@ -140,4 +143,4 @@ module Git
       end
       
   end
-end
+end

data/lib/git/lib.rb

@@ -7,14 +7,12 @@ module Git
   
   class Lib
       
-    @git_dir = nil
-    @git_index_file = nil
-    @git_work_dir = nil
-    @path = nil
-    
-    @logger = nil
-    
     def initialize(base = nil, logger = nil)
+      @git_dir = nil
+      @git_index_file = nil
+      @git_work_dir = nil
+      @path = nil
+      
       if base.is_a?(Git::Base)
         @git_dir = base.repo.path
         @git_index_file = base.index.path if base.index
@@ -24,9 +22,7 @@ module Git
         @git_index_file = base[:index] 
         @git_work_dir = base[:working_directory]
       end
-      if logger
-        @logger = logger
-      end
+      @logger = logger
     end
     
     def init
@@ -39,18 +35,22 @@ module Git
     #         {:working_directory} otherwise
     #
     # accepts options:
-    #  :remote - name of remote (rather than 'origin')
-    #  :bare   - no working directory
+    #  :remote:: name of remote (rather than 'origin')
+    #  :bare::   no working directory
+    #  :depth::  the number of commits back to pull
     # 
     # TODO - make this work with SSH password or auth_key
     #
     def clone(repository, name, opts = {})
       @path = opts[:path] || '.'
-      opts[:path] ? clone_dir = File.join(@path, name) : clone_dir = name
+      clone_dir = opts[:path] ? File.join(@path, name) : name
       
       arr_opts = []
       arr_opts << "--bare" if opts[:bare]
-      arr_opts << "-o #{opts[:remote]}" if opts[:remote]
+      arr_opts << "-o" << opts[:remote] if opts[:remote]
+      arr_opts << "--depth" << opts[:depth].to_i if opts[:depth] && opts[:depth].to_i > 0
+
+      arr_opts << '--'
       arr_opts << repository
       arr_opts << clone_dir
       
@@ -66,40 +66,41 @@ module Git
     def log_commits(opts = {})
       arr_opts = ['--pretty=oneline']
       arr_opts << "-#{opts[:count]}" if opts[:count]
-      arr_opts << "--since=\"#{opts[:since]}\"" if opts[:since].is_a? String
+      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
+      arr_opts << "--author=#{opts[:author]}" if opts[:author].is_a? String
       arr_opts << "#{opts[:between][0].to_s}..#{opts[:between][1].to_s}" if (opts[:between] && opts[:between].size == 2)
       arr_opts << opts[:object] if opts[:object].is_a? String
-      arr_opts << '-- ' + opts[:path_limiter] if opts[:path_limiter].is_a? String
-      
+      arr_opts << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
+
       command_lines('log', arr_opts, true).map { |l| l.split.first }
     end
     
     def full_log_commits(opts = {})
       arr_opts = ['--pretty=raw']
       arr_opts << "-#{opts[:count]}" if opts[:count]
-      arr_opts << "--since=\"#{opts[:since]}\"" if opts[:since].is_a? String
+      arr_opts << "--skip=#{opts[:skip]}" if opts[:skip]
+      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
+      arr_opts << "--author=#{opts[:author]}" if opts[:author].is_a? String
       arr_opts << "#{opts[:between][0].to_s}..#{opts[:between][1].to_s}" if (opts[:between] && opts[:between].size == 2)
       arr_opts << opts[:object] if opts[:object].is_a? String
-      arr_opts << '-- ' + opts[:path_limiter] if opts[:path_limiter].is_a? String
+      arr_opts << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
       
       full_log = command_lines('log', arr_opts, true)
       process_commit_data(full_log)
     end
     
     def revparse(string)
-      if /\w{40}/.match(string)  # passing in a sha - just no-op it
-        return string
+      return string if string =~ /[A-Fa-f0-9]{40}/  # passing in a sha - just no-op it
+      rev = ['head', 'remotes', 'tags'].map do |d|
+        File.join(@git_dir, 'refs', d, string)
+      end.find do |path|
+        File.file?(path)
       end
-            
-      head = File.join(@git_dir, 'refs', 'heads', string)
-      return File.read(head).chomp if File.file?(head)
-
-      head = File.join(@git_dir, 'refs', 'remotes', string)
-      return File.read(head).chomp if File.file?(head)
-      
-      head = File.join(@git_dir, 'refs', 'tags', string)
-      return File.read(head).chomp if File.file?(head)
-      
+      return File.read(rev).chomp if rev
       command('rev-parse', string)
     end
     
@@ -119,10 +120,10 @@ module Git
     def commit_data(sha)
       sha = sha.to_s
       cdata = command_lines('cat-file', ['commit', sha])
-      process_commit_data(cdata, sha)
+      process_commit_data(cdata, sha, 0)
     end
     
-    def process_commit_data(data, sha = nil)
+    def process_commit_data(data, sha = nil, indent = 4)
       in_message = false
             
       if sha
@@ -133,11 +134,11 @@ module Git
     
       data.each do |line|
         line = line.chomp
-        if in_message && line != ''
-          hsh['message'] += line + "\n"
-        end
-
-        if (line != '') && !in_message
+        if line == ''
+          in_message = !in_message
+        elsif in_message
+          hsh['message'] << line[indent..-1] << "\n"
+        else
           data = line.split
           key = data.shift
           value = data.join(' ')
@@ -151,10 +152,6 @@ module Git
           else
             hsh[key] = value
           end
-        elsif in_message && line == ''
-          in_message = false
-        else
-          in_message = true
         end
       end
       
@@ -166,14 +163,14 @@ module Git
       end
     end
     
-    def object_contents(sha)
-      command('cat-file', ['-p', sha])
+    def object_contents(sha, &block)
+      command('cat-file', ['-p', sha], &block)
     end
 
     def ls_tree(sha)
       data = {'blob' => {}, 'tree' => {}}
       
-      command_lines('ls-tree', sha.to_s).each do |line|
+      command_lines('ls-tree', sha).each do |line|
         (info, filenm) = line.split("\t")
         (mode, type, sha) = info.split
         data[type][filenm] = {:mode => mode, :sha => sha}
@@ -183,11 +180,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.to_s])
+      command_lines('ls-tree', ['-r', sha])
     end
             
     def tree_depth(sha)
@@ -201,8 +198,7 @@ module Git
     def branches_all
       arr = []
       command_lines('branch', '-a').each do |b| 
-        current = false
-        current = true if b[0, 2] == '* '
+        current = (b[0, 2] == '* ')
         arr << [b.gsub('* ', '').strip, current]
       end
       arr
@@ -224,14 +220,16 @@ module Git
     # [tree-ish] = [[line_no, match], [line_no, match2]]
     # [tree-ish] = [[line_no, match], [line_no, match2]]
     def grep(string, opts = {})
-      opts[:object] = 'HEAD' if !opts[:object]
+      opts[:object] ||= 'HEAD'
 
       grep_opts = ['-n']
       grep_opts << '-i' if opts[:ignore_case]
       grep_opts << '-v' if opts[:invert_match]
-      grep_opts << "-e '#{string}'"
+      grep_opts << '-e'
+      grep_opts << string
       grep_opts << opts[:object] if opts[:object].is_a?(String)
-      grep_opts << ('-- ' + opts[:path_limiter]) if opts[:path_limiter].is_a? String
+      grep_opts << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
+
       hsh = {}
       command_lines('grep', grep_opts).each do |line|
         if m = /(.*)\:(\d+)\:(.*)/.match(line)        
@@ -246,8 +244,8 @@ module Git
       diff_opts = ['-p']
       diff_opts << obj1
       diff_opts << obj2 if obj2.is_a?(String)
-      diff_opts << ('-- ' + opts[:path_limiter]) if opts[:path_limiter].is_a? String
-      
+      diff_opts << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
+
       command('diff', diff_opts)
     end
     
@@ -255,8 +253,8 @@ module Git
       diff_opts = ['--numstat']
       diff_opts << obj1
       diff_opts << obj2 if obj2.is_a?(String)
-      diff_opts << ('-- ' + opts[:path_limiter]) if opts[:path_limiter].is_a? String
-      
+      diff_opts << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
+
       hsh = {:total => {:insertions => 0, :deletions => 0, :lines => 0, :files => 0}, :files => {}}
       
       command_lines('diff', diff_opts).each do |file|
@@ -300,12 +298,18 @@ module Git
       command_lines('ls-files', '--stage').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
         hsh[file] = {:path => file, :mode_index => mode, :sha_index => sha, :stage => stage}
       end
       hsh
     end
 
 
+    def ignored_files
+      command_lines('ls-files', ['--others', '-i', '--exclude-standard'])
+    end
+
+
     def config_remote(name)
       hsh = {}
       config_list.each do |key, value|
@@ -317,8 +321,7 @@ module Git
     end
 
     def config_get(name)
-      c = config_list
-      c[name]
+      config_list[name]
       #command('config', ['--get', name])
     end
     
@@ -356,37 +359,59 @@ module Git
     ## WRITE COMMANDS ##
         
     def config_set(name, value)
-      command('config', [name, "'#{value}'"])
+      command('config', [name, value])
     end
           
     def add(path = '.')
-      path = path.join(' ') if path.is_a?(Array)
-      command('add', path)
+      arr_opts = ['--']
+      if path.is_a?(Array)
+        arr_opts += path
+      else
+        arr_opts << path
+      end
+      command('add', arr_opts)
     end
     
     def remove(path = '.', opts = {})
-      path = path.join(' ') if path.is_a?(Array)
-
       arr_opts = ['-f']  # overrides the up-to-date check by default
       arr_opts << ['-r'] if opts[:recursive]
-      arr_opts << path
+      arr_opts << '--'
+      if path.is_a?(Array)
+        arr_opts += path
+      else
+        arr_opts << path
+      end
 
       command('rm', arr_opts)
     end
 
     def commit(message, opts = {})
-      arr_opts = ["-m '#{message}'"]
+      arr_opts = ['-m', message]
       arr_opts << '-a' if opts[:add_all]
+      arr_opts << '--allow-empty' if opts[:allow_empty]
+      arr_opts << "--author" << opts[:author] if opts[:author]
       command('commit', arr_opts)
     end
 
     def reset(commit, opts = {})
       arr_opts = []
       arr_opts << '--hard' if opts[:hard]
-      arr_opts << commit.to_s if commit
+      arr_opts << commit if commit
       command('reset', arr_opts)
     end
     
+    def apply(patch_file)
+      arr_opts = []
+      arr_opts << '--' << patch_file if patch_file
+      command('apply', arr_opts)
+    end
+    
+    def apply_mail(patch_file)
+      arr_opts = []
+      arr_opts << '--' << patch_file if patch_file
+      command('am', arr_opts)
+    end
+    
     def stashes_all
       arr = []
       filename = File.join(@git_dir, 'logs/refs/stash')
@@ -400,14 +425,16 @@ module Git
     end
     
     def stash_save(message)
-      output = command('stash save', [message])
-      return false unless output.match(/HEAD is now at/)
-      return true
+      output = command('stash save', ['--', message])
+      output =~ /HEAD is now at/
     end
 
-    def stash_apply(id)
-      command('stash apply', [id])
-      # Already uptodate! ---???? What then
+    def stash_apply(id = nil)
+      if id
+        command('stash apply', [id])
+      else
+        command('stash apply')
+      end
     end
     
     def stash_clear
@@ -429,22 +456,23 @@ module Git
     def checkout(branch, opts = {})
       arr_opts = []
       arr_opts << '-f' if opts[:force]
-      arr_opts << branch.to_s
+      arr_opts << '-b' << opts[:new_branch] if opts[:new_branch]
+      arr_opts << branch
       
       command('checkout', arr_opts)
     end
 
     def checkout_file(version, file)
       arr_opts = []
-      arr_opts << version.to_s
-      arr_opts << file.to_s
+      arr_opts << version
+      arr_opts << file
       command('checkout', arr_opts)
     end
     
     def merge(branch, message = nil)      
       arr_opts = []
-      arr_opts << ["-m '#{message}'"] if message
-      arr_opts << branch.to_a.join(' ')
+      arr_opts << '-m' << message if message
+      arr_opts += [branch]
       command('merge', arr_opts)
     end
 
@@ -456,15 +484,13 @@ module Git
       unmerged
     end
 
-    def conflicts #yields :file, :your, :their
+    def conflicts # :yields: file, your, their
       self.unmerged.each do |f|
         your = Tempfile.new("YOUR-#{File.basename(f)}").path
-        arr_opts = [":2:#{f}", ">#{your}"]
-        command('show', arr_opts) 
+        command('show', ":2:#{f}", true, "> #{escape your}") 
 
         their = Tempfile.new("THEIR-#{File.basename(f)}").path
-        arr_opts = [":3:#{f}", ">#{their}"]
-        command('show', arr_opts) 
+        command('show', ":3:#{f}", true, "> #{escape their}") 
         yield(f, your, their)
       end
     end
@@ -472,6 +498,7 @@ module Git
     def remote_add(name, url, opts = {})
       arr_opts = ['add']
       arr_opts << '-f' if opts[:with_fetch]
+      arr_opts << '--'
       arr_opts << name
       arr_opts << url
       
@@ -481,7 +508,7 @@ module Git
     # this is documented as such, but seems broken for some reason
     # i'll try to get around it some other way later
     def remote_remove(name)
-      command('remote', ['rm', name])
+      command('remote', ['rm', '--', name])
     end
     
     def remotes
@@ -498,11 +525,12 @@ module Git
 
     
     def fetch(remote)
-      command('fetch', remote.to_s)
+      command('fetch', remote)
     end
     
-    def push(remote, branch = 'master')
-      command('push', [remote.to_s, branch.to_s])
+    def push(remote, branch = 'master', tags = false)
+      command('push', [remote, branch])
+      command('push', ['--tags', remote]) if tags
     end
     
     def tag_sha(tag_name)
@@ -524,7 +552,7 @@ module Git
     def read_tree(treeish, opts = {})
       arr_opts = []
       arr_opts << "--prefix=#{opts[:prefix]}" if opts[:prefix]
-      arr_opts << treeish.to_a.join(' ')
+      arr_opts += [treeish]
       command('read-tree', arr_opts)
     end
     
@@ -533,21 +561,20 @@ module Git
     end
     
     def commit_tree(tree, opts = {})
-      opts[:message] = "commit tree #{tree}" if !opts[:message]
+      opts[:message] ||= "commit tree #{tree}"
       t = Tempfile.new('commit-message')
       t.write(opts[:message])
       t.close
       
       arr_opts = []
       arr_opts << tree
-      arr_opts << "-p #{opts[:parent]}" if opts[:parent]
-      opts[:parents].each { |p| arr_opts << "-p #{p.to_s}" } if opts[:parents]
-      arr_opts << "< #{t.path}"
-      command('commit-tree', arr_opts)
+      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}")
     end
     
     def update_ref(branch, commit)
-      command('update-ref', [branch.to_s, commit.to_s])
+      command('update-ref', [branch, commit])
     end
     
     def checkout_index(opts = {})
@@ -555,7 +582,8 @@ module Git
       arr_opts << "--prefix=#{opts[:prefix]}" if opts[:prefix]
       arr_opts << "--force" if opts[:force]
       arr_opts << "--all" if opts[:all]
-      arr_opts << ('-- ' + opts[:path_limiter]) if opts[:path_limiter].is_a? String
+      arr_opts << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
+
       command('checkout-index', arr_opts)
     end
     
@@ -567,49 +595,45 @@ module Git
     #  :remote
     #  :path
     def archive(sha, file = nil, opts = {})
-      opts[:format] = 'zip' if !opts[:format]
+      opts[:format] ||= 'zip'
       
       if opts[:format] == 'tgz'
         opts[:format] = 'tar' 
         opts[:add_gzip] = true
       end
       
-      if !file
-        file = Tempfile.new('archive').path
-      end
+      file ||= Tempfile.new('archive').path
       
       arr_opts = []
       arr_opts << "--format=#{opts[:format]}" if opts[:format]
       arr_opts << "--prefix=#{opts[:prefix]}" if opts[:prefix]
       arr_opts << "--remote=#{opts[:remote]}" if opts[:remote]
       arr_opts << sha
-      arr_opts << opts[:path] if opts[:path]
-      arr_opts << '| gzip' if opts[:add_gzip]
-      arr_opts << "> #{file.to_s}"
-      command('archive', arr_opts)
+      arr_opts << '--' << opts[:path] if opts[:path]
+      command('archive', arr_opts, true, (opts[:add_gzip] ? '| gzip' : '') + " > #{escape file}")
       return file
     end
     
     private
     
-    def command_lines(cmd, opts = [], chdir = true)
+    def command_lines(cmd, opts = [], chdir = true, redirect = '')
       command(cmd, opts, chdir).split("\n")
     end
     
-    def command(cmd, opts = [], chdir = true)
-      ENV['GIT_DIR'] = @git_dir if (@git_dir != ENV['GIT_DIR'])
-      ENV['GIT_INDEX_FILE'] = @git_index_file if (@git_index_file != ENV['GIT_INDEX_FILE'])
-      ENV['GIT_WORK_TREE'] = @git_work_dir if (@git_work_dir != ENV['GIT_WORK_TREE'])
+    def command(cmd, opts = [], chdir = true, redirect = '', &block)
+      ENV['GIT_DIR'] = @git_dir
+      ENV['GIT_INDEX_FILE'] = @git_index_file
+      ENV['GIT_WORK_TREE'] = @git_work_dir
       path = @git_work_dir || @git_dir || @path
 
-      opts = opts.to_a.join(' ')
-      git_cmd = "git #{cmd} #{opts}"
+      opts = [opts].flatten.map {|s| escape(s) }.join(' ')
+      git_cmd = "git #{cmd} #{opts} #{redirect} 2>&1"
 
       out = nil
       if chdir && (Dir.getwd != path)
-        Dir.chdir(path) { out = `#{git_cmd} 2>&1`.chomp } 
+        Dir.chdir(path) { out = run_command(git_cmd, &block) } 
       else
-        out = `#{git_cmd} 2>&1`.chomp
+        out = run_command(git_cmd, &block)
       end
       
       if @logger
@@ -626,5 +650,17 @@ module Git
       out
     end
     
+    def run_command(git_cmd, &block)
+      if block_given?
+        IO.popen(git_cmd, &block)
+      else
+        `#{git_cmd}`.chomp
+      end
+    end
+
+    def escape(s)
+      "'" + s.to_s.gsub('\'', '\'\\\'\'') + "'"
+    end
+
   end
 end