Reformatting.

- Bringing indents in a little.
- Simplifying a little logic so that boolean shortcuts are taken faster.

1 files changed, 642 insertions, 661 deletions

diff --git a/lib/diff/lcs.rb b/lib/diff/lcs.rb
index 8ae85be..fe4a4b0 100644
--- a/lib/diff/lcs.rb
+++ b/lib/diff/lcs.rb
@@ -1,136 +1,135 @@
 # -*- ruby encoding: utf-8 -*-
 
-module Diff
-  # = Diff::LCS 1.1.3
-  # 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>.
-  #
-  # 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:
-  #
-  #    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:
-  #
-  #    a b c d f g j z
-  #
-  # From there it's only a small step to get diff-like output:
-  #
-  #    e   h i   k   q r x y
-  #    +   - +   +   - + + +
-  #
-  # 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
-  #
-  #    a x b y c z p d q
-  #    a b c a x b y c z
-  #
-  # A naive approach might start by matching up the +a+ and +b+ that appear
-  # at the beginning of each sequence, like this:
-  #
-  #    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+:
-  #
-  #          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 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 LCS
-    VERSION = '1.1.3'
-  end
+module Diff; end unless defined? Diff
+# = Diff::LCS 1.2.0
+#
+# 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>.
+#
+# 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:
+#
+#    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:
+#
+#    a b c d f g j z
+#
+# From there it's only a small step to get diff-like output:
+#
+#    e   h i   k   q r x y
+#    +   - +   +   - + + +
+#
+# 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
+#
+#    a x b y c z p d q
+#    a b c a x b y c z
+#
+# A naive approach might start by matching up the +a+ and +b+ that appear at
+# the beginning of each sequence, like this:
+#
+#    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+:
+#
+#          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;2102 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.0'
 end
 
 require 'diff/lcs/callbacks'
@@ -142,7 +141,7 @@ module Diff::LCS
   #
   #   lcs = seq1.lcs(seq2)
   def lcs(other, &block) #:yields self[ii] if there are matched subsequences:
-    Diff::LCS.LCS(self, other, &block)
+    Diff::LCS.lcs(self, other, &block)
   end
 
   # Returns the difference set between +self+ and +other+. See
@@ -197,449 +196,388 @@ module Diff::LCS
   end
 end
 
-module Diff::LCS
-  class << self
-    # Given two sequenced Enumerables, LCS returns an Array containing their
-    # longest common subsequences.
-    #
-    #   lcs = Diff::LCS.LCS(seq1, seq2)
-    #
-    # This array whose contents is such that:
-    #
-    #   lcs.each_with_index do |ee, ii|
-    #     assert(ee.nil? || (seq1[ii] == seq2[ee]))
-    #   end
-    #
-    # If a block is provided, the matching subsequences will be yielded from
-    # +seq1+ in turn and may be modified before they are placed into the
-    # returned Array of subsequences.
-    def LCS(seq1, seq2, &block) #:yields seq1[ii] for each matched:
-      matches = Diff::LCS::Internals.lcs(seq1, seq2)
-      ret = []
-      matches.each_with_index do |ee, ii|
-        unless matches[ii].nil?
-          if block_given?
-            ret << (yield seq1[ii])
-          else
-            ret << seq1[ii]
-          end
+class << Diff::LCS
+  def lcs(seq1, seq2, &block) #:yields seq1[ii] for each matched:
+    matches = Diff::LCS::Internals.lcs(seq1, seq2)
+    ret = []
+    matches.each_with_index do |ee, ii|
+      unless matches[ii].nil?
+        if block_given?
+          ret << (yield seq1[ii])
+        else
+          ret << seq1[ii]
         end
       end
-      ret
     end
+    ret
+  end
+  alias_method :LCS, :lcs
 
