rjgit 5.6.0.0 → 5.8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c590ad61a1ab2ef9e2a778f49722cf46886d390185a02aa6ca1ac8ef0b0e8073
-  data.tar.gz: 2c13389fc678529de6623891ff123f6fe05effc86b147e21d488869bcfdb2741
+  metadata.gz: 2022eac50d1c23127bf8971f5b8b60e931eb643ea0a181956de3743418c62a00
+  data.tar.gz: 4c7ad80622c9889ab848c15e7d1fbcce99f41f08f4900620bf65d805f2da1ea6
 SHA512:
-  metadata.gz: af2a8f79cf5600e81a6df902d10d4fa9d51ce2e52b99d012ca9c978e36611d332f6647a5c267e225e5e5626841fd28985efef97b171f47f293d3da2866ab592b
-  data.tar.gz: acab43332a63d482908b9c52b835cfd9ee364880af1558c53829b81ef86a71a984b6d37413a36156331d47a7d21d4c4adc4cc5fd2b01a27b31c22c47d9f2c445
+  metadata.gz: e4da6ac22532cb16873e6d45246d7290695bc456abf73afd5eae8dced1141a14460fad41797927612585237f9e6fe7f5bcc0695dacfbe3fc9249e1134481a433
+  data.tar.gz: bd28dc840e9e7c2676ad4bb4aa6c7f9f16a5948d34fe8ecd5bb0930881cf5d0915d19ac62f969e1f06fd683fe3ad36e3b2d4365177a7f4dfe0ad88703af4b844

data/Gemfile

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

data/README.md

@@ -75,6 +75,13 @@ repo.find('959329025f67539fb82e76b02782322fad032821')
 repo.find('959329025f67539fb82e76b02782322fad032821', :commit) # Find a specific :commit, :blob, :tree, or :tag
 ```
 
+### Logs
+
+```ruby
+repo.git.log # Returns an Array of Commits constituting the log for the default branch
+repo.git.log("follow-rename.txt", "HEAD", follow: true, list_renames: true) # Log for a specific path, tracking the pathname over renames. Returns an Array of TrackingCommits, which store the tracked filename: [#<RJGit::TrackingCommit:0x773014d3 @tracked_pathname="follow-rename.txt" ...>]
+```
+
 ### Getting diffs
 ```ruby
 sha1 = repo.head.id

data/lib/actor.rb

@@ -2,6 +2,7 @@ module RJGit
 
   # PersonIdent in JGit
   import 'org.eclipse.jgit.lib.PersonIdent'
+  import 'java.util.TimeZone'
   
   class Actor
 
@@ -17,10 +18,11 @@ module RJGit
       return self.new(name, email)
     end
     
-    def initialize(name, email)
+    def initialize(name, email, time = nil)
       @name = name
       @email = email
-      @person_ident = PersonIdent.new(name, email)
+      @time = time
+      @person_ident = @time ? PersonIdent.new(name, email, time.to_java, TimeZone.getTimeZone(time.zone)) : PersonIdent.new(name, email)
     end
     
     # Create an Actor from a string.
@@ -43,7 +45,8 @@ module RJGit
     # time - The Time the commit was authored or committed.
     #
     # Returns a String.
-    def output(time)
+    def output(time = nil)
+      time = time || self.time
       offset = time.utc_offset / 60
       "%s <%s> %d %+.2d%.2d" % [
         @name,
@@ -52,6 +55,10 @@ module RJGit
         offset / 60,
         offset.abs % 60]
     end
+    
+    def time
+      Time.at(@person_ident.getWhen.getTime/1000)
+    end
 
   end 
 

data/lib/commit.rb

@@ -4,7 +4,7 @@ module RJGit
   import 'org.eclipse.jgit.revwalk.RevCommit'
   import 'org.eclipse.jgit.diff.DiffFormatter'
   import 'org.eclipse.jgit.util.io.DisabledOutputStream'
-
+  
   class Commit
 
     attr_reader :id, :parents, :actor, :committer, :authored_date, :committed_date
@@ -100,12 +100,12 @@ module RJGit
       Commit.new(repository, RevWalk.new(repository).parseCommit(new_commit))
     end
     
-    def self.find_head(repository)
+    def self.find_head(repository, ref = Constants::HEAD)
       repository = RJGit.repository_type(repository)
       return nil if repository.nil?
       begin
         walk = RevWalk.new(repository)
