diff-lcs 1.3 → 1.4.2

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,214 +1,214 @@
1
- # -*- ruby encoding: utf-8 -*-
1
+ # frozen_string_literal: true
2
2
 
3
3
  require 'spec_helper'
4
4
 
5
- describe "Diff::LCS.sdiff" do
5
+ describe 'Diff::LCS.sdiff' do
6
6
  include Diff::LCS::SpecHelper::Matchers
7
7
 
8
- shared_examples "compare sequences correctly" do
9
- it "compares s1 -> s2 correctly" do
8
+ shared_examples 'compare sequences correctly' do
9
+ it 'compares s1 -> s2 correctly' do
10
10
  expect(Diff::LCS.sdiff(s1, s2)).to eq(context_diff(result))
11
11
  end
12
12
 
13
- it "compares s2 -> s1 correctly" do
13
+ it 'compares s2 -> s1 correctly' do
14
14
  expect(Diff::LCS.sdiff(s2, s1)).to eq(context_diff(reverse_sdiff(result)))
15
15
  end
16
16
  end
17
17
 
18
- describe "using seq1 & seq2" do
18
+ describe 'using seq1 & seq2' do
19
19
  let(:s1) { seq1 }
20
20
  let(:s2) { seq2 }
21
21
  let(:result) { correct_forward_sdiff }
22
22
 
23
- it_has_behavior "compare sequences correctly"
23
+ it_has_behavior 'compare sequences correctly'
24
24
  end
25
25
 
26
- describe "using %w(abc def yyy xxx ghi jkl) & %w(abc dxf xxx ghi jkl)" do
26
+ describe 'using %w(abc def yyy xxx ghi jkl) & %w(abc dxf xxx ghi jkl)' do
27
27
  let(:s1) { %w(abc def yyy xxx ghi jkl) }
28
28
  let(:s2) { %w(abc dxf xxx ghi jkl) }
29
29
  let(:result) {
30
30
  [
31
- [ '=', [ 0, 'abc' ], [ 0, 'abc' ] ],
32
- [ '!', [ 1, 'def' ], [ 1, 'dxf' ] ],
33
- [ '-', [ 2, 'yyy' ], [ 2, nil ] ],
34
- [ '=', [ 3, 'xxx' ], [ 2, 'xxx' ] ],
35
- [ '=', [ 4, 'ghi' ], [ 3, 'ghi' ] ],
36
- [ '=', [ 5, 'jkl' ], [ 4, 'jkl' ] ]
31
+ ['=', [0, 'abc'], [0, 'abc']],
32
+ ['!', [1, 'def'], [1, 'dxf']],
33
+ ['-', [2, 'yyy'], [2, nil]],
34
+ ['=', [3, 'xxx'], [2, 'xxx']],
35
+ ['=', [4, 'ghi'], [3, 'ghi']],
36
+ ['=', [5, 'jkl'], [4, 'jkl']]
37
37
  ]
38
38
  }
39
39
 
40
- it_has_behavior "compare sequences correctly"
40
+ it_has_behavior 'compare sequences correctly'
41
41
  end
42
42
 
43
- describe "using %w(a b c d e) & %w(a e)" do
43
+ describe 'using %w(a b c d e) & %w(a e)' do
44
44
  let(:s1) { %w(a b c d e) }
45
45
  let(:s2) { %w(a e) }
46
46
  let(:result) {
47
47
  [
48
- [ '=', [ 0, 'a' ], [ 0, 'a' ] ],
49
- [ '-', [ 1, 'b' ], [ 1, nil ] ],
50
- [ '-', [ 2, 'c' ], [ 1, nil ] ],
51
- [ '-', [ 3, 'd' ], [ 1, nil ] ],
52
- [ '=', [ 4, 'e' ], [ 1, 'e' ] ]
48
+ ['=', [0, 'a'], [0, 'a']],
49
+ ['-', [1, 'b'], [1, nil]],
50
+ ['-', [2, 'c'], [1, nil]],
51
+ ['-', [3, 'd'], [1, nil]],
52
+ ['=', [4, 'e'], [1, 'e']]
53
53
  ]
54
54
  }
55
55
 
56
- it_has_behavior "compare sequences correctly"
56
+ it_has_behavior 'compare sequences correctly'
57
57
  end
58
58
 
59
- describe "using %w(a e) & %w(a b c d e)" do
59
+ describe 'using %w(a e) & %w(a b c d e)' do
60
60
  let(:s1) { %w(a e) }
