git 1.2.5 → 1.2.6

data/lib/git/base.rb

@@ -16,19 +16,23 @@ module Git
     # initializes a git repository
     #
     # options:
+    #  :bare
+    #  :index
     #  :repository
-    #  :index_file
     #
     def self.init(working_dir, opts = {})
-      opts = {
-        :working_directory => working_dir,
-        :repository => File.join(working_dir, '.git')
-      }.merge(opts)
+      opts[:working_directory] = working_dir if !opts[:working_directory] 
+      opts[:repository] = File.join(opts[:working_directory], '.git') if !opts[:repository]
       
       FileUtils.mkdir_p(opts[:working_directory]) if opts[:working_directory] && !File.directory?(opts[:working_directory])
       
-      # run git_init there
-      Git::Lib.new(opts).init
+      init_opts = {
+        :bare => opts[:bare]
+      }
+
+      opts.delete(:working_directory) if opts[:bare]
+
+      Git::Lib.new(opts).init(init_opts)
        
       self.new(opts)
     end
@@ -115,11 +119,9 @@ module Git
     
     # returns the repository size in bytes
     def repo_size
-      size = 0
       Dir.chdir(repo.path) do
-        (size, dot) = `du -s`.chomp.split
+        return `du -s`.chomp.split.first.to_i
       end
-      size.to_i
     end
     
     #g.config('user.name', 'Scott Chacon') # sets value
@@ -243,9 +245,23 @@ module Git
       Git::Diff.new(self, objectish, obj2)
     end
     
-    # adds files from the working directory to the git repository
-    def add(path = '.')
-      self.lib.add(path)
+    # updates the repository index using the workig dorectory content
+    #
+    #    @git.add('path/to/file')
+    #    @git.add(['path/to/file1','path/to/file2'])
+    #    @git.add(:all => true)
+    #
+    # options:
+    #   :all => true
+    #
+    # @param [String,Array] paths files paths to be added (optional, default='.')
+    # @param [Hash] options
+    def add(*args)
+      if args[0].instance_of?(String) || args[0].instance_of?(Array)
+        self.lib.add(args[0],args[1]||{})
+      else
+        self.lib.add('.', args[0]||{})
+      end
     end
 
     # removes file(s) from the git repository
@@ -264,12 +280,34 @@ module Git
       self.lib.reset(commitish, opts)
     end
 
+    # cleans the working directory
+    #
+    # options:
+    #  :force
+    #  :d
+    #
+    def clean(opts = {})
+      self.lib.clean(opts)
+    end
+
+    # reverts the working directory to the provided commitish.
+    # Accepts a range, such as comittish..HEAD
+    #
+    # options:
+    #   :no_edit
+    #
+    def revert(commitish = nil, opts = {})
+      self.lib.revert(commitish, opts)
+    end
+
     # commits all pending changes in the index file to the git repository
     # 
     # options:
-    #   :add_all
+    #   :all
     #   :allow_empty
+    #   :amend
     #   :author
+    #
     def commit(message, opts = {})
       self.lib.commit(message, opts)
     end
@@ -319,10 +357,14 @@ module Git
       self.lib.conflicts(&block)
     end
 
-    # fetches a branch from a remote and merges it into the current working branch
-    def pull(remote = 'origin', branch = 'master', message = 'origin pull')
-      fetch(remote)
-      merge(branch, message)
+    # pulls the given branch from the given remote into the current branch
+    #
+    #  @git.pull                          # pulls from origin/master
+    #  @git.pull('upstream')              # pulls from upstream/master
+    #  @git.pull('upstream', 'develope')  # pulls from upstream/develop
+    #
+    def pull(remote='origin', branch='master')
+			self.lib.pull(remote, branch)
     end
     
     # returns an array of Git:Remote objects
@@ -337,12 +379,22 @@ module Git
     #  @git.fetch('scotts_git')
     #  @git.merge('scotts_git/master')
     #
+    # Options:
+    #   :fetch => true
+    #   :track => <branch_name>
     def add_remote(name, url, opts = {})
       url = url.repo.path if url.is_a?(Git::Base)
       self.lib.remote_add(name, url, opts)
       Git::Remote.new(self, name)
     end
 
+    # removes a remote from this repository
+    #
+    # @git.remove_remote('scott_git')
+    def remove_remote(name)
+      self.lib.remote_remove(name)
+    end
+
     # returns an array of all Git::Tag objects for this repository
     def tags
       self.lib.tags.map { |r| tag(r) }