-    # Diff::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.
-    #
-    # 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.
-    def diff(seq1, seq2, callbacks = nil, &block) # :yields diff changes:
-      callbacks ||= Diff::LCS::DiffCallbacks
-      if callbacks.kind_of?(Class)
-        cb = callbacks.new rescue callbacks
-        callbacks = cb
-      end
-      traverse_sequences(seq1, seq2, callbacks)
-      callbacks.finish if callbacks.respond_to?(:finish)
+  # #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.
+  #
+  # 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.
+  def diff(seq1, seq2, callbacks = nil, &block) # :yields diff changes:
+    callbacks ||= Diff::LCS::DiffCallbacks
+    if callbacks.kind_of?(Class)
+      cb = callbacks.new rescue callbacks
+      callbacks = cb
+    end
+    traverse_sequences(seq1, seq2, callbacks)
+    callbacks.finish if callbacks.respond_to?(:finish)
 
-      if block_given?
-        res = callbacks.diffs.map do |hunk|
-          if hunk.kind_of?(Array)
-            hunk = hunk.map { |hunk_block| yield hunk_block }
-          else
-            yield hunk
-          end
+    if block_given?
+      res = callbacks.diffs.map do |hunk|
+        if hunk.kind_of?(Array)
+          hunk = hunk.map { |hunk_block| yield hunk_block }
+        else
+          yield hunk
         end
-        res
-      else
-        callbacks.diffs
       end
+      res
+    else
+      callbacks.diffs
     end
+  end
 
-    # Diff::LCS.sdiff computes all necessary components to show two sequences
-    # and their minimized differences side by side, just like the Unix
-    # utility <em>sdiff</em> does:
-    #
-    #     old        <     -
-    #     same             same
-    #     before     |     after
-    #     -          >     new
-    #
-    # 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.
-    def sdiff(seq1, seq2, callbacks = nil, &block) #:yields diff changes:
-      callbacks ||= Diff::LCS::SDiffCallbacks
-      if callbacks.kind_of?(Class)
-        cb = callbacks.new rescue callbacks
-        callbacks = cb
-      end
-      traverse_balanced(seq1, seq2, callbacks)
-      callbacks.finish if callbacks.respond_to?(:finish)
+  # #sdiff computes all necessary components to show two sequences and their
+  # minimized differences side by side, just like the Unix utility
+  # <em>sdiff</em> does:
+  #
+  #     old        <     -
+  #     same             same
+  #     before     |     after
+  #     -          >     new
+  #
+  # 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.
+  def sdiff(seq1, seq2, callbacks = nil, &block) #:yields diff changes:
+    callbacks ||= Diff::LCS::SDiffCallbacks
+    if callbacks.kind_of?(Class)
+      cb = callbacks.new rescue callbacks
+      callbacks = cb
+    end
+    traverse_balanced(seq1, seq2, callbacks)
+    callbacks.finish if callbacks.respond_to?(:finish)
 
-      if block_given?
-        res = callbacks.diffs.map do |hunk|
-          if hunk.kind_of?(Array)
-            hunk = hunk.map { |hunk_block| yield hunk_block }
-          else
-            yield hunk
-          end
+    if block_given?
+      res = callbacks.diffs.map do |hunk|
+        if hunk.kind_of?(Array)
+          hunk = hunk.map { |hunk_block| yield hunk_block }
+        else
+          yield hunk
         end
-        res
-      else
-        callbacks.diffs
       end
+      res
+    else
+      callbacks.diffs
     end
+  end
 