61
61
  let(:s2) { %w(a b c d e) }
62
62
  let(:result) {
63
63
  [
64
- [ '=', [ 0, 'a' ], [ 0, 'a' ] ],
65
- [ '+', [ 1, nil ], [ 1, 'b' ] ],
66
- [ '+', [ 1, nil ], [ 2, 'c' ] ],
67
- [ '+', [ 1, nil ], [ 3, 'd' ] ],
68
- [ '=', [ 1, 'e' ], [ 4, 'e' ] ]
64
+ ['=', [0, 'a'], [0, 'a']],
65
+ ['+', [1, nil], [1, 'b']],
66
+ ['+', [1, nil], [2, 'c']],
67
+ ['+', [1, nil], [3, 'd']],
68
+ ['=', [1, 'e'], [4, 'e']]
69
69
  ]
70
70
  }
71
71
 
72
- it_has_behavior "compare sequences correctly"
72
+ it_has_behavior 'compare sequences correctly'
73
73
  end
74
74
 
75
- describe "using %w(v x a e) & %w(w y a b c d e)" do
75
+ describe 'using %w(v x a e) & %w(w y a b c d e)' do
76
76
  let(:s1) { %w(v x a e) }
77
77
  let(:s2) { %w(w y a b c d e) }
78
78
  let(:result) {
79
79
  [
80
- [ '!', [ 0, 'v' ], [ 0, 'w' ] ],
81
- [ '!', [ 1, 'x' ], [ 1, 'y' ] ],
82
- [ '=', [ 2, 'a' ], [ 2, 'a' ] ],
83
- [ '+', [ 3, nil ], [ 3, 'b' ] ],
84
- [ '+', [ 3, nil ], [ 4, 'c' ] ],
85
- [ '+', [ 3, nil ], [ 5, 'd' ] ],
86
- [ '=', [ 3, 'e' ], [ 6, 'e' ] ]
80
+ ['!', [0, 'v'], [0, 'w']],
81
+ ['!', [1, 'x'], [1, 'y']],
82
+ ['=', [2, 'a'], [2, 'a']],
83
+ ['+', [3, nil], [3, 'b']],
84
+ ['+', [3, nil], [4, 'c']],
85
+ ['+', [3, nil], [5, 'd']],
86
+ ['=', [3, 'e'], [6, 'e']]
87
87
  ]
88
88
  }
89
89
 
90
- it_has_behavior "compare sequences correctly"
90
+ it_has_behavior 'compare sequences correctly'
91
91
  end
92
92
 
93
- describe "using %w(x a e) & %w(a b c d e)" do
93
+ describe 'using %w(x a e) & %w(a b c d e)' do
94
94
  let(:s1) { %w(x a e) }
95
95
  let(:s2) { %w(a b c d e) }
96
96
  let(:result) {
97
97
  [
98
- [ '-', [ 0, 'x' ], [ 0, nil ] ],
99
- [ '=', [ 1, 'a' ], [ 0, 'a' ] ],
100
- [ '+', [ 2, nil ], [ 1, 'b' ] ],
101
- [ '+', [ 2, nil ], [ 2, 'c' ] ],
102
- [ '+', [ 2, nil ], [ 3, 'd' ] ],
103
- [ '=', [ 2, 'e' ], [ 4, 'e' ] ]
98
+ ['-', [0, 'x'], [0, nil]],
99
+ ['=', [1, 'a'], [0, 'a']],
100
+ ['+', [2, nil], [1, 'b']],
101
+ ['+', [2, nil], [2, 'c']],
102
+ ['+', [2, nil], [3, 'd']],
103
+ ['=', [2, 'e'], [4, 'e']]
104
104
  ]
105
105
  }
106
106
 
107
- it_has_behavior "compare sequences correctly"
107
+ it_has_behavior 'compare sequences correctly'
108
108
  end
109
109
 
110
- describe "using %w(a e) & %w(x a b c d e)" do
110
+ describe 'using %w(a e) & %w(x a b c d e)' do
111
111
  let(:s1) { %w(a e) }
112
112
  let(:s2) { %w(x a b c d e) }