-        objhead = repository.resolve(Constants::HEAD)
+        objhead = repository.resolve(ref)
         return Commit.new(repository, walk.parseCommit(objhead))
       rescue java.lang.NullPointerException => e
         return nil
@@ -128,4 +128,13 @@ module RJGit
     end
   
   end
+  
+  class TrackingCommit < Commit
+    attr_reader :tracked_pathname # This commit is part of a log for a single pathname. The tracked_pathname attribute tracks the pathname over renames.
+    
+    def initialize(repository, commit, tracked_pathname = nil)
+      super(repository, commit)
+      @tracked_pathname = tracked_pathname
+    end
+  end
 end

data/lib/git.rb

@@ -15,6 +15,10 @@ module RJGit
   import 'org.eclipse.jgit.api.TransportConfigCallback'
   import 'org.eclipse.jgit.transport.JschConfigSessionFactory'
   import 'org.eclipse.jgit.transport.SshTransport'
+  import 'org.eclipse.jgit.revwalk.FollowFilter'
+  import 'org.eclipse.jgit.revwalk.TreeRevFilter'
+  
+  class PatchApplyException < StandardError; end
 
   class RubyGit
 
@@ -47,67 +51,58 @@ module RJGit
       return [] unless ref
       jcommits = Array.new
 
+      logs = @jgit.log
+      logs.add(ref)
+
       if path && options[:follow]
-        current_path = path
-        start = nil
-        loop do
-          logs = @jgit.log.add(ref).addPath(current_path).call
-          logs.each do |jcommit|
-            next if jcommits.include?(jcommit)
-            jcommits << jcommit
-            start = jcommit
-          end
-          current_path = follow_renames(start, current_path) if start
-          break if current_path.nil?
-        end
+        cfg       = Configuration.new(nil)
+        cfg.add_setting('renames', true, 'diffs', nil)
+        follow    = FollowFilter.create(path, cfg.jconfig.get(org.eclipse.jgit.diff.DiffConfig::KEY))
+        logs.set_rev_filter(TreeRevFilter.new(RevWalk.new(jrepo), follow))
+      elsif path
+        logs.addPath(path)
+      end
 
-      else
-        logs = @jgit.log
-        logs.add(ref)
-        logs.addPath(path) if path
-        logs.setMaxCount(options[:max_count]) if options[:max_count]
-        logs.setSkip(options[:skip]) if options[:skip]
-
-        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
+      logs.setMaxCount(options[:max_count]) if options[:max_count]
+      logs.setSkip(options[:skip]) if options[:skip]
+
+      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
 
-      jcommits.map{ |jcommit| Commit.new(jrepo, jcommit) }
-    end
+      if options[:not]
+        revwalk = RevWalk.new(jrepo)
+        options[:not].each do |ref|
+          logs.not(revwalk.parseCommit(jrepo.resolve(ref)))
+        end
+      end
 
-    def follow_renames(jcommit, path)
-      commits = @jgit.log.add(jcommit).call
-      commits.each do |jcommit_prev|
-        tree_start = jcommit.getTree
-        tree_prev  = jcommit_prev.getTree
-        treewalk = TreeWalk.new(jrepo)
-        #treewalk.setFilter(PathFilter.create(File.dirname(path)))
-        treewalk.addTree(tree_prev)
-        treewalk.addTree(tree_start)
-        treewalk.setRecursive(true)
-        rename_detector = RenameDetector.new(jrepo)
-        rename_detector.addAll(DiffEntry.scan(treewalk))
-        diff_entries = rename_detector.compute
-        diff_entries.each do |entry|
-          if ((entry.getChangeType == DiffEntry::ChangeType::RENAME || entry.getChangeType == DiffEntry::ChangeType::COPY) && entry.getNewPath.match(path))
-            return entry.getOldPath
-          end
+      if options[:follow] && options[:list_renames]
+        df = DiffFormatter.new(DisabledOutputStream::INSTANCE)
+        df.set_repository(jrepo)
+        df.set_context(0)
+        df.set_path_filter(follow)
+        df.set_detect_renames(true)
+        prev_commit = nil
+        pathname = path
+      end
+      
+      commits = logs.call.map do |jcommit|
+        if path && options[:follow] && options[:list_renames]
+          entries = df.scan(jcommit, prev_commit).to_a
+          pathname = entries.empty? ? pathname : entries.last.get_old_path
+          prev_commit = jcommit
+          TrackingCommit.new(jrepo, jcommit, pathname)
+        else
+          Commit.new(jrepo, jcommit)
         end
       end
