diff-lcs 1.2.5 → 1.4.4

data/Manifest.txt

@@ -1,12 +1,8 @@
-.autotest
-.gemtest
-.hoerc
 .rspec
-.travis.yml
-Contributing.rdoc
-Gemfile
-History.rdoc
-License.rdoc
+Code-of-Conduct.md
+Contributing.md
+History.md
+License.md
 Manifest.txt
 README.rdoc
 Rakefile
@@ -18,6 +14,7 @@ docs/artistic.txt
 lib/diff-lcs.rb
 lib/diff/lcs.rb
 lib/diff/lcs/array.rb
+lib/diff/lcs/backports.rb
 lib/diff/lcs/block.rb
 lib/diff/lcs/callbacks.rb
 lib/diff/lcs/change.rb
@@ -28,9 +25,19 @@ lib/diff/lcs/ldiff.rb
 lib/diff/lcs/string.rb
 spec/change_spec.rb
 spec/diff_spec.rb
+spec/fixtures/aX
+spec/fixtures/bXaX
+spec/fixtures/ds1.csv
+spec/fixtures/ds2.csv
+spec/fixtures/ldiff/output.diff
+spec/fixtures/ldiff/output.diff-c
+spec/fixtures/ldiff/output.diff-e
+spec/fixtures/ldiff/output.diff-f
+spec/fixtures/ldiff/output.diff-u
 spec/hunk_spec.rb
 spec/issues_spec.rb
 spec/lcs_spec.rb
+spec/ldiff_spec.rb
 spec/patch_spec.rb
 spec/sdiff_spec.rb
 spec/spec_helper.rb

data/README.rdoc

@@ -1,9 +1,10 @@
 = Diff::LCS
 
-home :: http://diff-lcs.rubyforge.org/
+home :: https://github.com/halostatue/diff-lcs
 code :: https://github.com/halostatue/diff-lcs
 bugs :: https://github.com/halostatue/diff-lcs/issues
 rdoc :: http://rubydoc.info/github/halostatue/diff-lcs
