lodestone-assert-agile 0.4.1

data/CHANGELOG

@@ -0,0 +1 @@
+0.4.1 Updated README

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Matt Petty (matt@kizmeta.com)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,16 @@
+A fork of Phlip's assert2 (http://assert2.rubyforge.org) with bug fixes and merged assert_latest
+
+assert { foo == 42 }
+
+# For Rails or anything responding to .maximum and .find
+assert_latest Account, User do 
+  account = Account.create(:name => 'Foo Mart')
+  account.users.create(:login => 'foo-guy')
+end
+
+# You can grab the created records thusly:
+account, user = assert_latest Account, User do 
+  account = Account.create(:name => 'Foo Mart')
+  account.users.create(:login => 'foo-guy')
+end
+

data/assert-agile.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+  s.name     = "assert-agile"
+  s.version  = "0.4.1"
+  s.date     = "2008-11-07"
+  s.summary  = "Assert with radioactive spider power."
+  s.email    = "matt@kizmeta.com"
+  s.homepage = "http://github.com/lodestone/assert-agile"
+  s.description = "Assertion Sugar. Better block assertions - Forked from assert2.rubyforge.org"
+  s.has_rdoc = true
+  s.authors  = ["Matt Petty"]
+  s.files    = [
+    "CHANGELOG", 
+    "LICENSE",
+    "assert-agile.gemspec",
+    "init.rb",
+    "install.rb",
+    "lib/assert_agile.rb", 
+    "lib/assert_latest_and_greatest.rb", 
+    "lib/ruby_reflector.rb",
+    "Rakefile", 
+    "README", 
+    "tasks/assert_agile_tasks.rb",
+    "test/assert_agile_test.rb",
+    "uninstall.rb"
+  ]
+  s.test_files = ["test/assert_agile_test.rb"]
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["CHANGELOG", "README"]
+  s.add_dependency("diff-lcs", ["> 0.0.0"])
+  s.add_dependency("mime-types", ["> 0.0.0"])
+  s.add_dependency("open4", ["> 0.0.0"])
+end

data/init.rb

@@ -0,0 +1 @@
+require 'assert_agile' if RAILS_ENV == 'test'

data/lib/assert_agile.rb

