grit 2.4.1 → 2.5.0

data/lib/grit/git.rb

@@ -1,7 +1,10 @@
 require 'tempfile'
+require 'posix-spawn'
 module Grit
 
   class Git
+    include POSIX::Spawn
+
     class GitTimeout < RuntimeError
       attr_accessor :command
       attr_accessor :bytes_read
@@ -23,11 +26,17 @@ module Grit
       # Everything output on the command's stderr as a String.
       attr_reader :err
 
-      def initialize(command, exitstatus, err='')
-        @command = command
-        @exitstatus = exitstatus
-        @err = err
-        super "Command exited with #{exitstatus}: #{command}"
+      def initialize(command, exitstatus=nil, err='')
+        if exitstatus
+          @command = command
+          @exitstatus = exitstatus
+          @err = err
+          message = "Command failed [#{exitstatus}]: #{command}"
+          message << "\n\n" << err unless err.nil? || err.empty?
+          super message
+        else
+          super command
+        end
       end
     end
 
@@ -43,6 +52,14 @@ module Grit
       ruby_git.put_raw_object(content, type)
     end
 
+    def get_raw_object(object_id)
+      ruby_git.get_raw_object_by_sha1(object_id).content
+    end
+
+    def get_git_object(object_id)
+      ruby_git.get_raw_object_by_sha1(object_id).to_hash
+    end
+
     def object_exists?(object_id)
       ruby_git.object_exists?(object_id)
     end
@@ -67,7 +84,7 @@ module Grit
     self.git_timeout  = 10
     self.git_max_size = 5242880 # 5.megabytes
 
-    def self.with_timeout(timeout = 10.seconds)
+    def self.with_timeout(timeout = 10)
       old_timeout = Grit::Git.git_timeout
       Grit::Git.git_timeout = timeout
       yield
@@ -180,16 +197,23 @@ module Grit
 
     # Checks if the patch of a commit can be applied to the given head.
     #
+    # options     - grit command options hash
     # head_sha    - String SHA or ref to check the patch against.
     # applies_sha - String SHA of the patch.  The patch itself is retrieved
     #               with #get_patch.
     #
     # Returns 0 if the patch applies cleanly (according to `git apply`), or
     # an Integer that is the sum of the failed exit statuses.
-    def check_applies(head_sha, applies_sha)
+    def check_applies(options={}, head_sha=nil, applies_sha=nil)
+      options, head_sha, applies_sha = {}, options, head_sha if !options.is_a?(Hash)
+      options = options.dup
+      options[:env] &&= options[:env].dup
+
       git_index = create_tempfile('index', true)
-      options   = {:env => {'GIT_INDEX_FILE' => git_index}, :raise => true}
-      status    = 0
+      (options[:env] ||= {}).merge!('GIT_INDEX_FILE' => git_index)
+      options[:raise] = true
+
+      status = 0
       begin
         native(:read_tree, options.dup, head_sha)
         stdin = native(:diff, options.dup, "#{applies_sha}^", applies_sha)
@@ -202,27 +226,38 @@ module Grit
 
     # Gets a patch for a given SHA using `git diff`.
     #
+    # options     - grit command options hash
     # applies_sha - String SHA to get the patch from, using this command:
     #               `git diff #{applies_sha}^ #{applies_sha}`
     #
     # Returns the String patch from `git diff`.
-    def get_patch(applies_sha)
+    def get_patch(options={}, applies_sha=nil)
+      options, applies_sha = {}, options if !options.is_a?(Hash)
+      options = options.dup
+      options[:env] &&= options[:env].dup
+
       git_index = create_tempfile('index', true)
-      native(:diff, {
-        :env => {'GIT_INDEX_FILE' => git_index}},
-        "#{applies_sha}^", applies_sha)
+      (options[:env] ||= {}).merge!('GIT_INDEX_FILE' => git_index)
+
+      native(:diff, options, "#{applies_sha}^", applies_sha)
     end
 
     # Applies the given patch against the given SHA of the current repo.
     #
+    # options  - grit command hash
     # head_sha - String SHA or ref to apply the patch to.
     # patch    - The String patch to apply.  Get this from #get_patch.
     #
     # Returns the String Tree SHA on a successful patch application, or false.
-    def apply_patch(head_sha, patch)
+    def apply_patch(options={}, head_sha=nil, patch=nil)
+      options, head_sha, patch = {}, options, head_sha if !options.is_a?(Hash)
+      options = options.dup
+      options[:env] &&= options[:env].dup
+      options[:raise] = true
+
       git_index = create_tempfile('index', true)