+continuous integration :: {<img src="https://github.com/halostatue/diff-lcs/workflows/CI/badge.svg" />}[https://github.com/halostatue/diff-lcs/actions]
 
 == Description
 
@@ -11,14 +12,15 @@ Diff::LCS computes the difference between two Enumerable sequences using the
 McIlroy-Hunt longest common subsequence (LCS) algorithm. It includes utilities
 to create a simple HTML diff output format and a standard diff-like tool.
 
-This is release 1.2.4, fixing a bug introduced after diff-lcs 1.1.3 that did
-not properly prune common sequences at the beginning of a comparison set.
-Thanks to Paul Kunysch for fixing this issue.
+This is release 1.4.3, providing a simple extension that allows for
+Diff::LCS::Change objects to be treated implicitly as arrays and fixes a
+number of formatting issues.
 
-Coincident with the release of diff-lcs 1.2.3, we reported an issue with
-Rubinius in 1.9 mode
-({rubinius/rubinius#2268}[https://github.com/rubinius/rubinius/issues/2268]).
-We are happy to report that this issue has been resolved.
+Ruby versions below 2.5 are soft-deprecated, which means that older versions
+are no longer part of the CI test suite. If any changes have been introduced
+that break those versions, bug reports and patches will be accepted, but it
+will be up to the reporter to verify any fixes prior to release. The next
+major release will completely break compatibility.
 
 == Synopsis
 
@@ -69,17 +71,14 @@ or Array will perform best.
 Diff::LCS is a port of Perl's Algorithm::Diff that uses the McIlroy-Hunt
 longest common subsequence (LCS) algorithm to compute intelligent differences
 between two sequenced enumerable containers. The implementation is based on
-Mario I. Wolczko's {Smalltalk version 1.2}[ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st]
+Mario I. Wolczko's
+{Smalltalk version 1.2}[ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st]
 (1993) and Ned Konz's Perl version
 {Algorithm::Diff 1.15}[http://search.cpan.org/~nedkonz/Algorithm-Diff-1.15/].
+Diff::LCS#sdiff and Diff::LCS#traverse_balanced were originally written for the
+Perl version by Mike Schilli.
 
-This library is called Diff::LCS because of an early version of Algorithm::Diff
-which was restrictively licensed.
-
-== Continuous Integration Status
-
-{<img src="https://travis-ci.org/halostatue/diff-lcs.png" />}[https://travis-ci.org/halostatue/diff-lcs]
-
-:include: Contributing.rdoc
-
-:include: License.rdoc
+The algorithm is described in <em>A Fast Algorithm for Computing Longest Common
+Subsequences</em>, CACM, vol.20, no.5, pp.350-353, May 1977, with a few minor
+improvements to improve the speed. A simplified description of the algorithm,
+originally written for the Perl version, was written by Mark-Jason Dominus.

data/Rakefile

@@ -1,4 +1,4 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'rubygems'
 require 'rspec'
@@ -6,36 +6,69 @@ require 'hoe'
 
 Hoe.plugin :bundler
 Hoe.plugin :doofus
-Hoe.plugin :email
 Hoe.plugin :gemspec2
 Hoe.plugin :git
-Hoe.plugin :rubyforge
-Hoe.plugin :travis
 
-Hoe.spec 'diff-lcs' do
-  developer('Austin Ziegler', 'austin@rubyforge.org')
+if RUBY_VERSION < '1.9'
+  class Array #:nodoc:
+    def to_h
+      Hash[*flatten(1)]
+    end
+  end
 
-  self.remote_rdoc_dir = '.'
-  self.rsync_args << ' --exclude=statsvn/'
+  class Gem::Specification #:nodoc:
+    def metadata=(*); end
 
-  self.history_file = 'History.rdoc'
+    def default_value(*); end
+  end
+
+  class Object #:nodoc:
+    def caller_locations(*)
+      []
+    end
+  end
+end
+
+_spec = Hoe.spec 'diff-lcs' do
+  developer('Austin Ziegler', 'halostatue@gmail.com')
+
+  require_ruby_version '>= 1.8'
+
+  self.history_file = 'History.md'
   self.readme_file = 'README.rdoc'
-  self.extra_rdoc_files = FileList["*.rdoc"].to_a
-
-  %w(MIT Perl\ Artistic\ v2 GNU\ GPL\ v2).each { |l| self.license l }
-
-  self.extra_dev_deps << ['hoe-bundler', '~> 1.2']
-  self.extra_dev_deps << ['hoe-doofus', '~> 1.0']
-  self.extra_dev_deps << ['hoe-gemspec2', '~> 1.1']
-  self.extra_dev_deps << ['hoe-git', '~> 1.5']
-  self.extra_dev_deps << ['hoe-rubygems', '~> 1.0']
-  self.extra_dev_deps << ['hoe-travis', '~> 1.2']
-  self.extra_dev_deps << ['rake', '~> 10.0']
-  self.extra_dev_deps << ['rspec', '~> 2.0']
+  self.licenses = ['MIT', 'Artistic-2.0', 'GPL-2.0+']
+
+  extra_dev_deps << ['hoe-doofus', '~> 1.0']
+  extra_dev_deps << ['hoe-gemspec2', '~> 1.1']
+  extra_dev_deps << ['hoe-git', '~> 1.6']
+  extra_dev_deps << ['hoe-rubygems', '~> 1.0']
+  extra_dev_deps << ['rspec', '>= 2.0', '< 4']
+  extra_dev_deps << ['rake', '>= 10.0', '< 14']
+  extra_dev_deps << ['rdoc', '>= 0']
 end
 
-unless Rake::Task.task_defined? :test
-  task :test => :spec
+if RUBY_VERSION >= '2.0' && RUBY_ENGINE == 'ruby'
+  namespace :spec do
+    desc "Runs test coverage. Only works Ruby 2.0+ and assumes 'simplecov' is installed."
+    task :coverage do
+      ENV['COVERAGE'] = 'yes'
+      Rake::Task['spec'].execute
+    end
+  end
 end
 
-# vim: syntax=ruby
+task :ruby18 do
+  puts <<-MESSAGE
+You are starting a barebones Ruby 1.8 docker environment. You will need to
+do the following:
+
+- mv Gemfile.lock{,.v2}
+- gem install bundler --version 1.17.2 --no-ri --no-rdoc
+- ruby -S bundle
+- rake
+
+Don't forget to restore your Gemfile.lock after testing.
+
+  MESSAGE
+  sh "docker run -it --rm -v #{Dir.pwd}:/root/diff-lcs bellbind/docker-ruby18-rails2 bash -l"
+end

data/autotest/discover.rb

@@ -1 +1,3 @@
-Autotest.add_discovery { "rspec2" }
+# frozen_string_literal: true
+
+Autotest.add_discovery { 'rspec2' }

data/bin/htmldiff

@@ -1,4 +1,5 @@
-#!ruby -w
+#! /usr/bin/env ruby -w
+# frozen_string_literal: true
 
 require 'diff/lcs'
 require 'diff/lcs/htmldiff'
@@ -10,8 +11,8 @@ rescue LoadError
 end
 
 if ARGV.size < 2 or ARGV.size > 3
-  $stderr.puts "usage: #{File.basename($0)} old new [output.html]"
-  $stderr.puts "       #{File.basename($0)} old new > output.html"
+  warn "usage: #{File.basename($0)} old new [output.html]"
+  warn "       #{File.basename($0)} old new > output.html"
   exit 127
 end
 
@@ -23,10 +24,12 @@ options = { :title => "diff #{ARGV[0]} #{ARGV[1]}" }
 htmldiff = Diff::LCS::HTMLDiff.new(left, right, options)
 
 if ARGV[2]
-  File.open(ARGV[2], "w") do |f|
+  File.open(ARGV[2], 'w') do |f|
     htmldiff.options[:output] = f
     htmldiff.run
   end
 else
   htmldiff.run
 end
+
+# vim: ft=ruby

data/bin/ldiff

@@ -1,6 +1,9 @@
-#!ruby -w
+#! /usr/bin/env ruby -w
+# frozen_string_literal: true
 
 require 'diff/lcs'
 require 'diff/lcs/ldiff'
 
 exit Diff::LCS::Ldiff.run(ARGV)
+
+# vim: ft=ruby

data/lib/diff-lcs.rb

@@ -1,3 +1,3 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'diff/lcs'

data/lib/diff/lcs.rb

@@ -1,76 +1,24 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-module Diff; end unless defined? Diff
-# = Diff::LCS 1.2.5
-#
-# Computes "intelligent" differences between two sequenced Enumerables. This
-# is an implementation of the McIlroy-Hunt "diff" algorithm for Enumerable
-# objects that include Diffable.
-#
-# Based on Mario I. Wolczko's Smalltalk version (1.2, 1993) and Ned Konz's
-# Perl version (Algorithm::Diff 1.15).
-#
-# == Synopsis
-#   require 'diff/lcs'
-#
-#   seq1 = %w(a b c e h j l m n p)
-#   seq2 = %w(b c d e f j k l m r s t)
-#
-#   lcs = Diff::LCS.lcs(seq1, seq2)
-#   diffs = Diff::LCS.diff(seq1, seq2)
-#   sdiff = Diff::LCS.sdiff(seq1, seq2)
-#   seq = Diff::LCS.traverse_sequences(seq1, seq2, callback_obj)
-#   bal = Diff::LCS.traverse_balanced(seq1, seq2, callback_obj)
-#   seq2 == Diff::LCS.patch(seq1, diffs)
-#   seq2 == Diff::LCS.patch!(seq1, diffs)
-#   seq1 == Diff::LCS.unpatch(seq2, diffs)
-#   seq1 == Diff::LCS.unpatch!(seq2, diffs)
-#   seq2 == Diff::LCS.patch(seq1, sdiff)
-#   seq2 == Diff::LCS.patch!(seq1, sdiff)
-#   seq1 == Diff::LCS.unpatch(seq2, sdiff)
-#   seq1 == Diff::LCS.unpatch!(seq2, sdiff)
-#
-# Alternatively, objects can be extended with Diff::LCS:
-#
-#   seq1.extend(Diff::LCS)
-#   lcs = seq1.lcs(seq2)
-#   diffs = seq1.diff(seq2)
-#   sdiff = seq1.sdiff(seq2)
-#   seq = seq1.traverse_sequences(seq2, callback_obj)
-#   bal = seq1.traverse_balanced(seq2, callback_obj)
-#   seq2 == seq1.patch(diffs)
-#   seq2 == seq1.patch!(diffs)
-#   seq1 == seq2.unpatch(diffs)
-#   seq1 == seq2.unpatch!(diffs)
-#   seq2 == seq1.patch(sdiff)
-#   seq2 == seq1.patch!(sdiff)
-#   seq1 == seq2.unpatch(sdiff)
-#   seq1 == seq2.unpatch!(sdiff)
-#
-# Default extensions are provided for Array and String objects through the
-# use of 'diff/lcs/array' and 'diff/lcs/string'.
-#
-# == Introduction (by Mark-Jason Dominus)
-#
-# <em>The following text is from the Perl documentation. The only changes
-# have been to make the text appear better in Rdoc</em>.
+module Diff; end unless defined? Diff # rubocop:disable Style/Documentation
+
+# == How Diff Works (by Mark-Jason Dominus)
 #
-# I once read an article written by the authors of +diff+; they said that
-# they hard worked very hard on the algorithm until they found the right
-# one.
+# I once read an article written by the authors of +diff+; they said that they
+# hard worked very hard on the algorithm until they found the right one.
 #
-# I think what they ended up using (and I hope someone will correct me,
-# because I am not very confident about this) was the `longest common
-# subsequence' method. In the LCS problem, you have two sequences of items:
+# I think what they ended up using (and I hope someone will correct me, because
+# I am not very confident about this) was the `longest common subsequence'
+# method. In the LCS problem, you have two sequences of items:
 #
 #    a b c d f g h j q z
 #    a b c d e f g i j k r x y z
 #
 # and you want to find the longest sequence of items that is present in both
 # original sequences in the same order. That is, you want to find a new
-# sequence *S* which can be obtained from the first sequence by deleting
-# some items, and from the second sequence by deleting other items. You also
-# want *S* to be as long as possible. In this case *S* is:
+# sequence *S* which can be obtained from the first sequence by deleting some
+# items, and from the second sequence by deleting other items. You also want
+# *S* to be as long as possible. In this case *S* is:
 #
 #    a b c d f g j z
 #
@@ -82,9 +30,9 @@ module Diff; end unless defined? Diff
 # This module solves the LCS problem. It also includes a canned function to
 # generate +diff+-like output.
 #
-# It might seem from the example above that the LCS of two sequences is
-# always pretty obvious, but that's not always the case, especially when the
-# two sequences have many repeated elements. For example, consider
+# It might seem from the example above that the LCS of two sequences is always
+# pretty obvious, but that's not always the case, especially when the two
+# sequences have many repeated elements. For example, consider
 #
 #    a x b y c z p d q
 #    a b c a x b y c z
@@ -95,57 +43,35 @@ module Diff; end unless defined? Diff
 #    a x b y c         z p d q
 #    a   b   c a b y c z
 #
-# This finds the common subsequence +a b c z+. But actually, the LCS is +a x
-# b y c z+:
+# This finds the common subsequence +a b c z+. But actually, the LCS is +a x b
+# y c z+:
 #
 #          a x b y c z p d q
 #    a b c a x b y c z
-#
-# == Author
-# This version is by Austin Ziegler <austin@rubyforge.org>.
-#
-# It is based on the Perl Algorithm::Diff (1.15) by Ned Konz , copyright
-# &copy; 2000&ndash;2002 and the Smalltalk diff version by Mario I.
-# Wolczko, copyright &copy; 1993. Documentation includes work by
-# Mark-Jason Dominus.
-#
-# == Licence
-# Copyright &copy; 2004&ndash;2013 Austin Ziegler
-# This program is free software; you can redistribute it and/or modify it
-# under the same terms as Ruby, or alternatively under the Perl Artistic
-# licence.
-#
-# == Credits
-# Much of the documentation is taken directly from the Perl Algorithm::Diff
-# implementation and was written originally by Mark-Jason Dominus and later
-# by Ned Konz. The basic Ruby implementation was re-ported from the
-# Smalltalk implementation, available at
-# ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st
-#
-# #sdiff and #traverse_balanced were written for the Perl version by Mike
-# Schilli <m@perlmeister.com>.
-#
-# "The algorithm is described in <em>A Fast Algorithm for Computing Longest
-# Common Subsequences</em>, CACM, vol.20, no.5, pp.350-353, May
-# 1977, with a few minor improvements to improve the speed."
 module Diff::LCS
-  VERSION = '1.2.5'
+  VERSION = '1.4.4'
 end
 
 require 'diff/lcs/callbacks'
 require 'diff/lcs/internals'
 
-module Diff::LCS
+module Diff::LCS # rubocop:disable Style/Documentation
   # Returns an Array containing the longest common subsequence(s) between
-  # +self+ and +other+. See Diff::LCS#LCS.
+  # +self+ and +other+. See Diff::LCS#lcs.
   #
   #   lcs = seq1.lcs(seq2)
+  #
+  # A note when using objects: Diff::LCS only works properly when each object
+  # can be used as a key in a Hash, which typically means that the objects must
+  # implement Object#eql? in a way that two identical values compare
+  # identically for key purposes. That is:
+  #
+  #   O.new('a').eql?(O.new('a')) == true
   def lcs(other, &block) #:yields self[i] if there are matched subsequences:
     Diff::LCS.lcs(self, other, &block)
   end
 
-  # Returns the difference set between +self+ and +other+. See
-  # Diff::LCS#diff.
+  # Returns the difference set between +self+ and +other+. See Diff::LCS#diff.
   def diff(other, callbacks = nil, &block)
     Diff::LCS.diff(self, other, callbacks, &block)
   end
@@ -159,29 +85,27 @@ module Diff::LCS
   # Traverses the discovered longest common subsequences between +self+ and
   # +other+. See Diff::LCS#traverse_sequences.
   def traverse_sequences(other, callbacks = nil, &block)
-    traverse_sequences(self, other, callbacks ||
-                       Diff::LCS.YieldingCallbacks, &block)
+    traverse_sequences(self, other, callbacks || Diff::LCS::SequenceCallbacks, &block)
   end
 
   # Traverses the discovered longest common subsequences between +self+ and
   # +other+ using the alternate, balanced algorithm. See
   # Diff::LCS#traverse_balanced.
   def traverse_balanced(other, callbacks = nil, &block)
-    traverse_balanced(self, other, callbacks ||
-                      Diff::LCS.YieldingCallbacks, &block)
+    traverse_balanced(self, other, callbacks || Diff::LCS::BalancedCallbacks, &block)
   end
 
-  # Attempts to patch +self+ with the provided +patchset+. A new sequence
-  # based on +self+ and the +patchset+ will be created. See Diff::LCS#patch.
-  # Attempts to autodiscover the direction of the patch.
+  # Attempts to patch +self+ with the provided +patchset+. A new sequence based
+  # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Attempts
+  # to autodiscover the direction of the patch.
   def patch(patchset)
     Diff::LCS.patch(self, patchset)
   end
-  alias_method :unpatch, :patch
+  alias unpatch patch
 
-  # Attempts to patch +self+ with the provided +patchset+. A new sequence
-  # based on +self+ and the +patchset+ will be created. See Diff::LCS#patch.
-  # Does no patch direction autodiscovery.
+  # Attempts to patch +self+ with the provided +patchset+. A new sequence based
+  # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Does no
+  # patch direction autodiscovery.
   def patch!(patchset)
     Diff::LCS.patch!(self, patchset)
   end
@@ -194,8 +118,8 @@ module Diff::LCS
   end
 
   # Attempts to patch +self+ with the provided +patchset+, using #patch!. If
-  # the sequence this is used on supports #replace, the value of +self+ will
-  # be replaced. See Diff::LCS#patch. Does no patch direction autodiscovery.
+  # the sequence this is used on supports #replace, the value of +self+ will be
+  # replaced. See Diff::LCS#patch. Does no patch direction autodiscovery.
   def patch_me(patchset)
     if respond_to? :replace
       replace(patch!(patchset))
@@ -204,10 +128,9 @@ module Diff::LCS
     end
   end
 
-  # Attempts to unpatch +self+ with the provided +patchset+, using
-  # #unpatch!. If the sequence this is used on supports #replace, the value
-  # of +self+ will be replaced. See Diff::LCS#unpatch. Does no patch direction
-  # autodiscovery.
+  # Attempts to unpatch +self+ with the provided +patchset+, using #unpatch!.
+  # If the sequence this is used on supports #replace, the value of +self+ will
+  # be replaced. See Diff::LCS#unpatch. Does no patch direction autodiscovery.
   def unpatch_me(patchset)
     if respond_to? :replace
       replace(unpatch!(patchset))
@@ -222,29 +145,28 @@ class << Diff::LCS
     matches = Diff::LCS::Internals.lcs(seq1, seq2)
     ret = []
     string = seq1.kind_of? String
-    matches.each_with_index do |e, i|
-      unless matches[i].nil?
-        v = string ? seq1[i, 1] : seq1[i]
-        v = block[v] if block
-        ret << v
-      end
+    matches.each_with_index do |_e, i|
+      next if matches[i].nil?
+
+      v = string ? seq1[i, 1] : seq1[i]
+      v = block[v] if block
+      ret << v
     end
     ret
   end
-  alias_method :LCS, :lcs
+  alias LCS lcs
 
   # #diff computes the smallest set of additions and deletions necessary to
-  # turn the first sequence into the second, and returns a description of
-  # these changes.
+  # turn the first sequence into the second, and returns a description of these
+  # changes.
   #
   # See Diff::LCS::DiffCallbacks for the default behaviour. An alternate
   # behaviour may be implemented with Diff::LCS::ContextDiffCallbacks. If a
   # Class argument is provided for +callbacks+, #diff will attempt to
-  # initialise it. If the +callbacks+ object (possibly initialised) responds
-  # to #finish, it will be called.
+  # initialise it. If the +callbacks+ object (possibly initialised) responds to
+  # #finish, it will be called.
   def diff(seq1, seq2, callbacks = nil, &block) # :yields diff changes:
-    diff_traversal(:diff, seq1, seq2, callbacks || Diff::LCS::DiffCallbacks,
-                   &block)
+    diff_traversal(:diff, seq1, seq2, callbacks || Diff::LCS::DiffCallbacks, &block)
   end
 
   # #sdiff computes all necessary components to show two sequences and their
@@ -259,18 +181,31 @@ class << Diff::LCS
   # See Diff::LCS::SDiffCallbacks for the default behaviour. An alternate
   # behaviour may be implemented with Diff::LCS::ContextDiffCallbacks. If a
   # Class argument is provided for +callbacks+, #diff will attempt to
-  # initialise it. If the +callbacks+ object (possibly initialised) responds
-  # to #finish, it will be called.
+  # initialise it. If the +callbacks+ object (possibly initialised) responds to
+  # #finish, it will be called.
+  #
+  # Each element of a returned array is a Diff::LCS::ContextChange object,
+  # which can be implicitly converted to an array.
+  #
+  #   Diff::LCS.sdiff(a, b).each do |action, (old_pos, old_element), (new_pos, new_element)|
+  #     case action
+  #     when '!'
+  #       # replace
+  #     when '-'
+  #       # delete
+  #     when '+'
+  #       # insert
+  #     end
+  #   end
   def sdiff(seq1, seq2, callbacks = nil, &block) #:yields diff changes:
-    diff_traversal(:sdiff, seq1, seq2, callbacks || Diff::LCS::SDiffCallbacks,
-                   &block)
+    diff_traversal(:sdiff, seq1, seq2, callbacks || Diff::LCS::SDiffCallbacks, &block)
   end
 
-  # #traverse_sequences is the most general facility provided by this
-  # module; #diff and #lcs are implemented as calls to it.
+  # #traverse_sequences is the most general facility provided by this module;
+  # #diff and #lcs are implemented as calls to it.
   #
-  # The arguments to #traverse_sequences are the two sequences to traverse,
-  # and a callback object, like this:
+  # The arguments to #traverse_sequences are the two sequences to traverse, and
+  # a callback object, like this:
   #
   #   traverse_sequences(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new)
   #
@@ -298,56 +233,55 @@ class << Diff::LCS
   #           ^
   #       b---+
   #
-  # If there are two arrows (+a+ and +b+) pointing to elements of sequences
-  # +A+ and +B+, the arrows will initially point to the first elements of
-  # their respective sequences. #traverse_sequences will advance the arrows
-  # through the sequences one element at a time, calling a method on the
-  # user-specified callback object before each advance. It will advance the
-  # arrows in such a way that if there are elements <tt>A[i]</tt> and
-  # <tt>B[j]</tt> which are both equal and part of the longest common
-  # subsequence, there will be some moment during the execution of
-  # #traverse_sequences when arrow +a+ is pointing to <tt>A[i]</tt> and
-  # arrow +b+ is pointing to <tt>B[j]</tt>. When this happens,
-  # #traverse_sequences will call <tt>callbacks#match</tt> and then it will
-  # advance both arrows.
-  #
-  # Otherwise, one of the arrows is pointing to an element of its sequence
-  # that is not part of the longest common subsequence. #traverse_sequences
-  # will advance that arrow and will call <tt>callbacks#discard_a</tt> or
-  # <tt>callbacks#discard_b</tt>, depending on which arrow it advanced. If
-  # both arrows point to elements that are not part of the longest common
-  # subsequence, then #traverse_sequences will advance one of them and call
-  # the appropriate callback, but it is not specified which it will call.
-  #
-  # The methods for <tt>callbacks#match</tt>, <tt>callbacks#discard_a</tt>,
-  # and <tt>callbacks#discard_b</tt> are invoked with an event comprising
-  # the action ("=", "+", or "-", respectively), the indicies +i+ and +j+,
-  # and the elements <tt>A[i]</tt> and <tt>B[j]</tt>. Return values are
-  # discarded by #traverse_sequences.
+  # If there are two arrows (+a+ and +b+) pointing to elements of sequences +A+
+  # and +B+, the arrows will initially point to the first elements of their
+  # respective sequences. #traverse_sequences will advance the arrows through
+  # the sequences one element at a time, calling a method on the user-specified
+  # callback object before each advance. It will advance the arrows in such a
+  # way that if there are elements <tt>A[i]</tt> and <tt>B[j]</tt> which are
+  # both equal and part of the longest common subsequence, there will be some
+  # moment during the execution of #traverse_sequences when arrow +a+ is
+  # pointing to <tt>A[i]</tt> and arrow +b+ is pointing to <tt>B[j]</tt>. When
+  # this happens, #traverse_sequences will call <tt>callbacks#match</tt> and
+  # then it will advance both arrows.
+  #
+  # Otherwise, one of the arrows is pointing to an element of its sequence that
+  # is not part of the longest common subsequence. #traverse_sequences will
+  # advance that arrow and will call <tt>callbacks#discard_a</tt> or
+  # <tt>callbacks#discard_b</tt>, depending on which arrow it advanced. If both
+  # arrows point to elements that are not part of the longest common
+  # subsequence, then #traverse_sequences will advance one of them and call the
+  # appropriate callback, but it is not specified which it will call.
+  #
+  # The methods for <tt>callbacks#match</tt>, <tt>callbacks#discard_a</tt>, and
+  # <tt>callbacks#discard_b</tt> are invoked with an event comprising the
+  # action ("=", "+", or "-", respectively), the indicies +i+ and +j+, and the
+  # elements <tt>A[i]</tt> and <tt>B[j]</tt>. Return values are discarded by
+  # #traverse_sequences.
   #
   # === End of Sequences
   #
   # If arrow +a+ reaches the end of its sequence before arrow +b+ does,
-  # #traverse_sequence will try to call <tt>callbacks#finished_a</tt> with
-  # the last index and element of +A+ (<tt>A[-1]</tt>) and the current index
-  # and element of +B+ (<tt>B[j]</tt>). If <tt>callbacks#finished_a</tt>
-  # does not exist, then <tt>callbacks#discard_b</tt> will be called on each
-  # element of +B+ until the end of the sequence is reached (the call will
-  # be done with <tt>A[-1]</tt> and <tt>B[j]</tt> for each element).
+  # #traverse_sequence will try to call <tt>callbacks#finished_a</tt> with the
+  # last index and element of +A+ (<tt>A[-1]</tt>) and the current index and
+  # element of +B+ (<tt>B[j]</tt>). If <tt>callbacks#finished_a</tt> does not
+  # exist, then <tt>callbacks#discard_b</tt> will be called on each element of
+  # +B+ until the end of the sequence is reached (the call will be done with
+  # <tt>A[-1]</tt> and <tt>B[j]</tt> for each element).
   #
   # If +b+ reaches the end of +B+ before +a+ reaches the end of +A+,
   # <tt>callbacks#finished_b</tt> will be called with the current index and
   # element of +A+ (<tt>A[i]</tt>) and the last index and element of +B+
-  # (<tt>A[-1]</tt>). Again, if <tt>callbacks#finished_b</tt> does not exist
-  # on the callback object, then <tt>callbacks#discard_a</tt> will be called
-  # on each element of +A+ until the end of the sequence is reached
-  # (<tt>A[i]</tt> and <tt>B[-1]</tt>).
+  # (<tt>A[-1]</tt>). Again, if <tt>callbacks#finished_b</tt> does not exist on
+  # the callback object, then <tt>callbacks#discard_a</tt> will be called on
+  # each element of +A+ until the end of the sequence is reached (<tt>A[i]</tt>
+  # and <tt>B[-1]</tt>).
   #
   # There is a chance that one additional <tt>callbacks#discard_a</tt> or
-  # <tt>callbacks#discard_b</tt> will be called after the end of the
-  # sequence is reached, if +a+ has not yet reached the end of +A+ or +b+
-  # has not yet reached the end of +B+.
-  def traverse_sequences(seq1, seq2, callbacks = Diff::LCS::SequenceCallbacks, &block) #:yields change events:
+  # <tt>callbacks#discard_b</tt> will be called after the end of the sequence
+  # is reached, if +a+ has not yet reached the end of +A+ or +b+ has not yet
+  # reached the end of +B+.
+  def traverse_sequences(seq1, seq2, callbacks = Diff::LCS::SequenceCallbacks) #:yields change events:
     callbacks ||= Diff::LCS::SequenceCallbacks
     matches = Diff::LCS::Internals.lcs(seq1, seq2)
 
@@ -373,6 +307,7 @@ class << Diff::LCS
       else
         loop do
           break unless bj < b_line
+
           bx = string ? seq2[bj, 1] : seq2[bj]
           event = Diff::LCS::ContextChange.new('+', i, ax, bj, bx)
           event = yield event if block_given?
@@ -389,12 +324,12 @@ class << Diff::LCS
     end
     ai += 1
 
-    # The last entry (if any) processed was a match. +ai+ and +bj+ point
-    # just past the last matching lines in their sequences.
+    # The last entry (if any) processed was a match. +ai+ and +bj+ point just
+    # past the last matching lines in their sequences.
     while (ai < a_size) or (bj < b_size)
       # last A?
       if ai == a_size and bj < b_size
-        if callbacks.respond_to?(:finished_a) and not run_finished_a
+        if callbacks.respond_to?(:finished_a) and !run_finished_a
           ax = string ? seq1[-1, 1] : seq1[-1]
           bx = string ? seq2[bj, 1] : seq2[bj]
           event = Diff::LCS::ContextChange.new('>', (a_size - 1), ax, bj, bx)
@@ -416,7 +351,7 @@ class << Diff::LCS
 
       # last B?
       if bj == b_size and ai < a_size
-        if callbacks.respond_to?(:finished_b) and not run_finished_b
+        if callbacks.respond_to?(:finished_b) and !run_finished_b
           ax = string ? seq1[ai, 1] : seq1[ai]
           bx = string ? seq2[-1, 1] : seq2[-1]
           event = Diff::LCS::ContextChange.new('<', ai, ax, (b_size - 1), bx)
@@ -445,25 +380,25 @@ class << Diff::LCS
         ai += 1
       end
 
-      if bj < b_size
-        ax = string ? seq1[ai, 1] : seq1[ai]
-        bx = string ? seq2[bj, 1] : seq2[bj]
-        event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx)
-        event = yield event if block_given?
-        callbacks.discard_b(event)
-        bj += 1
-      end
+      next unless bj < b_size
+
+      ax = string ? seq1[ai, 1] : seq1[ai]
+      bx = string ? seq2[bj, 1] : seq2[bj]
+      event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx)
+      event = yield event if block_given?
+      callbacks.discard_b(event)
+      bj += 1
     end
   end
 
   # #traverse_balanced is an alternative to #traverse_sequences. It uses a
-  # different algorithm to iterate through the entries in the computed
-  # longest common subsequence. Instead of viewing the changes as insertions
-  # or deletions from one of the sequences, #traverse_balanced will report
+  # different algorithm to iterate through the entries in the computed longest
+  # common subsequence. Instead of viewing the changes as insertions or
+  # deletions from one of the sequences, #traverse_balanced will report
   # <em>changes</em> between the sequences.
   #
-  # The arguments to #traverse_balanced are the two sequences to traverse
-  # and a callback object, like this:
+  # The arguments to #traverse_balanced are the two sequences to traverse and a
+  # callback object, like this:
   #
   #   traverse_balanced(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new)
   #
@@ -499,24 +434,23 @@ class << Diff::LCS
   #
   # === Matches
   #
-  # If there are two arrows (+a+ and +b+) pointing to elements of sequences
-  # +A+ and +B+, the arrows will initially point to the first elements of
-  # their respective sequences. #traverse_sequences will advance the arrows
-  # through the sequences one element at a time, calling a method on the
-  # user-specified callback object before each advance. It will advance the
-  # arrows in such a way that if there are elements <tt>A[i]</tt> and
-  # <tt>B[j]</tt> which are both equal and part of the longest common
-  # subsequence, there will be some moment during the execution of
-  # #traverse_sequences when arrow +a+ is pointing to <tt>A[i]</tt> and
-  # arrow +b+ is pointing to <tt>B[j]</tt>. When this happens,
-  # #traverse_sequences will call <tt>callbacks#match</tt> and then it will
-  # advance both arrows.
+  # If there are two arrows (+a+ and +b+) pointing to elements of sequences +A+
+  # and +B+, the arrows will initially point to the first elements of their
+  # respective sequences. #traverse_sequences will advance the arrows through
+  # the sequences one element at a time, calling a method on the user-specified
+  # callback object before each advance. It will advance the arrows in such a
+  # way that if there are elements <tt>A[i]</tt> and <tt>B[j]</tt> which are
+  # both equal and part of the longest common subsequence, there will be some
+  # moment during the execution of #traverse_sequences when arrow +a+ is
+  # pointing to <tt>A[i]</tt> and arrow +b+ is pointing to <tt>B[j]</tt>. When
+  # this happens, #traverse_sequences will call <tt>callbacks#match</tt> and
+  # then it will advance both arrows.
   #
   # === Discards
   #
-  # Otherwise, one of the arrows is pointing to an element of its sequence
-  # that is not part of the longest common subsequence. #traverse_sequences
-  # will advance that arrow and will call <tt>callbacks#discard_a</tt> or
+  # Otherwise, one of the arrows is pointing to an element of its sequence that
+  # is not part of the longest common subsequence. #traverse_sequences will
+  # advance that arrow and will call <tt>callbacks#discard_a</tt> or
   # <tt>callbacks#discard_b</tt>, depending on which arrow it advanced.
   #
   # === Changes
@@ -530,14 +464,14 @@ class << Diff::LCS
   #
   # The methods for <tt>callbacks#match</tt>, <tt>callbacks#discard_a</tt>,
   # <tt>callbacks#discard_b</tt>, and <tt>callbacks#change</tt> are invoked
-  # with an event comprising the action ("=", "+", "-", or "!",
-  # respectively), the indicies +i+ and +j+, and the elements
-  # <tt>A[i]</tt> and <tt>B[j]</tt>. Return values are discarded by
-  # #traverse_balanced.
+  # with an event comprising the action ("=", "+", "-", or "!", respectively),
+  # the indicies +i+ and +j+, and the elements <tt>A[i]</tt> and <tt>B[j]</tt>.
+  # Return values are discarded by #traverse_balanced.
   #
   # === Context
-  # Note that +i+ and +j+ may not be the same index position, even if +a+
-  # and +b+ are considered to be pointing to matching or changed elements.
+  #
+  # Note that +i+ and +j+ may not be the same index position, even if +a+ and
+  # +b+ are considered to be pointing to matching or changed elements.
   def traverse_balanced(seq1, seq2, callbacks = Diff::LCS::BalancedCallbacks)
     matches = Diff::LCS::Internals.lcs(seq1, seq2)
     a_size = seq1.size
@@ -555,6 +489,7 @@ class << Diff::LCS
       end
 
       break if ma >= matches.size # end of matches?
+
       mb = matches[ma]
 
       # Change(seq2)
@@ -569,7 +504,6 @@ class << Diff::LCS
             event = yield event if block_given?
             callbacks.change(event)
             ai += 1
-            bj += 1
           else
             event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx)
             event = yield event if block_given?
@@ -579,8 +513,9 @@ class << Diff::LCS
             event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx)
             event = yield event if block_given?
             callbacks.discard_b(event)
-            bj += 1
           end
+
+          bj += 1
         when [true, false]
           event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx)
           event = yield event if block_given?
