assert2 0.3.2 → 0.3.3

data/lib/{ruby_reflector.rb → assert2/rubynode_reflector.rb}

@@ -1,10 +1,8 @@
-require 'rubygems'
-require 'rubynode'
 require 'pp'
 
 
-module RubyNodeReflector
-  
+module Test; module Unit; module Assertions
+
   # ERGO
   #		:bmethod      => [:cval],
   #		:cfunc        => [:argc, :cfnc],
@@ -34,101 +32,103 @@ module RubyNodeReflector
   #
   def reflect(&block)
     result = block.call
-    rf = RubyReflector.new(block)
+    rf = RubyReflector.new
+    rf.block = block
     
     begin
       waz = rf.colorize?
       rf.colorize(false)
-      return rf.result + arrow_result(result) + "\n" + rf.format_evaluations
+      return rf.result + rf.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
+    rf = RubyReflector.new(nil, false)
+    rf.block = block
+    return rf.result
   end
 
   #  This compiles a string and +reflect+s its source...
   #  as another string.
   #  
-  def reflect_string(string)
-    rf = RubyReflector.new(proc{})
+  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
 
-  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  #  this class turns hamburger back into live cattle
+    HAS_RIPPER = false
     
-  class RubyReflector  #  turn hamburger back into live cattle
-    include Coulor
+    begin
+      raise LoadError, 'whatever' if ENV['TEST_ASSERT_2_IN_1_8_7_MODE'] == 'true'
+      require 'rubygems'
+      require 'rubynode'
+      HAS_RUBYNODE = true
+    rescue LoadError
+      HAS_RUBYNODE = false
+    end
+
     attr_reader :evaluations,
-                :result
-    attr_writer :reflect_values
- 
-    def initialize(block, reflect_values = true)  #  note that a block, from your context, is not optional
+                :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         = ''
-      @block          = block
       @line           = 0
-      reflect_nodes(@block.body_node)
+      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 }"
-      #      pp @transformation
-      #      puts @result
       raise
     end
-    
-    def eval_intermediate_guarded(expression)
+
+    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(expression, @block.binding)
+        intermediate = eval(expr, @block.binding)
         @evaluations << [expression, intermediate, nil]
       rescue SyntaxError => e
         if e.message.index('syntax error, unexpected \',\'') and expression !~ /\[ /
-          return eval_intermediate_guarded('[ ' + expression + ' ]')
+          return detect('[ ' + expression + ' ]')
         end  #  faint prayer to infinite recursion diety here! (-;
 
         @evaluations << [expression, nil, e.message]
@@ -138,7 +138,7 @@ module RubyNodeReflector
     end
 
     def eval_intermediate(expression)
-      eval_intermediate_guarded(expression)  if @reflect_values
+      detect(expression)  if @reflect_values
       return expression
     end
 
@@ -552,13 +552,13 @@ p node
 
       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!
     
@@ -576,7 +576,7 @@ p node
       lit.gsub!('\\\\', '\\')  if regex
       return lit
     end
-    
+
     def _dstr(node, delim = '"')
       regex = delim == '/'
       expression = delim + scrape_literal(node, regex)
@@ -590,7 +590,7 @@ p node
           end
         end
       end
-      
+
       return eval_intermediate(expression + delim)
     end
 
@@ -598,13 +598,13 @@ p 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)
 
@@ -816,16 +816,45 @@ p 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
+      @__additional_diagnostics.unshift diagnostic
+      self.args = options.fetch(:args, [])
+      rf = self
+      polarity = 'assert{ '
+      lines = rf.split_and_read(called) 
+
+      if lines.first =~ /^\s*(assert|deny)/
+        polarity = $1 + '{ '
+      end
+      
+      rf.absorb_block_args lines 
+      rf.block = block
+      effect = " - should #{ 'not ' if polarity =~ /deny/ }pass\n"
+
+      report = rf.magenta(polarity) + rf.bold(rf.result) + rf.magenta(" }") + 
+                rf.red(arrow_result(result) + effect) + 
+                rf.format_evaluations
+
+      return __build_message(report)
+    end
+    
+    def arrow_result(result) #:nodoc:
+      return "\t--> #{ result.inspect }"
+    end
+
   end
 
-end
+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)
+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

data/lib/assert2/xpath.rb

