assert2 0.3.8 → 0.3.9

data/lib/assert2/xhtml.rb

@@ -56,191 +56,192 @@ requirements:
  - at fault time, the matcher prints out the failing elements
      and their immediate context.
 
-First, we take care of the paperwork. This spec works with Yuri's
-sample website. I add Nokogiri, for our XML engine:
 =end
 
 require 'nokogiri'
 
-=begin
-That block after "response.body.should be_html_with" answers
-Yuri's question. Any HTML we can think of, we can specify
-it in there.
+class Nokogiri::XML::Node
 
-If we inject a fault, such as :name => 'user[first_nome]', we 
-get this diagnostic:
+  class XPathYielder
+    def initialize(method_name, &block)
+      self.class.send :define_method, method_name do |*args|
+        raise 'must call with block' unless block
+        block.call(*args)
+      end
+    end
+  end
 
-  <input type="text" name="user[first_nome]">
-  does not match
-  <fieldset>
-  <legend>Personal Information</legend>
-      <ol>
-  <li id="control_user_first_name">
-          <label for="user_first_name">First name</label>
-          <input type="text" name="user[first_name]" id="user_first_name">
-  </li>
-      </ol>
-  </fieldset>
+  def xpath_with_callback(path, method_name, &block)
+    xpath path, XPathYielder.new(method_name, &block)
+  end
 
-The diagnostic only reported the fault's immediate 
-context - the <fieldset> where the matcher sought the 
-errant <input> field. It would not, for example, spew
-an entire website into our faces.
+end
 
-To support that specification, we will create a new
-RSpec "matcher":
-=end
+class BeHtmlWith
 
-  class BeHtmlWith
-
-    def matches?(stwing, &block)
-   #   @scope.wrap_expectation self do
-        begin
-          bwock = block || @block || proc{}
-          builder = Nokogiri::HTML::Builder.new(&bwock)
-          match = builder.doc.root
-          doc = Nokogiri::HTML(stwing)
-          @last_match = 0
-          @failure_message = match_nodes(match, doc)
-          return @failure_message.nil?
-        end
-  #    end
+  def get_texts(element)
+    element.xpath('text()').map{|x|x.to_s.strip}.reject{|x|x==''}.compact
+  end
+  
+  def match_text(ref, sam)
+    ref_text = get_texts(ref)
+      #  TODO regices?
+    ref_text.empty? or ( ref_text - get_texts(sam) ).empty?
+  end
+
+  def match_attributes_and_text(reference, sample)
+    reference.attribute_nodes.each do |attr|
+      sample[attr.name] == attr.value or return false
     end
 
-=begin
-The trick up our sleeve is Nokogiri::HTML::Builder. We passed
-the matching block into it - that's where all the 'form', 
-'fieldset', 'input', etc. elements came from. And this trick 
-exposes both our target page and our matched elements to the 
-full power of Nokogiri. Schema validation, for example, would 
-be very easy.
-
-The matches? method works by building two DOMs, and forcing
-our page's DOM to satisfy each element, attribute, and text
-in our specification's DOM.
-
-To match nodes, we first find all nodes, by name, below
-the current node. Note that match_nodes() recurses. Then
-we throw away all nodes that don't satisfy our matching
-criteria.
-
-We pick the first node that passes that check, and 
-then recursively match its children to each child,
-if any, from our matching node.
-=end
- 
- #  TODO does a multi-modal top axis work?
- 
-    def match_nodes(match, doc)
-      node = doc.xpath("descendant::#{match.name.sub(/\!$/, '')}").
-                select{|n| resemble(match, n) }.
-                first or return complaint(match, doc)
-
-      this_match = node.xpath('preceding::*').length
-      
-      if @last_match > this_match
-        return complaint(match, doc, 'node is out of specified order!')
-      end
-      
-      @last_match = this_match
-
-      # http://www.zvon.org/xxl/XPathTutorial/Output/example18.html
-      # The preceding axis contains all nodes in the same document 
-      # as the context node that are before the context node in 
-      # document order, excluding any ancestors and excluding 
-      # attribute nodes and namespace nodes 
-
-#p [node.name, node.text]
-# p node.path if lastest
-#p node.text
-# p lastest.path if lastest
-
-        #  TODO  try xpath('*')
-      match.children.grep(Nokogiri::XML::Element).each do |child|
-        issue = match_nodes(child, node) and 
-          return issue
-      end
+    return match_text(reference, sample)
+  end
 
