anbt-sql-formatter 0.0.1 → 0.0.2

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