diff-lcs 1.1.3 → 1.2.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,18 +1,4 @@
1
- #! /usr/env/bin ruby
2
- #--
3
- # Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
4
- # adapted from:
5
- # Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
6
- # Smalltalk by Mario I. Wolczko <mario@wolczko.com>
7
- # implements McIlroy-Hunt diff algorithm
8
- #
9
- # This program is free software. It may be redistributed and/or modified under
10
- # the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
11
- # Ruby licence.
12
- #
13
- # $Id$
14
- #++
15
- # Includes Diff::LCS into the Array built-in class.
1
+ # -*- ruby encoding: utf-8 -*-
16
2
 
17
3
  require 'diff/lcs'
18
4
 
@@ -1,22 +1,8 @@
1
- #! /usr/env/bin ruby
2
- #--
3
- # Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
4
- # adapted from:
5
- # Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
6
- # Smalltalk by Mario I. Wolczko <mario@wolczko.com>
7
- # implements McIlroy-Hunt diff algorithm
8
- #
9
- # This program is free software. It may be redistributed and/or modified under
10
- # the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
11
- # Ruby licence.
12
- #
13
- # $Id$
14
- #++
15
- # Contains Diff::LCS::Block for bin/ldiff.
1
+ # -*- ruby encoding: utf-8 -*-
16
2
 
17
- # A block is an operation removing, adding, or changing a group of items.
18
- # Basically, this is just a list of changes, where each change adds or
19
- # deletes a single item. Used by bin/ldiff.
3
+ # A block is an operation removing, adding, or changing a group of items.
4
+ # Basically, this is just a list of changes, where each change adds or
5
+ # deletes a single item. Used by bin/ldiff.
20
6
  class Diff::LCS::Block
21
7
  attr_reader :changes, :insert, :remove
22
8
 
@@ -1,44 +1,31 @@
1
- #! /usr/env/bin ruby
2
- #--
3
- # Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
4
- # adapted from:
5
- # Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
6
- # Smalltalk by Mario I. Wolczko <mario@wolczko.com>
7
- # implements McIlroy-Hunt diff algorithm
8
- #
9
- # This program is free software. It may be redistributed and/or modified under
10
- # the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
11
- # Ruby licence.
12
- #
13
- # $Id$
14
- #++
15
- # Contains definitions for all default callback objects.
1
+ # -*- ruby encoding: utf-8 -*-
16
2
 
17
3
  require 'diff/lcs/change'
18
4
 
19
5
  module Diff::LCS
20
- # This callback object implements the default set of callback events, which
21
- # only returns the event itself. Note that #finished_a and #finished_b are
22
- # not implemented -- I haven't yet figured out where they would be useful.
23
- #
24
- # Note that this is intended to be called as is, e.g.,
25
- #
26
- # Diff::LCS.LCS(seq1, seq2, Diff::LCS::DefaultCallbacks)
6
+ # This callback object implements the default set of callback events,
7
+ # which only returns the event itself. Note that #finished_a and
8
+ # #finished_b are not implemented -- I haven't yet figured out where they
9
+ # would be useful.
10
+ #
11
+ # Note that this is intended to be called as is, e.g.,
12
+ #
13
+ # Diff::LCS.LCS(seq1, seq2, Diff::LCS::DefaultCallbacks)
27
14
  class DefaultCallbacks
28
15
  class << self
29
- # Called when two items match.
16
+ # Called when two items match.
30
17
  def match(event)
31
18
  event
32
19
  end
33
- # Called when the old value is discarded in favour of the new value.
20
+ # Called when the old value is discarded in favour of the new value.
34
21
  def discard_a(event)
35
22
  event
36
23
  end
37
- # Called when the new value is discarded in favour of the old value.
24
+ # Called when the new value is discarded in favour of the old value.
38
25
  def discard_b(event)
39
26
  event
40
27
  end
41
- # Called when both the old and new values have changed.
28
+ # Called when both the old and new values have changed.
42
29
  def change(event)
43
30
  event
44
31
  end
@@ -47,65 +34,74 @@ module Diff::LCS
47
34
  end
48
35
  end
49
36
 
50
- # An alias for DefaultCallbacks that is used in Diff::LCS#traverse_sequences.
51
- #
52
- # Diff::LCS.LCS(seq1, seq2, Diff::LCS::SequenceCallbacks)
37
+ # An alias for DefaultCallbacks that is used in
38
+ # Diff::LCS#traverse_sequences.
39
+ #
40
+ # Diff::LCS.LCS(seq1, seq2, Diff::LCS::SequenceCallbacks)
53
41
  SequenceCallbacks = DefaultCallbacks
