mumukit-content-type 1.11.0 → 1.11.1

data/vendor/bundle/ruby/2.6.0/gems/diff-lcs-1.4.4/docs/artistic.txt

@@ -0,0 +1,127 @@
+The "Artistic License"
+
+				Preamble
+
+The intent of this document is to state the conditions under which a
+Package may be copied, such that the Copyright Holder maintains some
+semblance of artistic control over the development of the package,
+while giving the users of the package the right to use and distribute
+the Package in a more-or-less customary fashion, plus the right to make
+reasonable modifications.
+
+Definitions:
+
+	"Package" refers to the collection of files distributed by the
+	Copyright Holder, and derivatives of that collection of files
+	created through textual modification.
+
+	"Standard Version" refers to such a Package if it has not been
+	modified, or has been modified in accordance with the wishes
+	of the Copyright Holder as specified below.
+
+	"Copyright Holder" is whoever is named in the copyright or
+	copyrights for the package.
+
+	"You" is you, if you're thinking about copying or distributing
+	this Package.
+
+	"Reasonable copying fee" is whatever you can justify on the
+	basis of media cost, duplication charges, time of people involved,
+	and so on.  (You will not be required to justify it to the
+	Copyright Holder, but only to the computing community at large
+	as a market that must bear the fee.)
+
+	"Freely Available" means that no fee is charged for the item
+	itself, though there may be fees involved in handling the item.
+	It also means that recipients of the item may redistribute it
+	under the same conditions they received it.
+
+1. You may make and give away verbatim copies of the source form of the
+Standard Version of this Package without restriction, provided that you
+duplicate all of the original copyright notices and associated disclaimers.
+
+2. You may apply bug fixes, portability fixes and other modifications
+derived from the Public Domain or from the Copyright Holder.  A Package
+modified in such a way shall still be considered the Standard Version.
+
+3. You may otherwise modify your copy of this Package in any way, provided
+that you insert a prominent notice in each changed file stating how and
+when you changed that file, and provided that you do at least ONE of the
+following:
+
+    a) place your modifications in the Public Domain or otherwise make them
+    Freely Available, such as by posting said modifications to Usenet or
+    an equivalent medium, or placing the modifications on a major archive
+    site such as uunet.uu.net, or by allowing the Copyright Holder to include
+    your modifications in the Standard Version of the Package.
+
+    b) use the modified Package only within your corporation or organization.
+
+    c) rename any non-standard executables so the names do not conflict
+    with standard executables, which must also be provided, and provide
+    a separate manual page for each non-standard executable that clearly
+    documents how it differs from the Standard Version.
+
+    d) make other distribution arrangements with the Copyright Holder.
+
+4. You may distribute the programs of this Package in object code or
+executable form, provided that you do at least ONE of the following:
+
+    a) distribute a Standard Version of the executables and library files,
+    together with instructions (in the manual page or equivalent) on where
+    to get the Standard Version.
+
+    b) accompany the distribution with the machine-readable source of
+    the Package with your modifications.
+
+    c) give non-standard executables non-standard names, and clearly
+    document the differences in manual pages (or equivalent), together
+    with instructions on where to get the Standard Version.
+
+    d) make other distribution arrangements with the Copyright Holder.
+
+5. You may charge a reasonable copying fee for any distribution of this
+Package.  You may charge any fee you choose for support of this
+Package.  You may not charge a fee for this Package itself.  However,
+you may distribute this Package in aggregate with other (possibly
+commercial) programs as part of a larger (possibly commercial) software
+distribution provided that you do not advertise this Package as a
+product of your own.  You may embed this Package's interpreter within
+an executable of yours (by linking); this shall be construed as a mere
+form of aggregation, provided that the complete Standard Version of the
+interpreter is so embedded.
+
+6. The scripts and library files supplied as input to or produced as
+output from the programs of this Package do not automatically fall
+under the copyright of this Package, but belong to whoever generated
+them, and may be sold commercially, and may be aggregated with this
+Package.  If such scripts or library files are aggregated with this
+Package via the so-called "undump" or "unexec" methods of producing a
+binary executable image, then distribution of such an image shall
+neither be construed as a distribution of this Package nor shall it
+fall under the restrictions of Paragraphs 3 and 4, provided that you do
+not represent such an executable image as a Standard Version of this
+Package.
+
+7. C subroutines (or comparably compiled subroutines in other
+languages) supplied by you and linked into this Package in order to
+emulate subroutines and variables of the language defined by this
+Package shall not be considered part of this Package, but are the
+equivalent of input as in Paragraph 6, provided these subroutines do
+not change the language in any way that would cause it to fail the
+regression tests for the language.
+
+8. Aggregation of this Package with a commercial distribution is always
+permitted provided that the use of this Package is embedded; that is,
+when no overt attempt is made to make this Package's interfaces visible
+to the end user of the commercial distribution.  Such use shall not be
+construed as a distribution of this Package.
+
+9. The name of the Copyright Holder may not be used to endorse or promote
+products derived from this software without specific prior written permission.
+
+10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+				The End

