anbt-sql-formatter 0.0.7 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (20) hide show
  1. checksums.yaml +4 -4
  2. data/.gitignore +3 -0
  3. data/CHANGELOG.md +38 -1
  4. data/{readme.ja.txt → README.ja.rdoc} +2 -2
  5. data/{readme.txt → README.rdoc} +2 -2
  6. data/anbt-sql-formatter.gemspec +2 -0
  7. data/lib/anbt-sql-formatter/coarse-tokenizer.rb +28 -27
  8. data/lib/anbt-sql-formatter/constants.rb +1 -1
  9. data/lib/anbt-sql-formatter/parser.rb +1 -1
  10. data/lib/anbt-sql-formatter/rule.rb +1 -1
  11. data/lib/anbt-sql-formatter/token.rb +2 -2
  12. data/lib/anbt-sql-formatter/version.rb +1 -1
  13. data/misc/anbt-sql-formatter-customize-example +4 -4
  14. data/sample.sql +4 -0
  15. data/test/test_coarse-tokenizer.rb +5 -5
  16. data/test/test_formatter.rb +506 -529
  17. data/test/test_in_values.rb +6 -6
  18. data/test/test_parser.rb +435 -411
  19. data/test.sh +10 -0
  20. metadata +21 -10
data/test/test_formatter.rb CHANGED
@@ -20,483 +20,478 @@ class TestAnbtSqlFormatter < Test::Unit::TestCase
20
20
  Helper.format_tokens(tokens)
21
21
  end
22
22
 
23
- def test_modify_keyword_case
24
- msg = "upcase"
25
-
26
- ########
27
- @rule.keyword = AnbtSql::Rule::KEYWORD_UPPER_CASE
28
-
29
- tokens = @parser.parse("select")
30
- @fmt.modify_keyword_case(tokens)
31
- assert_equals(
32
- msg + "",
33
- strip_indent(
34
- <<-EOB
35
- keyword (SELECT)
36
- EOB
37
- ),
38
- _format(tokens)
39
- )
40
-
41
- ########
42
- msg = "downcase"
43
- @rule.keyword = AnbtSql::Rule::KEYWORD_LOWER_CASE
44
-
45
- tokens = @parser.parse("SELECT")
46
- @fmt.modify_keyword_case(tokens)
47
- assert_equals(
48
- msg + "",
49
- strip_indent(
50
- <<-EOB
51
- keyword (select)
52
- EOB
53
- ),
54
- _format(tokens)
55
- )
23
+ def token_new(type, string)
24
+ type_map = {
25
+ name: AnbtSql::TokenConstants::NAME,
26
+ space: AnbtSql::TokenConstants::SPACE
27
+ }
28
+ _type = type_map.fetch(type)
29
+
30
+ AnbtSql::Token.new(_type, string)
56
31
  end
57
32
 
58
33
 
59
- def test_concat_operator_for_oracle
60
- msg = "concat_operator_for_oracle - "
61
-
62
- ########
63
- tokens = @parser.parse("a+")
64
- @fmt.concat_operator_for_oracle(tokens)
65
- assert_equals(
66
- msg + "length is less than 3, should do nothing",
67
- strip_indent(
68
- <<-EOB
69
- name (a)
70
- symbol (+)
71
- EOB
72
- ),
73
- _format(tokens)
74
- )
75
-
76
- ########
77
- tokens = @parser.parse("(+)")
78
- @fmt.concat_operator_for_oracle(tokens)
79
- assert_equals(
80
- msg + "",
81
- strip_indent(
82
- <<-EOB
83
- symbol ((+))
84
- EOB
85
- ),
86
- _format(tokens)
87
- )
88
-
89
- ########
90
- tokens = @parser.parse("(+)")
91
- tokens = @fmt.format_list(tokens)
92
- assert_equals(
93
- msg + "format_list()",
94
- strip_indent(
95
- <<-EOB
96
- symbol ((+))
97
- EOB
98
- ),
99
- _format(tokens)
100
- )
34
+ sub_test_case "modify_keyword_case" do
35
+ test "upper case" do
36
+ @rule.keyword = AnbtSql::Rule::KEYWORD_UPPER_CASE
37
+
38
+ tokens = @parser.parse("select")
39
+ @fmt.modify_keyword_case(tokens)
40
+ assert_equal(
41
+ strip_indent(
42
+ <<-EOB
43
+ keyword (SELECT)
44
+ EOB
45
+ ),
46
+ _format(tokens)
47
+ )
48
+ end
49
+
50
+ test "lower case" do
51
+ @rule.keyword = AnbtSql::Rule::KEYWORD_LOWER_CASE
52
+
53
+ tokens = @parser.parse("SELECT")
54
+ @fmt.modify_keyword_case(tokens)
55
+ assert_equal(
56
+ strip_indent(
57
+ <<-EOB
58
+ keyword (select)
59
+ EOB
60
+ ),
61
+ _format(tokens)
62
+ )
63
+ end
101
64
  end
