hpricot 0.5-mswin32 → 0.6-mswin32

data/lib/hpricot/blankslate.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+module Hpricot
+
+  # BlankSlate provides an abstract base class with no predefined
+  # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+  # BlankSlate is useful as a base class when writing classes that
+  # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+  class BlankSlate
+    class << self
+
+      # Hide the method named +name+ in the BlankSlate class.  Don't
+      # hide +instance_eval+ or any method beginning with "__".
+      def hide(name)
+	undef_method name if
+	  instance_methods.include?(name.to_s) and
+	  name !~ /^(__|instance_eval)/
+      end
+    end
+
+    instance_methods.each { |m| hide(m) }
+  end
+end
+
+# Since Ruby is very dynamic, methods added to the ancestors of
+# BlankSlate <em>after BlankSlate is defined</em> will show up in the
+# list of available BlankSlate methods.  We handle this by defining a
+# hook in the Object and Kernel classes that will hide any defined
+module Kernel
+  class << self
+    alias_method :hpricot_slate_method_added, :method_added
+
+    # Detect method additions to Kernel and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      hpricot_slate_method_added(name)
+      return if self != Kernel
+      Hpricot::BlankSlate.hide(name)
+    end
+  end
+end
+
+class Object
+  class << self
+    alias_method :hpricot_slate_method_added, :method_added
+
+    # Detect method additions to Object and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      hpricot_slate_method_added(name)
+      return if self != Object
+      Hpricot::BlankSlate.hide(name)
+    end
+  end
+end

data/lib/hpricot/builder.rb