data/vendor/bundle/ruby/2.6.0/gems/diff-lcs-1.4.4/lib/diff-lcs.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'diff/lcs'

data/vendor/bundle/ruby/2.6.0/gems/diff-lcs-1.4.4/lib/diff/lcs.rb

@@ -0,0 +1,739 @@
+# frozen_string_literal: true
+
+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 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
+module Diff::LCS
+  VERSION = '1.4.4'
+end
+
+require 'diff/lcs/callbacks'
+require 'diff/lcs/internals'
+
+module Diff::LCS # rubocop:disable Style/Documentation
+  # Returns an Array containing the longest common subsequence(s) between
+  # +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.
+  def diff(other, callbacks = nil, &block)
+    Diff::LCS.diff(self, other, callbacks, &block)
+  end
+
+  # Returns the balanced ("side-by-side") difference set between +self+ and
+  # +other+. See Diff::LCS#sdiff.
+  def sdiff(other, callbacks = nil, &block)
+    Diff::LCS.sdiff(self, other, callbacks, &block)
+  end
+
+  # 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::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::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.
+  def patch(patchset)
+    Diff::LCS.patch(self, patchset)
+  end
+  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.
+  def patch!(patchset)
+    Diff::LCS.patch!(self, patchset)
+  end
+
+  # Attempts to unpatch +self+ with the provided +patchset+. A new sequence
+  # based on +self+ and the +patchset+ will be created. See Diff::LCS#unpatch.
+  # Does no patch direction autodiscovery.
+  def unpatch!(patchset)
+    Diff::LCS.unpatch!(self, patchset)
+  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.
+  def patch_me(patchset)
+    if respond_to? :replace
+      replace(patch!(patchset))
+    else
+      patch!(patchset)
+    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.
+  def unpatch_me(patchset)
+    if respond_to? :replace
+      replace(unpatch!(patchset))
+    else
+      unpatch!(patchset)
+    end
+  end
+end
+
+class << Diff::LCS
+  def lcs(seq1, seq2, &block) #:yields seq1[i] for each matched:
+    matches = Diff::LCS::Internals.lcs(seq1, seq2)
+    ret = []
+    string = seq1.kind_of? String
+    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 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.
+  #
+  # 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:
+    diff_traversal(:diff, seq1, seq2, callbacks || Diff::LCS::DiffCallbacks, &block)
+  end
+
+  # #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.
+  #
+  # 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)
+  end
+
+  # #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[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).
+  #
+  # 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>).
+  #
+  # 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) #:yields change events:
+    callbacks ||= Diff::LCS::SequenceCallbacks
+    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 |i|
+      b_line = matches[i]
+
+      ax = string ? seq1[i, 1] : seq1[i]
+      bx = string ? seq2[bj, 1] : seq2[bj]
+
+      if b_line.nil?
+        unless ax.nil? or (string and ax.empty?)
+          event = Diff::LCS::ContextChange.new('-', i, 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('+', i, 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('=', i, ax, bj, bx)
+        event = yield event if block_given?
+        callbacks.match(event)
+        bj += 1
+      end
+      ai = i
+    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.
+    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 !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
+
+      # last B?
+      if bj == b_size and ai < a_size
+        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)
+          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
+
+      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 = yield event if block_given?
+        callbacks.discard_a(event)
+        ai += 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
+  # <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[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
+  # <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 +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.
+  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 < 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
+          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)
+          end
+
+          bj += 1
+        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
+
+      # 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
+
+    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
+        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)
+        end
+
+        bj += 1
+      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
+
+  PATCH_MAP = { #:nodoc:
+    :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.
+  #
+  # 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(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:
+  #
+  #     [ # 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)
+
+    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
+    res = src.class.new
+
+    direction ||= Diff::LCS::Internals.intuit_diff_direction(src, patchset)
+
+    ai = bj = 0
+
+    patch_map = PATCH_MAP[direction]
+
+    patchset.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
+            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
+
+          ai += 1
+          bj += 1
+        when '!'
+          while ai < op
+            res << (string ? src[ai, 1] : src[ai])
+            ai += 1
+            bj += 1
+          end
+
+          bj += 1
+          ai += 1
+
+          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
+          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
+  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
+
+  # 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'