Class: RubyNodeReflector::RubyReflector

Inherits:
Object
  • Object
show all
Includes:
Coulor
Defined in:
lib/ruby_reflector.rb

Overview

turn hamburger back into live cattle

Defined Under Namespace

Classes: CallMethod, ScopeMethod

Constant Summary

Constants included from Coulor

Coulor::BOLD, Coulor::CLEAR

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Coulor

#blue, #bold, #colorize, #colorize?, #colour, #green, #magenta, #orange, #red

Constructor Details

#initialize(block, reflect_values = true) ⇒ RubyReflector

note that a block, from your context, is not optional



105
106
107
108
109
110
111
112
 
# File 'lib/ruby_reflector.rb', line 105

def initialize(block, reflect_values = true)  #  note that a block, from your context, is not optional
  @reflect_values = reflect_values
  @evaluations    = []
  @result         = ''
  @block          = block
  @line           = 0
  reflect_nodes(@block.body_node)
end

Instance Attribute Details

#evaluations ⇒ Object (readonly)

Returns the value of attribute evaluations.



101
102
103
 
# File 'lib/ruby_reflector.rb', line 101

def evaluations
  @evaluations
end

#reflect_values=(value) ⇒ Object (writeonly)

Sets the attribute reflect_values

Parameters:

  • value —

    the value to set the attribute reflect_values to.



103
104
105
 
# File 'lib/ruby_reflector.rb', line 103

def reflect_values=(value)
  @reflect_values = value
end

#result ⇒ Object (readonly)

Returns the value of attribute result.



101
102
103
 
# File 'lib/ruby_reflector.rb', line 101

def result
  @result
end

Instance Method Details

#_alias(node) ⇒ Object 



350
351
352
 
# File 'lib/ruby_reflector.rb', line 350

def _alias(node)
  return "alias #{ lit_(node[:new].last) } #{ lit_(node[:old].last) }"
end

#_and(node, und = 'and') ⇒ Object

operators



454
455
456
457
458
 
# File 'lib/ruby_reflector.rb', line 454

def _and(node, und = 'and')
  return eval_intermediate( '( ' +
           eval_parenz{ first_(node)} + ' ' + und + ' ' +
           eval_parenz{second_(node)} + ' )' )
end

#_args(node) ⇒ Object

_call and _fcall insert the real args



382
 
# File 'lib/ruby_reflector.rb', line 382

def _args(node); return ''; end

#_argscat(node) ⇒ Object 



815
816
817
818
 
# File 'lib/ruby_reflector.rb', line 815

def _argscat(node)
  return head_(node) + ', *' + 
           nest_if(node[:body].first == :array, '[', ']'){ body_(node) }
end

#_array(node) ⇒ Object 



670
671
672
673
674
675
676
677
678
 
# File 'lib/ruby_reflector.rb', line 670

def _array(node)
  nest_if we_b(node) == :array, '[', ']' do
    node.map{ |z|
      exp = _send(z)
      exp << ', '  unless z.object_id == node.last.object_id
      exp
    }.join
  end
end

#_attrasgn(node) ⇒ Object 



608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
 
# File 'lib/ruby_reflector.rb', line 608

def _attrasgn(node)
  recv, args = node.values_at(:recv, :args)

  if args
    if args.first == :array
      if node[:mid].class == Symbol
        if node[:mid] == :'[]='
          return recv_zero_self(node) + '[' + 
                _send(args.last.first) + '] = ' + 
                _send(args.last.last)
        end
        return recv_zero_self(node, '.') + mid_(node) + '(' + _send(args.last.last) + ')'
      end
    end
    
    return recv_zero_self(node) +
            '[' + head_(args.last) + '] = ' + 
             body_(args.last)
  end

  return recv_zero_self(node, '.') + node[:mid].to_s.gsub(/=$/, '')
end

#_back_ref(node) ⇒ Object 



460
 
# File 'lib/ruby_reflector.rb', line 460

def _back_ref(node); '$' + node[:nth].chr; end

#_begin(node) ⇒ Object 



221
 
# File 'lib/ruby_reflector.rb', line 221

def _begin(node); "begin\n" + body_(node) + "\nend\n"; end

#_block(node) ⇒ Object

structures



201
202
203
 