-    # Diff::LCS.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:
-    #
-    #   traverse_sequences(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new)
-    #
-    # #diff is implemented with #traverse_sequences.
-    #
-    # == Callback Methods
-    # Optional callback methods are <em>emphasized</em>.
-    #
-    # callbacks#match::               Called when +a+ and +b+ are pointing
-    #                                 to common elements in +A+ and +B+.
-    # callbacks#discard_a::           Called when +a+ is pointing to an
-    #                                 element not in +B+.
-    # callbacks#discard_b::           Called when +b+ is pointing to an
-    #                                 element not in +A+.
-    # <em>callbacks#finished_a</em>:: Called when +a+ has reached the end of
-    #                                 sequence +A+.
-    # <em>callbacks#finished_b</em>:: Called when +b+ has reached the end of
-    #                                 sequence +B+.
-    #
-    # == Algorithm
-    #       a---+
-    #           v
-    #       A = a b c e h j l m n p
-    #       B = b c d e f j k l m r s t
-    #           ^
-    #       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[ii]</tt> and <tt>B[jj]</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[ii]</tt> and arrow +b+ is pointing to <tt>B[jj]</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 +ii+ and
-    # +jj+, and the elements <tt>A[ii]</tt> and <tt>B[jj]</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[jj]</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[jj]</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[ii]</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[ii]</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:
-      matches = Diff::LCS::Internals.lcs(seq1, seq2)
-
-      run_finished_a = run_finished_b = false
-      string = seq1.kind_of?(String)
-
-      a_size = seq1.size
-      b_size = seq2.size
-      ai = bj = 0
-
-      (0 .. matches.size).each do |ii|
-        b_line = matches[ii]
-
-        ax = string ? seq1[ii, 1] : seq1[ii]
-        bx = string ? seq2[bj, 1] : seq2[bj]
+  # #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:
+  #
+  #   traverse_sequences(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new)
+  #
+  # == Callback Methods
+  #
+  # Optional callback methods are <em>emphasized</em>.
+  #
+  # callbacks#match::               Called when +a+ and +b+ are pointing to
+  #                                 common elements in +A+ and +B+.
+  # callbacks#discard_a::           Called when +a+ is pointing to an
+  #                                 element not in +B+.
+  # callbacks#discard_b::           Called when +b+ is pointing to an
+  #                                 element not in +A+.
+  # <em>callbacks#finished_a</em>:: Called when +a+ has reached the end of
+  #                                 sequence +A+.
+  # <em>callbacks#finished_b</em>:: Called when +b+ has reached the end of
+  #                                 sequence +B+.
+  #
+  # == Algorithm
+  #
+  #       a---+
+  #           v
+  #       A = a b c e h j l m n p
+  #       B = b c d e f j k l m r s t
+  #           ^
+  #       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[ii]</tt> and
+  # <tt>B[jj]</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[ii]</tt> and
+  # arrow +b+ is pointing to <tt>B[jj]</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 +ii+ and +jj+,
+  # and the elements <tt>A[ii]</tt> and <tt>B[jj]</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[jj]</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[jj]</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[ii]</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[ii]</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:
+    matches = Diff::LCS::Internals.lcs(seq1, seq2)
 
-        if b_line.nil?
-          unless ax.nil? or (string and ax.empty?)
-            event = Diff::LCS::ContextChange.new('-', ii, ax, bj, bx)
-            event = yield event if block_given?
-            callbacks.discard_a(event)
-          end
-        else
-          loop do
-            break unless bj < b_line
-            bx = string ? seq2[bj, 1] : seq2[bj]
-            event = Diff::LCS::ContextChange.new('+', ii, ax, bj, bx)
-            event = yield event if block_given?
-            callbacks.discard_b(event)
-            bj += 1
-          end
-          bx = string ? seq2[bj, 1] : seq2[bj]
-          event = Diff::LCS::ContextChange.new('=', ii, ax, bj, bx)
-          event = yield event if block_given?
-          callbacks.match(event)
-          bj += 1
-        end
-        ai = ii
-      end
-      ai += 1
+    run_finished_a = run_finished_b = false
+    string = seq1.kind_of?(String)
 
-      # 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
-            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)
-            event = yield event if block_given?
-            callbacks.finished_a(event)
-            run_finished_a = true
-          else
-            ax = string ? seq1[ai, 1] : seq1[ai]
-            loop do
-              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
-              break unless bj < b_size
-            end
-          end
-        end
+    a_size = seq1.size
+    b_size = seq2.size
+    ai = bj = 0
 
-        # last B?
-        if bj == b_size and ai < a_size
-          if callbacks.respond_to?(:finished_b) and not 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)
-            event = yield event if block_given?
-            callbacks.finished_b(event)
-            run_finished_b = true
-          else
-            bx = string ? seq2[bj, 1] : seq2[bj]
-            loop do
-              ax = string ? seq1[ai, 1] : seq1[ai]
-              event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx)
-              event = yield event if block_given?
-              callbacks.discard_a(event)
-              ai += 1
-              break unless bj < b_size
-            end
-          end
-        end
+    (0 .. matches.size).each do |ii|
+      b_line = matches[ii]
 
