command_line_reporter 3.2.1 → 3.3.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (26) hide show
  1. data/README.md +16 -12
  2. data/lib/{column.rb → command_line_reporter/column.rb} +8 -3
  3. data/lib/{nested_formatter.rb → command_line_reporter/formatter/nested.rb} +0 -1
  4. data/lib/{progress_formatter.rb → command_line_reporter/formatter/progress.rb} +0 -1
  5. data/lib/{options_validator.rb → command_line_reporter/options_validator.rb} +0 -0
  6. data/lib/{row.rb → command_line_reporter/row.rb} +4 -5
  7. data/lib/command_line_reporter/table.rb +130 -0
  8. data/lib/{version.rb → command_line_reporter/version.rb} +1 -1
  9. data/lib/command_line_reporter.rb +9 -2
  10. data/spec/column_spec.rb +193 -202
  11. data/spec/command_line_reporter_spec.rb +146 -146
  12. data/spec/nested_formatter_spec.rb +101 -91
  13. data/spec/options_validator_spec.rb +0 -1
  14. data/spec/progress_formatter_spec.rb +20 -18
  15. data/spec/row_spec.rb +56 -52
  16. data/spec/spec_helper.rb +4 -2
  17. data/spec/table_spec.rb +54 -16
  18. metadata +54 -57
  19. data/examples/capture.rb +0 -32
  20. data/examples/nested.rb +0 -38
  21. data/examples/progress.rb +0 -68
  22. data/examples/quiet.rb +0 -40
  23. data/examples/simple.rb +0 -23
  24. data/examples/table.rb +0 -71
  25. data/examples/variable.rb +0 -30
  26. data/lib/table.rb +0 -96
data/spec/column_spec.rb CHANGED
@@ -1,5 +1,4 @@
1
1
  require 'spec_helper'
2
- require 'column'
3
2
 
4
3
  describe CommandLineReporter::Column do
5
4
  describe '#initialize' do
@@ -16,11 +15,11 @@ describe CommandLineReporter::Column do
16
15
  end
17
16
 
18
17
  it 'defaults the width' do
19
- CommandLineReporter::Column.new('test').width.should == 10
18
+ expect(CommandLineReporter::Column.new('test').width).to eq(10)
20
19
  end
21
20
 
22
21
  it 'accepts the width' do
23
- CommandLineReporter::Column.new('test', :width => 50).width.should == 50
22
+ expect(CommandLineReporter::Column.new('test', :width => 50).width).to eq(50)
24
23
  end
25
24
 
26
25
  it 'requires valid width' do
@@ -30,23 +29,23 @@ describe CommandLineReporter::Column do
30
29
  end
31
30
 
32
31
  it 'accepts text' do
33
- CommandLineReporter::Column.new('asdf').text.should == 'asdf'
32
+ expect(CommandLineReporter::Column.new('asdf').text).to eq('asdf')
34
33
  end
35
34
 
36
35
  it 'accepts color' do
37
- CommandLineReporter::Column.new('asdf', :color => 'red').color.should == 'red'
36
+ expect(CommandLineReporter::Column.new('asdf', :color => 'red').color).to eq('red')
38
37
  end
39
38
 
40
39
  it 'accepts bold' do
41
- CommandLineReporter::Column.new('asdf', :bold => true).bold.should be_true
40
+ expect(CommandLineReporter::Column.new('asdf', :bold => true).bold).to be_true
42
41
  end
43
42
 
44
43
  it 'defaults the padding' do
45
- CommandLineReporter::Column.new('test').padding.should == 0
44
+ expect(CommandLineReporter::Column.new('test').padding).to eq(0)
46
45
  end
47
46
 
48
47
  it 'accepts the padding' do
49
- CommandLineReporter::Column.new('test', :padding => 5).padding.should == 5
48
+ expect(CommandLineReporter::Column.new('test', :padding => 5).padding).to eq(5)
50
49
  end
51
50
 
52
51
  it 'requires valid width' do
@@ -56,9 +55,25 @@ describe CommandLineReporter::Column do
56
55
  end