-      return nil
-    end
 
+      commits
+    end
 
     def branch_list
       branch = @jgit.branch_list
@@ -289,7 +284,11 @@ module RJGit
     end
 
     def apply(input_stream)
-      apply_result = @jgit.apply.set_patch(input_stream).call
+      begin
+        apply_result = @jgit.apply.set_patch(input_stream).call
+      rescue Java::OrgEclipseJgitApiErrors::PatchApplyException
+        raise RJGit::PatchApplyException
+      end
       updated_files = apply_result.get_updated_files
       updated_files_parsed = []
       updated_files.each do |file|

data/lib/rjgit.rb

@@ -1,5 +1,4 @@
 module RJGit
-
   begin
     require 'java'
     Dir["#{File.dirname(__FILE__)}/java/jars/*.jar"].each { |jar| require jar }
@@ -10,7 +9,7 @@ module RJGit
   def self.version
     VERSION
   end
-  
+
   require 'uri'
   require 'stringio'
   # gem requires
@@ -19,37 +18,42 @@ module RJGit
   require "#{File.dirname(__FILE__)}/rjgit_helpers.rb"
   # require everything else
   begin
-    Dir["#{File.dirname(__FILE__)}/*.rb"].each do |file| 
+    Dir["#{File.dirname(__FILE__)}/*.rb"].each do |file|
       require file
     end
   end
-  
+
   import 'org.eclipse.jgit.lib.ObjectId'
-   
+  
   module Porcelain
-   
+
+    import 'java.io.IOException'
+    import 'org.eclipse.jgit.lib.Constants'
     import 'org.eclipse.jgit.api.AddCommand'
     import 'org.eclipse.jgit.api.CommitCommand'
     import 'org.eclipse.jgit.api.BlameCommand'
+    import 'org.eclipse.jgit.api.errors.RefNotFoundException'
     import 'org.eclipse.jgit.blame.BlameGenerator'
     import 'org.eclipse.jgit.blame.BlameResult'
+    import 'org.eclipse.jgit.errors.IncorrectObjectTypeException'
+    import 'org.eclipse.jgit.errors.InvalidPatternException'
+    import 'org.eclipse.jgit.errors.MissingObjectException'
     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)
       repository.add(file_pattern)
     end
-    
+
     def self.commit(repository, message="")
       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, blob)
       jrepo = RJGit.repository_type(repository)
@@ -65,7 +69,7 @@ module RJGit
       bytes = jrepo.open(jblob.id).get_bytes
       return bytes.to_a.pack('c*').force_encoding('UTF-8')
     end
-    
+
     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)
@@ -95,7 +99,7 @@ module RJGit
       treewalk.set_recursive(options[:recursive])
       treewalk.set_filter(PathFilter.create(options[:path_filter])) if options[:path_filter]
       entries = []
-    
+
       while treewalk.next
         entry = {}
         mode = treewalk.get_file_mode(0)
@@ -107,8 +111,8 @@ module RJGit
       end
       options[:io].puts RJGit.stringify(entries) if options[:print]
       entries
-    end  
-      
+    end
+
     def self.blame(repository, file_path, options={})
       options = {:print => false, :io => $stdout}.merge(options)
       jrepo = RJGit.repository_type(repository)
@@ -130,28 +134,22 @@ module RJGit
       options[:io].puts RJGit.stringify(blame) if options[:print]
       return blame
     end
-    
+
     def self.diff(repository, options = {})
       options = {:namestatus => false, :patch => false}.merge(options)
       repo = RJGit.repository_type(repository)
       git = RubyGit.new(repo).jgit
       diff_command = git.diff
-        if options[:old_rev]
+      [:old, :new].each do |which_rev|
+        if rev = options["#{which_rev}_rev".to_sym]
           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]
-          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)
+          parser = CanonicalTreeParser.new
+          parser.reset(reader, repo.resolve("#{rev}^{tree}"))
+          diff_command.send("set_#{which_rev}_tree".to_sym, parser)
         end
+      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_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
@@ -169,34 +167,86 @@ module RJGit
       diff_entries = options[:patch] ? result : diff_entries.map {|entry| [entry]}
       RJGit.convert_diff_entries(diff_entries)
     end
