schacon-git 1.0.7 → 1.1.1

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,46 +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 << "--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 << "--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 << "--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 << "--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
     
@@ -125,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
@@ -139,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(' ')
@@ -157,10 +152,6 @@ module Git
           else
             hsh[key] = value
           end
-        elsif in_message && line == ''
-          in_message = false
-        else
-          in_message = true
         end
       end
       
@@ -179,7 +170,7 @@ module Git
     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}
@@ -189,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)
@@ -207,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
@@ -230,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)        
@@ -252,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
     
@@ -261,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|
@@ -306,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|
@@ -323,8 +321,7 @@ module Git
     end
 
     def config_get(name)
-      c = config_list
-      c[name]
+      config_list[name]
       #command('config', ['--get', name])
     end
     
@@ -362,46 +359,56 @@ 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.to_s if patch_file
+      arr_opts << '--' << patch_file if patch_file
       command('apply', arr_opts)
     end
     
     def apply_mail(patch_file)
       arr_opts = []
-      arr_opts << patch_file.to_s if patch_file
+      arr_opts << '--' << patch_file if patch_file
       command('am', arr_opts)
     end
     
@@ -418,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
@@ -447,23 +456,23 @@ module Git
     def checkout(branch, opts = {})
       arr_opts = []
       arr_opts << '-f' if opts[:force]
-      arr_opts << ["-b '#{opts[:new_branch]}'"] if opts[:new_branch]      
-      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
 
@@ -475,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
@@ -491,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
       
@@ -500,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
@@ -517,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)
@@ -543,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
     
@@ -552,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 = {})
@@ -574,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
     
@@ -586,43 +595,39 @@ 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, &block)
-      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} 2>&1"
+      opts = [opts].flatten.map {|s| escape(s) }.join(' ')
+      git_cmd = "git #{cmd} #{opts} #{redirect} 2>&1"
 
       out = nil
       if chdir && (Dir.getwd != path)
@@ -652,6 +657,10 @@ module Git
         `#{git_cmd}`.chomp
       end
     end
-    
+
+    def escape(s)
+      "'" + s.to_s.gsub('\'', '\'\\\'\'') + "'"
+    end
+
   end
 end

data/lib/git/log.rb

@@ -4,22 +4,20 @@ module Git
   class Log
     include Enumerable
     
-    @base = nil
-    @commits = nil
-    
-    @object = nil
-    @path = nil
-    @count = nil
-    @since = nil
-    @until = nil
-    @between = nil
-    
-    @dirty_flag = nil
-    
     def initialize(base, count = 30)
       dirty_log
       @base = base
       @count = count
+ 
+      @commits = nil
+      @author = nil
+      @grep = nil
+      @object = nil
+      @path = nil
+      @since = nil
+      @skip = nil
+      @until = nil
+      @between = nil
     end
 
     def object(objectish)
@@ -46,6 +44,12 @@ module Git
       return self
     end
     
+    def skip(num)
+      dirty_log
+      @skip = num
+      return self
+    end
+    
     def since(date)
       dirty_log
       @since = date
@@ -76,11 +80,9 @@ module Git
       @commits.size rescue nil
     end
     
-    def each
+    def each(&block)
       check_log
-      @commits.each do |c|
-        yield c
-      end
+      @commits.each(&block)
     end
     
     def first
@@ -105,11 +107,11 @@ module Git
       def run_log      
         log = @base.lib.full_log_commits(:count => @count, :object => @object, 
                                     :path_limiter => @path, :since => @since, 
-                                    :author => @author, :grep => @grep,
+                                    :author => @author, :grep => @grep, :skip => @skip,
                                     :until => @until, :between => @between)
         @commits = log.map { |c| Git::Object::Commit.new(@base, c['sha'], c) }
       end
       
   end
   
-end
+end