@@ -615,7 +550,6 @@ class << Diff::LCS
           event = yield event if block_given?
           callbacks.change(event)
           ai += 1
-          bj += 1
         else
           event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx)
           event = yield event if block_given?
@@ -625,8 +559,9 @@ class << Diff::LCS
           event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx)
           event = yield event if block_given?
           callbacks.discard_b(event)
-          bj += 1
         end
+
+        bj += 1
       when [true, false]
         event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx)
         event = yield event if block_given?
@@ -642,9 +577,9 @@ class << Diff::LCS
   end
 
   PATCH_MAP = { #:nodoc:
-    :patch => { '+' => '+', '-' => '-', '!' => '!', '=' => '=' },
-    :unpatch => { '+' => '-', '-' => '+', '!' => '!', '=' => '=' }
-  }
+    :patch => { '+' => '+', '-' => '-', '!' => '!', '=' => '=' }.freeze,
+    :unpatch => { '+' => '-', '-' => '+', '!' => '!', '=' => '=' }.freeze
+  }.freeze
 
   # Applies a +patchset+ to the sequence +src+ according to the +direction+
   # (<tt>:patch</tt> or <tt>:unpatch</tt>), producing a new sequence.
@@ -657,23 +592,23 @@ class << Diff::LCS
   #
   #     patch(s1, diff(s1, s2)) -> s2
   #