54
- # An alias for DefaultCallbacks that is used in Diff::LCS#traverse_balanced.
55
- #
56
- # Diff::LCS.LCS(seq1, seq2, Diff::LCS::BalancedCallbacks)
42
+
43
+ # An alias for DefaultCallbacks that is used in
44
+ # Diff::LCS#traverse_balanced.
45
+ #
46
+ # Diff::LCS.LCS(seq1, seq2, Diff::LCS::BalancedCallbacks)
57
47
  BalancedCallbacks = DefaultCallbacks
48
+
49
+ def self.callbacks_for(callbacks)
50
+ callbacks.new rescue callbacks
51
+ end
58
52
  end
59
53
 
60
- # This will produce a compound array of simple diff change objects. Each
61
- # element in the #diffs array is a +hunk+ or +hunk+ array, where each
62
- # element in each +hunk+ array is a single Change object representing the
63
- # addition or removal of a single element from one of the two tested
64
- # sequences. The +hunk+ provides the full context for the changes.
65
- #
66
- # diffs = Diff::LCS.diff(seq1, seq2)
67
- # # This example shows a simplified array format.
68
- # # [ [ [ '-', 0, 'a' ] ], # 1
69
- # # [ [ '+', 2, 'd' ] ], # 2
70
- # # [ [ '-', 4, 'h' ], # 3
71
- # # [ '+', 4, 'f' ] ],
72
- # # [ [ '+', 6, 'k' ] ], # 4
73
- # # [ [ '-', 8, 'n' ], # 5
74
- # # [ '-', 9, 'p' ],
75
- # # [ '+', 9, 'r' ],
76
- # # [ '+', 10, 's' ],
77
- # # [ '+', 11, 't' ] ] ]
78
- #
79
- # There are five hunks here. The first hunk says that the +a+ at position 0
80
- # of the first sequence should be deleted (<tt>'-'</tt>). The second hunk
81
- # says that the +d+ at position 2 of the second sequence should be inserted
82
- # (<tt>'+'</tt>). The third hunk says that the +h+ at position 4 of the
83
- # first sequence should be removed and replaced with the +f+ from position 4
84
- # of the second sequence. The other two hunks are described similarly.
85
- #
86
- # === Use
87
- # This callback object must be initialised and is used by the Diff::LCS#diff
88
- # method.
89
- #
90
- # cbo = Diff::LCS::DiffCallbacks.new
91
- # Diff::LCS.LCS(seq1, seq2, cbo)
92
- # cbo.finish
93
- #
94
- # Note that the call to #finish is absolutely necessary, or the last set of
95
- # changes will not be visible. Alternatively, can be used as:
96
- #
97
- # cbo = Diff::LCS::DiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
98
- #
99
- # The necessary #finish call will be made.
100
- #
101
- # === Simplified Array Format
102
- # The simplified array format used in the example above can be obtained
103
- # with:
104
- #
105
- # require 'pp'
106
- # pp diffs.map { |e| e.map { |f| f.to_a } }
54
+ # This will produce a compound array of simple diff change objects. Each
55
+ # element in the #diffs array is a +hunk+ or +hunk+ array, where each
56
+ # element in each +hunk+ array is a single Change object representing the
57
+ # addition or removal of a single element from one of the two tested
58
+ # sequences. The +hunk+ provides the full context for the changes.
59
+ #
60
+ # diffs = Diff::LCS.diff(seq1, seq2)
61
+ # # This example shows a simplified array format.
62
+ # # [ [ [ '-', 0, 'a' ] ], # 1
63
+ # # [ [ '+', 2, 'd' ] ], # 2
64
+ # # [ [ '-', 4, 'h' ], # 3
65
+ # # [ '+', 4, 'f' ] ],
66
+ # # [ [ '+', 6, 'k' ] ], # 4
67
+ # # [ [ '-', 8, 'n' ], # 5
68
+ # # [ '-', 9, 'p' ],
69
+ # # [ '+', 9, 'r' ],
70
+ # # [ '+', 10, 's' ],
71
+ # # [ '+', 11, 't' ] ] ]
72
+ #
73
+ # There are five hunks here. The first hunk says that the +a+ at position 0
74
+ # of the first sequence should be deleted (<tt>'-'</tt>). The second hunk
75
+ # says that the +d+ at position 2 of the second sequence should be inserted
76
+ # (<tt>'+'</tt>). The third hunk says that the +h+ at position 4 of the
77
+ # first sequence should be removed and replaced with the +f+ from position 4
78
+ # of the second sequence. The other two hunks are described similarly.
79
+ #
80
+ # === Use
81
+ #
82
+ # This callback object must be initialised and is used by the Diff::LCS#diff
83
+ # method.
84
+ #
85
+ # cbo = Diff::LCS::DiffCallbacks.new
86
+ # Diff::LCS.LCS(seq1, seq2, cbo)
87
+ # cbo.finish
88
+ #
89
+ # Note that the call to #finish is absolutely necessary, or the last set of
90
+ # changes will not be visible. Alternatively, can be used as:
91
+ #
92
+ # cbo = Diff::LCS::DiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
93
+ #
94
+ # The necessary #finish call will be made.
95
+ #
96
+ # === Simplified Array Format
97
+ #
98
+ # The simplified array format used in the example above can be obtained
99
+ # with:
100
+ #
101
+ # require 'pp'
102
+ # pp diffs.map { |e| e.map { |f| f.to_a } }
107
103
  class Diff::LCS::DiffCallbacks