@@ -0,0 +1,200 @@
+require 'hpricot/tags'
+require 'hpricot/xchar'
+require 'hpricot/blankslate'
+
+module Hpricot
+  def self.build(ele = Doc.new, assigns = {}, &blk)
+    ele.extend Builder
+    assigns.each do |k, v|
+      ele.instance_variable_set("@#{k}", v)
+    end
+    ele.instance_eval &blk
+    ele
+  end
+
+  module Builder
+
+    @@default = {
+      :indent => 0,
+      :output_helpers => true,
+      :output_xml_instruction => true,
+      :output_meta_tag => true,
+      :auto_validation => true,
+      :tagset => Hpricot::XHTMLTransitional,
+      :root_attributes => {
+        :xmlns => 'http://www.w3.org/1999/xhtml', :'xml:lang' => 'en', :lang => 'en'
+      }
+    }
+
+    def self.set(option, value)
+      @@default[option] = value
+    end
+
+    # Write a +string+ to the HTML stream, making sure to escape it.
+    def text!(string)
+      @children << Text.new(Hpricot.xs(string))
+    end
+
+    # Write a +string+ to the HTML stream without escaping it.
+    def text(string)
+      @children << Text.new(string)
+      nil
+    end
+    alias_method :<<, :text
+    alias_method :concat, :text
+
+    # Create a tag named +tag+. Other than the first argument which is the tag name,
+    # the arguments are the same as the tags implemented via method_missing.
+    def tag!(tag, *args, &block)
+      ele_id = nil
+      if @auto_validation and @tagset
+          if !@tagset.tagset.has_key?(tag)
+              raise InvalidXhtmlError, "no element `#{tag}' for #{tagset.doctype}"
+          elsif args.last.respond_to?(:to_hash)
+              attrs = args.last.to_hash
+              
+              if @tagset.forms.include?(tag) and attrs[:id]
+                attrs[:name] ||= attrs[:id]
+              end
+              
+              attrs.each do |k, v|
+                  atname = k.to_s.downcase.intern
+                  unless k =~ /:/ or @tagset.tagset[tag].include? atname
+                      raise InvalidXhtmlError, "no attribute `#{k}' on #{tag} elements"
+                  end
+                  if atname == :id
+                      ele_id = v.to_s
+                      if @elements.has_key? ele_id
+                          raise InvalidXhtmlError, "id `#{ele_id}' already used (id's must be unique)."
+                      end
+                  end
+              end
+          end
+      end
+
+      # turn arguments into children or attributes
+      childs = []
+      attrs = args.grep(Hash)
+      childs.concat((args - attrs).map do |x|
+        if x.respond_to? :to_html
+          Hpricot.make(x.to_html)
+        elsif x
+          Text.new(Hpricot.xs(x))
+        end
+      end.flatten)
+      attrs = attrs.inject({}) do |hsh, ath|
+        ath.each do |k, v|
+          hsh[k] = Hpricot.xs(v.to_s) if v
+        end
+        hsh
+      end
+
+      # create the element itself
+      f = Elem.new(STag.new(tag, attrs), childs, ETag.new(tag))
+
+      # build children from the block
+      if block
+        build(f, &block)
+      end
+
+      @children << f
+      f
+    end
+
+    def build(*a, &b)
+      Hpricot.build(*a, &b)
+    end
+
+    # Every HTML tag method goes through an html_tag call.  So, calling <tt>div</tt> is equivalent
+    # to calling <tt>html_tag(:div)</tt>.  All HTML tags in Hpricot's list are given generated wrappers
+    # for this method.
+    #
+    # If the @auto_validation setting is on, this method will check for many common mistakes which
+    # could lead to invalid XHTML.
+    def html_tag(sym, *args, &block)
+      if @auto_validation and @tagset.self_closing.include?(sym) and block
+        raise InvalidXhtmlError, "the `#{sym}' element is self-closing, please remove the block"
+      elsif args.empty? and block.nil?
+        CssProxy.new(self, sym)
+      else
+        tag!(sym, *args, &block)
+      end
+    end
+
+    XHTMLTransitional.tags.each do |k|
+      class_eval %{
+        def #{k}(*args, &block)
+          html_tag(#{k.inspect}, *args, &block)
+        end
+      }
+    end
+
+    def doctype(target, pub, sys)
+      @children << DocType.new(target, pub, sys)
+    end
+
+    remove_method :head
+    
+    # Builds a head tag.  Adds a <tt>meta</tt> tag inside with Content-Type
+    # set to <tt>text/html; charset=utf-8</tt>.
+    def head(*args, &block)
+      tag!(:head, *args) do
+        tag!(:meta, "http-equiv" => "Content-Type", "content" => "text/html; charset=utf-8") if @output_meta_tag
+        instance_eval(&block)
+      end
+    end
+
+    # Builds an html tag.  An XML 1.0 instruction and an XHTML 1.0 Transitional doctype
+    # are prepended.  Also assumes <tt>:xmlns => "http://www.w3.org/1999/xhtml",
+    # :lang => "en"</tt>.
+    def xhtml_transitional(attrs = {}, &block)
+      # self.tagset = Hpricot::XHTMLTransitional
+      xhtml_html(attrs, &block)
+    end
+
+    # Builds an html tag with XHTML 1.0 Strict doctype instead.
+    def xhtml_strict(attrs = {}, &block)
+      # self.tagset = Hpricot::XHTMLStrict
+      xhtml_html(attrs, &block)
+    end
+
+    private
+
+    def xhtml_html(attrs = {}, &block)
+      instruct! if @output_xml_instruction
+      doctype(:html, *@@default[:tagset].doctype)
+      tag!(:html, @@default[:root_attributes].merge(attrs), &block)
+    end
+
+  end
+
+  # Class used by Markaby::Builder to store element options.  Methods called
+  # against the CssProxy object are added as element classes or IDs.
+  #
+  # See the README for examples.
+  class CssProxy < BlankSlate
+
+    # Creates a CssProxy object.
+    def initialize(builder, sym)
+      @builder, @sym, @attrs = builder, sym, {}
+    end
+    
+    # Adds attributes to an element.  Bang methods set the :id attribute.
+    # Other methods add to the :class attribute.
+    def method_missing(id_or_class, *args, &block)
+      if (idc = id_or_class.to_s) =~ /!$/
+        @attrs[:id] = $`
+      else
+        @attrs[:class] = @attrs[:class].nil? ? idc : "#{@attrs[:class]} #{idc}".strip
+      end
+
+      if block or args.any?
+        args.push(@attrs)
+        return @builder.tag!(@sym, *args, &block)
+      end
+      
+      return self
+    end
+
+  end
+end

data/lib/hpricot/elements.rb

@@ -50,6 +50,7 @@ module Hpricot
 # Most of the useful element methods are in the mixins Hpricot::Traverse
 # and Hpricot::Container::Trav.
   class Elements < Array
+  
     # Searches this list for any elements (or children of these elements) matching
     # the CSS or XPath expression +expr+.  Root is assumed to be the element scanned.
     #
@@ -128,26 +129,26 @@ module Hpricot
 
     # Add to the end of the contents inside each element in this list.
     # Pass in an HTML +str+, which is turned into Hpricot elements.
-    def append(str)
-      each { |x| x.inner_html += str }
+    def append(str = nil, &blk)
+      each { |x| x.html(x.children + Hpricot.make(str, &blk)) }
     end
 
     # Add to the start of the contents inside each element in this list.
     # Pass in an HTML +str+, which is turned into Hpricot elements.
-    def prepend(str)
-      each { |x| x.inner_html = str + x.inner_html }
+    def prepend(str = nil, &blk)
+      each { |x| x.html(Hpricot.make(str, &blk) + x.children) }
     end
  
     # Add some HTML just previous to each element in this list.
     # Pass in an HTML +str+, which is turned into Hpricot elements.
-    def before(str)
-      each { |x| x.parent.insert_before Hpricot.make(str), x }
+    def before(str = nil, &blk)
+      each { |x| x.parent.insert_before Hpricot.make(str, &blk), x }
     end
 
     # Just after each element in this list, add some HTML.
     # Pass in an HTML +str+, which is turned into Hpricot elements.
-    def after(str)
-      each { |x| x.parent.insert_after Hpricot.make(str), x }
+    def after(str = nil, &blk)
+      each { |x| x.parent.insert_after Hpricot.make(str, &blk), x }
     end
 
     # Wraps each element in the list inside the element created by HTML +str+. 
@@ -158,49 +159,117 @@ module Hpricot
     #      wrap(%{<div class="link"><div class="link_inner"></div></div>})
     #
     # This code wraps every link on the page inside a +div.link+ and a +div.link_inner+ nest.
-    def wrap(str)
+    def wrap(str = nil, &blk)
       each do |x|
-        wrap = Hpricot.make(str)
+        wrap = Hpricot.make(str, &blk)
         nest = wrap.detect { |w| w.respond_to? :children }
         unless nest
           raise Exception, "No wrapping element found."
         end
         x.parent.replace_child(x, wrap)
         nest = nest.children.first until nest.empty?
-        nest.children << x
+        nest.html(nest.children + [x])
       end
     end
 
-    # Sets an attribute for all elements in this list.  You may use
-    # a simple pair (<em>attribute name</em>, <em>attribute value</em>):
+    # Gets and sets attributes on all matched elements.
     #
-    #   doc.search('p').set(:class, 'outline')
+    # Pass in a +key+ on its own and this method will return the string value
+    # assigned to that attribute for the first elements.  Or +nil+ if the 
+    # attribute isn't found.
     #
-    # Or, use a hash of pairs:
+    #   doc.search("a").attr("href")
+    #     #=> "http://hacketyhack.net/"
     #
-    #   doc.search('div#sidebar').set(:class => 'outline', :id => 'topbar')
+    # Or, pass in a +key+ and +value+.  This will set an attribute for all
+    # matched elements.
     #
-    def set(k, v = nil)
-      case k
-      when Hash
-        each do |node|
-          k.each { |a,b| node.set_attribute(a, b) }
+    #   doc.search("p").attr("class", "basic")
+    # 
+    # You may also use a Hash to set a series of attributes:
+    #
+    #   (doc/"a").attr(:class => "basic", :href => "http://hackety.org/")
+    # 
+    # Lastly, a block can be used to rewrite an attribute based on the element
+    # it belongs to.  The block will pass in an element.  Return from the block
+    # the new value of the attribute.
+    #
+    #   records.attr("href") { |e| e['href'] + "#top" }
+    #
+    # This example adds a <tt>#top</tt> anchor to each link.
+    #
+    def attr key, value = nil, &blk
+      if value or blk
+        each do |el|
+          el.set_attribute(key, value || blk[el])
         end
+        return self      
+      end    
+      if key.is_a? Hash
+        key.each { |k,v| self.attr(k,v) }
+        return self
       else
-        each do |node|
-          node.set_attribute(k, v)
+        return self[0].get_attribute(key)
+      end
+    end
+    alias_method :set, :attr
+  
+    # Adds the class to all matched elements.
+    #
+    #   (doc/"p").add_class("bacon")
+    #
+    # Now all paragraphs will have class="bacon".
+    def add_class class_name
+      each do |el|
+        next unless el.respond_to? :get_attribute
+        classes = el.get_attribute('class').to_s.split(" ")
+        el.set_attribute('class', classes.push(class_name).uniq.join(" "))
+      end
+      self
+    end
+
+    # Remove an attribute from each of the matched elements.
+    #
+    #   (doc/"input").remove_attr("disabled")
+    #
+    def remove_attr name
+      each do |el|
+        next unless el.respond_to? :remove_attribute
+        el.remove_attribute(name)
+      end
+      self      
+    end
+
+    # Removes a class from all matched elements.
+    #
+    #   (doc/"span").remove_class("lightgrey")
+    #
+    # Or, to remove all classes:
+    #
+    #   (doc/"span").remove_class
+    # 
+    def remove_class name = nil
+      each do |el|
+        next unless el.respond_to? :get_attribute
+        if name
+          classes = el.get_attribute('class').to_s.split(" ")
+          el.set_attribute('class', (classes - [name]).uniq.join(" "))
+        else
+          el.remove_attribute("class")
         end
       end
+      self      
     end
 
-    ATTR_RE = %r!\[ *(?:(@)([\w\(\)-]+)|([\w\(\)-]+\(\))) *([~\!\|\*$\^=]*) *'?"?([^'"]*)'?"? *\]!i
-    BRACK_RE = %r!(\[) *([^\]]*) *\]!i
+    ATTR_RE = %r!\[ *(?:(@)([\w\(\)-]+)|([\w\(\)-]+\(\))) *([~\!\|\*$\^=]*) *'?"?([^\]'"]*)'?"? *\]!i
+    BRACK_RE = %r!(\[) *([^\]]*) *\]+!i
     FUNC_RE = %r!(:)?([a-zA-Z0-9\*_-]*)\( *[\"']?([^ \)]*?)['\"]? *\)!
+    CUST_RE = %r!(:)([a-zA-Z0-9\*_-]*)()!
     CATCH_RE = %r!([:\.#]*)([a-zA-Z0-9\*_-]+)!
 
     def self.filter(nodes, expr, truth = true)
         until expr.empty?
-            _, *m = *expr.match(/^(?:#{ATTR_RE}|#{BRACK_RE}|#{FUNC_RE}|#{CATCH_RE})/)
+            _, *m = *expr.match(/^(?:#{ATTR_RE}|#{BRACK_RE}|#{FUNC_RE}|#{CUST_RE}|#{CATCH_RE})/)
             break unless _
 
             expr = $'
@@ -215,9 +284,15 @@ module Hpricot
 
             if m[0] == ":" && m[1] == "not"
                 nodes, = Elements.filter(nodes, m[2], false)
+            elsif "#{m[0]}#{m[1]}" =~ /^(:even|:odd)$/
+                new_nodes = []
+                nodes.each_with_index {|n,i| new_nodes.push(n) if (i % 2 == (m[1] == "even" ? 0 : 1)) }
+                nodes = new_nodes
+            elsif "#{m[0]}#{m[1]}" =~ /^(:first|:last)$/
+                nodes = [nodes.send(m[1])]
             else
-                meth = "filter[#{m[0]}#{m[1]}]"
-                if Traverse.method_defined? meth
+                meth = "filter[#{m[0]}#{m[1]}]" unless m[0].empty?
+                if meth and Traverse.method_defined? meth
                     args = m[2..-1]
                 else
                     meth = "filter[#{m[0]}]"
@@ -235,6 +310,40 @@ module Hpricot
         [nodes, expr]
     end
 
+    # Given two elements, attempt to gather an Elements array of everything between
+    # (and including) those two elements.
+    def self.expand(ele1, ele2, excl=false)
+      ary = []
+      offset = excl ? -1 : 0
+
+      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+offset)]
+        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+offset)]
+          end
+        end
+      end
+
+      return Elements[*ary]
+    end
+
     def filter(expr)
         nodes, = Elements.filter(self, expr)
         nodes
@@ -311,9 +420,9 @@ module Hpricot
 
     filter ':nth-child' do |arg,i|
       case arg 
-      when 'even'; parent.containers.index(self) % 2 == 0
-      when 'odd';  parent.containers.index(self) % 2 == 1
-      else         self == parent.containers[arg.to_i]
+      when 'even'; (parent.containers.index(self) + 1) % 2 == 0
+      when 'odd';  (parent.containers.index(self) + 1) % 2 == 1
+      else         self == (parent.containers[arg.to_i + 1])
       end
     end
 
@@ -357,9 +466,11 @@ module Hpricot
       self.comment?
     end
 
-    filter :contains do |arg,|
+    filter :contains do |arg, ignore|
       html.include? arg
     end
+    
+    
 
     pred_procs =
       {'text()' => proc { |ele, *_| ele.inner_text.strip },