@@ -394,9 +446,17 @@ module Git
     end
     
     def with_temp_index &blk
-      tempfile = Tempfile.new('temp-index')
-      temp_path = tempfile.path
-      tempfile.unlink
+      # Workaround for JRUBY, since they handle the TempFile path different.
+      # MUST be improved to be safer and OS independent. 
+      if RUBY_PLATFORM == 'java'
+        temp_path = "/tmp/temp-index-#{(0...15).map{ ('a'..'z').to_a[rand(26)] }.join}"
+      else
+        tempfile = Tempfile.new('temp-index')
+        temp_path = tempfile.path
+        tempfile.close
+        tempfile.unlink
+      end
+
       with_index(temp_path, &blk)
     end
     
@@ -444,6 +504,7 @@ module Git
     def with_temp_working &blk
       tempfile = Tempfile.new("temp-workdir")
       temp_dir = tempfile.path
+      tempfile.close
       tempfile.unlink
       Dir.mkdir(temp_dir, 0700)
       with_working(temp_dir, &blk)

data/lib/git/branch.rb

@@ -1,22 +1,17 @@
+require 'git/path'
+
 module Git
+
   class Branch < Path
     
     attr_accessor :full, :remote, :name
     
     def initialize(base, name)
-      @remote = nil
       @full = name
       @base = base
       @gcommit = nil
       @stashes = nil
-      
-      parts = name.split('/')
-      if parts[1]
-        @remote = Git::Remote.new(@base, parts[0])
-        @name = parts[1]
-      else
-        @name = parts[0]
-      end
+      @remote, @name = parse_name(name)
     end
     
     def gcommit
@@ -100,5 +95,28 @@ module Git
         @base.lib.branch_current == @name
       end
     
+      # Given a full branch name return an Array containing the remote and branch names.
+      #
+      # Removes 'remotes' from the beggining of the name (if present).
+      # Takes the second part (splittign by '/') as the remote name.
+      # Takes the rest as the repo name (can also hold one or more '/').
+      #
+      # Example:
+      #   parse_name('master') #=> [nil, 'master']
+      #   parse_name('origin/master') #=> ['origin', 'master']
+      #   parse_name('remotes/origin/master') #=> ['origin', 'master']
+      #   parse_name('origin/master/v2') #=> ['origin', 'master/v2'] 
+      #
+      # param [String] name branch full name.
+      # return [<Git::Remote,NilClass,String>] an Array containing the remote and branch names. 
+      def parse_name(name)
+        if name.match(/^(?:remotes)?\/([^\/]+)\/(.+)/)
+          return [Git::Remote.new(@base, $1), $2]
+        end
+
+        return [nil, name]
+      end
+    
   end
+  
 end

data/lib/git/branches.rb

@@ -2,6 +2,7 @@ module Git
   
   # object that holds all the available branches
   class Branches
+
     include Enumerable
     
     def initialize(base)
@@ -32,8 +33,29 @@ module Git
       @branches.values.each(&block)
     end
     
-    def [](symbol)
-      @branches[symbol.to_s]
+    # Returns the target branch
+    #
+    # Example:
+    #   Given (git branch -a):
+    #    master
+    #    remotes/working/master
+    #
+    #   g.branches['master'].full #=> 'master'
+    #   g.branches['working/master'].full => 'remotes/working/master'
+    #   g.branches['remotes/working/master'].full => 'remotes/working/master'
+    #
+    # @param [#to_s] branch_name the target branch name.
+    # @return [Git::Branch] the target branch.
+    def [](branch_name)
+      @branches.values.inject(@branches) do |branches, branch|
+        branches[branch.full] ||= branch
+
+        # This is how Git (version 1.7.9.5) works. 
+        # Lets you ignore the 'remotes' if its at the beginning of the branch full name (even if is not a real remote branch). 
+        branches[branch.full.sub('remotes/', '')] ||= branch if branch.full =~ /^remotes\/.+/
+        
+        branches
+      end[branch_name.to_s]
     end
     
     def to_s
@@ -45,4 +67,5 @@ module Git
     end
     
   end
+
 end

data/lib/git/lib.rb

@@ -24,9 +24,18 @@ module Git
       end
       @logger = logger
     end