-    
+
+    def self.describe(repository, ref, options = {})
+      options = {:always => false, :long => false, :tags => false, :match => []}.merge(options)
+      repo = RJGit.repository_type(repository)
+      git = RubyGit.new(repo).jgit
+      command = git.describe.
+        set_always(options[:always]).
+        set_long(options[:long]).
+        set_tags(options[:tags])
+      begin
+        command = command.set_target(ref)
+      rescue IncorrectObjectTypeException, IOException, MissingObjectException, RefNotFoundException
+        return nil
+      end
+      options[:match].each do |match|
+        begin
+          command = command.set_match(match)
+        rescue InvalidPatternException
+          return nil
+        end
+      end
+      command.call
+    end
+
+    # options:
+    #  * ref
+    #  * path_filter
+    #  * case_insensitive
+    def self.grep(repository, query, options={})
+      case_insensitive = options[:case_insensitive]
+      repo = RJGit.repository_type(repository)
+      walk = RevWalk.new(repo)
+      ls_tree_options = {:recursive => true, :path_filter => options[:path_filter]}
+
+      query = case query
+      when Regexp then query
+      when String then Regexp.new(Regexp.escape(query))
+      else raise "A #{query.class} was passed to #{self}.grep().  Only Regexps and Strings are supported!"
+      end
+
+      query = Regexp.new(query.source, query.options | Regexp::IGNORECASE) if case_insensitive
+
+      ls_tree(repo, nil, options.fetch(:ref, 'HEAD'), ls_tree_options).each_with_object({}) do |item, result|
+        blob = Blob.new(repo, item[:mode], item[:path], walk.lookup_blob(ObjectId.from_string(item[:id])))
+        next if blob.binary?
+
+        rows = blob.data.split("\n")
+        data = rows.grep(query)
+        next if data.empty?
+
+        result[blob.path] = data
+      end
+    end
   end
-  
+
   module Plumbing
     import org.eclipse.jgit.lib.Constants
-    
+
     class TreeBuilder
       import org.eclipse.jgit.lib.FileMode
       import org.eclipse.jgit.lib.TreeFormatter
-      
-    
+      import org.eclipse.jgit.patch.Patch
+
       attr_accessor :treemap
       attr_reader :log
-      
+
       def initialize(repository)
         @jrepo = RJGit.repository_type(repository)
         @treemap = {}
         init_log
       end
-      
+
       def object_inserter
         @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)
@@ -207,7 +257,7 @@ module RJGit
         end
         true
       end
-      
+
       def build_tree(start_tree, treemap = nil, flush = false)
         existing_trees = {}
         untouched_objects = {}
@@ -232,7 +282,7 @@ 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.each do |object_name, data|
           case data
@@ -252,27 +302,27 @@ module RJGit
         end
         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
-      
+
     end
-    
+
     class Index
       import org.eclipse.jgit.lib.CommitBuilder
-      
+
       attr_accessor :treemap, :current_tree
       attr_reader :jrepo
-      
+
       def initialize(repository)
         @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('/')
@@ -289,24 +339,24 @@ module RJGit
         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
@@ -323,14 +373,11 @@ module RJGit
         @treebuilder.object_inserter.flush
         result
       end