102
65
 
103
-
104
- def test_remove_symbol_side_space
105
- msg = "remove_symbol_side_space - "
106
-
107
- ########
108
- tokens = @parser.parse("a (b")
109
- @fmt.remove_symbol_side_space(tokens)
110
- assert_equals(
111
- msg + "",
112
- strip_indent(
113
- <<-EOB
114
- name (a)
115
- symbol (()
116
- name (b)
117
- EOB
118
- ),
119
- _format(tokens)
120
- )
121
-
122
66
 
123
- ########
124
- tokens = @parser.parse("a( b")
125
- @fmt.remove_symbol_side_space(tokens)
126
- assert_equals(
127
- msg + "", strip_indent(
128
- <<-EOB
129
- name (a)
130
- symbol (()
131
- name (b)
132
- EOB
133
- ),
134
- _format(tokens)
135
- )
136
-
137
-
138
- ########
139
- tokens = @parser.parse("a ( b")
140
- @fmt.remove_symbol_side_space(tokens)
141
- assert_equals(
142
- msg + "",
143
- strip_indent(
144
- <<-EOB
145
- name (a)
146
- symbol (()
147
- name (b)
148
- EOB
149
- ),
150
- _format(tokens)
151
- )
67
+ sub_test_case "concat_operator_for_oracle" do
68
+ test "length is less than 3, should do nothing" do
69
+ tokens = @parser.parse("a+")
70
+ @fmt.concat_operator_for_oracle(tokens)
71
+ assert_equal(
72
+ strip_indent(
73
+ <<-EOB
74
+ name (a)
75
+ symbol (+)
76
+ EOB
77
+ ),
78
+ _format(tokens)
79
+ )
80
+ end
81
+
82
+ test "basic" do
83
+ tokens = @parser.parse("(+)")
84
+ @fmt.concat_operator_for_oracle(tokens)
85
+ assert_equal(
86
+ strip_indent(
87
+ <<-EOB
88
+ symbol ((+))
89
+ EOB
90
+ ),
91
+ _format(tokens)
92
+ )
93
+ end
94
+
95
+ test "format_list" do
96
+ tokens = @parser.parse("(+)")
97
+ tokens = @fmt.format_list(tokens)
98
+ assert_equal(
99
+ strip_indent(
100
+ <<-EOB
101
+ symbol ((+))
102
+ EOB
103
+ ),
104
+ _format(tokens)
105
+ )
106
+ end
152
107
  end
153
-
154
-
155
- def test_special_treatment_for_parenthesis_with_one_element
156
- msg = "special_treatment_for_parenthesis_with_one_element - "
157
-
158
- ########
159
- tokens = @parser.parse("( 1 )")
160
- @fmt.special_treatment_for_parenthesis_with_one_element(tokens)
161
- assert_equals(
162
- msg + "one element, should not separate",
163
- strip_indent(
164
- <<-EOB
165
- symbol ((1))
166
- EOB
167
- ),
168
- _format(tokens)
169
- )
170
108
 
171
109
 
172
- ########
173
- tokens = @parser.parse("(1,2)")
174
- @fmt.special_treatment_for_parenthesis_with_one_element(tokens)
175
- assert_equals(
176
- msg + "more than one element, should separate",
177
- strip_indent(
178
- <<-EOB
179
- symbol (()
180
- value (1)
181
- symbol (,)
182
- value (2)
183
- symbol ())
184
- EOB
185
- ),
186
- _format(tokens)
187
- )
110
+ sub_test_case "remove_symbol_side_space" do
111
+ test "a (b" do
112
+ tokens = @parser.parse("a (b")
113
+ @fmt.remove_symbol_side_space(tokens)
114
+ assert_equal(
115
+ strip_indent(
116
+ <<-EOB
117
+ name (a)
118
+ symbol (()
119
+ name (b)
120
+ EOB
121
+ ),
122
+ _format(tokens)
123
+ )
124
+ end
125
+
126
+ test "a( b" do
127
+ tokens = @parser.parse("a( b")
128
+ @fmt.remove_symbol_side_space(tokens)
129
+ assert_equal(
130
+ strip_indent(
131
+ <<-EOB
132
+ name (a)
133
+ symbol (()
134
+ name (b)
135
+ EOB
136
+ ),
137
+ _format(tokens)
138
+ )
139
+ end
140
+
141
+ test "a ( b" do
142
+ tokens = @parser.parse("a ( b")
143
+ @fmt.remove_symbol_side_space(tokens)
144
+ assert_equal(
145
+ strip_indent(
146
+ <<-EOB
147
+ name (a)
148
+ symbol (()
149
+ name (b)
150
+ EOB
151
+ ),
152
+ _format(tokens)
153
+ )
154
+ end
188
155
  end
189
-
190
156
 
191
- def test_insert_space_between_tokens
192
- msg = "insert_space_between_tokens - "
193
157
 
194
- ########
195
- tokens = @parser.parse("a=")
196
- @fmt.insert_space_between_tokens(tokens)
197
- assert_equals(msg,
198
- strip_indent(
199
- <<-EOB
200
- name (a)
201
- space ( )
202
- symbol (=)
203
- EOB
204
- ),
205
- _format(tokens)
206
- )
207
-
208
- ########
209
- tokens = @parser.parse("=b")
210
- @fmt.insert_space_between_tokens(tokens)
211
- assert_equals(msg,
212
- strip_indent(
213
- <<-EOB
214
- symbol (=)
215
- space ( )
216
- name (b)
217
- EOB
218
- ),
219
- _format(tokens)
220
- )
158
+ sub_test_case "special_treatment_for_parenthesis_with_one_element" do
159
+ test "one element, should not separate" do
160
+ tokens = @parser.parse("( 1 )")
161
+ @fmt.special_treatment_for_parenthesis_with_one_element(tokens)
162
+ assert_equal(
163
+ strip_indent(
164
+ <<-EOB
165
+ symbol ((1))
166
+ EOB
167
+ ),
168
+ _format(tokens)
169
+ )
170
+ end
171
+
172
+ test "more than one element, should separate" do
173
+ tokens = @parser.parse("(1,2)")
174
+ @fmt.special_treatment_for_parenthesis_with_one_element(tokens)
175
+ assert_equal(
176
+ strip_indent(
177
+ <<-EOB
178
+ symbol (()
179
+ value (1)
180
+ symbol (,)
181
+ value (2)
182
+ symbol ())
183
+ EOB
184
+ ),
185
+ _format(tokens)
186
+ )
187
+ end
221
188
  end
222
189
 
223
-
224
- def test_insert_return_and_indent
225
- msg = "insert_return_and_indent - "
226
-
227
- ########
228
- tokens = @parser.parse("foo bar")
229
-
230
- index, indent_depth = 1, 1
231
-
232
- assert_equals(
233
- msg + "before",
234
- strip_indent(
235
- <<-EOB
236
- name (foo)
237
- space ( )
238
- name (bar)
239
- EOB
240
- ),
241
- _format(tokens)
242
- )
243
-
244
- result = @fmt.insert_return_and_indent(tokens, index, indent_depth)
245
-
246
- assert_equals(
247
- msg + "index: #{index} / indent depth: #{indent_depth}",
248
- strip_indent(
249
- <<-EOB
250
- name (foo)
251
- space (\n#{INDENT_STR})
252
- name (bar)
253
- EOB
254
- ),
255
- _format(tokens)
256
- )
257
-
258
- ########
259
- # msg = "" #"後の空白を置き換え"
260
- tokens = @parser.parse("select foo")
261
-
262
- index, indent_depth = 1, 1
263
-
264
- assert_equals(
265
- msg + "before",
266
- strip_indent(
267
- <<-EOB
268
- keyword (select)
269
- space ( )
270
- name (foo)
271
- EOB
272
- ),
273
- _format(tokens)
274
- )
275
-
276
- result = @fmt.insert_return_and_indent(tokens, index, indent_depth)
277
-
278
- assert_equals(
279
- msg + "#{msg}: index: #{index} / indent depth: #{indent_depth}",
280
- strip_indent(
281
- <<-EOB
282
- keyword (select)
283
- space (\n#{INDENT_STR})
284
- name (foo)
285
- EOB
286
- ),
287
- _format(tokens)
288
- )
289
-
290
- ########
291
- msg = "" #"前の空白を置き換え"
292
- tokens = @parser.parse("select foo")
293
- index, indent_depth = 2, 1
294
-
295
- assert_equals(
296
- msg + "before",
297
- strip_indent(
298
- <<-EOB
299
- keyword (select)
300
- space ( )
301
- name (foo)
302
- EOB
303
- ),
304
- _format(tokens)
305
- )
306
-
307
- result = @fmt.insert_return_and_indent(tokens, index, indent_depth)
308
- assert_equals(
309
- msg + "", 0, result)
310
-
311
- assert_equals(
312
- msg + "#{msg}: index: #{index} / indent depth: #{indent_depth}",
313
- strip_indent(
314
- <<-EOB
315
- keyword (select)
316
- space (\n#{INDENT_STR})
317
- name (foo)
318
- EOB
319
- ),
320
- _format(tokens)
321
- )
322
-
323
- ########
324
- msg = "indent depth = 2"
325
- tokens = @parser.parse("foo bar")
326
- index, indent_depth = 1, 2
327
-
328
- assert_equals(
329
- msg + "before",
330
- strip_indent(
331
- <<-EOB
332
- name (foo)
333
- space ( )
334
- name (bar)
335
- EOB
336
- ),
337
- _format(tokens)
338
- )
339
-
340
- result = @fmt.insert_return_and_indent(tokens, index, indent_depth)
341
-
342
- assert_equals(
343
- msg + "#{msg}: index: #{index} / indent depth: #{indent_depth}",
344
- strip_indent(
345
- <<-EOB
346
- name (foo)
347
- space (\n#{INDENT_STR}#{INDENT_STR})
348
- name (bar)
349
- EOB
350
- ),
351
- _format(tokens)
352
- )
353
-
354
- ########
355
- msg = "kw, nl, kw"
356
- tokens = @parser.parse("select\ncase")
357
190
 
358
- assert_equals(
359
- msg + "",
360
- strip_indent(
361
- <<-EOB
362
- keyword (select)
363
- space (\n)
364
- keyword (case)
365
- EOB
366
- ),
367
- _format(tokens)
368
- )
191
+ sub_test_case "insert_space_between_tokens" do
192
+ test "a=" do
193
+ tokens = @parser.parse("a=")
194
+ @fmt.insert_space_between_tokens(tokens)
195
+ assert_equal(
196
+ strip_indent(
197
+ <<-EOB
198
+ name (a)
199
+ space ( )
200
+ symbol (=)
201
+ EOB
202
+ ),
203
+ _format(tokens)
204
+ )
205
+ end
206
+
207
+ test "=b" do
208
+ tokens = @parser.parse("=b")
209
+ @fmt.insert_space_between_tokens(tokens)
210
+ assert_equal(
211
+ strip_indent(
212
+ <<-EOB
213
+ symbol (=)
214
+ space ( )
215
+ name (b)
216
+ EOB
217
+ ),
218
+ _format(tokens)
219
+ )
220
+ end
221
+ end
369
222
 
370
- ########
371
- =begin
372
- msg = "FROM の前で改行"
373
223
 
374
- assert_equals(
375
- msg + "",
376
- strip_indent(
377
- <<-EOB
378
- SELECT
379
- <-indent-><-indent->aa
380
- <-indent-><-indent->,bb
381
- <-indent-><-indent->,cc
382
- <-indent-><-indent->,dd
383
- <-indent-><-indent->,ee
384
- <-indent->FROM
385
- <-indent-><-indent->foo
386
- ;
387
- EOB
388
- ),
389
- # _format(tokens),
390
- @fmt.format("SELECT aa ,bb ,cc ,dd ,ee FROM foo;")
391
- )
392
- =end
393
-
394
- # ########
395
- # msg = "指定した index に対して tokens[index] が存在するので 1 を返すべき"
396
- # 間違い。tokens[index] が存在していても 1 を返すとは限らない。
397
- # tokens = parser.parse("foo bar")
398
- # #pp tokens
399
- # index = 1
400
- # result = @fmt.insert_return_and_indent(tokens, index, 1)
401
-
402
- # assert_equals(msg + "", 1, result, msg)
403
-
404
- ########
405
- msg = "指定した index に対して tokens[index] が存在しないので 0 を返すべき"
406
- tokens = @parser.parse("foo bar")
407
-
408
- index = 10
409
- result = @fmt.insert_return_and_indent(tokens, index, 1)
410
-
411
- assert_equals(msg + "", 0, result)
224
+ sub_test_case "insert_return_and_indent" do
225
+ test "basic" do
226
+ msg = "basic - "
227
+ tokens = @parser.parse("foo bar")
228
+
229
+ index, indent_depth = 1, 1
230
+
231
+ assert_equals(
232
+ msg + "before",
233
+ strip_indent(
234
+ <<-EOB
235
+ name (foo)
236
+ space ( )
237
+ name (bar)
238
+ EOB
239
+ ),
240
+ _format(tokens)
241
+ )
242
+
243
+ result = @fmt.insert_return_and_indent(tokens, index, indent_depth)
244
+
245
+ assert_equals(
246
+ msg + "index: #{index} / indent depth: #{indent_depth}",
247
+ strip_indent(
248
+ <<-EOB
249
+ name (foo)
250
+ space (\n#{INDENT_STR})
251
+ name (bar)
252
+ EOB
253
+ ),
254
+ _format(tokens)
255
+ )
256
+ end
257
+
258
+ test "replace: after" do
259
+ msg = "replace: after - " # 後の空白を置き換え
260
+ tokens = @parser.parse("select foo")
261
+
262
+ index, indent_depth = 1, 1
263
+
264
+ assert_equals(
265
+ msg + "before",
266
+ strip_indent(
267
+ <<-EOB
268
+ keyword (select)
269
+ space ( )
270
+ name (foo)
271
+ EOB
272
+ ),
273
+ _format(tokens)
274
+ )
275
+
276
+ result = @fmt.insert_return_and_indent(tokens, index, indent_depth)
277
+
278
+ assert_equals(
279
+ msg + "#{msg}: index: #{index} / indent depth: #{indent_depth}",
280
+ strip_indent(
281
+ <<-EOB
282
+ keyword (select)
283
+ space (\n#{INDENT_STR})
284
+ name (foo)
285
+ EOB
286
+ ),
287
+ _format(tokens)
288
+ )
289
+ end
290
+
291
+ test "replace: before" do
292
+ msg = "replace: before - " # 前の空白を置き換え
293
+ tokens = @parser.parse("select foo")
294
+ index, indent_depth = 2, 1
295
+
296
+ assert_equals(
297
+ msg + "before",
298
+ strip_indent(
299
+ <<-EOB
300
+ keyword (select)
301
+ space ( )
302
+ name (foo)
303
+ EOB
304
+ ),
305
+ _format(tokens)
306
+ )
307
+
308
+ result = @fmt.insert_return_and_indent(tokens, index, indent_depth)
309
+ assert_equals(
310
+ msg + "", 0, result)
311
+
312
+ assert_equals(
313
+ msg + "#{msg}: index: #{index} / indent depth: #{indent_depth}",
314
+ strip_indent(
315
+ <<-EOB
316
+ keyword (select)
317
+ space (\n#{INDENT_STR})
318
+ name (foo)
319
+ EOB
320
+ ),
321
+ _format(tokens)
322
+ )
323
+ end
324
+
325
+ test "indent depth = 2" do
326
+ msg = "indent depth = 2 - "
327
+ tokens = @parser.parse("foo bar")
328
+ index, indent_depth = 1, 2
329
+
330
+ assert_equals(
331
+ msg + "before",
332
+ strip_indent(
333
+ <<-EOB
334
+ name (foo)
335
+ space ( )
336
+ name (bar)
337
+ EOB
338
+ ),
339
+ _format(tokens)
340
+ )
341
+
342
+ result = @fmt.insert_return_and_indent(tokens, index, indent_depth)
343
+
344
+ assert_equals(
345
+ msg + "#{msg}: index: #{index} / indent depth: #{indent_depth}",
346
+ strip_indent(
347
+ <<-EOB
348
+ name (foo)
349
+ space (\n#{INDENT_STR}#{INDENT_STR})
350
+ name (bar)
351
+ EOB
352
+ ),
353
+ _format(tokens)
354
+ )
355
+ end
356
+
357
+ test "kw, nl, kw" do
358
+ tokens = @parser.parse("select\ncase")
359
+
360
+ assert_equal(
361
+ strip_indent(
362
+ <<-EOB
363
+ keyword (select)
364
+ space (\n)
365
+ keyword (case)
366
+ EOB
367
+ ),
368
+ _format(tokens)
369
+ )
370
+ end
371
+
372
+ test "insert: return 1" do
373
+ tokens = [
374
+ token_new(:name, "foo"),
375
+ token_new(:name, "bar")
376
+ ]
377
+
378
+ index = 1
379
+ result = @fmt.insert_return_and_indent(tokens, index, 1)
380
+
381
+ assert_equal(1, result)
382
+ end
383
+
384
+ test "replace: return 0" do
385
+ tokens = [
386
+ token_new(:name, "foo"),
387
+ token_new(:space, " "),
388
+ token_new(:name, "bar")
389
+ ]
390
+
391
+ index = 2
392
+ result = @fmt.insert_return_and_indent(tokens, index, 1)
393
+
394
+ assert_equal(0, result)
395
+ end
396
+
397
+ test "out of bounds" do
398
+ tokens = [
399
+ token_new(:name, "foo"),
400
+ token_new(:space, " "),
401
+ token_new(:name, "bar")
402
+ ]
403
+
404
+ index = 10
405
+ result = @fmt.insert_return_and_indent(tokens, index, 1)
406
+
407
+ assert_equal(0, result)
408
+ end
412
409
  end ## insert_return_and_indent
413
410
 
414
411
 
415
- def test_format
416
- msg = "format - "
417
-
418
- ########
419
- func_name = "TEST_FUNCTION"
420
- @rule.function_names << func_name
421
-
422
- assert_equals(
423
- msg + "function with parenthesis",
424
- strip_indent(
425
- <<-EOB
426
- SELECT
427
- <-indent-><-indent->#{func_name}( * )
428
- EOB
429
- ),
430
- @fmt.format("select #{func_name}(*)")
431
- )
432
-
433
- @rule.function_names.delete func_name
434
-
435
- ########
436
- assert_equals(
437
- msg + "Next line of single commnet",
438
- strip_indent(
439
- <<-EOB
440
- SELECT
441
- <-indent-><-indent->-- comment
442
- <-indent-><-indent->name
443
- EOB
444
- ),
445
- @fmt.format(strip_indent(
446
- <<-EOB
447
- select
448
- -- comment
449
- name
450
- EOB
451
- ))
452
- )
453
-
454
- ########
455
- assert_equals(
456
- msg + "new line after single line comment",
457
- strip_indent(
458
- <<-EOB
459
- --a
460
- b
461
- EOB
462
- ),
463
- @fmt.format(strip_indent(
464
- <<-EOB
465
- --a
466
- b
467
- EOB
468
- ))
469
- );
470
-
471
- ########
472
- assert_equals(
473
- msg + "two line breaks after semicolon",
474
- strip_indent(
475
- <<-EOB
476
- a
477
- ;
478
-
479
- b
480
- EOB
481
- ),
482
- @fmt.format(strip_indent(
483
- <<-EOB
484
- a;b
485
- EOB
486
- ))
487
- );
488
-
489
- ########
490
- assert_equals(
491
- msg + "two line breaks after semicolon",
492
- strip_indent(
493
- <<-EOB
494
- a
495
- ;
496
- EOB
497
- ),
498
- @fmt.format("a;")
499
- )
412
+ sub_test_case "format" do
413
+ test "function with parenthesis" do
414
+ func_name = "TEST_FUNCTION"
415
+ @rule.function_names << func_name
416
+
417
+ assert_equal(
418
+ strip_indent(
419
+ <<-EOB
420
+ SELECT
421
+ <-indent-><-indent->#{func_name}( * )
422
+ EOB
423
+ ),
424
+ @fmt.format("select #{func_name}(*)")
425
+ )
426
+
427
+ @rule.function_names.delete func_name
428
+ end
429
+
430
+ test "Next line of single comment" do
431
+ assert_equal(
432
+ strip_indent(
433
+ <<-EOB
434
+ SELECT
435
+ <-indent-><-indent->-- comment
436
+ <-indent-><-indent->name
437
+ EOB
438
+ ),
439
+ @fmt.format(strip_indent(
440
+ <<-EOB
441
+ select
442
+ -- comment
443
+ name
444
+ EOB
445
+ ))
446
+ )
447
+ end
448
+
449
+ test "new line after single line comment" do
450
+ assert_equal(
451
+ strip_indent(
452
+ <<-EOB
453
+ --a
454
+ b
455
+ EOB
456
+ ),
457
+ @fmt.format(strip_indent(
458
+ <<-EOB
459
+ --a
460
+ b
461
+ EOB
462
+ ))
463
+ )
464
+ end
465
+
466
+ test "two line breaks after semicolon" do
467
+ assert_equal(
468
+ strip_indent(
469
+ <<-EOB
470
+ a
471
+ ;
472
+
473
+ b
474
+ EOB
475
+ ),
476
+ @fmt.format(strip_indent(
477
+ <<-EOB
478
+ a;b
479
+ EOB
480
+ ))
481
+ )
482
+ end
483
+
484
+ test "no line breaks after semicolon" do
485
+ assert_equal(
486
+ strip_indent(
487
+ <<-EOB
488
+ a
489
+ ;
490
+ EOB
491
+ ),
492
+ @fmt.format("a;")
493
+ )
494
+ end
500
495
  end
501
496
 
502
497
  def test_format_between
@@ -512,77 +507,59 @@ class TestAnbtSqlFormatter < Test::Unit::TestCase
512
507
  end
513
508
 
514
509
 
515
- def test_split_to_statements
516
- msg = "split_to_statements - "
517
-
518
- ########
519
- tokens = @parser.parse("a;b")
520
-
521
- assert_equals(
522
- msg + "first statement",
523
- "a",
524
- @fmt.split_to_statements(tokens)[0][0].string
525
- )
526
- assert_equals(
527
- msg + "second statement",
528
- "b",
529
- @fmt.split_to_statements(tokens)[1][0].string
530
- )
531
-
532
- ########
533
- tokens = @parser.parse(";")
534
- statements = @fmt.split_to_statements(tokens)
535
- assert_equals(
536
- msg,
537
- [],
538
- statements[0]
539
- )
540
- assert_equals(
541
- msg,
542
- [],
543
- statements[1]
544
- )
545
-
546
- ########
547
- tokens = @parser.parse("a;")
548
- statements = @fmt.split_to_statements(tokens)
549
- assert_equals(
550
- msg,
551
- "name (a)",
552
- _format( statements[0] )
553
- )
554
- assert_equals(
555
- msg,
556
- [],
557
- statements[1]
558
- )
559
-
560
- ########
561
- tokens = @parser.parse(";a")
562
- statements = @fmt.split_to_statements(tokens)
563
- assert_equals(
564
- msg,
565
- [],
566
- statements[0]
567
- )
568
- assert_equals(
569
- msg,
570
- "name (a)",
571
- _format( statements[1] )
572
- )
573
-
574
- ########
575
- tokens = @parser.parse("a;b")
576
- statements = @fmt.split_to_statements(tokens)
577
- assert_equals(
578
- msg,
579
- "name (a)",
580
- _format( statements[0] )
581
- )
582
- assert_equals(
583
- msg,
584
- "name (b)",
585
- _format( statements[1] )
586
- )
510
+ sub_test_case "split_to_statements" do
511
+ test "a;b" do
512
+ tokens = @parser.parse("a;b")
513
+ statements = @fmt.split_to_statements(tokens)
514
+
515
+ assert_equal(2, statements.size)
516
+ assert_equal(
517
+ "name (a)",
518
+ _format( statements[0] )
519
+ )
520
+ assert_equal(
521
+ "name (b)",
522
+ _format( statements[1] )
523
+ )
524
+ end
525
+
526
+ test ";" do
527
+ tokens = @parser.parse(";")
528
+ statements = @fmt.split_to_statements(tokens)
529
+ assert_equal(
530
+ [],
531
+ statements[0]
532
+ )
533
+ assert_equal(
534
+ [],
535
+ statements[1]
536
+ )
537
+ end
538
+
539
+ test "a;" do
540
+ tokens = @parser.parse("a;")
541
+ statements = @fmt.split_to_statements(tokens)
542
+ assert_equal(
543
+ "name (a)",
544
+ _format( statements[0] )
545
+ )
546
+ assert_equal(
547
+ [],
548
+ statements[1]
549
+ )
550
+ end
551
+
552
+ test ";a" do
553
+ tokens = @parser.parse(";a")
554
+ statements = @fmt.split_to_statements(tokens)
555
+ assert_equal(
556
+ [],
557
+ statements[0]
558
+ )
559
+ assert_equal(
560
+ "name (a)",
561
+ _format( statements[1] )
562
+ )
563
+ end
587
564
  end
588
565
  end