# File 'lib/ruby_reflector.rb', line 201

def _block(node)
  return node.map{|n| _send(n, "\n") }.join
end

#_block_arg(node) ⇒ Object

is this ever called?



706
707
708
 
# File 'lib/ruby_reflector.rb', line 706

def _block_arg(node)  #  is this ever called?
  return ''  #  note that _scope should not take care of this
end

#_block_pass(node) ⇒ Object 



652
653
654
655
656
657
 
# File 'lib/ruby_reflector.rb', line 652

def _block_pass(node)
  fcall = node[:iter].last
  return eval_intermediate(recv_(fcall, '.') +
            mid_(fcall) + '(' + args_(fcall, ', ') +
            '&' + body_(node) + ')' )
end

#_break(node) ⇒ Object 



384
 
# File 'lib/ruby_reflector.rb', line 384

def _break(node); 'break'; end

#_call(node) ⇒ Object 



780
 
# File 'lib/ruby_reflector.rb', line 780

def _call(node);  CallMethod.new.caller(self, node);  end

#_case(node) ⇒ Object 



386
 
# File 'lib/ruby_reflector.rb', line 386

def _case(node); '( case ' + head_body(node) + "\nend )"; end

#_cdecl(node) ⇒ Object 



427
428
429
 
# File 'lib/ruby_reflector.rb', line 427

def _cdecl(node)
  return _send(node[ node[:vid] == 0 ? :else : :vid ]) + ' = ' + value_(node)
end

#_class(node) ⇒ Object 



216
 
# File 'lib/ruby_reflector.rb', line 216

def _class(node); _module(node, 'class');  end

#_colon2(node) ⇒ Object 



461
 
# File 'lib/ruby_reflector.rb', line 461

def _colon2(node); head_(node, '::') + mid_(node); end

#_colon3(node) ⇒ Object 



462
 
# File 'lib/ruby_reflector.rb', line 462

def _colon3(node); '::' + mid_(node); end

#_const(node) ⇒ Object

ERGO raise if any other key!



565
566
567
568
569
570
571
572
 
# File 'lib/ruby_reflector.rb', line 565

def _const(node)
  expression = vid_(node)
  q = eval(expression, @block.binding)
  eval_intermediate(expression)  unless q.kind_of?(Module)
  return expression
rescue  #  ERGO  will someone need to see whatever this was?
  return expression
end

#_cvar(node) ⇒ Object 



463
 
# File 'lib/ruby_reflector.rb', line 463

def _cvar(node); _lvar(node); end

#_cvasgn(node) ⇒ Object 



435
 
# File 'lib/ruby_reflector.rb', line 435

def _cvasgn(node); _dasgn_curr(node); end

#_cvdecl(node) ⇒ Object 



464
 
# File 'lib/ruby_reflector.rb', line 464

def _cvdecl(node); vid_(node) + ' = ' + value_(node); end

#_dasgn(node) ⇒ Object 



431
 
# File 'lib/ruby_reflector.rb', line 431

def _dasgn(node); _dasgn_curr(node); end

#_dasgn_curr(node) ⇒ Object

assignments



418
419
420
421
422
423
424
425
 
# File 'lib/ruby_reflector.rb', line 418

def _dasgn_curr(node)
  expression = vid_(node)
  return expression unless value = node[:value]
  expression << ' = '
  we_b_array = value.first == :array
  expression << nest_if(we_b_array, '[', ']'){ value_(node) }
  return expression
end

#_defined(node) ⇒ Object 



465
 
# File 'lib/ruby_reflector.rb', line 465

def _defined(node); 'defined? ' + head_(node); end

#_defn(node) ⇒ Object 



218
 
# File 'lib/ruby_reflector.rb', line 218

def _defn(node); _defs(node); end

#_defs(node) ⇒ Object 



317
318
319
320
321
 
# File 'lib/ruby_reflector.rb', line 317

def _defs(node)
  return 'def ' + recv_(node, '.') + mid_(node) + 
           defn_(node) + 
         "end\n"
end

#_dot2(node) ⇒ Object 



466
 
# File 'lib/ruby_reflector.rb', line 466

def _dot2(node); '( ' + beg_(node) + ' .. '  + end_(node) + ' )'; end

#_dot3(node) ⇒ Object 



467
 