-      
-      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)
+
+      def commit(message, author, parents = nil, ref = "refs/heads/#{Constants::MASTER}", force = false)
+        new_tree = build_new_tree(@treemap, "#{ref}^{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)
 
@@ -341,21 +388,129 @@ module RJGit
         ru.setRefLogIdent(author.person_ident)
         ru.setRefLogMessage("commit: #{message}", false)
         res = ru.update.to_string
-        
-        # @treebuilder.object_inserter.release
+
         @current_tree = new_tree
         log = @treebuilder.log
         @treebuilder.init_log
         sha =  ObjectId.to_string(new_head)
         return res, log, sha
       end
-      
+
       def self.successful?(result)
         ["NEW", "FAST_FORWARD", "FORCED"].include?(result)
       end
       
+      private
+      
+      def build_new_tree(treemap, ref)
+        @treebuilder.treemap = treemap
+        new_tree = @treebuilder.build_tree(@current_tree ? RJGit.tree_type(@current_tree) : @jrepo.resolve(ref))
+      end
+
     end
-    
+
+    class ApplyPatchToIndex < RJGit::Plumbing::Index
+
+      import org.eclipse.jgit.patch.Patch
+      import org.eclipse.jgit.diff.DiffEntry
+
+      ADD    = org.eclipse.jgit.diff.DiffEntry::ChangeType::ADD
+      COPY   = org.eclipse.jgit.diff.DiffEntry::ChangeType::COPY
+      MODIFY = org.eclipse.jgit.diff.DiffEntry::ChangeType::MODIFY
+      DELETE = org.eclipse.jgit.diff.DiffEntry::ChangeType::DELETE
+      RENAME = org.eclipse.jgit.diff.DiffEntry::ChangeType::RENAME
+
+      # Take the result of RJGit::Porcelain.diff with options[:patch] = true and return a patch String
+      def self.diffs_to_patch(diffs)
+        diffs.inject(""){|result, diff| result << diff[:patch]}
+      end
+
+      def initialize(repository, patch, ref = Constants::HEAD)
+        super(repository)
+        @ref   = ref
+        @patch = Patch.new
+        @patch.parse(ByteArrayInputStream.new(patch.to_java_bytes))
+        raise_patch_apply_error unless @patch.getErrors.isEmpty()
+        @current_tree = Commit.find_head(@jrepo, ref).tree
+      end
+
+      def commit(message, author, parents = nil, force = false)
+        super(message, author, parents, @ref, force)
+      end
+
+      def build_map
+        raise_patch_apply_error if @patch.getFiles.isEmpty()
+        @patch.getFiles.each do |file_header|
+          case file_header.getChangeType
+          when ADD
+            add(file_header.getNewPath, apply('', file_header))
+          when MODIFY
+            add(file_header.getOldPath, apply(getData(file_header.getOldPath), file_header))
+          when DELETE
+            delete(file_header.getOldPath)
+          when RENAME
+            delete(file_header.getOldPath)
+            add(file_header.getNewPath, getData(file_header.getOldPath))
+          when COPY
+            add(file_header.getNewPath, getData(file_header.getOldPath))
+          end
+        end
+        @treemap
+      end
+      
+      # Build the new tree based on the patch, but don't commit it
+      # Return the String object id of the new tree, and an Array of affected paths
+      def new_tree
+        map = build_map
+        return ObjectId.to_string(build_new_tree(map, @ref)), map.keys
+      end
+
+      private
+
+      def raise_patch_apply_error
+        raise ::RJGit::PatchApplyException.new('Patch failed to apply')
+      end
+
+      def getData(path)
+        begin
+          (@current_tree / path).data
+        rescue NoMethodError
+          raise_patch_apply_error
+        end
+      end
+
+      def hunk_sanity_check(hunk, hunk_line, pos, newLines)
+        raise_patch_apply_error unless newLines[hunk.getNewStartLine - 1 + pos] == hunk_line[1..-1]
+      end
+
+      def apply(original, file_header)
+        newLines = original.lines
+        file_header.getHunks.each do |hunk|
+          length = hunk.getEndOffset - hunk.getStartOffset
+          buffer_text = hunk.getBuffer.to_s.slice(hunk.getStartOffset, length)
+          pos = 0
+          buffer_text.each_line do |hunk_line|
+            case hunk_line[0]
+              when ' '
+                hunk_sanity_check(hunk, hunk_line, pos, newLines)
+                pos += 1
+              when '-'
+                if hunk.getNewStartLine == 0
+                  newLines = []
+                else
+                  hunk_sanity_check(hunk, hunk_line, pos, newLines)
+                  newLines.slice!(hunk.getNewStartLine - 1 + pos)
+                end
+              when '+'
+                newLines.insert(hunk.getNewStartLine - 1 + pos, hunk_line[1..-1])
+                pos += 1
+            end
+          end
+        end
+        newLines.join
+      end
+    end
+
   end
-  
+
 end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module RJGit
-  VERSION = "5.6.0.0"
+  VERSION = "5.8.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rjgit
 version: !ruby/object:Gem::Version
-  version: 5.6.0.0
+  version: 5.8.1.0
 platform: ruby
 authors:
 - Maarten Engelen
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-30 00:00:00.000000000 Z
+date: 2020-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -49,7 +49,8 @@ files:
 - lib/java/jars/bcpkix-jdk15on-161.jar
 - lib/java/jars/bcprov-jdk15on-161.jar
 - lib/java/jars/jsch-0.1.54.jar
-- lib/java/jars/org.eclipse.jgit-5.6.0.201912101111-r.jar
+- lib/java/jars/org.eclipse.jgit-5.8.1.202007141445-r.jar
+- lib/java/jars/org.eclipse.jgit.ssh.jsch-5.8.0.202006091008-r.jar
 - lib/java/jars/slf4j-api-1.7.2.jar
 - lib/java/jars/slf4j-simple-1.7.12.jar
 - lib/repo.rb