git 1.2.8 → 1.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aaf7dd4bc18409515ebafd5cbb88ae6b09b0cedd
-  data.tar.gz: e1514ed938b01b97f2bd47a85fec625918753c9c
+  metadata.gz: 2f8c43aab9887b1c224856449e057fa497c9d6ed
+  data.tar.gz: a607710a83056295b99a6eb5f0715109ccb4ea77
 SHA512:
-  metadata.gz: 5f4b39bd857530e4d47d16489d6749e9ab358097c06713351c94fce99b5254b4ba8da40cb5e82c167019057160a2afe6833cdff64914adfc38ed6b3b4ab5cdbf
-  data.tar.gz: 7726b6ac3a385d4904969a52c0c3718945fb47badfea35a80a7bb62130bd58f3a1bf763de1c9e16e4e063fc15ab4f113006f82154ab00832fcf289253d3f585a
+  metadata.gz: bcb2bc710c57c674a7f1d49a7c605ae86a76005a7ee55721c745b5fb215ecbc944892d7f3401420cf6af717c3744e730a6af32453d20f0a381f19dd23f67c068
+  data.tar.gz: e54136f3c5c988e9b4582fc921739de685bc5aa3ea10d2917d60bfe3c278acb8224b59c877426d718410d0a2ef92983d7066f863505f29bc4dfdcc2c15acf253

data/CHANGELOG

@@ -0,0 +1,75 @@
+== 1.2.9
+
+* Adding Git.configure (to configure the git env)
+* Adding Git.ls_remote [Git.ls_remote(repo_path_or_url='.')]
+* Adding Git.describe [repo.describe(objectish, opts)]
+* Adding Git.show [repo.show(objectish=nil, path=nil)]
+* Fixing Git::Diff to support default references (implicit references)
+* Fixing Git::Diff to support diff over git .patch files
+* Fixing Git.checkout when using :new_branch opt
+* Fixing Git::Object::Commit to preserve its sha after fetching metadata
+* Fixing Git.is_remote_branch? to actually check against remote branches
+* Improvements over how ENV variables are modified
+* Improving thrade safety (using --git-dir and --work-tree git opts)
+* Improving Git::Object::Tag. Adding annotated?, tagger and message
+* Supporting a submodule path as a valid repo
+* Git.checkout - supporting -f and -b
+* Git.clone - supporting --branch 
+* Git.fetch - supporting --prune
+* Git.tag - supporting 
+
+== 1.2.8
+
+* Keeping the old escape format for windows users
+* revparse: Supporting ref names containing SHA like substrings (40-hex strings)
+* Fix warnings on Ruby 2.1.2
+
+== 1.2.7 
+
+* Fixing mesages encoding
+* Fixing -f flag in git push
+* Fixing log parser for multiline messages
+* Supporting object references on Git.add_tag
+* Including dotfiles on Git.status
+* Git.fetch - supporting --tags
+* Git.clean - supporting -x
+* Git.add_tag options - supporting -a, -m and -s
+* Added Git.delete_tag
+
+== 1.2.6
+
+* Ruby 1.9.X/2.0 fully supported
+* JRuby 1.8/1.9 support
+* Rubinius support
+* Git.clone - supporting --recursive and --config
+* Git.log - supporting last and [] over the results
+* Git.add_remote - supporting -f and -t
+* Git.add - supporting --fore
+* Git.init - supporting --bare
+* Git.commit - supporting --all and --amend
+* Added Git.remote_remote, Git.revert and Git.clean 
+* Added Bundler to the formula
+* Travis configuration 
+* Licence included with the gem
+
+== 1.0.4
+
+* added camping/gitweb.rb frontend
+* added a number of speed-ups
+
+== 1.0.3
+
+* Sped up most of the operations
+* Added some predicate functions (commit?, tree?, etc)
+* Added a number of lower level operations (read-tree, write-tree, checkout-index, etc)
+* Fixed a bug with using bare repositories
+* Updated a good amount of the documentation
+
+== 1.0.2
+
+* Added methods to the git objects that might be helpful
+
+== 1.0.1
+
+* Initial version
+

