rjgit 4.1.1.0 → 4.2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de414913f4da2ef534b52b55772135221f7a6e46
-  data.tar.gz: c70951fb94958a2598ca3fac726eb4ad0b9c092c
+  metadata.gz: d56351d6b926d22b1eebd8c8c958b638cb1aef80
+  data.tar.gz: 6c5a3308f8fb57d5be9e80617835ab60f84a5ca6
 SHA512:
-  metadata.gz: dadcd6702f27e944c87b72f010964927c672be8a3a745d98b7565f0f0ec1d577f94f44a96ea5767e8999a8f384d49fa3a1f4a0d2d164f25c02bcde7bd38aaa9a
-  data.tar.gz: 21de8076d006644bca2677792dc0e4e2fee493e6c82bc604cbd4d172c6f0e7428574df8875458f68db20dccbedaf75dcb456d02c1a1e84bd2b8a087bdf3de353
+  metadata.gz: 07703d7678e79653a27b6d6e605c056b45eb9181fbee56bfe098d889802af1e52a64611786f7c1c43da9e45fb9a2a722344d84aaaf7dd2860164ec2065345fe5
+  data.tar.gz: 16fb0eab317a868eb2239e3194d93a8727ead62d8be8e34b7bb0381e9bf66197d37afb4806804f2357e8e83efd0e5eae6b75c93f7354070fd051e8a943ff81eb

data/Gemfile

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

data/lib/blob.rb

@@ -6,6 +6,7 @@ module RJGit
   class Blob 
     
     attr_reader :id, :mode, :name, :path, :jblob
+    alias_method :get_name, :id
     RJGit.delegate_to(RevBlob, :@jblob)
 
     def initialize(repository, mode, path, jblob)

data/lib/commit.rb

@@ -7,16 +7,9 @@ module RJGit
 
   class Commit
 
-    attr_reader :id
-    attr_reader :parents
-    attr_reader :actor
-    attr_reader :committer
-    attr_reader :authored_date
-    attr_reader :committed_date
-    attr_reader :message
-    attr_reader :short_message
-    attr_reader :jcommit
-    attr_reader :parent_count
+    attr_reader :id, :parents, :actor, :committer, :authored_date, :committed_date
+    attr_reader :message, :short_message, :jcommit, :parent_count
+    alias_method :get_name, :id
   
     RJGit.delegate_to(RevCommit, :@jcommit)
     
@@ -38,14 +31,16 @@ module RJGit
     end
   
     def parents
-      @parents ||= @jcommit.get_parents.map {|parent| Commit.new(@jrepo, parent)}
+      @parents ||= @jcommit.get_parents.map do |parent|
+        RJGit::Commit.new(@jrepo, RevWalk.new(@jrepo).parseCommit(parent.get_id))
+      end
     end
 
     def stats
       df = DiffFormatter.new(DisabledOutputStream::INSTANCE)
       df.set_repository(@jrepo)
       df.set_context(0)
-      parent_commit = @jcommit.parent_count > 0 ? @jcommit.get_parents[0]:nil
+      parent_commit = @jcommit.parent_count > 0 ? @jcommit.get_parents[0] : nil
       entries = df.scan(parent_commit, @jcommit)
       results = {}
       total_del = 0
@@ -67,6 +62,24 @@ module RJGit
       return total_ins, total_del, results
     end
 
+    def diff(options = {})
+      self.diffs(options).join
+    end
+
+    def diffs(options = {context: 2})
+      out_stream = ByteArrayOutputStream.new
+      formatter = DiffFormatter.new(out_stream)
+      formatter.set_repository(@jrepo)
+      formatter.set_context(options[:context])
+      parent_commit = @jcommit.parent_count > 0 ? @jcommit.get_parents.first : nil
+      entries = formatter.scan(parent_commit, @jcommit)
+      entries.each do |entry|
+        formatter.format(entry)
+        out_stream.write('custom_git_delimiter'.to_java_bytes)
+      end
+      out_stream.to_s.split('custom_git_delimiter')
+    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)
@@ -102,8 +115,5 @@ module RJGit
       end
     end
   
-    def self.diff(repo, a, b = nil, paths = [], options = {})
-    end
-
   end
 end

data/lib/git.rb

@@ -27,6 +27,14 @@ module RJGit
       @jgit = Git.new(@jrepo)
     end
 
+    def logs(refs, options = {})
+      logs = []
+      refs.each do |ref|
+        logs << log(nil, ref, options)
+      end
+      logs
+    end
+    
     def log(path = nil, revstring = Constants::HEAD, options = {})
       ref = jrepo.resolve(revstring)
       return [] unless ref