-      return nil
+  def elements_equal(element_1, element_2)
+    raise 'programming error: mismatched elements' unless element_1.document == element_2.document
+    element_1.path == element_2.path
+  end
+  
+#       end  #  TODO  more "elements" less "nodes"
+
+  def collect_samples(elements, index)
+    samples = elements.find_all do |element|
+      match_attributes_and_text(@references[index], element)
     end
-    
-=begin
-At any point in that recursion, if we can't find a match,
-we build a string describing that situation, and pass it
-back up the call stack. This immediately stops any iterating
-and recursing underway!
-
-Two nodes "resemble" each other if their names are the
-same (naturally!); if your matching element's
-attributes are a subset of your page's element's 
-attributes, and if their text is similar:
-=end
 
-    def resemble(match, node)
-      keys = match.attributes.keys
-      node_keys = valuate(node.attributes.select{|k,v| keys.include? k })
-      match_keys = valuate(match.attributes)
-      node_keys == match_keys or return false
+    @first_samples += samples if samples.any? and index == 0
+    return samples
+  end
+  
+  attr_accessor :doc,
+                :scope
+  
+  def matches?(stwing, &block)
+    @scope.wrap_expectation self do  #  TODO  put that back online
+      begin
+        bwock = block || @block || proc{} #  TODO  what to do with no block? validate?
+        builder = Nokogiri::HTML::Builder.new(&bwock)
+        @doc = Nokogiri::HTML(stwing)
+        @reason = nil
+
+        builder.doc.children.each do |child|
+          @first_samples = []
+            # TODO warn if child is text
+          path = build_deep_xpath(child)
+          next if path == "//html[ refer(., '0') ]" # CONSIDER wtf is this?
+
+          matchers = doc.root.xpath_with_callback path, :refer do |elements, index|
+                      collect_samples(elements, index.to_i)
+                    end
+          
+          if matchers.empty?
+            @first_samples << @doc.root if @first_samples.empty?  #  TODO  test the first_samples system
+            @failure_message = complain_about(builder.doc.root, @first_samples)
+            return false
+          end  #  TODO  use or lose @reason
+        end
         
-    #  TODO  try
-#       match_text = match.xpath('text()').map{|x|x.to_s}
-#        node_text = match.xpath('text()').map{|x|x.to_s}
+        # TODO complain if too many matchers
 
-      match_text = match.children.grep(Nokogiri::XML::Text).map{|t| t.to_s.strip }
-       node_text = node .children.grep(Nokogiri::XML::Text).map{|t| t.to_s.strip }
-      match_text.empty? or 0 == ( match_text - node_text ).length
+        return true
+      end
     end
+  end
 
-=begin
-That method cannot simply compare node.text, because Nokogiri
-conglomerates all that node's descendants' texts together, and
-these would gum up our search. So those elaborate lines with
-grep() and map() serve to extract all the current node's 
-immediate textual children, then compare them as sets.
-
-Put another way, <form> does not appear to contain "First name".
-Specifications can only match text by declaring their immediate 
-parent.
-
-The remaining support methods are self-explanatory. They
-prepare Node attributes for comparison, build our diagnostics,
-and plug our matcher object into RSpec:
-=end
- 
-    def valuate(attributes)
-      attributes.inject({}) do |h,(k,v)| 
-        h.merge(k => v.value) 
-      end  #  this converts objects to strings, so our Hashes
-    end    #  can compare for equality
-
-    def complaint(node, match, berate = nil)
-      "\n    #{berate}".rstrip +
-      "\n\n#{node.to_html}\n" +
-          "    does not match\n\n" +
-           match.to_html
-    end
+  def build_deep_xpath(element)
+    @references = []
+    return '//' + build_xpath(element)
+  end
+
+  attr_reader :references
 