-  # A +patchset+ can be considered to apply backward (<tt>:unpatch</tt>) if
-  # the following expression is true:
+  # A +patchset+ can be considered to apply backward (<tt>:unpatch</tt>) if the
+  # following expression is true:
   #
   #     patch(s2, diff(s1, s2)) -> s1
   #
-  # If the +patchset+ contains no changes, the +src+ value will be returned
-  # as either <tt>src.dup</tt> or +src+. A +patchset+ can be deemed as
-  # having no changes if the following predicate returns true:
+  # If the +patchset+ contains no changes, the +src+ value will be returned as
+  # either <tt>src.dup</tt> or +src+. A +patchset+ can be deemed as having no
+  # changes if the following predicate returns true:
   #
   #     patchset.empty? or
-  #       patchset.flatten.all? { |change| change.unchanged? }
+  #       patchset.flatten(1).all? { |change| change.unchanged? }
   #
   # === Patchsets
   #
-  # A +patchset+ is always an enumerable sequence of changes, hunks of
-  # changes, or a mix of the two. A hunk of changes is an enumerable
-  # sequence of changes:
+  # A +patchset+ is always an enumerable sequence of changes, hunks of changes,
+  # or a mix of the two. A hunk of changes is an enumerable sequence of
+  # changes:
   #
   #     [ # patchset
   #       # change
