Changeset 137

Timestamp:

04/14/2007 12:02:09 (20 months ago)

Author:

why

Message:

• lib/hpricot/traverse.rb: new syntax for grabbing everything between two elements using a Range in the search method: (doc/("font".."font/br")) or in nodes_at like so: (doc/"font").nodes_at("*".."br"). Only works with either a pair of siblings or a set of a parent and a sibling.
  
• lib/hpricot/elements.rb: Elements.expand(ele1, ele2) tries to build a list of all elements between two elements (used by the above.)
  
• lib/hpricot/build.rb: the build method now used to construct new elements, kind of a token gesture, designed to be overridden.
  

Location:

trunk/lib/hpricot

Files:

• builder.rb (modified) (2 diffs)
• elements.rb (modified) (1 diff)
• traverse.rb (modified) (3 diffs)

trunk/lib/hpricot/builder.rb

@@ -76 +76 @@
       childs = []
       attrs = args.grep(Hash)
-      childs.concat((args - attrs).map { |x| Text.new(Hpricot.xs(x)) })
+      childs.concat((args - attrs).map { |x| Text.new(Hpricot.xs(x)) if x })
       attrs = attrs.inject({}) do |hsh, ath|
         ath.each do |k, v|
@@ -89 +89 @@
       # build children from the block
       if block
-        Hpricot.build(f, &block)
+        build(f, &block)
       end
 
       @children << f
       f
+    end
+
+    def build(*a, &b)
+      Hpricot.build(*a, &b)
     end
 

trunk/lib/hpricot/elements.rb

@@ -242 +242 @@
     end
 
+    # Given two elements, attempt to gather an Elements array of everything between
+    # (and including) those two elements.
+    def self.expand(ele1, ele2)
+      ary = []
+
+      if ele1 and ele2
+        # let's quickly take care of siblings
+        if ele1.parent == ele2.parent
+          ary = ele1.parent.children[ele1.node_position..ele2.node_position]
+        else
+          # find common parent
+          p, ele1_p = ele1, [ele1]
+          ele1_p.unshift p while p.respond_to?(:parent) and p = p.parent
+          p, ele2_p = ele2, [ele2]
+          ele2_p.unshift p while p.respond_to?(:parent) and p = p.parent
+          common_parent = ele1_p.zip(ele2_p).select { |p1, p2| p1 == p2 }.flatten.last
+
+          child = nil
+          if ele1 == common_parent
+            child = ele2
+          elsif ele2 == common_parent
+            child = ele1
+          end
+
+          if child
+            ary = common_parent.children[0..child.node_position]
+          end
+        end
+      end
+
+      return Elements[*ary]
+    end
+
     def filter(expr)
         nodes, = Elements.filter(self, expr)

trunk/lib/hpricot/traverse.rb

@@ -35 +35 @@
     end
 
+    def index(name)
+      i = 0
+      return i if name == "*"
+      children.each do |x|
+        return i if (x.respond_to?(:name) and name == x.name) or
+          (x.text? and name == "text()")
+        i += 1
+      end
+      -1
+    end
+
     # Puts together an array of neighboring nodes based on their proximity
     # to this node.  So, for example, to get the next node, you could use
@@ -47 +58 @@
       sib = parent.children
       i, si = 0, sib.index(self)
+      pos.map! do |r|
+        if r.is_a?(Range) and r.begin.is_a?(String)
+          r = ((parent.index(r.begin)-si)..(parent.index(r.end)-si))
+        end
+        r
+      end
+      p pos
       Elements[*
         sib.select do |x|
-          sel = case i - si when *pos
-                  true
-                end
+          sel =
+            case i - si when *pos
+              true
+            end
           i += 1
           sel
@@ -217 +236 @@
     # is used to iterate through the matching set.
     def search(expr, &blk)
+      if Range === expr
+        return expand(at(expr.begin), at(expr.end))
+      end
       last = nil
       nodes = [self]