# File 'lib/ruby_reflector.rb', line 467

def _dot3(node); '( ' + beg_(node) + ' ... ' + end_(node) + ' )'; end

#_dregx(node) ⇒ Object 



468
 
# File 'lib/ruby_reflector.rb', line 468

def _dregx(node); _dstr(node, '/'); end

#_dregx_once(node) ⇒ Object 



469
 
# File 'lib/ruby_reflector.rb', line 469

def _dregx_once(node); _dstr(node, '/'); end

#_dstr(node, delim = '"') ⇒ Object 



580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
 
# File 'lib/ruby_reflector.rb', line 580

def _dstr(node, delim = '"')
  regex = delim == '/'
  expression = delim + scrape_literal(node, regex)

  if node[:next] and node[:next].first == :array
    (node[:next].last || []).each do |n|
      expression << if n.first == :str
        scrape_literal(n.last, regex)
      else
        '#{ ' + _send(n) + ' }'
      end
    end
  end
  
  return eval_intermediate(expression + delim)
end

#_dsym(node) ⇒ Object 



470
 
# File 'lib/ruby_reflector.rb', line 470

def _dsym(node); ':' + _lit(node[:lit]) + ' ' + rest_(node); end

#_dvar(node) ⇒ Object 



471
 
# File 'lib/ruby_reflector.rb', line 471

def _dvar(node); eval_intermediate(vid_(node)); end

#_dxstr(node) ⇒ Object 



472
 
# File 'lib/ruby_reflector.rb', line 472

def _dxstr(node); _dstr(node, '`'); end

#_ensure(node) ⇒ Object 



222
 
# File 'lib/ruby_reflector.rb', line 222

def _ensure(node); head_(node) + "\nensure\n" + ensr_(node); end

#_evstr(node) ⇒ Object 



474
 
# File 'lib/ruby_reflector.rb', line 474

def _evstr(node); body_(node); end

#_false(nada) ⇒ Object 



475
 
# File 'lib/ruby_reflector.rb', line 475

def _false(nada); 'false'; end

#_fcall(node) ⇒ Object 



646
647
648
649
650
 
# File 'lib/ruby_reflector.rb', line 646

def _fcall(node)
  exp = mid_(node) + fcall_args(node[:args], true)
  eval_intermediate(exp) unless %w(lambda proc).include?(exp)
  return exp
end

#_flip2(node) ⇒ Object

ERGO what the heck is this??



497
498
499
500
501
 
# File 'lib/ruby_reflector.rb', line 497

def _flip2(node)  #  ERGO  what the heck is this??
  p node
  p node.keys
  return ''
end

#_for(node) ⇒ Object 



376
377
378
379
380
 
# File 'lib/ruby_reflector.rb', line 376

def _for(node)
  return '( for ' + var_(node) + ' in ' + iter_(node) + "\n" +
              body_(node) + "\n" +
           'end )'
end

#_gasgn(node) ⇒ Object 



433
 
# File 'lib/ruby_reflector.rb', line 433

def _gasgn(node); _dasgn_curr(node); end

#_gvar(node) ⇒ Object 



476
 
# File 'lib/ruby_reflector.rb', line 476

def _gvar(node); vid_(node); end

#_hash(node) ⇒ Object 



680
681
682
683
684
685
686
687
688
689
690
 
# File 'lib/ruby_reflector.rb', line 680

def _hash(node)
  return '{}'  unless node[:head] and (array = node[:head].last)
  expression = '{ '
  
  array.in_groups_of 2 do |key, value|
    expression << _send(key) + ' => ' + _send(value)
    expression << ', '  if value != array.last
  end
  
  return expression + ' }'
end

#_iasgn(node) ⇒ Object 



432
 
# File 'lib/ruby_reflector.rb', line 432

def _iasgn(node); _dasgn_curr(node); end

#_if(node) ⇒ Object

control flow



361
362
363
364
365
366
367
368
 
# File 'lib/ruby_reflector.rb', line 361

def _if(node)
  expression = '( if ' + eval_parenz{cond_(node)} + ' then '
  expression <<     eval_parenz{body_(node)}  if node[:body]
  expression << ' else ' + 
                    eval_parenz{else_(node)}  if node[:else]
  expression << ' end )'
  return expression
end