+      (options[:env] ||= {}).merge!('GIT_INDEX_FILE' => git_index)
 
-      options = {:env => {'GIT_INDEX_FILE' => git_index}, :raise => true}
       begin
         native(:read_tree, options.dup, head_sha)
         native(:apply, options.merge(:cached => true, :input => patch))
@@ -252,6 +287,9 @@ module Grit
     #     :raise - When set true, commands that exit with a non-zero status
     #       raise a CommandFailed exception. This option is available only on
     #       platforms that support fork(2).
+    #     :process_info - By default, a single string with output written to
+    #       the process's stdout is returned. Setting this option to true
+    #       results in a [exitstatus, out, err] tuple being returned instead.
     # args - Non-option arguments passed on the command line.
     #
     # Optionally yields to the block an IO object attached to the child
@@ -260,7 +298,12 @@ module Grit
     # Examples
     #   git.native(:rev_list, {:max_count => 10, :header => true}, "master")
     #
-    # Returns a String with all output written to the child process's stdout.
+    # Returns a String with all output written to the child process's stdout
+    #   when the :process_info option is not set.
+    # Returns a [exitstatus, out, err] tuple when the :process_info option is
+    #   set. The exitstatus is an small integer that was the process's exit
+    #   status. The out and err elements are the data written to stdout and
+    #   stderr as Strings.
     # Raises Grit::Git::GitTimeout when the timeout is exceeded or when more
     #   than Grit::Git.git_max_size bytes are output.
     # Raises Grit::Git::CommandFailed when the :raise option is set true and the
@@ -269,12 +312,13 @@ module Grit
     #   detail about the error.
     def native(cmd, options = {}, *args, &block)
       args     = args.first if args.size == 1 && args[0].is_a?(Array)
-      args.map!    { |a| a.to_s.strip }
+      args.map!    { |a| a.to_s }
       args.reject! { |a| a.empty? }
 
       # special option arguments
       env = options.delete(:env) || {}
       raise_errors = options.delete(:raise)
+      process_info = options.delete(:process_info)
 
       # fall back to using a shell when the last argument looks like it wants to
       # start a pipeline for compatibility with previous versions of grit.
@@ -298,21 +342,24 @@ module Grit
       Grit.log(argv.join(' ')) if Grit.debug
 
       process =
-        Grit::Process.new(argv, env,
+        Child.new(env, *(argv + [{
           :input   => input,
           :chdir   => chdir,
           :timeout => (Grit::Git.git_timeout if timeout == true),
           :max     => (Grit::Git.git_max_size if timeout == true)
-        )
-      status = process.status
+        }]))
       Grit.log(process.out) if Grit.debug
       Grit.log(process.err) if Grit.debug
+
+      status = process.status
       if raise_errors && !status.success?
         raise CommandFailed.new(argv.join(' '), status.exitstatus, process.err)
+      elsif process_info
+        [status.exitstatus, process.out, process.err]
       else
         process.out
       end
-    rescue Grit::Process::TimeoutExceeded, Grit::Process::MaximumOutputExceeded
+    rescue TimeoutExceeded, MaximumOutputExceeded
       raise GitTimeout, argv.join(' ')
     end
 
@@ -404,18 +451,18 @@ module Grit
 
     def sh(command, &block)
       process =
