git 1.0.1

data/lib/git.rb

@@ -0,0 +1,50 @@
+
+# Add the directory containing this file to the start of the load path if it
+# isn't there already.
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'git/base'
+require 'git/path'
+require 'git/lib'
+
+require 'git/repository'
+require 'git/index'
+require 'git/working_directory'
+
+require 'git/log'
+require 'git/object'
+
+require 'git/branches'
+require 'git/branch'
+require 'git/remote'
+
+require 'git/diff'
+require 'git/status'
+=begin
+require 'git/author'
+require 'git/file'
+
+require 'git/sha'
+require 'git/ref'
+=end
+
+module Git
+  
+  def self.bare(git_dir)
+    Base.bare(git_dir)
+  end
+    
+  def self.open(working_dir, options = {})
+    Base.open(working_dir, options)
+  end
+
+  def self.init(working_dir = '.', options = {})
+    Base.init(working_dir, options)
+  end
+
+  def self.clone(repository, name, options = {})
+    Base.clone(repository, name, options)
+  end
+    
+end

data/lib/git/base.rb

@@ -0,0 +1,251 @@
+module Git
+  
+  class Base
+
+    @working_directory = nil
+    @repository = nil
+    @index = nil
+
+    # opens a bare Git Repository - no working directory options
+    def self.bare(git_dir)
+      self.new :repository => git_dir
+    end
+    
+    # opens a new Git Project from a working directory
+    # you can specify non-standard git_dir and index file in the options
+    def self.open(working_dir, opts={})    
+      default = {:working_directory => working_dir}
+      git_options = default.merge(opts)
+      
+      self.new(git_options)
+    end
+
+    # initializes a git repository
+    #
+    # options:
+    #  :repository
+    #  :index_file
+    #
+    def self.init(working_dir, opts = {})
+      default = {:working_directory => working_dir,
+                 :repository => File.join(working_dir, '.git')}
+      git_options = default.merge(opts)
+      
+      if git_options[:working_directory]
+        # if !working_dir, make it
+        FileUtils.mkdir_p(git_options[:working_directory]) if !File.directory?(git_options[:working_directory])
+      end
+      
+      # run git_init there
+      Git::Lib.new(git_options).init
+       
+      self.new(git_options)
+    end
+
+    # clones a git repository locally
+    #
+    #  repository - http://repo.or.cz/w/sinatra.git
+    #  name - sinatra
+    #
+    # options:
+    #   :repository
+    #
+    #    :bare
+    #   or 
+    #    :working_directory
+    #    :index_file
+    #
+    def self.clone(repository, name, opts = {})
+      # run git-clone 
+      self.new(Git::Lib.new.clone(repository, name, opts))
+    end
+        
+    def initialize(options = {})
+      if working_dir = options[:working_directory]
+        options[:repository] = File.join(working_dir, '.git') if !options[:repository]
+        options[:index] = File.join(working_dir, '.git', 'index') if !options[:index]
+      end
+      
+      @working_directory = Git::WorkingDirectory.new(options[:working_directory]) if options[:working_directory]
+      @repository = Git::Repository.new(options[:repository]) if options[:repository]
+      @index = Git::Index.new(options[:index], false) if options[:index]
+    end
+  
+  
+    def dir
+      @working_directory
+    end
+
+    def repo
+      @repository
+    end
+    
+    def index
+      @index
+    end
+    
+    def chdir
+      Dir.chdir(dir.path) do
+        yield dir.path
+      end
+    end
+    
+    def repo_size
+      size = 0
+      Dir.chdir(repo.path) do
+        (size, dot) = `du -d0`.chomp.split
+      end
+      size.to_i
+    end
+    
+    #g.config('user.name', 'Scott Chacon') # sets value
+    #g.config('user.email', 'email@email.com')  # sets value
+    #g.config('user.name')  # returns 'Scott Chacon'
+    #g.config # returns whole config hash
+    def config(name = nil, value = nil)
+      if(name && value)
+        # set value
+        lib.config_set(name, value)
+      elsif (name)
+        # return value
+        lib.config_get(name)
+      else
+        # return hash
+        lib.config_list
+      end
+    end
+    
+    # factory methods
+    
+    def object(objectish)
+      Git::Object.new(self, objectish)
+    end
+    alias_method :gtree, :object
+    alias_method :gcommit, :object
+    alias_method :gblob, :object
+    
+    
+    def log(count = 30)
+      Git::Log.new(self, count)
+    end
+
+    def status
+      Git::Status.new(self)
+    end
+        
+    def branches
+      Git::Branches.new(self)
+    end
+    
+    def branch(branch_name = 'master')
+      Git::Branch.new(self, branch_name)
+    end
+
+    def remote(remote_name = 'origin')
+      Git::Remote.new(self, remote_name)
+    end
+
+    
+    def lib
+      Git::Lib.new(self)
+    end
+    
+    def grep(string)
+      self.object('HEAD').grep(string)
+    end
+    
+    def diff(objectish = 'HEAD', obj2 = nil)
+      Git::Diff.new(self, objectish, obj2)
+    end
+    
+    # adds files from the working directory to the git repository
+    def add(path = '.')
+      self.lib.add(path)
+    end
+
+    def remove(path = '.', opts = {})
+      self.lib.remove(path, opts)
+    end
+
+    def reset(commitish = nil, opts = {})
+      self.lib.reset(commitish, opts)
+    end
+
+    def reset_hard(commitish = nil, opts = {})
+      opts = {:hard => true}.merge(opts)
+      self.lib.reset(commitish, opts)
+    end
+
+    def commit(message, opts = {})
+      self.lib.commit(message, opts)
+    end
+        
+    def commit_all(message, opts = {})
+      opts = {:add_all => true}.merge(opts)
+      self.lib.commit(message, opts)
+    end
+
+    def checkout(branch = 'master', opts = {})
+      self.lib.checkout(branch, opts)
+    end
+    
+    def fetch(remote = 'origin')
+      self.lib.fetch(remote)
+    end
+
+    def push(remote = 'origin', branch = 'master')
+      self.lib.push(remote, branch)
+    end
+    
+    def merge(branch, message = 'merge')
+      self.lib.merge(branch, message)
+    end
+
+    def pull(remote = 'origin', branch = 'master', message = 'origin pull')
+      fetch(remote)
+      merge(branch, message)
+    end
+    
+    def remotes
+      self.lib.remotes.map { |r| Git::Remote.new(self, r) }
+    end
+    
+    def add_remote(name, url, opts = {})
+      if url.is_a?(Git::Base)
+        url = url.repo.path
+      end
+      self.lib.remote_add(name, url, opts)
+      Git::Remote.new(self, name)
+    end
+
+    def tags
+      self.lib.tags.map { |r| tag(r) }
+    end
+    
+    def tag(tag_name)
+      Git::Object.new(self, tag_name, true)
+    end
+
+    def add_tag(tag_name)
+      self.lib.tag(tag_name)
+      tag(tag_name)
+    end
+    
+    # convenience methods
+
+    def repack
+      self.lib.repack
+    end
+    
+    def revparse(objectish)
+      self.lib.revparse(objectish)
+    end
+
+    def current_branch
+      self.lib.branch_current
+    end
+
+    
+  end
+  
+end