#_iter(node) ⇒ Object 



659
660
661
662
663
664
665
666
667
668
 
# File 'lib/ruby_reflector.rb', line 659

def _iter(node)
  var = node[:var]

  return eval_intermediate(
    iter_(node) +
      '{' +
      nest_if(var != false, '|', '|'){ var_(node)  unless var == 0 } +
      nest_if(node[:body] , ' ', ' '){ body_(node) } +
      '}')
end

#_ivar(node) ⇒ Object 



477
 
# File 'lib/ruby_reflector.rb', line 477

def _ivar(node); _dvar(node); end

#_lasgn(node) ⇒ Object 



434
 
# File 'lib/ruby_reflector.rb', line 434

def _lasgn(node); _dasgn_curr(node); end

#_lit(node) ⇒ Object 



478
 
# File 'lib/ruby_reflector.rb', line 478

def _lit(node); node[:lit].inspect; end

#_lvar(node) ⇒ Object 



479
 
# File 'lib/ruby_reflector.rb', line 479

def _lvar(node); eval_intermediate(vid_(node)); end

#_masgn(node) ⇒ Object 



503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
 
# File 'lib/ruby_reflector.rb', line 503

def _masgn(node)

  #{:value=>
  #  [:splat,
  #   {:head=>
  #     [:fcall,
  #      {:mid=>:calc_stack,
  #       :args=>
  #        [:array,
  #         [[:vcall, {:mid=>:insn}],
  #          [:vcall, {:mid=>:from}],
  #          [:vcall, {:mid=>:after}],
  #          [:vcall, {:mid=>:opops}]]]}]}],
  # :args=>false,
  # :head=>
  #  [:array,
  #   [[:dasgn_curr, {:value=>false, :vid=>:name}],
  #    [:dasgn_curr, {:value=>false, :vid=>:pops}],
  #    [:dasgn_curr, {:value=>false, :vid=>:rets}],
  #    [:dasgn_curr, {:value=>false, :vid=>:pushs1}],
  #    [:dasgn_curr, {:value=>false, :vid=>:pushs2}]]]}
  
  value, head, args = node.values_at(:value, :head, :args)
  
  if value 
    return '( ' + head_(node) + ' = *' + head_(value.last) + ' )'  if value.first == :splat
    
    if head and args
      exp = head_(node)
      return exp + ', * = ' + value_(node)  if args == -1 
      return exp + ', *' + args_(node) + ' = ' + value_(node)
    end
    
    return '( ' + head_(node) + ' = ' + value_(node) + ' )'  if args == false
  end
  
  if value == false and head == false and args
    return '*' + neg_one(args)
  end

  if head.kind_of?(Array) and head.first == :array
    return head.last.map{|n|
      nest_if(n.first == :masgn, '(', ')'){ _send(n) }
    }.join(', ')
  end

  if head == false and args and value
    return '*' + args_(node) + ' = ' + value_(node)
  end

  return head_(node)
end

#_match(node) ⇒ Object 



480
 
# File 'lib/ruby_reflector.rb', line 480

def _match(node); node[:lit].inspect; end

#_match2(node) ⇒ Object 



692
693
694
695
 
# File 'lib/ruby_reflector.rb', line 692

def _match2(node)
  #  ERGO  should this work like match3?
  return recv_(node) + ' =~ ' + value_(node)
end

#_match3(node) ⇒ Object 



701
702
703
704
 
# File 'lib/ruby_reflector.rb', line 701

def _match3(node)
  #  ERGO  do :lit and :value exclude each other?
  return recv_(node) + ' =~ ' + _send(node[:lit] || node[:value])
end

#_method(node) ⇒ Object 



211
212
213
214
 
# File 'lib/ruby_reflector.rb', line 211

def _method(node)
p node
  return ''
end

#_module(node, what = 'module') ⇒ Object 



205
206
207
208
209
 
# File 'lib/ruby_reflector.rb', line 205

def _module(node, what = 'module')
  return what + ' ' + cpath_(node) + "\n" + 
           body_(node) + 
       "\nend\n"
end

#_next(node) ⇒ Object 



385
 
# File 'lib/ruby_reflector.rb', line 385

def _next(node); 'next' ; end

#_nil(nada) ⇒ Object 



482
 
