assert2 0.4.6 → 0.4.7

data/lib/assert2/xhtml.rb

@@ -1,5 +1,5 @@
 =begin
-One Yury Kotlyarov recently posted this Rails project as a question:
+One Yury Kotlyarov recently this Rails project as a question:
 
   http://github.com/yura/howto-rspec-custom-matchers/tree/master
 
@@ -60,212 +60,206 @@ requirements:
 
 require 'nokogiri'
 
-class Nokogiri::XML::Node
-
-  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
+class BeHtmlWith
 
-  def xpath_with_callback(path, method_name, &block)
-    xpath path, XPathYielder.new(method_name, &block)
+  def initialize(scope, &block)
+    @scope, @block = scope, block
+    @references = []
+    @spewed = {}
   end
 
-end
+  attr_accessor :builder,
+                :doc,
+                :failure_message,
+                :scope
+  attr_reader   :references
+  attr_writer   :reference,
+                :sample
 
-class BeHtmlWith
-
-  def deAmpAmp(stwing)
-    stwing.to_s.gsub('&', '&').gsub('&', '&')
-  end  #  ERGO await a fix in Nokogiri, and hope nobody actually means & !!!
+  def matches?(stwing, &block)
+    @block = block
 
-  def get_texts(element)
-    element.xpath('text()').map{|x|x.to_s.strip}.reject{|x|x==''}.compact
+    @scope.wrap_expectation self do
+      @doc = Nokogiri::HTML(stwing)
+      return run_all_xpaths(build_xpaths)
+    end
   end
+ 
+  def build_xpaths(&block)
+    bwock = block || @block || proc{} #  CONSIDER  what to do with no block? validate?
+    @builder = Nokogiri::HTML::Builder.new(&bwock)
 