108
- # Returns the difference set collected during the diff process.
104
+ # Returns the difference set collected during the diff process.
109
105
  attr_reader :diffs
110
106
 
111
107
  def initialize # :yields self:
@@ -121,14 +117,14 @@ class Diff::LCS::DiffCallbacks
121
117
  end
122
118
  end
123
119
 
124
- # Finalizes the diff process. If an unprocessed hunk still exists, then it
125
- # is appended to the diff list.
120
+ # Finalizes the diff process. If an unprocessed hunk still exists, then it
121
+ # is appended to the diff list.
126
122
  def finish
127
- add_nonempty_hunk
123
+ finish_hunk
128
124
  end
129
125
 
130
126
  def match(event)
131
- add_nonempty_hunk
127
+ finish_hunk
132
128
  end
133
129
 
134
130
  def discard_a(event)
@@ -139,86 +135,88 @@ class Diff::LCS::DiffCallbacks
139
135
  @hunk << Diff::LCS::Change.new('+', event.new_position, event.new_element)
140
136
  end
141
137
 
142
- private
143
- def add_nonempty_hunk
138
+ def finish_hunk
144
139
  @diffs << @hunk unless @hunk.empty?
145
140
  @hunk = []
146
141
  end
142
+ private :finish_hunk
147
143
  end
148
144
 
