assert2 0.3.4 → 0.3.6

data/lib/assert2.rb

@@ -1,7 +1,7 @@
 require 'test/unit'
 
 #  FIXME  the first failing assertion of a batch should suggest you get with Ruby1.9...
-#  TODO  install Coulor
+#  TODO  install Coulor (flibberty) 
 #  TODO  add :verbose => option to assert{}
 #  TODO  pay for Staff Benda Bilili  ALBUM: Tr�s Tr�s Fort (Promo Sampler) !
 #  TODO  evaluate parts[3]
@@ -19,7 +19,7 @@ require 'test/unit'
   #~ end
 
 if RUBY_VERSION < '1.9.0'
-  require 'assert2/rubynode_reflector'  # FIXME default to null_reflector if rubynode not available
+  require 'assert2/rubynode_reflector'
 else
   require 'assert2/ripper_reflector'
 end
@@ -35,7 +35,7 @@ module Test; module Unit; module Assertions
                end
 
   def add_diagnostic(whatever = nil, &block)
-    @__additional_diagnostics ||= []
+    @__additional_diagnostics ||= []  #  TODO move that inside the reflector object, and persist it thru a test case event
     
     if whatever == :clear
       @__additional_diagnostics = []
@@ -115,7 +115,7 @@ module Test; module Unit; module Assertions
     include Coulor
     
     def split_and_read(called)
-      if called =~ /([^:]+):(\d+):/
+      if called + ':' =~ /([^:]+):(\d+):/
         file, line = $1, $2.to_i
         return File.readlines(file)[line - 1 .. -1]
       end
@@ -204,7 +204,10 @@ module Test; module Unit; module Assertions
     options[:keep_diagnostics] or add_diagnostic :clear
     
     begin
-      got = block.call(*options[:args]) and add_assertion and return got
+      if got = block.call(*options[:args])
+        add_assertion
+        return got
+      end
     rescue FlunkError
       raise  #  asserts inside assertions that fail do not decorate the outer assertion
     rescue => got
@@ -235,7 +238,7 @@ module Test; module Unit; module Assertions
     options[:keep_diagnostics] or add_diagnostic :clear
     
     begin
-      got = block.call(*options[:args]) or (add_assertion and return true)
+      got = block.call(*options[:args]) or (add_assertion ; return true)
     rescue FlunkError
       raise
     rescue => got
@@ -251,7 +254,7 @@ module Test; module Unit; module Assertions
     options[:keep_diagnostics] or add_diagnostic :clear
     
     begin
-      got = block.call(*options[:args]) or (add_assertion and return true)
+      got = block.call(*options[:args]) or (add_assertion ; return true)
     rescue FlunkError
       raise
     rescue => got

data/lib/assert2.rb~