# File 'lib/ruby_reflector.rb', line 482

def _nil(nada); 'nil'  ; end

#_not(node) ⇒ Object 



483
 
# File 'lib/ruby_reflector.rb', line 483

def _not(node); '(not(' + body_(node) + '))'; end

#_nth_ref(node) ⇒ Object

ERGO eval it?



484
 
# File 'lib/ruby_reflector.rb', line 484

def _nth_ref(node); "$#{ node[:nth] }"; end

#_op_asgn1(node) ⇒ Object

ERGO just look up the list of these?



790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
 
# File 'lib/ruby_reflector.rb', line 790

def _op_asgn1(node)  #  ERGO  just look up the list of these?
  return '' unless args = node[:args]
  exp = recv_(node)
  
  if [:'-', :'+', :'*', :'**', :'/', :^, :|, :&, 
      :'<<', :'>>', 
        ].include?(node[:mid]) and 
      node[:recv] and args.first == :argscat

    return exp + 
      "[#{ body_(args.last) }] #{ node[:mid] }= " + head_(args.last)
  end
  
  raise "unexpected mid value #{ node[:mid].inspect } in opcode for X= " unless node[:mid] == 0
        
  if args.first == :argscat and args.last[:body]
    exp << '[' + body_(args.last) + ']'
    exp << ' ||= ' + head_(args.last)
  else
    raise "unexpected arguments in opcode for ||= "
  end
  
  return exp
end

#_op_asgn2(node) ⇒ Object 



437
438
439
440
441
442
443
444
445
446
447
448
449
 
# File 'lib/ruby_reflector.rb', line 437

def _op_asgn2(node)
  expression = ''
  
  if node[:recv].first == :self
    expression << 'self'
  else
    expression << recv_(node)
  end
  
  expression << '.'
  expression << vid_(node[:next].last) + ' ||= ' + value_(node)
  return expression
end

#_op_asgn_and(node) ⇒ Object 



485
 
# File 'lib/ruby_reflector.rb', line 485

def _op_asgn_and(node); _op_asgn_or(node, ' &&= '); end

#_op_asgn_or(node, op = ' ||= ') ⇒ Object 



631
632
633
634
635
636
637
 
# File 'lib/ruby_reflector.rb', line 631

def _op_asgn_or(node, op = ' ||= ')
  #  CONSIDER what be :aid?
  #{:value=>[:lasgn, {:value=>[:str, {:lit=>"vm_opts.h"}], :cnt=>2, :vid=>:file}],
  # :aid=>0,
  # :head=>[:lvar, {:cnt=>2, :vid=>:file}]}
  return head_(node) + op + value_(node[:value].last)
end

#_or(node) ⇒ Object 



486
 
# File 'lib/ruby_reflector.rb', line 486

def _or(node); _and(node, 'or'); end

#_postexe(node) ⇒ Object 



408
409
410
411
 
# File 'lib/ruby_reflector.rb', line 408

def _postexe(node)
  raise '_postexe called with unexpected arguments' unless node == {} or node.keys == [:node]
  return 'END'
end

#_redo(node) ⇒ Object 



389
 
# File 'lib/ruby_reflector.rb', line 389

def _redo(node); 'redo'; end

#_resbody(node) ⇒ Object 



339
340
341
342
 
# File 'lib/ruby_reflector.rb', line 339

def _resbody(node)
  return body_(node)
    # already emitted: head_(node) + ' ' + args_(node)
end

#_rescue(node) ⇒ Object 



323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/ruby_reflector.rb', line 323

def _rescue(node)
  if node[:else] == false and node[:head] and 
        node[:resq] and node[:head].first == :vcall
    return head_(node) + ' rescue ' + resq_(node)
  else
    exp = head_(node) + 
            else_(node) +
          "rescue" 
    if node[:resq] and node[:resq].first == :resbody
      body = node[:resq].last  
      exp << ' ' + args_(body)  if body and body[:args]
    end
    return exp + "\n" + resq_(node)
  end
end

#_retry(node) ⇒ Object 



388
 
# File 'lib/ruby_reflector.rb', line 388

def _retry(node); 'retry'; end

#_return(node) ⇒ Object 



392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
 
# File 'lib/ruby_reflector.rb', line 392