@@ -0,0 +1,219 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/ruby_reflector'
+require File.dirname(__FILE__) + '/assert_latest_and_greatest'
+
+
+#  FIXME  evaluate parts[3]
+#  ERGO  if the block is a block, decorate with do-end
+#  ERGO  decorate assert_latest's block at fault time
+
+module AssertAgile
+  
+  include RubyNodeReflector
+  include Coulor #:nodoc:
+  include AssertLatestAndGreatest
+  #  This assertion calls a block, and faults if this returns
+  #  +false+ or +nil+. The fault diagnostic will reflect the
+  #  intermediate value of 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.0 }</code> instead.
+  #
+  #  If no block is provided, the assertion calls +assert_classic+,
+  #  which simulates RubyUnit's standard <code>assert()</code>.
+  #  
+  #  Note: This only works for Ruby 1.8.6 so far...
+  #
+  def assert(*args, &block)
+    if block
+      assert_ args.first, '', &block
+    else
+      assert_classic *args
+    end
+  end
+
+  #  The new <code>assert()</code> calls this to interpret
+  #  blocks of assertive statements.
+  #
+  def assert_(diagnostic = nil, twizzler = '_', &block)
+      # puts reflect(&block) # activate this line and test to see all your successes!
+      result = nil
+      
+      begin
+	result = block.call
+      rescue => e
+        diagnostic = [diagnostic, e.inspect, *e.backtrace].compact.join("\n\t")
+       _flunk_2_0("\nassert#{ twizzler }{ ", diagnostic, block, result)
+      end
+      
+      add_assertion and return if result
+     _flunk_2_0("assert#{ twizzler }{ ", diagnostic, block, result)
+  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, &block)  
+      #  "None shall pass!" --the Black Knight
+      # puts reflect(&block) # activate this line and test to see all your denials!
+    result = nil
+    
+    begin
+      result = block.call
+    rescue => e
+      diagnostic = [diagnostic, e.inspect, *e.backtrace].compact.join("\n\t")
+     _flunk_2_0("\ndeny{ ", diagnostic, block, result)
+    end
+    
+    return unless result
+   _flunk_2_0('deny{ ', diagnostic, block, result)
+  end  #  "You're a looney!"  -- King Arthur
+
+  # Assert that a block raises a given Exception type matching 
+  # a given message
+  # 
+  # * +types+ - single exception class or array of classes
+  # * +matcher+ - Regular Expression to match the inner_text of XML nodes
+  # * +diagnostic+ - optional string to add to failure message
+  # * +block+ - Ruby statements that should raise an exception
+  #
+  # Examples:
+  # %transclude AssertXPathSuite#test_assert_raise_message_detects_assertion_failure
+  #
+  # %transclude AssertXPathSuite#test_assert_raise_message_raises_message
+  #
+  # See: {assert_raise - Don't Just Say "No"}[http://www.oreillynet.com/onlamp/blog/2007/07/assert_raise_on_ruby_dont_just.html]
+  #
+  def assert_raise_message(types, matcher, diagnostic = nil, &block)
+    args = [types].flatten + [diagnostic]
+    exception = assert_raise(*args, &block)
+    
+    assert_match matcher,
+                 exception.message,
+                 [ diagnostic, 
+                   "incorrect #{ exception.class.name 
+                     } message raised from block:", 
+                   "\t"+reflect_source(&block).split("\n").join("\n\t")
+                   ].compact.join("\n")
+    
+    return exception
+  end
+
+  def deny_raise_message(types, matcher, diagnostic = nil, &block) #:nodoc:
+    exception = assert_raise_message(types, //, diagnostic, &block)
+    
+    assert_no_match matcher,
+                 exception.message,
+                 [ diagnostic, 
+                   "exception #{ exception.class.name 
+                     } with this message should not raise from block:", 
+                   "\t"+reflect_source(&block).split("\n").join("\n\t")
+                   ].compact.join("\n")
+    
+    return exception.message
+  end
+
+  def assert_flunked(gripe, diagnostic = nil, &block) #:nodoc:
+    assert_raise_message Test::Unit::AssertionFailedError,
+                         gripe,
+                         diagnostic,
+                        &block
+  end
+
+  def deny_flunked(gripe, diagnostic = nil, &block) #:nodoc:
+    deny_raise_message Test::Unit::AssertionFailedError,
+                       gripe,
+                       diagnostic,
+                      &block
+  end  #  ERGO  move to assert{ 2.0 }, reflect, and leave there!
+
+  # This is a copy of the classic assert, so your pre�xisting
+  # +assert+ calls will not change their behavior
+  #
+  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
+  
+  #  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, 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(prock, diagnostic = nil, &block)
+    source = reflect_source(&block)
+    fuss = [diagnostic, "fault before calling:", source].compact.join("\n")
+    assert fuss, &prock
+    block.call
+    fuss = [diagnostic, "fault after calling:", source].compact.join("\n")
+    assert fuss, &prock
+  end
+
+  private
+    def build_message_(diagnostic, reflection)
+      diagnostic = nil if diagnostic == ''
+      return [diagnostic, reflection].compact.join("\n")
+    end
+
+    def _flunk_2_0(polarity, diagnostic, block, result)
+      rf = RubyReflector.new(block)
+      effect = " - should #{ 'not ' if polarity =~ /deny/ }pass\n"
+
+      report = magenta(polarity) + bold(rf.result) + magenta(" }") + 
+                red(arrow_result(result) + effect) + 
+                rf.format_evaluations
+              
+      flunk build_message_(diagnostic, report)
+    end
+  
+end  #  "Eagle-eyes it!"
+
+class Test::Unit::TestCase #:nodoc:
+  include AssertAgile
+end

data/lib/assert_latest_and_greatest.rb