113
113
  let(:result) {
114
114
  [
115
- [ '+', [ 0, nil ], [ 0, 'x' ] ],
116
- [ '=', [ 0, 'a' ], [ 1, 'a' ] ],
117
- [ '+', [ 1, nil ], [ 2, 'b' ] ],
118
- [ '+', [ 1, nil ], [ 3, 'c' ] ],
119
- [ '+', [ 1, nil ], [ 4, 'd' ] ],
120
- [ '=', [ 1, 'e' ], [ 5, 'e' ] ]
115
+ ['+', [0, nil], [0, 'x']],
116
+ ['=', [0, 'a'], [1, 'a']],
117
+ ['+', [1, nil], [2, 'b']],
118
+ ['+', [1, nil], [3, 'c']],
119
+ ['+', [1, nil], [4, 'd']],
120
+ ['=', [1, 'e'], [5, 'e']]
121
121
  ]
122
122
  }
123
123
 
124
- it_has_behavior "compare sequences correctly"
124
+ it_has_behavior 'compare sequences correctly'
125
125
  end
126
126
 
127
- describe "using %w(a e v) & %w(x a b c d e w x)" do
127
+ describe 'using %w(a e v) & %w(x a b c d e w x)' do
128
128
  let(:s1) { %w(a e v) }
129
129
  let(:s2) { %w(x a b c d e w x) }
130
130
  let(:result) {
131
131
  [
132
- [ '+', [ 0, nil ], [ 0, 'x' ] ],
133
- [ '=', [ 0, 'a' ], [ 1, 'a' ] ],
134
- [ '+', [ 1, nil ], [ 2, 'b' ] ],
135
- [ '+', [ 1, nil ], [ 3, 'c' ] ],
136
- [ '+', [ 1, nil ], [ 4, 'd' ] ],
137
- [ '=', [ 1, 'e' ], [ 5, 'e' ] ],
138
- [ '!', [ 2, 'v' ], [ 6, 'w' ] ],
139
- [ '+', [ 3, nil ], [ 7, 'x' ] ]
132
+ ['+', [0, nil], [0, 'x']],
133
+ ['=', [0, 'a'], [1, 'a']],
134
+ ['+', [1, nil], [2, 'b']],
135
+ ['+', [1, nil], [3, 'c']],
136
+ ['+', [1, nil], [4, 'd']],
137
+ ['=', [1, 'e'], [5, 'e']],
138
+ ['!', [2, 'v'], [6, 'w']],
139
+ ['+', [3, nil], [7, 'x']]
140
140
  ]
141
141
  }
142
142
 
143
- it_has_behavior "compare sequences correctly"
143
+ it_has_behavior 'compare sequences correctly'
144
144
  end
145
145
 
146
- describe "using %w() & %w(a b c)" do
146
+ describe 'using %w() & %w(a b c)' do
147
147
  let(:s1) { %w() }
148
148
  let(:s2) { %w(a b c) }
149
149
  let(:result) {
150
150
  [
151
- [ '+', [ 0, nil ], [ 0, 'a' ] ],
152
- [ '+', [ 0, nil ], [ 1, 'b' ] ],
153
- [ '+', [ 0, nil ], [ 2, 'c' ] ]
151
+ ['+', [0, nil], [0, 'a']],
152
+ ['+', [0, nil], [1, 'b']],
153
+ ['+', [0, nil], [2, 'c']]
154
154
  ]
155
155
  }
156
156
 
157
- it_has_behavior "compare sequences correctly"
157
+ it_has_behavior 'compare sequences correctly'
158
158
  end
159
159
 
160
- describe "using %w(a b c) & %w(1)" do
160
+ describe 'using %w(a b c) & %w(1)' do
161
161
  let(:s1) { %w(a b c) }
162
162
  let(:s2) { %w(1) }
163
163
  let(:result) {
164
164
  [
165
- [ '!', [ 0, 'a' ], [ 0, '1' ] ],
166
- [ '-', [ 1, 'b' ], [ 1, nil ] ],
167
- [ '-', [ 2, 'c' ], [ 1, nil ] ]
165
+ ['!', [0, 'a'], [0, '1']],
166
+ ['-', [1, 'b'], [1, nil]],
167
+ ['-', [2, 'c'], [1, nil]]
168
168
  ]
169
169
  }
170
170
 
171
- it_has_behavior "compare sequences correctly"
171
+ it_has_behavior 'compare sequences correctly'
172
172
  end
173
173
 
174
- describe "using %w(a b c) & %w(c)" do
174
+ describe 'using %w(a b c) & %w(c)' do
175
175
  let(:s1) { %w(a b c) }