149
- # This will produce a compound array of contextual diff change objects. Each
150
- # element in the #diffs array is a "hunk" array, where each element in each
151
- # "hunk" array is a single change. Each change is a Diff::LCS::ContextChange
152
- # that contains both the old index and new index values for the change. The
153
- # "hunk" provides the full context for the changes. Both old and new objects
154
- # will be presented for changed objects. +nil+ will be substituted for a
155
- # discarded object.
156
- #
157
- # seq1 = %w(a b c e h j l m n p)
158
- # seq2 = %w(b c d e f j k l m r s t)
159
- #
160
- # diffs = Diff::LCS.diff(seq1, seq2, Diff::LCS::ContextDiffCallbacks)
161
- # # This example shows a simplified array format.
162
- # # [ [ [ '-', [ 0, 'a' ], [ 0, nil ] ] ], # 1
163
- # # [ [ '+', [ 3, nil ], [ 2, 'd' ] ] ], # 2
164
- # # [ [ '-', [ 4, 'h' ], [ 4, nil ] ], # 3
165
- # # [ '+', [ 5, nil ], [ 4, 'f' ] ] ],
166
- # # [ [ '+', [ 6, nil ], [ 6, 'k' ] ] ], # 4
167
- # # [ [ '-', [ 8, 'n' ], [ 9, nil ] ], # 5
168
- # # [ '+', [ 9, nil ], [ 9, 'r' ] ],
169
- # # [ '-', [ 9, 'p' ], [ 10, nil ] ],
170
- # # [ '+', [ 10, nil ], [ 10, 's' ] ],
171
- # # [ '+', [ 10, nil ], [ 11, 't' ] ] ] ]
172
- #
173
- # The five hunks shown are comprised of individual changes; if there is a
174
- # related set of changes, they are still shown individually.
175
- #
176
- # This callback can also be used with Diff::LCS#sdiff, which will produce
177
- # results like:
178
- #
179
- # diffs = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextCallbacks)
180
- # # This example shows a simplified array format.
181
- # # [ [ [ "-", [ 0, "a" ], [ 0, nil ] ] ], # 1
182
- # # [ [ "+", [ 3, nil ], [ 2, "d" ] ] ], # 2
183
- # # [ [ "!", [ 4, "h" ], [ 4, "f" ] ] ], # 3
184
- # # [ [ "+", [ 6, nil ], [ 6, "k" ] ] ], # 4
185
- # # [ [ "!", [ 8, "n" ], [ 9, "r" ] ], # 5
186
- # # [ "!", [ 9, "p" ], [ 10, "s" ] ],
187
- # # [ "+", [ 10, nil ], [ 11, "t" ] ] ] ]
188
- #
189
- # The five hunks are still present, but are significantly shorter in total
190
- # presentation, because changed items are shown as changes ("!") instead of
191
- # potentially "mismatched" pairs of additions and deletions.
192
- #
193
- # The result of this operation is similar to that of
194
- # Diff::LCS::SDiffCallbacks. They may be compared as:
195
- #
196
- # s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" }
197
- # c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten
198
- #
199
- # s == c # -> true
200
- #
201
- # === Use
202
- # This callback object must be initialised and can be used by the
203
- # Diff::LCS#diff or Diff::LCS#sdiff methods.
204
- #
205
- # cbo = Diff::LCS::ContextDiffCallbacks.new
206
- # Diff::LCS.LCS(seq1, seq2, cbo)
207
- # cbo.finish
208
- #
209
- # Note that the call to #finish is absolutely necessary, or the last set of
210
- # changes will not be visible. Alternatively, can be used as:
211
- #
212
- # cbo = Diff::LCS::ContextDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
213
- #
214
- # The necessary #finish call will be made.
215
- #
216
- # === Simplified Array Format
217
- # The simplified array format used in the example above can be obtained
218
- # with:
219
- #
220
- # require 'pp'
221
- # pp diffs.map { |e| e.map { |f| f.to_a } }
145
+ # This will produce a compound array of contextual diff change objects. Each
146
+ # element in the #diffs array is a "hunk" array, where each element in each
147
+ # "hunk" array is a single change. Each change is a Diff::LCS::ContextChange
148
+ # that contains both the old index and new index values for the change. The
149
+ # "hunk" provides the full context for the changes. Both old and new objects
150
+ # will be presented for changed objects. +nil+ will be substituted for a
151
+ # discarded object.
152
+ #
153
+ # seq1 = %w(a b c e h j l m n p)
154
+ # seq2 = %w(b c d e f j k l m r s t)
155
+ #
156
+ # diffs = Diff::LCS.diff(seq1, seq2, Diff::LCS::ContextDiffCallbacks)
157
+ # # This example shows a simplified array format.
158
+ # # [ [ [ '-', [ 0, 'a' ], [ 0, nil ] ] ], # 1
159
+ # # [ [ '+', [ 3, nil ], [ 2, 'd' ] ] ], # 2
160
+ # # [ [ '-', [ 4, 'h' ], [ 4, nil ] ], # 3
161
+ # # [ '+', [ 5, nil ], [ 4, 'f' ] ] ],
162
+ # # [ [ '+', [ 6, nil ], [ 6, 'k' ] ] ], # 4
163
+ # # [ [ '-', [ 8, 'n' ], [ 9, nil ] ], # 5
164
+ # # [ '+', [ 9, nil ], [ 9, 'r' ] ],
165
+ # # [ '-', [ 9, 'p' ], [ 10, nil ] ],
166
+ # # [ '+', [ 10, nil ], [ 10, 's' ] ],
167
+ # # [ '+', [ 10, nil ], [ 11, 't' ] ] ] ]
168
+ #
169
+ # The five hunks shown are comprised of individual changes; if there is a
170
+ # related set of changes, they are still shown individually.
171
+ #
172
+ # This callback can also be used with Diff::LCS#sdiff, which will produce
173
+ # results like:
174
+ #
175
+ # diffs = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextCallbacks)
176
+ # # This example shows a simplified array format.
177
+ # # [ [ [ "-", [ 0, "a" ], [ 0, nil ] ] ], # 1
178
+ # # [ [ "+", [ 3, nil ], [ 2, "d" ] ] ], # 2
179
+ # # [ [ "!", [ 4, "h" ], [ 4, "f" ] ] ], # 3
180
+ # # [ [ "+", [ 6, nil ], [ 6, "k" ] ] ], # 4
181
+ # # [ [ "!", [ 8, "n" ], [ 9, "r" ] ], # 5
182
+ # # [ "!", [ 9, "p" ], [ 10, "s" ] ],
183
+ # # [ "+", [ 10, nil ], [ 11, "t" ] ] ] ]
184
+ #
185
+ # The five hunks are still present, but are significantly shorter in total
186
+ # presentation, because changed items are shown as changes ("!") instead of
187
+ # potentially "mismatched" pairs of additions and deletions.
188
+ #
189
+ # The result of this operation is similar to that of
190
+ # Diff::LCS::SDiffCallbacks. They may be compared as:
191
+ #
192
+ # s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" }
193
+ # c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten
194
+ #
195
+ # s == c # -> true
196
+ #
197
+ # === Use
198
+ #
199
+ # This callback object must be initialised and can be used by the
200
+ # Diff::LCS#diff or Diff::LCS#sdiff methods.
201
+ #
202
+ # cbo = Diff::LCS::ContextDiffCallbacks.new
203
+ # Diff::LCS.LCS(seq1, seq2, cbo)
204
+ # cbo.finish
205
+ #
206
+ # Note that the call to #finish is absolutely necessary, or the last set of
207
+ # changes will not be visible. Alternatively, can be used as:
208
+ #
209
+ # cbo = Diff::LCS::ContextDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
210
+ #
211
+ # The necessary #finish call will be made.
212
+ #
213
+ # === Simplified Array Format
214
+ #
215
+ # The simplified array format used in the example above can be obtained
216
+ # with:
217
+ #
218
+ # require 'pp'
219
+ # pp diffs.map { |e| e.map { |f| f.to_a } }
222
220
  class Diff::LCS::ContextDiffCallbacks < Diff::LCS::DiffCallbacks
