sorcerer 0.1.0 → 0.2.0

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 (4) hide show
  1. data/lib/sorcerer/resource.rb +521 -459
  2. data/lib/sorcerer/version.rb +1 -1
  3. data/test/sorcerer/resource_test.rb +118 -71
  4. metadata +2 -2
data/lib/sorcerer/resource.rb CHANGED
@@ -18,11 +18,16 @@ module Sorcerer
18
18
 
19
19
  def initialize(sexp, options={})
20
20
  @sexp = sexp
21
- @source = ''
22
21
  @debug = options[:debug]
23
- @multiline = options[:multiline]
22
+ @indent = options[:indent] || 0
23
+ @indent = 2 if @indent && ! @indent.is_a?(Integer)
24
+ @multiline = options[:multiline] || indenting?
25
+
26
+ @source = ''
24
27
  @word_level = 0
25
28
  @stack = []
29
+ @level = 0
30
+ @virgin_line = true
26
31
  end
27
32
 
28
33
  def source
@@ -31,6 +36,32 @@ module Sorcerer
31
36
  @source
32
37
  end
33
38
 
39
+ private
40
+
41
+ def multiline?
42
+ @multiline
43
+ end
44
+
45
+ def indenting?
46
+ @indent > 0
47
+ end
48
+
49
+ def indent
50
+ old_level = @level
51
+ @level += 1
52
+ yield
53
+ ensure
54
+ @level = old_level
55
+ end
56
+
57
+ def outdent
58
+ old_level = @level
59
+ @level -= 1
60
+ yield
61
+ ensure
62
+ @level = old_level
63
+ end
64
+
34
65
  def sexp?(obj)
35
66
  obj && obj.respond_to?(:each) && obj.first.is_a?(Symbol)
36
67
  end
@@ -48,8 +79,13 @@ module Sorcerer
48
79
  puts "----------------------------------------------------------"
49
80
  pp sexp
50
81
  end
82
+ apply_handler(sexp, handler)
83
+ end
84
+
85
+ def apply_handler(sexp, handler)
51
86
  @stack.push(sexp.first)
52
- handler.call(self, sexp)
87
+ instance_exec(sexp, &handler)
88
+ ensure
53
89
  @stack.pop
54
90
  end
55
91
 
@@ -57,14 +93,16 @@ module Sorcerer
57
93
  emit(" ")
58
94
  emit(do_word)
59
95
  resource(sexp[1]) if sexp[1] # Arguments
60
- if ! void?(sexp[2])
61
- soft_newline
62
- resource(sexp[2]) # Statements
63
- end
64
- if !void?(sexp[2])
65
- soft_newline
66
- else
67
- emit(" ")
96
+ indent do
97
+ if ! void?(sexp[2])
98
+ soft_newline
99
+ resource(sexp[2]) # Statements
100
+ end
101
+ if !void?(sexp[2])
102
+ soft_newline
103
+ else
104
+ emit(" ")
105
+ end
68
106
  end
69
107
  emit(end_word)
70
108
  end
@@ -87,7 +125,13 @@ module Sorcerer
87
125
  end
88
126
 
89
127
  def emit(string)
90
- puts "EMITTING '#{string}' (#{last_handler})" if @debug
128
+ emit_raw(" " * @level) if indenting? && virgin_line?
129
+ @virgin_line = false
130
+ emit_raw(string.to_s)
131
+ end
132
+
133
+ def emit_raw(string)
134
+ puts "EMITTING '#{string}' (#{last_handler}) [#{@level}]" if @debug
91
135
  @source << string.to_s
92
136
  end
93
137
 
@@ -95,6 +139,14 @@ module Sorcerer
95
139
  raise "Handler for #{sexp.first} not implemented (#{sexp.inspect})"
96
140
  end
97
141
 
142
+ def emit_then
143
+ if multiline?
144
+ soft_newline
145
+ else
146
+ emit(" then ")
147
+ end
148
+ end
149
+
98
150
  def emit_separator(sep, first)
99
151
  emit(sep) unless first
100
152
  false
@@ -151,17 +203,18 @@ module Sorcerer
151
203
  sexp == VOID_BODY2
152
204
  end
153
205
 
154
- def multiline?
155
- @multiline
156
- end
157
-
158
206
  def last_handler
159
207
  @stack.last
160
208
  end
161
209
 
210
+ def virgin_line?
211
+ @virgin_line
212
+ end
213
+
162
214
  def newline
163
215
  if multiline?
164
216
  emit("\n")
217
+ @virgin_line = true
165
218
  else
166
219
  emit("; ")
167
220
  end
@@ -169,7 +222,7 @@ module Sorcerer
169
222
 
170
223
  def soft_newline
171
224
  if multiline?
172
- emit("\n")
225
+ newline
173
226
  else
174
227
  emit(" ")
175
228
  end
@@ -182,7 +235,7 @@ module Sorcerer
182
235
  ']' => '[',
183
236
  }
184
237
 
185
- def self.determine_regexp_delimiters(sexp)
238
+ def determine_regexp_delimiters(sexp)
186
239
  sym, end_delim, other = sexp
187
240
  fail UnexpectedSexpError, "Expected :@regexp_end, got #{sym.inspect}" unless sym == :@regexp_end