176
176
  let(:s2) { %w(c) }
177
177
  let(:result) {
178
178
  [
179
- [ '-', [ 0, 'a' ], [ 0, nil ] ],
180
- [ '-', [ 1, 'b' ], [ 0, nil ] ],
181
- [ '=', [ 2, 'c' ], [ 0, 'c' ] ]
179
+ ['-', [0, 'a'], [0, nil]],
180
+ ['-', [1, 'b'], [0, nil]],
181
+ ['=', [2, 'c'], [0, 'c']]
182
182
  ]
183
183
  }
184
184
 
185
- it_has_behavior "compare sequences correctly"
185
+ it_has_behavior 'compare sequences correctly'
186
186
  end
187
187
 
188
- describe "using %w(abcd efgh ijkl mnop) & []" do
188
+ describe 'using %w(abcd efgh ijkl mnop) & []' do
189
189
  let(:s1) { %w(abcd efgh ijkl mnop) }
190
190
  let(:s2) { [] }
191
191
  let(:result) {
192
192
  [
193
- [ '-', [ 0, 'abcd' ], [ 0, nil ] ],
194
- [ '-', [ 1, 'efgh' ], [ 0, nil ] ],
195
- [ '-', [ 2, 'ijkl' ], [ 0, nil ] ],
196
- [ '-', [ 3, 'mnop' ], [ 0, nil ] ]
193
+ ['-', [0, 'abcd'], [0, nil]],
194
+ ['-', [1, 'efgh'], [0, nil]],
195
+ ['-', [2, 'ijkl'], [0, nil]],
196
+ ['-', [3, 'mnop'], [0, nil]]
197
197
  ]
198
198
  }
199
199
 
200
- it_has_behavior "compare sequences correctly"
200
+ it_has_behavior 'compare sequences correctly'
201
201
  end
202
202
 
203
- describe "using [[1,2]] & []" do
204
- let(:s1) { [ [ 1, 2 ] ] }
203
+ describe 'using [[1,2]] & []' do
204
+ let(:s1) { [[1, 2]] }
205
205
  let(:s2) { [] }
206
206
  let(:result) {
207
207
  [
208
- [ '-', [ 0, [ 1, 2 ] ], [ 0, nil ] ]
208
+ ['-', [0, [1, 2]], [0, nil]]
209
209
  ]
210
210
  }
211
211
 
212
- it_has_behavior "compare sequences correctly"
212
+ it_has_behavior 'compare sequences correctly'
213
213
  end
214
214
  end
@@ -1,23 +1,20 @@
1
- # -*- ruby encoding: utf-8 -*-
1
+ # frozen_string_literal: true
2
2
 
3
3
  require 'rubygems'
4
4
  require 'pathname'
5
5
  require 'psych'
6
6
 
7
- if ENV['COVERALLS']
8
- require 'coveralls'
9
- Coveralls.wear!
10
- elsif ENV['COVERAGE']
7
+ if ENV['COVERAGE']
11
8
  require 'simplecov'
12
9
 
13
- def require_do(resource, &block)
10
+ def require_do(resource)
14
11
  require resource
15
- block.call
12
+ yield if block_given?
16
13
  rescue LoadError
17
14
  nil
18
15
  end
19
16
 
20
- formatters = [ SimpleCov::Formatter::HTMLFormatter ]
17
+ formatters = [SimpleCov::Formatter::HTMLFormatter]
21
18
 