def _return(node)
  exp = 'return'
  return exp unless stts = node[:stts]        
  exp << ' '
  
  if stts.first == :array
    exp << '[' + stts_(node) + ']'
  elsif stts.first == :svalue
    exp << stts_(node)
  else
    exp << eval_parenz{stts_(node)}
  end
  
  return exp
end

#_sclass(node) ⇒ Object 



224
225
226
227
228
 
# File 'lib/ruby_reflector.rb', line 224

def _sclass(node)
  return 'class << ' + recv_(node) + 
            head_body(node) + 
         "end\n"
end

#_scope(node) ⇒ Object 



313
314
315
 
# File 'lib/ruby_reflector.rb', line 313

def _scope(node)
  return ScopeMethod.new._scopic(self, node)
end

#_self(node) ⇒ Object 



217
 
# File 'lib/ruby_reflector.rb', line 217

def _self(node); 'self'; end

#_send(node, thence = '') ⇒ Object 



179
180
181
182
183
184
185
186
187
188
 
# File 'lib/ruby_reflector.rb', line 179

def _send(node, thence = '')
  return '' unless node
  return node.to_s + thence  if node.class == Symbol
  target = :"_#{ node.first }"
  last = node.last
  (@line = last[:node].line) rescue nil
  exp    = send(target, last)
  exp << thence  if exp.length > 0
  return exp
end

#_splat(node) ⇒ Object 



556
557
558
559
560
561
562
563
 
# File 'lib/ruby_reflector.rb', line 556

def _splat(node)
  if (head = node[:head]) and 
      ((we_b_array = head.first == :array) or head.first == :lvar)
    return '*' + nest_if(we_b_array, '[', ']'){ head_(node) }
  end
  
  return '*' + head_(node)
end

#_str(node) ⇒ Object 



487
 
# File 'lib/ruby_reflector.rb', line 487

def _str(node); _lit(node); end

#_super(node) ⇒ Object 



219
 
# File 'lib/ruby_reflector.rb', line 219

def _super(node); 'super(' + args_(node) + ')'; end

#_svalue(node) ⇒ Object 



488
 
# File 'lib/ruby_reflector.rb', line 488

def _svalue(node); head_(node); end

#_to_ary(node) ⇒ Object 



489
 
# File 'lib/ruby_reflector.rb', line 489

def _to_ary(node); head_(node); end

#_true(nada) ⇒ Object 



490
 
# File 'lib/ruby_reflector.rb', line 490

def _true(nada); 'true' ; end

#_undef(node) ⇒ Object 



491
 
# File 'lib/ruby_reflector.rb', line 491

def _undef(node); 'undef ' + mid_(node); end

#_until(node) ⇒ Object 



383
 
# File 'lib/ruby_reflector.rb', line 383

def _until(node); _while(node, 'until'); end

#_valias(node) ⇒ Object 



354
355
356
 
# File 'lib/ruby_reflector.rb', line 354

def _valias(node)
  return "alias #{ node[:new] } #{ node[:old] }"
end

#_vcall(node) ⇒ Object 



492
 
# File 'lib/ruby_reflector.rb', line 492

def _vcall(node); mid_(node); end

#_when(node) ⇒ Object 



387
 
# File 'lib/ruby_reflector.rb', line 387

def _when(node); 'when ' + head_body(node) + "\n" + next_(node); end

#_while(node, concept = 'while') ⇒ Object 



370
371
372
373
374
 
# File 'lib/ruby_reflector.rb', line 370

def _while(node, concept = 'while')
  return '( ' + concept + ' ' + cond_(node) + 
              head_body(node) + 
         "\nend )"
end

#_xstr(node) ⇒ Object 



494
 
# File 'lib/ruby_reflector.rb', line 494

def _xstr(node); '`' + scrape_literal(node) + '`'; end

#_yield(node) ⇒ Object 



344
345
346
347
348
 
# File 'lib/ruby_reflector.rb', line 344

def _yield(node)
  exp = 'yield'
  exp << '(' + head_(node) + ')'  if node[:head]
  return exp
end

#_zarray(node) ⇒ Object 



495
 
# File 'lib/ruby_reflector.rb', line 495

def _zarray(node); return '[]'; end

#_zsuper(node) ⇒ Object 



220
 
# File 'lib/ruby_reflector.rb', line 220