223
221
  def discard_a(event)
224
222
  @hunk << Diff::LCS::ContextChange.simplify(event)
@@ -233,70 +231,72 @@ class Diff::LCS::ContextDiffCallbacks < Diff::LCS::DiffCallbacks
233
231
  end
234
232
  end
235
233
 
236
- # This will produce a simple array of diff change objects. Each element in
237
- # the #diffs array is a single ContextChange. In the set of #diffs provided
238
- # by SDiffCallbacks, both old and new objects will be presented for both
239
- # changed <strong>and unchanged</strong> objects. +nil+ will be substituted
240
- # for a discarded object.
241
- #
242
- # The diffset produced by this callback, when provided to Diff::LCS#sdiff,
243
- # will compute and display the necessary components to show two sequences
244
- # and their minimized differences side by side, just like the Unix utility
245
- # +sdiff+.
246
- #
247
- # same same
248
- # before | after
249
- # old < -
250
- # - > new
251
- #
252
- # seq1 = %w(a b c e h j l m n p)
253
- # seq2 = %w(b c d e f j k l m r s t)
254
- #
255
- # diffs = Diff::LCS.sdiff(seq1, seq2)
256
- # # This example shows a simplified array format.
257
- # # [ [ "-", [ 0, "a"], [ 0, nil ] ],
258
- # # [ "=", [ 1, "b"], [ 0, "b" ] ],
259
- # # [ "=", [ 2, "c"], [ 1, "c" ] ],
260
- # # [ "+", [ 3, nil], [ 2, "d" ] ],
261
- # # [ "=", [ 3, "e"], [ 3, "e" ] ],
262
- # # [ "!", [ 4, "h"], [ 4, "f" ] ],
263
- # # [ "=", [ 5, "j"], [ 5, "j" ] ],
264
- # # [ "+", [ 6, nil], [ 6, "k" ] ],
265
- # # [ "=", [ 6, "l"], [ 7, "l" ] ],
266
- # # [ "=", [ 7, "m"], [ 8, "m" ] ],
267
- # # [ "!", [ 8, "n"], [ 9, "r" ] ],
268
- # # [ "!", [ 9, "p"], [ 10, "s" ] ],
269
- # # [ "+", [ 10, nil], [ 11, "t" ] ] ]
270
- #
271
- # The result of this operation is similar to that of
272
- # Diff::LCS::ContextDiffCallbacks. They may be compared as:
273
- #
274
- # s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" }
275
- # c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten
276
- #
277
- # s == c # -> true
278
- #
279
- # === Use
280
- # This callback object must be initialised and is used by the Diff::LCS#sdiff
281
- # method.
282
- #
283
- # cbo = Diff::LCS::SDiffCallbacks.new
284
- # Diff::LCS.LCS(seq1, seq2, cbo)
285
- #
286
- # As with the other initialisable callback objects, Diff::LCS::SDiffCallbacks
287
- # can be initialised with a block. As there is no "fininishing" to be done,
288
- # this has no effect on the state of the object.
289
- #
290
- # cbo = Diff::LCS::SDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
291
- #
292
- # === Simplified Array Format
293
- # The simplified array format used in the example above can be obtained
294
- # with:
295
- #
296
- # require 'pp'
297
- # pp diffs.map { |e| e.to_a }
234
+ # This will produce a simple array of diff change objects. Each element in
235
+ # the #diffs array is a single ContextChange. In the set of #diffs provided
236
+ # by SDiffCallbacks, both old and new objects will be presented for both
237
+ # changed <strong>and unchanged</strong> objects. +nil+ will be substituted
238
+ # for a discarded object.
239
+ #
240
+ # The diffset produced by this callback, when provided to Diff::LCS#sdiff,
241
+ # will compute and display the necessary components to show two sequences
242
+ # and their minimized differences side by side, just like the Unix utility
243
+ # +sdiff+.
244
+ #
245
+ # same same
246
+ # before | after
247
+ # old < -
248
+ # - > new
249
+ #
250
+ # seq1 = %w(a b c e h j l m n p)
251
+ # seq2 = %w(b c d e f j k l m r s t)
252
+ #
253
+ # diffs = Diff::LCS.sdiff(seq1, seq2)
254
+ # # This example shows a simplified array format.
255
+ # # [ [ "-", [ 0, "a"], [ 0, nil ] ],
256
+ # # [ "=", [ 1, "b"], [ 0, "b" ] ],
257
+ # # [ "=", [ 2, "c"], [ 1, "c" ] ],
258
+ # # [ "+", [ 3, nil], [ 2, "d" ] ],
259
+ # # [ "=", [ 3, "e"], [ 3, "e" ] ],
260
+ # # [ "!", [ 4, "h"], [ 4, "f" ] ],
261
+ # # [ "=", [ 5, "j"], [ 5, "j" ] ],
262
+ # # [ "+", [ 6, nil], [ 6, "k" ] ],
263
+ # # [ "=", [ 6, "l"], [ 7, "l" ] ],
264
+ # # [ "=", [ 7, "m"], [ 8, "m" ] ],
265
+ # # [ "!", [ 8, "n"], [ 9, "r" ] ],
266
+ # # [ "!", [ 9, "p"], [ 10, "s" ] ],
267
+ # # [ "+", [ 10, nil], [ 11, "t" ] ] ]
268
+ #
269
+ # The result of this operation is similar to that of
270
+ # Diff::LCS::ContextDiffCallbacks. They may be compared as:
271
+ #
272
+ # s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" }
273
+ # c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten
274
+ #
275
+ # s == c # -> true
276
+ #
277
+ # === Use
278
+ #
279
+ # This callback object must be initialised and is used by the Diff::LCS#sdiff
280
+ # method.
281
+ #
282
+ # cbo = Diff::LCS::SDiffCallbacks.new
283
+ # Diff::LCS.LCS(seq1, seq2, cbo)
284
+ #
285
+ # As with the other initialisable callback objects,
286
+ # Diff::LCS::SDiffCallbacks can be initialised with a block. As there is no
287
+ # "fininishing" to be done, this has no effect on the state of the object.
288
+ #
289
+ # cbo = Diff::LCS::SDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
290
+ #
291
+ # === Simplified Array Format
292
+ #
293
+ # The simplified array format used in the example above can be obtained
294
+ # with:
295
+ #
296
+ # require 'pp'
297
+ # pp diffs.map { |e| e.to_a }
298
298
  class Diff::LCS::SDiffCallbacks
299
- # Returns the difference set collected during the diff process.
299
+ # Returns the difference set collected during the diff process.
300
300
  attr_reader :diffs
301
301
 
302
302
  def initialize #:yields self: