scrubyt 0.2.6 → 0.2.8

data/test/unittests/constraint_test.rb

@@ -11,9 +11,9 @@ class ConstraintTest < Test::Unit::TestCase
                           ensure_absence_of_attribute('fill' => 'small_circles')      
     end
     
-    assert_equal(data.children[0].filters[0].constraints[0].type,
+    assert_equal(data.children[0].constraints[0].type,
                  Scrubyt::Constraint::CONSTRAINT_TYPE_ENSURE_PRESENCE_OF_ATTRIBUTE)
-    assert_equal(data.children[0].filters[0].constraints[1].type,
+    assert_equal(data.children[0].constraints[1].type,
                  Scrubyt::Constraint::CONSTRAINT_TYPE_ENSURE_ABSENCE_OF_ATTRIBUTE)
   end
   
@@ -25,9 +25,9 @@ class ConstraintTest < Test::Unit::TestCase
                      ensure_absence_of_ancestor_node(:intersects_with, 'name' => 'spaghetti_ice')      
     end
   
-    assert_equal(data.children[0].filters[0].constraints[0].type,
+    assert_equal(data.children[0].constraints[0].type,
                  Scrubyt::Constraint::CONSTRAINT_TYPE_ENSURE_PRESENCE_OF_ANCESTOR_NODE)
-    assert_equal(data.children[0].filters[0].constraints[1].type,
+    assert_equal(data.children[0].constraints[1].type,
                  Scrubyt::Constraint::CONSTRAINT_TYPE_ENSURE_ABSENCE_OF_ANCESTOR_NODE)
   end
   
@@ -50,14 +50,18 @@ class ConstraintTest < Test::Unit::TestCase
       (shape 'ruby_diamond').ensure_presence_of_ancestor_node(:contains, 'name' => 'crispy_ham').
                      ensure_absence_of_ancestor_node(:intersects_with, 'name' => 'spaghetti_ice')      
     end
-    
+        
     data3 = Scrubyt::Extractor.define do
       fetch File.join(File.dirname(__FILE__), "input/constraint_test.html")
        
-      (shape 'line').ensure_presence_of_ancestor_node(:contains, 'name' => 'fungus_ooze').
-                     ensure_presence_of_ancestor_node(:intersects_with, 'object' => 'funky_lemon')
+      shape 'line'#.ensure_presence_of_ancestor_node(:contains, 'name' => 'fungus_ooze').
+                    # ensure_presence_of_ancestor_node(:intersects_with, 'object' => 'funky_lemon')
     end
     
+    p data3.to_xml.to_s
+    exit
+    
+    
     data4 = Scrubyt::Extractor.define do
       fetch File.join(File.dirname(__FILE__), "input/constraint_test.html")
       

data/test/unittests/extractor_test.rb

@@ -11,8 +11,8 @@ class ExtractorTest < Test::Unit::TestCase
     
     assert_equal(pattern.name, "root")
     assert_equal(pattern.children[0].name, 'pattern')
-    assert_equal(pattern.type, Scrubyt::Pattern::PATTERN_TYPE_ROOT)
-    assert_equal(pattern.output_type, Scrubyt::Pattern::OUTPUT_TYPE_MODEL)
+    assert_equal(pattern.type, :root)
+    assert_equal(pattern.output_type, :model)
     
     assert_equal(pattern.generalize, false)
     assert_equal(pattern.children[0].generalize, true)
@@ -25,12 +25,12 @@ class ExtractorTest < Test::Unit::TestCase
     end
       
     assert_equal(pattern.name, "root")
-    assert_equal(pattern.type, Scrubyt::Pattern::PATTERN_TYPE_ROOT)
-    assert_equal(pattern.output_type, Scrubyt::Pattern::OUTPUT_TYPE_MODEL)
+    assert_equal(pattern.type, :root)
+    assert_equal(pattern.output_type, :model)
     
     assert_equal(pattern.children[0].name, "parent")        
-    assert_equal(pattern.children[0].type, Scrubyt::Pattern::PATTERN_TYPE_TREE)
-    assert_equal(pattern.children[0].output_type, Scrubyt::Pattern::OUTPUT_TYPE_MODEL)
+    assert_equal(pattern.children[0].type, :tree)
+    assert_equal(pattern.children[0].output_type, :model)
   end
 
   def test_create_more_children

data/test/unittests/filter_test.rb

@@ -5,75 +5,75 @@ require 'test/unit'
 class FilterTest < Test::Unit::TestCase
   def test_determine_example_type
     #Test children example
-    assert_equal(Scrubyt::Filter.determine_example_type(nil), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_CHILDREN)                 
+    assert_equal(Scrubyt::BaseFilter.determine_example_type(nil), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_CHILDREN)                 
     #Test image example
-    assert_equal(Scrubyt::Filter.determine_example_type('scrubyt.png'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_IMAGE)
-    assert_equal(Scrubyt::Filter.determine_example_type('scrubyt.gif'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_IMAGE)
-    assert_equal(Scrubyt::Filter.determine_example_type('scrubyt.jpg'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_IMAGE)
-    assert_equal(Scrubyt::Filter.determine_example_type('scrubyt.jpeg'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_IMAGE)                 
-    assert_not_equal(Scrubyt::Filter.determine_example_type('scrubyt.zip'), 
-                     Scrubyt::Filter::EXAMPLE_TYPE_IMAGE)
-    assert_not_equal(Scrubyt::Filter.determine_example_type('scrubyt.pif'), 
-                     Scrubyt::Filter::EXAMPLE_TYPE_IMAGE)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('scrubyt.png'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_IMAGE)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('scrubyt.gif'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_IMAGE)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('scrubyt.jpg'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_IMAGE)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('scrubyt.jpeg'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_IMAGE)                 
+    assert_not_equal(Scrubyt::BaseFilter.determine_example_type('scrubyt.zip'), 
+                     Scrubyt::BaseFilter::EXAMPLE_TYPE_IMAGE)
+    assert_not_equal(Scrubyt::BaseFilter.determine_example_type('scrubyt.pif'), 
+                     Scrubyt::BaseFilter::EXAMPLE_TYPE_IMAGE)
     #Test XPaths
-    assert_equal(Scrubyt::Filter.determine_example_type('/p/img'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)                 
-    assert_equal(Scrubyt::Filter.determine_example_type('/p/h3'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)                 
-    assert_equal(Scrubyt::Filter.determine_example_type('/p/h3/a/h2'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('/h2'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('/h1/h3'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)                                 
-    assert_equal(Scrubyt::Filter.determine_example_type('/p'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('//p'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('/p//img'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('//p//img'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('/p[0]/img'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('/p[0]'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('//p[1]'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('/p[1]//img[2]'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('//p[1]//img'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('/table/tr/td//span/b'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_equal(Scrubyt::Filter.determine_example_type('/table[0]//tr/td[1]/span[2]/b'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_not_equal(Scrubyt::Filter.determine_example_type('table[0]//tr/td[1]/span[2]/b'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)                 
-    assert_not_equal(Scrubyt::Filter.determine_example_type('/table[a]//tr/td[1]/span[2]/b'),
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)                 
-    assert_not_equal(Scrubyt::Filter.determine_example_type('/tab2le[a]//tr/td[1]/span[2]/b'),
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
-    assert_not_equal(Scrubyt::Filter.determine_example_type('/table[a]///tr/td[1]/span[2]/b'),
-                 Scrubyt::Filter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/p/img'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)                 
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/p/h3'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)                 
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/p/h3/a/h2'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/h2'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/h1/h3'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)                                 
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/p'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('//p'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/p//img'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('//p//img'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/p[0]/img'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/p[0]'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('//p[1]'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/p[1]//img[2]'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('//p[1]//img'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/table/tr/td//span/b'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('/table[0]//tr/td[1]/span[2]/b'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_not_equal(Scrubyt::BaseFilter.determine_example_type('table[0]//tr/td[1]/span[2]/b'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)                 
+    assert_not_equal(Scrubyt::BaseFilter.determine_example_type('/table[a]//tr/td[1]/span[2]/b'),
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)                 
+    assert_not_equal(Scrubyt::BaseFilter.determine_example_type('/tab2le[a]//tr/td[1]/span[2]/b'),
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
+    assert_not_equal(Scrubyt::BaseFilter.determine_example_type('/table[a]///tr/td[1]/span[2]/b'),
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_XPATH)
     #Test string example
-    assert_equal(Scrubyt::Filter.determine_example_type('Hello, world!'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_STRING)
-    assert_equal(Scrubyt::Filter.determine_example_type('$1022'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_STRING)
-    assert_equal(Scrubyt::Filter.determine_example_type('CANON'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_STRING)
-    assert_equal(Scrubyt::Filter.determine_example_type('This is a string'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_STRING)
-    assert_equal(Scrubyt::Filter.determine_example_type('45'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_STRING)
-    assert_equal(Scrubyt::Filter.determine_example_type('td'), 
-                 Scrubyt::Filter::EXAMPLE_TYPE_STRING)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('Hello, world!'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_STRING)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('$1022'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_STRING)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('CANON'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_STRING)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('This is a string'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_STRING)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('45'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_STRING)
+    assert_equal(Scrubyt::BaseFilter.determine_example_type('td'), 
+                 Scrubyt::BaseFilter::EXAMPLE_TYPE_STRING)
 
   end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: scrubyt
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
-date: 2007-03-25 00:00:00 +01:00
+  version: 0.2.8
+date: 2007-04-12 00:00:00 +02:00
 summary: A powerful Web-scraping framework
 require_paths: 
 - lib
@@ -34,36 +34,43 @@ files:
 - CHANGELOG
 - Rakefile
 - lib/scrubyt.rb
-- lib/scrubyt/utils/shared_utils.rb
-- lib/scrubyt/utils/xpathutils.rb
-- lib/scrubyt/utils/simple_example_lookup.rb
-- lib/scrubyt/utils/compound_example_lookup.rb
 - lib/scrubyt/output/result_dumper.rb
+- lib/scrubyt/output/result.rb
 - lib/scrubyt/output/export.rb
 - lib/scrubyt/output/post_processor.rb
-- lib/scrubyt/output/result.rb
+- lib/scrubyt/utils/compound_example_lookup.rb
+- lib/scrubyt/utils/simple_example_lookup.rb
+- lib/scrubyt/utils/ruby_extensions.rb
+- lib/scrubyt/utils/xpathutils.rb
+- lib/scrubyt/utils/shared_utils.rb
 - lib/scrubyt/core/navigation/navigation_actions.rb
 - lib/scrubyt/core/navigation/fetch_action.rb
-- lib/scrubyt/core/scraping/result_indexer.rb
-- lib/scrubyt/core/scraping/constraint_adder.rb
 - lib/scrubyt/core/scraping/constraint.rb
-- lib/scrubyt/core/scraping/filter.rb
 - lib/scrubyt/core/scraping/pattern.rb
 - lib/scrubyt/core/scraping/pre_filter_document.rb
 - lib/scrubyt/core/scraping/compound_example.rb
+- lib/scrubyt/core/scraping/constraint_adder.rb
+- lib/scrubyt/core/scraping/result_indexer.rb
+- lib/scrubyt/core/scraping/filters/attribute_filter.rb
+- lib/scrubyt/core/scraping/filters/base_filter.rb
+- lib/scrubyt/core/scraping/filters/regexp_filter.rb
+- lib/scrubyt/core/scraping/filters/tree_filter.rb
+- lib/scrubyt/core/scraping/filters/html_subtree_filter.rb
+- lib/scrubyt/core/scraping/filters/detail_page_filter.rb
+- lib/scrubyt/core/scraping/filters/download_filter.rb
 - lib/scrubyt/core/shared/u_r_i_builder.rb
-- lib/scrubyt/core/shared/evaluation_context.rb
 - lib/scrubyt/core/shared/extractor.rb
+- lib/scrubyt/core/shared/evaluation_context.rb
 test_files: 
 - test/unittests/input
+- test/unittests/constraint_test.rb
 - test/unittests/filter_test.rb
-- test/unittests/pattern_test.rb
-- test/unittests/extractor_test.rb
 - test/unittests/xpathutils_test.rb
-- test/unittests/constraint_test.rb
+- test/unittests/extractor_test.rb
+- test/unittests/pattern_test.rb
 - test/unittests/simple_example_lookup_test.rb
-- test/unittests/input/constraint_test.html
 - test/unittests/input/test.html
+- test/unittests/input/constraint_test.html
 rdoc_options: []
 
 extra_rdoc_files: []

data/lib/scrubyt/core/scraping/filter.rb

@@ -1,201 +0,0 @@
-module Scrubyt
-  ##
-  #=<tt>Filter out relevant pieces from the parent pattern</tt>
-  #
-  #A Scrubyt extractor is almost like a waterfall: water is pouring from the top until
-  #it reaches the bottom. The biggest difference is that instead of water, a HTML 
-  #document travels through the space.
-  #
-  #Of course Scrubyt would not make much sense if the same document would arrive at 
-  #the bottom that was poured in at the top - since in this case we might use an 
-  #indentity transformation (i.e. do nothing with the input) as well. 
-  #
-  #This is where filters came in: as they name says, they filter the stuff that is
-  #pouring from above, to leave the interesting parts and discard the rest. 
-  #The working of a filter will be explained most easily by the help of an example.
-  #Let's consider that we would like to extract information from a webshop; Concretely
-  #we are interested in the name of the items and the URL pointing to the image of the 
-  #item.
-  #
-  #To accomplish this, first we select the items with the pattern item (a pattern is 
-  #a logical grouping of fillters; see Pattern documentation) Then our new 
-  #context is the result extracted by the 'item' pattern; For every 'item' pattern, further
-  #extract the name and the image of the item; and finally, extract the href attribute
-  #of the image. Let's see an illustration:
-  #
-  #   root             --> This pattern is called a 'root pattern', It is invisible to you
-  #   |                    and basically it represents the document; it has no filters
-  #   +-- item         --> Filter what's coming from above (the whole document) to get 
-  #       |                relevant pieces of data (in this case webshop items)
-  #       +-- name     --> Again, filter what's coming from above (a webshop item) and
-  #       |                leave only item names after this operation
-  #       +-- image    --> This time filter the image of the item
-  #           |
-  #           +-- href --> And finally, from the image elements, get the attribute 'href'
-  class Filter
-    #Type of the example this filter is extracted with
-    
-    #XPath example, like html/body/tr/td[1] etc.
-    EXAMPLE_TYPE_XPATH = 0
-    #String from the document, for example 'Canon EOS 300 D'.
-    EXAMPLE_TYPE_STRING = 1
-    #Image example, like 'http://www.rubyrailways.com/scrubyt.jpg'
-    EXAMPLE_TYPE_IMAGE = 2
-    #No example - the actual XPath is determined from the children XPaths (their LCA)
-    EXAMPLE_TYPE_CHILDREN = 3
-    #Regexp example, like /\d+@*\d+[a-z]/
-    EXAMPLE_TYPE_REGEXP = 4
-    #Compound example, like :contains => 'goodies'
-    EXAMPLE_TYPE_COMPOUND = 5
-    
-    attr_accessor :example_type, :parent_pattern, :temp_sink, 
-                  :constraints, :xpath, :regexp, :example, :source, :sink
-
-    def initialize(parent_pattern, example=nil, *args)
-      @parent_pattern = parent_pattern
-      #If the example type is not explicitly defined in the pattern definition,
-      #try to determine it automatically from the example
-      #@example_type = (args[0] == nil ? Filter.determine_example_type(example) :
-      #                                  args[0][:example_type])
-      #TODOOOOO correct this!
-      @example_type = Filter.determine_example_type(example)
-      @sink = []                  #output of a filter
-      @source = []                #input of a filter                                        
-      @example = example
-      @xpath = nil #The xpath to evaluate this filter
-      #temp sinks are used for the initial run when determining the XPaths for examples;
-      #@temp_sink = nil 
-      @constraints = [] #list of constraints
-    end
-    
-    #Evaluate this filter. This method shoulf not be called directly - as the pattern hierarchy 
-    #is evaluated, every pattern evaluates its filters and then they are calling this method
-    def evaluate(source)
-      case @parent_pattern.type        
-        when Scrubyt::Pattern::PATTERN_TYPE_TREE      
-          result = source/@xpath
-          #puts "Evaluating #{@parent_pattern.name} with #{@xpath}"
-          result.class == Hpricot::Elements ? result.map : [result]
-        when Scrubyt::Pattern::PATTERN_TYPE_ATTRIBUTE  
-          puts "Evaluating: #{@parent_pattern.name}"
-          attribute_value = [source.attributes[@example]] 
-          return attribute_value if attribute_value[0]
-          @@attribute_in_parent = nil
-          Filter.traverse_up_until_attribute_found(source.parent, @example)
-          @@attribute_in_parent                  
-        when Scrubyt::Pattern::PATTERN_TYPE_REGEXP
-          source.inner_text.scan(@example).flatten
-        when Scrubyt::Pattern::PATTERN_TYPE_DETAIL
-          #p @parent_pattern.name
-          result = @parent_pattern.evaluation_context.extractor.evaluate_subextractor(
-            XPathUtils.find_nearest_node_with_attribute(source, 'href').attributes['href'],
-            @parent_pattern)
-      end      
-    end
-             
-    #For all the tree patterns, generate an XPath based on the given example
-    #Also this method should not be called directly; It is automatically called for every tree
-    #pattern directly after wrapper definition
-    def generate_XPath_for_example(next_page_example=false)
-      #puts "generating example for: #{@parent_pattern.name}"
-      #puts @example_type
-      case @example_type
-        when EXAMPLE_TYPE_XPATH
-          @xpath = @example
-        when EXAMPLE_TYPE_STRING
-          @temp_sink = SimpleExampleLookup.find_node_from_text( @parent_pattern.evaluation_context.root_pattern.filters[0].source[0], 
-	                                                            @example, 
-						                                        next_page_example )
-          @xpath = @parent_pattern.generalize ? XPathUtils.generate_XPath(@temp_sink, nil, false) :
-                                                 XPathUtils.generate_XPath(@temp_sink, nil, true)
-        when EXAMPLE_TYPE_CHILDREN
-          current_example_index = 0
-          loop do
-            all_child_temp_sinks = []
-            @parent_pattern.children.each do |child_pattern|
-              all_child_temp_sinks << child_pattern.filters[current_example_index].temp_sink
-            end
-            result = all_child_temp_sinks.pop
-            if all_child_temp_sinks.empty?
-              result = result.parent
-            else
-              all_child_temp_sinks.each do |child_sink|              
-                result = XPathUtils.lowest_common_ancestor(result, child_sink)
-              end
-            end
-            xpath = @parent_pattern.generalize ? XPathUtils.generate_XPath(result, nil, false) :
-                                                   XPathUtils.generate_XPath(result, nil, true)
-            if @parent_pattern.filters.size < current_example_index + 1
-              @parent_pattern.filters << Scrubyt::Filter.new(@parent_pattern)
-            end  
-            @parent_pattern.filters[current_example_index].xpath = xpath
-            @parent_pattern.filters[current_example_index].temp_sink = result
-            @parent_pattern.children.each do |child_pattern|            
-                  next if child_pattern.type == Scrubyt::Pattern::PATTERN_TYPE_DETAIL
-                  child_pattern.filters[current_example_index].xpath = 
-                    child_pattern.generalize ? XPathUtils.generate_generalized_relative_XPath(child_pattern.filters[current_example_index].temp_sink, result) :
-                                               XPathUtils.generate_relative_XPath(child_pattern.filters[current_example_index].temp_sink, result)                                            
-            end                                                
-            if @parent_pattern.children[0].examples == nil
-              break if @parent_pattern.children[0].filters.size == current_example_index+1
-            else
-              break if @parent_pattern.children[0].examples.size == current_example_index+1
-            end             
-            current_example_index += 1
-          end
-        when EXAMPLE_TYPE_IMAGE
-          @temp_sink = XPathUtils.find_image(@parent_pattern.evaluation_context.root_pattern.filters[0].source[0], @example)
-          @xpath = XPathUtils.generate_XPath(@temp_sink, nil, false)
-        when EXAMPLE_TYPE_COMPOUND        
-          @temp_sink = CompoundExampleLookup.find_node_from_compund_example( @parent_pattern.evaluation_context.root_pattern.filters[0].source[0],
-	                                                                         @example, 
-						                                                     next_page_example )
-          @xpath = @parent_pattern.generalize ? XPathUtils.generate_XPath(@temp_sink, nil, false) :
-                                                 XPathUtils.generate_XPath(@temp_sink, nil, true)
-      end
-    end
-    
-    def setup_relative_XPaths
-      return if !@parent_pattern.parent.parent
-      parent_filter = @parent_pattern.parent.filters[@parent_pattern.filters.index(self)]
-      @xpath = XPathUtils.generate_relative_XPath_from_XPaths(parent_filter.xpath, @xpath) if (@xpath =~ /^\/html/)
-    end
-
-    #Dispatcher method to add constraints; of course, as with any method_missing, this method
-    #should not be called directly
-    def method_missing(method_name, *args, &block)
-      constraints << Constraint.send("add_#{method_name.to_s}".to_sym, self, *args)
-    end    
-    
-private    
-    def self.traverse_up_until_attribute_found(source, attribute)
-      if (!source.parent.is_a? Hpricot::Doc)
-        #p source.attributes
-        #p attribute
-        #p source.attributes[attribute]
-        @@attribute_in_parent = source.attributes[attribute] if source.attributes[attribute]        
-        traverse_up_until_attribute_found(source.parent, attribute) if !@attribute_in_parent
-      end
-    end
-        
-    def self.determine_example_type(example)
-      if example.instance_of? Regexp
-        EXAMPLE_TYPE_REGEXP
-      elsif example.instance_of? Hash
-        EXAMPLE_TYPE_COMPOUND
-      else
-        case example
-          when nil
-            EXAMPLE_TYPE_CHILDREN
-          when /\.(jpg|png|gif|jpeg)$/
-            EXAMPLE_TYPE_IMAGE
-          when 
-/^\/{1,2}[a-z]+[0-9]?(\[[0-9]+\])?(\/{1,2}[a-z()]+[0-9]?(\[[0-9]+\])?)*$/ 
-            (example.include? '/' || example.include?('[')) ? EXAMPLE_TYPE_XPATH : EXAMPLE_TYPE_STRING 
-          else
-            EXAMPLE_TYPE_STRING
-        end
-      end
-    end #End of method determine_example_type
-  end #End of class 
-end #End of module