geminfo 0.1.0 → 0.1.1

data/path/gems/diff-lcs-1.2.5/docs/artistic.txt

@@ -1,127 +0,0 @@
-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/path/gems/diff-lcs-1.2.5/lib/diff-lcs.rb

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

data/path/gems/diff-lcs-1.2.5/lib/diff/lcs.rb

@@ -1,805 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-
-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>.
-#
-# 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;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'
-end
-
-require 'diff/lcs/callbacks'
-require 'diff/lcs/internals'
-
-module Diff::LCS
-  # Returns an Array containing the longest common subsequence(s) between
-  # +self+ and +other+. See Diff::LCS#LCS.
-  #
-  #   lcs = seq1.lcs(seq2)
-  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.YieldingCallbacks, &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)
-  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_method :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|
-      unless matches[i].nil?
-        v = string ? seq1[i, 1] : seq1[i]
-        v = block[v] if block
-        ret << v
-      end
-    end
-    ret
-  end
-  alias_method :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.
-  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, &block) #: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 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
-
-      # 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
-
-      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
-
-      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
-
-  # #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
-            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
-
-      # 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
-          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
-
-  PATCH_MAP = { #:nodoc:
-    :patch => { '+' => '+', '-' => '-', '!' => '!', '=' => '=' },
-    :unpatch => { '+' => '-', '-' => '+', '!' => '!', '=' => '=' }
-  }
-
-  # 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.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
-
-    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.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
-            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