rjgit 0.2.0 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9e630be01944c941f17a49c0672e3b4e6152d5b
+  data.tar.gz: 83a4b49462dcb91f3752f6efd78e3f07365472e5
+SHA512:
+  metadata.gz: d993640e4a08b325bda42aef04ccaf2eca55afd5b1ac47d8553398c343db871635a0216f6543da639a1ddb60f373a1c87df7ea928ab4b672f8c6f5937802d965
+  data.tar.gz: c75fe41b10fb0b21cd4d48944d981bace59aa130455e3468e92d9426edc0b54a0e0f6f006748cc2add6cc3ddb0829bdacf32669e63b08a95e0ed80a03999ac1b

data/Gemfile

@@ -1,11 +1,11 @@
 source 'https://rubygems.org'
 
 gem "mime-types", "~> 1.15"
-gem "rake", "~> 0.9.2.2"
+gem "rake", "~> 10.1.0"
 
 gem 'coveralls', require: false
 
 group :test do
-  gem "rspec", "~> 2.0"
+  gem "rspec", "2.13.0"
   gem "simplecov"
-end
+end

data/README.md

@@ -5,6 +5,7 @@ RJGit
 
 [![Build Status](https://travis-ci.org/repotag/rjgit.png)](https://travis-ci.org/repotag/rjgit)
 [![Coverage Status](https://coveralls.io/repos/repotag/rjgit/badge.png?branch=master)](https://coveralls.io/r/repotag/rjgit)
+[![Gem Version](https://badge.fury.io/rb/rjgit.png)](http://badge.fury.io/rb/rjgit)
 
 Authors
 -------
@@ -37,7 +38,9 @@ $ gem install rjgit
 
 Usage
 -----
-RJGit wraps most (if not all) of JGit's core functionality; see below for some examples of what you can do with it. Make sure you have [JRuby](http://jruby.org/) installed.
+RJGit wraps most (if not all) of JGit's core functionality; it has classes for all important Git objects, i.e., Repo, Blob, Tree, Commit, and Tag. It allows parsing and manipulation of these objects in an intuitive manner, either simulating ordinary git usage (with a working directory on disk) or on a lower level, through creating new git objects manually (also works with 'bare' repositories, without a working directory).
+
+See below for some examples of what you can do with RJGit. Make sure you have [JRuby](http://jruby.org/) installed.
 
 ### Require the gem and include the RJGit module
 
@@ -56,33 +59,53 @@ repo = Repo.new("repo.git")
 
 ```ruby
 repo = Repo.new("repo.git", :create => true)
-repo = Repo.new("repo.git", :create => true, :bare => true) # Create a 'bare' git repo, which stores all git-data under the '.git' directory.
+repo = Repo.new("repo.git", :create => true, :is_bare => true) # Create a 'bare' git repo.
+repo.bare? # Is this a bare repository?
 ```
 
-### Getting a list of commits
+### Getting commits
 ```ruby
 repo.commits('master')
 repo.commits('959329025f67539fb82e76b02782322fad032821')
+commit = repo.commits('master').first # a Commit object; try commit.actor, commit.id, etc.
 # Similarly for getting tags, branches, trees (directories), and blobs (files).
 ```
 
+### Finding a single object by SHA
+```ruby
+repo.find('959329025f67539fb82e76b02782322fad032821')
+repo.find('959329025f67539fb82e76b02782322fad032821', :commit) # Find a specific :commit, :blob, :tree, or :tag
+```
+
 ### Getting tags
 ```ruby
 tag = repo.tags['example_tag']
 tag.id # tag's object id
 tag.author.name # Etcetera
+some_object = Porcelain.object_for_tag(repo, tag) # Returns the tagged object; e.g. a Commit
+```
+
+### Blobs and Trees
+```ruby
+blob = repo.blob("example/file.txt") # Retrieve a file by filepath...
+blob = repo.find("959329025f67539fb82e76b02782322fad032822", :blob) # ...or by SHA
+blob.data # Cat the file; also blob.id, blob.mode, etc.
+tree = repo.tree("example") # Retrieve a tree by filepath...
+tree = repo.find("959329025f67539fb82e76b02782322fad032000", :tree) #...or by SHA
+tree.data # List the tree's contents (blobs and trees). Also tree.id, tree.mode, etc.
+tree.each {|entry| puts entry.inspect} # Loop over the Tree's children (Blobs and Trees)
+tree.trees # An array of the Tree's child Trees
+tree.blobs # An array of the Tree's child Blobs
+Porcelain::ls_tree(repo, repo.tree("example"), :print => true, :recursive => true, :branch => 'mybranch') # Outputs the Tree's contents to $stdout. Faster for recursive listing than Tree#each. Passing nil as the second argument lists the entire repository. Branch defaults to HEAD.
 ```
 
-### Getting a repository's contents
+### Creating blobs and trees from scratch
 ```ruby
-repo.blob("example/file.txt") # Retrieve a file by filepath
-repo.blob("example/file.txt").data # Cat the file
-repo.tree("example") # Retrieve a tree by filepath
-repo.tree("example").data # List the tree's contents (blobs and trees)
-Porcelain::ls_tree(repo, repo.tree("example"), :print => true, :recursive => true, :branch => 'mybranch') # Outputs a file list to $stdout. Passing nil as the second argument lists the entire repository. Branch defaults to HEAD.
+blob = Blob.new_from_string(repo, "Contents of the new blob.") # Inserts the blob into the repository, returns an RJGit::Blob
+tree = Tree.new_from_hashmap(repo, {"newblob" => "contents", "newtree" => { "otherblob" => "this blob is contained in the tree 'newtree'" } } ) # Constructs the tree and its children based on the hashmap and inserts it into the repository, returning an RJGit::Tree. Tree.new_from_hashmap takes an RJGit::Tree as an optional third argument, in which case the new tree will consist of the children of that Tree *plus* the contents of the hashmap.
 ```
 
-### Manipulating repositories
+### Committing and adding branches to repositories, 'porcelain' style (only works with non-bare repos)
 ```ruby
 repo.create_branch('new_branch') # Similarly for deleting, renaming
 repo.checkout('new_branch')
@@ -90,6 +113,14 @@ repo.add('new_file.txt') # Similarly for removing
 repo.commit('My message')
 ```
 
+### Committing and adding branches to repositories, 'plumbing' style (also works with bare repos)
+```ruby
+repo = repo.new("repo.git")
+tree = Tree.new_from_hashmap(repo, {"newblob" => "contents"}, repo.head.tree ) # As above, use the current head commit's tree as a starting point and add "newblob"
+actor = RJGit::Actor.new("test", "test@repotag.org")
+commit = Commit.new_with_tree(repo, tree, "My commit message", actor) # Create a new commit with tree as base tree
+```
+
 ### And more...
 ```ruby
 pack = RJGitReceivePack.new(repo) # Implement the smart-http protocol with RJGitReceivePack and RJGitUploadPack

data/lib/actor.rb

@@ -9,15 +9,18 @@ module RJGit
     
     RJGit.delegate_to(PersonIdent, :@person_ident)
     
-    def self.new_from_name_and_email(name, email)
-      return self.new(PersonIdent.new(name, email))
-    end
     alias_method :to_s, :name
-
-    def initialize(person_ident)
-      @name = person_ident.get_name
-      @email = person_ident.get_email_address
-      @person_ident = person_ident
+      
+    def self.new_from_person_ident(person_ident)
+      name = person_ident.get_name
+      email = person_ident.get_email_address
+      return self.new(name, email)
+    end
+    
+    def initialize(name, email)
+      @name = name
+      @email = email
+      @person_ident = PersonIdent.new(name, email)
     end
     
     # Create an Actor from a string.
@@ -28,7 +31,7 @@ module RJGit
     def self.from_string(str)
       if str =~ /<.+>/
         m, name, email = *str.match(/(.*) <(.+?)>/)
-        return self.new_from_name_and_email(name, email)
+        return self.new(name, email)
       end
     end
 

data/lib/blob.rb

@@ -7,11 +7,11 @@ module RJGit
     attr_reader :id, :mode, :name, :path, :jblob
     RJGit.delegate_to(RevBlob, :@jblob)
 
-    def initialize(jrepo, path, mode, jblob)
-      @jrepo = jrepo
+    def initialize(repository, mode, path, jblob)
+      @jrepo = RJGit.repository_type(repository)
       @jblob = jblob
       @path = path
-      @name = File.basename(path)
+      @name = @path ? File.basename(@path) : nil
       @mode = mode
       @id = ObjectId.toString(jblob.get_id)
     end
@@ -36,7 +36,11 @@ module RJGit
     def data
       @data ||= RJGit::Porcelain.cat_file(@jrepo, @jblob) 
     end
-
+    
+    def is_symlink?
+      @mode == SYMLINK_TYPE
+    end
+    
     # The mime type of this file (based on the filename)
     # Returns String
     def mime_type
@@ -48,10 +52,17 @@ module RJGit
       guesses.first ? guesses.first.simplified : DEFAULT_MIME_TYPE
     end
     
+    def self.new_from_string(repository, contents)
+      repository = RJGit.repository_type(repository)
+      blob_id = RJGit::Plumbing::TreeBuilder.new(repository).write_blob(contents, true)
+      walk = RevWalk.new(repository)
+      Blob.new(repository, FileMode::REGULAR_FILE, nil, walk.lookup_blob(blob_id))
+    end
+    
     # Finds a particular Blob in repository matching file_path
-    def self.find_blob(repository, file_path, branch=Constants::HEAD)
+    def self.find_blob(repository, file_path, revstring=Constants::HEAD)
       jrepo = RJGit.repository_type(repository)
-      last_commit_hash = jrepo.resolve(branch)
+      last_commit_hash = jrepo.resolve(revstring)
       return nil if last_commit_hash.nil?
 
       walk = RevWalk.new(jrepo)
@@ -64,8 +75,8 @@ module RJGit
       if treewalk.next
         jblob = walk.lookup_blob(treewalk.objectId(0))
         if jblob
-          mode = RJGit.get_file_mode(jrepo, file_path, jtree) 
-          Blob.new(jrepo, file_path, mode, jblob)
+          mode = RJGit.get_file_mode_with_path(jrepo, file_path, jtree) 
+          Blob.new(jrepo, mode, file_path, jblob)
         end
       else
         nil

data/lib/commit.rb

@@ -14,23 +14,48 @@ module RJGit
     attr_reader :message
     attr_reader :short_message
     attr_reader :jcommit
-    attr_reader :count
+    attr_reader :parent_count
   
     RJGit.delegate_to(RevCommit, :@jcommit)
     
-    def initialize(commit)
+    def initialize(repository, commit)
+      @jrepo = RJGit.repository_type(repository)
       @jcommit = commit
       @id = ObjectId.to_string(commit.get_id)
-      @actor = Actor.new(@jcommit.get_author_ident)
-      @committer = Actor.new(@jcommit.get_committer_ident)
+      @actor = Actor.new_from_person_ident(@jcommit.get_author_ident)
+      @committer = Actor.new_from_person_ident(@jcommit.get_committer_ident)
       @committed_date = Time.at(@jcommit.commit_time)
       @message = @jcommit.get_full_message
       @short_message = @jcommit.get_short_message
-      @count = @jcommit.get_parent_count
+      @parent_count = @jcommit.get_parent_count
+    end
+    
+    def tree
+      @tree ||= Tree.new(@jrepo, FileMode::TREE, nil, @jcommit.get_tree)
     end
   
     def parents
-      @parents ||= @jcommit.get_parents.map{|parent| Commit.new(parent) }
+      @parents ||= @jcommit.get_parents.map {|parent| Commit.new(@jrepo, parent)}
+    end
+    
+    # Pass an empty array for parents if the commit should have no parents
+    def self.new_with_tree(repository, tree, message, actor, parents = nil)
+      repository = RJGit.repository_type(repository)
+      parents = parents ? parents : repository.resolve("refs/heads/#{Constants::MASTER}")
+      new_commit = RJGit::Plumbing::Index.new(repository).do_commit(message, actor, parents, tree)
+      Commit.new(repository, RevWalk.new(repository).parseCommit(new_commit))
+    end
+    
+    def self.find_head(repository)
+      repository = RJGit.repository_type(repository)
+      return nil if repository.nil?
+      begin
+        walk = RevWalk.new(repository)
+        objhead = repository.resolve(Constants::HEAD)
+        return Commit.new(repository, walk.parseCommit(objhead))
+      rescue NativeException => e
+        return nil
+      end
     end
     
     def self.find_all(repository, ref, options)
@@ -41,7 +66,7 @@ module RJGit
         objhead = repository.resolve(ref)
         root = walk.parse_commit(objhead)
         walk.mark_start(root)
-        commits = walk.map { |commit| Commit.new(commit) }
+        commits = walk.map { |commit| Commit.new(repository, commit) }
         return commits.first(options[:limit])
       rescue NativeException => e
         return Array.new

data/lib/config.rb

@@ -42,7 +42,7 @@ module RJGit
         end
         settings[name] = value
       end
-      settings
+      settings.empty? ? nil : settings
     end
     
     def is_num?(str)

data/lib/git.rb

@@ -27,7 +27,7 @@ module RJGit
       logs = @jgit.log
       commits = Array.new
       logs.call.each do |jcommit|
-        commits << Commit.new(jcommit)
+        commits << Commit.new(jrepo, jcommit)
       end
       commits
     end
@@ -42,7 +42,7 @@ module RJGit
     end
 
     def commit(message)
-      Commit.new(@jgit.commit.set_message(message).call)
+      Commit.new(jrepo, @jgit.commit.set_message(message).call)
     end
 
     def clone(remote, local, options = {})
@@ -53,7 +53,7 @@ module RJGit
       clone_command = Git.clone_repository
       clone_command.setURI(remote)
       clone_command.set_directory(java.io.File.new(local))
-      clone_command.set_bare(true) if options[:bare]
+      clone_command.set_bare(true) if options[:is_bare]
       if options[:branch]
         if options[:branch] == :all
           clone_command.set_clone_all_branches(true)
@@ -92,7 +92,7 @@ module RJGit
       tag_command.set_name(name)
       tag_command.set_force_update(force)
       tag_command.set_message(message)
-      tag_command.set_object_id(commit_or_revision) if commit_or_revision
+      tag_command.set_object_id(RJGit.commit_type(commit_or_revision)) if commit_or_revision
       if actor
         actor = RJGit.actor_type(actor)
         tag_command.set_tagger(actor)
@@ -182,7 +182,7 @@ module RJGit
       commits.each do |commit|
         revert_command.include commit.jcommit
       end
-      Commit.new(revert_command.call)
+      Commit.new(jrepo, revert_command.call)
     end
 
     def status

data/lib/repo.rb

@@ -49,13 +49,13 @@ module RJGit
       # If the repo path is new
       unless File.exists?(epath) 
         # take user setting if defined
-        bare = !! options[:bare] unless options[:bare].nil?
+        bare = !! options[:is_bare] unless options[:is_bare].nil?
       # If the repo path exists
       else
         # scan the directory for a .git directory
         bare = File.exists?(gitpath) ? false : true
         # but allow overriding user setting
-        bare = !! options[:bare] unless options[:bare].nil? 
+        bare = !! options[:is_bare] unless options[:is_bare].nil? 
       end
       
       @path = bare ? epath : gitpath
@@ -69,8 +69,9 @@ module RJGit
     def bare?
       @jrepo.is_bare
     end
+    alias_method :bare, :bare?
     
-    def self.create(path, options = {:bare => false})
+    def self.create(path, options = {:is_bare => false})
       options[:create] = true
       Repo.new(path, options)
     end
@@ -79,11 +80,20 @@ module RJGit
       @jrepo.create(self.bare?)
     end
 
+    def self.new_from_jgit_repo(jrepo)
+      path = File.dirname(jrepo.get_directory.get_path)
+      Repo.new(path, {:is_bare => jrepo.is_bare})
+    end
+
     def commits(ref="master", limit=100)
       options = { :limit => limit }
       Commit.find_all(@jrepo, ref, options)
     end
     
+    def head
+      Commit.find_head(@jrepo)
+    end
+    
     def valid?
       @jrepo.get_object_database.exists
     end
@@ -152,15 +162,58 @@ module RJGit
     def clean(options = {})
       @git.clean(options)
     end
+    
+    def find(sha, type = :any)
+        begin
+          oi = ObjectId.from_string(sha)
+          walk = RevWalk.new(@jrepo)
+          rev_object = case type
+          when :any
+            walk.parse_any(oi)
+          when :tree
+            walk.parse_tree(oi)
+          when :blob
+            walk.parse_any(oi)
+          when :tag
+            walk.parse_tag(oi)
+          when :commit
+            walk.parse_commit(oi)
+          else nil
+          end
+        rescue Java::OrgEclipseJgitErrors::MissingObjectException, Java::JavaLang::IllegalArgumentException, Java::JavaLang::NullPointerException
+          return nil
+        end
+      return nil if rev_object.nil?
+      object_type = (type == :any || type == :blob) ? RJGit.sym_for_type(rev_object.get_type) : type
+      return nil if type == :blob && object_type != :blob # Blobs need to be found with parse_any, so make sure that the result of this is actually a blob.
+        return case object_type
+        when :tree
+          Tree.new(@jrepo, nil, nil, rev_object)
+        when :blob
+          mode = RJGit.get_file_mode(@jrepo, rev_object)
+          Blob.new(@jrepo, mode, nil, rev_object)
+        when :tag
+          Tag.new(rev_object)
+        when :commit
+          Commit.new(jrepo, rev_object)
+        end
+    end
 
     # Convenience method to retrieve a Blob by name
-    def blob(file_path)
-      Blob.find_blob(@jrepo, file_path)
+    def blob(file_path, revstring=Constants::HEAD)
+      Blob.find_blob(@jrepo, file_path, revstring)
     end
 
     # Convenience method to retrieve a Tree by name
-    def tree(file_path)
-      Tree.find_tree(@jrepo, file_path)
+    def tree(file_path, revstring=Constants::HEAD)
+      Tree.find_tree(@jrepo, file_path, revstring)
+    end
+    
+    def update_ref(commit, force = false, ref = "refs/heads/#{Constants::MASTER}")
+      ref_updater = @jrepo.updateRef(ref)
+      ref_updater.setNewObjectId(RJGit.commit_type(commit))
+      msg = force ? :update : :forceUpdate
+      ref_updater.send(msg).to_string
     end
     
     # Update the info files required for fetching files over the dump-HTTP protocol

data/lib/rjgit.rb

@@ -25,7 +25,7 @@ module RJGit
   
   import 'org.eclipse.jgit.lib.ObjectId'
    
-  class Porcelain
+  module Porcelain
    
     import 'org.eclipse.jgit.api.AddCommand'
     import 'org.eclipse.jgit.api.CommitCommand'
@@ -42,9 +42,23 @@ module RJGit
       repository.commit(message)
     end
     
+    def self.object_for_tag(repository, tag)
+      repository.find(tag.object.name, RJGit.sym_for_type(tag.object_type))
+    end
+    
     # http://dev.eclipse.org/mhonarc/lists/jgit-dev/msg00558.html
-    def self.cat_file(repository, object)
-      bytes = repository.open(object.id).get_bytes
+    def self.cat_file(repository, blob)
+      jrepo = RJGit.repository_type(repository)
+      jblob = RJGit.blob_type(blob)
+      # Try to resolve symlinks; return nil otherwise
+      mode = RJGit.get_file_mode(jrepo, jblob)
+      if mode == SYMLINK_TYPE
+        symlink_source = jrepo.open(jblob.id).get_bytes.to_a.pack('c*').force_encoding('UTF-8')
+        blob = Blob.find_blob(jrepo, symlink_source)
+        return nil if blob.nil?
+        jblob = blob.jblob
+      end
+      bytes = jrepo.open(jblob.id).get_bytes
       return bytes.to_a.pack('c*').force_encoding('UTF-8')
     end
     
@@ -75,7 +89,7 @@ module RJGit
         entries << entry
       end
       options[:io].puts RJGit.stringify(entries) if options[:print]
-      entries
+      return entries
     end
       
     def self.blame(repository, file_path, options={})
@@ -90,9 +104,9 @@ module RJGit
       blame = []
       for index in (0..content.size - 1) do
         blameline = {}
-        blameline[:actor] = Actor.new(result.get_source_author(index))
+        blameline[:actor] = Actor.new_from_person_ident(result.get_source_author(index))
         blameline[:line] = result.get_source_line(index)
-        blameline[:commit] = Commit.new(result.get_source_commit(index))
+        blameline[:commit] = Commit.new(repository, result.get_source_commit(index))
         blameline[:line] = content.get_string(index)
         blame << blameline
       end
@@ -112,7 +126,180 @@ module RJGit
       diff_entries = diff_command.call
       diff_entries = diff_entries.to_array.to_ary
       diff_entries = RJGit.convert_diff_entries(diff_entries)
-      diff_entries
+      return diff_entries
+    end
+    
+  end
+  
+  module Plumbing
+    import org.eclipse.jgit.lib.Constants
+    
+    class TreeBuilder
+      import org.eclipse.jgit.lib.FileMode
+      import org.eclipse.jgit.lib.TreeFormatter
+      
+    
+      attr_accessor :treemap
+      attr_reader :log
+      
+      def initialize(repository)
+        @jrepo = RJGit.repository_type(repository)
+        @treemap = {}
+        init_log
+      end
+      
+      def object_inserter
+        @jrepo.newObjectInserter
+      end
+      
+      def init_log
+        @log = {:deleted => [], :added => [] }
+      end
+      
+      def only_contains_deletions(hashmap)
+        hashmap.each do |key, value|
+          if value.is_a?(Hash) then
+            return false unless only_contains_deletions(value)
+          elsif value.is_a?(String)
+            return false
+          end
+        end
+        true
+      end
+      
+      def build_tree(start_tree, treemap = nil, flush = false)
+        existing_trees = {}
+        formatter = TreeFormatter.new
+        treemap ||= self.treemap
+    
+        if start_tree then
+          treewalk = TreeWalk.new(@jrepo)
+          treewalk.add_tree(start_tree)
+          while treewalk.next
+            filename = treewalk.get_name_string
+            if treemap.keys.include?(filename) then
+              kind = treewalk.isSubtree ? :tree : :blob
+                if treemap[filename] == false then
+                  @log[:deleted] << [kind, filename, treewalk.get_object_id(0)]
+                else
+                  existing_trees[filename] = treewalk.get_object_id(0) if kind == :tree
+                end
+            else
+              mode = treewalk.isSubtree ? FileMode::TREE : FileMode::REGULAR_FILE
+              formatter.append(filename.to_java_string, treewalk.get_file_mode(0), treewalk.get_object_id(0))
+            end
+          end
+        end
+    
+        treemap.each do |object_name, data|
+          case data
+            when String
+              blobid = write_blob(data)
+              formatter.append(object_name.to_java_string, FileMode::REGULAR_FILE, blobid)
+              @log[:added] << [:blob, object_name, blobid]
+            when Hash
+              next_tree = build_tree(existing_trees[object_name], data)
+              formatter.append(object_name.to_java_string, FileMode::TREE, next_tree)
+              @log[:added] << [:tree, object_name, next_tree] unless only_contains_deletions(data)
+            end
+        end
+    
+        result = object_inserter.insert(formatter)
+      end
+      
+      def write_blob(contents, flush = false)
+        blobid = object_inserter.insert(Constants::OBJ_BLOB, contents.to_java_bytes)
+        blobid
+      end
+      
+    end
+    
+    class Index
+      import org.eclipse.jgit.lib.CommitBuilder
+      
+      attr_accessor :treemap, :current_tree
+      attr_reader :jrepo
+      
+      def initialize(repository, branch = nil)
+        @treemap = {}
+        @jrepo = RJGit.repository_type(repository)
+        @treebuilder = TreeBuilder.new(@jrepo)
+      end
+      
+      def add(path, data)
+        path = path[1..-1] if path[0] == '/'
+        path = path.split('/')
+        filename = path.pop
+
+        current = self.treemap
+
+        path.each do |dir|
+          current[dir] ||= {}
+          node = current[dir]
+          current = node
+        end
+
+        current[filename] = data
+        @treemap
+      end
+  
+      def delete(path)
+        path = path[1..-1] if path[0] == '/'
+        path = path.split('/')
+        last = path.pop
+    
+        current = self.treemap
+    
+        path.each do |dir|
+          current[dir] ||= {}
+          node = current[dir]
+          current = node
+        end
+    
+        current[last] = false
+        @treemap
+      end
+      
+      def do_commit(message, author, parents, new_tree)
+        commit_builder = CommitBuilder.new
+        person = author.person_ident
+        commit_builder.setCommitter(person)
+        commit_builder.setAuthor(person)
+        commit_builder.setMessage(message)
+        commit_builder.setTreeId(RJGit.tree_type(new_tree))
+          if parents.is_a?(Array) then
+            parents.each {|parent| commit_builder.addParentId(RJGit.commit_type(parent)) }
+          elsif parents
+            commit_builder.addParentId(RJGit.commit_type(parents))
+          end
+        @treebuilder.object_inserter.insert(commit_builder)
+      end
+      
+      def commit(message, author, parents = nil, ref = "refs/heads/#{Constants::MASTER}")
+        @current_tree = @current_tree ? RJGit.tree_type(@current_tree) : @jrepo.resolve("refs/heads/#{Constants::MASTER}^{tree}")
+        @treebuilder.treemap = @treemap
+        new_tree = @treebuilder.build_tree(@current_tree)
+        return false if @current_tree && new_tree.name == @current_tree.name
+        
+        parents = parents ? parents : @jrepo.resolve(ref+"^{commit}")
+        new_head = do_commit(message, author, parents, new_tree)
+
+        # Point ref to the newest commit
+        ru = @jrepo.updateRef(ref)
+        ru.setNewObjectId(new_head)
+        res = ru.forceUpdate.to_string
+      
+        @current_tree = new_tree
+        @treemap = {}
+        log = @treebuilder.log
+        @treebuilder.init_log
+        return res, log
+      end
+      
+      def self.successful?(result)
+        ["NEW", "FAST_FORWARD"].include?(result)
+      end
+      
     end
     
   end

data/lib/rjgit_helpers.rb

@@ -16,11 +16,29 @@ module RJGit
     def_delegators delegate_name, *java_methods
   end
 
-  def self.get_file_mode(repository, path, jtree)
-    treewalk = TreeWalk.forPath(repository, path, jtree)
+  def self.get_file_mode_with_path(jrepo, path, jtree)
+    treewalk = TreeWalk.forPath(jrepo, path, jtree)
     return treewalk.get_file_mode(0).get_bits
   end
   
+  def self.get_file_mode(jrepo, jblob, revstring=Constants::HEAD)
+    last_commit_hash = jrepo.resolve(revstring)
+    return nil if last_commit_hash.nil?
+    walk = RevWalk.new(jrepo)
+    jcommit = walk.parse_commit(last_commit_hash)
+    treewalk = TreeWalk.new(jrepo)
+    jtree = jcommit.get_tree
+    treewalk.add_tree(jtree)
+    treewalk.set_recursive(true)
+    while treewalk.next
+      jblob_lookup = walk.lookup_blob(treewalk.objectId(0))
+      if jblob_lookup.get_name == jblob.get_name
+        mode = treewalk.get_file_mode(0).get_bits
+        return mode
+      end
+    end
+  end
+  
   def self.stringify(entries)
     str = ""
     entries.each do |entry|
@@ -49,6 +67,18 @@ module RJGit
      entry
   end
   
+  def self.sym_for_type(type)
+    result = case type
+    when Constants::OBJ_BLOB
+      :blob
+    when Constants::OBJ_TREE
+      :tree
+    when Constants::OBJ_COMMIT
+      :commit
+    when Constants::OBJ_TAG
+      :tag
+    end 
+  end
   
   def self.repository_type(repository)
     repo = case repository
@@ -70,6 +100,23 @@ module RJGit
     treeobj = case tree
       when Tree then tree.jtree
       when org.eclipse.jgit.revwalk.RevTree then tree
+      when org.eclipse.jgit.lib.ObjectId then tree
+      else nil
+    end
+  end
+  
+  def self.blob_type(blob)
+    blobobj = case blob
+      when Blob then blob.jblob
+      when org.eclipse.jgit.revwalk.RevBlob then blob
+      else nil
+    end
+  end
+  
+  def self.commit_type(commit)
+    commitobj = case commit
+      when Commit then commit.jcommit
+      when org.eclipse.jgit.lib.ObjectId then commit
       else nil
     end
   end

data/lib/tag.rb

@@ -22,7 +22,7 @@ module RJGit
     end 
     
     def actor
-      @actor ||= Actor.new(@jtag.get_tagger_ident)
+      @actor ||= Actor.new_from_person_ident(@jtag.get_tagger_ident)
     end
     
     def name
@@ -33,6 +33,13 @@ module RJGit
       @type ||= @jtag.get_type
     end
     
+    def object
+      @object ||= @jtag.get_object
+    end
+    
+    def object_type
+      @object_type ||= object.get_type
+    end
     
   end
 end

data/lib/tree.rb

@@ -7,26 +7,70 @@ module RJGit
 
     attr_reader :contents, :id, :mode, :name, :repo, :jtree
     RJGit.delegate_to(RevTree, :@jtree)
+    include Enumerable
     
     def initialize(repository, mode, path, jtree)
-      @repo = repository
+      @jrepo = RJGit.repository_type(repository)
       @mode = mode
       @path = path
-      @name = File.basename(path)
+      @name = @path ? File.basename(path) : nil
       @jtree = jtree
       @id = ObjectId.to_string(jtree.get_id)
     end
     
     def data
+      return @contents if @contents
       strio = StringIO.new
-      RJGit::Porcelain.ls_tree(@repo, @jtree, options={:print => true, :io => strio})
-      strio.string
+      RJGit::Porcelain.ls_tree(@jrepo, @jtree, options={:print => true, :io => strio})
+      @contents = strio.string
     end
     
-    def self.find_tree(repository, file_path, branch=Constants::HEAD)
+    def contents_array
+      return @contents_ary if @contents_ary
+      results = []
+      RJGit::Porcelain.ls_tree(@jrepo, @jtree).each do |item|
+        walk = RevWalk.new(@jrepo)
+        results << Tree.new(@jrepo, item[:mode], item[:path], walk.lookup_tree(ObjectId.from_string(item[:id]))) if item[:type] == 'tree'
+        results << Blob.new(@jrepo, item[:mode], item[:path], walk.lookup_blob(ObjectId.from_string(item[:id]))) if item[:type] == 'blob'
+      end
+      @contents_ary = results
+    end
+    
+    def each(&block)
+      contents_array.each(&block)
+    end
+    
+    def blobs
+      contents_array.select {|x| x.is_a?(Blob)}
+    end
+    
+    def trees
+      contents_array.select {|x| x.is_a?(Tree)}
+    end
+    
+    # From Grit
+    def /(file)
+      if file =~ /\//
+        file.split("/").inject(self) { |acc, x| acc/x } rescue nil
+      else
+        self.contents_array.find { |c| c.name == file }
+      end
+    end
+    
+    def self.new_from_hashmap(repository, hashmap, base_tree = nil)
+      jrepo = RJGit.repository_type(repository)
+      tree_builder = Plumbing::TreeBuilder.new(jrepo)
+      base_tree = RJGit.tree_type(base_tree)
+      new_tree = tree_builder.build_tree(base_tree, hashmap, true)
+      walk = RevWalk.new(jrepo)
+      new_tree = walk.lookup_tree(new_tree)
+      Tree.new(jrepo, FileMode::TREE, nil, new_tree)
+    end
+    
+    def self.find_tree(repository, file_path, revstring=Constants::HEAD)
       jrepo = RJGit.repository_type(repository)
       return nil if jrepo.nil?
-      last_commit_hash = jrepo.resolve(branch)
+      last_commit_hash = jrepo.resolve(revstring)
       return nil if last_commit_hash.nil?
 
       walk = RevWalk.new(jrepo)
@@ -38,7 +82,7 @@ module RJGit
       if treewalk.next
         jsubtree = walk.lookup_tree(treewalk.object_id(0))
         if jsubtree
-          mode = RJGit.get_file_mode(jrepo, file_path, jtree) 
+          mode = RJGit.get_file_mode_with_path(jrepo, file_path, jtree) 
           Tree.new(jrepo, mode, file_path, jsubtree)
         end
       else

data/lib/version.rb

@@ -1,3 +1,3 @@
 module RJGit
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rjgit
 version: !ruby/object:Gem::Version
-  prerelease:
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Maarten Engelen
@@ -13,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-07-18 00:00:00.000000000 Z
+date: 2013-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types
@@ -22,13 +21,11 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.15'
-    none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.15'
-    none: false
   prerelease: false
   type: :runtime
 description: JRuby wrapper around the JGit library for manipulating git repositories in code.
@@ -55,11 +52,12 @@ files:
 - LICENSE
 - Gemfile
 - lib/java/jars/jsch-0.1.49.jar
-- lib/java/jars/org.eclipse.jgit-3.0.0.201306101825-r.jar
+- lib/java/jars/org.eclipse.jgit-3.1.0.201310021548-r.jar
 homepage: https://github.com/repotag/rjgit
 licenses:
 - Modified BSD
 - EPL
+metadata: {}
 post_install_message:
 rdoc_options:
 - --charset=UTF-8
@@ -69,21 +67,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      segments:
-      - 0
-      hash: 2
       version: '0'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 requirements: []
 rubyforge_project:
-rubygems_version: 1.8.24
+rubygems_version: 2.1.9
 signing_key:
-specification_version: 3
+specification_version: 4
 summary: JRuby wrapper around the JGit library.
 test_files: []