-    
-    def init
-      command('init')
+
+    # creates or reinitializes the repository
+    #
+    # options:
+    #   :bare
+    #   :working_directory
+    #
+    def init(opts={})
+      arr_opts = []
+      arr_opts << '--bare' if opts[:bare]
+
+      command('init', arr_opts, false)
     end
     
     # tries to clone the given repo
@@ -35,9 +44,10 @@ module Git
     #         {:working_directory} otherwise
     #
     # accepts options:
-    #  :remote:: name of remote (rather than 'origin')
-    #  :bare::   no working directory
-    #  :depth::  the number of commits back to pull
+    #  :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.
+    #  :depth::     the number of commits back to pull
     # 
     # TODO - make this work with SSH password or auth_key
     #
@@ -47,8 +57,10 @@ module Git
       
       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 << '--'
       arr_opts << repository
@@ -62,36 +74,29 @@ module Git
     
     ## READ COMMANDS ##
     
+    def log_commits(opts={})
+      arr_opts = log_common_options(opts)
     
-    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 << "#{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 << '--pretty=oneline'
+     
+      arr_opts += log_path_options(opts)
 
       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]
+    def full_log_commits(opts={})
+      arr_opts = log_common_options(opts)
+    
+      arr_opts << '--pretty=raw'
       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 += log_path_options(opts)
       
       full_log = command_lines('log', arr_opts, true)
       process_commit_data(full_log)
     end
+
+
     
     def revparse(string)
       return string if string =~ /[A-Fa-f0-9]{40}/  # passing in a sha - just no-op it
@@ -271,26 +276,12 @@ module Git
 
     # compares the index and the working directory
     def diff_files
-      hsh = {}
-      command_lines('diff-files').each do |line|
-        (info, file) = line.split("\t")
-        (mode_src, mode_dest, sha_src, sha_dest, type) = info.split
-        hsh[file] = {:path => file, :mode_file => mode_src.to_s[1, 7], :mode_index => mode_dest, 
-                      :sha_file => sha_src, :sha_index => sha_dest, :type => type}
-      end
-      hsh
+      diff_as_hash('diff-files')
     end
     
     # compares the index and the repository
     def diff_index(treeish)
-      hsh = {}
-      command_lines('diff-index', treeish).each do |line|
-        (info, file) = line.split("\t")
-        (mode_src, mode_dest, sha_src, sha_dest, type) = info.split
-        hsh[file] = {:path => file, :mode_repo => mode_src.to_s[1, 7], :mode_index => mode_dest, 
-                      :sha_repo => sha_src, :sha_index => sha_dest, :type => type}
-      end
-      hsh
+      diff_as_hash('diff-index', treeish)
     end
             
     def ls_files(location=nil)
@@ -321,7 +312,7 @@ module Git
     end
 
     def config_get(name)
-      do_get = lambda do
+      do_get = lambda do |path|
         command('config', ['--get', name])
       end
 
@@ -362,24 +353,7 @@ module Git
     end
 
     def parse_config(file)
-      hsh = {}
       parse_config_list command_lines('config', ['--list', '--file', file], false)
-      #hsh = {}
-      #file = File.expand_path(file)
-      #if File.file?(file)
-      #  current_section = nil
-      #  File.readlines(file).each do |line|
-      #    if m = /\[(\w+)\]/.match(line)
-      #      current_section = m[1]
-      #    elsif m = /\[(\w+?) "(.*?)"\]/.match(line)
-      #      current_section = "#{m[1]}.#{m[2]}"
-      #    elsif m = /(\w+?) = (.*)/.match(line)
-      #      key = "#{current_section}.#{m[1]}"
-      #      hsh[key] = m[2] 
-      #    end
-      #  end
-      #end
-      #hsh
     end
     
     ## WRITE COMMANDS ##
@@ -391,14 +365,31 @@ module Git
     def global_config_set(name, value)
       command('config', ['--global', name, value], false)
     end
