rhomobile-grit 2.4.1

data/lib/grit/index.rb

@@ -0,0 +1,197 @@
+module Grit
+
+  class Index
+    # Public: Gets/Sets the Grit::Repo to which this index belongs.
+    attr_accessor :repo
+
+    # Public: Gets/Sets the Hash tree map that holds the changes to be made
+    # in the next commit.
+    attr_accessor :tree
+
+    # Public: Gets/Sets the Grit::Tree object representing the tree upon
+    # which the next commit will be based.
+    attr_accessor :current_tree
+
+    # Initialize a new Index object.
+    #
+    # repo - The Grit::Repo to which the index belongs.
+    #
+    # Returns the newly initialized Grit::Index.
+    def initialize(repo)
+      self.repo = repo
+      self.tree = {}
+      self.current_tree = nil
+    end
+
+    # Public: Add a file to the index.
+    #
+    # path - The String file path including filename (no slash prefix).
+    # data - The String binary contents of the file.
+    #
+    # Returns nothing.
+    def add(path, data)
+      path = path.split('/')
+      filename = path.pop
+
+      current = self.tree
+
+      path.each do |dir|
+        current[dir] ||= {}
+        node = current[dir]
+        current = node
+      end
+
+      current[filename] = data
+    end
+
+    # Public: Delete the given file from the index.
+    #
+    # path - The String file path including filename (no slash prefix).
+    #
+    # Returns nothing.
+    def delete(path)
+      add(path, false)
+    end
+
+    # Public: Read the contents of the given Tree into the index to use as a
+    # starting point for the index.
+    #
+    # tree - The String branch/tag/sha of the Git tree object.
+    #
+    # Returns nothing.
+    def read_tree(tree)
+      self.current_tree = self.repo.tree(tree)
+    end
+
+    # 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
+    #             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").
+    #
+    # 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
+      return false if tree_sha1 == last_tree
+
+      contents = []
+      contents << ['tree', tree_sha1].join(' ')
+      parents.each do |p|
+        contents << ['parent', p].join(' ')
+      end if parents
+
+      committer      ||= begin
+        config = Config.new(self.repo)
+        Actor.new(config['user.name'], config['user.email'])
+      end
+      author         ||= committer
+      committed_date ||= Time.now
+      authored_date  ||= committed_date
+
+      contents << ['author',    author.output(authored_date)].join(' ')
+      contents << ['committer', committer.output(committed_date)].join(' ')
+      contents << ''
+      contents << message
+
+      commit_sha1 = self.repo.git.put_raw_object(contents.join("\n"), 'commit')
+
+      self.repo.update_ref(head, commit_sha1)
+    end
+
+    # Recursively write a tree to the index.
+    #
+    # tree -     The Hash tree map:
+    #            key - The String directory or filename.
+    #            val - The Hash submap or the String contents of the file.
+    # now_tree - The Grit::Tree representing the a previous tree upon which
+    #            this tree will be based (default: nil).
+    #
+    # Returns the String SHA1 String of the tree.
+    def write_tree(tree, now_tree = nil)
+      tree_contents = {}
+
+      # fill in original tree
+      now_tree.contents.each do |obj|
+        sha = [obj.id].pack("H*")
+        k = obj.name
+        k += '/' if (obj.class == Grit::Tree)
+        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
+      tree.each do |k, v|
+        case v
+          when String
+            sha = write_blob(v)
+            sha = [sha].pack("H*")
+            str = "%s %s\0%s" % ['100644', k, sha]
+            tree_contents[k] = str
+          when Hash
+            ctree = now_tree/k if now_tree
+            sha = write_tree(v, ctree)
+            sha = [sha].pack("H*")
+            str = "%s %s\0%s" % ['40000', k, sha]
+            tree_contents[k + '/'] = str
+          when false
+            tree_contents.delete(k)
+        end
+      end
+
+      tr = tree_contents.sort.map { |k, v| v }.join('')
+      self.repo.git.put_raw_object(tr, 'tree')
+    end
+
+    # Write a blob to the index.
+    #
+    # data - The String data to write.
+    #
+    # Returns the String SHA1 of the new blob.
+    def write_blob(data)
+      self.repo.git.put_raw_object(data, 'blob')
+    end
+  end # Index
+
+end # Grit

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

@@ -0,0 +1,35 @@
+##
+# Allows attributes to be declared as lazy, meaning that they won't be
+# computed until they are asked for.
+#
+# Works by delegating each lazy_reader to a cached lazy_source method.
+#
+# class Person
+#   lazy_reader :eyes
+#
+#   def lazy_source
+#     OpenStruct.new(:eyes => 2)
+#   end
+# end
+#
+# >> Person.new.eyes
+# => 2
+#
+module Lazy
+  def self.extended(klass)
+    klass.send(:attr_writer, :lazy_source)
+  end
+
+  def lazy_reader(*args)
+    args.each do |arg|
+      ivar = "@#{arg}"
+      define_method(arg) do
+        if instance_variable_defined?(ivar)
+          val = instance_variable_get(ivar)
+          return val if val
+        end
+        instance_variable_set(ivar, (@lazy_source ||= lazy_source).send(arg))
+      end
+    end
+  end
+end

data/lib/grit/merge.rb

@@ -0,0 +1,45 @@
+module Grit
+
+  class Merge
+
+    STATUS_BOTH = 'both'
+    STATUS_OURS = 'ours'
+    STATUS_THEIRS = 'theirs'
+
+    attr_reader :conflicts, :text, :sections
+
+    def initialize(str)
+      status = STATUS_BOTH
+
+      section = 1
+      @conflicts = 0
+      @text = {}
+
+      lines = str.split("\n")
+      lines.each do |line|
+        if /^<<<<<<< (.*?)/.match(line)
+          status = STATUS_OURS
+          @conflicts += 1
+          section += 1
+        elsif line == '======='
+          status = STATUS_THEIRS
+        elsif /^>>>>>>> (.*?)/.match(line)
+          status = STATUS_BOTH
+          section += 1
+        else
+          @text[section] ||= {}
+          @text[section][status] ||= []
+          @text[section][status] << line
+        end
+      end
+      @text = @text.values
+      @sections = @text.size
+    end
+
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Merge}
+    end
+  end # Merge
+
+end # Grit

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