-    attr_accessor :failure_message
- 
-    def negative_failure_message
-      "yack yack yack"
+  def build_xpath(element)
+    path = element.name.sub(/\!$/, '')
+    element_kids = element.children.grep(Nokogiri::XML::Element)
+    path << "[ refer(., '#{@references.length}')"
+    @references << element
+
+    if element_kids.any?
+      path << ' and ' +
+              element_kids.map{|child|
+                './descendant::' + build_xpath(child)
+              }.join(' and ')
     end
+
+    path << ' ]'
+    return path
+  end
+
+  def complain_about(refered, samples, reason = nil)  #  TODO  put argumnets in order
+    reason = " (#{reason})" if reason
+    "\nCould not find this reference#{reason}...\n\n" +
+      refered.to_html +
+      "\n\n...in these sample(s)...\n\n" +  #  TODO  how many samples?
+      samples.map{|s|s.to_html}.join("\n\n...or...\n\n")
+  end
+
+  def count_elements_to_node(container, element)
+    return 0 if elements_equal(container, element)
+    count = 0
     
-    def initialize(scope, &block)
-      @scope, @block = scope, block
+    container.children.each do |child|
+      sub_count = count_elements_to_node(child, element)
+      return count + sub_count if sub_count        
+      count += 1
     end
+    
+    return nil
+  end  #  TODO  use or lose these
+
+#  TODO does a multi-modal top axis work?
+# TODO      this_match = node.xpath('preceding::*').length
+    
+    # http://www.zvon.org/xxl/XPathTutorial/Output/example18.html
+    # The preceding axis contains all nodes in the same document 
+    # as the context node that are before the context node in 
+    # document order, excluding any ancestors and excluding 
+    # attribute nodes and namespace nodes 
+
+  attr_accessor :failure_message
+
+  def negative_failure_message
+    "TODO"
+  end
+  
+  def initialize(scope, &block)
+    @scope, @block = scope, block
+  end
+
+  def self.create(stwing)
+    bhw = BeHtmlWith.new(nil)
+    bhw.doc = Nokogiri::HTML(stwing)
+    return bhw
   end
 
-module Test::Unit::Assertions
+end
+
+
+module Test; module Unit; module Assertions
+
+  def wrap_expectation whatever;  yield;  end unless defined? wrap_expectation
+
   def assert_xhtml(xhtml = @response.body, &block)  # TODO merge
-   _assert_xml(xhtml) # , XML::HTMLParser)
     if block
-     # require 'should_be_html_with_spec'
       matcher = BeHtmlWith.new(self, &block)
       matcher.matches?(xhtml, &block)
       message = matcher.failure_message
       flunk message if message.to_s != ''
+#       return matcher.builder.doc.to_html # TODO return something reasonable
+    else
+     _assert_xml(xhtml)
+      return @xdoc
     end
-    return @xdoc
   end
-end
+
+end; end; end
+
+module Spec; module Matchers
+  def be_html_with(&block)
+    BeHtmlWith.new(self, &block)
+  end
+end; end

data/lib/assert2/xhtml.rb~

@@ -56,191 +56,193 @@ requirements:
  - at fault time, the matcher prints out the failing elements
      and their immediate context.
 
-First, we take care of the paperwork. This spec works with Yuri's
-sample website. I add Nokogiri, for our XML engine:
 =end
 
 require 'nokogiri'
 
-=begin
-That block after "response.body.should be_html_with" answers
-Yuri's question. Any HTML we can think of, we can specify
-it in there.
+class Nokogiri::XML::Node
 
-If we inject a fault, such as :name => 'user[first_nome]', we 
-get this diagnostic:
+  class XPathYielder
+    def initialize(method_name, &block)
+      self.class.send :define_method, method_name do |*args|
+        raise 'must call with block' unless block
+        block.call(*args)
+      end
+    end
+  end
 