data/lib/git/branch.rb

@@ -0,0 +1,94 @@
+module Git
+  class Branch < Path
+    
+    attr_accessor :full, :remote, :name
+    
+    @base = nil
+    @gcommit = nil
+    
+    def initialize(base, name)
+      @remote = nil
+      @full = name
+      @base = base
+      
+      parts = name.split('/')
+      if parts[1]
+        @remote = Git::Remote.new(@base, parts[0])
+        @name = parts[1]
+      else
+        @name = parts[0]
+      end
+    end
+    
+    def gcommit
+      @gcommit = @base.object(name) if !@gcommit
+      @gcommit
+    end
+    
+    def checkout
+      check_if_create
+      @base.checkout(@name)
+    end
+    
+    
+    # g.branch('new_branch').in_branch do
+    #   # create new file
+    #   # do other stuff
+    #   return true # auto commits and switches back
+    # end
+    def in_branch (message = 'in branch work')
+      old_current = @base.lib.branch_current
+      checkout
+      if yield
+        @base.commit_all(message)
+      else
+        @base.reset_hard
+      end
+      @base.checkout(old_current)
+    end
+    
+    def create
+      check_if_create
+    end
+    
+    def delete
+      @base.lib.branch_delete(@name)
+    end
+    
+    def current
+      determine_current
+    end
+    
+    def merge(branch = nil, message = nil)
+      if branch
+        in_branch do 
+          @base.merge(branch, message)
+          false
+        end
+        # merge a branch into this one
+      else
+        # merge this branch into the current one
+        @base.merge(@name)
+      end
+    end
+    
+    def to_a
+      [@full]
+    end
+    
+    def to_s
+      @full
+    end
+    
+    private 
+
+      def check_if_create
+        @base.lib.branch_new(@name) rescue nil
+      end
+      
+      def determine_current
+        @base.lib.branch_current == @name
+      end
+    
+  end
+end

