grit 2.3.0 → 2.4.0

data/History.txt

@@ -1,3 +1,38 @@
+== 2.4.0 / 2011-01-06
+  * Major Enhancements
+    * Add support for parsing git notes.
+    * Add `git cat-file --batch` support with Grit::Repo#batch.
+    * Grit::Process is a custom written external command invocation heavily
+      optimized for running git commands quickly and efficiently.
+    * Grit::Git#native takes an :input option for piping data into git
+      commands
+    * Grit::Git#native takes an :env option for setting the git child
+      process's
+      environment without futsing with the parent's environment.
+    * Grit::Git#native takes an :chdir option for setting the current working
+      directory (PWD) of the git child process.
+    * Grit::Git#native takes an :raise => true option that causes an exception
+      to be raised when the git child process exits non-zero.
+  * Minor Enhancements
+    * Grit::Index#commit supports custom committer/author names and dates.
+    * Performance enhancements with internal command output buffering.
+    * Reduce fork/execs needed to execute a smoke command from between 3-4
+      to 1.
+    * Git child processes are now properly parented under the grit Ruby
+      process instead of being dropped under init.
+  * Bug Fixes
+    * Zero-Padding issue in Grit::Index was fixed.
+    * Fix issue where Repo#diff skips the first diff (#42)
+    * Fix Repo.init_bare for repo names not ending in .git (#40)
+    * Fix a variety of process hangs when git stderr output or data written
+      to stdin exceeded PIPE_BUF bytes.
+
+== 2.3.2 / 2011-01-06
+  * Erroneously released. SemVer violation and misc release screwups.
+
+== 2.3.1
+  * Skipped for unknown reasons.
+
 == 2.3.0 / 2010-09-29
   * Minor Enhancements
     * Add Grit::Repo.init.

data/grit.gemspec

@@ -4,8 +4,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = '1.3.5'
 
   s.name              = 'grit'
-  s.version           = '2.3.0'
-  s.date              = '2010-09-29'
+  s.version           = '2.4.0'
+  s.date              = '2011-01-06'
   s.rubyforge_project = 'grit'
 
   s.summary     = "Ruby Git bindings."
@@ -59,9 +59,10 @@ Gem::Specification.new do |s|
     lib/grit/git-ruby/repository.rb
     lib/grit/git.rb
     lib/grit/index.rb
+    lib/grit/jruby.rb
     lib/grit/lazy.rb
     lib/grit/merge.rb
-    lib/grit/open3_detach.rb
+    lib/grit/process.rb
     lib/grit/ref.rb
     lib/grit/repo.rb
     lib/grit/ruby1.9.rb

data/lib/grit.rb

@@ -9,27 +9,26 @@ require 'timeout'
 require 'logger'
 require 'digest/sha1'
 
-if defined? RUBY_ENGINE && RUBY_ENGINE == 'jruby'
-  require 'open3'
-elsif RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
-  require 'win32/open3'
-else
-  require 'grit/open3_detach'
-end
-
 # third party
-require 'rubygems'
+
 begin
-  gem "mime-types", ">=0"
   require 'mime/types'
-rescue Gem::LoadError => e
-  puts "WARNING: Gem LoadError: #{e.message}"
+  require 'rubygems'
+rescue LoadError
+  require 'rubygems'
+  begin
+    gem "mime-types", ">=0"
+    require 'mime/types'
+  rescue Gem::LoadError => e
+    puts "WARNING: Gem LoadError: #{e.message}"
+  end
 end
 
 # ruby 1.9 compatibility
 require 'grit/ruby1.9'
 
 # internal requires
+require 'grit/process'
 require 'grit/lazy'
 require 'grit/errors'
 require 'grit/git-ruby'
@@ -50,8 +49,13 @@ require 'grit/submodule'
 require 'grit/blame'
 require 'grit/merge'
 
+# platform specific requires
+if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
+  require 'grit/jruby'
+end
+
 module Grit
-  VERSION = '2.3.0'
+  VERSION = '2.4.0'
 
   class << self
     # Set +debug+ to true to log all git calls and responses

data/lib/grit/actor.rb

@@ -11,12 +11,10 @@ module Grit
     alias_method :to_s, :name
 
     # Create an Actor from a string.
-    #   +str+ is the string, which is expected to be in regular git format
     #
-    # Format
-    #   John Doe <jdoe@example.com>
+    # str - The String in this format: 'John Doe <jdoe@example.com>'
     #
-    # Returns Actor
+    # Returns Git::Actor.
     def self.from_string(str)
       case str
         when /<.+>/
@@ -27,6 +25,24 @@ module Grit
       end
     end
 
+    # Outputs an actor string for Git commits.
+    #
+    #   actor = Actor.new('bob', 'bob@email.com')
+    #   actor.output(time) # => "bob <bob@email.com> UNIX_TIME +0700"
+    #
+    # time - The Time the commit was authored or committed.
+    #
+    # Returns a String.
+    def output(time)
+      out = @name.to_s.dup
+      if @email
+        out << " <#{@email}>"
+      end
+      hours = (time.utc_offset.to_f / 3600).to_i # 60 * 60, seconds to hours
+      rem   = time.utc_offset.abs % 3600
+      out << " #{time.to_i} #{hours >= 0 ? :+ : :-}#{hours.abs.to_s.rjust(2, '0')}#{rem.to_s.rjust(2, '0')}"
+    end
+
     # Pretty object inspection
     def inspect
       %Q{#<Grit::Actor "#{@name} <#{@email}>">}

data/lib/grit/blame.rb

@@ -26,16 +26,21 @@ module Grit
         if line[0, 1] == "\t"
           lines << line[1, line.size]
         elsif m = /^(\w{40}) (\d+) (\d+)/.match(line)
-          if !commits[m[1]]
-            commits[m[1]] = @repo.commit(m[1])
-          end
-          info[m[3].to_i] = [commits[m[1]], m[2].to_i]
+          commit_id, old_lineno, lineno = m[1], m[2].to_i, m[3].to_i
+          commits[commit_id] = nil if !commits.key?(commit_id)
+          info[lineno] = [commit_id, old_lineno]
         end
       end
 
+      # load all commits in single call
+      @repo.batch(*commits.keys).each do |commit|
+        commits[commit.id] = commit
+      end
+
       # get it together
-      info.sort.each do |lineno, commit|
-        final << BlameLine.new(lineno, commit[1], commit[0], lines[lineno - 1])
+      info.sort.each do |lineno, (commit_id, old_lineno)|
+        commit = commits[commit_id]
+        final << BlameLine.new(lineno, old_lineno, commit, lines[lineno - 1])
       end
 
       @lines = final
@@ -58,4 +63,4 @@ module Grit
 
   end # Blame
 
-end # Grit
+end # Grit

data/lib/grit/commit.rb

@@ -1,6 +1,8 @@
 module Grit
 
   class Commit
+    extend Lazy
+
     attr_reader :id
     attr_reader :repo
     lazy_reader :parents
@@ -13,6 +15,31 @@ module Grit
     lazy_reader :short_message
     lazy_reader :author_string
 
+    # Parses output from the `git-cat-file --batch'.
+    #
+    # repo   - Grit::Repo instance.
+    # sha    - String SHA of the Commit.
+    # size   - Fixnum size of the object.
+    # object - Parsed String output from `git cat-file --batch`.
+    #
+    # Returns an Array of Grit::Commit objects.
+    def self.parse_batch(repo, sha, size, object)
+      info, message = object.split("\n\n", 2)
+
+      lines = info.split("\n")
+      tree = lines.shift.split(' ', 2).last
+      parents = []
+      parents << lines.shift[7..-1] while lines.first[0, 6] == 'parent'
+      author,    authored_date  = Grit::Commit.actor(lines.shift)
+      committer, committed_date = Grit::Commit.actor(lines.shift)
+
+      Grit::Commit.new(
+        repo, sha, parents, tree,
+        author, authored_date,
+        committer, committed_date,
+        message.to_s.split("\n"))
+    end
+
     # Instantiate a new Commit
     #   +id+ is the id of the commit
     #   +parents+ is an array of commit ids (will be converted into Commit instances)
@@ -167,7 +194,7 @@ module Grit
 
     def show
       if parents.size > 1
-        diff = @repo.git.native("diff #{parents[0].id}...#{parents[1].id}", {:full_index => true})
+        diff = @repo.git.native(:diff, {:full_index => true}, "#{parents[0].id}...#{parents[1].id}")
       else
         diff = @repo.git.show({:full_index => true, :pretty => 'raw'}, @id)
       end
@@ -214,6 +241,17 @@ module Grit
       @repo.git.format_patch({'1' => true, :stdout => true}, to_s)
     end
 
+    def notes
+      ret = {}
+      notes = Note.find_all(@repo)
+      notes.each do |note|
+        if n = note.commit.tree/(self.id)
+          ret[note.name] = n.data
+        end
+      end
+      ret
+    end
+
     # Pretty object inspection
     def inspect
       %Q{#<Grit::Commit "#{@id}">}

data/lib/grit/git-ruby/internal/pack.rb

@@ -317,7 +317,7 @@ module Grit
               if indata.size == 0
                 raise PackFormatError, 'error reading pack data'
               end
-              outdata += zstr.inflate(indata)
+              outdata << zstr.inflate(indata)
             end
             if outdata.size > destsize
               raise PackFormatError, 'error reading pack data'
@@ -351,9 +351,9 @@ module Grit
               cp_size |= delta.getord(pos += 1) << 16 if c & 0x40 != 0
               cp_size = 0x10000 if cp_size == 0
               pos += 1
-              dest += base[cp_off,cp_size]
+              dest << base[cp_off,cp_size]
             elsif c != 0
-              dest += delta[pos,c]
+              dest << delta[pos,c]
               pos += c
             else
               raise PackFormatError, 'invalid delta data'

data/lib/grit/git-ruby/repository.rb

@@ -701,21 +701,35 @@ module Grit
           @loose
         end
 
-        def load_alternate_loose(path)
-          # load alternate loose, too
+        def each_alternate_path(path)
           alt = File.join(path, 'info/alternates')
-          if File.exists?(alt)
-            File.readlines(alt).each do |line|
-              next if @loaded.include?(line.chomp)
-              if line[0, 2] == '..'
-                line = File.expand_path(File.join(@git_dir, line))
-              end
-              load_loose(line.chomp)
-              load_alternate_loose(line.chomp)
+          return if !File.exists?(alt)
+
+          File.readlines(alt).each do |line|
+            path = line.chomp
+            if path[0, 2] == '..'
+              yield File.expand_path(File.join(@git_dir, 'objects', path))
+
+              # XXX this is here for backward compatibility with grit < 2.3.0
+              # relative alternate objects paths are expanded relative to the
+              # objects directory, not the git repository directory.
+              yield File.expand_path(File.join(@git_dir, path))
+            else
+              yield path
             end
           end
         end
 
+        def load_alternate_loose(path)
+          # load alternate loose, too
+          each_alternate_path path do |path|
+            next if @loaded.include?(path)
+            next if !File.exist?(path)
+            load_loose(path)
+            load_alternate_loose(path)
+          end
+        end
+
         def load_loose(path)
           @loaded << path
           return if !File.exists?(path)
@@ -732,17 +746,11 @@ module Grit
         end
 
         def load_alternate_packs(path)
-          alt = File.join(path, 'info/alternates')
-          if File.exists?(alt)
-            File.readlines(alt).each do |line|
-              if line[0, 2] == '..'
-                line = File.expand_path(File.join(@git_dir, line))
-              end
-              full_pack = File.join(line.chomp, 'pack')
-              next if @loaded_packs.include?(full_pack)
-              load_packs(full_pack)
-              load_alternate_packs(File.join(line.chomp))
-            end
+          each_alternate_path path do |path|
+            full_pack = File.join(path, 'pack')
+            next if @loaded_packs.include?(full_pack)
+            load_packs(full_pack)
+            load_alternate_packs(path)
           end
         end
 

data/lib/grit/git.rb

@@ -3,7 +3,8 @@ module Grit
 
   class Git
     class GitTimeout < RuntimeError
-      attr_reader :command, :bytes_read
+      attr_accessor :command
+      attr_accessor :bytes_read
 
       def initialize(command = nil, bytes_read = nil)
         @command = command
@@ -11,6 +12,25 @@ module Grit
       end
     end
 
+    # Raised when a native git command exits with non-zero.
+    class CommandFailed < StandardError
+      # The full git command that failed as a String.
+      attr_reader :command
+
+      # The integer exit status.
+      attr_reader :exitstatus
+
+      # 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}"
+      end
+    end
+
     undef_method :clone
 
     include GitRuby
@@ -34,14 +54,16 @@ module Grit
     end
 
     class << self
-      attr_accessor :git_binary, :git_timeout, :git_max_size
+      attr_accessor :git_timeout, :git_max_size
+      def git_binary
+        @git_binary ||=
+          ENV['PATH'].split(':').
+            map  { |p| File.join(p, 'git') }.
+            find { |p| File.exist?(p) }
+      end
+      attr_writer :git_binary
     end
 
-    if RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
-      self.git_binary   = "git" # using search path
-    else
-      self.git_binary   = "/usr/bin/env git"
-    end
     self.git_timeout  = 10
     self.git_max_size = 5242880 # 5.megabytes
 
@@ -206,35 +228,157 @@ module Grit
     # RAW CALLS WITH ENV SETTINGS END
 
 
-
-    # Run the given git command with the specified arguments and return
-    # the result as a String
-    #   +cmd+ is the command
-    #   +options+ is a hash of Ruby style options
-    #   +args+ is the list of arguments (to be joined by spaces)
+    # Execute a git command, bypassing any library implementation.
+    #
+    # cmd - The name of the git command as a Symbol. Underscores are
+    #   converted to dashes as in :rev_parse => 'rev-parse'.
+    # options - Command line option arguments passed to the git command.
+    #   Single char keys are converted to short options (:a => -a).
+    #   Multi-char keys are converted to long options (:arg => '--arg').
+    #   Underscores in keys are converted to dashes. These special options
+    #   are used to control command execution and are not passed in command
+    #   invocation:
+    #     :timeout - Maximum amount of time the command can run for before
+    #       being aborted. When true, use Grit::Git.git_timeout; when numeric,
+    #       use that number of seconds; when false or 0, disable timeout.
+    #     :base - Set false to avoid passing the --git-dir argument when
+    #       invoking the git command.
+    #     :env - Hash of environment variable key/values that are set on the
+    #       child process.
+    #     :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).
+    # args - Non-option arguments passed on the command line.
+    #
+    # Optionally yields to the block an IO object attached to the child
+    # process's STDIN.
     #
     # Examples
+    #   git.native(:rev_list, {:max_count => 10, :header => true}, "master")
+    #
+    # Returns a String with all output written to the child process's stdout.
+    # 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
+    #   git command exits with a non-zero exit status. The CommandFailed's #command,
+    #   #exitstatus, and #err attributes can be used to retrieve additional
+    #   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.reject! { |a| a.empty? }
+
+      # special option arguments
+      env = options.delete(:env) || {}
+      raise_errors = options.delete(:raise)
+
+      # 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.
+      return run(prefix, cmd, '', options, args) if args[-1].to_s[0] == ?|
+
+      # more options
+      input    = options.delete(:input)
+      timeout  = options.delete(:timeout); timeout = true if timeout.nil?
+      base     = options.delete(:base);    base    = true if base.nil?
+      chdir    = options.delete(:chdir)
+
+      # build up the git process argv
+      argv = []
+      argv << Git.git_binary
+      argv << "--git-dir=#{git_dir}" if base
+      argv << cmd.to_s.tr('_', '-')
+      argv.concat(options_to_argv(options))
+      argv.concat(args)
+
+      # run it and deal with fallout
+      Grit.log(argv.join(' ')) if Grit.debug
+
+      process =
+        Grit::Process.new(argv, env,
+          :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
+      if raise_errors && !status.success?
+        raise CommandFailed.new(argv.join(' '), status.exitstatus, process.err)
+      else
+        process.out
+      end
+    rescue Grit::Process::TimeoutExceeded, Grit::Process::MaximumOutputExceeded
+      raise GitTimeout, argv.join(' ')
+    end
+
+    # Methods not defined by a library implementation execute the git command
+    # using #native, passing the method name as the git command name.
+    #
+    # Examples:
     #   git.rev_list({:max_count => 10, :header => true}, "master")
+    def method_missing(cmd, options={}, *args, &block)
+      native(cmd, options, *args, &block)
+    end
+
+    # Transform a ruby-style options hash to command-line arguments sutiable for
+    # use with Kernel::exec. No shell escaping is performed.
     #
-    # Returns String
-    def method_missing(cmd, options = {}, *args)
-      run('', cmd, '', options, args)
+    # Returns an Array of String option arguments.
+    def options_to_argv(options)
+      argv = []
+      options.each do |key, val|
+        if key.to_s.size == 1
+          if val == true
+            argv << "-#{key}"
+          elsif val == false
+            # ignore
+          else
+            argv << "-#{key}"
+            argv << val.to_s
+          end
+        else
+          if val == true
+            argv << "--#{key.to_s.tr('_', '-')}"
+          elsif val == false
+            # ignore
+          else
+            argv << "--#{key.to_s.tr('_', '-')}=#{val}"
+          end
+        end
+      end
+      argv
     end
 
-    # Bypass any pure Ruby implementations and go straight to the native Git command
+    # Simple wrapper around Timeout::timeout.
+    #
+    # seconds - Float number of seconds before a Timeout::Error is raised. When
+    #   true, the Grit::Git.git_timeout value is used. When the timeout is less
+    #   than or equal to 0, no timeout is established.
     #
-    # Returns String
-    def native(cmd, options = {}, *args)
-      method_missing(cmd, options, *args)
+    # Raises Timeout::Error when the timeout has elapsed.
+    def timeout_after(seconds)
+      seconds = self.class.git_timeout if seconds == true
+      if seconds && seconds > 0
+        Timeout.timeout(seconds) { yield }
+      else
+        yield
+      end
     end
 
-    def run(prefix, cmd, postfix, options, args)
+    # DEPRECATED OPEN3-BASED COMMAND EXECUTION
+
+    def run(prefix, cmd, postfix, options, args, &block)
       timeout  = options.delete(:timeout) rescue nil
       timeout  = true if timeout.nil?
 
       base     = options.delete(:base) rescue nil
       base     = true if base.nil?
 
+      if input = options.delete(:input)
+        block = lambda { |stdin| stdin.write(input) }
+      end
+
       opt_args = transform_options(options)
 
       if RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
@@ -246,50 +390,29 @@ module Grit
         gitdir = base ? "--git-dir='#{self.git_dir}'" : ""
         call = "#{prefix}#{Git.git_binary} #{gitdir} #{cmd.to_s.gsub(/_/, '-')} #{(opt_args + ext_args).join(' ')}#{e(postfix)}"
       end
+
       Grit.log(call) if Grit.debug
-      response, err = timeout ? sh(call) : wild_sh(call)
+      response, err = timeout ? sh(call, &block) : wild_sh(call, &block)
       Grit.log(response) if Grit.debug
       Grit.log(err) if Grit.debug
       response
     end
 
-    def sh(command)
-      ret, err = '', ''
-      Open3.popen3(command) do |_, stdout, stderr|
-        Timeout.timeout(self.class.git_timeout) do
-          while tmp = stdout.read(1024)
-            ret += tmp
-            if (@bytes_read += tmp.size) > self.class.git_max_size
-              bytes = @bytes_read
-              @bytes_read = 0
-              raise GitTimeout.new(command, bytes)
-            end
-          end
-        end
-
-        while tmp = stderr.read(1024)
-          err += tmp
-        end
-      end
-      [ret, err]
-    rescue Timeout::Error, Grit::Git::GitTimeout
-      bytes = @bytes_read
-      @bytes_read = 0
-      raise GitTimeout.new(command, bytes)
-    end
-
-    def wild_sh(command)
-      ret, err = '', ''
-      Open3.popen3(command) do |_, stdout, stderr|
-        while tmp = stdout.read(1024)
-          ret += tmp
-        end
+    def sh(command, &block)
+      process =
+        Grit::Process.new(
+          command, {},
+          :timeout => Git.git_timeout,
+          :max     => Git.git_max_size
+        )
+      [process.out, process.err]
+    rescue Grit::Process::TimeoutExceeded, Grit::Process::MaximumOutputExceeded
+      raise GitTimeout, command
+    end
 
-        while tmp = stderr.read(1024)
-          err += tmp
-        end
-      end
-      [ret, err]
+    def wild_sh(command, &block)
+      process = Grit::Process.new(command)
+      [process.out, process.err]
     end
 
     # Transform Ruby style options into git command line options

data/lib/grit/index.rb

@@ -63,7 +63,27 @@ module Grit
       self.current_tree = self.repo.tree(tree)
     end
 
-    # Public: Commit the contents of the index
+    # Public: Commit the contents of the index.  This method supports two
+    # formats for arguments:
+    #
+    # message - The String commit message.
+    # options - An optional Hash of index options.
+    #           :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 
+    #                             the commit (default: nil).
+    #           :last_tree      - The String SHA1 of a tree to compare with
+    #                             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: Time.now)
+    #           :authored_date  - The Time that the commit was authored.  
+    #                             (Default: committed_date)
+    #
+    # The legacy argument style looks like:
     #
     # message   - The String commit message.
     # parents   - Array of String commit SHA1s or Grit::Commit objects to
@@ -77,6 +97,20 @@ module Grit
     #
     # Returns a String of the SHA1 of the new commit.
     def commit(message, parents = nil, actor = nil, last_tree = nil, head = 'master')
+      if parents.is_a?(Hash)
+        actor          = parents[:actor]
+        committer      = parents[:committer]
+        author         = parents[:author]
+        last_tree      = parents[:last_tree]
+        head           = parents[:head]
+        committed_date = parents[:committed_date]
+        authored_date  = parents[:authored_date]
+        parents        = parents[:parents]
+      end
+
+      committer ||= actor
+      author    ||= committer
+
       tree_sha1 = write_tree(self.tree, self.current_tree)
 
       # don't write identical commits
@@ -88,18 +122,16 @@ module Grit
         contents << ['parent', p].join(' ')
       end if parents
 
-      if actor
-        name  = actor.name
-        email = actor.email
-      else
+      committer      ||= begin
         config = Config.new(self.repo)
-        name   = config['user.name']
-        email  = config['user.email']
+        Actor.new(config['user.name'], config['user.email'])
       end
+      author         ||= committer
+      committed_date ||= Time.now
+      authored_date  ||= committed_date
 
-      author_string = "#{name} <#{email}> #{Time.now.to_i} -0700" # !! TODO : gotta fix this
-      contents << ['author', author_string].join(' ')
-      contents << ['committer', author_string].join(' ')
+      contents << ['author',    author.output(authored_date)].join(' ')
+      contents << ['committer', committer.output(committed_date)].join(' ')
       contents << ''
       contents << message
 
@@ -125,7 +157,8 @@ module Grit
         sha = [obj.id].pack("H*")
         k = obj.name
         k += '/' if (obj.class == Grit::Tree)
-        tree_contents[k] = "%s %s\0%s" % [obj.mode.to_s, obj.name, sha]
+        tmode = obj.mode.to_i.to_s  ## remove zero-padding
+        tree_contents[k] = "%s %s\0%s" % [tmode, obj.name, sha]
       end if now_tree
 
       # overwrite with new tree contents

data/lib/grit/jruby.rb

@@ -0,0 +1,45 @@
+require 'grit/process'
+
+module Grit
+  # Override the Grit::Process class's popen4 and waitpid methods to work around
+  # various quirks in JRuby.
+  class Process
+    # Use JRuby's built in IO.popen4 but emulate the special spawn env
+    # and options arguments as best we can.
+    def popen4(*argv)
+      env = (argv.shift if argv[0].is_a?(Hash))  || {}
+      opt = (argv.pop   if argv[-1].is_a?(Hash)) || {}
+
+      # emulate :chdir option
+      if opt[:chdir]
+        previous_dir = Dir.pwd
+        Dir.chdir(opt[:chdir])
+      else
+        previous_dir = nil
+      end
+
+      # emulate :env option
+      if env.size > 0
+        previous_env = ENV
+        ENV.merge!(env)
+      else
+        previous_env = nil
+      end
+
+      pid, stdin, stdout, stderr = IO.popen4(*argv)
+    ensure
+      ENV.replace(previous_env) if previous_env
+      Dir.chdir(previous_dir)   if previous_dir
+    end
+
+    # JRuby always raises ECHILD on pids returned from its IO.popen4 method
+    # for some reason. Return a fake Process::Status object.
+    FakeStatus = Struct.new(:pid, :exitstatus, :success?, :fake?)
+    def waitpid(pid)
+      ::Process::waitpid(pid)
+      $?
+    rescue Errno::ECHILD
+      FakeStatus.new(pid, 0, true, true)
+    end
+  end
+end

data/lib/grit/lazy.rb

@@ -16,6 +16,10 @@
 # => 2
 #
 module Lazy
+  def self.extended(klass)
+    klass.send(:attr_writer, :lazy_source)
+  end
+
   def lazy_reader(*args)
     args.each do |arg|
       ivar = "@#{arg}"
@@ -28,6 +32,4 @@ module Lazy
       end
     end
   end
-end
-
-Object.extend Lazy unless Object.ancestors.include? Lazy
+end

data/lib/grit/process.rb

@@ -0,0 +1,294 @@
+module Grit
+  # Grit::Process includes logic for executing child processes and
+  # reading/writing from their standard input, output, and error streams.
+  #
+  # Create an run a process to completion:
+  #
+  #   >> process = Grit::Process.new(['git', '--help'])
+  #
+  # Retrieve stdout or stderr output:
+  #
+  #   >> process.out
+  #   => "usage: git [--version] [--exec-path[=GIT_EXEC_PATH]]\n ..."
+  #   >> process.err
+  #   => ""
+  #
+  # Check process exit status information:
+  #
+  #   >> process.status
+  #   => #<Process::Status: pid=80718,exited(0)>
+  #
+  # Grit::Process is designed to take all input in a single string and
+  # provides all output as single strings. It is therefore not well suited
+  # to streaming large quantities of data in and out of commands.
+  #
+  # Q: Why not use popen3 or hand-roll fork/exec code?
+  #
+  # - It's more efficient than popen3 and provides meaningful process
+  #   hierarchies because it performs a single fork/exec. (popen3 double forks
+  #   to avoid needing to collect the exit status and also calls
+  #   Process::detach which creates a Ruby Thread!!!!).
+  #
+  # - It's more portable than hand rolled pipe, fork, exec code because
+  #   fork(2) and exec(2) aren't available on all platforms. In those cases,
+  #   Grit::Process falls back to using whatever janky substitutes the platform
+  #   provides.
+  #
+  # - It handles all max pipe buffer hang cases, which is non trivial to
+  #   implement correctly and must be accounted for with either popen3 or
+  #   hand rolled fork/exec code.
+  class Process
+    # Create and execute a new process.
+    #
+    # argv    - Array of [command, arg1, ...] strings to use as the new
+    #           process's argv. When argv is a String, the shell is used
+    #           to interpret the command.
+    # env     - The new process's environment variables. This is merged with
+    #           the current environment as if by ENV.merge(env).
+    # options - Additional options:
+    #             :input   => str to write str to the process's stdin.
+    #             :timeout => int number of seconds before we given up.
+    #             :max     => total number of output bytes
+    #           A subset of Process:spawn options are also supported on all
+    #           platforms:
+    #             :chdir => str to start the process in different working dir.
+    #
+    # Returns a new Process instance that has already executed to completion.
+    # The out, err, and status attributes are immediately available.
+    def initialize(argv, env={}, options={})
+      @argv = argv
+      @env = env
+
+      @options = options.dup
+      @input = @options.delete(:input)
+      @timeout = @options.delete(:timeout)
+      @max = @options.delete(:max)
+      @options.delete(:chdir) if @options[:chdir].nil?
+
+      exec!
+    end
+
+    # All data written to the child process's stdout stream as a String.
+    attr_reader :out
+
+    # All data written to the child process's stderr stream as a String.
+    attr_reader :err
+
+    # A Process::Status object with information on how the child exited.
+    attr_reader :status
+
+    # Total command execution time (wall-clock time)
+    attr_reader :runtime
+
+    # Determine if the process did exit with a zero exit status.
+    def success?
+      @status && @status.success?
+    end
+
+  private
+    # Execute command, write input, and read output. This is called
+    # immediately when a new instance of this object is initialized.
+    def exec!
+      # when argv is a string, use /bin/sh to interpret command
+      argv = @argv
+      argv = ['/bin/sh', '-c', argv.to_str] if argv.respond_to?(:to_str)
+
+      # spawn the process and hook up the pipes
+      pid, stdin, stdout, stderr = popen4(@env, *(argv + [@options]))
+
+      # async read from all streams into buffers
+      @out, @err = read_and_write(@input, stdin, stdout, stderr, @timeout, @max)
+
+      # grab exit status
+      @status = waitpid(pid)
+    rescue Object => boom
+      [stdin, stdout, stderr].each { |fd| fd.close rescue nil }
+      if @status.nil?
+        ::Process.kill('TERM', pid) rescue nil
+        @status = waitpid(pid)      rescue nil
+      end
+      raise
+    end
+
+    # Exception raised when the total number of bytes output on the command's
+    # stderr and stdout streams exceeds the maximum output size (:max option).
+    class MaximumOutputExceeded < StandardError
+    end
+
+    # Exception raised when timeout is exceeded.
+    class TimeoutExceeded < StandardError
+    end
+
+    # Maximum buffer size for reading
+    BUFSIZE = (32 * 1024)
+
+    # Start a select loop writing any input on the child's stdin and reading
+    # any output from the child's stdout or stderr.
+    #
+    # input   - String input to write on stdin. May be nil.
+    # stdin   - The write side IO object for the child's stdin stream.
+    # stdout  - The read side IO object for the child's stdout stream.
+    # stderr  - The read side IO object for the child's stderr stream.
+    # timeout - An optional Numeric specifying the total number of seconds
+    #           the read/write operations should occur for.
+    #
+    # Returns an [out, err] tuple where both elements are strings with all
+    #   data written to the stdout and stderr streams, respectively.
+    # Raises TimeoutExceeded when all data has not been read / written within
+    #   the duration specified in the timeout argument.
+    # Raises MaximumOutputExceeded when the total number of bytes output
+    #   exceeds the amount specified by the max argument.
+    def read_and_write(input, stdin, stdout, stderr, timeout=nil, max=nil)
+      input ||= ''
+      max = nil if max && max <= 0
+      out, err = '', ''
+      offset = 0
+
+      timeout = nil if timeout && timeout <= 0.0
+      @runtime = 0.0
+      start = Time.now
+
+      writers = [stdin]
+      readers = [stdout, stderr]
+      t = timeout
+      while readers.any? || writers.any?
+        ready = IO.select(readers, writers, readers + writers, t)
+        raise TimeoutExceeded if ready.nil?
+
+        # write to stdin stream
+        ready[1].each do |fd|
+          begin
+            boom = nil
+            size = fd.write_nonblock(input)
+            input = input[size, input.size]
+          rescue Errno::EPIPE => boom
+          rescue Errno::EAGAIN, Errno::EINTR
+          end
+          if boom || input.size == 0
+            stdin.close
+            writers.delete(stdin)
+          end
+        end
+
+        # read from stdout and stderr streams
+        ready[0].each do |fd|
+          buf = (fd == stdout) ? out : err
+          begin
+            buf << fd.readpartial(BUFSIZE)
+          rescue Errno::EAGAIN, Errno::EINTR
+          rescue EOFError
+            readers.delete(fd)
+            fd.close
+          end
+        end
+
+        # keep tabs on the total amount of time we've spent here
+        @runtime = Time.now - start
+        if timeout
+          t = timeout - @runtime
+          raise TimeoutExceeded if t < 0.0
+        end
+
+        # maybe we've hit our max output
+        if max && ready[0].any? && (out.size + err.size) > max
+          raise MaximumOutputExceeded
+        end
+      end
+
+      [out, err]
+    end
+
+    # Spawn a child process, perform IO redirection and environment prep, and
+    # return the running process's pid.
+    #
+    # This method implements a limited subset of Ruby 1.9's Process::spawn.
+    # The idea is that we can just use that when available, since most platforms
+    # will eventually build in special (and hopefully good) support for it.
+    #
+    #   env     - Hash of { name => val } environment variables set in the child
+    #             process.
+    #   argv    - New process's argv as an Array. When this value is a string,
+    #             the command may be run through the system /bin/sh or
+    #   options - Supports a subset of Process::spawn options, including:
+    #             :chdir => str to change the directory to str in the child
+    #                 FD => :close to close a file descriptor in the child
+    #                :in => FD to redirect child's stdin to FD
+    #               :out => FD to redirect child's stdout to FD
+    #               :err => FD to redirect child's stderr to FD
+    #
+    # Returns the pid of the new process as an integer. The process exit status
+    # must be obtained using Process::waitpid.
+    def spawn(env, *argv)
+      options = (argv.pop if argv[-1].kind_of?(Hash)) || {}
+      fork do
+        # { fd => :close } in options means close that fd
+        options.each { |k,v| k.close if v == :close && !k.closed? }
+
+        # reopen stdin, stdout, and stderr on provided fds
+        STDIN.reopen(options[:in])
+        STDOUT.reopen(options[:out])
+        STDERR.reopen(options[:err])
+
+        # setup child environment
+        env.each { |k, v| ENV[k] = v }
+
+        # { :chdir => '/' } in options means change into that dir
+        ::Dir.chdir(options[:chdir]) if options[:chdir]
+
+        # do the deed
+        ::Kernel::exec(*argv)
+        exit! 1
+      end
+    end
+
+    # Start a process with spawn options and return
+    # popen4([env], command, arg1, arg2, [opt])
+    #
+    #   env     - The child process's environment as a Hash.
+    #   command - The command and zero or more arguments.
+    #   options - An options hash.
+    #
+    # See Ruby 1.9 IO.popen and Process::spawn docs for more info:
+    # http://www.ruby-doc.org/core-1.9/classes/IO.html#M001640
+    #
+    # Returns a [pid, stdin, stderr, stdout] tuple where pid is the child
+    # process's pid, stdin is a writeable IO object, and stdout + stderr are
+    # readable IO objects.
+    def popen4(*argv)
+      # create some pipes (see pipe(2) manual -- the ruby docs suck)
+      ird, iwr = IO.pipe
+      ord, owr = IO.pipe
+      erd, ewr = IO.pipe
+
+      # spawn the child process with either end of pipes hooked together
+      opts =
+        ((argv.pop if argv[-1].is_a?(Hash)) || {}).merge(
+          # redirect fds        # close other sides
+          :in  => ird,          iwr  => :close,
+          :out => owr,          ord  => :close,
+          :err => ewr,          erd  => :close
+        )
+      pid = spawn(*(argv + [opts]))
+
+      [pid, iwr, ord, erd]
+    ensure
+      # we're in the parent, close child-side fds
+      [ird, owr, ewr].each { |fd| fd.close }
+    end
+
+    # Wait for the child process to exit
+    #
+    # Returns the Process::Status object obtained by reaping the process.
+    def waitpid(pid)
+      ::Process::waitpid(pid)
+      $?
+    end
+
+    # Use native Process::spawn implementation on Ruby 1.9.
+    if ::Process.respond_to?(:spawn)
+      def spawn(*argv)
+        ::Process.spawn(*argv)
+      end
+    end
+  end
+end

data/lib/grit/ref.rb

@@ -73,4 +73,6 @@ module Grit
 
   class Remote < Ref; end
 
+  class Note < Ref; end
+
 end # Grit

data/lib/grit/repo.rb

@@ -2,6 +2,9 @@ module Grit
 
   class Repo
     DAEMON_EXPORT_FILE = 'git-daemon-export-ok'
+    BATCH_PARSERS      = {
+      'commit' => ::Grit::Commit
+    }
 
     # Public: The String path of the Git repo.
     attr_accessor :path
@@ -55,7 +58,7 @@ module Grit
 
     # Public: Initialize a git repository (create it on the filesystem). By
     # default, the newly created repository will contain a working directory.
-    # If you would like to create a bare repo, use Gollum::Repo.init_bare.
+    # If you would like to create a bare repo, use Grit::Repo.init_bare.
     #
     # path         - The String full path to the repo. Traditionally ends with
     #                "/<name>.git".
@@ -96,6 +99,7 @@ module Grit
       git = Git.new(path)
       git.fs_mkdir('..')
       git.init(git_options)
+      repo_options = {:is_bare => true}.merge(repo_options)
       self.new(path, repo_options)
     end
 
@@ -155,6 +159,40 @@ module Grit
       Repo.new(self.path)
     end
 
+    # Public: Return the full Git objects from the given SHAs.  Only Commit
+    # objects are parsed for now.
+    #
+    # *shas - Array of String SHAs.
+    #
+    # Returns an Array of Grit objects (Grit::Commit).
+    def batch(*shas)
+      shas.flatten!
+      text = git.native(:cat_file, {:batch => true, :input => (shas * "\n")})
+      parse_batch(text)
+    end
+
+    # Parses `git cat-file --batch` output, returning an array of Grit objects.
+    #
+    # text - Raw String output.
+    #
+    # Returns an Array of Grit objects (Grit::Commit).
+    def parse_batch(text)
+      io = StringIO.new(text)
+      objects = []
+      while line = io.gets
+        sha, type, size = line.split(" ", 3)
+        parser = BATCH_PARSERS[type]
+        if type == 'missing' || !parser
+          objects << nil
+          next
+        end
+
+        object   = io.read(size.to_i + 1)
+        objects << parser.parse_batch(self, sha, size, object)
+      end
+      objects
+    end
+
     # The project's description. Taken verbatim from GIT_REPO/description
     #
     # Returns String
@@ -415,7 +453,8 @@ module Grit
       else
         # NO PARENTS:
         cmd = "-r -t #{commit_sha}"
-        revs = self.git.method_missing('ls-tree', {:timeout => false}, "-r -t #{commit_sha}").split("\n").map{ |a| a.split("\t").first.split(' ')[2] }
+        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
       revs << self.commit(commit_sha).tree.id
       Grit.no_quote = false
@@ -461,7 +500,7 @@ module Grit
       diff = self.git.native('diff', {}, a, b, '--', *paths)
 
       if diff =~ /diff --git a/
-        diff = diff.sub(/.+?(diff --git a)/m, '\1')
+        diff = diff.sub(/.*?(diff --git a)/m, '\1')
       else
         diff = ''
       end
@@ -558,11 +597,9 @@ module Grit
     # Returns Array[String] (pathnames of alternates)
     def alternates
       alternates_path = "objects/info/alternates"
-      if self.git.fs_exist?(alternates_path)
-        self.git.fs_read(alternates_path).strip.split("\n")
-      else
-        []
-      end
+      self.git.fs_read(alternates_path).strip.split("\n")
+    rescue Errno::ENOENT
+      []
     end
 
     # Sets the alternates

data/lib/grit/tag.rb

@@ -1,6 +1,8 @@
 module Grit
 
   class Tag < Ref
+    extend Lazy
+
     lazy_reader :message
     lazy_reader :tagger
     lazy_reader :tag_date

data/lib/grit/tree.rb

@@ -1,6 +1,8 @@
 module Grit
 
   class Tree
+    extend Lazy
+
     lazy_reader :contents
     attr_reader :id
     attr_reader :mode

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: grit
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 31
   prerelease: false
   segments: 
   - 2
-  - 3
+  - 4
   - 0
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors: 
 - Tom Preston-Werner
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-29 00:00:00 -07:00
+date: 2011-01-06 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -105,9 +105,10 @@ files:
 - lib/grit/git-ruby/repository.rb
 - lib/grit/git.rb
 - lib/grit/index.rb
+- lib/grit/jruby.rb
 - lib/grit/lazy.rb
 - lib/grit/merge.rb
-- lib/grit/open3_detach.rb
+- lib/grit/process.rb
 - lib/grit/ref.rb
 - lib/grit/repo.rb
 - lib/grit/ruby1.9.rb

data/lib/grit/open3_detach.rb

@@ -1,46 +0,0 @@
-module Open3
-  extend self
-
-  def popen3(*cmd)
-    pw = IO::pipe   # pipe[0] for read, pipe[1] for write
-    pr = IO::pipe
-    pe = IO::pipe
-
-    pid = fork{
-      # child
-      fork{
-        # grandchild
-        pw[1].close
-        STDIN.reopen(pw[0])
-        pw[0].close
-
-        pr[0].close
-        STDOUT.reopen(pr[1])
-        pr[1].close
-
-        pe[0].close
-        STDERR.reopen(pe[1])
-        pe[1].close
-
-        exec(*cmd)
-      }
-      exit!(0)
-    }
-
-    pw[0].close
-    pr[1].close
-    pe[1].close
-    Process.waitpid(pid)
-    pi = [pw[1], pr[0], pe[0]]
-    pw[1].sync = true
-    if defined? yield
-      begin
-        return yield(*pi)
-      ensure
-        Process.detach(pid) if pid
-        pi.each { |p| p.close unless p.closed? }
-      end
-    end
-    pi
-  end
-end