-        Grit::Process.new(
-          command, {},
+        Child.new(
+          command,
           :timeout => Git.git_timeout,
           :max     => Git.git_max_size
         )
       [process.out, process.err]
-    rescue Grit::Process::TimeoutExceeded, Grit::Process::MaximumOutputExceeded
+    rescue TimeoutExceeded, MaximumOutputExceeded
       raise GitTimeout, command
     end
 
     def wild_sh(command, &block)
-      process = Grit::Process.new(command)
+      process = Child.new(command)
       [process.out, process.err]
     end
 

data/lib/grit/index.rb

@@ -12,6 +12,10 @@ module Grit
     # which the next commit will be based.
     attr_accessor :current_tree
 
+    # Public: if a tree or commit is written, this stores the size of that object
+    attr_reader :last_tree_size
+    attr_reader :last_commit_size
+
     # Initialize a new Index object.
     #
     # repo - The Grit::Repo to which the index belongs.
@@ -71,16 +75,16 @@ module Grit
     #           :parents        - Array of String commit SHA1s or Grit::Commit
     #                             objects to attach this commit to to form a 
     #                             new head (default: nil).
-    #           :actor          - The Grit::Actor details of the user making 
+    #           :actor          - The Grit::Actor details of the user making
     #                             the commit (default: nil).
     #           :last_tree      - The String SHA1 of a tree to compare with
-    #                             in order to avoid making empty commits 
+    #                             in order to avoid making empty commits
     #                             (default: nil).
     #           :head           - The String branch name to write this head to
-    #                             (default: "master").
-    #           :committed_date - The Time that the commit was made.  
+    #                             (default: nil).
+    #           :committed_date - The Time that the commit was made.
     #                             (Default: Time.now)
-    #           :authored_date  - The Time that the commit was authored.  
+    #           :authored_date  - The Time that the commit was authored.
     #                             (Default: committed_date)
     #
     # The legacy argument style looks like:
@@ -97,7 +101,9 @@ module Grit
     #
     # Returns a String of the SHA1 of the new commit.
     def commit(message, parents = nil, actor = nil, last_tree = nil, head = 'master')
+      commit_tree_sha = nil
       if parents.is_a?(Hash)
+        commit_tree_sha = parents[:commit_tree_sha]
         actor          = parents[:actor]
         committer      = parents[:committer]
         author         = parents[:author]
@@ -111,7 +117,11 @@ module Grit
       committer ||= actor
       author    ||= committer
 
-      tree_sha1 = write_tree(self.tree, self.current_tree)
+      if commit_tree_sha
+        tree_sha1 = commit_tree_sha
+      else
+        tree_sha1 = write_tree(self.tree, self.current_tree)
+      end
 
       # don't write identical commits
       return false if tree_sha1 == last_tree
@@ -135,9 +145,12 @@ module Grit
       contents << ''
       contents << message
 
-      commit_sha1 = self.repo.git.put_raw_object(contents.join("\n"), 'commit')
+      contents = contents.join("\n")
+      @last_commit_size = contents.size
+      commit_sha1 = self.repo.git.put_raw_object(contents, 'commit')
 
-      self.repo.update_ref(head, commit_sha1)
+      self.repo.update_ref(head, commit_sha1) if head
+      commit_sha1
     end
 
     # Recursively write a tree to the index.
@@ -149,10 +162,12 @@ module Grit
     #            this tree will be based (default: nil).
     #
     # Returns the String SHA1 String of the tree.
-    def write_tree(tree, now_tree = nil)
+    def write_tree(tree = nil, now_tree = nil)
+      tree = self.tree if !tree
       tree_contents = {}
 
       # fill in original tree
+      now_tree = read_tree(now_tree) if(now_tree && now_tree.is_a?(String))
       now_tree.contents.each do |obj|
         sha = [obj.id].pack("H*")
         k = obj.name
@@ -164,6 +179,15 @@ module Grit
       # overwrite with new tree contents
       tree.each do |k, v|
         case v
+          when Array
+            sha, mode = v
+            if sha.size == 40        # must be a sha
+              sha = [sha].pack("H*")
+              mode = mode.to_i.to_s  # leading 0s not allowed
+              k = k.split('/').last  # slashes not allowed
+              str = "%s %s\0%s" % [mode, k, sha]
+              tree_contents[k] = str
+            end
           when String
             sha = write_blob(v)
             sha = [sha].pack("H*")
@@ -181,6 +205,7 @@ module Grit
       end
 
       tr = tree_contents.sort.map { |k, v| v }.join('')
+      @last_tree_size = tr.size
       self.repo.git.put_raw_object(tr, 'tree')
     end
 

data/lib/grit/repo.rb

@@ -183,6 +183,7 @@ module Grit
         sha, type, size = line.split(" ", 3)
         parser = BATCH_PARSERS[type]
         if type == 'missing' || !parser
+          io.seek(size.to_i + 1, IO::SEEK_CUR)
           objects << nil
           next
         end
@@ -345,6 +346,21 @@ module Grit
       [ Head.find_all(self), Tag.find_all(self), Remote.find_all(self) ].flatten
     end
 
+    # returns an array of hashes representing all references
+    def refs_list
+      refs = self.git.for_each_ref
+      refarr = refs.split("\n").map do |line|
+        shatype, ref = line.split("\t")
+        sha, type = shatype.split(' ')
+        [ref, sha, type]
+      end
+      refarr
+    end
+
+    def delete_ref(ref)
+      self.git.native(:update_ref, {:d => true}, ref)
+    end
+
     def commit_stats(start = 'master', max_count = 10, skip = 0)
       options = {:max_count => max_count,
                  :skip => skip}
@@ -375,6 +391,11 @@ module Grit
       Commit.find_all(self, "#{from}..#{to}").reverse
     end
 
+    def fast_forwardable?(to, from)
+      mb = self.git.native(:merge_base, {}, [to, from]).strip
+      mb == from
+    end
+
     # The Commits objects that are newer than the specified date.
     # Commits are returned in chronological order.
     #   +start+ is the branch/commit name (default 'master')
@@ -415,23 +436,20 @@ module Grit
       repo_refs       = self.git.rev_list({}, ref).strip.split("\n")
       other_repo_refs = other_repo.git.rev_list({}, other_ref).strip.split("\n")
 
-      (other_repo_refs - repo_refs).map do |ref|
-        Commit.find_all(other_repo, ref, {:max_count => 1}).first
+      (other_repo_refs - repo_refs).map do |refn|
+        Commit.find_all(other_repo, refn, {:max_count => 1}).first
       end
     end
 
     def objects(refs)
-      Grit.no_quote = true
-      obj = self.git.rev_list({:objects => true, :timeout => false}, refs).split("\n").map { |a| a[0, 40] }
-      Grit.no_quote = false
-      obj
+      refs = refs.split(/\s+/) if refs.respond_to?(:to_str)
+      self.git.rev_list({:objects => true, :timeout => false}, *refs).
+        split("\n").map { |a| a[0, 40] }
     end
 
     def commit_objects(refs)
-      Grit.no_quote = true
-      obj = self.git.rev_list({:timeout => false}, refs).split("\n").map { |a| a[0, 40] }
-      Grit.no_quote = false
-      obj
+      refs = refs.split(/\s+/) if refs.respond_to?(:to_str)
+      self.git.rev_list({:timeout => false}, *refs).split("\n").map { |a| a[0, 40] }
     end
 
     def objects_between(ref1, ref2 = nil)
@@ -448,11 +466,10 @@ module Grit
       Grit.no_quote = true
       if parents
         # PARENTS:
-        cmd = "-r -t -m #{commit_sha}"
-        revs = self.git.diff_tree({:timeout => false}, cmd).strip.split("\n").map{ |a| r = a.split(' '); r[3] if r[1] != '160000' }
+        revs = self.git.diff_tree({:timeout => false, :r => true, :t => true, :m => true}, commit_sha).
+          strip.split("\n").map{ |a| r = a.split(' '); r[3] if r[1] != '160000' }
       else
         # NO PARENTS:
-        cmd = "-r -t #{commit_sha}"
         revs = self.git.native(:ls_tree, {:timeout => false, :r => true, :t => true}, commit_sha).
           split("\n").map{ |a| a.split("\t").first.split(' ')[2] }
       end
@@ -463,7 +480,7 @@ module Grit
 
     # The Tree object for the given treeish reference
     #   +treeish+ is the reference (default 'master')
-    #   +paths+ is an optional Array of directory paths to restrict the tree (deafult [])
+    #   +paths+ is an optional Array of directory paths to restrict the tree (default [])
     #
     # Examples
     #   repo.tree('master', ['lib/'])
@@ -473,6 +490,43 @@ module Grit
       Tree.construct(self, treeish, paths)
     end
 
+    # quick way to get a simple array of hashes of the entries
+    # of a single tree or recursive tree listing from a given
+    # sha or reference
+    #   +treeish+ is the reference (default 'master')
+    #   +options+ is a hash or options - currently only takes :recursive
+    #
+    # Examples
+    #   repo.lstree('master', :recursive => true)
+    #
+    # Returns array of hashes - one per tree entry
+    def lstree(treeish = 'master', options = {})
+      # check recursive option
+      opts = {:timeout => false, :l => true, :t => true}
+      if options[:recursive]
+        opts[:r] = true
+      end
+      # mode, type, sha, size, path
+      revs = self.git.native(:ls_tree, opts, treeish)
+      lines = revs.split("\n")
+      revs = lines.map do |a|
+        stuff, path = a.split("\t")
+        mode, type, sha, size = stuff.split(" ")
+        entry = {:mode => mode, :type => type, :sha => sha, :path => path}
+        entry[:size] = size.strip.to_i if size.strip != '-'
+        entry
+      end
+      revs
+    end
+
+    def object(sha)
+      obj = git.get_git_object(sha)
+      raw = Grit::GitRuby::Internal::RawObject.new(obj[:type], obj[:content])
+      object = Grit::GitRuby::GitObject.from_raw(raw)
+      object.sha = sha
+      object
+    end
+
     # The Blob object for the given id
     #   +id+ is the SHA1 id of the blob
     #