@@ -0,0 +1,344 @@
+require 'test/unit'
+
+#  FIXME  the first failing assertion of a batch should suggest you get with Ruby1.9...
+#  TODO  install Coulor (flibberty) 
+#  TODO  add :verbose => option to assert{}
+#  TODO  pay for Staff Benda Bilili  ALBUM: Tr�s Tr�s Fort (Promo Sampler) !
+#  TODO  evaluate parts[3]
+#  ERGO  if the block is a block, decorate with do-end
+#  ERGO  decorate assert_latest's block at fault time
+
+#~ if RUBY_VERSION > '1.8.6'
+  #~ puts "\nWarning: This version of assert{ 2.0 } requires\n" +
+       #~ "RubyNode, which only works on Ruby versions < 1.8.7.\n" +
+       #~ "Upgrade to Ruby1.9, and try 'gem install assert21'\n\n"
+#~ end
+
+  #~ def colorize(whatever)
+    #~ # FIXME stop ignoring this and start colorizing v2.1!
+  #~ end
+
+if RUBY_VERSION < '1.9.0'
+  require 'assert2/rubynode_reflector'
+else
+  require 'assert2/ripper_reflector'
+end
+
+#  CONSIDER  fix if an assertion contains more than one command - reflect it all!
+
+module Test; module Unit; module Assertions
+
+  FlunkError = if defined? Test::Unit::AssertionFailedError
+                 Test::Unit::AssertionFailedError
+               else
+                 MiniTest::Assertion
+               end
+
+  def add_diagnostic(whatever = nil, &block)
+    @__additional_diagnostics ||= []  #  TODO move that inside the reflector object, and persist it thru a test case event
+    
+    if whatever == :clear
+      @__additional_diagnostics = []
+      whatever = nil
+    end
+    
+    @__additional_diagnostics += [whatever, block]  # note .compact will take care of them if they don't exist
+  end
+
+  def assert(*args, &block)
+  #  This assertion calls a block, and faults if it returns
+  #  +false+ or +nil+. The fault diagnostic will reflect the
+  #  assertion's complete source - with comments - and will
+  #  reevaluate the every variable and expression in the
+  #  block.
+  #
+  #  The first argument can be a diagnostic string:
+  #
+  #    assert("foo failed"){ foo() }
+  #
+  #  The fault diagnostic will print that line.
+  # 
+  #  The next time you think to write any of these assertions...
+  #  
+  #  - +assert+
+  #  - +assert_equal+
+  #  - +assert_instance_of+
+  #  - +assert_kind_of+
+  #  - +assert_operator+
+  #  - +assert_match+
+  #  - +assert_not_nil+
+  #  
+  #  use <code>assert{ 2.1 }</code> instead.
+  #
+  #  If no block is provided, the assertion calls +assert_classic+,
+  #  which simulates RubyUnit's standard <code>assert()</code>.
+    if block
+      assert_ *args, &block
+    else
+      assert_classic *args
+    end
+    return true # or die trying ;-)
+  end
+
+  module Coulor  #:nodoc:
+    def colorize(we_color)
+      @@we_color = we_color
+    end
+    unless defined? BOLD
+      BOLD  = "\e[1m" 
+      CLEAR = "\e[0m" 
+    end       # ERGO  modularize these; anneal with Win32
+    def colour(text, colour_code)
+      return colour_code + text + CLEAR  if colorize?
+      return text
+    end
+    def colorize?  #  ERGO  how other libraries set these options transparent??
+      we_color = (@@we_color rescue true)  #  ERGO  parens needed?
+      return false if ENV['EMACS'] == 't'
+      return (we_color == :always or we_color && $stdout.tty?)
+    end
+    def bold(text)
+      return BOLD + text + CLEAR  if colorize?
+      return text
+    end
+    def green(text); colour(text, "\e[32m"); end
+    def red(text); colour(text, "\e[31m"); end
+    def magenta(text); colour(text, "\e[35m"); end
+    def blue(text); colour(text, "\e[34m"); end
+    def orange(text); colour(text, "\e[3Bm"); end
+  end
+  
+  class RubyReflector
+    attr_accessor :captured_block_vars,
+                  :args
+
+    include Coulor
+    
+    def split_and_read(called)
+      if called + ':' =~ /([^:]+):(\d+):/
+        file, line = $1, $2.to_i
+        return File.readlines(file)[line - 1 .. -1]
+      end
+      
+      return nil
+    end
+    
+    def __evaluate_diagnostics
+      @__additional_diagnostics.each_with_index do |d, x|
+        @__additional_diagnostics[x] = d.call if d.respond_to? :call
+      end
+    end  #  CONSIDER  pass the same args as blocks take?
+
+    def __build_message(reflection)
+      __evaluate_diagnostics
+      return (@__additional_diagnostics.uniq + [reflection]).compact.join("\n")
+    end  #  TODO  move this fluff to the ruby_reflector!
+
+    def format_inspection(inspection, spaces)
+      spaces = ' ' * spaces
+      inspection = inspection.gsub('\n'){ "\\n\" +\n \"" } if inspection =~ /^".*"$/
+      inspection = inspection.gsub("\n"){ "\n" + spaces }
+      return inspection.lstrip
+    end
+
+    def format_assertion_result(assertion_source, inspection)
+      spaces = " --> ".length
+      inspection = format_inspection(inspection, spaces)
+      return assertion_source.rstrip + "\n --> #{inspection.lstrip}\n"
+    end
+
+    def format_capture(width, snip, value)
+      return "#{ format_snip(width, snip) } --> #{ format_value(width, value) }"
+    end
+
+    def format_value(width, value)  #  TODO  width is a de-facto instance variable
+      width += 4
+      source = value.pretty_inspect.rstrip
+      return format_inspection(source, width)
+    end
+
+    def measure_capture(kap)
+      return kap.split("\n").inject(0){|x, v| v.strip.length > x ? v.strip.length : x } if kap.match("\n")
+      kap.length
+      # TODO  need the if?
+    end
+
+  end
+  
+  def colorize(to_color)
+    RubyReflector.new.colorize(to_color)
+  end
+
+  #  TODO  work with raw MiniTest 
+
+  # This is a copy of the classic assert, so your pre-existing
+  # +assert+ calls will not change their behavior
+  #
+  if defined? MiniTest::Assertion 
+    def assert_classic(test, msg=nil)
+      msg ||= "Failed assertion, no message given."
+      self._assertions += 1
+      unless test then
+        msg = msg.call if Proc === msg
+        raise MiniTest::Assertion, msg
+      end
+      true
+    end
+    
+    def add_assertion
+      self._assertions += 1
+    end
+  else
+    def assert_classic(boolean, message=nil)
+      #_wrap_assertion do
+        assert_block("assert<classic> should not be called with a block.") { !block_given? }
+        assert_block(build_message(message, "<?> is not true.", boolean)) { boolean }
+      #end
+    end
+  end
+
+  #  The new <code>assert()</code> calls this to interpret
+  #  blocks of assertive statements.
+  #
+  def assert_(diagnostic = nil, options = {}, &block)
+    options[:keep_diagnostics] or add_diagnostic :clear
+    
+    begin
+      if got = block.call(*options[:args])
+        add_assertion
+        return got
+      end
+    rescue FlunkError
+      raise  #  asserts inside assertions that fail do not decorate the outer assertion
+    rescue => got
+      add_exception got
+    end
+
+    flunk diagnose(diagnostic, got, caller[1], options, block)
+  end
+
+  def add_exception(ex)
+    ex.backtrace[0..10].each do |line|
+      add_diagnostic '  ' + line
+    end
+  end
+
+  #  This assertion replaces:
+  #  
+  #  - +assert_nil+
+  #  - +assert_no_match+
+  #  - +assert_not_equal+
+  #
+  #  It faults, and prints its block's contents and values,
+  #  if its block returns non-+false+ and non-+nil+.
+  #  
+  def deny(diagnostic = nil, options = {}, &block)
+      #  "None shall pass!" --the Black Knight
+      
+    options[:keep_diagnostics] or add_diagnostic :clear
+    
+    begin
+      got = block.call(*options[:args]) or (add_assertion and return true)
+    rescue FlunkError
+      raise
+    rescue => got
+      add_exception got
+    end
+  
+    flunk diagnose(diagnostic, got, caller[0], options, block)
+  end  #  "You're a looney!"  -- King Arthur
+
+  def deny_(diagnostic = nil, options = {}, &block)
+      #  "None shall pass!" --the Black Knight
+      
+    options[:keep_diagnostics] or add_diagnostic :clear
+    
+    begin
+      got = block.call(*options[:args]) or (add_assertion and return true)
+    rescue FlunkError
+      raise
+    rescue => got
+      add_exception got
+    end
+  
+    flunk diagnose(diagnostic, got, caller[0], options, block)
+  end  #  "You're a looney!"  -- King Arthur
+
+#  FIXME  document why this deny_ is here, and how to alias it back to deny
+
+  alias denigh deny  #  to line assert{ ... } and 
+                     #          denigh{ ... } statements up neatly!
+
+  #~ def __reflect_assertion(called, options, block, got)
+    #~ effect = RubyReflector.new(called)
+    #~ effect.args = *options[:args]
+    #~ return effect.reflect_assertion(block, got)
+  #~ end
+
+  #~ def __reflect_assertion(called, options, block, got)
+    #~ effect = RubyReflector.new(called)
+    #~ effect.args = *options[:args]
+    #~ effect.block = block
+    #~ return effect.reflect_assertion(block, got)  #  TODO  merge this and its copies into assert2_utilities
+  #~ end
+
+  #!doc!
+  def diagnose(diagnostic = nil, got = nil, called = caller[0],
+                options = {}, block = nil)                    #   TODO  make this directly callable
+    rf = RubyReflector.new
+    rf.diagnose(diagnostic, got, called, options, block, @__additional_diagnostics)
+    #~ options = { :args => [] }.merge(options)
+     #~ # CONSIDER only capture the block_vars if there be args?
+    #~ @__additional_diagnostics.unshift diagnostic
+    #~ return __build_message(__reflect_assertion(called, options, block, got))
+  end
+
+if RubyReflector::HAS_RUBYNODE
+  #  wrap this common idiom:
+  #    foo = assemble()
+  #    deny{ foo.bar() }
+  #    foo.activate()
+  #    assert{ foo.bar() }
+  #
+  #  that becomes:
+  #    foo = assemble()
+  #
+  #    assert_yin_yang proc{ foo.bar() } do
+  #      foo.activate()
+  #    end
+  #
+  def assert_yin_yang(*args, &block)
+      # prock(s), diagnostic = nil, &block)
+    procks, diagnostic = args.partition{|p| p.respond_to? :call }
+    block ||= procks.shift
+    source = reflect_source(&block)
+    fuss = [diagnostic, "fault before calling:", source].compact.join("\n")
+    procks.each do |prock|  deny(fuss, &prock);  end
+    block.call
+    fuss = [diagnostic, "fault after calling:", source].compact.join("\n")
+    procks.each do |prock|  assert(fuss, &prock);  end
+  end
+
+  #  the prock assertion must pass on both sides of the called block
+  #
+  def deny_yin_yang(*args, &block)
+      # prock(s), diagnostic = nil, &block)
+    procks, diagnostic = args.partition{|p| p.respond_to? :call }
+    block ||= procks.shift
+    source = reflect_source(&block)
+    fuss = [diagnostic, "fault before calling:", source].compact.join("\n")
+    procks.each do |prock|  assert(fuss, &prock);  end
+    block.call
+    fuss = [diagnostic, "fault after calling:", source].compact.join("\n")
+    procks.each do |prock|  assert(fuss, &prock);  end
+  end
+
+end
+
+end ; end ; end
+
+class File
+  def self.write(filename, contents)
+    open(filename, 'w'){|f|  f.write(contents)  }
+  end
+end