@@ -52,9 +60,19 @@ module RJGit
         logs.addPath(path) if path
         logs.setMaxCount(options[:max_count]) if options[:max_count]
         logs.setSkip(options[:skip]) if options[:skip]
-        # These options need tests
-        # logs.addRange(options[:since], options[:until]) if (options[:since] && options[:until])
-        # logs.not(options[:not]) if options[:not]
+
+        if (options[:since] && options[:until])
+          revwalk = RevWalk.new(jrepo)
+          since_commit = revwalk.parseCommit(jrepo.resolve(options[:since]))
+          until_commit = revwalk.parseCommit(jrepo.resolve(options[:until]))
+          logs.addRange(since_commit, until_commit) 
+        end
+        if options[:not]
+          revwalk = RevWalk.new(jrepo)
+          options[:not].each do |ref|
+            logs.not(revwalk.parseCommit(jrepo.resolve(ref)))
+          end
+        end
         jcommits = logs.call
       end
       

data/lib/rjgit.rb

@@ -65,24 +65,36 @@ module RJGit
       return bytes.to_a.pack('c*').force_encoding('UTF-8')
     end
     
-    def self.ls_tree(repository, tree=nil, options={})
-      options = {:recursive => false, :print => false, :io => $stdout, :ref => Constants::HEAD}.merge options
+    def self.ls_tree(repository, path=nil, treeish=Constants::HEAD, options={})
+      options = {recursive: false, print: false, io: $stdout, path_filter: nil}.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[:ref])
-        return nil unless last_commit_hash
+      ref = treeish.respond_to?(:get_name) ? treeish.get_name : treeish
+
+      begin
+        obj = jrepo.resolve(ref)
         walk = RevWalk.new(jrepo)
-        jcommit = walk.parse_commit(last_commit_hash)
-        jtree = jcommit.get_tree
+        revobj = walk.parse_any(obj)
+        jtree = case revobj.get_type
+        when Constants::OBJ_TREE
+          walk.parse_tree(obj)
+        when Constants::OBJ_COMMIT
+          walk.parse_commit(obj).get_tree
+        end
+      rescue Java::OrgEclipseJgitErrors::MissingObjectException, Java::JavaLang::IllegalArgumentException, Java::JavaLang::NullPointerException
+        return nil
+      end
+      if path
+        treewalk = TreeWalk.forPath(jrepo, path, jtree)
+        return nil unless treewalk
+        treewalk.enter_subtree
+      else
+        treewalk = TreeWalk.new(jrepo)
+        treewalk.add_tree(jtree)
       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)
+      treewalk.set_filter(PathFilter.create(options[:path_filter])) if options[:path_filter]
       entries = []
+    
       while treewalk.next
         entry = {}
         mode = treewalk.get_file_mode(0)
@@ -93,8 +105,8 @@ module RJGit
         entries << entry
       end
       options[:io].puts RJGit.stringify(entries) if options[:print]
-      return entries
-    end
+      entries
+    end  
       
     def self.blame(repository, file_path, options={})
       options = {:print => false, :io => $stdout}.merge(options)
@@ -200,15 +212,14 @@ module RJGit
         untouched_objects = {}
         formatter = TreeFormatter.new
         treemap ||= self.treemap
-
-        if start_tree then
+        if start_tree
           treewalk = TreeWalk.new(@jrepo)
           treewalk.add_tree(start_tree)
           while treewalk.next
             filename = treewalk.get_name_string
-            if treemap.keys.include?(filename) then
+            if treemap.keys.include?(filename)
               kind = treewalk.isSubtree ? :tree : :blob
-                if treemap[filename] == false then
+                if treemap[filename] == false
                   @log[:deleted] << [kind, filename, treewalk.get_object_id(0)]
                 else
                   existing_trees[filename] = treewalk.get_object_id(0) if kind == :tree
@@ -220,9 +231,8 @@ module RJGit
             end
           end
         end
-    
-        sorted_treemap = treemap.inject({}) {|h, (k,v)| v.is_a?(Hash) ? h["#{k}/"] = v : h[k] = v; h }.merge(untouched_objects).sort
         
+        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 Array
@@ -239,7 +249,6 @@ module RJGit
               @log[:added] << [:blob, object_name, blobid]
             end
         end
-    
         object_inserter.insert(formatter)
       end
       
@@ -349,5 +358,3 @@ module RJGit
   end
   
 end
-
-

data/lib/tag.rb

@@ -6,6 +6,7 @@ module RJGit
   class Tag
 
     attr_reader :id, :jtag