@@ -682,18 +617,15 @@ class << Diff::LCS
   #       ]
   #     ]
   #
-  # The +patch+ method accepts <tt>patchset</tt>s that are enumerable
-  # sequences containing either Diff::LCS::Change objects (or a subclass) or
-  # the array representations of those objects. Prior to application, array
+  # The +patch+ method accepts <tt>patchset</tt>s that are enumerable sequences
+  # containing either Diff::LCS::Change objects (or a subclass) or the array
+  # representations of those objects. Prior to application, array
   # representations of Diff::LCS::Change objects will be reified.
   def patch(src, patchset, direction = nil)
     # Normalize the patchset.
     has_changes, patchset = Diff::LCS::Internals.analyze_patchset(patchset)
 
-    if not has_changes
-      return src.dup if src.respond_to? :dup
-      return src
-    end
+    return src.respond_to?(:dup) ? src.dup : src unless has_changes
 
     string = src.kind_of?(String)
     # Start with a new empty type of the source's class
@@ -705,7 +637,7 @@ class << Diff::LCS
 
     patch_map = PATCH_MAP[direction]
 
-    patchset.flatten.each do |change|
+    patchset.each do |change|
       # Both Change and ContextChange support #action
       action = patch_map[change.action]
 
@@ -737,8 +669,8 @@ class << Diff::LCS
             bj += 1
           end
 
