grit 0.7.0

data/lib/grit/commit.rb

@@ -0,0 +1,169 @@
+module Grit
+  
+  class Commit
+    include Lazy
+    
+    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
+    
+    # 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 the first line of the commit message
+    #
+    # 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
+      
+      __baked__
+    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 = nil
+      @id = nil
+      @parents = nil
+      @tree = nil
+      @author = nil
+      @authored_date = nil
+      @committer = nil
+      @committed_date = nil
+      @message = nil
+      @__baked__ = nil
+      
+      @repo = repo
+      atts.each do |k, v|
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+      self
+    end
+    
+    # Use the id of this instance to populate all of the other fields
+    # when any of them are called.
+    #
+    # Returns nil
+    def __bake__
+      temp = self.class.find_all(@repo, @id, {:max_count => 1}).first
+      @parents = temp.parents
+      @tree = temp.tree
+      @author = temp.author
+      @authored_date = temp.authored_date
+      @committer = temp.committer
+      @committed_date = temp.committed_date
+      @message = temp.message
+      nil
+    end
+    
+    # Find all commits matching the given criteria.
+    #   +repo+ is the Repo
+    #   +ref+ is the ref from which to begin (SHA1 or name)
+    #   +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]
+      
+      default_options = {:pretty => "raw"}
+      actual_options = default_options.merge(options)
+      
+      output = repo.git.rev_list(actual_options, ref)
+      
+      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)
+      # remove empty lines
+      lines = text.split("\n").select { |l| !l.strip.empty? }
+      
+      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)
+        
+        messages = []
+        messages << lines.shift.strip while lines.first =~ /^ {4}/
+        message = messages.first || ''
+        
+        commits << Commit.new(repo, id, parents, tree, author, authored_date, committer, committed_date, message)
+      end
+      
+      commits
+    end
+    
+    def self.diff(repo, id)
+      text = repo.git.diff({:full_index => true}, id)
+      Diff.list_from_string(repo, text)
+    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
+  end # Commit
+  
+end # Grit

data/lib/grit/diff.rb

@@ -0,0 +1,57 @@
+module Grit
+  
+  class Diff
+    attr_reader :a_path, :b_path
+    attr_reader :a_commit, :b_commit
+    attr_reader :mode
+    attr_reader :new_file, :deleted_file
+    attr_reader :diff
+    
+    def initialize(repo, a_path, b_path, a_commit, b_commit, 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)
+      @mode = 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/(\S+) b/(\S+)$})
+        
+        new_file = false
+        deleted_file = false
+        
+        if lines.first =~ /^new file/
+          m, mode = lines.shift.match(/^new file mode (.+)$/)
+          new_file = true
+        elsif lines.first =~ /^deleted file/
+          m, mode = lines.shift.match(/^deleted file mode (.+)$/)
+          deleted_file = true
+        end
+        
+        m, a_commit, b_commit, mode = *lines.shift.match(%r{^index ([0-9A-Fa-f]+)\.\.([0-9A-Fa-f]+) ?(.+)?$})
+        mode.strip! if 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, mode, new_file, deleted_file, diff)
+      end
+      
+      diffs
+    end
+  end # Diff
+  
+end # Grit

data/lib/grit/errors.rb

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

data/lib/grit/git.rb

@@ -0,0 +1,64 @@
+module Grit
+  
+  class Git
+    class << self
+      attr_accessor :git_binary
+    end
+  
+    self.git_binary = "/usr/bin/env git"
+    
+    attr_accessor :git_dir
+    
+    def initialize(git_dir)
+      self.git_dir = git_dir
+    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)
+      opt_args = transform_options(options)
+      
+      call = "#{Git.git_binary} --git-dir='#{self.git_dir}' #{cmd.to_s.gsub(/_/, '-')} #{(opt_args + args).join(' ')}"
+      puts call if Grit.debug
+      response = `#{call}`
+      puts response if Grit.debug
+      response
+    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/lib/grit/head.rb

