rjgit 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 447838b49b9eefa69e97d032efd07f2fea46e644
-  data.tar.gz: eb4c73d1121f3566042ab1fa7d31b008c020eb56
+  metadata.gz: aed799412640c7cdcfecf08ca4ecc5f69c692db4
+  data.tar.gz: 305deb6503f24888df0b65cffc5870baa1dfdb4d
 SHA512:
-  metadata.gz: 05fd1e8028507931b635c5be4b2ca146215611742f4a21c55109bb9b0976fc01e41497ba848a643ec5c6ff075d849e67a038754c29488ff4b232a68db80333f7
-  data.tar.gz: 4b2ffb2740ada2553aa96c950b5526a49dd20eeeec6627aae26c6ac6b0315568bc6c7b4479e436f29d11f9a3ffa3125f3a406a709682a12481f932024c9eb249
+  metadata.gz: e04cca82e0ee0ba500c1249f6054909eb59aea835c76231f9a62ada7be16281306b0ef1b489c5468a7cddb77ba453f2b59f02719e2bbb5c2d9428c644736d3b7
+  data.tar.gz: 815a03dc8dc2e8779c464bc2fad1a8b1a198defc27d16889901071785e5348a128ba94efe7cc56051557d6b2c46dd50acf6031b8eeb5b7055d668c1df61073b5

data/LICENSE

@@ -1,6 +1,6 @@
 # RJGit
 
-Copyright (c) 2013, Team Repotag
+Copyright (c) 2013-2014, Team Repotag
 
 (Modified BSD License)
 

data/README.md

@@ -67,6 +67,7 @@ repo.bare? # Is this a bare repository?
 ```ruby
 repo.commits('master')
 repo.commits('959329025f67539fb82e76b02782322fad032821')
+repo.head
 commit = repo.commits('master').first # a Commit object; try commit.actor, commit.id, etc.
 # Similarly for getting tags, branches, trees (directories), and blobs (files).
 ```
@@ -96,7 +97,7 @@ tree.data # List the tree's contents (blobs and trees). Also tree.id, tree.mode,
 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.