def _zsuper(node); 'super'; end

#eval_intermediate(expression) ⇒ Object 



140
141
142
143
 
# File 'lib/ruby_reflector.rb', line 140

def eval_intermediate(expression)
  eval_intermediate_guarded(expression)  if @reflect_values
  return expression
end

#eval_intermediate_guarded(expression) ⇒ Object 



125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/ruby_reflector.rb', line 125

def eval_intermediate_guarded(expression)
  begin
    intermediate = eval(expression, @block.binding)
    @evaluations << [expression, intermediate, nil]
  rescue SyntaxError => e
    if e.message.index('syntax error, unexpected \',\'') and expression !~ /\[ /
      return eval_intermediate_guarded('[ ' + expression + ' ]')
    end  #  faint prayer to infinite recursion diety here! (-;

    @evaluations << [expression, nil, e.message]
  rescue => e
    @evaluations << [expression, nil, e.message]
  end
end

#eval_parenz ⇒ Object 



473
 
# File 'lib/ruby_reflector.rb', line 473

def  eval_parenz; eval_intermediate('( ' + yield + ' )'); end

#fcall_args(node = nil, methodic = false) ⇒ Object 



639
640
641
642
643
644
 
# File 'lib/ruby_reflector.rb', line 639

def fcall_args(node = nil, methodic = false)
  expression = ''
  return expression  unless node
  expression << ' '  unless methodic
  return expression + nest_if(methodic, '(', ')'){  _send(node)  }
end

#format_evaluations ⇒ Object

ERGO spew the backrefs (?) any regular expression matchers may emit!

ERGO  don't eval the caller of a block without its block!



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/ruby_reflector.rb', line 158

def format_evaluations
  max_line = @evaluations.map{|exp, val, prob| exp.length}.sort.last
  already = {}
  lines  = []

  @evaluations.each do |exp, val, prob|
    line = "    #{ exp.center(max_line) } "

    line << if prob then
      orange('--? ' + prob)
    else
      green('--> ') + bold(short_inspect(val))
    end

    lines << line  unless already[line] == true
    already[line] = true
  end
  
  return lines.compact.join("\n")
end

#head_body(node) ⇒ Object 



390
 
# File 'lib/ruby_reflector.rb', line 390

def head_body(node); head_(node) + "\n" + body_(node); end

#neg_one(node) ⇒ Object 



481
 
# File 'lib/ruby_reflector.rb', line 481

def  neg_one(node); node == -1 ? '' : _send(node); end

#nest_if(condition, before, after, &block) ⇒ Object 



782
783
784
785
786
787
788
 
# File 'lib/ruby_reflector.rb', line 782

def nest_if(condition, before, after, &block)
  exp = ''
  exp << before  if condition
  exp << (block.call || '')
  exp << after   if condition
  return exp
end

#recv_zero_self(node, plus = '') ⇒ Object 



602
603
604
605
606
 
# File 'lib/ruby_reflector.rb', line 602

def recv_zero_self(node, plus = '')
  recv = node[:recv]
  return 'self' + plus  if recv == 0
  return recv_(node, plus)
end

#reflect_nodes(body_node) ⇒ Object 



114
115
116
117
118
119
120
121
122
123
 
# File 'lib/ruby_reflector.rb', line 114

def reflect_nodes(body_node)
  return unless body_node
  @transformation = body_node.transform(:include_node => true)
  return @result = _send(@transformation)
rescue
  puts "\nOffending line: #{ @line }"
  #      pp @transformation
  #      puts @result
  raise
end

#scrape_literal(node, regex = false) ⇒ Object 



574
575
576
577
578
 
# File 'lib/ruby_reflector.rb', line 574

def scrape_literal(node, regex = false)
  lit = node[:lit].inspect.gsub(/^"/, '').gsub(/"$/, '')
  lit.gsub!('\\\\', '\\')  if regex
  return lit
end

#we_b(node) ⇒ Object 



493
 
# File 'lib/ruby_reflector.rb', line 493

def  we_b(node); node.first.first; end

#we_b_op(node) ⇒ Object 



697
698
699
 
# File 'lib/ruby_reflector.rb', line 697

def we_b_op(node)
  return node[:mid] && node[:mid].to_s !~ /^[a-z]/i
end