-        if ai < a_size
-          ax = string ? seq1[ai, 1] : seq1[ai]
-          bx = string ? seq2[bj, 1] : seq2[bj]
-          event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx)
+      ax = string ? seq1[ii, 1] : seq1[ii]
+      bx = string ? seq2[bj, 1] : seq2[bj]
+
+      if b_line.nil?
+        unless ax.nil? or (string and ax.empty?)
+          event = Diff::LCS::ContextChange.new('-', ii, ax, bj, bx)
           event = yield event if block_given?
           callbacks.discard_a(event)
-          ai += 1
         end
-
-        if bj < b_size
-          ax = string ? seq1[ai, 1] : seq1[ai]
+      else
+        loop do
+          break unless bj < b_line
           bx = string ? seq2[bj, 1] : seq2[bj]
-          event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx)
+          event = Diff::LCS::ContextChange.new('+', ii, ax, bj, bx)
           event = yield event if block_given?
           callbacks.discard_b(event)
           bj += 1
         end
+        bx = string ? seq2[bj, 1] : seq2[bj]
+        event = Diff::LCS::ContextChange.new('=', ii, ax, bj, bx)
+        event = yield event if block_given?
+        callbacks.match(event)
+        bj += 1
       end
+      ai = ii
     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 <em>changes</em> between the sequences. To represent a
-    #
-    # 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)
-    #
-    # #sdiff is implemented with #traverse_balanced.
-    #
-    # == Callback Methods
-    # Optional callback methods are <em>emphasized</em>.
-    #
-    # callbacks#match::               Called when +a+ and +b+ are pointing
-    #                                 to common elements in +A+ and +B+.
-    # callbacks#discard_a::           Called when +a+ is pointing to an
-    #                                 element not in +B+.
-    # callbacks#discard_b::           Called when +b+ is pointing to an
-    #                                 element not in +A+.
-    # <em>callbacks#change</em>::     Called when +a+ and +b+ are pointing
-    #                                 to the same relative position, but
-    #                                 <tt>A[a]</tt> and <tt>B[b]</tt> are
-    #                                 not the same; a <em>change</em> has
-    #                                 occurred.
-    #
-    # #traverse_balanced might be a bit slower than #traverse_sequences,
-    # noticable only while processing huge amounts of data.
-    #
-    # The +sdiff+ function of this module is implemented as call to
-    # #traverse_balanced.
-    #
-    # == Algorithm
-    #       a---+
-    #           v
-    #       A = a b c e h j l m n p
-    #       B = b c d e f j k l m r s t
-    #           ^
-    #       b---+
-    #
-    # === 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[ii]</tt> and <tt>B[jj]</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[ii]</tt> and arrow +b+ is pointing to <tt>B[jj]</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 <tt>callbacks#discard_b</tt>,
-    # depending on which arrow it advanced.
-    #
-    # === Changes
-    # If both +a+ and +b+ point to elements that are not part of the longest
-    # common subsequence, then #traverse_sequences will try to call
-    # <tt>callbacks#change</tt> and advance both arrows. If
-    # <tt>callbacks#change</tt> is not implemented, then
-    # <tt>callbacks#discard_a</tt> and <tt>callbacks#discard_b</tt> will be
-    # called in turn.
-    #
-    # 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 +ii+ and +jj+, and the elements
-    # <tt>A[ii]</tt> and <tt>B[jj]</tt>. Return values are discarded by
-    # #traverse_balanced.
-    #
-    # === Context
-    # Note that +ii+ and +jj+ 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
-      b_size = seq2.size
-      ai = bj = mb = 0
-      ma = -1
-      string = seq1.kind_of?(String)
-
-        # Process all the lines in the match vector.
-      loop do
-          # Find next match indices +ma+ and +mb+
-        loop do
-          ma += 1
-          break unless ma < matches.size and matches[ma].nil?
+    ai += 1
+
+    # 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
+          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)
+          event = yield event if block_given?
+          callbacks.finished_a(event)
+          run_finished_a = true
+        else
+          ax = string ? seq1[ai, 1] : seq1[ai]
+          loop do
+            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
+            break unless bj < b_size
+          end
         end