@@ -0,0 +1,79 @@
+module Grit
+  
+  # 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
+    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
+    
+    # Find all Heads
+    #   +repo+ is the Repo
+    #   +options+ is a Hash of options
+    #
+    # Returns Grit::Head[] (baked)
+    def self.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, "refs/heads")
+                 
+      Head.list_from_string(repo, output)
+    end
+    
+    # Parse out head information into an array of baked head objects
+    #   +repo+ is the Repo
+    #   +text+ is the text output from the git command
+    #
+    # Returns Grit::Head[] (baked)
+    def self.list_from_string(repo, text)
+      heads = []
+      
+      text.split("\n").each do |line|
+        heads << self.from_string(repo, line)
+      end
+      
+      heads
+    end
+    
+    # Create a new Head 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::Head (baked)
+    def self.from_string(repo, line)
+      full_name, id = line.split("\0")
+      name = full_name.split("/").last
+      commit = Commit.create(repo, :id => id)
+      self.new(name, commit)
+    end
+    
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Head "#{@name}">}
+    end
+  end # Head
+  
+end # Grit

data/lib/grit/lazy.rb

@@ -0,0 +1,53 @@
+# Allows attributes to be declared as lazy, meaning that they won't be
+# computed until they are asked for. Just mix this module in:
+#
+#   class Foo
+#     include Lazy
+#     ...
+#   end
+#
+# To specify a lazy reader:
+#
+#   lazy_reader :att
+#
+# Then, define a method called __bake__ that computes all your lazy
+# attributes:
+#
+#   def __bake__
+#     @att = ...
+#   end
+#
+# If you happen to have already done all the hard work, you can mark an instance
+# as already baked by calling:
+#
+#   __baked__
+#
+# That's it! (Tom Preston-Werner: rubyisawesome.com)
+module Lazy
+  module ClassMethods
+    def lazy_reader(*args)
+      args.each do |arg|
+        define_method(arg) do
+          val = instance_variable_get("@#{arg}")
+          return val if val
+          self.__prebake__
+          instance_variable_get("@#{arg}")
+        end
+      end
+    end
+  end
+  
+  def __prebake__
+    return if @__baked__
+    self.__bake__
+    @__baked__ = true
+  end
+  
+  def __baked__
+    @__baked__ = true
+  end
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end 
+end

data/lib/grit/repo.rb