data/lib/assert2/rubynode_reflector.rb

@@ -1,76 +1,75 @@
-require 'pp'
-
-
-module Test; module Unit; module Assertions
-
-  # ERGO
-  #		:bmethod      => [:cval],
-  #		:cfunc        => [:argc, :cfnc],
-  #		:cref         => [:next, :clss],
-  #		:defs         => [:mid, :defn, :recv],
-  #		:dmethod      => [:cval],
-  #		:dot2         => [:beg, :end],
-  #		:dot3         => [:beg, :end],
-  #		:dregx_once   => [:next, :lit, :cflag],
-  #		:fbody        => [:orig, :mid, :head],
-  #		:flip2        => [:cnt, :beg, :end],
-  #		:flip3        => [:cnt, :beg, :end],
-  #		:gasgn        => [:vid, :value], # entry not supported
-  #		:ifunc        => [:tval, :state, :cfnc],
-  #		:lasgn        => [:vid, :cnt, :value],
-  #		:last         => [],
-  #		:match        => [:lit],
-  #		:memo         => {:u1_value=>:u1_value}, # different uses in enum.c, variabe.c and eval.c ...
-  #		:method       => [:body, :noex, :cnt], # cnt seems to be always 0 in 1.8.4
-  #		:module       => [:cpath, :body],
-  #		:next         => [:stts],
-  #		:opt_n        => [:body],
-  #		:to_ary       => [:head],
-
-  #  This +reflect+s a block of code, by evaluating it, reflecting its
-  #  source, and reflecting all its intermediate values
-  #
-  def reflect(&block)
-    result = block.call
+require 'pp'
+
+
+module Test; module Unit; module Assertions
+
+  # ERGO
+  #     :bmethod      => [:cval],
+  #     :cfunc        => [:argc, :cfnc],
+  #     :cref         => [:next, :clss],
+  #     :defs         => [:mid, :defn, :recv],
+  #     :dmethod      => [:cval],
+  #     :dot2         => [:beg, :end],
+  #     :dot3         => [:beg, :end],
+  #     :dregx_once   => [:next, :lit, :cflag],
+  #     :fbody        => [:orig, :mid, :head],
+  #     :flip2        => [:cnt, :beg, :end],
+  #     :flip3        => [:cnt, :beg, :end],
+  #     :gasgn        => [:vid, :value], # entry not supported
+  #     :ifunc        => [:tval, :state, :cfnc],
+  #     :lasgn        => [:vid, :cnt, :value],
+  #     :last         => [],
+  #     :match        => [:lit],
+  #     :memo         => {:u1_value=>:u1_value}, # different uses in enum.c, variabe.c and eval.c ...
+  #     :method       => [:body, :noex, :cnt], # cnt seems to be always 0 in 1.8.4
+  #     :module       => [:cpath, :body],
+  #     :next         => [:stts],
+  #     :opt_n        => [:body],
+  #     :to_ary       => [:head],
+
+  #  This +reflect+s a block of code, by evaluating it, reflecting its
+  #  source, and reflecting all its intermediate values
+  #
+  def reflect(&block)
+    result = block.call
     rf = RubyReflector.new
-    rf.block = block
-    
-    begin
-      waz = rf.colorize?
-      rf.colorize(false)
-      return rf.result + rf.arrow_result(result) + "\n" + rf.format_evaluations
-    ensure
-      rf.colorize(waz)
-    end
-  end
- 
-  #  This +reflect+s a block of code, /without/ evaluating it.
-  #  The function only compiles the source and reflects it as
-  #  a string of disassembled Ruby
-  #  
-  def reflect_source(&block)
+    rf.block = block
+    
+    begin
+      waz = rf.colorize?
+      rf.colorize(false)
+      return rf.result + rf.arrow_result(result) + "\n" + rf.format_evaluations
+    ensure
+      rf.colorize(waz)
+    end
+  end
+ 
+  #  This +reflect+s a block of code, /without/ evaluating it.
+  #  The function only compiles the source and reflects it as
+  #  a string of disassembled Ruby
+  #  
+  def reflect_source(&block)
     rf = RubyReflector.new(nil, false)
     rf.block = block
-    return rf.result
-  end
-
-  #  This compiles a string and +reflect+s its source...
-  #  as another string.
-  #  
+    return rf.result
+  end
+
+  #  This compiles a string and +reflect+s its source...
+  #  as another string.
+  #  
   def reflect_string(string)
     rf = RubyReflector.new # def initialize
     rf.block = proc{}
-    rf.reflect_values = false
-      # pp string.parse_to_nodes.transform
-    got = rf.reflect_nodes(string.parse_to_nodes)
-    return got
-  end
-
+    rf.reflect_values = false
+      # pp string.parse_to_nodes.transform
+    got = rf.reflect_nodes(string.parse_to_nodes)
+    return got
+  end
+
   class RubyReflector  #  this class turns hamburger back into live cattle
     HAS_RIPPER = false