+      end
 
-        break if ma >= matches.size # end of matches?
-        mb = matches[ma]
-
-          # Change(seq2)
-        while (ai < ma) or (bj < mb)
+      # last B?
+      if bj == b_size and ai < a_size
+        if callbacks.respond_to?(:finished_b) and not 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)
+          event = yield event if block_given?
+          callbacks.finished_b(event)
+          run_finished_b = true
+        else
           bx = string ? seq2[bj, 1] : seq2[bj]
-
-          case [(ai < ma), (bj < mb)]
-          when [true, true]
-            if callbacks.respond_to?(:change)
-              event = Diff::LCS::ContextChange.new('!', ai, ax, bj, bx)
-              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?
-              callbacks.discard_a(event)
-              ai += 1
-              ax = string ? seq1[ai, 1] : seq1[ai]
-              event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx)
-              event = yield event if block_given?
-              callbacks.discard_b(event)
-              bj += 1
-            end
-          when [true, false]
+          loop do
+            ax = string ? seq1[ai, 1] : seq1[ai]
             event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx)
             event = yield event if block_given?
             callbacks.discard_a(event)
             ai += 1
-          when [false, true]
-            event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx)
-            event = yield event if block_given?
-            callbacks.discard_b(event)
-            bj += 1
+            break unless bj < b_size
           end
         end
+      end
 
-        # Match
+      if ai < a_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 = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx)
         event = yield event if block_given?
-        callbacks.match(event)
+        callbacks.discard_a(event)
         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
+    end
+  end
 
-      while (ai < a_size) or (bj < b_size)
+  # #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
+  # <em>changes</em> between the sequences.
+  #
+  # 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)
+  #
+  # #sdiff is implemented with #traverse_balanced.
+  #
+  # == Callback Methods
+  #
+  # Optional callback methods are <em>emphasized</em>.
+  #
+  # callbacks#match::               Called when +a+ and +b+ are pointing to
+  #                                 common elements in +A+ and +B+.
+  # callbacks#discard_a::           Called when +a+ is pointing to an
+  #                                 element not in +B+.
+  # callbacks#discard_b::           Called when +b+ is pointing to an
+  #                                 element not in +A+.
+  # <em>callbacks#change</em>::     Called when +a+ and +b+ are pointing to
+  #                                 the same relative position, but
+  #                                 <tt>A[a]</tt> and <tt>B[b]</tt> are not
+  #                                 the same; a <em>change</em> has
+  #                                 occurred.
+  #
+  # #traverse_balanced might be a bit slower than #traverse_sequences,
+  # noticable only while processing huge amounts of data.
+  #
+  # == Algorithm
+  #
+  #       a---+
+  #           v
+  #       A = a b c e h j l m n p
+  #       B = b c d e f j k l m r s t
+  #           ^
+  #       b---+
+  #
+  # === 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[ii]</tt> and
+  # <tt>B[jj]</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[ii]</tt> and
+  # arrow +b+ is pointing to <tt>B[jj]</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
+  # <tt>callbacks#discard_b</tt>, depending on which arrow it advanced.
+  #
+  # === Changes
+  #
+  # If both +a+ and +b+ point to elements that are not part of the longest
+  # common subsequence, then #traverse_sequences will try to call
+  # <tt>callbacks#change</tt> and advance both arrows. If
+  # <tt>callbacks#change</tt> is not implemented, then
+  # <tt>callbacks#discard_a</tt> and <tt>callbacks#discard_b</tt> will be
+  # called in turn.
+  #
+  # 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 +ii+ and +jj+, and the elements
+  # <tt>A[ii]</tt> and <tt>B[jj]</tt>. Return values are discarded by
+  # #traverse_balanced.
+  #
+  # === Context
+  # Note that +ii+ and +jj+ 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
+    b_size = seq2.size
+    ai = bj = mb = 0
+    ma = -1
+    string = seq1.kind_of?(String)
+
+    # Process all the lines in the match vector.
+    loop do
+      # Find next match indices +ma+ and +mb+
+      loop do
+        ma += 1
+        break unless ma < matches.size and matches[ma].nil?
+      end
+
+      break if ma >= matches.size # end of matches?
+      mb = matches[ma]
+
+      # Change(seq2)
+      while (ai < ma) or (bj < mb)
         ax = string ? seq1[ai, 1] : seq1[ai]
         bx = string ? seq2[bj, 1] : seq2[bj]
 