data/README.md

@@ -57,6 +57,20 @@ Require the 'git' gem.
     require 'git'
 ```
 
+Git env config
+
+```ruby
+  Git.configure do |config|
+    # If you want to use a custom git binary
+    config.binary_path = '/git/bin/path'
+
+    # If you need to use a custom SSH Key
+    config.git_ssh = '/path/to/ssh/script'
+  end
+
+```
+
+
 Here are the operations that need read permission only.
 
 ```ruby
@@ -113,7 +127,10 @@ Here are the operations that need read permission only.
     g.grep('hello')  # implies HEAD
     g.blob('v2.5:Makefile').grep('hello')
     g.tag('v2.5').grep('hello', 'docs/')
-
+    g.describe() 
+    g.describe('0djf2aa')
+    g.describe('HEAD', {:all => true, :tags => true})
+  
     g.diff(commit1, commit2).size
     g.diff(commit1, commit2).stats
     g.gtree('v2.5').diff('v2.6').insertions
@@ -132,6 +149,15 @@ Here are the operations that need read permission only.
     g.config # returns whole config hash
 
     g.tags # returns array of Git::Tag objects
+    
+    g.show()
+    g.show('HEAD')
+    g.show('v2.8', 'README.md')
+
+    Git.ls_remote('https://github.com/schacon/ruby-git.git') # returns a hash containing the available references of the repo.
+    Git.ls_remote('/path/to/local/repo')
+    Git.ls_remote() # same as Git.ls_remote('.')
+
 ```
 
 And here are the operations that will need to write to your git repository.

data/VERSION

@@ -0,0 +1 @@
+1.2.9

data/lib/git.rb

@@ -7,6 +7,7 @@ require 'git/author'
 require 'git/base'
 require 'git/branch'
 require 'git/branches'
+require 'git/config'
 require 'git/diff'
 require 'git/index'
 require 'git/lib'
@@ -60,6 +61,14 @@ module Git
     end
   end
 
+  def self.configure
+    yield Base.config
+  end
+
+  def self.config
+    return Base.config
+  end
+
   def global_config(name = nil, value = nil)
     self.class.global_config(name, value)
   end
@@ -130,6 +139,15 @@ module Git
   def self.init(working_dir = '.', options = {})
     Base.init(working_dir, options)
   end
+    
+  # returns a Hash containing information about the references 
+  # of the target repository
+  #
+  # @param [String|NilClass] location the target repository location or nil for '.'
+  # @return [{String=>Hash}] the available references of the target repo.
+  def self.ls_remote(location=nil)
+    Git::Lib.new.ls_remote(location)
+  end
 
   # open an existing git working directory
   # 

data/lib/git/author.rb

@@ -11,4 +11,4 @@ module Git
     end
     
   end
-end
+end

data/lib/git/base.rb

@@ -1,16 +1,39 @@
+require 'git/base/factory'
+
 module Git
   
   class Base
 
+    include Git::Base::Factory
+
     # opens a bare Git Repository - no working directory options
     def self.bare(git_dir, opts = {})
       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={})
-      self.new({:working_directory => working_dir}.merge(opts))
+    # clones a git repository locally
+    #
+    #  repository - http://repo.or.cz/w/sinatra.git
+    #  name - sinatra
+    #
+    # options:
+    #   :repository
+    #
+    #    :bare
+    #   or 
+    #    :working_directory
+    #    :index_file
+    #
+    def self.clone(repository, name, opts = {})
+      # run git-clone 
+      self.new(Git::Lib.new.clone(repository, name, opts))
+    end
+    
+    # Returns (and initialize if needed) a Git::Config instance
+    #
+    # @return [Git::Config] the current config instance.
+    def self.config
+      return @@config ||= Config.new
     end
 
     # initializes a git repository
@@ -21,8 +44,8 @@ module Git
     #  :repository
     #
     def self.init(working_dir, opts = {})
-      opts[:working_directory] = working_dir if !opts[:working_directory] 
-      opts[:repository] = File.join(opts[:working_directory], '.git') if !opts[:repository]
+      opts[:working_directory] ||= working_dir 
+      opts[:repository] ||= File.join(opts[:working_directory], '.git')
       
       FileUtils.mkdir_p(opts[:working_directory]) if opts[:working_directory] && !File.directory?(opts[:working_directory])
       
@@ -31,30 +54,27 @@ module Git
       }
 
       opts.delete(:working_directory) if opts[:bare]
+      
+      # Submodules have a .git *file* not a .git folder.
+      # This file's contents point to the location of
+      # where the git refs are held (In the parent repo)
+      if File.file?('.git')
+        git_file = File.open('.git').read[8..-1].strip
+        opts[:repository] = git_file
+        opts[:index] = git_file + '/index'
+      end
 
       Git::Lib.new(opts).init(init_opts)
        
       self.new(opts)
     end
-
-    # clones a git repository locally
-    #
-    #  repository - http://repo.or.cz/w/sinatra.git
-    #  name - sinatra
-    #
-    # options:
-    #   :repository
-    #
-    #    :bare
-    #   or 
-    #    :working_directory
-    #    :index_file
-    #
-    def self.clone(repository, name, opts = {})
-      # run git-clone 
-      self.new(Git::Lib.new.clone(repository, name, opts))
+    
+    # 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={})
+      self.new({:working_directory => working_dir}.merge(opts))
     end
-        
+    
     def initialize(options = {})
       if working_dir = options[:working_directory]
         options[:repository] ||= File.join(working_dir, '.git')
@@ -71,36 +91,6 @@ module Git
       @repository = options[:repository] ? Git::Repository.new(options[:repository]) : nil 
       @index = options[:index] ? Git::Index.new(options[:index], false) : nil
     end
-  
-  
-    # returns a reference to the working directory
-    #  @git.dir.path
-    #  @git.dir.writeable?
-    def dir
-      @working_directory
-    end
-
-    # returns reference to the git repository directory
-    #  @git.dir.path
-    def repo
-      @repository
-    end
-    
-    # returns reference to the git index file
-    def index
-      @index
-    end
-    
-    
-    def set_working(work_dir, check = true)
-      @lib = nil
-      @working_directory = Git::WorkingDirectory.new(work_dir.to_s, check)
-    end
-
-    def set_index(index_file, check = true)
-      @lib = nil
-      @index = Git::Index.new(index_file.to_s, check)
-    end
     
     # changes current working directory for a block
     # to the git working directory
@@ -117,13 +107,6 @@ module Git
       end
     end
     
-    # returns the repository size in bytes
-    def repo_size
-      Dir.chdir(repo.path) do
-        return `du -s`.chomp.split.first.to_i
-      end
-    end
-    
     #g.config('user.name', 'Scott Chacon') # sets value
     #g.config('user.email', 'email@email.com')  # sets value
     #g.config('user.name')  # returns 'Scott Chacon'
@@ -140,51 +123,40 @@ module Git
         lib.config_list
       end
     end
-    
-    # factory methods
-    
-    # returns a Git::Object of the appropriate type
-    # 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.  
-    #
-    # @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 
-    def object(objectish)
-      Git::Object.new(self, objectish)
+  
+    # returns a reference to the working directory
+    #  @git.dir.path
+    #  @git.dir.writeable?
+    def dir
+      @working_directory
     end
     
-    def gtree(objectish)
-      Git::Object.new(self, objectish, 'tree')
+    # returns reference to the git index file
+    def index
+      @index
     end
-    
-    def gcommit(objectish)
-      Git::Object.new(self, objectish, 'commit')
+
+    # returns reference to the git repository directory
+    #  @git.dir.path
+    def repo
+      @repository
     end
     
-    def gblob(objectish)
-      Git::Object.new(self, objectish, 'blob')
+    # returns the repository size in bytes
+    def repo_size
+      Dir.chdir(repo.path) do
+        return `du -s`.chomp.split.first.to_i
+      end
     end
     
-    # returns a Git::Log object with count commits
-    def log(count = 30)
-      Git::Log.new(self, count)
-    end
-
-    # returns a Git::Status object
-    def status
-      Git::Status.new(self)
-    end
-        
-    # returns a Git::Branches object of all the Git::Branch objects for this repo
-    def branches
-      Git::Branches.new(self)
+    def set_index(index_file, check = true)
+      @lib = nil
+      @index = Git::Index.new(index_file.to_s, check)
     end
     
-    # returns a Git::Branch object for branch_name
-    def branch(branch_name = 'master')
-      Git::Branch.new(self, branch_name)
+    def set_working(work_dir, check = true)
+      @lib = nil
+      @working_directory = Git::WorkingDirectory.new(work_dir.to_s, check)
     end
     
     # returns +true+ if the branch exists locally
@@ -195,7 +167,7 @@ module Git
 
     # returns +true+ if the branch exists remotely
     def is_remote_branch?(branch)
-      branch_names = self.branches.local.map {|b| b.name}
+      branch_names = self.branches.remote.map {|b| b.name}
       branch_names.include?(branch)
     end
 
@@ -205,11 +177,6 @@ module Git
       branch_names.include?(branch)
     end
 
-    # returns a Git::Remote object
-    def remote(remote_name = 'origin')
-      Git::Remote.new(self, remote_name)
-    end
-
     # this is a convenience method for accessing the class that wraps all the 
     # actual 'git' forked system calls.  At some point I hope to replace the Git::Lib
     # class with one that uses native methods or libgit C bindings
@@ -240,12 +207,7 @@ module Git
       self.object('HEAD').grep(string, path_limiter, opts)
     end
     
-    # returns a Git::Diff object
-    def diff(objectish = 'HEAD', obj2 = nil)
-      Git::Diff.new(self, objectish, obj2)
-    end
-    
-    # updates the repository index using the workig dorectory content
+    # updates the repository index using the working directory content
     #
     #    @git.add('path/to/file')
     #    @git.add(['path/to/file1','path/to/file2'])
@@ -290,6 +252,25 @@ module Git
       self.lib.clean(opts)
     end
 
+    #  returns the most recent tag that is reachable from a commit
+    #
+    # options:
+    #  :all
+    #  :tags
+    #  :contains
+    #  :debug
+    #  :exact_match
+    #  :dirty
+    #  :abbrev
+    #  :candidates
+    #  :long
+    #  :always
+    #  :match
+    #
+    def describe(committish=nil, opts={})
+      self.lib.describe(committish, opts)
+    end
+
     # reverts the working directory to the provided commitish.
     # Accepts a range, such as comittish..HEAD
     #
@@ -402,11 +383,6 @@ module Git
     def tags
       self.lib.tags.map { |r| tag(r) }
     end
-    
-    # returns a Git::Tag object
-    def tag(tag_name)
-      Git::Object.new(self, tag_name, 'tag', true)
-    end
 
     # Creates a new git tag (Git::Tag)
     # Usage:
@@ -423,7 +399,7 @@ module Git
     #   
     def add_tag(name, *opts)
       self.lib.tag(name, *opts)
-      tag(name)
+      self.tag(name)
     end
  
     # deletes a tag 
@@ -454,6 +430,15 @@ module Git
     def apply_mail(file)
       self.lib.apply_mail(file) if File.exist?(file)
     end
+
+    # Shows objects
+    #
+    # @param [String|NilClass] objectish the target object reference (nil == HEAD)
+    # @param [String|NilClass] path the path of the file to be shown
+    # @return [String] the object information
+    def show(objectish=nil, path=nil)
+      self.lib.show(objectish, path)
+    end
     
     ## LOWER LEVEL INDEX OPERATIONS ##
     
@@ -492,10 +477,6 @@ module Git
       self.lib.write_tree
     end
     
-    def commit_tree(tree = nil, opts = {})
-      Git::Object::Commit.new(self, self.lib.commit_tree(tree, opts))
-    end
-    
     def write_and_commit_tree(opts = {})
       tree = write_tree
       commit_tree(tree, opts)
@@ -553,7 +534,6 @@ module Git
     def current_branch
       self.lib.branch_current
     end
-
     
   end
   

data/lib/git/base/factory.rb

@@ -0,0 +1,75 @@
+module Git
+
+  class Base
+
+    module Factory
+      
+      # returns a Git::Branch 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
+      def branches
+        Git::Branches.new(self)
+      end
+      
+      def commit_tree(tree = nil, opts = {})
+        Git::Object::Commit.new(self, self.lib.commit_tree(tree, opts))
+      end
+
+      # returns a Git::Diff object
+      def diff(objectish = 'HEAD', obj2 = nil)
+        Git::Diff.new(self, objectish, obj2)
+      end
+      
+      def gblob(objectish)
+        Git::Object.new(self, objectish, 'blob')
+      end
+      
+      def gcommit(objectish)
+        Git::Object.new(self, objectish, 'commit')
+      end
+
+      def gtree(objectish)
+        Git::Object.new(self, objectish, 'tree')
+      end
+      
+      # returns a Git::Log object with count 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 
+      # just for readability.  If you call @git.gtree('HEAD') it will
+      # 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 
+      def object(objectish)
+        Git::Object.new(self, objectish)
+      end
+  
+      # returns a Git::Remote object
+      def remote(remote_name = 'origin')
+        Git::Remote.new(self, remote_name)
+      end
+
+      # returns a Git::Status object
+      def status
+        Git::Status.new(self)
+      end
+    
+      # returns a Git::Tag object
+      def tag(tag_name)
+        Git::Object.new(self, tag_name, 'tag', true)
+      end
+
+    end
+
+  end
+
+end

data/lib/git/config.rb

@@ -0,0 +1,19 @@
+module Git
+
+  class Config
+
+    attr_writer :binary_path
+
+    attr_accessor :git_ssh
+
+    def initialize
+      @binary_path = nil
+    end
+
+    def binary_path
+      @binary_path || 'git'
+    end
+
+  end
+
+end

data/lib/git/diff.rb

@@ -6,8 +6,8 @@ module Git
     
     def initialize(base, from = nil, to = nil)
       @base = base
-      @from = from.to_s
-      @to = to.to_s
+      @from = from && from.to_s 
+      @to = to && to.to_s
 
       @path = nil
       @full_diff = nil
@@ -116,20 +116,25 @@ module Git
       
       # break up @diff_full
       def process_full_diff
+        defaults = {
+          :mode => '',
+          :src => '',
+          :dst => '',
+          :type => 'modified'
+        }
         final = {}
         current_file = nil
         @full_diff.split("\n").each do |line|
-          if m = /diff --git a\/(.*?) b\/(.*?)/.match(line)
+          if m = /^diff --git a\/(.*?) b\/(.*?)/.match(line)
             current_file = m[1]
-            final[current_file] = {:patch => line, :path => current_file, 
-                                    :mode => '', :src => '', :dst => '', :type => 'modified'}
+            final[current_file] = defaults.merge({:patch => line, :path => current_file})
           else
-            if m = /index (.......)\.\.(.......)( ......)*/.match(line)
+            if m = /^index (.......)\.\.(.......)( ......)*/.match(line)
               final[current_file][:src] = m[1]
               final[current_file][:dst] = m[2]
               final[current_file][:mode] = m[3].strip if m[3]
             end
-            if m = /(.*?) file mode (......)/.match(line)
+            if m = /^([[:alpha:]]*?) file mode (......)/.match(line)
               final[current_file][:type] = m[1]
               final[current_file][:mode] = m[2]
             end

data/lib/git/lib.rb

@@ -6,7 +6,9 @@ module Git
   end
   
   class Lib
-      
+     
+    @@semaphore = Mutex.new
+
     def initialize(base = nil, logger = nil)
       @git_dir = nil
       @git_index_file = nil
@@ -44,10 +46,13 @@ module Git
     #         {:working_directory} otherwise
     #
     # accepts options:
-    #  :remote::    name of remote (rather than 'origin')
     #  :bare::      no working directory
-    #  :recursive:: after the clone is created, initialize all submodules within, using their default settings.
+    #  :branch::    name of branch to track (rather than 'master')
     #  :depth::     the number of commits back to pull
+    #  :origin::    name of remote (same as remote)
+    #  :path::      directory where the repo will be cloned
+    #  :remote::    name of remote (rather than 'origin')
+    #  :recursive:: after the clone is created, initialize all submodules within, using their default settings.
     # 
     # TODO - make this work with SSH password or auth_key
     #
@@ -56,13 +61,15 @@ module Git
       clone_dir = opts[:path] ? File.join(@path, name) : name
       
       arr_opts = []
-      arr_opts << "--bare" if opts[:bare]
-      arr_opts << "--recursive" if opts[:recursive]
-      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 << "--config" << opts[:config] if opts[:config]
+      arr_opts << '--bare' if opts[:bare]
+      arr_opts << '--branch' << opts[:branch] if opts[:branch]
+      arr_opts << '--depth' << opts[:depth].to_i if opts[:depth] && opts[:depth].to_i > 0
+      arr_opts << '--config' << opts[:config] if opts[:config]
+      arr_opts << '--origin' << opts[:remote] || opts[:origin] if opts[:remote] || opts[:origin]
+      arr_opts << '--recursive' if opts[:recursive]
 
       arr_opts << '--'
+
       arr_opts << repository
       arr_opts << clone_dir
       
@@ -74,6 +81,49 @@ module Git
     
     ## READ COMMANDS ##
     
+    #
+    # Returns most recent tag that is reachable from a commit
+    #
+    # accepts options:
+    #  :all
+    #  :tags
+    #  :contains
+    #  :debug
+    #  :exact_match
+    #  :dirty
+    #  :abbrev
+    #  :candidates
+    #  :long
+    #  :always
+    #  :math
+    #
+    #  @param [String|NilClass] committish target commit sha or object name
+    #  @param [{Symbol=>Object}] opts the given options
+    #  @return [String] the tag name
+    #
+    def describe(committish=nil, opts={})
+      arr_opts = []
+
+      arr_opts << '--all' if opts[:all]
+      arr_opts << '--tags' if opts[:tags]
+      arr_opts << '--contains' if opts[:contains]
+      arr_opts << '--debug' if opts[:debug]
+      arr_opts << '--long' if opts[:long]
+      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 << "--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
+
+      return command('describe', arr_opts)
+    end
+
     def log_commits(opts={})
       arr_opts = log_common_options(opts)
     
@@ -150,6 +200,31 @@ module Git
 
       return hsh
     end
+
+    def tag_data(name)
+      sha = sha.to_s
+      tdata = command_lines('cat-file', ['tag', name])
+      process_tag_data(tdata, name, 0)
+    end
+
+    def process_tag_data(data, name, indent=4)
+      hsh = {
+        'name'    => name,
+        'message' => ''
+      }
+
+      loop do
+        key, *value = data.shift.split
+
+        break if key.nil?
+
+        hsh[key] = value.join(' ')
+      end
+      
+      hsh['message'] = data.collect {|line| line[indent..-1]}.join("\n") + "\n"
+
+      return hsh
+    end
     
     def process_commit_log_data(data)
       in_message = false
@@ -317,6 +392,19 @@ module Git
       hsh
     end
 
+    def ls_remote(location=nil)
+      location ||= '.'
+      Hash.new{ |h,k| h[k] = {} }.tap do |hsh|
+        command_lines('ls-remote', [location], false).each do |line|
+          (sha, info) = line.split("\t")
+          (ref, type, name) = info.split('/', 3)
+          type ||= 'head'
+          type = 'branches' if type == 'heads'
+          value = {:ref => ref, :sha => sha}
+          hsh[type].update( name.nil? ? value : { name => value })
+        end
+      end
+    end
 
     def ignored_files
       command_lines('ls-files', ['--others', '-i', '--exclude-standard'])
@@ -377,6 +465,19 @@ module Git
     def parse_config(file)
       parse_config_list command_lines('config', ['--list', '--file', file], false)
     end
+
+    # Shows objects
+    #
+    # @param [String|NilClass] objectish the target object reference (nil == HEAD)
+    # @param [String|NilClass] path the path of the file to be shown
+    # @return [String] the object information
+    def show(objectish=nil, path=nil)
+      arr_opts = []
+
+      arr_opts << (path ? "#{objectish}:#{path}" : objectish)
+      
+      command('show', arr_opts.compact)
+    end
     
     ## WRITE COMMANDS ##
         
@@ -388,7 +489,7 @@ module Git
       command('config', ['--global', name, value], false)
     end
          
-    # updates the repository index using the workig dorectory content
+    # updates the repository index using the working directory content
     # 
     #    lib.add('path/to/file')
     #    lib.add(['path/to/file1','path/to/file2'])
@@ -521,8 +622,8 @@ 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 << '-b' if opts[:new_branch] || opts[:b]
+      arr_opts << '--force' if opts[:force] || opts[:f]
       arr_opts << branch
       
       command('checkout', arr_opts)
@@ -610,6 +711,7 @@ module Git
     def fetch(remote, opts)
       arr_opts = [remote]
       arr_opts << '--tags' if opts[:t] || opts[:tags]
+      arr_opts << '--prune' if opts[:p] || opts[:prune]
 
       command('fetch', arr_opts)
     end
@@ -699,8 +801,14 @@ module Git
         opts[:add_gzip] = true
       end
       
-      file ||= Tempfile.new('archive').path
-      
+      if !file
+        tempfile = Tempfile.new('archive')
+        file = tempfile.path
+        # delete it now, before we write to it, so that Ruby doesn't delete it
+        # when it finalizes the Tempfile.
+        tempfile.close!
+      end
+
       arr_opts = []
       arr_opts << "--format=#{opts[:format]}" if opts[:format]
       arr_opts << "--prefix=#{opts[:prefix]}" if opts[:prefix]
@@ -728,42 +836,88 @@ module Git
 
 
     private
+
+    # Systen ENV variables involved in the git commands.
+    #
+    # @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 = '')
       command(cmd, opts, chdir).split("\n")
     end
     
-    def command(cmd, opts = [], chdir = true, redirect = '', &block)
+    # Takes the current git's system ENV variables and store them.
+    def store_git_system_env_variables
+      @git_system_env_variables = {}
+      ENV_VARIABLE_NAMES.each do |env_variable_name|
+        @git_system_env_variables[env_variable_name] = ENV[env_variable_name]
+      end
+    end
+
+    # Takes the previously stored git's ENV variables and set them again on ENV.
+    def restore_git_system_env_variables
+      ENV_VARIABLE_NAMES.each do |env_variable_name|
+        ENV[env_variable_name] = @git_system_env_variables[env_variable_name] 
+      end
+    end
+
+    # Sets git's ENV variables to the custom values for the current instance.
+    def set_custom_git_env_variables
       ENV['GIT_DIR'] = @git_dir
       ENV['GIT_WORK_TREE'] = @git_work_dir
       ENV['GIT_INDEX_FILE'] = @git_index_file
+      ENV['GIT_SSH'] = Git::Base.config.git_ssh
+    end
 
-      path = @git_work_dir || @git_dir || @path
-
+    # Runs a block inside an environment with customized ENV variables.
+    # It restores the ENV after execution.
+    #
+    # @param [Proc] block block to be executed within the customized environment
+    def with_custom_env_variables(&block)
+      @@semaphore.synchronize do
+        store_git_system_env_variables()
+        set_custom_git_env_variables()
+        return block.call()
+      end
+    ensure
+      restore_git_system_env_variables()
+    end
+    
+    def command(cmd, opts = [], chdir = true, redirect = '', &block)
+      global_opts = []
+      global_opts << "--git-dir=#{@git_dir}" if !@git_dir.nil?
+      global_opts << "--work-tree=#{@git_work_dir}" if !@git_work_dir.nil?
+      
       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"
+      
+      output = nil
+      
+      command_thread = nil; 
+      
+      exitstatus = nil
 
-      git_cmd = "git #{cmd} #{opts} #{redirect} 2>&1"
-
-      out = nil
-      if chdir && (Dir.getwd != path)
-        Dir.chdir(path) { out = run_command(git_cmd, &block) } 
-      else
-
-        out = run_command(git_cmd, &block)
+      with_custom_env_variables do
+        command_thread = Thread.new do 
+          output = run_command(git_cmd, &block)
+          exitstatus = $?.exitstatus
+        end
+        command_thread.join
       end
-      
+
       if @logger
         @logger.info(git_cmd)
-        @logger.debug(out)
+        @logger.debug(output)
       end
             
-      if $?.exitstatus > 0
-        if $?.exitstatus == 1 && out == ''
-          return ''
-        end
-        raise Git::GitExecuteError.new(git_cmd + ':' + out.to_s) 
+      if exitstatus > 1 || (exitstatus == 1 && output != '')
+        raise Git::GitExecuteError.new(git_cmd + ':' + output.to_s) 
       end
-      out
+
+      return output
     end
 
     # Takes the diff command line output (as Array) and parse it into a Hash
@@ -816,16 +970,13 @@ module Git
      
       arr_opts << opts[:object] if opts[:object].is_a? String
       arr_opts << '--' << opts[:path_limiter] if opts[:path_limiter]
-
       arr_opts
     end
     
     def run_command(git_cmd, &block)
-      if block_given?
-        IO.popen(git_cmd, &block)
-      else
-        `#{git_cmd}`.chomp
-      end
+      return IO.popen(git_cmd, &block) if block_given?
+      
+      `#{git_cmd}`.chomp
     end
 
     def escape(s)