-  def match_regexp(reference, sample)
-    reference =~ /^\(\?/ and 
-      Regexp.new(reference) =~ sample
+    elemental_children.map do |child|
+      build_deep_xpath(child)
+    end
   end
 
-  def match_text(ref, sam)
-    ref_text = get_texts(ref)
+  def elemental_children(element = @builder.doc)
+    element.children.grep(Nokogiri::XML::Element)
+  end
 
-    ref_text.empty? or ( ref_text - (sam_text = get_texts(sam)) ).empty? or
-      (ref_text.length == 1 and 
-        match_regexp(ref_text.first, sam_text.join) )
-  end  #  The irony _is_ lost on us
+  def build_deep_xpath(element)
+    path = build_xpath(element)
+    path.index('not(') == 0 and return '/*[ ' + path + ' ]'
+    return '//' + path
+  end
 
-  def verbose_spew(reference, sample)
-    if reference['verbose!'] == 'true' and
-       @spewed[yo_path = sample.path] == nil
-      puts
-      puts '-' * 60
-      p yo_path
-      puts sample.to_xhtml
-      @spewed[yo_path] = true
+  def build_xpath(element)
+    count = @references.length
+    @references << element  #  note we skip the without @reference!
+    
+    if element.name == 'without!'
+      return 'not( ' + build_predicate(element, 'or') + ' )'
+    else
+      target = element.name.sub(/\!$/, '')
+      path = "descendant::#{ target }[ refer(., '#{ count }') "
+        #  refer() is first so we collect many samples, despite boolean short-circuiting
+      path << 'and '  if elemental_children(element).any?
+      path << build_predicate(element) + ']'
+      return path
     end
   end
 
-  def match_class(attr_name, ref, sam)
-    return false unless attr_name == 'class'
-    return " #{sam} ".index(" #{ref} ")
-  end  #  NOTE  if you call it a class, but ref contains 
-       #        something fruity, you are on your own!
-  
-  def match_attributes(reference, sample)
-    reference.attribute_nodes.each do |attr|
-      unless %w( xpath! verbose! ).include? attr.name       
-        ref, sam = deAmpAmp(attr.value),
-                    deAmpAmp(sample[attr.name])
-        
-        ref == sam or 
-          match_regexp(ref, sam) or 
-          match_class(attr.name, ref, sam) or
-          return false
+  def build_predicate(element, conjunction = 'and')
+    conjunction = " #{ conjunction } "
+    element_kids = elemental_children(element)
+    return element_kids.map{|child|  build_xpath(child)  }.join(conjunction)
+  end
+
+  def run_all_xpaths(xpaths)
+    xpaths.each do |path|
+      if match_xpath(path).empty?
+        complain
+        return false
       end
     end
     
     return true
   end
 
-  def match_xpath(reference, sample)
-    if value = reference['xpath!']
-      matches = sample.parent.xpath("*[ #{value} ]")
-      match_paths = matches.map{|m| m.path }
-      return match_paths.include? sample.path
+  def match_xpath(path, &refer)
+    @doc.root.xpath_with_callback path, :refer do |element, index|
+      collect_samples(element, index.to_i)
     end
-
-    return true
   end
 
-  def match_attributes_and_text(reference, sample)
-    if match_attributes(reference, sample) and
-        match_text(reference, sample) and
-        match_xpath(reference, sample)
-      
-      verbose_spew(reference, sample)
-      return true
-    end
+#  ERGO  match text with internal spacies?
 
-    return false
+  def collect_samples(elements, index) # TODO  rename these samples to specimens
+    samples = elements.find_all do |element|
+                match_attributes_and_text(@references[index], element)
+              end
+    
+    collect_best_sample(samples)
+    samples
   end
 
-  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
+  def match_attributes_and_text(reference, sample)
+    @reference, @sample = reference, sample
+    match_attributes and match_text
   end
 
-  def collect_samples(elements, index)
-    samples = elements.find_all do |element|
-      match_attributes_and_text(@references[index], element)
+#  TODO  document without! and xpath! in the diagnostic
+#  TODO  uh, indenting mebbe?
+
+  def match_attributes
+    sort_nodes.each do |attr|
+      case attr.name
+        when 'verbose!' ;  verbose_spew(attr)
+        when 'xpath!'   ;  match_xpath_predicate(attr) or return false
+        else            ;  match_attribute(attr)       or return false
+      end
     end
 
-    @first_samples += elements # if index == 0  
-      #  TODO  this could use more testage, and it could enforce a link to the parent
-    return samples
+    return true
   end
-  
-  attr_accessor :doc,
-                :scope,
-                :builder
 
-  def assemble_complaint
-    @first_samples << @doc.root if @first_samples.empty?  #  TODO  test the first_samples system
-    @failure_message = complain_about(@builder.doc.root, @first_samples)
+  def sort_nodes
+    @reference.attribute_nodes.sort_by do |q|
+      { 'verbose!' => 0,  #  put this first, so it always runs, even if attributes don't match
+        'xpath!' => 2  #  put this last, so if attributes don't match, it does not waste time
+        }.fetch(q.name, 1)
+    end 
   end
 
-  def build_xpaths(&block)
-    paths = []
-    bwock = block || @block || proc{} #  TODO  what to do with no block? validate?
-    @builder = Nokogiri::HTML::Builder.new(&bwock)
-
-    @builder.doc.children.each do |child|
-      @path = build_deep_xpath(child)
-      next if @path == "//descendant::html[ refer(., '0') ]" # CONSIDER wtf is this?
-      paths << @path
+  def verbose_spew(attr)
+    if attr.value == 'true' and @spewed[yo_path = @sample.path] == nil
+      puts
+      puts '-' * 60
+      p yo_path
+      puts @sample.to_xhtml
+      @spewed[yo_path] = true
     end
+  end  #   ERGO  this could use a test...
 
-    return paths
-  end  #  TODO  refactor more to actually use this
-  
-  def matches?(stwing, &block)
-    @scope.wrap_expectation self do
-      begin
-        paths = build_xpaths(&block)
-        @doc = Nokogiri::HTML(stwing)
-        @reason = nil
-
-        @builder.doc.children.each do |child|
-          @first_samples = []
-          @spewed = {}
-          @path = build_deep_xpath(child)
-          next if @path == "//descendant::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
-          
-          matchers.empty? and assemble_complaint and return false
-           #  TODO  use or lose @reason
-        end
-        
-        # TODO complain if too many matchers
+#  TODO  why we have no :css! yet??
 
+  def match_xpath_predicate(attr)
+    @sample.parent.xpath("*[ #{ attr.value } ]").each do |m|
+      m.path == @sample.path and 
         return true
-      end
     end
+
+    return false
   end
 
-  def build_deep_xpath(element)
-    @references = []
-    path = build_xpath(element)
-    if path.index('not') == 0
-      return '/*[ ' + path + ' ]'   #  ERGO  uh, is there a cleaner way?
-    end
-    return '//' + path
+  def match_attribute(attr)
+    ref = deAmpAmp(attr.value)
+    sam = deAmpAmp(@sample[attr.name])
+    ref == sam or match_regexp(ref, sam) or 
+      match_class(attr.name, ref, sam)
   end
 
-  def build_deep_xpath_too(element)
-    @references = []
-    return '//' + build_xpath_too(element)
+  def deAmpAmp(stwing)
+    stwing.to_s.gsub('&amp;amp;', '&').gsub('&amp;', '&')
+  end  #  ERGO await a fix in Nokogiri, and hope nobody actually means &amp;amp; !!!
+
+  def match_regexp(reference, sample)
+    reference =~ /\(\?.*\)/ and   #  the irony _is_ lost on us...
+      Regexp.new(reference) =~ sample
   end
 
-  attr_reader :references
+  def match_class(attr_name, ref, sam)
+    attr_name == 'class' and
+      " #{ sam } ".index(" #{ ref } ")
+  end  #  NOTE  if you call it a class, but ref contains 
+       #        something fruity, you are on your own!
 
-  def build_predicate(element, conjunction = 'and')
-    path = ''
-    conjunction = " #{ conjunction } "
-    element_kids = element.children.grep(Nokogiri::XML::Element)
+  def match_text(ref = @reference, sam = @sample)
+    ref_text = get_texts(ref)
+    ref_text.empty? and return true
+    sam_text = get_texts(sam)
+    (ref_text - sam_text).empty? and return true
+    ref_text.length == 1 and match_regexp(ref_text.first, sam_text.join)
+  end
 
-    if element_kids.any?
-      path << element_kids.map{|child|  build_xpath(child)  }.join(conjunction)
-      path << ' and '
+  def get_texts(element)
+    element.children.grep(Nokogiri::XML::Text).
+      map{|x| x.to_s.strip}.select{|x|x.any?}
+  end
+
+  def collect_best_sample(samples)
+    sample = samples.first or return
+
+    if @best_sample.nil? or depth(@best_sample) > depth(sample)
+      @best_sample = sample
     end
+  end
 
-    return path
+  def depth(e)
+    e.xpath('ancestor-or-self::*').length
+  end
+  
+  def complain( refered = @builder.doc, 
+                 sample = @best_sample || @doc.root )
+    @failure_message = "\nCould not find this reference...\n\n" +
+                          refered.to_html.sub(/^\<\!DOCTYPE.*/, '') +
+                     "\n\n...in this sample...\n\n" +
+                          sample.to_html
   end
 
-  def build_xpath(element)
-    count = @references.length
-    @references << element  #  note we skip the without @reference!
-    
-    if element.name == 'without!'
-      return 'not( ' + build_predicate(element, 'or') + '1=1 )'
-    else
-      path = 'descendant::'
-      path << element.name.sub(/\!$/, '')
-      path << '[ '
-      path << build_predicate(element)
-      path << "refer(., '#{count}') ]"  #  last so boolean short-circuiting optimizes
-#       xpath = element['xpath!']
-#       path << "[ #{ xpath } ]" if xpath
-      return path
-    end
+  def build_deep_xpath_too(element)
+    return '//' + build_xpath_too(element)
   end
 
   def build_xpath_too(element)
@@ -288,47 +282,14 @@ class BeHtmlWith
     end
        path << ' and ' if element_kids.any?
 
-    path << "refer(., '#{count}') ]"  #  last so boolean short-circuiting optimizes
+    path << "refer(., '#{ count }') ]"  #  last so boolean short-circuiting optimizes
     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
-    
-    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
-
-  attr_accessor :failure_message
-
   def negative_failure_message
-    "TODO"
+    "please don't negate - use without!"
   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
-
 end
 
 
@@ -336,7 +297,7 @@ 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
+  def assert_xhtml(xhtml = @response.body, &block)  # ERGO merge
     if block
       matcher = BeHtmlWith.new(self, &block)
       matcher.matches?(xhtml, &block)
@@ -368,4 +329,22 @@ class Nokogiri::XML::Builder
         node = Nokogiri::XML::Text.new(string.to_s, @doc)
         insert(node)
       end
+end  #  ERGO  retire these monkey patches as Nokogiri catches up
+
+class Nokogiri::XML::Node
+
+  class XPathPredicateYielder
+    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
+
+  def xpath_with_callback(path, method_name, &block)
+    xpath path, XPathPredicateYielder.new(method_name, &block)
+  end
+
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: assert2
 version: !ruby/object:Gem::Version 
-  version: 0.4.6
+  version: 0.4.7
 platform: ruby
 authors: 
 - Phlip
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-22 00:00:00 -07:00
+date: 2009-03-28 00:00:00 -07:00
 default_executable: 
 dependencies: []