@@ -0,0 +1,159 @@
+require 'test/unit'
+require 'assert2'
+require 'rexml/document'
+require 'rexml/entity'
+require 'rexml/formatters/pretty'
+
+module Test; module Unit; module Assertions
+  
+  def assert_xhtml(xhtml)
+    return _assert_xml(xhtml) # , XML::HTMLParser)
+  end 
+
+  def _assert_xml(xml) #, parser = XML::Parser)
+    if false
+      xp = parser.new()
+      xp.string = xml
+      
+      if XML.respond_to? :'default_pedantic_parser='
+        XML.default_pedantic_parser = true
+      else
+        XML::Parser.default_pedantic_parser = true
+      end  #  CONSIDER  uh, figure out the best libxml-ruby??
+      
+      @xdoc = xp.parse.root
+    else
+      #  CONSIDER  figure out how entities are supposed to work!!
+      xml = xml.gsub('—', '--')
+      doc = REXML::Document.new(xml)
+      @xdoc = doc.root
+    end
+  end 
+
+  class AssertXPathArguments
+    
+    def initialize(path = '', id = nil, options = {})
+      @subs = {}
+      @xpath = ''
+      to_xpath(path, id, options)
+    end
+    
+    attr_reader :subs
+    attr_reader :xpath
+    
+    def to_conditions(hash)
+      xml_attribute_name = /^[a-z][_a-z0-9]+$/i  #  CONSIDER is that an XML attribute name match?
+      
+      @xpath << hash.map{|k, v|
+                  sk = k.to_s
+                  sk = '_text' if sk == '.' or k == 46
+                  k = '.' if k == 46 and RUBY_VERSION < '1.9.0'
+                  @subs[sk] = v.to_s
+                  "#{ '@' if k.to_s =~ xml_attribute_name }#{k} = $#{sk}" 
+                }.join(' and ')
+    end
+    
+    def to_predicate(hash, options)
+      hash = { :id => hash } if hash.kind_of? Symbol
+      hash.merge! options
+      @xpath << '[ '
+      to_conditions(hash)
+      @xpath << ' ]'
+    end
+
+    def to_xpath(path, id, options)
+      @xpath = path
+      @xpath = "descendant-or-self::#{ @xpath }" if @xpath.kind_of? Symbol
+      to_predicate(id, options) if id
+    end
+
+  end
+
+    # if node = @xdoc.find_first(path) ## for libxml
+    #  def node.text
+    #    find_first('text()').to_s
+    #  end
+
+  def xpath(path, id = nil, options = {}, &block)
+    former_xdoc = @xdoc
+    apa = AssertXPathArguments.new(path, id, options)
+    node = REXML::XPath.first(@xdoc, apa.xpath, nil, apa.subs)
+    
+    add_diagnostic :clear do
+      diagnostic = "xpath: #{ apa.xpath.inspect }\n"
+      diagnostic << "arguments: #{ apa.subs.pretty_inspect }\n" if apa.subs.any?
+      diagnostic + "xml context:\n" + indent_xml
+    end
+
+    if node
+      def node.[](symbol)
+        return attributes[symbol.to_s]
+      end
+    end
+
+    if block
+      assert_('this xpath cannot find a node', :keep_diagnostics => true){ node }
+      assert_ nil, :args => [@xdoc = node], :keep_diagnostics => true, &block  #  TODO  need the _ ?
+    end
+    
+    return node
+    # TODO raid http://thebogles.com/blog/an-hpricot-style-interface-to-libxml/
+  ensure
+    @xdoc = former_xdoc
+  end  #  TODO trap LibXML::XML::XPath::InvalidPath and explicate it's an XPath problem
+ 
+  def indent_xml(node = @xdoc)
+    bar = REXML::Formatters::Pretty.new
+    out = String.new
+    bar.write(node, out)
+    return out
+  end
+  
+end; end; end
+
+
+if RUBY_VERSION <= '1.8.6'
+
+module REXML
+  module Formatters
+    class Pretty
+
+      private
+
+  #  see http://www.google.com/codesearch/p?hl=en#Ezb_-tQR858/test_libs/rexml_fix.rb
+  #   for less info about this fix...
+  
+      def wrap(string, width)
+        # Recursivly wrap string at width.
+        return string if string.length <= width
+        place = string.rindex(/\s+/, width) # Position in string with last ' ' before cutoff
+        return string if place.nil?
+        return string[0,place] + "\n" + wrap(string[place+1..-1], width)
+      end
+
+    end
+  end
+
+  class Element
+    # this patches http://www.germane-software.com/projects/rexml/ticket/128
+    def write(output=$stdout, indent=-1, transitive=false, ie_hack=false)
+      Kernel.warn("#{self.class.name}.write is deprecated.  See REXML::Formatters")
+      formatter = if indent > -1
+          if transitive
+            require "rexml/formatters/transitive"
+            REXML::Formatters::Transitive.new( indent, ie_hack )
+          else
+            REXML::Formatters::Pretty.new( indent, ie_hack )
+          end
+        else
+          REXML::Formatters::Default.new( ie_hack )
+        end
+      formatter.write( self, output )
+    end
+  end
+end
+
+end
+
+
+require '../../test/assert_xhtml_suite.rb' if $0 == __FILE__ and File.exist?('../../test/assert_xhtml_suite.rb')

metadata

@@ -1,55 +1,61 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: assert2
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
-date: 2008-05-24 00:00:00 -07:00
-summary: An assertion that reflects its block, with all intermediate values
-require_paths: 
-- lib
-email: phlip2005@gmail.com
-homepage: http://assert2.rubyforge.org/
-rubyforge_project: assert2
-description: 
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: false
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.3.3
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Phlip
-files: 
-- lib/ruby_reflector.rb
-- lib/assert2.rb
-test_files: []
-
-rdoc_options: []
+autorequire: 
+bindir: bin
+cert_chain: []
 
-extra_rdoc_files: []
+date: 2009-01-12 00:00:00 -08:00
+default_executable: 
+dependencies: []
 
+description: 
+email: phlip2005@gmail.com
 executables: []
 
 extensions: []
 
+extra_rdoc_files: []
+
+files: 
+- lib/assert2
+- lib/assert2/flunk.rb
+- lib/assert2/null_reflector.rb
+- lib/assert2/ripdoc.html.erb
+- lib/assert2/ripdoc.rb
+- lib/assert2/ripper_reflector.rb
+- lib/assert2/rubynode_reflector.rb
+- lib/assert2/xpath.rb
+- lib/assert2.rb
+has_rdoc: false
+homepage: http://assert2.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+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: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rubynode
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
-    version: 
+rubyforge_project: assert2
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: An assertion that reflects its block, with all intermediate values
+test_files: []
+