git 1.0.1

data/lib/git/index.rb

@@ -0,0 +1,4 @@
+module Git
+  class Index < Git::Path
+  end
+end

data/lib/git/lib.rb

@@ -0,0 +1,344 @@
+module Git
+  
+  class GitExecuteError < StandardError 
+  end
+  
+  class Lib
+      
+    @git_dir = nil
+    @git_index_file = nil
+    @git_work_dir = nil
+    @path = nil
+        
+    def initialize(base = nil)
+      if base.is_a?(Git::Base)
+        @git_dir = base.repo.path
+        @git_index_file = base.index.path   
+        @git_work_dir = base.dir.path
+      elsif base.is_a?(Hash)
+        @git_dir = base[:repository]
+        @git_index_file = base[:index] 
+        @git_work_dir = base[:working_directory]
+      end
+    end
+    
+    def init
+      command('init')
+    end
+    
+    # tries to clone the given repo
+    #
+    # returns {:repository} (if bare)
+    #         {:working_directory} otherwise
+    #
+    # accepts options:
+    #  :remote - name of remote (rather than 'origin')
+    #  :bare   - no working directory
+    # 
+    # TODO - make this work with SSH password or auth_key
+    #
+    def clone(repository, name, opts = {})
+      @path = opts[:path] || '.'
+      opts[:path] ? clone_dir = File.join(@path, name) : clone_dir = name
+      
+      arr_opts = []
+      arr_opts << "--bare" if opts[:bare]
+      arr_opts << "-o #{opts[:remote]}" if opts[:remote]
+      arr_opts << repository
+      arr_opts << clone_dir
+      
+      command('clone', arr_opts)
+      
+      opts[:bare] ? {:repository => clone_dir} : {:working_directory => clone_dir}
+    end
+    
+    
+    ## READ COMMANDS ##
+    
+    
+    def log_commits(opts = {})
+      arr_opts = ['--pretty=oneline']
+      arr_opts << "-#{opts[:count]}" if opts[:count]
+      arr_opts << "--since=\"#{opts[:since]}\"" if opts[:since].is_a? String
+      arr_opts << "#{opts[:between][0]}..#{opts[:between][1].to_s}" if (opts[:between] && opts[:between].size == 2)
+      arr_opts << opts[:object] if opts[:object].is_a? String
+      arr_opts << '-- ' + opts[:path_limiter] if opts[:path_limiter].is_a? String
+      
+      command_lines('log', arr_opts).map { |l| l.split.first }
+    end
+    
+    def revparse(string)
+      command('rev-parse', string)
+    end
+    
+    def object_type(sha)
+      command('cat-file', ['-t', sha])
+    end
+    
+    def object_size(sha)
+      command('cat-file', ['-s', sha]).to_i
+    end
+    
+    def object_contents(sha)
+      command('cat-file', ['-p', sha])
+    end
+
+    def branches_all
+      arr = []
+      command_lines('branch', '-a').each do |b| 
+        current = false
+        current = true if b[0, 2] == '* '
+        arr << [b.gsub('* ', '').strip, current]
+      end
+      arr
+    end
+
+    def branch_current
+      branches_all.select { |b| b[1] }.first[0] rescue nil
+    end
+
+
+    # returns hash
+    # [tree-ish] = [[line_no, match], [line_no, match2]]
+    # [tree-ish] = [[line_no, match], [line_no, match2]]
+    def grep(string, opts = {})
+      opts[:object] = 'HEAD' if !opts[:object]
+
+      grep_opts = ['-n']
+      grep_opts << '-i' if opts[:ignore_case]
+      grep_opts << '-v' if opts[:invert_match]
+      grep_opts << "-e '#{string}'"
+      grep_opts << opts[:object] if opts[:object].is_a?(String)
+      grep_opts << ('-- ' + opts[:path_limiter]) if opts[:path_limiter].is_a? String
+      hsh = {}
+      command_lines('grep', grep_opts).each do |line|
+        if m = /(.*)\:(\d+)\:(.*)/.match(line)        
+          hsh[m[1]] ||= []
+          hsh[m[1]] << [m[2].to_i, m[3]] 
+        end
+      end
+      hsh
+    end
+    
+    def diff_full(obj1 = 'HEAD', obj2 = nil, opts = {})
+      diff_opts = ['-p']
+      diff_opts << obj1
+      diff_opts << obj2 if obj2.is_a?(String)
+      diff_opts << ('-- ' + opts[:path_limiter]) if opts[:path_limiter].is_a? String
+      
+      command('diff', diff_opts)
+    end
+    
+    def diff_stats(obj1 = 'HEAD', obj2 = nil, opts = {})
+      diff_opts = ['--numstat']
+      diff_opts << obj1
+      diff_opts << obj2 if obj2.is_a?(String)
+      diff_opts << ('-- ' + opts[:path_limiter]) if opts[:path_limiter].is_a? String
+      
+      hsh = {:total => {:insertions => 0, :deletions => 0, :lines => 0, :files => 0}, :files => {}}
+      
+      command_lines('diff', diff_opts).each do |file|
+        (insertions, deletions, filename) = file.split("\t")
+        hsh[:total][:insertions] += insertions.to_i
+        hsh[:total][:deletions] += deletions.to_i
+        hsh[:total][:lines] = (hsh[:total][:deletions] + hsh[:total][:insertions])
+        hsh[:total][:files] += 1
+        hsh[:files][filename] = {:insertions => insertions.to_i, :deletions => deletions.to_i}
+      end
+            
+      hsh
+    end
+
+    # compares the index and the working directory
+    def diff_files
+      hsh = {}
+      command_lines('diff-files').each do |line|
+        (info, file) = line.split("\t")
+        (mode_src, mode_dest, sha_src, sha_dest, type) = info.split
+        hsh[file] = {:path => file, :mode_file => mode_src.to_s[1, 7], :mode_index => mode_dest, 
+                      :sha_file => sha_src, :sha_index => sha_dest, :type => type}
+      end
+      hsh
+    end
+    
+    # compares the index and the repository
+    def diff_index(treeish)
+      hsh = {}
+      command_lines('diff-index', treeish).each do |line|
+        (info, file) = line.split("\t")
+        (mode_src, mode_dest, sha_src, sha_dest, type) = info.split
+        hsh[file] = {:path => file, :mode_repo => mode_src.to_s[1, 7], :mode_index => mode_dest, 
+                      :sha_repo => sha_src, :sha_index => sha_dest, :type => type}
+      end
+      hsh
+    end
+            
+    def ls_files
+      hsh = {}
+      command_lines('ls-files', '--stage').each do |line|
+        (info, file) = line.split("\t")
+        (mode, sha, stage) = info.split
+        hsh[file] = {:path => file, :mode_index => mode, :sha_index => sha, :stage => stage}
+      end
+      hsh
+    end
+
+
+    def config_remote(name)
+      hsh = {}
+      command_lines('config', ['--get-regexp', "remote.#{name}"]).each do |line|
+        (key, value) = line.split
+        hsh[key.gsub("remote.#{name}.", '')] = value
+      end
+      hsh
+    end
+
+    def config_get(name)
+      command('config', ['--get', name])
+    end
+    
+    def config_list
+      hsh = {}
+      command_lines('config', ['--list']).each do |line|
+        (key, value) = line.split('=')
+        hsh[key] = value
+      end
+      hsh
+    end
+    
+    ## WRITE COMMANDS ##
+        
+    def config_set(name, value)
+      command('config', [name, "'#{value}'"])
+    end
+          
+    def add(path = '.')
+      path = path.join(' ') if path.is_a?(Array)
+      command('add', path)
+    end
+    
+    def remove(path = '.', opts = {})
+      path = path.join(' ') if path.is_a?(Array)
+
+      arr_opts = ['-f']  # overrides the up-to-date check by default
+      arr_opts << ['-r'] if opts[:recursive]
+      arr_opts << path
+
+      command('rm', arr_opts)
+    end
+
+    def commit(message, opts = {})
+      arr_opts = ["-m '#{message}'"]
+      arr_opts << '-a' if opts[:add_all]
+      command('commit', arr_opts)
+    end
+
+    def reset(commit, opts = {})
+      arr_opts = []
+      arr_opts << '--hard' if opts[:hard]
+      arr_opts << commit.to_s if commit
+      command('reset', arr_opts)
+    end
+
+
+    def branch_new(branch)
+      command('branch', branch)
+    end
+    
+    def branch_delete(branch)
+      command('branch', ['-d', branch])
+    end
+    
+    def checkout(branch, opts = {})
+      arr_opts = []
+      arr_opts << '-f' if opts[:force]
+      arr_opts << branch.to_s
+      
+      command('checkout', arr_opts)
+    end
+    
+    def merge(branch, message = nil)      
+      arr_opts = []
+      arr_opts << ["-m '#{message}'"] if message
+      arr_opts << branch.to_a.join(' ')
+      command('merge', arr_opts)
+    end
+    
+    def remote_add(name, url, opts = {})
+      arr_opts = ['add']
+      arr_opts << '-f' if opts[:with_fetch]
+      arr_opts << name
+      arr_opts << url
+      
+      command('remote', arr_opts)
+    end
+    
+    # this is documented as such, but seems broken for some reason
+    # i'll try to get around it some other way later
+    def remote_remove(name)
+      command('remote', ['rm', name])
+    end
+    
+    def remotes
+      command_lines('remote')
+    end
+
+    def tags
+      command_lines('tag')
+    end
+
+    def tag(tag)
+      command('tag', tag)
+    end
+
+    
+    def fetch(remote)
+      command('fetch', remote.to_s)
+    end
+    
+    def push(remote, branch = 'master')
+      command('push', [remote.to_s, branch.to_s])
+    end
+    
+    def tag_sha(tag_name)
+      command('show-ref',  ['--tags', '-s', tag_name])
+    end  
+    
+    def repack
+      command('repack', ['-a', '-d'])
+    end
+    
+    private
+    
+    def command_lines(cmd, opts = {})
+      command(cmd, opts).split("\n")
+    end
+    
+    def command(cmd, opts = {})
+      ENV['GIT_DIR'] = @git_dir 
+      ENV['GIT_INDEX_FILE'] = @git_index_file 
+      ENV['GIT_WORK_DIR'] = @git_work_dir 
+      path = @git_work_dir || @git_dir || @path
+      Dir.chdir(path) do  
+        opts = opts.to_a.join(' ')
+        git_cmd = "git #{cmd} #{opts}"
+        out = `git #{cmd} #{opts} 2>&1`.chomp
+        #puts path
+        #puts "gd: #{@git_work_dir}"
+        #puts "gi: #{@git_index_file}"
+        #puts "pp: #{@path}"
+        #puts git_cmd
+        #puts out
+        #puts
+        if $?.exitstatus > 0
+          if $?.exitstatus == 1 && out == ''
+            return ''
+          end
+          raise Git::GitExecuteError.new(git_cmd + ':' + out.to_s)
+        end
+        out
+      end
+    end
+    
+  end
+end