-        case [(ai < a_size), (bj < b_size)]
+        case [(ai < ma), (bj < mb)]
         when [true, true]
           if callbacks.respond_to?(:change)
             event = Diff::LCS::ContextChange.new('!', ai, ax, bj, bx)
@@ -670,169 +608,212 @@ module Diff::LCS
           bj += 1
         end
       end
+
+      # Match
+      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.match(event)
+      ai += 1
+      bj += 1
     end
 
-    PATCH_MAP = { #:nodoc:
-      :patch => { '+' => '+', '-' => '-', '!' => '!', '=' => '=' },
-      :unpatch => { '+' => '-', '-' => '+', '!' => '!', '=' => '=' }
-    }
-
-    # Applies a +patchset+ to the sequence +src+ according to the
-    # +direction+ (<tt>:patch</tt> or <tt>:unpatch</tt>).
-    #
-    # If the +direction+ is not specified, Diff::LCS::patch will attempt to
-    # discover the direction of the +patchset+.
-    #
-    # A +patchset+ can be considered to apply forward (<tt>:patch</tt>) if
-    # the following expression is true:
-    #
-    #     patch(s1, diff(s1, s2)) -> s2
-    #
-    # 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:
-    #
-    #     patchset.empty? or
-    #       patchset.flatten.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:
-    #
-    #     [ # patchset
-    #       # change
-    #       [ # hunk
-    #         # change
-    #       ]
-    #     ]
-    #
-    # 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
+    while (ai < a_size) or (bj < b_size)
+      ax = string ? seq1[ai, 1] : seq1[ai]
+      bx = string ? seq2[bj, 1] : seq2[bj]
+
+      case [(ai < a_size), (bj < b_size)]
+      when [true, true]
+        if callbacks.respond_to?(:change)
+          event = Diff::LCS::ContextChange.new('!', ai, ax, bj, bx)
+          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?
+          callbacks.discard_a(event)
+          ai += 1
+          ax = string ? seq1[ai, 1] : seq1[ai]
+          event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx)
+          event = yield event if block_given?
+          callbacks.discard_b(event)
+          bj += 1
+        end
+      when [true, false]
+        event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx)
+        event = yield event if block_given?
+        callbacks.discard_a(event)
+        ai += 1
+      when [false, true]
+        event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx)
+        event = yield event if block_given?
+        callbacks.discard_b(event)
+        bj += 1
       end
+    end
+  end
 
-      string = src.kind_of?(String)
-      # Start with a new empty type of the source's class
-      res = src.class.new
+  PATCH_MAP = { #:nodoc:
+    :patch => { '+' => '+', '-' => '-', '!' => '!', '=' => '=' },
+    :unpatch => { '+' => '-', '-' => '+', '!' => '!', '=' => '=' }
+  }
 
-      direction ||= Diff::LCS::Internals.diff_direction(src, patchset)
+  # Applies a +patchset+ to the sequence +src+ according to the +direction+
+  # (<tt>:patch</tt> or <tt>:unpatch</tt>).
+  #
+  # If the +direction+ is not specified, Diff::LCS::patch will attempt to
+  # discover the direction of the +patchset+.
+  #
+  # A +patchset+ can be considered to apply forward (<tt>:patch</tt>) if the
+  # following expression is true:
+  #
+  #     patch(s1, diff(s1, s2)) -> s2
+  #
+  # 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:
+  #
+  #     patchset.empty? or
+  #       patchset.flatten.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:
+  #
+  #     [ # patchset
+  #       # change
+  #       [ # hunk
+  #         # change
+  #       ]
+  #     ]
+  #
+  # 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
 
