Class: Diff::LCS::ContextDiffCallbacks

Inherits:
DiffCallbacks show all
Defined in:
lib/diff/lcs/callbacks.rb

Overview

This will produce a compound array of contextual diff change objects. Each element in the #diffs array is a “hunk” array, where each element in each “hunk” array is a single change. Each change is a Diff::LCS::ContextChange that contains both the old index and new index values for the change. The “hunk” provides the full context for the changes. Both old and new objects will be presented for changed objects. nil will be substituted for a discarded object.

“‘ruby seq1 = %w(a b c e h j l m n p) seq2 = %w(b c d e f j k l m r s t)

diffs = Diff::LCS.diff(seq1, seq2, Diff::LCS::ContextDiffCallbacks) # This example shows a simplified array format. # [ [ [ ‘-’, [ 0, ‘a’ ], [ 0, nil ] ] ], # 1 # [ [ ‘+’, [ 3, nil ], [ 2, ‘d’ ] ] ], # 2 # [ [ ‘-’, [ 4, ‘h’ ], [ 4, nil ] ], # 3 # [ ‘+’, [ 5, nil ], [ 4, ‘f’ ] ] ], # [ [ ‘+’, [ 6, nil ], [ 6, ‘k’ ] ] ], # 4 # [ [ ‘-’, [ 8, ‘n’ ], [ 9, nil ] ], # 5 # [ ‘+’, [ 9, nil ], [ 9, ‘r’ ] ], # [ ‘-’, [ 9, ‘p’ ], [ 10, nil ] ], # [ ‘+’, [ 10, nil ], [ 10, ‘s’ ] ], # [ ‘+’, [ 10, nil ], [ 11, ‘t’ ] ] ] ] “‘

The five hunks shown are comprised of individual changes; if there is a related set of changes, they are still shown individually.

This callback can also be used with Diff::LCS#sdiff, which will produce results like:

“‘ruby diffs = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextCallbacks) # This example shows a simplified array format. # [ [ [ “-”, [ 0, “a” ], [ 0, nil ] ] ], # 1 # [ [ “+”, [ 3, nil ], [ 2, “d” ] ] ], # 2 # [ [ “!”, [ 4, “h” ], [ 4, “f” ] ] ], # 3 # [ [ “+”, [ 6, nil ], [ 6, “k” ] ] ], # 4 # [ [ “!”, [ 8, “n” ], [ 9, “r” ] ], # 5 # [ “!”, [ 9, “p” ], [ 10, “s” ] ], # [ “+”, [ 10, nil ], [ 11, “t” ] ] ] ] “`

The five hunks are still present, but are significantly shorter in total presentation, because changed items are shown as changes (“!”) instead of potentially “mismatched” pairs of additions and deletions.

The result of this operation is similar to that of Diff::LCS::SDiffCallbacks. They may be compared as:

“‘ruby s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == “=” } c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten(1)

s == c # => true “‘

### Use

This callback object must be initialised and can be used by the Diff::LCS#diff or Diff::LCS#sdiff methods.

“‘ruby cbo = Diff::LCS::ContextDiffCallbacks.new Diff::LCS.lcs(seq1, seq2, cbo) cbo.finish “`

Note that the call to #finish is absolutely necessary, or the last set of changes will not be visible. This callback also supports a block mode which automatically calls #finish.

“‘ruby result = Diff::LCS::ContextDiffCallbacks.new { |cbo| Diff::LCS.lcs(seq1, seq2, cbo) } “`

### Simplified Array Format

The simplified array format used in the example above can be obtained with:

“‘ruby require ’pp’ pp diffs.map { |e| e.map { |f| f.to_a } } “‘

Instance Attribute Summary

Attributes inherited from DiffCallbacks

#diffs

Instance Method Summary collapse

Methods inherited from DiffCallbacks

#finish, #initialize, #match

Constructor Details

This class inherits a constructor from Diff::LCS::DiffCallbacks

Instance Method Details

#change(event) ⇒ Object 



227
228
229
 
# File 'lib/diff/lcs/callbacks.rb', line 227

def change(event)
  @hunk << Diff::LCS::ContextChange.simplify(event)
end

#discard_a(event) ⇒ Object 



219
220
221
 
# File 'lib/diff/lcs/callbacks.rb', line 219

def discard_a(event)
  @hunk << Diff::LCS::ContextChange.simplify(event)
end

#discard_b(event) ⇒ Object 



223
224
225
 
# File 'lib/diff/lcs/callbacks.rb', line 223

def discard_b(event)
  @hunk << Diff::LCS::ContextChange.simplify(event)
end