data/lib/git/branches.rb

@@ -0,0 +1,45 @@
+module Git
+  
+  # object that holds all the available branches
+  class Branches
+    include Enumerable
+    
+    @base = nil
+    @branches = nil
+    
+    def initialize(base)
+      @branches = {}
+      
+      @base = base
+            
+      @base.lib.branches_all.each do |b|
+        @branches[b[0]] = Git::Branch.new(@base, b[0])
+      end
+    end
+
+    def local
+      self.select { |b| !b.remote }
+    end
+    
+    def remote
+      self.select { |b| b.remote }
+    end
+    
+    # array like methods
+
+    def size
+      @branches.size
+    end    
+    
+    def each
+      @branches.each do |k, b|
+        yield b
+      end
+    end
+    
+    def [](symbol)
+      @branches[symbol.to_s]
+    end
+    
+  end
+end

data/lib/git/diff.rb

@@ -0,0 +1,143 @@
+module Git
+  
+  # object that holds the last X commits on given branch
+  class Diff
+    include Enumerable
+    
+    @base = nil
+    @from = nil
+    @to = nil
+    @path = nil
+    
+    @full_diff = nil
+    @full_diff_files = nil
+    @stats = nil
+    
+    def initialize(base, from = nil, to = nil)
+      @base = base
+      @from = from.to_s
+      @to = to.to_s
+    end
+    
+    def path(path)
+      @path = path
+      return self
+    end
+    
+    def size
+      cache_stats
+      @stats[:total][:files]
+    end
+    
+    def lines
+      cache_stats
+      @stats[:total][:lines]
+    end
+    
+    def deletions
+      cache_stats
+      @stats[:total][:deletions]
+    end
+    
+    def insertions
+      cache_stats
+      @stats[:total][:insertions]
+    end
+    
+    def stats
+      cache_stats
+      @stats
+    end
+    
+    # if file is provided and is writable, it will write the patch into the file
+    def patch(file = nil)
+      cache_full
+      @full_diff
+    end
+    alias_method :to_s, :patch
+    
+    # enumerable methods
+    
+    def [](key)
+      process_full
+      @full_diff_files.assoc(key)[1]
+    end
+    
+    def each
+      process_full
+      @full_diff_files.each do |file|
+        yield file[1]
+      end
+    end
+    
+    class DiffFile
+      attr_accessor :patch, :path, :mode, :src, :dst, :type
+      @base = nil
+      
+      def initialize(base, hash)
+        @base = base
+        @patch = hash[:patch]
+        @path = hash[:path]
+        @mode = hash[:mode]
+        @src = hash[:src]
+        @dst = hash[:dst]
+        @type = hash[:type]
+      end
+      
+      def blob(type = :dst)
+        if type == :src
+          @base.object(@src) if @src != '0000000'
+        else
+          @base.object(@dst) if @dst != '0000000'
+        end
+      end
+    end
+    
+    private
+    
+      def cache_full
+        if !@full_diff
+          @full_diff = @base.lib.diff_full(@from, @to, {:path_limiter => @path})
+        end
+      end
+      
+      def process_full
+        if !@full_diff_files
+          cache_full
+          @full_diff_files = process_full_diff
+        end
+      end
+      
+      def cache_stats
+        if !@stats
+          @stats = @base.lib.diff_stats(@from, @to, {:path_limiter => @path})
+        end
+      end
+      
+      # break up @diff_full
+      def process_full_diff
+        final = {}
+        current_file = nil
+        @full_diff.split("\n").each do |line|
+          if m = /diff --git a\/(.*?) b\/(.*?)/.match(line)
+            current_file = m[1]
+            final[current_file] = {:patch => line, :path => current_file, 
+                                    :mode => '', :src => '', :dst => '', :type => 'modified'}
+          else
+            if m = /index (.......)\.\.(.......)( ......)*/.match(line)
+              final[current_file][:src] = m[1]
+              final[current_file][:dst] = m[2]
+              final[current_file][:mode] = m[3].strip if m[3]
+            end
+            if m = /(.*?) file mode (......)/.match(line)
+              final[current_file][:type] = m[1]
+              final[current_file][:mode] = m[2]
+            end
+            final[current_file][:patch] << "\n" + line 
+          end
+        end
+        final.map { |e| [e[0], DiffFile.new(@base, e[1])] }
+      end
+      
+  end
+end