data/lib/git/object.rb

@@ -217,9 +217,7 @@ module Git
       end
       
       def set_commit(data)
-        if data['sha']
-          @sha = data['sha']
-        end
+        @sha ||= data['sha']
         @committer = Git::Author.new(data['committer'])
         @author = Git::Author.new(data['author'])
         @tree = Git::Object::Tree.new(@base, data['tree'])
@@ -235,10 +233,10 @@ module Git
   
         # see if this object has been initialized and do so if not
         def check_commit
-          unless @tree
-            data = @base.lib.commit_data(@objectish)
-            set_commit(data)
-          end
+          return if @tree
+          
+          data = @base.lib.commit_data(@objectish)
+          set_commit(data)
         end
       
     end
@@ -249,11 +247,43 @@ module Git
       def initialize(base, sha, name)
         super(base, sha)
         @name = name
+        @annotated = nil
+        @loaded = false
+      end
+
+      def annotated?
+        @annotated ||= (@base.lib.object_type(self.name) == 'tag')
       end
 
+      def message
+        check_tag()
+        return @message
+      end
+      
       def tag?
         true
       end
+
+      def tagger
+        check_tag()
+        return @tagger
+      end
+
+      private
+
+      def check_tag
+        return if @loaded
+
+        if !self.annotated? 
+          @message = @tagger = nil
+        else
+          tdata = @base.lib.tag_data(@name)
+          @message = tdata['message'].chomp
+          @tagger = Git::Author.new(tdata['tagger'])
+        end
+
+        @loaded = true
+      end
         
     end
     

data/lib/git/version.rb

@@ -2,6 +2,6 @@ module Git
 
   # The current gem version
   # @return [String] the current gem version.
-  VERSION='1.2.8'
+  VERSION='1.2.9'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: git
 version: !ruby/object:Gem::Version
-  version: 1.2.8
+  version: 1.2.9
 platform: ruby
 authors:
 - Scott Chacon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-31 00:00:00.000000000 Z
+date: 2015-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -44,14 +44,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
 description: 
 email: schacon@gmail.com
 executables: []
@@ -59,13 +65,17 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- CHANGELOG
 - LICENSE
 - README.md
+- VERSION
 - lib/git.rb
 - lib/git/author.rb
 - lib/git/base.rb
+- lib/git/base/factory.rb
 - lib/git/branch.rb
 - lib/git/branches.rb
+- lib/git/config.rb
 - lib/git/diff.rb
 - lib/git/index.rb
 - lib/git/lib.rb
@@ -101,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - git 1.6.0.0, or greater
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby/Git is a Ruby library that can be used to create, read and manipulate