+Porcelain::ls_tree(repo, repo.tree("example"), :print => true, :recursive => true, :ref => '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. ref defaults to HEAD.
 ```
 
 ### Creating blobs and trees from scratch
@@ -160,7 +161,7 @@ jruby --ng -S rake
 
 License
 -------
-Copyright (c) 2011 - 2013, Team Repotag
+Copyright (c) 2011 - 2014, Team Repotag
 
 (Modified BSD License)
 

data/lib/blob.rb

@@ -56,7 +56,7 @@ module RJGit
       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))
+      Blob.new(repository, REG_FILE_TYPE, nil, walk.lookup_blob(blob_id))
     end
     
     # Finds a particular Blob in repository matching file_path

data/lib/commit.rb

@@ -25,13 +25,14 @@ module RJGit
       @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)
+      @authored_date = Time.at(@jcommit.get_author_ident.when.time/1000)
       @message = @jcommit.get_full_message
       @short_message = @jcommit.get_short_message
       @parent_count = @jcommit.get_parent_count
     end
     
     def tree
-      @tree ||= Tree.new(@jrepo, FileMode::TREE, nil, @jcommit.get_tree)
+      @tree ||= Tree.new(@jrepo, TREE_TYPE, nil, @jcommit.get_tree)
     end
   
     def parents

data/lib/git.rb

@@ -3,6 +3,7 @@ module RJGit
   import 'java.io.ByteArrayInputStream'
   import 'java.io.FileInputStream'
 
+  import 'org.eclipse.jgit.lib.Constants'
   import 'org.eclipse.jgit.api.Git'
   import 'org.eclipse.jgit.api.AddCommand'
   import 'org.eclipse.jgit.api.RmCommand'
@@ -23,8 +24,13 @@ module RJGit
       @jgit = Git.new(@jrepo)
     end
 
-    def log
+    def log(path = nil, revstring = Constants::HEAD, options = {})
       logs = @jgit.log
+      ref = jrepo.resolve(revstring)
+      logs.add(ref)
+      logs.addPath(path) if path
+      logs.setMaxCount(options[:max_count]) if options[:max_count]
+      logs.setSkip(options[:skip]) if options[:skip]
       commits = Array.new
       logs.call.each do |jcommit|
         commits << Commit.new(jrepo, jcommit)
@@ -41,8 +47,16 @@ module RJGit
       array
     end
 
-    def commit(message)
-      Commit.new(jrepo, @jgit.commit.set_message(message).call)
+    def commit(message, options = {})
+      commit_cmd = @jgit.commit.set_message(message)
+      commit_cmd.set_all(options[:all]) unless options[:all].nil?
+      commit_cmd.set_amend(options[:amend]) unless options[:amend].nil?
+      commit_cmd.set_author(options[:author].person_ident) unless options[:author].nil?
+      commit_cmd.set_committer(options[:committer].person_ident) unless options[:committer].nil?
+      commit_cmd.set_insert_change_id(options[:insert_change_id]) unless options[:insert_change_id].nil?
+      options[:only_paths].each {|path| commit_cmd.set_only(path)} unless options[:only_paths].nil?
+      commit_cmd.set_reflog_comment(options[:reflog_comment]) unless options[:reflog_comment].nil?
+      Commit.new(jrepo, commit_cmd.call)
     end
 
     def clone(remote, local, options = {})
@@ -121,8 +135,10 @@ module RJGit
       @jgit.branch_rename.set_old_name(old_name).set_new_name(new_name).call
     end
 
-    def checkout(branch_name, options = {})
+    def checkout(branch_name = "master", options = {})
       checkout_command = @jgit.checkout.set_name(branch_name)
+      checkout_command.set_start_point(options[:commit])
+      options[:paths].each {|path| checkout_command.add_path(path)} if options[:path]
       checkout_command.set_create_branch(true) if options[:create]
       checkout_command.set_force(true) if options[:force]
       result = {}

data/lib/repo.rb

@@ -155,8 +155,8 @@ module RJGit
       @git.remove(file_pattern)
     end
     
-    def commit(message)
-      @git.commit(message)
+    def commit(message, options = {})
+      @git.commit(message, options)
     end
     
     def clean(options = {})
@@ -211,12 +211,12 @@ module RJGit
     
     def update_ref(commit, force = false, ref = "refs/heads/#{Constants::MASTER}")
       ref_updater = @jrepo.updateRef(ref)
+      ref_updater.setForceUpdate(force)
       ref_updater.setNewObjectId(RJGit.commit_type(commit))
-      msg = force ? :update : :forceUpdate
-      ref_updater.send(msg).to_string
+      ref_updater.update.to_string
     end
     
-    # Update the info files required for fetching files over the dump-HTTP protocol
+    # Update the info files required for fetching files over the dumb-HTTP protocol
     def update_server_info
       # First update the $GIT_DIR/refs/info file
       refs = @jrepo.get_all_refs # Note: JGit will include directories under $GIT_DIR/refs/heads that start with a '.' in its search for refs. Filter these out in LocalRefWriter?

data/lib/rjgit.rb

@@ -32,6 +32,9 @@ module RJGit
     import 'org.eclipse.jgit.api.BlameCommand'
     import 'org.eclipse.jgit.blame.BlameGenerator'
     import 'org.eclipse.jgit.blame.BlameResult'
+    import 'org.eclipse.jgit.treewalk.CanonicalTreeParser'
+    import 'org.eclipse.jgit.diff.DiffFormatter'
+
     
     # http://wiki.eclipse.org/JGit/User_Guide#Porcelain_API
     def self.add(repository, file_pattern)
@@ -63,13 +66,13 @@ module RJGit
     end
     
     def self.ls_tree(repository, tree=nil, options={})
-      options = {:recursive => false, :print => false, :io => $stdout, :branch => Constants::HEAD}.merge(options)
+      options = {:recursive => false, :print => false, :io => $stdout, :ref => Constants::HEAD}.merge options
       jrepo = RJGit.repository_type(repository)
       return nil unless jrepo
       if tree 
         jtree = RJGit.tree_type(tree)
       else
-        last_commit_hash = jrepo.resolve(options[:branch])
+        last_commit_hash = jrepo.resolve(options[:ref])
         return nil unless last_commit_hash
         walk = RevWalk.new(jrepo)
         jcommit = walk.parse_commit(last_commit_hash)
@@ -77,6 +80,7 @@ module RJGit
       end
       treewalk = TreeWalk.new(jrepo)
       treewalk.set_recursive(options[:recursive])
+      treewalk.set_filter(PathFilter.create(options[:file_path])) if options[:file_path]
       treewalk.add_tree(jtree)
       entries = []
       while treewalk.next
@@ -115,18 +119,42 @@ module RJGit
     end
     
     def self.diff(repository, options = {})
-      options = {:namestatus => false}.merge(options)
+      options = {:namestatus => false, :patch => false}.merge(options)
       git = repository.git.jgit
+      repo = RJGit.repository_type(repository)
       diff_command = git.diff
-      diff_command.set_old_tree(old_tree) if options[:old_tree]
-      diff_command.set_new_tree(new_tree) if options[:new_tree]
-      diff_command.set_path_filter(PathFilter.create(file_path)) if options[:file_path]
+        if options[:old_rev] then
+          reader = repo.new_object_reader
+          old_tree = repo.resolve("#{options[:old_rev]}^{tree}")
+          old_tree_iter = CanonicalTreeParser.new
+          old_tree_iter.reset(reader, old_tree)
+          diff_command.set_old_tree(old_tree_iter)
+        end
+        if options[:new_rev] then
+          reader = repo.new_object_reader unless reader
+          new_tree = repo.resolve("#{options[:new_rev]}^{tree}")
+          new_tree_iter = CanonicalTreeParser.new
+          new_tree_iter.reset(reader, new_tree)
+          diff_command.set_new_tree(new_tree_iter)
+        end
+      diff_command.set_path_filter(PathFilter.create(options[:file_path])) if options[:file_path]
       diff_command.set_show_name_and_status_only(true) if options[:namestatus] 
       diff_command.set_cached(true) if options[:cached]
       diff_entries = diff_command.call
       diff_entries = diff_entries.to_array.to_ary
-      diff_entries = RJGit.convert_diff_entries(diff_entries)
-      return diff_entries
+        if options[:patch] then
+          result = []
+          out_stream = ByteArrayOutputStream.new
+          formatter = DiffFormatter.new(out_stream)
+          formatter.set_repository(repo)
+          diff_entries.each do |diff_entry|
+            formatter.format(diff_entry)
+            result.push [diff_entry, out_stream.to_string]
+            out_stream.reset
+          end
+        end
+      diff_entries = options[:patch] ? result : diff_entries.map {|entry| [entry]}
+      RJGit.convert_diff_entries(diff_entries)
     end
     
   end
@@ -149,7 +177,7 @@ module RJGit
       end
       
       def object_inserter
-        @jrepo.newObjectInserter
+        @object_inserter ||= @jrepo.newObjectInserter
       end
       
       def init_log
@@ -169,9 +197,10 @@ module RJGit
       
       def build_tree(start_tree, treemap = nil, flush = false)
         existing_trees = {}
+        untouched_objects = {}
         formatter = TreeFormatter.new
         treemap ||= self.treemap
-    
+
         if start_tree then
           treewalk = TreeWalk.new(@jrepo)
           treewalk.add_tree(start_tree)
@@ -185,30 +214,38 @@ module RJGit
                   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))
+              mode = treewalk.get_file_mode(0)
+              filename = "#{filename}/" if mode == FileMode::TREE
+              untouched_objects[filename] = [mode, treewalk.get_object_id(0)]
             end
           end
         end
     
-        treemap.each do |object_name, data|
+        sorted_treemap = treemap.inject({}) {|h, (k,v)| v.is_a?(Hash) ? h["#{k}/"] = v : h[k] = v; h }.merge(untouched_objects).sort
+        
+        sorted_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 Array
+              object_name = object_name[0...-1] if data[0] == FileMode::TREE
+              formatter.append(object_name.to_java_string, data[0], data[1])
             when Hash
+              object_name = object_name[0...-1]
               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)
+            when String
+              blobid = write_blob(data)
+              formatter.append(object_name.to_java_string, FileMode::REGULAR_FILE, blobid)
+              @log[:added] << [:blob, object_name, blobid]
             end
         end
     
-        result = object_inserter.insert(formatter)
+        object_inserter.insert(formatter)
       end
       
       def write_blob(contents, flush = false)
         blobid = object_inserter.insert(Constants::OBJ_BLOB, contents.to_java_bytes)
+        object_inserter.flush if flush
         blobid
       end
       
@@ -220,7 +257,7 @@ module RJGit
       attr_accessor :treemap, :current_tree
       attr_reader :jrepo
       
-      def initialize(repository, branch = nil)
+      def initialize(repository)
         @treemap = {}
         @jrepo = RJGit.repository_type(repository)
         @treebuilder = TreeBuilder.new(@jrepo)
@@ -272,10 +309,13 @@ module RJGit
           elsif parents
             commit_builder.addParentId(RJGit.commit_type(parents))
           end
-        @treebuilder.object_inserter.insert(commit_builder)
+        result = @treebuilder.object_inserter.insert(commit_builder)
+        @treebuilder.object_inserter.flush
+        result
       end
       
-      def commit(message, author, parents = nil, ref = "refs/heads/#{Constants::MASTER}")
+      def commit(message, author, parents = nil, ref = nil, force = false)
+        ref = ref ? 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)
@@ -287,17 +327,22 @@ module RJGit
         # Point ref to the newest commit
         ru = @jrepo.updateRef(ref)
         ru.setNewObjectId(new_head)
-        res = ru.forceUpdate.to_string
-      
+        ru.setForceUpdate(force)
+        ru.setRefLogIdent(author.person_ident)
+        ru.setRefLogMessage("commit: #{message}", false)
+        res = ru.update.to_string
+        
+        @treebuilder.object_inserter.release
         @current_tree = new_tree
         @treemap = {}
         log = @treebuilder.log
         @treebuilder.init_log
-        return res, log
+        sha =  ObjectId.to_string(new_head)
+        return res, log, sha
       end
       
       def self.successful?(result)
-        ["NEW", "FAST_FORWARD"].include?(result)
+        ["NEW", "FAST_FORWARD", "FORCED"].include?(result)
       end
       
     end

data/lib/rjgit_helpers.rb

@@ -50,21 +50,22 @@ module RJGit
   
   def self.convert_diff_entries(entries)
     entries.map do |diff_entry|
-      RJGit. diff_entry_to_hash(diff_entry)
+      RJGit.diff_entry_to_hash(diff_entry[0], diff_entry[1])
     end
   end
   
-  def self.diff_entry_to_hash(diff_entry)
+  def self.diff_entry_to_hash(diff_entry, patch)
     entry = {}
     entry[:changetype] = diff_entry.get_change_type.to_string
     entry[:oldpath] = diff_entry.get_old_path
     entry[:newpath] = diff_entry.get_new_path
-     entry[:oldmode] = diff_entry.get_old_mode.get_bits
-     entry[:newmode] = diff_entry.get_new_mode.get_bits
-     entry[:score] = diff_entry.get_score
-     entry[:oldid] = diff_entry.get_old_id.name
-     entry[:newid] = diff_entry.get_new_id.name
-     entry
+    entry[:oldmode] = diff_entry.get_old_mode.get_bits
+    entry[:newmode] = diff_entry.get_new_mode.get_bits
+    entry[:score] = diff_entry.get_score
+    entry[:oldid] = diff_entry.get_old_id.name
+    entry[:newid] = diff_entry.get_new_id.name
+    entry[:patch] = patch unless patch == nil
+    entry
   end
   
   def self.sym_for_type(type)

data/lib/tree.rb

@@ -64,7 +64,7 @@ module RJGit
       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)
+      Tree.new(jrepo, TREE_TYPE, nil, new_tree)
     end
     
     def self.find_tree(repository, file_path, revstring=Constants::HEAD)

data/lib/version.rb

@@ -1,3 +1,3 @@
 module RJGit
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rjgit
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Maarten Engelen
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-12-21 00:00:00.000000000 Z
+date: 2014-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types
@@ -35,12 +35,17 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- Gemfile
+- LICENSE
+- README.md
 - lib/actor.rb
 - lib/blob.rb
 - lib/commit.rb
 - lib/config.rb
 - lib/constants.rb
 - lib/git.rb
+- lib/java/jars/jsch-0.1.49.jar
+- lib/java/jars/org.eclipse.jgit-3.5.1.201410131835-r.jar
 - lib/repo.rb
 - lib/rjgit.rb
 - lib/rjgit_helpers.rb
@@ -48,11 +53,6 @@ files:
 - lib/transport.rb
 - lib/tree.rb
 - lib/version.rb
-- README.md
-- LICENSE
-- Gemfile
-- lib/java/jars/jsch-0.1.49.jar
-- lib/java/jars/org.eclipse.jgit-3.2.0.201312181205-r.jar
 homepage: https://github.com/repotag/rjgit
 licenses:
 - Modified BSD
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.1.9
+rubygems_version: 2.2.2
 signing_key:
 specification_version: 4
 summary: JRuby wrapper around the JGit library.