-  <input type="text" name="user[first_nome]">
-  does not match
-  <fieldset>
-  <legend>Personal Information</legend>
-      <ol>
-  <li id="control_user_first_name">
-          <label for="user_first_name">First name</label>
-          <input type="text" name="user[first_name]" id="user_first_name">
-  </li>
-      </ol>
-  </fieldset>
+  def xpath_with_callback(path, method_name, &block)
+    xpath path, XPathYielder.new(method_name, &block)
+  end
 
-The diagnostic only reported the fault's immediate 
-context - the <fieldset> where the matcher sought the 
-errant <input> field. It would not, for example, spew
-an entire website into our faces.
+end
 
-To support that specification, we will create a new
-RSpec "matcher":
-=end
+class BeHtmlWith
 
-  class BeHtmlWith
-
-    def matches?(stwing, &block)
-   #   @scope.wrap_expectation self do
-        begin
-          bwock = block || @block || proc{}
-          builder = Nokogiri::HTML::Builder.new(&bwock)
-          match = builder.doc.root
-          doc = Nokogiri::HTML(stwing)
-          @last_match = 0
-          @failure_message = match_nodes(match, doc)
-          return @failure_message.nil?
-        end
-  #    end
+  def get_texts(element)
+    element.xpath('text()').map{|x|x.to_s.strip}.reject{|x|x==''}.compact
+  end
+  
+  def match_text(ref, sam)
+    ref_text = get_texts(ref)
+      #  TODO regices?
+    ref_text.empty? or ( ref_text - get_texts(sam) ).empty?
+  end
+
+  def match_attributes_and_text(reference, sample)
+    reference.attribute_nodes.each do |attr|
+      sample[attr.name] == attr.value or return false
     end
 
-=begin
-The trick up our sleeve is Nokogiri::HTML::Builder. We passed
-the matching block into it - that's where all the 'form', 
-'fieldset', 'input', etc. elements came from. And this trick 
-exposes both our target page and our matched elements to the 
-full power of Nokogiri. Schema validation, for example, would 
-be very easy.
-
-The matches? method works by building two DOMs, and forcing
-our page's DOM to satisfy each element, attribute, and text
-in our specification's DOM.
-
-To match nodes, we first find all nodes, by name, below
-the current node. Note that match_nodes() recurses. Then
-we throw away all nodes that don't satisfy our matching
-criteria.
-
-We pick the first node that passes that check, and 
-then recursively match its children to each child,
-if any, from our matching node.
-=end
- 
- #  TODO does a multi-modal top axis work?
- 
-    def match_nodes(match, doc)
-      node = doc.xpath("descendant::#{match.name.sub(/\!$/, '')}").
-                select{|n| resemble(match, n) }.
-                first or return complaint(match, doc)
-
-      this_match = node.xpath('preceding::*').length
-      
-      if @last_match > this_match
-        return complaint(match, doc, 'node is out of specified order!')
-      end
-      
-      @last_match = this_match
-
-      # http://www.zvon.org/xxl/XPathTutorial/Output/example18.html
-      # The preceding axis contains all nodes in the same document 
-      # as the context node that are before the context node in 
-      # document order, excluding any ancestors and excluding 
-      # attribute nodes and namespace nodes 
-
-#p [node.name, node.text]
-# p node.path if lastest
-#p node.text
-# p lastest.path if lastest
-
-        #  TODO  try xpath('*')
-      match.children.grep(Nokogiri::XML::Element).each do |child|
-        issue = match_nodes(child, node) and 
-          return issue
-      end
+    return match_text(reference, sample)
+  end
 
-      return nil
+  def elements_equal(element_1, element_2)
+    raise 'programming error: mismatched elements' unless element_1.document == element_2.document
+    element_1.path == element_2.path
+  end
+  
+#       end  #  TODO  more "elements" less "nodes"
+
+  def collect_samples(elements, index)
+    samples = elements.find_all do |element|
+      match_attributes_and_text(@references[index], element)
     end
-    
-=begin
-At any point in that recursion, if we can't find a match,
-we build a string describing that situation, and pass it
-back up the call stack. This immediately stops any iterating
-and recursing underway!
-
-Two nodes "resemble" each other if their names are the
-same (naturally!); if your matching element's
-attributes are a subset of your page's element's 
-attributes, and if their text is similar:
-=end
 