57
56
  end
58
57
 
58
+ describe '#size' do
59
+ it 'is the width less twice the padding' do
60
+ expect(CommandLineReporter::Column.new('test').size).to eq(10)
61
+ expect(CommandLineReporter::Column.new('test', :width => 5).size).to eq(5)
62
+ expect(CommandLineReporter::Column.new('test', :width => 5, :padding => 1).size).to eq(3)
63
+ end
64
+ end
65
+
66
+ describe '#required_width' do
67
+ it 'is the length of the text plus twice the padding' do
68
+ expect(CommandLineReporter::Column.new('test').required_width).to eq(4)
69
+ expect(CommandLineReporter::Column.new('test', :padding => 1).required_width).to eq(6)
70
+ expect(CommandLineReporter::Column.new('test', :padding => 5).required_width).to eq(14)
71
+ end
72
+ end
73
+
59
74
  describe '#screen_rows' do
60
- before :all do
61
- @controls = {
75
+ let :controls do
76
+ {
62
77
  :clear => "\e[0m",
63
78
  :bold => "\e[1m",
64
79
  :red => "\e[31m",
@@ -74,143 +89,131 @@ describe CommandLineReporter::Column do
74
89
 
75
90
  it 'handles empty text' do
76
91
  c = CommandLineReporter::Column.new
77
- c.screen_rows[0].should == ' ' * 10
92
+ expect(c.screen_rows[0]).to eq(' ' * 10)
78
93
  end
79
94
 
80
95
  context 'left justifies' do
81
- before :each do
82
- @text = 'x' * 10
83
- @filler = ' ' * 10
84
- end
96
+ let(:text) { 'x' * 10 }
97
+ let(:filler) { ' ' * 10 }
85
98
 
86
99
  it 'plain text' do
87
- c = CommandLineReporter::Column.new(@text, :width => 20)
88
- c.screen_rows[0].should == @text + @filler
100
+ c = CommandLineReporter::Column.new(text, :width => 20)
101
+ expect(c.screen_rows[0]).to eq(text + filler)
89
102
  end
90
103
 
91
104
  it 'outputs red' do
92
- c = CommandLineReporter::Column.new(@text, :align => 'left', :width => 20, :color => 'red')
93
- c.screen_rows[0].should == @controls[:red] + @text + @filler + @controls[:clear]
105
+ c = CommandLineReporter::Column.new(text, :align => 'left', :width => 20, :color => 'red')
106
+ expect(c.screen_rows[0]).to eq(controls[:red] + text + filler + controls[:clear])
94
107
  end
95
108
 
96
109
  it 'outputs bold' do
97
- c = CommandLineReporter::Column.new(@text, :align => 'left', :width => 20, :bold => true)
98
- c.screen_rows[0].should == @controls[:bold] + @text + @filler + @controls[:clear]
110
+ c = CommandLineReporter::Column.new(text, :align => 'left', :width => 20, :bold => true)
111
+ expect(c.screen_rows[0]).to eq(controls[:bold] + text + filler + controls[:clear])
99
112
  end
100
113
  end
101
114
 
102
115
  context 'right justifies' do
103
- before :each do
104
- @text = 'x' * 10
105
- @filler = ' ' * 10
106
- end
116
+ let(:text) { 'x' * 10 }
117
+ let(:filler) { ' ' * 10 }
107
118
 
108
119
  it 'plain text' do
109
- c = CommandLineReporter::Column.new(@text, :align => 'right', :width => 20)
110
- c.screen_rows[0].should == @filler + @text
120
+ c = CommandLineReporter::Column.new(text, :align => 'right', :width => 20)
121
+ expect(c.screen_rows[0]).to eq(filler + text)
111
122
  end
112
123
 
113
124
  it 'outputs red' do
114
- c = CommandLineReporter::Column.new(@text, :align => 'right', :width => 20, :color => 'red')
115
- c.screen_rows[0].should == @controls[:red] + @filler + @text + @controls[:clear]
125
+ c = CommandLineReporter::Column.new(text, :align => 'right', :width => 20, :color => 'red')
126
+ expect(c.screen_rows[0]).to eq(controls[:red] + filler + text + controls[:clear])
116
127
  end
117
128
 
118
129
  it 'outputs bold' do
119
- c = CommandLineReporter::Column.new(@text, :align => 'right', :width => 20, :bold => true)
120
- c.screen_rows[0].should == @controls[:bold] + @filler + @text + @controls[:clear]
130
+ c = CommandLineReporter::Column.new(text, :align => 'right', :width => 20, :bold => true)
131
+ expect(c.screen_rows[0]).to eq(controls[:bold] + filler + text + controls[:clear])
121
132
  end
122
133
  end
123
134
 
124
135
  context 'center justifies' do
125
- before :each do
126
- @text = 'x' * 10
127
- @filler = ' ' * 5
128
- end
136
+ let(:text) { 'x' * 10 }
137
+ let(:filler) { ' ' * 5 }
129
138
 
130
139
  it 'plain text' do
131
- c = CommandLineReporter::Column.new(@text, :align => 'center', :width => 20)
132
- c.screen_rows[0].should == @filler + @text + @filler
140
+ c = CommandLineReporter::Column.new(text, :align => 'center', :width => 20)
141
+ expect(c.screen_rows[0]).to eq(filler + text + filler)
133
142
  end
134
143
 
135
144
  it 'outputs red' do
136
- c = CommandLineReporter::Column.new(@text, :align => 'center', :width => 20, :color => 'red')
137
- c.screen_rows[0].should == @controls[:red] + @filler + @text + @filler + @controls[:clear]
145
+ c = CommandLineReporter::Column.new(text, :align => 'center', :width => 20, :color => 'red')
146
+ expect(c.screen_rows[0]).to eq(controls[:red] + filler + text + filler + controls[:clear])
138
147
  end
139
148
 
140
149
  it 'outputs bold' do
141
- c = CommandLineReporter::Column.new(@text, :align => 'center', :width => 20, :bold => true)
142
- c.screen_rows[0].should == @controls[:bold] + @filler + @text + @filler + @controls[:clear]
150
+ c = CommandLineReporter::Column.new(text, :align => 'center', :width => 20, :bold => true)
151
+ expect(c.screen_rows[0]).to eq(controls[:bold] + filler + text + filler + controls[:clear])
143
152
  end
144
153
  end
145
154
  end
146
155
 
147
156
  context 'accounts for padding' do
148
157
  context 'left justifies' do
149
- before :each do
150
- @text = 'x' * 10
151
- @padding = ' ' * 5
152
- @filler = ' ' * 10
153
- end
158
+ let(:text) { 'x' * 10 }
159
+ let(:padding) { ' ' * 5 }
160
+ let(:filler) { ' ' * 10 }
154
161
 
155
162
  it 'plain text' do
156
- c = CommandLineReporter::Column.new(@text, :padding => 5, :width => 30)
157
- c.screen_rows[0].should == @padding + @text + @filler + @padding
163
+ c = CommandLineReporter::Column.new(text, :padding => 5, :width => 30)
164
+ expect(c.screen_rows[0]).to eq(padding + text + filler + padding)
158
165
  end
159
166
 
160
167
  it 'outputs red' do
161
- c = CommandLineReporter::Column.new(@text, :padding => 5, :width => 30, :color => 'red')
162
- c.screen_rows[0].should == @padding + @controls[:red] + @text + @filler + @controls[:clear] + @padding
168
+ c = CommandLineReporter::Column.new(text, :padding => 5, :width => 30, :color => 'red')
169
+ expect(c.screen_rows[0]).to eq(padding + controls[:red] + text + filler + controls[:clear] + padding)
163
170
  end
164
171
 
165
172
  it 'outputs bold' do
166
- c = CommandLineReporter::Column.new(@text, :padding => 5, :width => 30, :bold => true)
167
- c.screen_rows[0].should == @padding + @controls[:bold] + @text + @filler + @controls[:clear] + @padding
173
+ c = CommandLineReporter::Column.new(text, :padding => 5, :width => 30, :bold => true)
174
+ expect(c.screen_rows[0]).to eq(padding + controls[:bold] + text + filler + controls[:clear] + padding)
168
175
  end
169
176
  end
170
177
 
171
178
  context 'right justifies' do
172
- before :each do
173
- @text = 'x' * 10
174
- @padding = ' ' * 5
175
- @filler = ' ' * 10
176
- end
179
+ let(:text) { 'x' * 10 }
180
+ let(:padding) { ' ' * 5 }
181
+ let(:filler) { ' ' * 10 }
177
182
 
178
183
  it 'plain text' do
179
- c = CommandLineReporter::Column.new(@text, :align => 'right', :padding => 5, :width => 30)
180
- c.screen_rows[0].should == @padding + @filler + @text + @padding
184
+ c = CommandLineReporter::Column.new(text, :align => 'right', :padding => 5, :width => 30)
185
+ expect(c.screen_rows[0]).to eq(padding + filler + text + padding)
181
186
  end
182
187
 
183
188
  it 'outputs red' do
184
- c = CommandLineReporter::Column.new(@text, :align => 'right', :padding => 5, :width => 30, :color => 'red')
185
- c.screen_rows[0].should == @padding + @controls[:red] + @filler + @text + @controls[:clear] + @padding
189
+ c = CommandLineReporter::Column.new(text, :align => 'right', :padding => 5, :width => 30, :color => 'red')
190
+ expect(c.screen_rows[0]).to eq(padding + controls[:red] + filler + text + controls[:clear] + padding)
186
191
  end
187
192
 
188
193
  it 'outputs bold' do
189
- c = CommandLineReporter::Column.new(@text, :align => 'right', :padding => 5, :width => 30, :bold => true)
190
- c.screen_rows[0].should == @padding + @controls[:bold] + @filler + @text + @controls[:clear] + @padding
194
+ c = CommandLineReporter::Column.new(text, :align => 'right', :padding => 5, :width => 30, :bold => true)
195
+ expect(c.screen_rows[0]).to eq(padding + controls[:bold] + filler + text + controls[:clear] + padding)
191
196
  end
192
197
  end
193
198
 
194
199
  context 'right justifies' do
195
- before :each do
196
- @text = ' ' * 10
197
- @padding = ' ' * 5
198
- @filler = ' ' * 5
199
- end
200
+ let(:text) { 'x' * 10 }
201
+ let(:padding) { ' ' * 5 }
202
+ let(:filler) { ' ' * 5 }
200
203
 
201
204
  it 'plain text' do
202
- c = CommandLineReporter::Column.new(@text, :align => 'center', :padding => 5, :width => 30)
203
- c.screen_rows[0].should == @padding + @filler + @text + @filler + @padding
205
+ c = CommandLineReporter::Column.new(text, :align => 'center', :padding => 5, :width => 30)
206
+ expect(c.screen_rows[0]).to eq(padding + filler + text + filler + padding)
204
207
  end
205
208
 
206
209
  it 'outputs red' do
207
- c = CommandLineReporter::Column.new(@text, :align => 'center', :padding => 5, :width => 30, :color => 'red')
208
- c.screen_rows[0].should == @padding + @controls[:red] + @filler + @text + @filler + @controls[:clear] + @padding
210
+ c = CommandLineReporter::Column.new(text, :align => 'center', :padding => 5, :width => 30, :color => 'red')
211
+ expect(c.screen_rows[0]).to eq(padding + controls[:red] + filler + text + filler + controls[:clear] + padding)
209
212
  end
210
213
 
211
214
  it 'outputs bold' do
212
- c = CommandLineReporter::Column.new(@text, :align => 'center', :padding => 5, :width => 30, :bold => true)
213
- c.screen_rows[0].should == @padding + @controls[:bold] + @filler + @text + @filler + @controls[:clear] + @padding
215
+ c = CommandLineReporter::Column.new(text, :align => 'center', :padding => 5, :width => 30, :bold => true)
216
+ expect(c.screen_rows[0]).to eq(padding + controls[:bold] + filler + text + filler + controls[:clear] + padding)
214
217
  end
215
218
  end
216
219
  end
@@ -219,204 +222,192 @@ describe CommandLineReporter::Column do
219
222
  context 'with wrapping' do
220
223
  context 'no padding' do
221
224
  context 'left justifies' do
222
- before :each do
223
- @text = 'x' * 25
224
- @full_line = 'x' * 10
225
- @remainder = 'x' * 5
226
- @filler = ' ' * 5
227
- end
225
+ let(:text) { 'x' * 25 }
226
+ let(:full_line) { 'x' * 10 }
227
+ let(:remainder) { 'x' * 5 }
228
+ let(:filler) { ' ' * 5 }
228
229
 
229
230
  it 'plain text' do
230
- c = CommandLineReporter::Column.new(@text, :width => 10)
231
- c.screen_rows.should == [@full_line, @full_line, @remainder + @filler]
231
+ c = CommandLineReporter::Column.new(text, :width => 10)
232
+ expect(c.screen_rows).to eq([full_line, full_line, remainder + filler])
232
233
  end
233
234
 
234
235
  it 'outputs red' do
235
- c = CommandLineReporter::Column.new(@text, :width => 10, :color => 'red')
236
- c.screen_rows.should == [
237
- @controls[:red] + @full_line + @controls[:clear],
238
- @controls[:red] + @full_line + @controls[:clear],
239
- @controls[:red] + @remainder + @filler + @controls[:clear],
240
- ]
236
+ c = CommandLineReporter::Column.new(text, :width => 10, :color => 'red')
237
+ expect(c.screen_rows).to eq([
238
+ controls[:red] + full_line + controls[:clear],
239
+ controls[:red] + full_line + controls[:clear],
240
+ controls[:red] + remainder + filler + controls[:clear],
241
+ ])
241
242
  end
242
243
 
243
244
  it 'outputs bold' do
244
- c = CommandLineReporter::Column.new(@text, :width => 10, :bold => true)
245
- c.screen_rows.should == [
246
- @controls[:bold] + @full_line + @controls[:clear],
247
- @controls[:bold] + @full_line + @controls[:clear],
248
- @controls[:bold] + @remainder + @filler + @controls[:clear],
249
- ]
245
+ c = CommandLineReporter::Column.new(text, :width => 10, :bold => true)
246
+ expect(c.screen_rows).to eq([
247
+ controls[:bold] + full_line + controls[:clear],
248
+ controls[:bold] + full_line + controls[:clear],
249
+ controls[:bold] + remainder + filler + controls[:clear],
250
+ ])
250
251
  end
251
252
  end
252
253
 
253
254
  context 'right justifies' do
254
- before :each do
255
- @text = 'x' * 25
256
- @full_line = 'x' * 10
257
- @remainder = 'x' * 5
258
- @filler = ' ' * 5
259
- end
255
+ let(:text) { 'x' * 25 }
256
+ let(:full_line) { 'x' * 10 }
257
+ let(:remainder) { 'x' * 5 }
258
+ let(:filler) { ' ' * 5 }
260
259
 
261
260
  it 'plain text' do
262
- c = CommandLineReporter::Column.new(@text, :align => 'right', :width => 10)
263
- c.screen_rows.should == [@full_line, @full_line, @filler + @remainder]
261
+ c = CommandLineReporter::Column.new(text, :align => 'right', :width => 10)
262
+ expect(c.screen_rows).to eq([full_line, full_line, filler + remainder])
264
263
  end
265
264
 
266
265
  it 'outputs red' do
267
- c = CommandLineReporter::Column.new(@text, :align => 'right', :width => 10, :color => 'red')
268
- c.screen_rows.should == [
269
- @controls[:red] + @full_line + @controls[:clear],
270
- @controls[:red] + @full_line + @controls[:clear],
271
- @controls[:red] + @filler + @remainder + @controls[:clear],
272
- ]
266
+ c = CommandLineReporter::Column.new(text, :align => 'right', :width => 10, :color => 'red')
267
+ expect(c.screen_rows).to eq([
268
+ controls[:red] + full_line + controls[:clear],
269
+ controls[:red] + full_line + controls[:clear],
270
+ controls[:red] + filler + remainder + controls[:clear],
271
+ ])
273
272
  end
274
273
 
275
274
  it 'outputs bold' do
276
- c = CommandLineReporter::Column.new(@text, :align => 'right', :width => 10, :bold => true)
277
- c.screen_rows.should == [
278
- @controls[:bold] + @full_line + @controls[:clear],
279
- @controls[:bold] + @full_line + @controls[:clear],
280
- @controls[:bold] + @filler + @remainder + @controls[:clear],
281
- ]
275
+ c = CommandLineReporter::Column.new(text, :align => 'right', :width => 10, :bold => true)
276
+ expect(c.screen_rows).to eq([
277
+ controls[:bold] + full_line + controls[:clear],
278
+ controls[:bold] + full_line + controls[:clear],
279
+ controls[:bold] + filler + remainder + controls[:clear],
280
+ ])
282
281
  end
283
282
  end
284
283
 
285
284
  context 'center justifies' do
286
- before :each do
287
- @text = 'x' * 25
288
- @full_line = 'x' * 10
289
- @remainder = 'x' * 5
290
- @left_filler = ' ' * 3
291
- @right_filler = ' ' * 2
292
- end
285
+ let(:text) { 'x' * 25 }
286
+ let(:full_line) { 'x' * 10 }
287
+ let(:remainder) { 'x' * 5 }
288
+ let(:left_filler) { ' ' * 3 }
289
+ let(:right_filler) { ' ' * 2 }
293
290
 
294
291
  it 'plain text' do
295
- c = CommandLineReporter::Column.new(@text, :align => 'center', :width => 10)
296
- c.screen_rows.should == [@full_line, @full_line, ' ' * 3 + @remainder + @right_filler]
292
+ c = CommandLineReporter::Column.new(text, :align => 'center', :width => 10)
293
+ expect(c.screen_rows).to eq([full_line, full_line, ' ' * 3 + remainder + right_filler])
297
294
  end
298
295
 
299
296
  it 'outputs red' do
300
- c = CommandLineReporter::Column.new(@text, :align => 'center', :width => 10, :color => 'red')
301
- c.screen_rows.should == [
302
- @controls[:red] + @full_line + @controls[:clear],
303
- @controls[:red] + @full_line + @controls[:clear],
304
- @controls[:red] + @left_filler + @remainder + @right_filler + @controls[:clear],
305
- ]
297
+ c = CommandLineReporter::Column.new(text, :align => 'center', :width => 10, :color => 'red')
298
+ expect(c.screen_rows).to eq([
299
+ controls[:red] + full_line + controls[:clear],
300
+ controls[:red] + full_line + controls[:clear],
301
+ controls[:red] + left_filler + remainder + right_filler + controls[:clear],
302
+ ])
306
303
  end
307
304
 
308
305
  it 'outputs bold' do
309
- c = CommandLineReporter::Column.new(@text, :align => 'center', :width => 10, :bold => true)
310
- c.screen_rows.should == [
311
- @controls[:bold] + @full_line + @controls[:clear],
312
- @controls[:bold] + @full_line + @controls[:clear],
313
- @controls[:bold] + @left_filler + @remainder + @right_filler + @controls[:clear],
314
- ]
306
+ c = CommandLineReporter::Column.new(text, :align => 'center', :width => 10, :bold => true)
307
+ expect(c.screen_rows).to eq([
308
+ controls[:bold] + full_line + controls[:clear],
309
+ controls[:bold] + full_line + controls[:clear],
310
+ controls[:bold] + left_filler + remainder + right_filler + controls[:clear],
311
+ ])
315
312
  end
316
313
  end
317
314
  end
318
315
 
319
316
  context 'account for padding' do
320
317
  context 'left justifies' do
321
- before :each do
322
- @text = 'x' * 25
323
- @full_line = 'x' * 16
324
- @remainder = 'x' * 9
325
- @padding = ' ' * 2
326
- @filler = ' ' * 7
327
- end
318
+ let(:text) { 'x' * 25 }
319
+ let(:full_line) { 'x' * 16 }
320
+ let(:remainder) { 'x' * 9 }
321
+ let(:padding) { ' ' * 2 }
322
+ let(:filler) { ' ' * 7 }
328
323
 
329
324
  it 'plain text' do
330
- c = CommandLineReporter::Column.new(@text, :padding => 2, :width => 20)
331
- c.screen_rows.should == [
332
- @padding + @full_line + @padding,
333
- @padding + @remainder + @filler + @padding,
334
- ]
325
+ c = CommandLineReporter::Column.new(text, :padding => 2, :width => 20)
326
+ expect(c.screen_rows).to eq([
327
+ padding + full_line + padding,
328
+ padding + remainder + filler + padding,
329
+ ])
335
330
  end
336
331
 
337
332
  it 'outputs red' do
338
- c = CommandLineReporter::Column.new(@text, :padding => 2, :width => 20, :color => 'red')
339
- c.screen_rows.should == [
340
- @padding + @controls[:red] + @full_line + @controls[:clear] + @padding,
341
- @padding + @controls[:red] + @remainder + @filler + @controls[:clear] + @padding,
342
- ]
333
+ c = CommandLineReporter::Column.new(text, :padding => 2, :width => 20, :color => 'red')
334
+ expect(c.screen_rows).to eq([
335
+ padding + controls[:red] + full_line + controls[:clear] + padding,
336
+ padding + controls[:red] + remainder + filler + controls[:clear] + padding,
337
+ ])
343
338
  end
344
339
 
345
340
  it 'outputs bold' do
346
- c = CommandLineReporter::Column.new(@text, :padding => 2, :width => 20, :bold => true)
347
- c.screen_rows.should == [
348
- @padding + @controls[:bold] + @full_line + @controls[:clear] + @padding,
349
- @padding + @controls[:bold] + @remainder + @filler + @controls[:clear] + @padding,
350
- ]
341
+ c = CommandLineReporter::Column.new(text, :padding => 2, :width => 20, :bold => true)
342
+ expect(c.screen_rows).to eq([
343
+ padding + controls[:bold] + full_line + controls[:clear] + padding,
344
+ padding + controls[:bold] + remainder + filler + controls[:clear] + padding,
345
+ ])
351
346
  end
352
347
  end
353
348
 
354
349
  context 'right justifies' do
355
- before :each do
356
- @text = 'x' * 25
357
- @full_line = 'x' * 16
358
- @remainder = 'x' * 9
359
- @padding = ' ' * 2
360
- @filler = ' ' * 7
361
- end
350
+ let(:text) { 'x' * 25 }
351
+ let(:full_line) { 'x' * 16 }
352
+ let(:remainder) { 'x' * 9 }
353
+ let(:padding) { ' ' * 2 }
354
+ let(:filler) { ' ' * 7 }
362
355
 
363
356
  it 'plain text' do
364
- c = CommandLineReporter::Column.new(@text, :padding => 2, :align => 'right', :width => 20)
365
- c.screen_rows.should == [
366
- @padding + @full_line + @padding,
367
- @padding + @filler + @remainder + @padding,
368
- ]
357
+ c = CommandLineReporter::Column.new(text, :padding => 2, :align => 'right', :width => 20)
358
+ expect(c.screen_rows).to eq([
359
+ padding + full_line + padding,
360
+ padding + filler + remainder + padding,
361
+ ])
369
362
  end
370
363
 
371
364
  it 'outputs red' do
372
- c = CommandLineReporter::Column.new(@text, :align => 'right', :padding => 2, :width => 20, :color => 'red')
373
- c.screen_rows.should == [
374
- @padding + @controls[:red] + @full_line + @controls[:clear] + @padding,
375
- @padding + @controls[:red] + @filler + @remainder + @controls[:clear] + @padding,
376
- ]
365
+ c = CommandLineReporter::Column.new(text, :align => 'right', :padding => 2, :width => 20, :color => 'red')
366
+ expect(c.screen_rows).to eq([
367
+ padding + controls[:red] + full_line + controls[:clear] + padding,
368
+ padding + controls[:red] + filler + remainder + controls[:clear] + padding,
369
+ ])
377
370
  end
378
371
 
379
372
  it 'outputs bold' do
380
- c = CommandLineReporter::Column.new(@text, :align => 'right', :padding => 2, :width => 20, :bold => true)
381
- c.screen_rows.should == [
382
- @padding + @controls[:bold] + @full_line + @controls[:clear] + @padding,
383
- @padding + @controls[:bold] + @filler + @remainder + @controls[:clear] + @padding,
384
- ]
373
+ c = CommandLineReporter::Column.new(text, :align => 'right', :padding => 2, :width => 20, :bold => true)
374
+ expect(c.screen_rows).to eq([
375
+ padding + controls[:bold] + full_line + controls[:clear] + padding,
376
+ padding + controls[:bold] + filler + remainder + controls[:clear] + padding,
377
+ ])
385
378
  end
386
379
  end
387
380
 
388
381
  context 'center justifies' do
389
- before :each do
390
- @text = 'x' * 25
391
- @full_line = 'x' * 16
392
- @remainder = 'x' * 9
393
- @padding = ' ' * 2
394
- @left_filler = ' ' * 4
395
- @right_filler = ' ' * 3
396
- end
382
+ let(:text) { 'x' * 25 }
383
+ let(:full_line) { 'x' * 16 }
384
+ let(:remainder) { 'x' * 9 }
385
+ let(:padding) { ' ' * 2 }
386
+ let(:left_filler) { ' ' * 4 }
387
+ let(:right_filler) { ' ' * 3 }
397
388
 
398
389
  it 'plain text' do
399
- c = CommandLineReporter::Column.new(@text, :padding => 2, :align => 'center', :width => 20)
400
- c.screen_rows.should == [
401
- @padding + @full_line + @padding,
402
- @padding + @left_filler + @remainder + @right_filler + @padding,
403
- ]
390
+ c = CommandLineReporter::Column.new(text, :padding => 2, :align => 'center', :width => 20)
391
+ expect(c.screen_rows).to eq([
392
+ padding + full_line + padding,
393
+ padding + left_filler + remainder + right_filler + padding,
394
+ ])
404
395
  end
405
396
 
406
397
  it 'outputs red' do
407
- c = CommandLineReporter::Column.new(@text, :padding => 2, :align => 'center', :width => 20, :color => 'red')
408
- c.screen_rows.should == [
409
- @padding + @controls[:red] + @full_line + @controls[:clear] + @padding,
410
- @padding + @controls[:red] + @left_filler + @remainder + @right_filler + @controls[:clear] + @padding,
411
- ]
398
+ c = CommandLineReporter::Column.new(text, :padding => 2, :align => 'center', :width => 20, :color => 'red')
399
+ expect(c.screen_rows).to eq([
400
+ padding + controls[:red] + full_line + controls[:clear] + padding,
401
+ padding + controls[:red] + left_filler + remainder + right_filler + controls[:clear] + padding,
402
+ ])
412
403
  end
413
404
 
414
405
  it 'outputs bold' do
415
- c = CommandLineReporter::Column.new(@text, :padding => 2, :align => 'center', :width => 20, :bold => true)
416
- c.screen_rows.should == [
417
- @padding + @controls[:bold] + @full_line + @controls[:clear] + @padding,
418
- @padding + @controls[:bold] + @left_filler + @remainder + @right_filler + @controls[:clear] + @padding,
419
- ]
406
+ c = CommandLineReporter::Column.new(text, :padding => 2, :align => 'center', :width => 20, :bold => true)
407
+ expect(c.screen_rows).to eq([
408
+ padding + controls[:bold] + full_line + controls[:clear] + padding,
409
+ padding + controls[:bold] + left_filler + remainder + right_filler + controls[:clear] + padding,
410
+ ])
420
411
  end
421
412
  end
422
413
  end