@@ -0,0 +1,65 @@
+
+module AssertLatestAndGreatest
+  
+  #  This collects every model in the given class that appears while its block runs
+  def assert_latest(*models, &block)
+    models, diagnostic = _get_latest_args(models, 'assert')
+    latests = get_latest(models, &block)
+    latests.compact.length == models.length and add_assertion or
+      _flunk_latest(models, latests, diagnostic, true, block)
+    return *latests
+  end
+
+  def _get_latest_args(models, what) #:nodoc:
+    diagnostic = nil
+    diagnostic = models.pop if models.last.kind_of? String
+
+    unless models.length > 0 and
+            (diagnostic.nil? or diagnostic.kind_of? String)
+      raise "call #{ what }_latest(models..., diagnostic) with any number " +
+            'of Model classes, followed by an optional diagnostic message'
+    end
+    return models, diagnostic
+  end
+  private :_get_latest_args
+
+  def deny_latest(*models, &block)
+    models, diagnostic = _get_latest_args(models, 'deny')
+    latests = get_latest(models, &block)
+    return if latests.compact.empty?
+    models = [latests].flatten.compact.map(&:class)
+   _flunk_latest(models, latests, diagnostic, false, block)
+  end
+
+  def get_latest(models, &block)
+    max_ids = models.map{|model| model.maximum(:id) || 0 }
+    block.call
+    index = -1
+    return models.map{|model|
+      any = *model.find( :all,
+                        :conditions => "id > #{max_ids[index += 1]}",
+                        :order => "id asc" )
+      any  # * returns nil for [],
+           #   one object for [x],
+           #   or an array with more than one item
+    }
+  end
+
+  def _flunk_latest(models, latests, diagnostic, polarity, block) #:nodoc:
+    model_names = models.map(&:name)
+    model_names.each_with_index do |it, index|
+      model_names[index] = nil if !!latests[index] == polarity
+    end
+    model_names = model_names.compact.join(', ')
+    rationale = "should#{ ' not' unless polarity
+                 } create new #{ model_names
+                 } record(s) in block:\n\t\t#{
+                    reflect_source(&block).gsub("\n", "\n\t\t")
+                 }\n"
+#                 RubyNodeReflector::RubyReflector.new(block, false).result }"
+                 # note we don't evaluate...
+    flunk build_message(diagnostic, rationale)
+  end
+  private :_flunk_latest
+  
+end

data/lib/ruby_reflector.rb

@@ -0,0 +1,831 @@
+require 'rubygems'
+require 'rubynode'
+require 'pp'
+
+
+module RubyNodeReflector
+  
+  # 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(block)
+    
+    begin
+      waz = rf.colorize?
+      rf.colorize(false)
+      return rf.result + arrow_result(result) + "\n" + rf.format_evaluations
+    ensure
+      rf.colorize(waz)
+    end
+  end
+
+  def arrow_result(result) #:nodoc:
+    return "\t--> #{ result.inspect }"
+  end
+  private :arrow_result
+  
+  #  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)
+    return RubyReflector.new(block, false).result
+  end
+
+  #  This compiles a string and +reflect+s its source...
+  #  as another string.
+  #  
+  def reflect_string(string)
+    rf = RubyReflector.new(proc{})
+    rf.reflect_values = false
+      # pp string.parse_to_nodes.transform
+    got = rf.reflect_nodes(string.parse_to_nodes)
+    return got
+  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 (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  #  turn hamburger back into live cattle
+    include Coulor
+    attr_reader :evaluations,
+                :result
+    attr_writer :reflect_values
+ 
+    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
+    
+    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
+    
+    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
+
+    def eval_intermediate(expression)
+      eval_intermediate_guarded(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
+       
+  end
+
+end
+
+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

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: lodestone-assert-agile
+version: !ruby/object:Gem::Version 
+  version: 0.4.1
+platform: ruby
+authors: 
+- Matt Petty
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-07 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: diff-lcs
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: open4
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+description: Assertion Sugar. Better block assertions - Forked from assert2.rubyforge.org
+email: matt@kizmeta.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- README
+files: 
+- CHANGELOG
+- LICENSE
+- assert-agile.gemspec
+- init.rb
+- install.rb
+- lib/assert_agile.rb
+- lib/assert_latest_and_greatest.rb
+- lib/ruby_reflector.rb
+- Rakefile
+- README
+- tasks/assert_agile_tasks.rb
+- test/assert_agile_test.rb
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/lodestone/assert-agile
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Assert with radioactive spider power.
+test_files: 
+- test/assert_agile_test.rb