-    def resemble(match, node)
-      keys = match.attributes.keys
-      node_keys = valuate(node.attributes.select{|k,v| keys.include? k })
-      match_keys = valuate(match.attributes)
-      node_keys == match_keys or return false
+    @first_samples += samples if samples.any? and index == 0
+    return samples
+  end
+  
+  attr_accessor :doc,
+                :scope
+  
+  def matches?(stwing, &block)
+    @scope.wrap_expectation self do  #  TODO  put that back online
+      begin
+        bwock = block || @block || proc{} #  TODO  what to do with no block? validate?
+        builder = Nokogiri::HTML::Builder.new(&bwock)
+puts builder.doc.root.to_html
+        @doc = Nokogiri::HTML(stwing)
+        @reason = nil
+
+        builder.doc.children.each do |child|
+          @first_samples = []
+            # TODO warn if child is text
+          path = build_deep_xpath(child)
+          next if path == "//html[ refer(., '0') ]" # CONSIDER wtf is this?
+
+          matchers = doc.root.xpath_with_callback path, :refer do |elements, index|
+                      collect_samples(elements, index.to_i)
+                    end
+          
+          if matchers.empty?
+            @first_samples << @doc.root if @first_samples.empty?  #  TODO  test the first_samples system
+            @failure_message = complain_about(builder.doc.root, @first_samples)
+            return false
+          end  #  TODO  use or lose @reason
+        end
         
-    #  TODO  try
-#       match_text = match.xpath('text()').map{|x|x.to_s}
-#        node_text = match.xpath('text()').map{|x|x.to_s}
+        # TODO complain if too many matchers
 
-      match_text = match.children.grep(Nokogiri::XML::Text).map{|t| t.to_s.strip }
-       node_text = node .children.grep(Nokogiri::XML::Text).map{|t| t.to_s.strip }
-      match_text.empty? or 0 == ( match_text - node_text ).length
+        return true
+      end
     end
+  end
 
-=begin
-That method cannot simply compare node.text, because Nokogiri
-conglomerates all that node's descendants' texts together, and
-these would gum up our search. So those elaborate lines with
-grep() and map() serve to extract all the current node's 
-immediate textual children, then compare them as sets.
-
-Put another way, <form> does not appear to contain "First name".
-Specifications can only match text by declaring their immediate 
-parent.
-
-The remaining support methods are self-explanatory. They
-prepare Node attributes for comparison, build our diagnostics,
-and plug our matcher object into RSpec:
-=end
- 
-    def valuate(attributes)
-      attributes.inject({}) do |h,(k,v)| 
-        h.merge(k => v.value) 
-      end  #  this converts objects to strings, so our Hashes
-    end    #  can compare for equality
-
-    def complaint(node, match, berate = nil)
-      "\n    #{berate}".rstrip +
-      "\n\n#{node.to_html}\n" +
-          "    does not match\n\n" +
-           match.to_html
-    end
+  def build_deep_xpath(element)
+    @references = []
+    return '//' + build_xpath(element)
+  end
+
+  attr_reader :references
 
-    attr_accessor :failure_message
- 
-    def negative_failure_message
-      "yack yack yack"
+  def build_xpath(element)
+    path = element.name.sub(/\!$/, '')
+    element_kids = element.children.grep(Nokogiri::XML::Element)
+    path << "[ refer(., '#{@references.length}')"
+    @references << element
+
+    if element_kids.any?
+      path << ' and ' +
+              element_kids.map{|child|
+                './descendant::' + build_xpath(child)
+              }.join(' and ')
     end
+
+    path << ' ]'
+    return path
+  end
+
+  def complain_about(refered, samples, reason = nil)  #  TODO  put argumnets in order
+    reason = " (#{reason})" if reason
+    "\nCould not find this reference#{reason}...\n\n" +
+      refered.to_html +
+      "\n\n...in these sample(s)...\n\n" +  #  TODO  how many samples?
+      samples.map{|s|s.to_html}.join("\n\n...or...\n\n")
+  end
+
+  def count_elements_to_node(container, element)
+    return 0 if elements_equal(container, element)
+    count = 0
     