-          
-    def add(path = '.')
-      arr_opts = ['--']
-      if path.is_a?(Array)
-        arr_opts += path
-      else
-        arr_opts << path
-      end
+         
+    # updates the repository index using the workig dorectory content
+    # 
+    #    lib.add('path/to/file')
+    #    lib.add(['path/to/file1','path/to/file2'])
+    #    lib.add(:all => true)
+    #
+    # options:
+    #   :all => true
+    #   :force => true
+    #
+    # @param [String,Array] paths files paths to be added to the repository
+    # @param [Hash] options
+    def add(paths='.',options={})
+      arr_opts = []
+      
+      arr_opts << '--all' if options[:all]
+      arr_opts << '--force' if options[:force]
+
+      arr_opts << '--' 
+
+      arr_opts << paths
+      
+      arr_opts.flatten!
+
       command('add', arr_opts)
     end
     
@@ -416,10 +407,13 @@ module Git
     end
 
     def commit(message, opts = {})
-      arr_opts = ['-m', message]
-      arr_opts << '-a' if opts[:add_all]
+      arr_opts = []
+      arr_opts << "--message=#{message}" if message
+      arr_opts << '--amend' << '--no-edit' if opts[:amend]
+      arr_opts << '--all' if opts[:add_all] || opts[:all] 
       arr_opts << '--allow-empty' if opts[:allow_empty]
-      arr_opts << "--author" << opts[:author] if opts[:author]
+      arr_opts << "--author=#{opts[:author]}" if opts[:author]
+      
       command('commit', arr_opts)
     end
 
@@ -429,7 +423,26 @@ module Git
       arr_opts << commit if commit
       command('reset', arr_opts)
     end
+
+    def clean(opts = {})
+      arr_opts = [] 
+      arr_opts << '--force' if opts[:force]
+      arr_opts << '-d' if opts[:d]
+      
+      command('clean', arr_opts)
+    end
     
+    def revert(commitish, opts = {})
+      # Forcing --no-edit as default since it's not an interactive session.
+      opts = {:no_edit => true}.merge(opts)
+      
+      arr_opts = []
+      arr_opts << '--no-edit' if opts[:no_edit] 
+      arr_opts << commitish
+
+      command('revert', arr_opts)
+    end
+
     def apply(patch_file)
       arr_opts = []
       arr_opts << '--' << patch_file if patch_file
@@ -527,7 +540,8 @@ module Git
 
     def remote_add(name, url, opts = {})
       arr_opts = ['add']
-      arr_opts << '-f' if opts[:with_fetch]
+      arr_opts << '-f' if opts[:with_fetch] || opts[:fetch]
+      arr_opts << '-t' << opts[:track] if opts[:track]
       arr_opts << '--'
       arr_opts << name
       arr_opts << url
@@ -535,10 +549,8 @@ module Git
       command('remote', arr_opts)
     end
     
-    # 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
@@ -562,7 +574,11 @@ module Git
       command('push', [remote, branch])
       command('push', ['--tags', remote]) if tags
     end
-    
+
+		def pull(remote='origin', branch='master')
+			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.exists?(head)
@@ -674,11 +690,13 @@ module Git
     
     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
+      ENV['GIT_INDEX_FILE'] = @git_index_file
+
       path = @git_work_dir || @git_dir || @path
 
       opts = [opts].flatten.map {|s| escape(s) }.join(' ')
+
       git_cmd = "git #{cmd} #{opts} #{redirect} 2>&1"
 
       out = nil
@@ -701,6 +719,60 @@ module Git
       end
       out
     end
+
+    # Takes the diff command line output (as Array) and parse it into a Hash
+    #
+    # @param [String] diff_command the diff commadn to be used
+    # @param [Array] opts the diff options to be used
+    # @return [Hash] the diff as Hash
+    def diff_as_hash(diff_command, opts=[])
+      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
+        
+        memo[file] = {
+          :mode_index => mode_dest, 
+          :mode_repo => mode_src.to_s[1, 7], 
+          :path => file, 
+          :sha_repo => sha_src, 
+          :sha_index => sha_dest, 
+          :type => type
+        }
+
+        memo
+      end
+    end
+    
+    # Returns an array holding the common options for the log commands 
+    #
+    # @param [Hash] opts the given options
+    # @return [Array] the set of common options that the log command will use
+    def log_common_options(opts)
+      arr_opts = []
+
+      arr_opts << "-#{opts[:count]}" if opts[:count]
+      arr_opts << "--no-color"
+      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
+    end
+    
+    # Retrurns an array holding path options for the log commands
+    #
+    # @param [Hash] opts the given options
+    # @return [Array] the set of path options that the log command will use
+    def log_path_options(opts)
+      arr_opts = []
+     
+      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?