@@ -0,0 +1,185 @@
+module Grit
+  
+  class Repo
+    # The path of the git repo as a String
+    attr_accessor :path
+    attr_reader :bare
+    
+    # The git command line interface object
+    attr_accessor :git
+    
+    # Create a new Repo instance
+    #   +path+ is the path to either the root git directory or the bare git repo
+    #
+    # Examples
+    #   g = Repo.new("/Users/tom/dev/grit")
+    #   g = Repo.new("/Users/tom/public/grit.git")
+    #
+    # Returns Grit::Repo
+    def initialize(path)
+      epath = File.expand_path(path)
+      
+      if File.exist?(File.join(epath, '.git'))
+        self.path = File.join(epath, '.git')
+        @bare = false
+      elsif File.exist?(epath) && epath =~ /\.git$/
+        self.path = epath
+        @bare = true
+      elsif File.exist?(epath)
+        raise InvalidGitRepositoryError.new(epath)
+      else
+        raise NoSuchPathError.new(epath)
+      end
+      
+      self.git = Git.new(self.path)
+    end
+    
+    # The project's description. Taken verbatim from GIT_REPO/description
+    #
+    # Returns String
+    def description
+      File.open(File.join(self.path, 'description')).read.chomp
+    end
+    
+    # An array of Head objects representing the branch heads in
+    # this repo
+    #
+    # Returns Grit::Head[] (baked)
+    def heads
+      Head.find_all(self)
+    end
+    
+    alias_method :branches, :heads
+    
+    # An array of Commit objects representing the history of a given ref/commit
+    #   +start+ is the branch/commit name (default 'master')
+    #   +max_count+ is the maximum number of commits to return (default 10)
+    #   +skip+ is the number of commits to skip (default 0)
+    #
+    # Returns Grit::Commit[] (baked)
+    def commits(start = 'master', max_count = 10, skip = 0)
+      options = {:max_count => max_count,
+                 :skip => skip}
+      
+      Commit.find_all(self, start, options)
+    end
+    
+    # The Commit object for the specified id
+    #   +id+ is the SHA1 identifier of the commit
+    #
+    # Returns Grit::Commit (baked)
+    def commit(id)
+      options = {:max_count => 1}
+      
+      Commit.find_all(self, id, options).first
+    end
+    
+    # The Tree object for the given treeish reference
+    #   +treeish+ is the reference (default 'master')
+    #   +paths+ is an optional Array of directory paths to restrict the tree (deafult [])
+    #
+    # Examples
+    #   Repo.tree('master', ['lib/'])
+    #
+    # Returns Grit::Tree (baked)
+    def tree(treeish = 'master', paths = [])
+      Tree.construct(self, treeish, paths)
+    end
+    
+    # The Blob object for the given id
+    #   +id+ is the SHA1 id of the blob
+    #
+    # Returns Grit::Blob (unbaked)
+    def blob(id)
+      Blob.create(self, :id => id)
+    end
+
+    # The commit log for a treeish
+    #
+    # Returns Grit::Commit[]
+    def log(commit = 'master', path = nil, options = {})
+      default_options = {:pretty => "raw"}
+      actual_options  = default_options.merge(options)
+      arg = path ? "#{commit} -- #{path}" : commit
+      commits = self.git.log(actual_options, arg)
+      Commit.list_from_string(self, commits)
+    end
+    
+    # The diff from commit +a+ to commit +b+, optionally restricted to the given file(s)
+    #   +a+ is the base commit
+    #   +b+ is the other commit
+    #   +paths+ is an optional list of file paths on which to restrict the diff
+    def diff(a, b, *paths)
+      self.git.diff({}, a, b, '--', *paths)
+    end
+    
+    # The commit diff for the given commit
+    #   +commit+ is the commit name/id
+    #
+    # Returns Grit::Diff[]
+    def commit_diff(commit)
+      Commit.diff(self, commit)
+    end
+    
+    # Initialize a bare git repository at the given path
+    #   +path+ is the full path to the repo (traditionally ends with /<name>.git)
+    #
+    # Examples
+    #   Grit::Repo.init_bare('/var/git/myrepo.git')
+    #
+    # Returns Grit::Repo (the newly created repo)
+    def self.init_bare(path)
+      git = Git.new(path)
+      git.init
+      self.new(path)
+    end
+    
+    # Archive the given treeish
+    #   +treeish+ is the treeish name/id (default 'master')
+    #   +prefix+ is the optional prefix
+    #
+    # Examples
+    #   repo.archive_tar
+    #   # => <String containing tar archive>
+    #
+    #   repo.archive_tar('a87ff14')
+    #   # => <String containing tar archive for commit a87ff14>
+    #
+    #   repo.archive_tar('master', 'myproject/')
+    #   # => <String containing tar archive and prefixed with 'myproject/'>
+    #
+    # Returns String (containing tar archive)
+    def archive_tar(treeish = 'master', prefix = nil)
+      options = {}
+      options[:prefix] = prefix if prefix
+      self.git.archive(options, treeish)
+    end
+    
+    # Archive and gzip the given treeish
+    #   +treeish+ is the treeish name/id (default 'master')
+    #   +prefix+ is the optional prefix
+    #
+    # Examples
+    #   repo.archive_tar_gz
+    #   # => <String containing tar.gz archive>
+    #
+    #   repo.archive_tar_gz('a87ff14')
+    #   # => <String containing tar.gz archive for commit a87ff14>
+    #
+    #   repo.archive_tar_gz('master', 'myproject/')
+    #   # => <String containing tar.gz archive and prefixed with 'myproject/'>
+    #
+    # Returns String (containing tar.gz archive)
+    def archive_tar_gz(treeish = 'master', prefix = nil)
+      options = {}
+      options[:prefix] = prefix if prefix
+      self.git.archive(options, treeish, "| gzip")
+    end
+    
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Repo "#{@path}">}
+    end
+  end # Repo
+  
+end # Grit