-      ai = bj = 0
+    string = src.kind_of?(String)
+    # Start with a new empty type of the source's class
+    res = src.class.new
 
-      patch_map = PATCH_MAP[direction]
+    direction ||= Diff::LCS::Internals.diff_direction(src, patchset)
 
-      patchset.flatten.each do |change|
-        # Both Change and ContextChange support #action
-        action = patch_map[change.action]
+    ai = bj = 0
 
-        case change
-        when Diff::LCS::ContextChange
-          case direction
-          when :patch
-            el = change.new_element
-            op = change.old_position
-            np = change.new_position
-          when :unpatch
-            el = change.old_element
-            op = change.new_position
-            np = change.old_position
-          end
+    patch_map = PATCH_MAP[direction]
 
-          case action
-          when '-' # Remove details from the old string
-            while ai < op
-              res << (string ? src[ai, 1] : src[ai])
-              ai += 1
-              bj += 1
-            end
+    patchset.flatten.each do |change|
+      # Both Change and ContextChange support #action
+      action = patch_map[change.action]
+
+      case change
+      when Diff::LCS::ContextChange
+        case direction
+        when :patch
+          el = change.new_element
+          op = change.old_position
+          np = change.new_position
+        when :unpatch
+          el = change.old_element
+          op = change.new_position
+          np = change.old_position
+        end
+
+        case action
+        when '-' # Remove details from the old string
+          while ai < op
+            res << (string ? src[ai, 1] : src[ai])
+            ai += 1
+            bj += 1
+          end
+          ai += 1
+        when '+'
+          while bj < np
+            res << (string ? src[ai, 1] : src[ai])
             ai += 1
-          when '+'
-            while bj < np
-              res << (string ? src[ai, 1] : src[ai])
-              ai += 1
-              bj += 1
-            end
+            bj += 1
+          end
 
+        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
+          # element.
           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
-            # element.
-            res << el
 
+          ai += 1
+          bj += 1
+        when '!'
+          while ai < op
+            res << (string ? src[ai, 1] : src[ai])
             ai += 1
             bj += 1
-          when '!'
-            while ai < op
-              res << (string ? src[ai, 1] : src[ai])
-              ai += 1
-              bj += 1
-            end
+          end
 
-          bj += 1
-          ai += 1
+        bj += 1
+        ai += 1
 
-          res << el
+        res << el
+        end
+      when Diff::LCS::Change
+        case action
+        when '-'
+          while ai < change.position
+            res << (string ? src[ai, 1] : src[ai])
+            ai += 1
+            bj += 1
           end
-        when Diff::LCS::Change
-          case action
-          when '-'
-            while ai < change.position
-              res << (string ? src[ai, 1] : src[ai])
-              ai += 1
-              bj += 1
-            end
+        ai += 1
+        when '+'
+          while bj < change.position
+            res << (string ? src[ai, 1] : src[ai])
             ai += 1
-          when '+'
-            while bj < change.position
-              res << (string ? src[ai, 1] : src[ai])
-              ai += 1
-              bj += 1
-            end
-
             bj += 1
-
-            res << change.element
           end
-        end
-      end
 
-      while ai < src.size
-        res << (string ? src[ai, 1] : src[ai])
-        ai += 1
         bj += 1
-      end
 
-      res
+        res << change.element
+        end
+      end
     end
 
-    # Given a set of patchset, convert the current version to the prior
-    # version. Does no auto-discovery.
-    def unpatch!(src, patchset)
-      Diff::LCS.patch(src, patchset, :unpatch)
+    while ai < src.size
+      res << (string ? src[ai, 1] : src[ai])
+      ai += 1
+      bj += 1
     end
 
-    # Given a set of patchset, convert the current version to the next
-    # version. Does no auto-discovery.
-    def patch!(src, patchset)
-      Diff::LCS.patch(src, patchset, :patch)
-    end
+    res
+  end
+
+  # 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
-end
 
-# vim: ft=ruby
+  # 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