-    def initialize(scope, &block)
-      @scope, @block = scope, block
+    container.children.each do |child|
+      sub_count = count_elements_to_node(child, element)
+      return count + sub_count if sub_count        
+      count += 1
     end
+    
+    return nil
+  end  #  TODO  use or lose these
+
+#  TODO does a multi-modal top axis work?
+# TODO      this_match = node.xpath('preceding::*').length
+    
+    # http://www.zvon.org/xxl/XPathTutorial/Output/example18.html
+    # The preceding axis contains all nodes in the same document 
+    # as the context node that are before the context node in 
+    # document order, excluding any ancestors and excluding 
+    # attribute nodes and namespace nodes 
+
+  attr_accessor :failure_message
+
+  def negative_failure_message
+    "TODO"
+  end
+  
+  def initialize(scope, &block)
+    @scope, @block = scope, block
+  end
+
+  def self.create(stwing)
+    bhw = BeHtmlWith.new(nil)
+    bhw.doc = Nokogiri::HTML(stwing)
+    return bhw
   end
 
-module Test::Unit::Assertions
+end
+
+
+module Test; module Unit; module Assertions
+
+  def wrap_expectation whatever;  yield;  end unless defined? wrap_expectation
+
   def assert_xhtml(xhtml = @response.body, &block)  # TODO merge
-   _assert_xml(xhtml) # , XML::HTMLParser)
     if block
-     # require 'should_be_html_with_spec'
       matcher = BeHtmlWith.new(self, &block)
       matcher.matches?(xhtml, &block)
       message = matcher.failure_message
-      flunk message if message.any?
+      flunk message if message.to_s != ''
+#       return matcher.builder.doc.to_html # TODO return something reasonable
+    else
+     _assert_xml(xhtml)
+      return @xdoc
     end
-    return @xdoc
   end
-end
+
+end; end; end
+
+module Spec; module Matchers
+  def be_html_with(&block)
+    BeHtmlWith.new(self, &block)
+  end
+end; end

data/lib/assert2/xpath.rb

@@ -131,8 +131,7 @@ module Test; module Unit; module Assertions
     former_xdoc = @xdoc
     apa = AssertXPathArguments.new(path, id, options)
     node = @xdoc.xpath(apa.xpath) #, nil, apa.subs)
-       # TODO  advise Nokogiri to provide substitution arguments
-    
+       
     add_diagnostic :clear do
       diagnostic = "xpath: #{ apa.xpath.inspect }\n"
       diagnostic << "arguments: #{ apa.subs.pretty_inspect }\n" if apa.subs.any?

data/lib/assert2/xpath.rb~

@@ -0,0 +1,213 @@
+require 'test/unit'
+require 'assert2'
+require 'rexml/document'
+require 'rexml/entity'
+require 'rexml/formatters/pretty'
+require 'nokogiri'  #  must be installed to use xpath{}!
+
+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 
+
+  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
+      #  TODO  figure out how entities are supposed to work!!
+      xml = xml.gsub('—', '--')
+      doc = Nokogiri::XML(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 xpath_(path, id = nil, options = {}, &block)
+    former_xdoc = @xdoc
+    apa = AssertXPathArguments.new(path, id, options)
+    node = @xdoc.xpath(apa.xpath) #, nil, apa.subs)
+       # TODO  advise Nokogiri to provide substitution arguments
+    
+    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,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: assert2
 version: !ruby/object:Gem::Version 
-  version: 0.3.8
+  version: 0.3.9
 platform: ruby
 authors: 
 - Phlip
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-11 00:00:00 -07:00
+date: 2009-03-15 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,6 +25,7 @@ files:
 - lib/assert2
 - lib/assert2/xhtml.rb~
 - lib/assert2/flunk.rb
+- lib/assert2/xpath.rb~
 - lib/assert2/rubynode_reflector.rb
 - lib/assert2/xpath.rb
 - lib/assert2/ripper_reflector.rb