-        res << el
-        bj += 1
+          res << el
+          bj += 1
         when '='
           # This only appears in sdiff output with the SDiff callback.
           # Therefore, we only need to worry about dealing with a single
@@ -754,10 +686,10 @@ class << Diff::LCS
             bj += 1
           end
 
-        bj += 1
-        ai += 1
+          bj += 1
+          ai += 1
 
-        res << el
+          res << el
         end
       when Diff::LCS::Change
         case action
@@ -767,7 +699,7 @@ class << Diff::LCS
             ai += 1
             bj += 1
           end
-        ai += 1
+          ai += 1
         when '+'
           while bj < change.position
             res << (string ? src[ai, 1] : src[ai])
@@ -775,9 +707,9 @@ class << Diff::LCS
             bj += 1
           end
 
-        bj += 1
+          bj += 1
 
-        res << change.element
+          res << change.element
         end
       end
     end
@@ -791,15 +723,17 @@ class << Diff::LCS
     res
   end
 
-  # Given a set of patchset, convert the current version to the prior
-  # version. Does no auto-discovery.
+  # Given a set of patchset, convert the current version to the prior version.
+  # Does no auto-discovery.
   def unpatch!(src, patchset)
     patch(src, patchset, :unpatch)
   end
 
-  # Given a set of patchset, convert the current version to the next
-  # version. Does no auto-discovery.
+  # Given a set of patchset, convert the current version to the next version.
+  # Does no auto-discovery.
   def patch!(src, patchset)
     patch(src, patchset, :patch)
   end
 end
+
+require 'diff/lcs/backports'