data/lib/git/log.rb

@@ -0,0 +1,94 @@
+module Git
+  
+  # object that holds the last X commits on given branch
+  class Log
+    include Enumerable
+    
+    @base = nil
+    @commits = nil
+    
+    @object = nil
+    @path = nil
+    @count = nil
+    @since = nil
+    @between = nil
+    
+    @dirty_flag = nil
+    
+    def initialize(base, count = 30)
+      dirty_log
+      @base = base
+      @count = count
+    end
+
+    def object(objectish)
+      dirty_log
+      @object = objectish
+      return self
+    end
+    
+    def path(path)
+      dirty_log
+      @path = path
+      return self
+    end
+    
+    def since(date)
+      dirty_log
+      @since = date
+      return self
+    end
+    
+    def between(sha1, sha2 = nil)
+      dirty_log
+      @between = [@base.lib.revparse(sha1), @base.lib.revparse(sha2)]
+      return self
+    end
+    
+    def to_s
+      self.map { |c| c.sha }.join("\n")
+    end
+    
+
+    # forces git log to run
+    
+    def size
+      check_log
+      @commits.size rescue nil
+    end
+    
+    def each
+      check_log
+      @commits.each do |c|
+        yield c
+      end
+    end
+    
+    def first
+      check_log
+      @commits.first rescue nil
+    end
+    
+    private 
+    
+      def dirty_log
+        @dirty_flag = true
+      end
+      
+      def check_log
+        if @dirty_flag
+          run_log
+          @dirty_flag = false
+        end
+      end
+      
+      # actually run the 'git log' command
+      def run_log      
+        log = @base.lib.log_commits(:count => @count, :object => @object, 
+                                    :path_limiter => @path, :since => @since, :between => @between)
+        @commits = log.map { |l| Git::Object::Commit.new(@base, l) }
+      end
+      
+  end
+  
+end