22
19
  require_do('simplecov-rcov') {
23
20
  formatters << SimpleCov::Formatter::RcovFormatter
@@ -40,15 +37,47 @@ parent = path.parent
40
37
 
41
38
  $:.unshift parent.join('lib')
42
39
 
40
+ module CaptureSubprocessIO
41
+ def _synchronize
42
+ yield
43
+ end
44
+
45
+ def capture_subprocess_io
46
+ _synchronize do
47
+ begin
48
+ require 'tempfile'
49
+
50
+ captured_stdout, captured_stderr = Tempfile.new('out'), Tempfile.new('err')
51
+
52
+ orig_stdout, orig_stderr = $stdout.dup, $stderr.dup
53
+ $stdout.reopen captured_stdout
54
+ $stderr.reopen captured_stderr
55
+
56
+ yield
57
+
58
+ $stdout.rewind
59
+ $stderr.rewind
60
+
61
+ return captured_stdout.read, captured_stderr.read
62
+ ensure
63
+ captured_stdout.unlink
64
+ captured_stderr.unlink
65
+ $stdout.reopen orig_stdout
66
+ $stderr.reopen orig_stderr
67
+ end
68
+ end
69
+ end
70
+ end
71
+
43
72
  require 'diff-lcs'
44
73
 
45
74
  module Diff::LCS::SpecHelper
46
75
  def hello
47
- "hello"
76
+ 'hello'
48
77
  end
49
78
 
50
79
  def hello_ary
51
- %W(h e l l o)
80
+ %w(h e l l o)
52
81
  end
53
82
 
54
83
  def seq1
@@ -77,50 +106,69 @@ module Diff::LCS::SpecHelper
77
106
 
78
107
  def correct_forward_diff
79
108
  [
80
- [ [ '-', 0, 'a' ] ],
81
- [ [ '+', 2, 'd' ] ],
82
- [ [ '-', 4, 'h' ],
83
- [ '+', 4, 'f' ] ],
84
- [ [ '+', 6, 'k' ] ],
85
- [ [ '-', 8, 'n' ],
86
- [ '-', 9, 'p' ],
87
- [ '+', 9, 'r' ],
88
- [ '+', 10, 's' ],
89
- [ '+', 11, 't' ] ]
109
+ [
110
+ ['-', 0, 'a']
111
+ ],
112
+ [
113
+ ['+', 2, 'd']
114
+ ],
115
+ [
116
+ ['-', 4, 'h'],
117
+ ['+', 4, 'f']
118
+ ],
119
+ [
120
+ ['+', 6, 'k']
121
+ ],
122
+ [
123
+ ['-', 8, 'n'],
124
+ ['-', 9, 'p'],
125
+ ['+', 9, 'r'],
126
+ ['+', 10, 's'],
127
+ ['+', 11, 't']
128
+ ]
90
129
  ]
91
130
  end
92
131
 
93
132
  def correct_backward_diff
94
133
  [
95
- [ [ '+', 0, 'a' ] ],
96
- [ [ '-', 2, 'd' ] ],
97
- [ [ '-', 4, 'f' ],
98
- [ '+', 4, 'h' ] ],
99
- [ [ '-', 6, 'k' ] ],
100
134
  [
101
- [ '-', 9, 'r' ],
102
- [ '-', 10, 's' ],
103
- [ '+', 8, 'n' ],
104
- [ '-', 11, 't' ],
105
- [ '+', 9, 'p' ] ]
135
+ ['+', 0, 'a']
136
+ ],
137
+ [
138
+ ['-', 2, 'd']
139
+ ],
140
+ [
141
+ ['-', 4, 'f'],
142
+ ['+', 4, 'h']
143
+ ],
144
+ [
145
+ ['-', 6, 'k']
146
+ ],
147
+ [
148
+ ['-', 9, 'r'],
149
+ ['-', 10, 's'],
150
+ ['+', 8, 'n'],
151
+ ['-', 11, 't'],
152
+ ['+', 9, 'p']
153
+ ]
106
154
  ]
107
155
  end
108
156
 
109
157
  def correct_forward_sdiff
110
158
  [
111
- [ '-', [ 0, 'a' ], [ 0, nil ] ],
112
- [ '=', [ 1, 'b' ], [ 0, 'b' ] ],
113
- [ '=', [ 2, 'c' ], [ 1, 'c' ] ],
114
- [ '+', [ 3, nil ], [ 2, 'd' ] ],
115
- [ '=', [ 3, 'e' ], [ 3, 'e' ] ],
116
- [ '!', [ 4, 'h' ], [ 4, 'f' ] ],
117
- [ '=', [ 5, 'j' ], [ 5, 'j' ] ],
118
- [ '+', [ 6, nil ], [ 6, 'k' ] ],
119
- [ '=', [ 6, 'l' ], [ 7, 'l' ] ],
120
- [ '=', [ 7, 'm' ], [ 8, 'm' ] ],
121
- [ '!', [ 8, 'n' ], [ 9, 'r' ] ],
122
- [ '!', [ 9, 'p' ], [ 10, 's' ] ],
123
- [ '+', [ 10, nil ], [ 11, 't' ] ]
159
+ ['-', [0, 'a'], [0, nil]],
160
+ ['=', [1, 'b'], [0, 'b']],
161
+ ['=', [2, 'c'], [1, 'c']],
162
+ ['+', [3, nil], [2, 'd']],
163
+ ['=', [3, 'e'], [3, 'e']],
164
+ ['!', [4, 'h'], [4, 'f']],
165
+ ['=', [5, 'j'], [5, 'j']],
166
+ ['+', [6, nil], [6, 'k']],
167
+ ['=', [6, 'l'], [7, 'l']],
168
+ ['=', [7, 'm'], [8, 'm']],
169
+ ['!', [8, 'n'], [9, 'r']],
170
+ ['!', [9, 'p'], [10, 's']],
171
+ ['+', [10, nil], [11, 't']]
124
172
  ]
