git-trip 0.0.3

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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,70 @@
+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

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

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

@@ -0,0 +1,116 @@
+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

data/vendor/grit/lib/grit/index.rb

@@ -0,0 +1,77 @@
+module Grit
+  
+  class Index
+    attr_accessor :repo, :tree
+    
+    def initialize(repo)
+      self.repo = repo
+      self.tree = {}
+    end
+    
+    # Add a file to the index
+    #   +path+ is the path (including filename)
+    #   +data+ is the binary contents of the file
+    #
+    # Returns nothing
+    def add(file_path, data)
+      path = file_path.split('/')
+      filename = path.pop
+      
+      current = self.tree
+      
+      path.each do |dir|
+        current[dir] ||= {}
+        node = current[dir]
+        current = node
+      end
+      
+      current[filename] = data
+    end
+    
+    # Commit the contents of the index
+    #   +message+ is the commit message
+    #
+    # Returns a String of the SHA1 of the commit
+    def commit(message)
+      tree_sha1 = write_tree(self.tree)
+      
+      message = message.gsub("'", "\\'")
+      commit_sha1 = self.repo.git.run("echo '#{message}' | ", :commit_tree, '', {}, [tree_sha1])
+      
+      # self.repo.git.update_ref({}, 'HEAD', commit_sha1)
+      File.open(File.join(self.repo.path, 'refs', 'heads', 'master'), 'w') do |f|
+        f.write(commit_sha1)
+      end
+      
+      commit_sha1
+    end
+    
+    # Recursively write a tree to the index
+    #   +tree+ is the tree
+    #
+    # Returns the SHA1 String of the tree
+    def write_tree(tree)
+      lstree = []
+      tree.each do |k, v|
+        case v
+          when String:
+            lstree << "100644 blob #{write_blob(v)}\t#{k}"
+          when Hash:
+            lstree << "040000 tree #{write_tree(v)}\t#{k}"
+        end
+      end
+      
+      lstree_string = lstree.join("\n").gsub("'", "\\'")
+      self.repo.git.run("echo '#{lstree_string}' | ", :mktree, '', {}, []).chomp
+    end
+    
+    # Write the blob to the index
+    #   +data+ is the data to write
+    #
+    # Returns the SHA1 String of the blob
+    def write_blob(data)
+      self.repo.git.run("echo '#{data}' | ", :hash_object, '', {:w => true, :stdin => true}, []).chomp
+    end
+  end # Index
+  
+end # Grit

data/vendor/grit/lib/grit/lazy.rb

@@ -0,0 +1,31 @@
+##
+# 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 lazy_reader(*args)
+    args.each do |arg|
+      ivar = "@#{arg}"
+      define_method(arg) do
+        val = instance_variable_get(ivar) 
+        return val if val
+        instance_variable_set(ivar, (@lazy_source ||= lazy_source).send(arg))
+      end
+    end
+  end
+end
+
+Object.extend Lazy unless Object.ancestors.include? Lazy

data/vendor/grit/lib/grit/ref.rb

@@ -0,0 +1,110 @@
+module Grit
+
+  class Ref
+
+    class << self
+
+      # Find all Refs
+      #   +repo+ is the Repo
+      #   +options+ is a Hash of options
+      #
+      # Returns Grit::Ref[] (baked)
+      def find_all(repo, options = {})
+        default_options = {:sort => "committerdate",
+                           :format => "%(refname)%00%(objectname)"}
+
+        actual_options = default_options.merge(options)
+
+        output = repo.git.for_each_ref(actual_options, prefix)
+
+        self.list_from_string(repo, output)
+      end
+
+      # Parse out ref information into an array of baked refs objects
+      #   +repo+ is the Repo
+      #   +text+ is the text output from the git command
+      #
+      # Returns Grit::Ref[] (baked)
+      def list_from_string(repo, text)
+        refs = []
+
+        text.split("\n").each do |line|
+          refs << self.from_string(repo, line)
+        end
+
+        refs.sort { | x, y | x.name <=> y.name }
+      end
+
+      # Create a new Ref instance from the given string.
+      #   +repo+ is the Repo
+      #   +line+ is the formatted head information
+      #
+      # Format
+      #   name: [a-zA-Z_/]+
+      #   <null byte>
+      #   id: [0-9A-Fa-f]{40}
+      #
+      # Returns Grit::Ref (baked)
+      def from_string(repo, line)
+        full_name, id = line.split("\0")
+        name = full_name.sub("#{prefix}/", '')
+        commit = Commit.create(repo, :id => id)
+        self.new(name, commit)
+      end
+
+      protected
+
+        def prefix
+          "refs/#{name.to_s.gsub(/^.*::/, '').downcase}s"
+        end
+
+    end
+
+    attr_reader :name
+    attr_reader :commit
+
+    # Instantiate a new Head
+    #   +name+ is the name of the head
+    #   +commit+ is the Commit that the head points to
+    #
+    # Returns Grit::Head (baked)
+    def initialize(name, commit)
+      @name = name
+      @commit = commit
+    end
+
+    # Pretty object inspection
+    def inspect
+      %Q{#<#{self.class.name} "#{@name}">}
+    end
+  end # Ref
+
+  # A Head is a named reference to a Commit. Every Head instance contains a name
+  # and a Commit object.
+  #
+  #   r = Grit::Repo.new("/path/to/repo")
+  #   h = r.heads.first
+  #   h.name       # => "master"
+  #   h.commit     # => #<Grit::Commit "1c09f116cbc2cb4100fb6935bb162daa4723f455">
+  #   h.commit.id  # => "1c09f116cbc2cb4100fb6935bb162daa4723f455"
+  class Head < Ref
+
+    # Get the HEAD revision of the repo.
+    #   +repo+ is the Repo
+    #   +options+ is a Hash of options
+    #
+    # Returns Grit::Head (baked)
+    def self.current(repo, options = {})
+      head = File.open(File.join(repo.path, 'HEAD')).read.chomp
+      if /ref: refs\/heads\/(.*)/.match(head)
+        self.new($1, repo.git.rev_parse(options, 'HEAD'))
+      end
+    end
+
+  end # Head
+
+  class Tag < Ref ; end
+
+  class Remote < Ref ; end
+
+end # Grit