square-circle-triangle-grit 1.1.2

data/API.txt

@@ -0,0 +1,101 @@
+== TODO ==
+
+* Add remote branch references (Grit::Remote)
+* Add status - what is modified, staged
+
+g.checkout('new_branch')
+g.checkout(g.branch('new_branch'))
+
+g.branch(name).merge(branch2)
+g.branch(branch2).merge  # merges HEAD with branch2
+
+g.branch(name).in_branch(message) { # add files }  # auto-commits
+g.merge('new_branch')
+g.merge('origin/remote_branch')
+g.merge(b.branch('master'))
+g.merge([branch1, branch2])
+
+r = g.add_remote(name, uri)  # Git::Remote
+r = g.add_remote(name, Git::Base)  # Git::Remote
+
+g.remotes  # array of Git::Remotes
+g.remote(name).fetch
+g.remote(name).remove
+g.remote(name).merge
+g.remote(name).merge(branch)
+
+g.fetch
+g.fetch(g.remotes.first)
+
+g.pull
+g.pull(Git::Repo, Git::Branch) # fetch and a merge
+
+g.add_tag('tag_name') # returns Git::Tag
+
+g.repack
+
+g.push
+g.push(g.remote('name'))
+   
+g.reset # defaults to HEAD
+g.reset_hard(Git::Commit)
+
+g.branch('new_branch') # creates new or fetches existing
+g.branch('new_branch').checkout
+g.branch('new_branch').delete
+g.branch('existing_branch').checkout
+
+
+
+
+
+require 'mojombo-grit'
+
+include Grit
+Grit.debug
+Grit.use_pure_ruby
+
+repo = Repo.new("/Users/tom/dev/grit")
+
+= Commit Log
+
+repo.commits('mybranch')
+repo.commits('40d3057d09a7a4d61059bca9dca5ae698de58cbe')
+repo.commits('v0.1')
+
+repo.log('mybranch', 100, 20)
+
+head = repo.commits.first
+head.id
+# => "e80bbd2ce67651aa18e57fb0b43618ad4baf7750"
+head.parents
+# => [#<Grit::Commit "91169e1f5fa4de2eaea3f176461f5dc784796769">]
+head.tree
+# => #<Grit::Tree "3536eb9abac69c3e4db583ad38f3d30f8db4771f">
+head.author
+# => #<Grit::Actor "Tom Preston-Werner <tom@mojombo.com>">
+head.authored_date
+# => Wed Oct 24 22:02:31 -0700 2007
+head.committer
+# => #<Grit::Actor "Tom Preston-Werner <tom@mojombo.com>">
+head.committed_date
+# => Wed Oct 24 22:02:31 -0700 2007
+head.message
+# => "add Actor inspect"
+contents = tree.contents
+  # => [#<Grit::Blob "4ebc8aea50e0a67e000ba29a30809d0a7b9b2666">,
+        #<Grit::Blob "81d2c27608b352814cbe979a6acd678d30219678">,
+        #<Grit::Tree "c3d07b0083f01a6e1ac969a0f32b8d06f20c62e5">,
+        #<Grit::Tree "4d00fe177a8407dbbc64a24dbfc564762c0922d8">]
+blob.id
+# => "4ebc8aea50e0a67e000ba29a30809d0a7b9b2666"
+blob.name
+# => "README.txt"
+blob.mode
+# => "100644"
+blob.size
+# => 7726
+blob.data
+
+repo.blob("4ebc8aea50e0a67e000ba29a30809d0a7b9b2666")
+# => #<Grit::Blob "4ebc8aea50e0a67e000ba29a30809d0a7b9b2666">

data/History.txt

@@ -0,0 +1,49 @@
+== 1.1.0 / 2009-03-29
+  * Backwards breaking changes
+    * Diff#a_commit -> Diff#a_blob, Diff#b_commit -> Diff#b_blob
+  * Major Enhancments
+    * Ruby 1.9 compatibility [github.com/chapados, github.com/js]
+  * Minor Enhancements
+    * Convert readme to markdown
+    * Added a shortcut for commit_stats as Commit#stats [github.com/js]
+    * Add a #basename method to Submodule, Blob and Tree for retrieving the name [github.com/js]
+    * Make Grit::Submodule grasp the concept of non-unix lineendings [github.com/js]
+    * Added Repo#commit_deltas_from [github.com/js]
+    * do some mild shell escaping when running commands [github.com/js]
+    * Added two shortcut methods to Tree, for picking trees/blobs only [github.com/Voker57]
+    * Added <=> method to Blob, needed for sorting tree [github.com/Voker57]
+    * Make the number of bytes to be read from git's stdout configurable [github.com/josb]
+    * Repo.archive_to_file accepts extra parameters making plain zipping possible [github.com/darwin]
+    * Handle commit stats that summarize commits with binary changes [github.com/therealadam]
+    * Add a DiffStat class for easy access to diff stats [github.com/therealadam]
+    * Don't split git logs that contain blank lines into two CommitStats [github.com/therealadam]
+    * Add DiffStat#net for total change count [github.com/therealadam]
+
+== 1.0.3 / 2009-02-13
+  * Minor Enhancements
+    * Added Grit::Commit#to_patch for plaintext formatted patches.
+    * Fixed Grit::Tag to work with annotated tags.
+
+== 1.0.2 / 2009-02-10
+  * Minor Enhancements
+    * Implement Grit.version to use VERSION.yml file
+
+== 1.0.1 / 2009-02-10
+  * Bug Fixes
+    * Add diff-lcs as a dependency
+
+== 1.0.0 / 2009-01-27
+  * Tons of awesome in here. Also, we suck at updating the history.
+  * Let's do better at that from now on.
+
+== 0.8.3 / 2008-07-07
+  * Capture stderr and log if debug is true (rsanheim)
+  
+== 0.8.2 / 2008-06-27
+  * Allow user provided logger (rsanheim)
+  
+== 0.8.0 / 2008-04-24
+  * Lots of fixes and additions
+
+== 0.7.0 / 2008-01-07
+  * First public release!

data/README.md

@@ -0,0 +1,210 @@
+Grit
+====
+
+Grit gives you object oriented read/write access to Git repositories via Ruby.
+The main goals are stability and performance. To this end, some of the
+interactions with Git repositories are done by shelling out to the system's
+`git` command, and other interactions are done with pure Ruby
+reimplementations of core Git functionality. This choice, however, is
+transparent to end users, and you need not know which method is being used.
+
+This software was developed to power GitHub, and should be considered
+production ready. An extensive test suite is provided to verify its correctness.
+
+Grit is maintained by Tom Preston-Werner, Scott Chacon, Chris Wanstrath, and
+PJ Hyett.
+
+This documentation is accurate as of Grit 1.0.2.
+
+
+## Requirements #############################################################
+
+* git (http://git-scm.com) tested with 1.6.0.2
+
+
+## Install ##################################################################
+
+Easiest install is via RubyGems:
+
+    $ gem install grit
+
+or
+
+    $ gem sources -a http://gems.github.com/ (you only need to do this once)
+    $ gem install mojombo-grit
+
+The gem from GitHub will generally be available sooner than the gem from
+Rubyforge. Both sources will eventually contain the same releases.
+
+
+## Source ###################################################################
+
+Grit's Git repo is available on GitHub, which can be browsed at:
+
+    http://github.com/mojombo/grit
+
+and cloned with:
+
+    git clone git://github.com/mojombo/grit.git
+
+
+## Usage ####################################################################
+
+Grit gives you object model access to your Git repositories. Once you have
+created a `Repo` object, you can traverse it to find parent commits,
+trees, blobs, etc.
+
+### Initialize a Repo object
+
+The first step is to create a `Grit::Repo` object to represent your repo. In
+this documentation I include the `Grit` module to reduce typing.
+
+    require 'grit'
+    include Grit
+    repo = Repo.new("/Users/tom/dev/grit")
+
+In the above example, the directory `/Users/tom/dev/grit` is my working
+directory and contains the `.git` directory. You can also initialize Grit with
+a bare repo.
+
+    repo = Repo.new("/var/git/grit.git")
+
+### Getting a list of commits
+
+From the `Repo` object, you can get a list of commits as an array of `Commit`
+objects.
+
+    repo.commits
+    # => [#<Grit::Commit "e80bbd2ce67651aa18e57fb0b43618ad4baf7750">,
+          #<Grit::Commit "91169e1f5fa4de2eaea3f176461f5dc784796769">,
+          #<Grit::Commit "038af8c329ef7c1bae4568b98bd5c58510465493">,
+          #<Grit::Commit "40d3057d09a7a4d61059bca9dca5ae698de58cbe">,
+          #<Grit::Commit "4ea50f4754937bf19461af58ce3b3d24c77311d9">]
+
+Called without arguments, `Repo#commits` returns a list of up to ten commits
+reachable by the **master** branch (starting at the latest commit). You can
+ask for commits beginning at a different branch, commit, tag, etc.
+
+    repo.commits('mybranch')
+    repo.commits('40d3057d09a7a4d61059bca9dca5ae698de58cbe')
+    repo.commits('v0.1')
+
+You can specify the maximum number of commits to return.
+
+    repo.commits('master', 100)
+
+If you need paging, you can specify a number of commits to skip.
+
+    repo.commits('master', 10, 20)
+
+The above will return commits 21-30 from the commit list.
+
+### The Commit object
+
+`Commit` objects contain information about that commit.
+
+    head = repo.commits.first
+
+    head.id
+    # => "e80bbd2ce67651aa18e57fb0b43618ad4baf7750"
+
+    head.parents
+    # => [#<Grit::Commit "91169e1f5fa4de2eaea3f176461f5dc784796769">]
+
+    head.tree
+    # => #<Grit::Tree "3536eb9abac69c3e4db583ad38f3d30f8db4771f">
+
+    head.author
+    # => #<Grit::Actor "Tom Preston-Werner <tom@mojombo.com>">
+
+    head.authored_date
+    # => Wed Oct 24 22:02:31 -0700 2007
+
+    head.committer
+    # => #<Grit::Actor "Tom Preston-Werner <tom@mojombo.com>">
+
+    head.committed_date
+    # => Wed Oct 24 22:02:31 -0700 2007
+
+    head.message
+    # => "add Actor inspect"
+
+You can traverse a commit's ancestry by chaining calls to `#parents`.
+
+    repo.commits.first.parents[0].parents[0].parents[0]
+
+The above corresponds to **master^^^** or **master~3** in Git parlance.
+
+### The Tree object
+
+A tree records pointers to the contents of a directory. Let's say you want
+the root tree of the latest commit on the **master** branch.
+
+    tree = repo.commits.first.tree
+    # => #<Grit::Tree "3536eb9abac69c3e4db583ad38f3d30f8db4771f">
+
+    tree.id
+    # => "3536eb9abac69c3e4db583ad38f3d30f8db4771f"
+
+Once you have a tree, you can get the contents.
+
+    contents = tree.contents
+    # => [#<Grit::Blob "4ebc8aea50e0a67e000ba29a30809d0a7b9b2666">,
+          #<Grit::Blob "81d2c27608b352814cbe979a6acd678d30219678">,
+          #<Grit::Tree "c3d07b0083f01a6e1ac969a0f32b8d06f20c62e5">,
+          #<Grit::Tree "4d00fe177a8407dbbc64a24dbfc564762c0922d8">]
+
+This tree contains two `Blob` objects and two `Tree` objects. The trees are
+subdirectories and the blobs are files. Trees below the root have additional
+attributes.
+
+    contents.last.name
+    # => "lib"
+
+    contents.last.mode
+    # => "040000"
+
+There is a convenience method that allows you to get a named sub-object
+from a tree.
+
+    tree / "lib"
+    # => #<Grit::Tree "e74893a3d8a25cbb1367cf241cc741bfd503c4b2">
+
+You can also get a tree directly from the repo if you know its name.
+
+    repo.tree
+    # => #<Grit::Tree "master">
+
+    repo.tree("91169e1f5fa4de2eaea3f176461f5dc784796769")
+    # => #<Grit::Tree "91169e1f5fa4de2eaea3f176461f5dc784796769">
+
+### The Blob object
+
+A blob represents a file. Trees often contain blobs.
+
+    blob = tree.contents.first
+    # => #<Grit::Blob "4ebc8aea50e0a67e000ba29a30809d0a7b9b2666">
+
+A blob has certain attributes.
+
+    blob.id
+    # => "4ebc8aea50e0a67e000ba29a30809d0a7b9b2666"
+
+    blob.name
+    # => "README.txt"
+
+    blob.mode
+    # => "100644"
+
+    blob.size
+    # => 7726
+
+You can get the data of a blob as a string.
+
+    blob.data
+    # => "Grit is a library to ..."
+
+You can also get a blob directly from the repo if you know its name.
+
+    repo.blob("4ebc8aea50e0a67e000ba29a30809d0a7b9b2666")
+    # => #<Grit::Blob "4ebc8aea50e0a67e000ba29a30809d0a7b9b2666">

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 2
+:major: 1

data/lib/grit/actor.rb

@@ -0,0 +1,36 @@
+module Grit
+  
+  class Actor
+    attr_reader :name
+    attr_reader :email
+    
+    def initialize(name, email)
+      @name = name
+      @email = email
+    end
+    alias_method :to_s, :name
+    
+    # Create an Actor from a string.
+    #   +str+ is the string, which is expected to be in regular git format
+    #
+    # Format
+    #   John Doe <jdoe@example.com>
+    #
+    # Returns Actor
+    def self.from_string(str)
+      case str
+        when /<.+>/
+          m, name, email = *str.match(/(.*) <(.+?)>/)
+          return self.new(name, email)
+        else
+          return self.new(str, nil)
+      end
+    end
+    
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Actor "#{@name} <#{@email}>">}
+    end
+  end # Actor
+  
+end # Grit

data/lib/grit/blame.rb

@@ -0,0 +1,61 @@
+module Grit
+
+  class Blame
+
+    attr_reader :lines
+
+    def initialize(repo, file, commit)
+      @repo = repo
+      @file = file
+      @commit = commit
+      @lines = []
+      load_blame
+    end
+
+    def load_blame
+      output = @repo.git.blame({'p' => true}, @commit, '--', @file)
+      process_raw_blame(output)
+    end
+
+    def process_raw_blame(output)
+      lines, final = [], []
+      info, commits = {}, {}
+
+      # process the output
+      output.split("\n").each do |line|
+        if line[0, 1] == "\t"
+          lines << line[1, line.size]
+        elsif m = /^(\w{40}) (\d+) (\d+)/.match(line)
+          if !commits[m[1]]
+            commits[m[1]] = @repo.commit(m[1])
+          end
+          info[m[3].to_i] = [commits[m[1]], m[2].to_i]
+        end
+      end
+
+      # get it together
+      info.sort.each do |lineno, commit|
+        final << BlameLine.new(lineno, commit[1], commit[0], lines[lineno - 1])
+      end
+
+      @lines = final
+    end
+
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Blame "#{@file} <#{@commit}>">}
+    end
+
+    class BlameLine
+      attr_accessor :lineno, :oldlineno, :commit, :line
+      def initialize(lineno, oldlineno, commit, line)
+        @lineno = lineno
+        @oldlineno = oldlineno
+        @commit = commit
+        @line = line
+      end
+    end
+
+  end # Blame
+
+end # Grit

