git-trip 0.0.4 → 0.0.5

data/vendor/grit/lib/grit/commit.rb

@@ -1,208 +0,0 @@
-module Grit
-  
-  class Commit
-    attr_reader :id
-    lazy_reader :parents
-    lazy_reader :tree
-    lazy_reader :author
-    lazy_reader :authored_date
-    lazy_reader :committer
-    lazy_reader :committed_date
-    lazy_reader :message
-    lazy_reader :short_message
-    
-    # Instantiate a new Commit
-    #   +id+ is the id of the commit
-    #   +parents+ is an array of commit ids (will be converted into Commit instances)
-    #   +tree+ is the correspdonding tree id (will be converted into a Tree object)
-    #   +author+ is the author string
-    #   +authored_date+ is the authored Time
-    #   +committer+ is the committer string
-    #   +committed_date+ is the committed Time
-    #   +message+ is an array of commit message lines
-    #
-    # Returns Grit::Commit (baked)
-    def initialize(repo, id, parents, tree, author, authored_date, committer, committed_date, message)
-      @repo = repo
-      @id = id
-      @parents = parents.map { |p| Commit.create(repo, :id => p) }
-      @tree = Tree.create(repo, :id => tree)
-      @author = author
-      @authored_date = authored_date
-      @committer = committer
-      @committed_date = committed_date
-      @message = message.join("\n")
-      @short_message = message[0] || ''
-    end
-    
-    def id_abbrev
-      @id_abbrev ||= @repo.git.rev_parse({:short => true}, self.id).chomp
-    end
-    
-    # Create an unbaked Commit containing just the specified attributes
-    #   +repo+ is the Repo
-    #   +atts+ is a Hash of instance variable data
-    #
-    # Returns Grit::Commit (unbaked)
-    def self.create(repo, atts)
-      self.allocate.create_initialize(repo, atts)
-    end
-    
-    # Initializer for Commit.create
-    #   +repo+ is the Repo
-    #   +atts+ is a Hash of instance variable data
-    #
-    # Returns Grit::Commit (unbaked)
-    def create_initialize(repo, atts)
-      @repo = repo
-      atts.each do |k, v|
-        instance_variable_set("@#{k}", v)
-      end
-      self
-    end
-    
-    def lazy_source
-      self.class.find_all(@repo, @id, {:max_count => 1}).first
-    end
-    
-    # Count the number of commits reachable from this ref
-    #   +repo+ is the Repo
-    #   +ref+ is the ref from which to begin (SHA1 or name)
-    #
-    # Returns Integer
-    def self.count(repo, ref)
-      repo.git.rev_list({}, ref).strip.split("\n").size
-    end
-    
-    # Find all commits matching the given criteria.
-    #   +repo+ is the Repo
-    #   +ref+ is the ref from which to begin (SHA1 or name) or nil for --all
-    #   +options+ is a Hash of optional arguments to git
-    #     :max_count is the maximum number of commits to fetch
-    #     :skip is the number of commits to skip
-    #
-    # Returns Grit::Commit[] (baked)
-    def self.find_all(repo, ref, options = {})
-      allowed_options = [:max_count, :skip, :since]
-      
-      default_options = {:pretty => "raw"}
-      actual_options = default_options.merge(options)
-      
-      if ref
-        output = repo.git.rev_list(actual_options, ref)
-      else
-        output = repo.git.rev_list(actual_options.merge(:all => true))
-      end
-      
-      self.list_from_string(repo, output)
-    end
-    
-    # Parse out commit information into an array of baked Commit objects
-    #   +repo+ is the Repo
-    #   +text+ is the text output from the git command (raw format)
-    #
-    # Returns Grit::Commit[] (baked)
-    def self.list_from_string(repo, text)
-      lines = text.split("\n")
-      
-      commits = []
-      
-      while !lines.empty?
-        id = lines.shift.split.last
-        tree = lines.shift.split.last
-        
-        parents = []
-        parents << lines.shift.split.last while lines.first =~ /^parent/
-        
-        author, authored_date = self.actor(lines.shift)
-        committer, committed_date = self.actor(lines.shift)
-        
-        lines.shift
-        
-        message_lines = []
-        message_lines << lines.shift[4..-1] while lines.first =~ /^ {4}/
-        
-        lines.shift while lines.first && lines.first.empty?
-        
-        commits << Commit.new(repo, id, parents, tree, author, authored_date, committer, committed_date, message_lines)
-      end
-      
-      commits
-    end
-    
-    # Show diffs between two trees:
-    #   +repo+ is the Repo
-    #   +a+ is a named commit
-    #   +b+ is an optional named commit.  Passing an array assumes you 
-    #     wish to omit the second named commit and limit the diff to the 
-    #     given paths.
-    #   +paths* is an array of paths to limit the diff.
-    #
-    # Returns Grit::Diff[] (baked)
-    def self.diff(repo, a, b = nil, paths = [])
-      if b.is_a?(Array)
-        paths = b
-        b     = nil
-      end
-      paths.unshift("--") unless paths.empty?
-      paths.unshift(b)    unless b.nil?
-      paths.unshift(a)
-      text = repo.git.diff({:full_index => true}, *paths)
-      Diff.list_from_string(repo, text)
-    end
-
-    def diffs
-      if parents.empty?
-        diff = @repo.git.show({:full_index => true, :pretty => 'raw'}, @id)
-        if diff =~ /diff --git a/
-          diff = diff.sub(/.+?(diff --git a)/m, '\1')
-        else
-          diff = ''
-        end
-        Diff.list_from_string(@repo, diff)
-      else
-        self.class.diff(@repo, parents.first.id, @id) 
-      end
-    end
-    
-    # Convert this Commit to a String which is just the SHA1 id
-    def to_s
-      @id
-    end
-    
-    # Pretty object inspection
-    def inspect
-      %Q{#<Grit::Commit "#{@id}">}
-    end
-    
-    # private
-    
-    # Parse out the actor (author or committer) info
-    #
-    # Returns [String (actor name and email), Time (acted at time)]
-    def self.actor(line)
-      m, actor, epoch = *line.match(/^.+? (.*) (\d+) .*$/)
-      [Actor.from_string(actor), Time.at(epoch.to_i)]
-    end
-
-    def to_hash
-      {
-        'id'       => id,
-        'parents'  => parents.map { |p| { 'id' => p.id } },
-        'tree'     => tree.id,
-        'message'  => message,
-        'author'   => {
-          'name'  => author.name,
-          'email' => author.email
-        },
-        'committer' => {
-          'name'  => committer.name,
-          'email' => committer.email
-        },
-        'authored_date'  => authored_date.xmlschema,
-        'committed_date' => committed_date.xmlschema,
-      }
-    end
-  end # Commit
-  
-end # Grit

data/vendor/grit/lib/grit/config.rb

@@ -1,44 +0,0 @@
-module Grit
-  
-  class Config
-    def initialize(repo)
-      @repo = repo
-    end
-    
-    def []=(key, value)
-      @repo.git.config({}, key, value)
-      @data = nil
-    end
-    
-    def [](key)
-      data[key]
-    end
-    
-    def fetch(key, default = nil)
-      data[key] || default || raise(IndexError.new("key not found"))
-    end
-    
-    def keys
-      data.keys
-    end
-    
-    protected
-      def data
-        @data ||= load_config
-      end
-      
-      def load_config
-        hash = {}
-        config_lines.map do |line|
-          key, value = line.split(/=/, 2)
-          hash[key] = value
-        end
-        hash
-      end
-      
-      def config_lines
-        @repo.git.config(:list => true).split(/\n/)
-      end
-  end # Config
-  
-end # Grit

data/vendor/grit/lib/grit/diff.rb

@@ -1,70 +0,0 @@
-module Grit
-  
-  class Diff
-    attr_reader :a_path, :b_path
-    attr_reader :a_commit, :b_commit
-    attr_reader :a_mode, :b_mode
-    attr_reader :new_file, :deleted_file
-    attr_reader :diff
-    
-    def initialize(repo, a_path, b_path, a_commit, b_commit, a_mode, b_mode, new_file, deleted_file, diff)
-      @repo = repo
-      @a_path = a_path
-      @b_path = b_path
-      @a_commit = a_commit =~ /^0{40}$/ ? nil : Commit.create(repo, :id => a_commit)
-      @b_commit = b_commit =~ /^0{40}$/ ? nil : Commit.create(repo, :id => b_commit)
-      @a_mode = a_mode
-      @b_mode = b_mode
-      @new_file = new_file
-      @deleted_file = deleted_file
-      @diff = diff
-    end
-    
-    def self.list_from_string(repo, text)
-      lines = text.split("\n")
-      
-      diffs = []
-      
-      while !lines.empty?
-        m, a_path, b_path = *lines.shift.match(%r{^diff --git a/(.+?) b/(.+)$})
-        
-        if lines.first =~ /^old mode/
-          m, a_mode = *lines.shift.match(/^old mode (\d+)/)
-          m, b_mode = *lines.shift.match(/^new mode (\d+)/)
-        end
-        
-        if lines.empty? || lines.first =~ /^diff --git/
-          diffs << Diff.new(repo, a_path, b_path, nil, nil, a_mode, b_mode, false, false, nil)
-          next
-        end
-        
-        new_file = false
-        deleted_file = false
-        
-        if lines.first =~ /^new file/
-          m, b_mode = lines.shift.match(/^new file mode (.+)$/)
-          a_mode = nil
-          new_file = true
-        elsif lines.first =~ /^deleted file/
-          m, a_mode = lines.shift.match(/^deleted file mode (.+)$/)
-          b_mode = nil
-          deleted_file = true
-        end
-        
-        m, a_commit, b_commit, b_mode = *lines.shift.match(%r{^index ([0-9A-Fa-f]+)\.\.([0-9A-Fa-f]+) ?(.+)?$})
-        b_mode.strip! if b_mode
-        
-        diff_lines = []
-        while lines.first && lines.first !~ /^diff/
-          diff_lines << lines.shift
-        end
-        diff = diff_lines.join("\n")
-        
-        diffs << Diff.new(repo, a_path, b_path, a_commit, b_commit, a_mode, b_mode, new_file, deleted_file, diff)
-      end
-      
-      diffs
-    end
-  end # Diff
-  
-end # Grit

data/vendor/grit/lib/grit/errors.rb

@@ -1,7 +0,0 @@
-module Grit
-  class InvalidGitRepositoryError < StandardError
-  end
-  
-  class NoSuchPathError < StandardError
-  end
-end

data/vendor/grit/lib/grit/git.rb

@@ -1,116 +0,0 @@
-trap("CHLD") do
-  begin
-    Process.wait(-1, Process::WNOHANG)
-  rescue Object
-  end
-end
-
-module Grit
-  
-  class Git
-    class GitTimeout < RuntimeError
-      attr_reader :command, :bytes_read
-
-      def initialize(command = nil, bytes_read = nil)
-        @command = command
-        @bytes_read = bytes_read
-      end
-    end
-
-    undef_method :clone
-    
-    class << self
-      attr_accessor :git_binary, :git_timeout
-    end
-  
-    self.git_binary  = "/usr/bin/env git"
-    self.git_timeout = 5
-    
-    attr_accessor :git_dir, :bytes_read
-    
-    def initialize(git_dir)
-      self.git_dir    = git_dir
-      self.bytes_read = 0
-    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)
-    #
-    # Examples
-    #   git.rev_list({:max_count => 10, :header => true}, "master")
-    #
-    # Returns String
-    def method_missing(cmd, options = {}, *args)
-      run('', cmd, '', options, args)
-    end
-    
-    def run(prefix, cmd, postfix, options, args)
-      timeout  = options.delete(:timeout)
-      timeout  = true if timeout.nil?
-
-      opt_args = transform_options(options)
-      ext_args = args.map { |a| a == '--' ? a : "'#{a}'" }
-      
-      call = "#{prefix}#{Git.git_binary} --git-dir='#{self.git_dir}' #{cmd.to_s.gsub(/_/, '-')} #{(opt_args + ext_args).join(' ')}#{postfix}"
-      puts call if Grit.debug
-      response = timeout ? sh(call) : wild_sh(call)
-      puts response if Grit.debug
-      response
-    end
-
-    def sh(command)
-      pid, _, io, _ = Open4.popen4(command)
-      ret = Timeout.timeout(self.class.git_timeout) { io.read }
-      @bytes_read += ret.size
-
-      if @bytes_read > 5242880 # 5.megabytes
-        bytes = @bytes_read
-        @bytes_read = 0
-        raise GitTimeout.new(command, bytes) 
-      end
-
-      ret
-    rescue Object => e
-      Process.kill('KILL', pid) rescue nil
-      bytes = @bytes_read
-      @bytes_read = 0
-      raise GitTimeout.new(command, bytes)
-    end
-
-    def wild_sh(command)
-      pid, _, io, _ = Open4.popen4(command)
-      io.read
-    end
-
-    # Transform Ruby style options into git command line options
-    #   +options+ is a hash of Ruby style options
-    #
-    # Returns String[]
-    #   e.g. ["--max-count=10", "--header"]
-    def transform_options(options)
-      args = []
-      options.keys.each do |opt|
-        if opt.to_s.size == 1
-          if options[opt] == true
-            args << "-#{opt}"
-          else
-            val = options.delete(opt)
-            args << "-#{opt.to_s} '#{val}'"
-          end
-        else
-          if options[opt] == true
-            args << "--#{opt.to_s.gsub(/_/, '-')}"
-          else
-            val = options.delete(opt)
-            args << "--#{opt.to_s.gsub(/_/, '-')}='#{val}'"
-          end
-        end
-      end
-      args
-    end
-  end # Git
-  
-end # Grit