diff options
Diffstat (limited to 'LCS.html')
| -rw-r--r-- | LCS.html | 1119 |
1 files changed, 1119 insertions, 0 deletions
diff --git a/LCS.html b/LCS.html new file mode 100644 index 0000000..ef19930 --- /dev/null +++ b/LCS.html @@ -0,0 +1,1119 @@ +<!DOCTYPE html> + +<html> +<head> +<meta charset="UTF-8"> + +<title>module LCS - diff-lcs-1.5.0 Documentation</title> + +<script type="text/javascript"> + var rdoc_rel_prefix = "./"; + var index_rel_prefix = "./"; +</script> + +<script src="./js/navigation.js" defer></script> +<script src="./js/search.js" defer></script> +<script src="./js/search_index.js" defer></script> +<script src="./js/searcher.js" defer></script> +<script src="./js/darkfish.js" defer></script> + +<link href="./css/fonts.css" rel="stylesheet"> +<link href="./css/rdoc.css" rel="stylesheet"> + + +<body id="top" role="document" class="module"> +<nav role="navigation"> + <div id="project-navigation"> + <div id="home-section" role="region" title="Quick navigation" class="nav-section"> + <h2> + <a href="./index.html" rel="home">Home</a> + </h2> + + <div id="table-of-contents-navigation"> + <a href="./table_of_contents.html#pages">Pages</a> + <a href="./table_of_contents.html#classes">Classes</a> + <a href="./table_of_contents.html#methods">Methods</a> + </div> +</div> + + <div id="search-section" role="search" class="project-section initially-hidden"> + <form action="#" method="get" accept-charset="utf-8"> + <div id="search-field-wrapper"> + <input id="search-field" role="combobox" aria-label="Search" + aria-autocomplete="list" aria-controls="search-results" + type="text" name="search" placeholder="Search" spellcheck="false" + title="Type to search, Up and Down to navigate, Enter to load"> + </div> + + <ul id="search-results" aria-label="Search Results" + aria-busy="false" aria-expanded="false" + aria-atomic="false" class="initially-hidden"></ul> + </form> +</div> + + </div> + + + + <div id="class-metadata"> + + + + + +<!-- Method Quickref --> +<div id="method-list-section" class="nav-section"> + <h3>Methods</h3> + + <ul class="link-list" role="directory"> + <li ><a href="#method-c-LCS">::LCS</a> + <li ><a href="#method-c-callbacks_for">::callbacks_for</a> + <li ><a href="#method-c-diff">::diff</a> + <li ><a href="#method-c-lcs">::lcs</a> + <li ><a href="#method-c-patch">::patch</a> + <li ><a href="#method-c-patch-21">::patch!</a> + <li ><a href="#method-c-sdiff">::sdiff</a> + <li ><a href="#method-c-traverse_balanced">::traverse_balanced</a> + <li ><a href="#method-c-traverse_sequences">::traverse_sequences</a> + <li ><a href="#method-c-unpatch-21">::unpatch!</a> + <li ><a href="#method-i-diff">#diff</a> + <li ><a href="#method-i-lcs">#lcs</a> + <li ><a href="#method-i-patch">#patch</a> + <li ><a href="#method-i-patch-21">#patch!</a> + <li ><a href="#method-i-patch_me">#patch_me</a> + <li ><a href="#method-i-sdiff">#sdiff</a> + <li ><a href="#method-i-traverse_balanced">#traverse_balanced</a> + <li ><a href="#method-i-traverse_sequences">#traverse_sequences</a> + <li ><a href="#method-i-unpatch">#unpatch</a> + <li ><a href="#method-i-unpatch-21">#unpatch!</a> + <li ><a href="#method-i-unpatch_me">#unpatch_me</a> + </ul> +</div> + + </div> +</nav> + +<main role="main" aria-labelledby="module-LCS"> + <h1 id="module-LCS" class="module"> + module LCS + </h1> + + <section class="description"> + +<h2 id="module-LCS-label-How+Diff+Works+-28by+Mark-Jason+Dominus-29">How <a href="Diff.html"><code>Diff</code></a> Works (by Mark-Jason Dominus)<span><a href="#module-LCS-label-How+Diff+Works+-28by+Mark-Jason+Dominus-29">¶</a> <a href="#top">↑</a></span></h2> + +<p>I once read an article written by the authors of <code>diff</code>; they said that they hard worked very hard on the algorithm until they found the right one.</p> + +<p>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 <a href="LCS.html"><code>LCS</code></a> problem, you have two sequences of items:</p> + +<pre class="ruby"><span class="ruby-identifier">a</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">d</span> <span class="ruby-identifier">f</span> <span class="ruby-identifier">g</span> <span class="ruby-identifier">h</span> <span class="ruby-identifier">j</span> <span class="ruby-identifier">q</span> <span class="ruby-identifier">z</span> +<span class="ruby-identifier">a</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">d</span> <span class="ruby-identifier">e</span> <span class="ruby-identifier">f</span> <span class="ruby-identifier">g</span> <span class="ruby-identifier">i</span> <span class="ruby-identifier">j</span> <span class="ruby-identifier">k</span> <span class="ruby-identifier">r</span> <span class="ruby-identifier">x</span> <span class="ruby-identifier">y</span> <span class="ruby-identifier">z</span> +</pre> + +<p>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 <strong>S</strong> which can be obtained from the first sequence by deleting some items, and from the second sequence by deleting other items. You also want <strong>S</strong> to be as long as possible. In this case <strong>S</strong> is:</p> + +<pre class="ruby"><span class="ruby-identifier">a</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">d</span> <span class="ruby-identifier">f</span> <span class="ruby-identifier">g</span> <span class="ruby-identifier">j</span> <span class="ruby-identifier">z</span> +</pre> + +<p>From there it's only a small step to get diff-like output:</p> + +<pre>e h i k q r x y ++ - + + - + + +</pre> + +<p>This module solves the <a href="LCS.html"><code>LCS</code></a> problem. It also includes a canned function to generate <code>diff</code>-like output.</p> + +<p>It might seem from the example above that the <a href="LCS.html"><code>LCS</code></a> 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</p> + +<pre class="ruby"><span class="ruby-identifier">a</span> <span class="ruby-identifier">x</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">y</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">z</span> <span class="ruby-identifier">p</span> <span class="ruby-identifier">d</span> <span class="ruby-identifier">q</span> +<span class="ruby-identifier">a</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">x</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">y</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">z</span> +</pre> + +<p>A naive approach might start by matching up the <code>a</code> and <code>b</code> that appear at the beginning of each sequence, like this:</p> + +<pre class="ruby"><span class="ruby-identifier">a</span> <span class="ruby-identifier">x</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">y</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">z</span> <span class="ruby-identifier">p</span> <span class="ruby-identifier">d</span> <span class="ruby-identifier">q</span> +<span class="ruby-identifier">a</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">y</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">z</span> +</pre> + +<p>This finds the common subsequence +a b c z+. But actually, the <a href="LCS.html"><code>LCS</code></a> is +a x b y c z+:</p> + +<pre class="ruby"> <span class="ruby-identifier">a</span> <span class="ruby-identifier">x</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">y</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">z</span> <span class="ruby-identifier">p</span> <span class="ruby-identifier">d</span> <span class="ruby-identifier">q</span> +<span class="ruby-identifier">a</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">a</span> <span class="ruby-identifier">x</span> <span class="ruby-identifier">b</span> <span class="ruby-identifier">y</span> <span class="ruby-identifier">c</span> <span class="ruby-identifier">z</span> +</pre> + + </section> + + <section id="5Buntitled-5D" class="documentation-section"> + + + <section class="constants-list"> + <header> + <h3>Constants</h3> + </header> + <dl> + <dt id="BalancedCallbacks">BalancedCallbacks + <dd><p>This callback object implements the default set of callback events, which only returns the event itself. Note that finished_a and finished_b are not implemented – I haven't yet figured out where they would be useful.</p> + +<p>Note that this is intended to be called as is, e.g.,</p> + +<pre class="ruby"><span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-constant">LCS</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">DefaultCallbacks</span>) +</pre> + <dt id="SequenceCallbacks">SequenceCallbacks + <dd><p>This callback object implements the default set of callback events, which only returns the event itself. Note that finished_a and finished_b are not implemented – I haven't yet figured out where they would be useful.</p> + +<p>Note that this is intended to be called as is, e.g.,</p> + +<pre class="ruby"><span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-constant">LCS</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">DefaultCallbacks</span>) +</pre> + <dt id="VERSION">VERSION + <dd> + </dl> + </section> + + + + <section id="public-class-5Buntitled-5D-method-details" class="method-section"> + <header> + <h3>Public Class Methods</h3> + </header> + + <div id="method-c-LCS" class="method-detail method-alias"> + <div class="method-heading"> + <span class="method-name">LCS</span><span + class="method-args">(seq1, seq2, &block)</span> + </div> + + <div class="method-description"> + + + </div> + + + <div class="aliases"> + Alias for: <a href="LCS.html#method-c-lcs">lcs</a> + </div> + </div> + + <div id="method-c-callbacks_for" class="method-detail "> + <div class="method-heading"> + <span class="method-name">callbacks_for</span><span + class="method-args">(callbacks)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + + + <div class="method-source-code" id="callbacks_for-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs/callbacks.rb, line 52</span> +<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">callbacks_for</span>(<span class="ruby-identifier">callbacks</span>) + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">new</span> <span class="ruby-keyword">rescue</span> <span class="ruby-identifier">callbacks</span> +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-c-diff" class="method-detail "> + <div class="method-heading"> + <span class="method-name">diff</span><span + class="method-args">(seq1, seq2, callbacks = nil, &block)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p><a href="LCS.html#method-i-diff"><code>diff</code></a> computes the smallest set of additions and deletions necessary to turn the first sequence into the second, and returns a description of these changes.</p> + +<p>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 <code>callbacks</code>, <a href="LCS.html#method-i-diff"><code>diff</code></a> will attempt to initialise it. If the <code>callbacks</code> object (possibly initialised) responds to finish, it will be called.</p> + + <div class="method-source-code" id="diff-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 168</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">diff</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-identifier">callbacks</span> = <span class="ruby-keyword">nil</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) <span class="ruby-comment"># :yields diff changes:</span> + <span class="ruby-identifier">diff_traversal</span>(<span class="ruby-value">:diff</span>, <span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-identifier">callbacks</span> <span class="ruby-operator">||</span> <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">DiffCallbacks</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-c-lcs" class="method-detail "> + <div class="method-heading"> + <span class="method-name">lcs</span><span + class="method-args">(seq1, seq2, &block)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + + + <div class="method-source-code" id="lcs-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 144</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">lcs</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) <span class="ruby-comment">#:yields seq1[i] for each matched:</span> + <span class="ruby-identifier">matches</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">Internals</span>.<span class="ruby-identifier">lcs</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>) + <span class="ruby-identifier">ret</span> = [] + <span class="ruby-identifier">string</span> = <span class="ruby-identifier">seq1</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">String</span> + <span class="ruby-identifier">matches</span>.<span class="ruby-identifier">each_with_index</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">_e</span>, <span class="ruby-identifier">i</span><span class="ruby-operator">|</span> + <span class="ruby-keyword">next</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">matches</span>[<span class="ruby-identifier">i</span>].<span class="ruby-identifier">nil?</span> + + <span class="ruby-identifier">v</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">i</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">i</span>] + <span class="ruby-identifier">v</span> = <span class="ruby-identifier">block</span>[<span class="ruby-identifier">v</span>] <span class="ruby-keyword">if</span> <span class="ruby-identifier">block</span> + <span class="ruby-identifier">ret</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">v</span> + <span class="ruby-keyword">end</span> + <span class="ruby-identifier">ret</span> +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + <div class="aliases"> + Also aliased as: <a href="LCS.html#method-c-LCS">LCS</a> + </div> + + </div> + + <div id="method-c-patch" class="method-detail "> + <div class="method-heading"> + <span class="method-name">patch</span><span + class="method-args">(src, patchset, direction = nil)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Applies a <code>patchset</code> to the sequence <code>src</code> according to the <code>direction</code> (<code>:patch</code> or <code>:unpatch</code>), producing a new sequence.</p> + +<p>If the <code>direction</code> is not specified, <a href="LCS.html#method-c-patch"><code>Diff::LCS::patch</code></a> will attempt to discover the direction of the <code>patchset</code>.</p> + +<p>A <code>patchset</code> can be considered to apply forward (<code>:patch</code>) if the following expression is true:</p> + +<pre>patch(s1, diff(s1, s2)) -> s2</pre> + +<p>A <code>patchset</code> can be considered to apply backward (<code>:unpatch</code>) if the following expression is true:</p> + +<pre>patch(s2, diff(s1, s2)) -> s1</pre> + +<p>If the <code>patchset</code> contains no changes, the <code>src</code> value will be returned as either <code>src.dup</code> or <code>src</code>. A <code>patchset</code> can be deemed as having no changes if the following predicate returns true:</p> + +<pre class="ruby"><span class="ruby-identifier">patchset</span>.<span class="ruby-identifier">empty?</span> <span class="ruby-keyword">or</span> + <span class="ruby-identifier">patchset</span>.<span class="ruby-identifier">flatten</span>(<span class="ruby-value">1</span>).<span class="ruby-identifier">all?</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">change</span><span class="ruby-operator">|</span> <span class="ruby-identifier">change</span>.<span class="ruby-identifier">unchanged?</span> } +</pre> + +<h3 id="method-c-patch-label-Patchsets">Patchsets<span><a href="#method-c-patch-label-Patchsets">¶</a> <a href="#top">↑</a></span></h3> + +<p>A <code>patchset</code> 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:</p> + +<pre class="ruby">[ <span class="ruby-comment"># patchset</span> + <span class="ruby-comment"># change</span> + [ <span class="ruby-comment"># hunk</span> + <span class="ruby-comment"># change</span> + ] +] +</pre> + +<p>The <code>patch</code> method accepts <code>patchset</code>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.</p> + + <div class="method-source-code" id="patch-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 624</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">patch</span>(<span class="ruby-identifier">src</span>, <span class="ruby-identifier">patchset</span>, <span class="ruby-identifier">direction</span> = <span class="ruby-keyword">nil</span>) + <span class="ruby-comment"># Normalize the patchset.</span> + <span class="ruby-identifier">has_changes</span>, <span class="ruby-identifier">patchset</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">Internals</span>.<span class="ruby-identifier">analyze_patchset</span>(<span class="ruby-identifier">patchset</span>) + + <span class="ruby-keyword">return</span> <span class="ruby-identifier">src</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:dup</span>) <span class="ruby-operator">?</span> <span class="ruby-identifier">src</span>.<span class="ruby-identifier">dup</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">src</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">has_changes</span> + + <span class="ruby-identifier">string</span> = <span class="ruby-identifier">src</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">String</span>) + <span class="ruby-comment"># Start with a new empty type of the source's class</span> + <span class="ruby-identifier">res</span> = <span class="ruby-identifier">src</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span> + + <span class="ruby-identifier">direction</span> <span class="ruby-operator">||=</span> <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">Internals</span>.<span class="ruby-identifier">intuit_diff_direction</span>(<span class="ruby-identifier">src</span>, <span class="ruby-identifier">patchset</span>) + + <span class="ruby-identifier">ai</span> = <span class="ruby-identifier">bj</span> = <span class="ruby-value">0</span> + + <span class="ruby-identifier">patch_map</span> = <span class="ruby-constant">PATCH_MAP</span>[<span class="ruby-identifier">direction</span>] + + <span class="ruby-identifier">patchset</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">change</span><span class="ruby-operator">|</span> + <span class="ruby-comment"># Both Change and ContextChange support #action</span> + <span class="ruby-identifier">action</span> = <span class="ruby-identifier">patch_map</span>[<span class="ruby-identifier">change</span>.<span class="ruby-identifier">action</span>] + + <span class="ruby-keyword">case</span> <span class="ruby-identifier">change</span> + <span class="ruby-keyword">when</span> <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span> + <span class="ruby-keyword">case</span> <span class="ruby-identifier">direction</span> + <span class="ruby-keyword">when</span> <span class="ruby-value">:patch</span> + <span class="ruby-identifier">el</span> = <span class="ruby-identifier">change</span>.<span class="ruby-identifier">new_element</span> + <span class="ruby-identifier">op</span> = <span class="ruby-identifier">change</span>.<span class="ruby-identifier">old_position</span> + <span class="ruby-identifier">np</span> = <span class="ruby-identifier">change</span>.<span class="ruby-identifier">new_position</span> + <span class="ruby-keyword">when</span> <span class="ruby-value">:unpatch</span> + <span class="ruby-identifier">el</span> = <span class="ruby-identifier">change</span>.<span class="ruby-identifier">old_element</span> + <span class="ruby-identifier">op</span> = <span class="ruby-identifier">change</span>.<span class="ruby-identifier">new_position</span> + <span class="ruby-identifier">np</span> = <span class="ruby-identifier">change</span>.<span class="ruby-identifier">old_position</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-keyword">case</span> <span class="ruby-identifier">action</span> + <span class="ruby-keyword">when</span> <span class="ruby-string">'-'</span> <span class="ruby-comment"># Remove details from the old string</span> + <span class="ruby-keyword">while</span> <span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">op</span> + <span class="ruby-identifier">res</span> <span class="ruby-operator"><<</span> (<span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>]) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">when</span> <span class="ruby-string">'+'</span> + <span class="ruby-keyword">while</span> <span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">np</span> + <span class="ruby-identifier">res</span> <span class="ruby-operator"><<</span> (<span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>]) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-identifier">res</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">el</span> + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">when</span> <span class="ruby-string">'='</span> + <span class="ruby-comment"># This only appears in sdiff output with the SDiff callback.</span> + <span class="ruby-comment"># Therefore, we only need to worry about dealing with a single</span> + <span class="ruby-comment"># element.</span> + <span class="ruby-identifier">res</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">el</span> + + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">when</span> <span class="ruby-string">'!'</span> + <span class="ruby-keyword">while</span> <span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">op</span> + <span class="ruby-identifier">res</span> <span class="ruby-operator"><<</span> (<span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>]) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + + <span class="ruby-identifier">res</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">el</span> + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">when</span> <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">Change</span> + <span class="ruby-keyword">case</span> <span class="ruby-identifier">action</span> + <span class="ruby-keyword">when</span> <span class="ruby-string">'-'</span> + <span class="ruby-keyword">while</span> <span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">change</span>.<span class="ruby-identifier">position</span> + <span class="ruby-identifier">res</span> <span class="ruby-operator"><<</span> (<span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>]) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">when</span> <span class="ruby-string">'+'</span> + <span class="ruby-keyword">while</span> <span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">change</span>.<span class="ruby-identifier">position</span> + <span class="ruby-identifier">res</span> <span class="ruby-operator"><<</span> (<span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>]) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + + <span class="ruby-identifier">res</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">change</span>.<span class="ruby-identifier">element</span> + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-keyword">while</span> <span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">src</span>.<span class="ruby-identifier">size</span> + <span class="ruby-identifier">res</span> <span class="ruby-operator"><<</span> (<span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">src</span>[<span class="ruby-identifier">ai</span>]) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-identifier">res</span> +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-c-patch-21" class="method-detail "> + <div class="method-heading"> + <span class="method-name">patch!</span><span + class="method-args">(src, patchset)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Given a set of patchset, convert the current version to the next version. Does no auto-discovery.</p> + + <div class="method-source-code" id="patch-21-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 734</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">patch!</span>(<span class="ruby-identifier">src</span>, <span class="ruby-identifier">patchset</span>) + <span class="ruby-identifier">patch</span>(<span class="ruby-identifier">src</span>, <span class="ruby-identifier">patchset</span>, <span class="ruby-value">:patch</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-c-sdiff" class="method-detail "> + <div class="method-heading"> + <span class="method-name">sdiff</span><span + class="method-args">(seq1, seq2, callbacks = nil, &block)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p><a href="LCS.html#method-i-sdiff"><code>sdiff</code></a> computes all necessary components to show two sequences and their minimized differences side by side, just like the Unix utility <em>sdiff</em> does:</p> + +<pre>old < - +same same +before | after +- > new</pre> + +<p>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 <code>callbacks</code>, <a href="LCS.html#method-i-diff"><code>diff</code></a> will attempt to initialise it. If the <code>callbacks</code> object (possibly initialised) responds to finish, it will be called.</p> + +<p>Each element of a returned array is a Diff::LCS::ContextChange object, which can be implicitly converted to an array.</p> + +<pre class="ruby"><span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-identifier">sdiff</span>(<span class="ruby-identifier">a</span>, <span class="ruby-identifier">b</span>).<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">action</span>, (<span class="ruby-identifier">old_pos</span>, <span class="ruby-identifier">old_element</span>), (<span class="ruby-identifier">new_pos</span>, <span class="ruby-identifier">new_element</span>)<span class="ruby-operator">|</span> + <span class="ruby-keyword">case</span> <span class="ruby-identifier">action</span> + <span class="ruby-keyword">when</span> <span class="ruby-string">'!'</span> + <span class="ruby-comment"># replace</span> + <span class="ruby-keyword">when</span> <span class="ruby-string">'-'</span> + <span class="ruby-comment"># delete</span> + <span class="ruby-keyword">when</span> <span class="ruby-string">'+'</span> + <span class="ruby-comment"># insert</span> + <span class="ruby-keyword">end</span> +<span class="ruby-keyword">end</span> +</pre> + + <div class="method-source-code" id="sdiff-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 200</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">sdiff</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-identifier">callbacks</span> = <span class="ruby-keyword">nil</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) <span class="ruby-comment">#:yields diff changes:</span> + <span class="ruby-identifier">diff_traversal</span>(<span class="ruby-value">:sdiff</span>, <span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-identifier">callbacks</span> <span class="ruby-operator">||</span> <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">SDiffCallbacks</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-c-traverse_balanced" class="method-detail "> + <div class="method-heading"> + <span class="method-name">traverse_balanced</span><span + class="method-args">(seq1, seq2, callbacks = Diff::LCS::BalancedCallbacks) { |event| ... }</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p><a href="LCS.html#method-i-traverse_balanced"><code>traverse_balanced</code></a> is an alternative to <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a>. 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, <a href="LCS.html#method-i-traverse_balanced"><code>traverse_balanced</code></a> will report <em>changes</em> between the sequences.</p> + +<p>The arguments to <a href="LCS.html#method-i-traverse_balanced"><code>traverse_balanced</code></a> are the two sequences to traverse and a callback object, like this:</p> + +<pre class="ruby"><span class="ruby-identifier">traverse_balanced</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextDiffCallbacks</span>.<span class="ruby-identifier">new</span>) +</pre> + +<p><a href="LCS.html#method-i-sdiff"><code>sdiff</code></a> is implemented with <a href="LCS.html#method-i-traverse_balanced"><code>traverse_balanced</code></a>.</p> + +<h2 id="method-c-traverse_balanced-label-Callback+Methods">Callback Methods<span><a href="#method-c-traverse_balanced-label-Callback+Methods">¶</a> <a href="#top">↑</a></span></h2> + +<p>Optional callback methods are <em>emphasized</em>.</p> +<dl class="rdoc-list note-list"><dt>callbacks#match +<dd> +<p>Called when <code>a</code> and <code>b</code> are pointing to common elements in <code>A</code> and <code>B</code>.</p> +</dd><dt>callbacks#discard_a +<dd> +<p>Called when <code>a</code> is pointing to an element not in <code>B</code>.</p> +</dd><dt>callbacks#discard_b +<dd> +<p>Called when <code>b</code> is pointing to an element not in <code>A</code>.</p> +</dd><dt><em>callbacks#change</em> +<dd> +<p>Called when <code>a</code> and <code>b</code> are pointing to the same relative position, but <code>A[a]</code> and <code>B[b]</code> are not the same; a <em>change</em> has occurred.</p> +</dd></dl> + +<p><a href="LCS.html#method-i-traverse_balanced"><code>traverse_balanced</code></a> might be a bit slower than <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a>, noticable only while processing huge amounts of data.</p> + +<h2 id="method-c-traverse_balanced-label-Algorithm">Algorithm<span><a href="#method-c-traverse_balanced-label-Algorithm">¶</a> <a href="#top">↑</a></span></h2> + +<pre>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---+</pre> + +<h3 id="method-c-traverse_balanced-label-Matches">Matches<span><a href="#method-c-traverse_balanced-label-Matches">¶</a> <a href="#top">↑</a></span></h3> + +<p>If there are two arrows (<code>a</code> and <code>b</code>) pointing to elements of sequences <code>A</code> and <code>B</code>, the arrows will initially point to the first elements of their respective sequences. <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> 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 <code>A[i]</code> and <code>B[j]</code> which are both equal and part of the longest common subsequence, there will be some moment during the execution of <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> when arrow <code>a</code> is pointing to <code>A[i]</code> and arrow <code>b</code> is pointing to <code>B[j]</code>. When this happens, <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> will call <code>callbacks#match</code> and then it will advance both arrows.</p> + +<h3 id="method-c-traverse_balanced-label-Discards">Discards<span><a href="#method-c-traverse_balanced-label-Discards">¶</a> <a href="#top">↑</a></span></h3> + +<p>Otherwise, one of the arrows is pointing to an element of its sequence that is not part of the longest common subsequence. <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> will advance that arrow and will call <code>callbacks#discard_a</code> or <code>callbacks#discard_b</code>, depending on which arrow it advanced.</p> + +<h3 id="method-c-traverse_balanced-label-Changes">Changes<span><a href="#method-c-traverse_balanced-label-Changes">¶</a> <a href="#top">↑</a></span></h3> + +<p>If both <code>a</code> and <code>b</code> point to elements that are not part of the longest common subsequence, then <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> will try to call <code>callbacks#change</code> and advance both arrows. If <code>callbacks#change</code> is not implemented, then <code>callbacks#discard_a</code> and <code>callbacks#discard_b</code> will be called in turn.</p> + +<p>The methods for <code>callbacks#match</code>, <code>callbacks#discard_a</code>, <code>callbacks#discard_b</code>, and <code>callbacks#change</code> are invoked with an event comprising the action (“=”, “+”, “-”, or “!”, respectively), the indicies <code>i</code> and <code>j</code>, and the elements <code>A[i]</code> and <code>B[j]</code>. Return values are discarded by <a href="LCS.html#method-i-traverse_balanced"><code>traverse_balanced</code></a>.</p> + +<h3 id="method-c-traverse_balanced-label-Context">Context<span><a href="#method-c-traverse_balanced-label-Context">¶</a> <a href="#top">↑</a></span></h3> + +<p>Note that <code>i</code> and <code>j</code> may not be the same index position, even if <code>a</code> and <code>b</code> are considered to be pointing to matching or changed elements.</p> + + <div class="method-source-code" id="traverse_balanced-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 475</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">traverse_balanced</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-identifier">callbacks</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">BalancedCallbacks</span>) + <span class="ruby-identifier">matches</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">Internals</span>.<span class="ruby-identifier">lcs</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>) + <span class="ruby-identifier">a_size</span> = <span class="ruby-identifier">seq1</span>.<span class="ruby-identifier">size</span> + <span class="ruby-identifier">b_size</span> = <span class="ruby-identifier">seq2</span>.<span class="ruby-identifier">size</span> + <span class="ruby-identifier">ai</span> = <span class="ruby-identifier">bj</span> = <span class="ruby-identifier">mb</span> = <span class="ruby-value">0</span> + <span class="ruby-identifier">ma</span> = <span class="ruby-value">-1</span> + <span class="ruby-identifier">string</span> = <span class="ruby-identifier">seq1</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">String</span>) + + <span class="ruby-comment"># Process all the lines in the match vector.</span> + <span class="ruby-identifier">loop</span> <span class="ruby-keyword">do</span> + <span class="ruby-comment"># Find next match indices +ma+ and +mb+</span> + <span class="ruby-identifier">loop</span> <span class="ruby-keyword">do</span> + <span class="ruby-identifier">ma</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">break</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">ma</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">matches</span>.<span class="ruby-identifier">size</span> <span class="ruby-keyword">and</span> <span class="ruby-identifier">matches</span>[<span class="ruby-identifier">ma</span>].<span class="ruby-identifier">nil?</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-keyword">break</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">ma</span> <span class="ruby-operator">>=</span> <span class="ruby-identifier">matches</span>.<span class="ruby-identifier">size</span> <span class="ruby-comment"># end of matches?</span> + + <span class="ruby-identifier">mb</span> = <span class="ruby-identifier">matches</span>[<span class="ruby-identifier">ma</span>] + + <span class="ruby-comment"># Change(seq2)</span> + <span class="ruby-keyword">while</span> (<span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">ma</span>) <span class="ruby-keyword">or</span> (<span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">mb</span>) + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + + <span class="ruby-keyword">case</span> [(<span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">ma</span>), (<span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">mb</span>)] + <span class="ruby-keyword">when</span> [<span class="ruby-keyword">true</span>, <span class="ruby-keyword">true</span>] + <span class="ruby-keyword">if</span> <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:change</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'!'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">change</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">else</span> + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'-'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_a</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'+'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_b</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-keyword">end</span> + + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">when</span> [<span class="ruby-keyword">true</span>, <span class="ruby-keyword">false</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'-'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_a</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">when</span> [<span class="ruby-keyword">false</span>, <span class="ruby-keyword">true</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'+'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_b</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-comment"># Match</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'='</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">match</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-keyword">while</span> (<span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">a_size</span>) <span class="ruby-keyword">or</span> (<span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">b_size</span>) + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + + <span class="ruby-keyword">case</span> [(<span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">a_size</span>), (<span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">b_size</span>)] + <span class="ruby-keyword">when</span> [<span class="ruby-keyword">true</span>, <span class="ruby-keyword">true</span>] + <span class="ruby-keyword">if</span> <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:change</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'!'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">change</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">else</span> + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'-'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_a</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'+'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_b</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-keyword">end</span> + + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">when</span> [<span class="ruby-keyword">true</span>, <span class="ruby-keyword">false</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'-'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_a</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">when</span> [<span class="ruby-keyword">false</span>, <span class="ruby-keyword">true</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'+'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_b</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">end</span> +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-c-traverse_sequences" class="method-detail "> + <div class="method-heading"> + <span class="method-name">traverse_sequences</span><span + class="method-args">(seq1, seq2, callbacks = Diff::LCS::SequenceCallbacks) { |event| ... }</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p><a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> is the most general facility provided by this module; <a href="LCS.html#method-i-diff"><code>diff</code></a> and <a href="LCS.html#method-i-lcs"><code>lcs</code></a> are implemented as calls to it.</p> + +<p>The arguments to <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> are the two sequences to traverse, and a callback object, like this:</p> + +<pre class="ruby"><span class="ruby-identifier">traverse_sequences</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextDiffCallbacks</span>.<span class="ruby-identifier">new</span>) +</pre> + +<h2 id="method-c-traverse_sequences-label-Callback+Methods">Callback Methods<span><a href="#method-c-traverse_sequences-label-Callback+Methods">¶</a> <a href="#top">↑</a></span></h2> + +<p>Optional callback methods are <em>emphasized</em>.</p> +<dl class="rdoc-list note-list"><dt>callbacks#match +<dd> +<p>Called when <code>a</code> and <code>b</code> are pointing to common elements in <code>A</code> and <code>B</code>.</p> +</dd><dt>callbacks#discard_a +<dd> +<p>Called when <code>a</code> is pointing to an element not in <code>B</code>.</p> +</dd><dt>callbacks#discard_b +<dd> +<p>Called when <code>b</code> is pointing to an element not in <code>A</code>.</p> +</dd><dt><em>callbacks#finished_a</em> +<dd> +<p>Called when <code>a</code> has reached the end of sequence <code>A</code>.</p> +</dd><dt><em>callbacks#finished_b</em> +<dd> +<p>Called when <code>b</code> has reached the end of sequence <code>B</code>.</p> +</dd></dl> + +<h2 id="method-c-traverse_sequences-label-Algorithm">Algorithm<span><a href="#method-c-traverse_sequences-label-Algorithm">¶</a> <a href="#top">↑</a></span></h2> + +<pre>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---+</pre> + +<p>If there are two arrows (<code>a</code> and <code>b</code>) pointing to elements of sequences <code>A</code> and <code>B</code>, the arrows will initially point to the first elements of their respective sequences. <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> 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 <code>A[i]</code> and <code>B[j]</code> which are both equal and part of the longest common subsequence, there will be some moment during the execution of <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> when arrow <code>a</code> is pointing to <code>A[i]</code> and arrow <code>b</code> is pointing to <code>B[j]</code>. When this happens, <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> will call <code>callbacks#match</code> and then it will advance both arrows.</p> + +<p>Otherwise, one of the arrows is pointing to an element of its sequence that is not part of the longest common subsequence. <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> will advance that arrow and will call <code>callbacks#discard_a</code> or <code>callbacks#discard_b</code>, depending on which arrow it advanced. If both arrows point to elements that are not part of the longest common subsequence, then <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a> will advance arrow <code>a</code> and call the appropriate callback, then it will advance arrow <code>b</code> and call the appropriate callback.</p> + +<p>The methods for <code>callbacks#match</code>, <code>callbacks#discard_a</code>, and <code>callbacks#discard_b</code> are invoked with an event comprising the action (“=”, “+”, or “-”, respectively), the indicies <code>i</code> and <code>j</code>, and the elements <code>A[i]</code> and <code>B[j]</code>. Return values are discarded by <a href="LCS.html#method-i-traverse_sequences"><code>traverse_sequences</code></a>.</p> + +<h3 id="method-c-traverse_sequences-label-End+of+Sequences">End of Sequences<span><a href="#method-c-traverse_sequences-label-End+of+Sequences">¶</a> <a href="#top">↑</a></span></h3> + +<p>If arrow <code>a</code> reaches the end of its sequence before arrow <code>b</code> does, traverse_sequence will try to call <code>callbacks#finished_a</code> with the last index and element of <code>A</code> (<code>A[-1]</code>) and the current index and element of <code>B</code> (<code>B[j]</code>). If <code>callbacks#finished_a</code> does not exist, then <code>callbacks#discard_b</code> will be called on each element of <code>B</code> until the end of the sequence is reached (the call will be done with <code>A[-1]</code> and <code>B[j]</code> for each element).</p> + +<p>If <code>b</code> reaches the end of <code>B</code> before <code>a</code> reaches the end of <code>A</code>, <code>callbacks#finished_b</code> will be called with the current index and element of <code>A</code> (<code>A[i]</code>) and the last index and element of <code>B</code> (<code>A[-1]</code>). Again, if <code>callbacks#finished_b</code> does not exist on the callback object, then <code>callbacks#discard_a</code> will be called on each element of <code>A</code> until the end of the sequence is reached (<code>A[i]</code> and <code>B[-1]</code>).</p> + +<p>There is a chance that one additional <code>callbacks#discard_a</code> or <code>callbacks#discard_b</code> will be called after the end of the sequence is reached, if <code>a</code> has not yet reached the end of <code>A</code> or <code>b</code> has not yet reached the end of <code>B</code>.</p> + + <div class="method-source-code" id="traverse_sequences-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 285</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">traverse_sequences</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>, <span class="ruby-identifier">callbacks</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">SequenceCallbacks</span>) <span class="ruby-comment">#:yields change events:</span> + <span class="ruby-identifier">callbacks</span> <span class="ruby-operator">||=</span> <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">SequenceCallbacks</span> + <span class="ruby-identifier">matches</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">Internals</span>.<span class="ruby-identifier">lcs</span>(<span class="ruby-identifier">seq1</span>, <span class="ruby-identifier">seq2</span>) + + <span class="ruby-identifier">run_finished_a</span> = <span class="ruby-identifier">run_finished_b</span> = <span class="ruby-keyword">false</span> + <span class="ruby-identifier">string</span> = <span class="ruby-identifier">seq1</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">String</span>) + + <span class="ruby-identifier">a_size</span> = <span class="ruby-identifier">seq1</span>.<span class="ruby-identifier">size</span> + <span class="ruby-identifier">b_size</span> = <span class="ruby-identifier">seq2</span>.<span class="ruby-identifier">size</span> + <span class="ruby-identifier">ai</span> = <span class="ruby-identifier">bj</span> = <span class="ruby-value">0</span> + + <span class="ruby-identifier">matches</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">b_line</span><span class="ruby-operator">|</span> + <span class="ruby-keyword">if</span> <span class="ruby-identifier">b_line</span>.<span class="ruby-identifier">nil?</span> + <span class="ruby-keyword">unless</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>].<span class="ruby-identifier">nil?</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'-'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_a</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">else</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + + <span class="ruby-identifier">loop</span> <span class="ruby-keyword">do</span> + <span class="ruby-keyword">break</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">b_line</span> + + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'+'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_b</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'='</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">match</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-comment"># The last entry (if any) processed was a match. +ai+ and +bj+ point just</span> + <span class="ruby-comment"># past the last matching lines in their sequences.</span> + <span class="ruby-keyword">while</span> (<span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">a_size</span>) <span class="ruby-keyword">or</span> (<span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">b_size</span>) + <span class="ruby-comment"># last A?</span> + <span class="ruby-keyword">if</span> <span class="ruby-identifier">ai</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">a_size</span> <span class="ruby-keyword">and</span> <span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">b_size</span> + <span class="ruby-keyword">if</span> <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:finished_a</span>) <span class="ruby-keyword">and</span> <span class="ruby-operator">!</span><span class="ruby-identifier">run_finished_a</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-value">-1</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-value">-1</span>] + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'>'</span>, (<span class="ruby-identifier">a_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>), <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">finished_a</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">run_finished_a</span> = <span class="ruby-keyword">true</span> + <span class="ruby-keyword">else</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">loop</span> <span class="ruby-keyword">do</span> + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'+'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_b</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">break</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">b_size</span> + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-comment"># last B?</span> + <span class="ruby-keyword">if</span> <span class="ruby-identifier">bj</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">b_size</span> <span class="ruby-keyword">and</span> <span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">a_size</span> + <span class="ruby-keyword">if</span> <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-value">:finished_b</span>) <span class="ruby-keyword">and</span> <span class="ruby-operator">!</span><span class="ruby-identifier">run_finished_b</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-value">-1</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-value">-1</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'<'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, (<span class="ruby-identifier">b_size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>), <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">finished_b</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">run_finished_b</span> = <span class="ruby-keyword">true</span> + <span class="ruby-keyword">else</span> + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + <span class="ruby-identifier">loop</span> <span class="ruby-keyword">do</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'-'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_a</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">break</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">b_size</span> + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-keyword">if</span> <span class="ruby-identifier">ai</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">a_size</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'-'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_a</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">ai</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + + <span class="ruby-keyword">if</span> <span class="ruby-identifier">bj</span> <span class="ruby-operator"><</span> <span class="ruby-identifier">b_size</span> + <span class="ruby-identifier">ax</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq1</span>[<span class="ruby-identifier">ai</span>] + <span class="ruby-identifier">bx</span> = <span class="ruby-identifier">string</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>, <span class="ruby-value">1</span>] <span class="ruby-operator">:</span> <span class="ruby-identifier">seq2</span>[<span class="ruby-identifier">bj</span>] + <span class="ruby-identifier">event</span> = <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">ContextChange</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'+'</span>, <span class="ruby-identifier">ai</span>, <span class="ruby-identifier">ax</span>, <span class="ruby-identifier">bj</span>, <span class="ruby-identifier">bx</span>) + <span class="ruby-identifier">event</span> = <span class="ruby-keyword">yield</span> <span class="ruby-identifier">event</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">block_given?</span> + <span class="ruby-identifier">callbacks</span>.<span class="ruby-identifier">discard_b</span>(<span class="ruby-identifier">event</span>) + <span class="ruby-identifier">bj</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span> + <span class="ruby-keyword">end</span> + <span class="ruby-keyword">end</span> +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-c-unpatch-21" class="method-detail "> + <div class="method-heading"> + <span class="method-name">unpatch!</span><span + class="method-args">(src, patchset)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Given a set of patchset, convert the current version to the prior version. Does no auto-discovery.</p> + + <div class="method-source-code" id="unpatch-21-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 728</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">unpatch!</span>(<span class="ruby-identifier">src</span>, <span class="ruby-identifier">patchset</span>) + <span class="ruby-identifier">patch</span>(<span class="ruby-identifier">src</span>, <span class="ruby-identifier">patchset</span>, <span class="ruby-value">:unpatch</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + </section> + + <section id="public-instance-5Buntitled-5D-method-details" class="method-section"> + <header> + <h3>Public Instance Methods</h3> + </header> + + <div id="method-i-diff" class="method-detail "> + <div class="method-heading"> + <span class="method-name">diff</span><span + class="method-args">(other, callbacks = nil, &block)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Returns the difference set between <code>self</code> and <code>other</code>. See <a href="LCS.html#method-i-diff"><code>Diff::LCS#diff</code></a>.</p> + + <div class="method-source-code" id="diff-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 75</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">diff</span>(<span class="ruby-identifier">other</span>, <span class="ruby-identifier">callbacks</span> = <span class="ruby-keyword">nil</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) + <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-identifier">diff</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">other</span>, <span class="ruby-identifier">callbacks</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-i-lcs" class="method-detail "> + <div class="method-heading"> + <span class="method-name">lcs</span><span + class="method-args">(other, &block)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Returns an <a href="Array.html"><code>Array</code></a> containing the longest common subsequence(s) between <code>self</code> and <code>other</code>. See <a href="LCS.html#method-i-lcs"><code>Diff::LCS#lcs</code></a>.</p> + +<pre class="ruby"><span class="ruby-identifier">lcs</span> = <span class="ruby-identifier">seq1</span>.<span class="ruby-identifier">lcs</span>(<span class="ruby-identifier">seq2</span>) +</pre> + +<p>A note when using objects: <a href="LCS.html"><code>Diff::LCS</code></a> 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:</p> + +<pre class="ruby"><span class="ruby-constant">O</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'a'</span>).<span class="ruby-identifier">eql?</span>(<span class="ruby-constant">O</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'a'</span>)) <span class="ruby-operator">==</span> <span class="ruby-keyword">true</span> +</pre> + + <div class="method-source-code" id="lcs-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 70</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">lcs</span>(<span class="ruby-identifier">other</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) <span class="ruby-comment">#:yields self[i] if there are matched subsequences:</span> + <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-identifier">lcs</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">other</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-i-patch" class="method-detail "> + <div class="method-heading"> + <span class="method-name">patch</span><span + class="method-args">(patchset)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Attempts to patch <code>self</code> with the provided <code>patchset</code>. A new sequence based on <code>self</code> and the <code>patchset</code> will be created. See <a href="LCS.html#method-i-patch"><code>Diff::LCS#patch</code></a>. Attempts to autodiscover the direction of the patch.</p> + + <div class="method-source-code" id="patch-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 101</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">patch</span>(<span class="ruby-identifier">patchset</span>) + <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-identifier">patch</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">patchset</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + <div class="aliases"> + Also aliased as: <a href="LCS.html#method-i-unpatch">unpatch</a> + </div> + + </div> + + <div id="method-i-patch-21" class="method-detail "> + <div class="method-heading"> + <span class="method-name">patch!</span><span + class="method-args">(patchset)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Attempts to patch <code>self</code> with the provided <code>patchset</code>. A new sequence based on <code>self</code> and the <code>patchset</code> will be created. See <a href="LCS.html#method-i-patch"><code>Diff::LCS#patch</code></a>. Does no patch direction autodiscovery.</p> + + <div class="method-source-code" id="patch-21-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 109</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">patch!</span>(<span class="ruby-identifier">patchset</span>) + <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-identifier">patch!</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">patchset</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-i-patch_me" class="method-detail "> + <div class="method-heading"> + <span class="method-name">patch_me</span><span + class="method-args">(patchset)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Attempts to patch <code>self</code> with the provided <code>patchset</code>, using <a href="LCS.html#method-i-patch-21"><code>patch!</code></a>. If the sequence this is used on supports replace, the value of <code>self</code> will be replaced. See <a href="LCS.html#method-i-patch"><code>Diff::LCS#patch</code></a>. Does no patch direction autodiscovery.</p> + + <div class="method-source-code" id="patch_me-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 123</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">patch_me</span>(<span class="ruby-identifier">patchset</span>) + <span class="ruby-keyword">if</span> <span class="ruby-identifier">respond_to?</span> <span class="ruby-value">:replace</span> + <span class="ruby-identifier">replace</span>(<span class="ruby-identifier">patch!</span>(<span class="ruby-identifier">patchset</span>)) + <span class="ruby-keyword">else</span> + <span class="ruby-identifier">patch!</span>(<span class="ruby-identifier">patchset</span>) + <span class="ruby-keyword">end</span> +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-i-sdiff" class="method-detail "> + <div class="method-heading"> + <span class="method-name">sdiff</span><span + class="method-args">(other, callbacks = nil, &block)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Returns the balanced (“side-by-side”) difference set between <code>self</code> and <code>other</code>. See <a href="LCS.html#method-i-sdiff"><code>Diff::LCS#sdiff</code></a>.</p> + + <div class="method-source-code" id="sdiff-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 81</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">sdiff</span>(<span class="ruby-identifier">other</span>, <span class="ruby-identifier">callbacks</span> = <span class="ruby-keyword">nil</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) + <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-identifier">sdiff</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">other</span>, <span class="ruby-identifier">callbacks</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-i-traverse_balanced" class="method-detail "> + <div class="method-heading"> + <span class="method-name">traverse_balanced</span><span + class="method-args">(other, callbacks = nil, &block)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Traverses the discovered longest common subsequences between <code>self</code> and <code>other</code> using the alternate, balanced algorithm. See <a href="LCS.html#method-i-traverse_balanced"><code>Diff::LCS#traverse_balanced</code></a>.</p> + + <div class="method-source-code" id="traverse_balanced-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 94</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">traverse_balanced</span>(<span class="ruby-identifier">other</span>, <span class="ruby-identifier">callbacks</span> = <span class="ruby-keyword">nil</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) + <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-identifier">traverse_balanced</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">other</span>, <span class="ruby-identifier">callbacks</span> <span class="ruby-operator">||</span> <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">BalancedCallbacks</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-i-traverse_sequences" class="method-detail "> + <div class="method-heading"> + <span class="method-name">traverse_sequences</span><span + class="method-args">(other, callbacks = nil, &block)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Traverses the discovered longest common subsequences between <code>self</code> and <code>other</code>. See <a href="LCS.html#method-i-traverse_sequences"><code>Diff::LCS#traverse_sequences</code></a>.</p> + + <div class="method-source-code" id="traverse_sequences-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 87</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">traverse_sequences</span>(<span class="ruby-identifier">other</span>, <span class="ruby-identifier">callbacks</span> = <span class="ruby-keyword">nil</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) + <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-identifier">traverse_sequences</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">other</span>, <span class="ruby-identifier">callbacks</span> <span class="ruby-operator">||</span> <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span><span class="ruby-operator">::</span><span class="ruby-constant">SequenceCallbacks</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-i-unpatch" class="method-detail method-alias"> + <div class="method-heading"> + <span class="method-name">unpatch</span><span + class="method-args">(patchset)</span> + </div> + + <div class="method-description"> + + + </div> + + + <div class="aliases"> + Alias for: <a href="LCS.html#method-i-patch">patch</a> + </div> + </div> + + <div id="method-i-unpatch-21" class="method-detail "> + <div class="method-heading"> + <span class="method-name">unpatch!</span><span + class="method-args">(patchset)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Attempts to unpatch <code>self</code> with the provided <code>patchset</code>. A new sequence based on <code>self</code> and the <code>patchset</code> will be created. See <a href="LCS.html#method-i-unpatch"><code>Diff::LCS#unpatch</code></a>. Does no patch direction autodiscovery.</p> + + <div class="method-source-code" id="unpatch-21-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 116</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">unpatch!</span>(<span class="ruby-identifier">patchset</span>) + <span class="ruby-constant">Diff</span><span class="ruby-operator">::</span><span class="ruby-constant">LCS</span>.<span class="ruby-identifier">unpatch!</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">patchset</span>) +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + <div id="method-i-unpatch_me" class="method-detail "> + <div class="method-heading"> + <span class="method-name">unpatch_me</span><span + class="method-args">(patchset)</span> + <span class="method-click-advice">click to toggle source</span> + </div> + + <div class="method-description"> + <p>Attempts to unpatch <code>self</code> with the provided <code>patchset</code>, using <a href="LCS.html#method-i-unpatch-21"><code>unpatch!</code></a>. If the sequence this is used on supports replace, the value of <code>self</code> will be replaced. See <a href="LCS.html#method-i-unpatch"><code>Diff::LCS#unpatch</code></a>. Does no patch direction autodiscovery.</p> + + <div class="method-source-code" id="unpatch_me-source"> + <pre><span class="ruby-comment"># File lib/diff/lcs.rb, line 134</span> +<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">unpatch_me</span>(<span class="ruby-identifier">patchset</span>) + <span class="ruby-keyword">if</span> <span class="ruby-identifier">respond_to?</span> <span class="ruby-value">:replace</span> + <span class="ruby-identifier">replace</span>(<span class="ruby-identifier">unpatch!</span>(<span class="ruby-identifier">patchset</span>)) + <span class="ruby-keyword">else</span> + <span class="ruby-identifier">unpatch!</span>(<span class="ruby-identifier">patchset</span>) + <span class="ruby-keyword">end</span> +<span class="ruby-keyword">end</span></pre> + </div> + </div> + + + </div> + + </section> + + </section> +</main> + + +<footer id="validator-badges" role="contentinfo"> + <p><a href="https://validator.w3.org/check/referer">Validate</a> + <p>Generated by <a href="https://ruby.github.io/rdoc/">RDoc</a> 6.3.3. + <p>Based on <a href="http://deveiate.org/projects/Darkfish-RDoc/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>. +</footer> + |