data/lib/grit/blob.rb

@@ -0,0 +1,126 @@
+module Grit
+  
+  class Blob
+    DEFAULT_MIME_TYPE = "text/plain"
+    
+    attr_reader :id
+    attr_reader :mode
+    attr_reader :name
+    
+    # Create an unbaked Blob containing just the specified attributes
+    #   +repo+ is the Repo
+    #   +atts+ is a Hash of instance variable data
+    #
+    # Returns Grit::Blob (unbaked)
+    def self.create(repo, atts)
+      self.allocate.create_initialize(repo, atts)
+    end
+    
+    # Initializer for Blob.create
+    #   +repo+ is the Repo
+    #   +atts+ is a Hash of instance variable data
+    #
+    # Returns Grit::Blob (unbaked)
+    def create_initialize(repo, atts)
+      @repo = repo
+      atts.each do |k, v|
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+      self
+    end
+    
+    # The size of this blob in bytes
+    #
+    # Returns Integer
+    def size
+      @size ||= @repo.git.cat_file({:s => true}, id).chomp.to_i
+    end
+    
+    # The binary contents of this blob.
+    #
+    # Returns String
+    def data
+      @data ||= @repo.git.cat_file({:p => true}, id)
+    end
+    
+    # The mime type of this file (based on the filename)
+    #
+    # Returns String
+    def mime_type
+      guesses = MIME::Types.type_for(self.name) rescue []
+      guesses.first ? guesses.first.simplified : DEFAULT_MIME_TYPE
+    end
+    
+    # The blame information for the given file at the given commit
+    #
+    # Returns Array: [Grit::Commit, Array: [<line>]]
+    def self.blame(repo, commit, file)
+      data = repo.git.blame({:p => true}, commit, '--', file)
+      
+      commits = {}
+      blames = []
+      info = nil
+      
+      data.split("\n").each do |line|
+        parts = line.split(/\s+/, 2)
+        case parts.first
+          when /^[0-9A-Fa-f]{40}$/
+            case line
+              when /^([0-9A-Fa-f]{40}) (\d+) (\d+) (\d+)$/
+                _, id, origin_line, final_line, group_lines = *line.match(/^([0-9A-Fa-f]{40}) (\d+) (\d+) (\d+)$/)
+                info = {:id => id}
+                blames << [nil, []]
+              when /^([0-9A-Fa-f]{40}) (\d+) (\d+)$/
+                _, id, origin_line, final_line = *line.match(/^([0-9A-Fa-f]{40}) (\d+) (\d+)$/)
+                info = {:id => id}
+            end
+          when /^(author|committer)/
+            case parts.first
+              when /^(.+)-mail$/
+                info["#{$1}_email".intern] = parts.last
+              when /^(.+)-time$/
+                info["#{$1}_date".intern] = Time.at(parts.last.to_i)
+              when /^(author|committer)$/
+                info[$1.intern] = parts.last
+            end
+          when /^filename/
+            info[:filename] = parts.last
+          when /^summary/
+            info[:summary] = parts.last
+          when ''
+            c = commits[info[:id]]
+            unless c
+              c = Commit.create(repo, :id => info[:id],
+                                      :author => Actor.from_string(info[:author] + ' ' + info[:author_email]),
+                                      :authored_date => info[:author_date],
+                                      :committer => Actor.from_string(info[:committer] + ' ' + info[:committer_email]),
+                                      :committed_date => info[:committer_date],
+                                      :message => info[:summary])
+              commits[info[:id]] = c
+            end
+            _, text = *line.match(/^\t(.*)$/)
+            blames.last[0] = c
+            blames.last[1] << text
+            info = nil
+        end
+      end
+
+      blames
+    end
+    
+    def basename
+      File.basename(name)
+    end
+    
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Blob "#{@id}">}
+    end
+
+    # Compares blobs by name
+    def <=>(other)
+      name <=> other.name
+    end
+  end # Blob
+
+end # Grit