-    
+    
     begin
-      raise LoadError, 'whatever' if ENV['TEST_ASSERT_2_IN_1_8_7_MODE'] == 'true'
       require 'rubygems'
       require 'rubynode'
       HAS_RUBYNODE = true
@@ -78,744 +77,745 @@ module Test; module Unit; module Assertions
       HAS_RUBYNODE = false
     end
 
-    attr_reader :evaluations,
-                :result,
-                :transformation
-    attr_writer :block,
-                :reflect_values
-
+    attr_reader :evaluations,
+                :result,
+                :transformation
+    attr_writer :block,
+                :reflect_values
+
     def initialize(called = nil, yo_block = nil, reflect_values = true)  #  note that a block, from your context, is not optional
-        #  FIXME  these args are bogus use or lose
-      @reflect_values = reflect_values
-      @evaluations    = []
-      @result         = ''
-      @line           = 0
-      self.block      = yo_block
-    end
-
+        #  FIXME  these args are bogus use or lose
+      @reflect_values = reflect_values
+      @evaluations    = []
+      @result         = ''
+      @line           = 0
+      self.block      = yo_block
+    end
+
     def block=(yo_block)
-      @block = yo_block and HAS_RUBYNODE and
-        reflect_nodes(@block.body_node)
-    end
-
-    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 }"
-      raise
-    end
-
-    def absorb_block_args(code_fragments)  #  CONSIDER a suckier way of detecting 
-      @captured_block_vars = nil      #  the block args is indeed remotely possible...
-      if code_fragments.first =~ /\|(.*)\|/ or code_fragments[1].to_s =~ /\|(.*)\|/
-        @captured_block_vars = $1
-      end
-    end
-
-    def detect(expression)
-      expr = expression
-      $__args = nil
-      if @args and @captured_block_vars
-        expr = "#{@captured_block_vars} = $__args.kind_of?(Array) && $__args.length == 1 ? $__args.first : $__args\n" + 
-                expr
-        $__args = @args
-      end
-
-      begin
-        intermediate = eval(expr, @block.binding)
-        @evaluations << [expression, intermediate, nil]
-      rescue SyntaxError => e
-        if e.message.index('syntax error, unexpected \',\'') and expression !~ /\[ /
-          return detect('[ ' + expression + ' ]')
-        end  #  faint prayer to infinite recursion diety here! (-;
-
-        @evaluations << [expression, nil, e.message]
-      rescue => e
-        @evaluations << [expression, nil, e.message]
-      end
-    end
-
-    def eval_intermediate(expression)
-      detect(expression)  if @reflect_values
-      return expression
-    end
-
-    def short_inspect(intermediate)
-      pretty = intermediate.inspect
-      #  ERGO  Proc is prob'ly rare here!
-      pretty = { '#<Proc' => '<Proc>' }.fetch(pretty.split(':').first, pretty)
-      prettier = pretty[0..90]
-      prettier << '*** '  unless prettier == pretty
-      return prettier
-    end
-    private :short_inspect
-
-    #  ERGO  spew the backrefs (?) any regular expression matchers may emit!
-    #  ERGO  don't eval the caller of a block without its block!
-    
-    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
-
-    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
-
-    %w( args beg body cond cpath defn else end ensr 
-        first head iter ivar lit mid next second
-        stts recv resq rest value var vid ).each do |sender|
-      define_method sender + '_' do |node, *args|
-        return _send(node[sender.to_sym], *args)
-      end
-    end
-    
-    ########################################################
-    ####  structures
-
-    def _block(node)
-      return node.map{|n| _send(n, "\n") }.join
-    end
-
-    def _module(node, what = 'module')
-      return what + ' ' + cpath_(node) + "\n" + 
-               body_(node) + 
-           "\nend\n"
-    end
-
-    def _method(node)
-p node
-      return ''
-    end
-
-    def _class(node); _module(node, 'class');  end
-    def _self(node); 'self'; end
-    def _defn(node); _defs(node); end
-    def _super(node); 'super(' + args_(node) + ')'; end
-    def _zsuper(node); 'super'; end
-    def _begin(node); "begin\n" + body_(node) + "\nend\n"; end
-    def _ensure(node); head_(node) + "\nensure\n" + ensr_(node); end
-
-    def _sclass(node)
-      return 'class << ' + recv_(node) + 
-                head_body(node) + 
-             "end\n"
-    end
-
-    class ScopeMethod #:nodoc:
-        #  this is complex because Ruby gloms several different
-        #  kinds of variables into one "scope" token, and they
-        #  don't directly match their layout in the source code
-        
-      def _scopic(ref, node)
-        @ref        = ref
-        @node       = node
-        @expression = ''
-        @previously = false
-        @block_arg  = false
-        @splat_arg  = false
-        @previous_splat = false
-        
-        if @node[:tbl]
-          @expression << '('
-          render_argument_list
-          @expression << ')'
-        end
-        
-        @expression << "\n"
-        @expression << @ref.next_(@node)
-        return @expression
-      end
-      
-      def ulterior_comma(token)
-        @expression << ', ' if @index > 0
-        @expression << token
-        @index = 0
-      end
-      
-      def possible_comma(token)
-        @expression << ', ' if @index > 0
-        @expression << @ref._send(token)
-      end
-
-      def render_argument_list
-        @nekst = @node[:next]
-        @block = @nekst.last       if @nekst && @nekst.first == :block
-        @args  = @block.first.last if @block && @block.first.first == :args
-        @rest  = @args[:rest]      if @args
-        @opt   = @args[:opt]       if @args
-
-        @node[:tbl].each_with_index do |_n, _index|
-          @n, @index = _n, _index
-          render_argument
-          break if @block_arg
-        end
-      end
-      
-      def render_argument
-        @splat_arg = @block_arg = false
-
-        if @rest and @rest.first == :lasgn and 
-            (@n == nil or @rest.last[:vid] == @n)
-          ulterior_comma('*')
-          @splat_arg = true
-        end
-
-        if @block and (ba = @block[1]) and
-            ba.first == :block_arg and ba.last[:vid] == @n
-          ulterior_comma('&')
-          @block_arg = true
-        end
-
-        #  ERGO  Ruby 1.9 changes these rules!!
-
-        if !@previous_splat or @block_arg
-          if @opt and @opt.first == :block and #  ERGO  why a @block??
-            (lasgn = @opt.last.first).first == :lasgn and
-              lasgn.last[:vid] == @n
-            @previously = true
-            possible_comma(@opt.last.first)
-          else
-            possible_comma(@n)
-            @expression << ' = nil' if @previously and !@block_arg and !@splat_arg
-          end
-
-          @previous_splat ||= @splat_arg
-        end
-      end
-    end
-    
-    def _scope(node)
-      return ScopeMethod.new._scopic(self, node)
-    end
-
-    def _defs(node)
-      return 'def ' + recv_(node, '.') + mid_(node) + 
-               defn_(node) + 
-             "end\n"
-    end
-
-    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
-
-    def _resbody(node)
-      return body_(node)
-        # already emitted: head_(node) + ' ' + args_(node)
-    end
-
-    def _yield(node)
-      exp = 'yield'
-      exp << '(' + head_(node) + ')'  if node[:head]
-      return exp
-    end
-    
-    def _alias(node)
-      return "alias #{ lit_(node[:new].last) } #{ lit_(node[:old].last) }"
-    end
-    
-    def _valias(node)
-      return "alias #{ node[:new] } #{ node[:old] }"
-    end
-    
-    ########################################################
-    ####  control flow
-    
-    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
-
-    def _while(node, concept = 'while')
-      return '( ' + concept + ' ' + cond_(node) + 
-                  head_body(node) + 
-             "\nend )"
-    end
-
-    def _for(node)
-      return '( for ' + var_(node) + ' in ' + iter_(node) + "\n" +
-                  body_(node) + "\n" +
-               'end )'
-    end
-
-    def _args(node); return ''; end  #  _call and _fcall insert the real args
-    def _until(node); _while(node, 'until'); end
-    def _break(node); 'break'; end
-    def _next(node); 'next' ; end
-    def _case(node); '( case ' + head_body(node) + "\nend )"; end
-    def _when(node); 'when ' + head_body(node) + "\n" + next_(node); end
-    def _retry(node); 'retry'; end
-    def _redo(node); 'redo'; end
-    def head_body(node); head_(node) + "\n" + body_(node); end
-
-    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
-        
-    def _postexe(node)
-      raise '_postexe called with unexpected arguments' unless node == {} or node.keys == [:node]
-      return 'END'
-    end
-
-    #		:argscat      => [:body, :head],
-
-    ########################################################
-    ####  assignments
-    
-    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
-    
-    def _cdecl(node)
-      return _send(node[ node[:vid] == 0 ? :else : :vid ]) + ' = ' + value_(node)
-    end
-    
-    def _dasgn(node); _dasgn_curr(node); end
-    def _iasgn(node); _dasgn_curr(node); end
-    def _gasgn(node); _dasgn_curr(node); end
-    def _lasgn(node); _dasgn_curr(node); end
-    def _cvasgn(node); _dasgn_curr(node); end
-    
-    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
-
-    ########################################################
-    ####  operators
-    
-    def _and(node, und = 'and')
-      return eval_intermediate( '( ' +
-               eval_parenz{ first_(node)} + ' ' + und + ' ' +
-               eval_parenz{second_(node)} + ' )' )
-    end
-    
-    def _back_ref(node); '$' + node[:nth].chr; end
-    def _colon2(node); head_(node, '::') + mid_(node); end
-    def _colon3(node); '::' + mid_(node); end
-    def _cvar(node); _lvar(node); end
-    def _cvdecl(node); vid_(node) + ' = ' + value_(node); end
-    def _defined(node); 'defined? ' + head_(node); end
-    def _dot2(node); '( ' + beg_(node) + ' .. '  + end_(node) + ' )'; end
-    def _dot3(node); '( ' + beg_(node) + ' ... ' + end_(node) + ' )'; end
-    def _dregx(node); _dstr(node, '/'); end
-    def _dregx_once(node); _dstr(node, '/'); end
-    def _dsym(node); ':' + _lit(node[:lit]) + ' ' + rest_(node); end
-    def _dvar(node); eval_intermediate(vid_(node)); end
-    def _dxstr(node); _dstr(node, '`'); end
-    def  eval_parenz; eval_intermediate('( ' + yield + ' )'); end
-    def _evstr(node); body_(node); end
-    def _false(nada); 'false'; end
-    def _gvar(node); vid_(node); end
-    def _ivar(node); _dvar(node); end
-    def _lit(node); node[:lit].inspect; end
-    def _lvar(node); eval_intermediate(vid_(node)); end
-    def _match(node); node[:lit].inspect; end
-    def  neg_one(node); node == -1 ? '' : _send(node); end
-    def _nil(nada); 'nil'  ; end
-    def _not(node); '(not(' + body_(node) + '))'; end
-    def _nth_ref(node); "$#{ node[:nth] }"; end #  ERGO  eval it?
-    def _op_asgn_and(node); _op_asgn_or(node, ' &&= '); end
-    def _or(node); _and(node, 'or'); end
-    def _str(node); _lit(node); end
-    def _svalue(node); head_(node); end
-    def _to_ary(node); head_(node); end
-    def _true(nada); 'true' ; end
-    def _undef(node); 'undef ' + mid_(node); end
-    def _vcall(node); mid_(node); end
-    def  we_b(node); node.first.first; end
-    def _xstr(node); '`' + scrape_literal(node) + '`'; end
-    def _zarray(node); return '[]'; end
-    
-    def _flip2(node)  #  ERGO  what the heck is this??
-      p node
-      p node.keys
-      return ''
-    end
-        
-    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
-
-    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  #  ERGO  raise if any other key!
-    
-    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
-
-    def scrape_literal(node, regex = false)
-      lit = node[:lit].inspect.gsub(/^"/, '').gsub(/"$/, '')
-      lit.gsub!('\\\\', '\\')  if regex
-      return lit
-    end
-
-    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
-
-    def _retry(node)
-      raise '_retry called with unexpected arguments' unless node == {} or node.keys == [:node]
-      return 'retry'
-    end
-
-    def recv_zero_self(node, plus = '')
-      recv = node[:recv]
-      return 'self' + plus  if recv == 0
-      return recv_(node, plus)
-    end
-
-    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
-    
-    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
-       
-    def fcall_args(node = nil, methodic = false)
-      expression = ''
-      return expression  unless node
-      expression << ' '  unless methodic
-      return expression + nest_if(methodic, '(', ')'){  _send(node)  }
-    end    
-    
-    def _fcall(node)
-      exp = mid_(node) + fcall_args(node[:args], true)
-      eval_intermediate(exp) unless %w(lambda proc).include?(exp)
-      return exp
-    end
-
-    def _block_pass(node)
-      fcall = node[:iter].last
-      return eval_intermediate(recv_(fcall, '.') +
-                mid_(fcall) + '(' + args_(fcall, ', ') +
-                '&' + body_(node) + ')' )
-    end
-
-    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
-
-    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
-
-    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
-    
-    def _match2(node)
-      #  ERGO  should this work like match3?
-      return recv_(node) + ' =~ ' + value_(node)
-    end
-    
-    def we_b_op(node)
-      return node[:mid] && node[:mid].to_s !~ /^[a-z]/i
-    end
-    
-    def _match3(node)
-      #  ERGO  do :lit and :value exclude each other?
-      return recv_(node) + ' =~ ' + _send(node[:lit] || node[:value])
-    end
-    
-    def _block_arg(node)  #  is this ever called?
-      return ''  #  note that _scope should not take care of this
-    end
-    
-    class CallMethod
-      def bracket_args
-        return false unless @mid == '[]'
-        @expression << '[' + @ref.args_(@node) + ']'
-        return true
-      end
-
-      def insert_method_call
-        @expression << '.'
-        @expression << @mid
-        @expression << '(' + @ref.args_(@node) + ')'
-        @ref.eval_intermediate(@expression) if @methodic
-      end
-      
-      def operator_and_arguments
-        @mid = @ref.mid_(@node)
-
-        unless bracket_args
-          @methodic = @mid =~ /[a-z]/i
-
-          if @methodic
-            insert_method_call
-          else
-            @expression << ' '
-            @expression << @mid
-            @expression << ' '
-            nest_args
-          end
-        end
-      end
-      
-      def nest_args
-        return unless @args = @node[:args]
-        
-        nest_me = @args.first == :array && 
-                  @args.last.length == 1 &&
-                  (call = @args.last.first).first == :call &&
-                  @ref.we_b_op(call.last)
-
-        exp = @ref.nest_if(nest_me, '( ', ' )'){ @ref.args_(@node) }
-        @ref.eval_intermediate(exp) if nest_me
-        @expression << exp
-      end
-
-      def caller(ref, node)
-        @ref, @node = ref, node
-        @expression = ''
-        @recv    = @node[:recv]
-
-        if @recv.first == :block_pass
-          @expression << @ref.recv_(@node)
-          operator_and_arguments
-        else
-          nest_me = @recv.first == :call && @ref.we_b_op(@recv.last)
-
-          exp = if @recv.first == :array
-            @ref.nest_if(true, '[ ', ' ]'){ @ref.recv_(node) }
-          else
-            exp2 = @ref.nest_if(nest_me, '( ', ' )'){ @ref.recv_(node) }
-            @ref.eval_intermediate(exp2)  if nest_me
-            exp2
-          end
-
-          @expression << exp
-          operator_and_arguments
-        end
-        return @expression
-      end
-    end
-
-    def _call(node);  CallMethod.new.caller(self, node);  end
-
-    def nest_if(condition, before, after, &block)
-      exp = ''
-      exp << before  if condition
-      exp << (block.call || '')
-      exp << after   if condition
-      return exp
-    end
-
-    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
-    
-    def _argscat(node)
-      return head_(node) + ', *' + 
-               nest_if(node[:body].first == :array, '[', ']'){ body_(node) }
-    end
+      @block = yo_block and @block.respond_to?(:body_node) and
+        reflect_nodes(@block.body_node)
+    end
+
+    def reflect_nodes(body_node)
+      if body_node
+        @transformation = body_node.transform(:include_node => true)
+        return @result = _send(@transformation)
+      end
+    rescue
+      puts "\nOffending line: #{ @line }"
+      raise
+    end
+
+    def absorb_block_args(code_fragments)  #  CONSIDER a suckier way of detecting 
+      @captured_block_vars = nil      #  the block args is indeed remotely possible...
+      if code_fragments.first =~ /\|(.*)\|/ or code_fragments[1].to_s =~ /\|(.*)\|/
+        @captured_block_vars = $1
+      end
+    end
+
+    def detect(expression)
+      expr = expression
+      $__args = nil
+      if @args and @captured_block_vars
+        expr = "#{@captured_block_vars} = $__args.kind_of?(Array) && $__args.length == 1 ? $__args.first : $__args\n" + 
+                expr
+        $__args = @args
+      end
+
+      begin
+        intermediate = eval(expr, @block.binding)
+        @evaluations << [expression, intermediate, nil]
+      rescue SyntaxError => e
+        if e.message.index('syntax error, unexpected \',\'') and expression !~ /\[ /
+          return detect('[ ' + expression + ' ]')
+        end  #  faint prayer to infinite recursion diety here! (-;
+
+        @evaluations << [expression, nil, e.message]
+      rescue => e
+        @evaluations << [expression, nil, e.message]
+      end
+    end
+
+    def eval_intermediate(expression)
+      detect(expression)  if @reflect_values
+      return expression
+    end
+
+    def short_inspect(intermediate)
+      pretty = intermediate.inspect
+      #  ERGO  Proc is prob'ly rare here!
+      pretty = { '#<Proc' => '<Proc>' }.fetch(pretty.split(':').first, pretty)
+      prettier = pretty[0..90]
+      prettier << '*** '  unless prettier == pretty
+      return prettier
+    end
+    private :short_inspect
+
+    #  ERGO  spew the backrefs (?) any regular expression matchers may emit!
+    #  ERGO  don't eval the caller of a block without its block!
+    
+    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
+
+    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
+
+    %w( args beg body cond cpath defn else end ensr 
+        first head iter ivar lit mid next second
+        stts recv resq rest value var vid ).each do |sender|
+      define_method sender + '_' do |node, *args|
+        return _send(node[sender.to_sym], *args)
+      end
+    end
+    
+    ########################################################
+    ####  structures
+
+    def _block(node)
+      return node.map{|n| _send(n, "\n") }.join
+    end
+
+    def _module(node, what = 'module')
+      return what + ' ' + cpath_(node) + "\n" + 
+               body_(node) + 
+           "\nend\n"
+    end
+
+    def _method(node)
+p node
+      return ''
+    end
+
+    def _class(node); _module(node, 'class');  end
+    def _self(node); 'self'; end
+    def _defn(node); _defs(node); end
+    def _super(node); 'super(' + args_(node) + ')'; end
+    def _zsuper(node); 'super'; end
+    def _begin(node); "begin\n" + body_(node) + "\nend\n"; end
+    def _ensure(node); head_(node) + "\nensure\n" + ensr_(node); end
+
+    def _sclass(node)
+      return 'class << ' + recv_(node) + 
+                head_body(node) + 
+             "end\n"
+    end
+
+    class ScopeMethod #:nodoc:
+        #  this is complex because Ruby gloms several different
+        #  kinds of variables into one "scope" token, and they
+        #  don't directly match their layout in the source code
+        
+      def _scopic(ref, node)
+        @ref        = ref
+        @node       = node
+        @expression = ''
+        @previously = false
+        @block_arg  = false
+        @splat_arg  = false
+        @previous_splat = false
+        
+        if @node[:tbl]
+          @expression << '('
+          render_argument_list
+          @expression << ')'
+        end
+        
+        @expression << "\n"
+        @expression << @ref.next_(@node)
+        return @expression
+      end
+      
+      def ulterior_comma(token)
+        @expression << ', ' if @index > 0
+        @expression << token
+        @index = 0
+      end
+      
+      def possible_comma(token)
+        @expression << ', ' if @index > 0
+        @expression << @ref._send(token)
+      end
+
+      def render_argument_list
+        @nekst = @node[:next]
+        @block = @nekst.last       if @nekst && @nekst.first == :block
+        @args  = @block.first.last if @block && @block.first.first == :args
+        @rest  = @args[:rest]      if @args
+        @opt   = @args[:opt]       if @args
+
+        @node[:tbl].each_with_index do |_n, _index|
+          @n, @index = _n, _index
+          render_argument
+          break if @block_arg
+        end
+      end
+      
+      def render_argument
+        @splat_arg = @block_arg = false
+
+        if @rest and @rest.first == :lasgn and 
+            (@n == nil or @rest.last[:vid] == @n)
+          ulterior_comma('*')
+          @splat_arg = true
+        end
+
+        if @block and (ba = @block[1]) and
+            ba.first == :block_arg and ba.last[:vid] == @n
+          ulterior_comma('&')
+          @block_arg = true
+        end
+
+        #  ERGO  Ruby 1.9 changes these rules!!
+
+        if !@previous_splat or @block_arg
+          if @opt and @opt.first == :block and #  ERGO  why a @block??
+            (lasgn = @opt.last.first).first == :lasgn and
+              lasgn.last[:vid] == @n
+            @previously = true
+            possible_comma(@opt.last.first)
+          else
+            possible_comma(@n)
+            @expression << ' = nil' if @previously and !@block_arg and !@splat_arg
+          end
+
+          @previous_splat ||= @splat_arg
+        end
+      end
+    end
+    
+    def _scope(node)
+      return ScopeMethod.new._scopic(self, node)
+    end
+
+    def _defs(node)
+      return 'def ' + recv_(node, '.') + mid_(node) + 
+               defn_(node) + 
+             "end\n"
+    end
+
+    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
+
+    def _resbody(node)
+      return body_(node)
+        # already emitted: head_(node) + ' ' + args_(node)
+    end
+
+    def _yield(node)
+      exp = 'yield'
+      exp << '(' + head_(node) + ')'  if node[:head]
+      return exp
+    end
+    
+    def _alias(node)
+      return "alias #{ lit_(node[:new].last) } #{ lit_(node[:old].last) }"
+    end
+    
+    def _valias(node)
+      return "alias #{ node[:new] } #{ node[:old] }"
+    end
+    
+    ########################################################
+    ####  control flow
+    
+    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
+
+    def _while(node, concept = 'while')
+      return '( ' + concept + ' ' + cond_(node) + 
+                  head_body(node) + 
+             "\nend )"
+    end
+
+    def _for(node)
+      return '( for ' + var_(node) + ' in ' + iter_(node) + "\n" +
+                  body_(node) + "\n" +
+               'end )'
+    end
+
+    def _args(node); return ''; end  #  _call and _fcall insert the real args
+    def _until(node); _while(node, 'until'); end
+    def _break(node); 'break'; end
+    def _next(node); 'next' ; end
+    def _case(node); '( case ' + head_body(node) + "\nend )"; end
+    def _when(node); 'when ' + head_body(node) + "\n" + next_(node); end
+    def _retry(node); 'retry'; end
+    def _redo(node); 'redo'; end
+    def head_body(node); head_(node) + "\n" + body_(node); end
+
+    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
+        
+    def _postexe(node)
+      raise '_postexe called with unexpected arguments' unless node == {} or node.keys == [:node]
+      return 'END'
+    end
+
+    #       :argscat      => [:body, :head],
+
+    ########################################################
+    ####  assignments
+    
+    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
+    
+    def _cdecl(node)
+      return _send(node[ node[:vid] == 0 ? :else : :vid ]) + ' = ' + value_(node)
+    end
+    
+    def _dasgn(node); _dasgn_curr(node); end
+    def _iasgn(node); _dasgn_curr(node); end
+    def _gasgn(node); _dasgn_curr(node); end
+    def _lasgn(node); _dasgn_curr(node); end
+    def _cvasgn(node); _dasgn_curr(node); end
+    
+    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
+
+    ########################################################
+    ####  operators
+    
+    def _and(node, und = 'and')
+      return eval_intermediate( '( ' +
+               eval_parenz{ first_(node)} + ' ' + und + ' ' +
+               eval_parenz{second_(node)} + ' )' )
+    end
+    
+    def _back_ref(node); '$' + node[:nth].chr; end
+    def _colon2(node); head_(node, '::') + mid_(node); end
+    def _colon3(node); '::' + mid_(node); end
+    def _cvar(node); _lvar(node); end
+    def _cvdecl(node); vid_(node) + ' = ' + value_(node); end
+    def _defined(node); 'defined? ' + head_(node); end
+    def _dot2(node); '( ' + beg_(node) + ' .. '  + end_(node) + ' )'; end
+    def _dot3(node); '( ' + beg_(node) + ' ... ' + end_(node) + ' )'; end
+    def _dregx(node); _dstr(node, '/'); end
+    def _dregx_once(node); _dstr(node, '/'); end
+    def _dsym(node); ':' + _lit(node[:lit]) + ' ' + rest_(node); end
+    def _dvar(node); eval_intermediate(vid_(node)); end
+    def _dxstr(node); _dstr(node, '`'); end
+    def  eval_parenz; eval_intermediate('( ' + yield + ' )'); end
+    def _evstr(node); body_(node); end
+    def _false(nada); 'false'; end
+    def _gvar(node); vid_(node); end
+    def _ivar(node); _dvar(node); end
+    def _lit(node); node[:lit].inspect; end
+    def _lvar(node); eval_intermediate(vid_(node)); end
+    def _match(node); node[:lit].inspect; end
+    def  neg_one(node); node == -1 ? '' : _send(node); end
+    def _nil(nada); 'nil'  ; end
+    def _not(node); '(not(' + body_(node) + '))'; end
+    def _nth_ref(node); "$#{ node[:nth] }"; end #  ERGO  eval it?
+    def _op_asgn_and(node); _op_asgn_or(node, ' &&= '); end
+    def _or(node); _and(node, 'or'); end
+    def _str(node); _lit(node); end
+    def _svalue(node); head_(node); end
+    def _to_ary(node); head_(node); end
+    def _true(nada); 'true' ; end
+    def _undef(node); 'undef ' + mid_(node); end
+    def _vcall(node); mid_(node); end
+    def  we_b(node); node.first.first; end
+    def _xstr(node); '`' + scrape_literal(node) + '`'; end
+    def _zarray(node); return '[]'; end
+    
+    def _flip2(node)  #  ERGO  what the heck is this??
+      p node
+      p node.keys
+      return ''
+    end
+        
+    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
+
+    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  #  ERGO  raise if any other key!
+    
+    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
+
+    def scrape_literal(node, regex = false)
+      lit = node[:lit].inspect.gsub(/^"/, '').gsub(/"$/, '')
+      lit.gsub!('\\\\', '\\')  if regex
+      return lit
+    end
+
+    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
+
+    def _retry(node)
+      raise '_retry called with unexpected arguments' unless node == {} or node.keys == [:node]
+      return 'retry'
+    end
+
+    def recv_zero_self(node, plus = '')
+      recv = node[:recv]
+      return 'self' + plus  if recv == 0
+      return recv_(node, plus)
+    end
+
+    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
+    
+    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
+       
+    def fcall_args(node = nil, methodic = false)
+      expression = ''
+      return expression  unless node
+      expression << ' '  unless methodic
+      return expression + nest_if(methodic, '(', ')'){  _send(node)  }
+    end    
+    
+    def _fcall(node)
+      exp = mid_(node) + fcall_args(node[:args], true)
+      eval_intermediate(exp) unless %w(lambda proc).include?(exp)
+      return exp
+    end
+
+    def _block_pass(node)
+      fcall = node[:iter].last
+      return eval_intermediate(recv_(fcall, '.') +
+                mid_(fcall) + '(' + args_(fcall, ', ') +
+                '&' + body_(node) + ')' )
+    end
+
+    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
+
+    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
+
+    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
+    
+    def _match2(node)
+      #  ERGO  should this work like match3?
+      return recv_(node) + ' =~ ' + value_(node)
+    end
+    
+    def we_b_op(node)
+      return node[:mid] && node[:mid].to_s !~ /^[a-z]/i
+    end
+    
+    def _match3(node)
+      #  ERGO  do :lit and :value exclude each other?
+      return recv_(node) + ' =~ ' + _send(node[:lit] || node[:value])
+    end
+    
+    def _block_arg(node)  #  is this ever called?
+      return ''  #  note that _scope should not take care of this
+    end
+    
+    class CallMethod
+      def bracket_args
+        return false unless @mid == '[]'
+        @expression << '[' + @ref.args_(@node) + ']'
+        return true
+      end
+
+      def insert_method_call
+        @expression << '.'
+        @expression << @mid
+        @expression << '(' + @ref.args_(@node) + ')'
+        @ref.eval_intermediate(@expression) if @methodic
+      end
+      
+      def operator_and_arguments
+        @mid = @ref.mid_(@node)
+
+        unless bracket_args
+          @methodic = @mid =~ /[a-z]/i
+
+          if @methodic
+            insert_method_call
+          else
+            @expression << ' '
+            @expression << @mid
+            @expression << ' '
+            nest_args
+          end
+        end
+      end
+      
+      def nest_args
+        return unless @args = @node[:args]
+        
+        nest_me = @args.first == :array && 
+                  @args.last.length == 1 &&
+                  (call = @args.last.first).first == :call &&
+                  @ref.we_b_op(call.last)
+
+        exp = @ref.nest_if(nest_me, '( ', ' )'){ @ref.args_(@node) }
+        @ref.eval_intermediate(exp) if nest_me
+        @expression << exp
+      end
+
+      def caller(ref, node)
+        @ref, @node = ref, node
+        @expression = ''
+        @recv    = @node[:recv]
+
+        if @recv.first == :block_pass
+          @expression << @ref.recv_(@node)
+          operator_and_arguments
+        else
+          nest_me = @recv.first == :call && @ref.we_b_op(@recv.last)
+
+          exp = if @recv.first == :array
+            @ref.nest_if(true, '[ ', ' ]'){ @ref.recv_(node) }
+          else
+            exp2 = @ref.nest_if(nest_me, '( ', ' )'){ @ref.recv_(node) }
+            @ref.eval_intermediate(exp2)  if nest_me
+            exp2
+          end
+
+          @expression << exp
+          operator_and_arguments
+        end
+        return @expression
+      end
+    end
+
+    def _call(node);  CallMethod.new.caller(self, node);  end
+
+    def nest_if(condition, before, after, &block)
+      exp = ''
+      exp << before  if condition
+      exp << (block.call || '')
+      exp << after   if condition
+      return exp
+    end
+
+    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
+    
+    def _argscat(node)
+      return head_(node) + ', *' + 
+               nest_if(node[:body].first == :array, '[', ']'){ body_(node) }
+    end
 
     def diagnose(diagnostic, result, called, options, block, additional_diagnostics)
       @__additional_diagnostics = additional_diagnostics
@@ -843,18 +843,18 @@ p node
     def arrow_result(result) #:nodoc:
       return "\t--> #{ result.inspect }"
     end
-
-  end
-
-end; end; end
-
-unless [].respond_to? :in_groups_of
-  class Array
-    def in_groups_of(number, fill_with = nil, &block)
-      require 'enumerator'
-      collection = dup
-      collection << fill_with until collection.size.modulo(number).zero?
-      collection.each_slice(number, &block)
-    end
-  end
-end
+
+  end
+
+end; end; end
+
+unless [].respond_to? :in_groups_of
+  class Array
+    def in_groups_of(number, fill_with = nil, &block)
+      require 'enumerator'
+      collection = dup
+      collection << fill_with until collection.size.modulo(number).zero?
+      collection.each_slice(number, &block)
+    end
+  end
+end