data/lib/git/object.rb

@@ -0,0 +1,110 @@
+module Git
+  
+  class GitTagNameDoesNotExist< StandardError 
+  end
+  
+  class Object
+    
+    class AbstractObject
+      attr_accessor :sha, :size, :type, :mode
+    
+      @base = nil
+    
+      def initialize(base, sha)
+        @base = base
+        @sha = sha
+        @size = @base.lib.object_size(@sha)
+        setup
+      end
+    
+      def contents
+        @base.lib.object_contents(@sha)
+      end
+      
+      def contents_array
+        self.contents.split("\n")
+      end
+      
+      def setup
+        raise NotImplementedError
+      end
+      
+      def to_s
+        @sha
+      end
+      
+      def grep(string, path_limiter = nil, opts = {})
+        default = {:object => @sha, :path_limiter => path_limiter}
+        grep_options = default.merge(opts)
+        @base.lib.grep(string, grep_options)
+      end
+      
+      def diff(objectish)
+        Git::Diff.new(@base, @sha, objectish)
+      end
+      
+      def log(count = 30)
+        Git::Log.new(@base, count).object(@sha)
+      end
+      
+    end
+  
+    
+    class Blob < AbstractObject
+      def setup
+        @type = 'blob'
+      end
+    end
+  
+    class Tree < AbstractObject
+      def setup
+        @type = 'tree'
+      end
+    end
+  
+    class Commit < AbstractObject
+      def setup
+        @type = 'commit'
+      end
+    end
+  
+    class Tag < AbstractObject
+      attr_accessor :name
+      
+      def initialize(base, sha, name)
+        super(base, sha)
+        @name = name
+      end
+      
+      def setup
+        @type = 'tag'
+      end
+    end
+    
+    class << self
+      # if we're calling this, we don't know what type it is yet
+      # so this is our little factory method
+      def new(base, objectish, is_tag = false)
+        if is_tag
+          sha = base.lib.tag_sha(objectish)
+          if sha == ''
+            raise Git::GitTagNameDoesNotExist.new(objectish)
+          end
+          return Tag.new(base, sha, objectish)
+        else
+          sha = base.lib.revparse(objectish)
+          type = base.lib.object_type(sha) 
+        end
+        
+        klass =
+          case type
+          when /blob/:   Blob   
+          when /commit/: Commit
+          when /tree/:   Tree
+          end
+        klass::new(base, sha)
+      end
+    end 
+    
+  end
+end