125
173
  end
126
174
 
@@ -144,13 +192,13 @@ module Diff::LCS::SpecHelper
144
192
  end
145
193
 
146
194
  def format_diffs(diffs)
147
- diffs.map do |e|
195
+ diffs.map { |e|
148
196
  if e.kind_of?(Array)
149
- e.map { |f| f.to_a.join }.join(", ")
197
+ e.map { |f| f.to_a.join }.join(', ')
150
198
  else
151
199
  e.to_a.join
152
200
  end
153
- end.join("\n")
201
+ }.join("\n")
154
202
  end
155
203
 
156
204
  def map_diffs(diffs, klass = Diff::LCS::ContextChange)
@@ -171,8 +219,8 @@ module Diff::LCS::SpecHelper
171
219
 
172
220
  def balanced_reverse(change_result)
173
221
  new_result = []
174
- change_result.each { |line|
175
- line = [ line[0], line[2], line[1] ]
222
+ change_result.each do |line|
223
+ line = [line[0], line[2], line[1]]
176
224
  case line[0]
177
225
  when '<'
178
226
  line[0] = '>'
@@ -180,21 +228,21 @@ module Diff::LCS::SpecHelper
180
228
  line[0] = '<'
181
229
  end
182
230
  new_result << line
183
- }
184
- new_result.sort_by { |line| [ line[1], line[2] ] }
231
+ end
232
+ new_result.sort_by { |line| [line[1], line[2]] }
185
233
  end
186
234
 
187
235
  def map_to_no_change(change_result)
188
236
  new_result = []
189
- change_result.each { |line|
237
+ change_result.each do |line|
190
238
  case line[0]
191
239
  when '!'
192
- new_result << [ '<', line[1], line[2] ]
193
- new_result << [ '>', line[1] + 1, line[2] ]
240
+ new_result << ['<', line[1], line[2]]
241
+ new_result << ['>', line[1] + 1, line[2]]
194
242
  else
195
243
  new_result << line
196
244
  end
197
- }
245
+ end
198
246
  new_result
199
247
  end
200
248
 
@@ -231,14 +279,18 @@ module Diff::LCS::SpecHelper
231
279
  end
232
280
 
233
281
  def finished_a(event)
234
- @done_a << [event.old_element, event.old_position,
235
- event.new_element, event.new_position]
282
+ @done_a << [
283
+ event.old_element, event.old_position,
284
+ event.new_element, event.new_position
285
+ ]
236
286
  end
237
287
 
238
288
  def finished_b(event)
239
- p "called #finished_b"
240
- @done_b << [event.old_element, event.old_position,
241
- event.new_element, event.new_position]
289
+ p 'called #finished_b'
290
+ @done_b << [
291
+ event.old_element, event.old_position,
292
+ event.new_element, event.new_position
293
+ ]
242
294
  end
243
295
  end
244
296
  callbacks.reset
@@ -264,19 +316,19 @@ module Diff::LCS::SpecHelper
264
316
  end
265
317
 
266
318
  def match(event)
267
- @result << [ "=", event.old_position, event.new_position ]
319
+ @result << ['=', event.old_position, event.new_position]
268
320
  end
269
321
 
270
322
  def discard_a(event)
271
- @result << [ "<", event.old_position, event.new_position ]
323
+ @result << ['<', event.old_position, event.new_position]
272
324
  end
273
325
 
274
326
  def discard_b(event)
275
- @result << [ ">", event.old_position, event.new_position ]
327
+ @result << ['>', event.old_position, event.new_position]
276
328
  end
277
329
 
278
330
  def change(event)
279
- @result << [ "!", event.old_position, event.new_position ]
331
+ @result << ['!', event.old_position, event.new_position]
280
332
  end
281
333
  end
282
334
  cb.reset