+    alias_method :get_name, :id
     RJGit.delegate_to(RevTag, :@jtag)
     
     def initialize(jtag)

data/lib/tree.rb

@@ -5,7 +5,8 @@ module RJGit
   
   class Tree 
 
-    attr_reader :contents, :id, :mode, :name, :repo, :jtree
+    attr_reader :contents, :id, :mode, :name, :repo, :path, :jtree
+    alias_method :get_name, :id
     RJGit.delegate_to(RevTree, :@jtree)
     include Enumerable
     
@@ -21,19 +22,29 @@ module RJGit
     def data
       return @contents if @contents
       strio = StringIO.new
-      RJGit::Porcelain.ls_tree(@jrepo, @jtree, options={:print => true, :io => strio})
+      RJGit::Porcelain.ls_tree(@jrepo, @path, Constants::HEAD, options={:print => true, :io => strio})
       @contents = strio.string
     end
     
     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'
+      @contents_ary ||= jtree_entries
+    end
+
+    def count
+      contents_array.size
+    end
+          
+    def recursive_contents_array(limit = nil)
+      if @recursive_contents.nil? || @recursive_contents[:limit] != limit
+        @recursive_contents = {}
+        @recursive_contents[:objects] = jtree_entries({recursive: true, limit: limit})
+        @recursive_contents[:limit] = limit
       end
-      @contents_ary = results
+      @recursive_contents[:objects]
+    end
+    
+    def recursive_count(limit = nil)
+      recursive_contents_array(limit).size
     end
     
     def each(&block)
@@ -41,20 +52,17 @@ module RJGit
     end
     
     def blobs
-      contents_array.select {|x| x.is_a?(Blob)}
+      @content_blobs ||= contents_array.select {|x| x.is_a?(Blob)}
     end
     
     def trees
-      contents_array.select {|x| x.is_a?(Tree)}
+      @content_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
+      treewalk = TreeWalk.forPath(@jrepo, file, @jtree)
+      treewalk.nil? ? nil : 
+        wrap_tree_or_blob(treewalk.get_file_mode(0), treewalk.get_path_string, treewalk.get_object_id(0))
     end
     
     def self.new_from_hashmap(repository, hashmap, base_tree = nil)
@@ -70,11 +78,11 @@ module RJGit
     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(revstring)
-      return nil if last_commit_hash.nil?
+      last_commit = jrepo.resolve(revstring)
+      return nil if last_commit.nil?
 
       walk = RevWalk.new(jrepo)
-      commit = walk.parse_commit(last_commit_hash)
+      commit = walk.parse_commit(last_commit)
       treewalk = TreeWalk.new(jrepo)
       jtree = commit.get_tree
       treewalk.add_tree(jtree)
@@ -89,6 +97,26 @@ module RJGit
         nil
       end
     end
+
+    private
+
+    def jtree_entries(options={})
+      treewalk = TreeWalk.new(@jrepo)
+      treewalk.add_tree(@jtree)
+      treewalk.set_recursive(true) if options[:recursive]
+      entries = []
+      while treewalk.next
+        entries << wrap_tree_or_blob(treewalk.get_file_mode(0), treewalk.get_path_string, treewalk.get_object_id(0))
+        break if options[:limit] && entries.size >= options[:limit].to_i
+      end
+      entries
+    end
+
+    def wrap_tree_or_blob(mode, path, id)
+      type = mode.get_object_type == Constants::OBJ_TREE ? RJGit::Tree : RJGit::Blob
+      walk = RevWalk.new(@jrepo)
+      type.new(@jrepo, mode.get_bits, path, walk.parse_any(id)) 
+    end
     
   end
   

data/lib/version.rb

@@ -1,3 +1,3 @@
 module RJGit
-  VERSION = "4.1.1.0"
+  VERSION = "4.2.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rjgit
 version: !ruby/object:Gem::Version
-  version: 4.1.1.0
+  version: 4.2.0.0
 platform: ruby
 authors:
 - Maarten Engelen
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-11-17 00:00:00.000000000 Z
+date: 2016-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types
@@ -45,7 +45,7 @@ files:
 - lib/constants.rb
 - lib/git.rb
 - lib/java/jars/jsch-0.1.49.jar
-- lib/java/jars/org.eclipse.jgit-4.1.1.201511131810-r.jar
+- lib/java/jars/org.eclipse.jgit-4.2.0.201601211800-r.jar
 - lib/java/jars/slf4j-api-1.7.2.jar
 - lib/java/jars/slf4j-simple-1.7.12.jar
 - lib/repo.rb