188
241
  end_delim_char = end_delim[0]
@@ -193,586 +246,595 @@ module Sorcerer
193
246
  [first_delim, end_delim]
194
247
  end
195
248
 
196
- NYI = lambda { |src, sexp| src.nyi(sexp) }
197
- DBG = lambda { |src, sexp| pp(sexp) }
198
- NOOP = lambda { |src, sexp| }
199
- SPACE = lambda { |src, sexp| src.emit(" ") }
200
- PASS1 = lambda { |src, sexp| src.resource(sexp[1]) }
201
- PASS2 = lambda { |src, sexp| src.resource(sexp[2]) }
202
- EMIT1 = lambda { |src, sexp| src.emit(sexp[1]) }
249
+ NYI = lambda { |sexp| nyi(sexp) }
250
+ DBG = lambda { |sexp| pp(sexp) }
251
+ NOOP = lambda { |sexp| }
252
+ SPACE = lambda { |sexp| emit(" ") }
253
+ PASS1 = lambda { |sexp| resource(sexp[1]) }
254
+ PASS2 = lambda { |sexp| resource(sexp[2]) }
255
+ EMIT1 = lambda { |sexp| emit(sexp[1]) }
203
256
 
204
257
  HANDLERS = {
205
258
  # parser keywords
206
259
 
207
- :BEGIN => lambda { |src, sexp|
208
- src.emit("BEGIN {")
209
- if src.void?(sexp[1])
210
- src.emit " }"
260
+ :BEGIN => lambda { |sexp|
261
+ emit("BEGIN {")
262
+ if void?(sexp[1])
263
+ emit " }"
211
264
  else
212
- src.soft_newline
213
- src.resource(sexp[1])
214
- src.soft_newline
215
- src.emit("}")
265
+ soft_newline
266
+ indent do
267
+ resource(sexp[1])
268
+ soft_newline
269
+ end
270
+ emit("}")
216
271
  end
217
272
  },
218
- :END => lambda { |src, sexp|
219
- src.emit("END {")
220
- if src.void?(sexp[1])
221
- src.emit(" }")
273
+ :END => lambda { |sexp|
274
+ emit("END {")
275
+ if void?(sexp[1])
276
+ emit(" }")
222
277
  else
223
- src.soft_newline
224
- src.resource(sexp[1])
225
- src.soft_newline
226
- src.emit("}")
278
+ soft_newline
279
+ indent do
280
+ resource(sexp[1])
281
+ soft_newline
282
+ end
283
+ emit("}")
227
284
  end
228
285
  },
229
- :alias => lambda { |src, sexp|
230
- src.emit("alias ")
231
- src.resource(sexp[1])
232
- src.emit(" ")
233
- src.resource(sexp[2])
286
+ :alias => lambda { |sexp|
287
+ emit("alias ")
288
+ resource(sexp[1])
289
+ emit(" ")
290
+ resource(sexp[2])
234
291
  },
235
292
  :alias_error => NYI,
236
- :aref => lambda { |src, sexp|
237
- src.resource(sexp[1])
238
- src.emit("[")
239
- src.resource(sexp[2])
240
- src.emit("]")
241
- },
242
- :aref_field => lambda { |src, sexp|
243
- src.resource(sexp[1])
244
- src.emit("[")
245
- src.resource(sexp[2])
246
- src.emit("]")
293
+ :aref => lambda { |sexp|
294
+ resource(sexp[1])
295
+ emit("[")
296
+ resource(sexp[2])
297
+ emit("]")
298
+ },
299
+ :aref_field => lambda { |sexp|
300
+ resource(sexp[1])
301
+ emit("[")
302
+ resource(sexp[2])
303
+ emit("]")
247
304
  },
248
305
  :arg_ambiguous => NYI,
249
- :arg_paren => lambda { |src, sexp|
250
- src.emit("(")
251
- src.resource(sexp[1]) if sexp[1]
252
- src.emit(")")
306
+ :arg_paren => lambda { |sexp|
307
+ emit("(")
308
+ resource(sexp[1]) if sexp[1]
309
+ emit(")")
253
310
  },
254
- :args_add => lambda { |src, sexp|
255
- src.resource(sexp[1])
311
+ :args_add => lambda { |sexp|
312
+ resource(sexp[1])
256
313
  if sexp[1].first != :args_new
257
- src.emit(", ")
314
+ emit(", ")
258
315
  end
259
- src.resource(sexp[2])
316
+ resource(sexp[2])
260
317
  },
261
- :args_add_block => lambda { |src, sexp|
262
- src.resource(sexp[1])
318
+ :args_add_block => lambda { |sexp|
319
+ resource(sexp[1])
263
320
  if sexp[2]
264
321
  if sexp[1].first != :args_new
265
- src.emit(", ")
322
+ emit(", ")
266
323
  end
267
324
  if sexp[2]
268
- src.emit("&")
269
- src.resource(sexp[2])
325
+ emit("&")
326
+ resource(sexp[2])
270
327
  end
271
328
  end
272
329
  },
273
- :args_add_star => lambda { |src, sexp|
274
- src.resource(sexp[1])
330
+ :args_add_star => lambda { |sexp|
331
+ resource(sexp[1])
275
332
  if sexp[1].first != :args_new
276
- src.emit(", ")
333
+ emit(", ")
277
334
  end
278
- src.emit("*")
279
- src.resource(sexp[2])
335
+ emit("*")
336
+ resource(sexp[2])
280
337
  },
281
338
  :args_new => NOOP,
282
339
  :args_prepend => NYI,
283
- :array => lambda { |src, sexp|
284
- src.emit("[")
285
- src.resource(sexp[1]) if sexp[1]
286
- src.emit("]")
340
+ :array => lambda { |sexp|
341
+ emit("[")
342
+ resource(sexp[1]) if sexp[1]
343
+ emit("]")
287
344
  },
288
- :assign => lambda { |src, sexp|
289
- src.resource(sexp[1])
290
- src.emit(" = ")
291
- src.resource(sexp[2])
345
+ :assign => lambda { |sexp|
346
+ resource(sexp[1])
347
+ emit(" = ")
348
+ resource(sexp[2])
292
349
  },
293
350
  :assign_error => NYI,
294
- :assoc_new => lambda { |src, sexp|
295
- src.resource(sexp[1])
296
- src.emit(" => ")
297
- src.resource(sexp[2])
351
+ :assoc_new => lambda { |sexp|
352
+ resource(sexp[1])
353
+ emit(" => ")
354
+ resource(sexp[2])
298
355
  },
299
- :assoclist_from_args => lambda { |src, sexp|
356
+ :assoclist_from_args => lambda { |sexp|
300
357
  first = true
301
358
  sexp[1].each do |sx|
302
- src.emit(", ") unless first
359
+ emit(", ") unless first
303
360
  first = false
304
- src.resource(sx)
361
+ resource(sx)
305
362
  end
306
363
  },
307
- :bare_assoc_hash => lambda { |src, sexp|
364
+ :bare_assoc_hash => lambda { |sexp|
308
365
  first = true
309
366
  sexp[1].each do |sx|
310
- src.emit(", ") unless first
367
+ emit(", ") unless first
311
368
  first = false
312
- src.resource(sx)
369
+ resource(sx)
313
370
  end
314
371
  },
315
- :begin => lambda { |src, sexp|
316
- src.emit("begin")
317
- if src.void?(sexp[1])
318
- src.emit(" ")
319
- else
320
- src.soft_newline
321
- src.resource(sexp[1])
372
+ :begin => lambda { |sexp|
373
+ emit("begin")
374
+ indent do
375
+ if void?(sexp[1])
376
+ emit(" ")
377
+ else
378
+ soft_newline
379
+ resource(sexp[1])
380
+ end
322
381
  end
323
- src.emit("end")
382
+ emit("end")
324
383
  },
325
- :binary => lambda { |src, sexp|
326
- src.resource(sexp[1])
327
- src.emit(" #{sexp[2]} ")
328
- src.resource(sexp[3])
384
+ :binary => lambda { |sexp|
385
+ resource(sexp[1])
386
+ emit(" #{sexp[2]} ")
387
+ resource(sexp[3])
329
388
  },
330
- :block_var => lambda { |src, sexp|
331
- src.emit(" |")
332
- src.resource(sexp[1])
333
- src.emit("|")
389
+ :block_var => lambda { |sexp|
390
+ emit(" |")
391
+ resource(sexp[1])
392
+ emit("|")
334
393
  },
335
394
  :block_var_add_block => NYI,
336
395
  :block_var_add_star => NYI,
337
- :blockarg => lambda { |src, sexp|
338
- src.emit("&")
339
- src.resource(sexp[1])
340
- },
341
- :body_stmt => lambda { |src, sexp|
342
- src.resource(sexp[1]) # Main Body
343
- src.newline unless src.void?(sexp[1])
344
- src.resource(sexp[2]) if sexp[2] # Rescue
345
- src.resource(sexp[4]) if sexp[4] # Ensure
346
- },
347
- :brace_block => lambda { |src, sexp|
348
- src.emit_block(sexp, "{", "}")
349
- },
350
- :break => lambda { |src, sexp|
351
- src.emit("break")
352
- src.emit(" ") unless sexp[1] == [:args_new]
353
- src.resource(sexp[1])
354
- },
355
- :call => lambda { |src, sexp|
356
- src.resource(sexp[1])
357
- src.emit(sexp[2])
358
- src.resource(sexp[3]) unless sexp[3] == :call
359
- },
360
- :case => lambda { |src, sexp|
361
- src.emit("case ")
362
- src.resource(sexp[1])
363
- src.soft_newline
364
- src.resource(sexp[2])
365
- src.newline
366
- src.emit("end")
367
- },
368
- :class => lambda { |src, sexp|
369
- src.emit("class ")
370
- src.resource(sexp[1])
371
- if ! src.void?(sexp[2])
372
- src.emit " < "
373
- src.resource(sexp[2])
396
+ :blockarg => lambda { |sexp|
397
+ emit("&")
398
+ resource(sexp[1])
399
+ },
400
+ :body_stmt => lambda { |sexp|
401
+ resource(sexp[1]) # Main Body
402
+ newline unless void?(sexp[1])
403
+ resource(sexp[2]) if sexp[2] # Rescue
404
+ resource(sexp[4]) if sexp[4] # Ensure
405
+ },
406
+ :brace_block => lambda { |sexp|
407
+ emit_block(sexp, "{", "}")
408
+ },
409
+ :break => lambda { |sexp|
410
+ emit("break")
411
+ emit(" ") unless sexp[1] == [:args_new]
412
+ resource(sexp[1])
413
+ },
414
+ :call => lambda { |sexp|
415
+ resource(sexp[1])
416
+ emit(sexp[2])
417
+ resource(sexp[3]) unless sexp[3] == :call
418
+ },
419
+ :case => lambda { |sexp|
420
+ emit("case ")
421
+ resource(sexp[1])
422
+ soft_newline
423
+ indent do
424
+ resource(sexp[2])
425
+ newline
374
426
  end
375
- src.newline
376
- src.resource(sexp[3]) unless src.void?(sexp[3])
377
- src.emit("end")
427
+ emit("end")
428
+ },
429
+ :class => lambda { |sexp|
430
+ emit("class ")
431
+ resource(sexp[1])
432
+ if ! void?(sexp[2])
433
+ emit " < "
434
+ resource(sexp[2])
435
+ end
436
+ newline
437
+ indent do
438
+ resource(sexp[3]) unless void?(sexp[3])
439
+ end
440
+ emit("end")
378
441
  },
379
442
  :class_name_error => NYI,
380
- :command => lambda { |src, sexp|
381
- src.resource(sexp[1])
382
- src.emit(" ")
383
- src.resource(sexp[2])
443
+ :command => lambda { |sexp|
444
+ resource(sexp[1])
445
+ emit(" ")
446
+ resource(sexp[2])
384
447
  },
385
448
  :command_call => NYI,
386
- :const_path_field => lambda { |src, sexp|
387
- src.resource(sexp[1])
388
- src.emit("::")
389
- src.resource(sexp[2])
449
+ :const_path_field => lambda { |sexp|
450
+ resource(sexp[1])
451
+ emit("::")
452
+ resource(sexp[2])
390
453
  },
391
- :const_path_ref => lambda { |src, sexp|
392
- src.resource(sexp[1])
393
- src.emit("::")
394
- src.resource(sexp[2])
454
+ :const_path_ref => lambda { |sexp|
455
+ resource(sexp[1])
456
+ emit("::")
457
+ resource(sexp[2])
395
458
  },
396
459
  :const_ref => PASS1,
397
- :def => lambda { |src, sexp|
398
- src.emit("def ")
399
- src.resource(sexp[1])
400
- src.opt_parens(sexp[2])
401
- src.newline
402
- src.resource(sexp[3])
403
- src.emit("end")
404
- },
405
- :defined => lambda { |src, sexp|
406
- src.emit("defined?(")
407
- src.resource(sexp[1])
408
- src.emit(")")
460
+ :def => lambda { |sexp|
461
+ emit("def ")
462
+ resource(sexp[1])
463
+ opt_parens(sexp[2])
464
+ newline
465
+ indent do resource(sexp[3]) end
466
+ emit("end")
467
+ },
468
+ :defined => lambda { |sexp|
469
+ emit("defined?(")
470
+ resource(sexp[1])
471
+ emit(")")
409
472
  },
410
473
  :defs => NYI,
411
- :do_block => lambda { |src, sexp|
412
- src.emit_block(sexp, "do", "end")
413
- },
414
- :dot2 => lambda { |src, sexp|
415
- src.resource(sexp[1])
416
- src.emit("..")
417
- src.resource(sexp[2])
418
- },
419
- :dot3 => lambda { |src, sexp|
420
- src.resource(sexp[1])
421
- src.emit("...")
422
- src.resource(sexp[2])
423
- },
424
- :dyna_symbol => lambda { |src, sexp|
425
- src.emit(':"')
426
- src.resource(sexp[1])
427
- src.emit('"')
428
- },
429
- :else => lambda { |src, sexp|
430
- src.soft_newline
431
- src.emit("else")
432
- src.soft_newline
433
- src.resource(sexp[1])
434
- },
435
- :elsif => lambda { |src, sexp|
436
- src.soft_newline
437
- src.emit("elsif ")
438
- src.resource(sexp[1])
439
- if src.multiline?
440
- src.soft_newline
441
- else
442
- src.emit(" then ")
443
- end
444
- src.resource(sexp[2])
445
- src.resource(sexp[3]) if sexp[3]
474
+ :do_block => lambda { |sexp|
475
+ emit_block(sexp, "do", "end")
476
+ },
477
+ :dot2 => lambda { |sexp|
478
+ resource(sexp[1])
479
+ emit("..")
480
+ resource(sexp[2])
481
+ },
482
+ :dot3 => lambda { |sexp|
483
+ resource(sexp[1])
484
+ emit("...")
485
+ resource(sexp[2])
486
+ },
487
+ :dyna_symbol => lambda { |sexp|
488
+ emit(':"')
489
+ resource(sexp[1])
490
+ emit('"')
446
491
  },
447
- :ensure => lambda { |src, sexp|
448
- src.emit("ensure")
449
- if src.void?(sexp[1])
450
- src.soft_newline
492
+ :else => lambda { |sexp|
493
+ soft_newline
494
+ outdent do emit("else") end
495
+ soft_newline
496
+ resource(sexp[1])
497
+ },
498
+ :elsif => lambda { |sexp|
499
+ soft_newline
500
+ outdent do emit("elsif ") end
501
+ resource(sexp[1])
502
+ emit_then
503
+ resource(sexp[2])
504
+ resource(sexp[3]) if sexp[3]
505
+ },
506
+ :ensure => lambda { |sexp|
507
+ outdent do emit("ensure") end
508
+ if void?(sexp[1])
509
+ soft_newline
451
510
  else
452
- src.soft_newline
453
- src.resource(sexp[1])
454
- src.newline unless src.void?(sexp[1])
511
+ soft_newline
512
+ resource(sexp[1])
513
+ newline unless void?(sexp[1])
455
514
  end
456
515
  },
457
516
  :excessed_comma => NYI,
458
517
  :fcall => PASS1,
459
- :field => lambda { |src, sexp|
460
- src.resource(sexp[1])
461
- src.emit(sexp[2])
462
- src.resource(sexp[3])
463
- },
464
- :for => lambda { |src, sexp|
465
- src.emit("for ")
466
- src.resource(sexp[1])
467
- src.emit(" in ")
468
- src.resource(sexp[2])
469
- src.emit(" do ")
470
- unless src.void?(sexp[3])
471
- src.resource(sexp[3])
472
- src.emit(" ")
518
+ :field => lambda { |sexp|
519
+ resource(sexp[1])
520
+ emit(sexp[2])
521
+ resource(sexp[3])
522
+ },
523
+ :for => lambda { |sexp|
524
+ emit("for ")
525
+ resource(sexp[1])
526
+ emit(" in ")
527
+ resource(sexp[2])
528
+ newline
529
+ indent do
530
+ unless void?(sexp[3])
531
+ resource(sexp[3])
532
+ soft_newline
533
+ end
473
534
  end
474
- src.emit("end")
475
- },
476
- :hash => lambda { |src, sexp|
477
- src.emit("{")
478
- src.resource(sexp[1]) if sexp[1]
479
- src.emit("}")
480
- },
481
- :if => lambda { |src, sexp|
482
- src.emit("if ")
483
- src.resource(sexp[1])
484
- if src.multiline?
485
- src.newline
486
- else
487
- src.emit(" then ")
535
+ emit("end")
536
+ },
537
+ :hash => lambda { |sexp|
538
+ emit("{")
539
+ resource(sexp[1]) if sexp[1]
540
+ emit("}")
541
+ },
542
+ :if => lambda { |sexp|
543
+ emit("if ")
544
+ resource(sexp[1])
545
+ emit_then
546
+ indent do
547
+ resource(sexp[2])
548
+ resource(sexp[3]) if sexp[3]
549
+ soft_newline
488
550
  end
489
- src.resource(sexp[2])
490
- src.resource(sexp[3]) if sexp[3]
491
- src.soft_newline
492
- src.emit("end")
493
- },
494
- :if_mod => lambda { |src, sexp|
495
- src.resource(sexp[2])
496
- src.emit(" if ")
497
- src.resource(sexp[1])
498
- },
499
- :ifop => lambda { |src, sexp|
500
- src.resource(sexp[1])
501
- src.emit(" ? ")
502
- src.resource(sexp[2])
503
- src.emit(" : ")
504
- src.resource(sexp[3])
505
- },
506
- :lambda => lambda { |src, sexp|
507
- src.emit("->")
508
- src.resource(sexp[1])
509
- src.emit(" {")
510
- if ! src.void?(sexp[2])
511
- src.emit(" ")
512
- src.resource(sexp[2])
551
+ emit("end")
552
+ },
553
+ :if_mod => lambda { |sexp|
554
+ resource(sexp[2])
555
+ emit(" if ")
556
+ resource(sexp[1])
557
+ },
558
+ :ifop => lambda { |sexp|
559
+ resource(sexp[1])
560
+ emit(" ? ")
561
+ resource(sexp[2])
562
+ emit(" : ")
563
+ resource(sexp[3])
564
+ },
565
+ :lambda => lambda { |sexp|
566
+ emit("->")
567
+ resource(sexp[1])
568
+ emit(" {")
569
+ if ! void?(sexp[2])
570
+ soft_newline
571
+ resource(sexp[2])
513
572
  end
514
- src.emit(" ")
515
- src.emit("}")
573
+ if void?(sexp[2])
574
+ emit(" ")
575
+ else
576
+ soft_newline
577
+ end
578
+ emit("}")
516
579
  },
517
580
  :magic_comment => NYI,
518
- :massign => lambda { |src, sexp|
519
- src.resource(sexp[1])
520
- src.emit(" = ")
521
- src.resource(sexp[2])
522
- },
523
- :method_add_arg => lambda { |src, sexp|
524
- src.resource(sexp[1])
525
- src.resource(sexp[2])
526
- },
527
- :method_add_block => lambda { |src, sexp|
528
- src.resource(sexp[1])
529
- src.resource(sexp[2])
530
- },
531
- :mlhs_add => lambda { |src, sexp|
532
- src.resource(sexp[1])
533
- src.emit(", ") unless sexp[1] == [:mlhs_new]
534
- src.resource(sexp[2])
535
- },
536
- :mlhs_add_star => lambda { |src, sexp|
537
- src.resource(sexp[1])
538
- src.emit(", ") unless sexp[1] == [:mlhs_new]
539
- src.emit("*")
540
- src.resource(sexp[2])
581
+ :massign => lambda { |sexp|
582
+ resource(sexp[1])
583
+ emit(" = ")
584
+ resource(sexp[2])
585
+ },
586
+ :method_add_arg => lambda { |sexp|
587
+ resource(sexp[1])
588
+ resource(sexp[2])
589
+ },
590
+ :method_add_block => lambda { |sexp|
591
+ resource(sexp[1])
592
+ resource(sexp[2])
593
+ },
594
+ :mlhs_add => lambda { |sexp|
595
+ resource(sexp[1])
596
+ emit(", ") unless sexp[1] == [:mlhs_new]
597
+ resource(sexp[2])
598
+ },
599
+ :mlhs_add_star => lambda { |sexp|
600
+ resource(sexp[1])
601
+ emit(", ") unless sexp[1] == [:mlhs_new]
602
+ emit("*")
603
+ resource(sexp[2])
541
604
  },
542
605
  :mlhs_new => NOOP,
543
- :mlhs_paren => lambda { |src, sexp|
544
- src.emit("(")
545
- src.resource(sexp[1])
546
- src.emit(")")
547
- },
548
- :module => lambda { |src, sexp|
549
- src.emit("module ")
550
- src.resource(sexp[1])
551
- src.newline
552
- if src.void?(sexp[2])
553
- else
554
- src.resource(sexp[2])
606
+ :mlhs_paren => lambda { |sexp|
607
+ emit("(")
608
+ resource(sexp[1])
609
+ emit(")")
610
+ },
611
+ :module => lambda { |sexp|
612
+ emit("module ")
613
+ resource(sexp[1])
614
+ newline
615
+ unless void?(sexp[2])
616
+ indent do resource(sexp[2]) end
555
617
  end
556
- src.emit("end")
618
+ emit("end")
557
619
  },
558
- :mrhs_add => lambda { |src, sexp|
559
- src.resource(sexp[1])
560
- src.emit(", ")
561
- src.resource(sexp[2])
620
+ :mrhs_add => lambda { |sexp|
621
+ resource(sexp[1])
622
+ emit(", ")
623
+ resource(sexp[2])
562
624
  },
563
- :mrhs_add_star => lambda { |src, sexp|
564
- src.resource(sexp[1])
565
- src.emit(", ")
566
- src.emit("*")
567
- src.resource(sexp[2])
625
+ :mrhs_add_star => lambda { |sexp|
626
+ resource(sexp[1])
627
+ emit(", ")
628
+ emit("*")
629
+ resource(sexp[2])
568
630
  },
569
631
  :mrhs_new => NYI,
570
632
  :mrhs_new_from_args => PASS1,
571
- :next => lambda { |src, sexp|
572
- src.emit("next")
633
+ :next => lambda { |sexp|
634
+ emit("next")
573
635
  },
574
- :opassign => lambda { |src, sexp|
575
- src.resource(sexp[1])
576
- src.emit(" ")
577
- src.resource(sexp[2])
578
- src.emit(" ")
579
- src.resource(sexp[3])
636
+ :opassign => lambda { |sexp|
637
+ resource(sexp[1])
638
+ emit(" ")
639
+ resource(sexp[2])
640
+ emit(" ")
641
+ resource(sexp[3])
580
642
  },
581
643
  :param_error => NYI,
582
- :params => lambda { |src, sexp|
583
- src.params(sexp[1], sexp[2], sexp[3], sexp[4], sexp[5])
644
+ :params => lambda { |sexp|
645
+ params(sexp[1], sexp[2], sexp[3], sexp[4], sexp[5])
584
646
  },
585
- :paren => lambda { |src, sexp|
586
- src.emit("(")
587
- src.resource(sexp[1])
588
- src.emit(")")
647
+ :paren => lambda { |sexp|
648
+ emit("(")
649
+ resource(sexp[1])
650
+ emit(")")
589
651
  },
590
652
  :parse_error => NYI,
591
653
  :program => PASS1,
592
- :qwords_add => lambda { |src, sexp|
593
- src.words("w", sexp)
654
+ :qwords_add => lambda { |sexp|
655
+ words("w", sexp)
594
656
  },
595
657
  :qwords_new => NOOP,
596
- :redo => lambda { |src, sexp|
597
- src.emit("redo")
658
+ :redo => lambda { |sexp|
659
+ emit("redo")
598
660
  },
599
661
  :regexp_add => PASS2,
600
- :regexp_literal => lambda { |src, sexp|
662
+ :regexp_literal => lambda { |sexp|
601
663
  delims = determine_regexp_delimiters(sexp[2])
602
- src.emit(delims[0])
603
- src.resource(sexp[1])
604
- src.emit(delims[1])
664
+ emit(delims[0])
665
+ resource(sexp[1])
666
+ emit(delims[1])
605
667
  },
606
- :rescue => lambda { |src, sexp|
607
- src.emit("rescue")
668
+ :rescue => lambda { |sexp|
669
+ outdent do emit("rescue") end
608
670
  if sexp[1] # Exception list
609
- src.emit(" ")
671
+ emit(" ")
610
672
  if sexp[1].first.kind_of?(Symbol)
611
- src.resource(sexp[1])
673
+ resource(sexp[1])
612
674
  else
613
- src.resource(sexp[1].first)
675
+ resource(sexp[1].first)
614
676
  end
615
- src.emit(" => ")
616
- src.resource(sexp[2])
677
+ emit(" => ")
678
+ resource(sexp[2])
617
679
  end
618
- src.newline
619
- if sexp[3] && ! src.void?(sexp[3])
620
- src.resource(sexp[3])
621
- src.newline
680
+ newline
681
+ if sexp[3] && ! void?(sexp[3])
682
+ resource(sexp[3])
683
+ newline
622
684
  end
623
685
  },
624
- :rescue_mod => lambda { |src, sexp|
625
- src.resource(sexp[2])
626
- src.emit(" rescue ")
627
- src.resource(sexp[1])
686
+ :rescue_mod => lambda { |sexp|
687
+ resource(sexp[2])
688
+ emit(" rescue ")
689
+ resource(sexp[1])
628
690
  },
629
- :rest_param => lambda { |src, sexp|
630
- src.emit("*")
631
- src.resource(sexp[1])
691
+ :rest_param => lambda { |sexp|
692
+ emit("*")
693
+ resource(sexp[1])
632
694
  },
633
- :retry => lambda { |src, sexp|
634
- src.emit("retry")
695
+ :retry => lambda { |sexp|
696
+ emit("retry")
635
697
  },
636
- :return => lambda { |src, sexp|
637
- src.emit("return")
638
- src.opt_parens(sexp[1])
698
+ :return => lambda { |sexp|
699
+ emit("return")
700
+ opt_parens(sexp[1])
639
701
  },
640
- :return0 => lambda { |src, sexp|
641
- src.emit("return")
702
+ :return0 => lambda { |sexp|
703
+ emit("return")
642
704
  },
643
705
  :sclass => NYI,
644
- :stmts_add => lambda { |src, sexp|
645
- if sexp[1] != [:stmts_new] && ! src.void?(sexp[1])
646
- src.resource(sexp[1])
647
- src.newline
706
+ :stmts_add => lambda { |sexp|
707
+ if sexp[1] != [:stmts_new] && ! void?(sexp[1])
708
+ resource(sexp[1])
709
+ newline
648
710
  end
649
- src.resource(sexp[2]) if sexp[2]
711
+ resource(sexp[2]) if sexp[2]
650
712
  },
651
713
  :stmts_new => NOOP,
652
- :string_add => lambda { |src, sexp|
653
- src.resource(sexp[1])
654
- src.resource(sexp[2])
714
+ :string_add => lambda { |sexp|
715
+ resource(sexp[1])
716
+ resource(sexp[2])
655
717
  },
656
- :string_concat => lambda { |src, sexp|
657
- src.resource(sexp[1])
658
- src.emit(" ")
659
- src.resource(sexp[2])
718
+ :string_concat => lambda { |sexp|
719
+ resource(sexp[1])
720
+ emit(" ")
721
+ resource(sexp[2])
660
722
  },
661
723
  :string_content => NOOP,
662
724
  :string_dvar => NYI,
663
- :string_embexpr => lambda { |src, sexp|
664
- src.emit('#{')
665
- src.resource(sexp[1])
666
- src.emit('}')
725
+ :string_embexpr => lambda { |sexp|
726
+ emit('#{')
727
+ resource(sexp[1])
728
+ emit('}')
667
729
  },
668
- :string_literal => lambda { |src, sexp|
669
- src.emit('"')
670
- src.resource(sexp[1])
671
- src.emit('"')
730
+ :string_literal => lambda { |sexp|
731
+ emit('"')
732
+ resource(sexp[1])
733
+ emit('"')
672
734
  },
673
- :super => lambda { |src, sexp|
674
- src.emit("super")
675
- src.opt_parens(sexp[1])
735
+ :super => lambda { |sexp|
736
+ emit("super")
737
+ opt_parens(sexp[1])
676
738
  },
677
- :symbol => lambda { |src, sexp|
678
- src.emit(":")
679
- src.resource(sexp[1])
739
+ :symbol => lambda { |sexp|
740
+ emit(":")
741
+ resource(sexp[1])
680
742
  },
681
743
  :symbol_literal => PASS1,
682
744
  :top_const_field => NYI,
683
745
  :top_const_ref => NYI,
684
- :unary => lambda { |src, sexp|
685
- src.emit(sexp[1].to_s[0,1])
686
- src.resource(sexp[2])
687
- },
688
- :undef => lambda { |src, sexp|
689
- src.emit("undef ")
690
- src.resource(sexp[1].first)
691
- },
692
- :unless => lambda { |src, sexp|
693
- src.emit("unless ")
694
- src.resource(sexp[1])
695
- if src.multiline?
696
- src.newline
697
- else
698
- src.emit(" then ")
746
+ :unary => lambda { |sexp|
747
+ emit(sexp[1].to_s[0,1])
748
+ resource(sexp[2])
749
+ },
750
+ :undef => lambda { |sexp|
751
+ emit("undef ")
752
+ resource(sexp[1].first)
753
+ },
754
+ :unless => lambda { |sexp|
755
+ emit("unless ")
756
+ resource(sexp[1])
757
+ emit_then
758
+ indent do
759
+ resource(sexp[2])
760
+ resource(sexp[3]) if sexp[3]
761
+ soft_newline
699
762
  end
700
- src.resource(sexp[2])
701
- src.resource(sexp[3]) if sexp[3]
702
- src.soft_newline
703
- src.emit("end")
704
- },
705
- :unless_mod => lambda { |src, sexp|
706
- src.resource(sexp[2])
707
- src.emit(" unless ")
708
- src.resource(sexp[1])
709
- },
710
- :until => lambda { |src, sexp|
711
- src.emit("until ")
712
- src.resource(sexp[1])
713
- src.emit(" do ")
714
- src.resource(sexp[2])
715
- src.emit(" end")
716
- },
717
- :until_mod => lambda { |src, sexp|
718
- src.resource(sexp[2])
719
- src.emit(" until ")
720
- src.resource(sexp[1])
763
+ emit("end")
764
+ },
765
+ :unless_mod => lambda { |sexp|
766
+ resource(sexp[2])
767
+ emit(" unless ")
768
+ resource(sexp[1])
769
+ },
770
+ :until => lambda { |sexp|
771
+ emit("until ")
772
+ resource(sexp[1])
773
+ newline
774
+ indent do resource(sexp[2]) end
775
+ emit(" end")
776
+ },
777
+ :until_mod => lambda { |sexp|
778
+ resource(sexp[2])
779
+ emit(" until ")
780
+ resource(sexp[1])
721
781
  },
722
782
  :var_alias => NYI,
723
783
  :var_field => PASS1,
724
784
  :var_ref => PASS1,
725
785
  :void_stmt => NOOP,
726
- :when => lambda { |src, sexp|
727
- src.emit("when ")
728
- src.resource(sexp[1])
729
- src.newline
730
- src.resource(sexp[2])
786
+ :when => lambda { |sexp|
787
+ outdent do emit("when ") end
788
+ resource(sexp[1])
789
+ newline
790
+ resource(sexp[2])
731
791
  if sexp[3] && sexp[3].first == :when
732
- src.emit(" ")
792
+ emit(" ")
733
793
  end
734
- src.resource(sexp[3]) if sexp[3]
735
- },
736
- :while => lambda { |src, sexp|
737
- src.emit("while ")
738
- src.resource(sexp[1])
739
- src.newline
740
- unless src.void?(sexp[2])
741
- src.resource(sexp[2])
742
- src.newline
794
+ resource(sexp[3]) if sexp[3]
795
+ },
796
+ :while => lambda { |sexp|
797
+ emit("while ")
798
+ resource(sexp[1])
799
+ newline
800
+ indent do
801
+ unless void?(sexp[2])
802
+ resource(sexp[2])
803
+ newline
804
+ end
743
805
  end
744
- src.emit("end")
806
+ emit("end")
745
807
  },
746
- :while_mod => lambda { |src, sexp|
747
- src.resource(sexp[2])
748
- src.emit(" while ")
749
- src.resource(sexp[1])
808
+ :while_mod => lambda { |sexp|
809
+ resource(sexp[2])
810
+ emit(" while ")
811
+ resource(sexp[1])
750
812
  },
751
813
  :word_add => PASS2,
752
814
  :word_new => NOOP,
753
- :words_add => lambda { |src, sexp|
754
- src.words("W", sexp)
815
+ :words_add => lambda { |sexp|
816
+ words("W", sexp)
755
817
  },
756
818
  :words_new => NOOP,
757
- :xstring_add => lambda { |src, sexp|
758
- src.resource(sexp[1])
759
- src.resource(sexp[2])
819
+ :xstring_add => lambda { |sexp|
820
+ resource(sexp[1])
821
+ resource(sexp[2])
760
822
  },
761
- :xstring_literal => lambda { |src, sexp|
762
- src.emit('"')
763
- src.resource(sexp[1])
764
- src.emit('"')
823
+ :xstring_literal => lambda { |sexp|
824
+ emit('"')
825
+ resource(sexp[1])
826
+ emit('"')
765
827
  },
766
828
  :xstring_new => NOOP,
767
- :yield => lambda { |src, sexp|
768
- src.emit("yield")
769
- src.opt_parens(sexp[1])
829
+ :yield => lambda { |sexp|
830
+ emit("yield")
831
+ opt_parens(sexp[1])
770
832
  },
771
- :yield0 => lambda { |src, sexp|
772
- src.emit("yield")
833
+ :yield0 => lambda { |sexp|
834
+ emit("yield")
773
835
  },
774
- :zsuper => lambda { |src, sexp|
775
- src.emit("super")
836
+ :zsuper => lambda { |sexp|
837
+ emit("super")
776
838
  },
777
839
 
778
840
  # Scanner keywords