hpricot 0.6.164 → 0.7

data/ext/hpricot_scan/test.rb

@@ -1,5 +1,4 @@
 require './hpricot_scan.so'
 
 doc = "<doc><person><test>YESSS</test></person><train>SET</train></doc>"
-Hpricot.scan(doc) { |x| p x }
-p Hpricot.lemon(doc)
+p Hpricot.scan(doc)

data/lib/hpricot/builder.rb

@@ -1,20 +1,13 @@
 require 'hpricot/tags'
 require 'fast_xs'
 require 'hpricot/blankslate'
+require 'hpricot/htmlinfo'
 
 module Hpricot
-  PREDEFINED = {
-    34 => '"', # quotation mark
-    38 => '&',  # ampersand
-    60 => '<',   # left angle bracket
-    62 => '>'    # right angle bracket
-  }
-  PREDEFINED_U = PREDEFINED.inject({}) { |hsh, (k, v)| hsh[v] = k; hsh }
-
   # XML unescape
   def self.uxs(str)
     str.to_s.
-        gsub(/\&\w+;/) { |x| (PREDEFINED_U[x] || ??).chr }.
+        gsub(/\&(\w+);/) { [NamedCharacters[$1] || ??].pack("U*") }.
         gsub(/\&\#(\d+);/) { [$1.to_i].pack("U*") }
   end
 
@@ -23,7 +16,7 @@ module Hpricot
     assigns.each do |k, v|
       ele.instance_variable_set("@#{k}", v)
     end
-    ele.instance_eval &blk
+    ele.instance_eval(&blk)
     ele
   end
 
@@ -45,14 +38,21 @@ module Hpricot
       @@default[option] = value
     end
 
+    def add_child ele
+      ele.parent = self
+      self.children ||= []
+      self.children << ele
+      ele
+    end
+
     # Write a +string+ to the HTML stream, making sure to escape it.
     def text!(string)
-      @children << Text.new(string.fast_xs)
+      add_child Text.new(string.fast_xs)
     end
 
     # Write a +string+ to the HTML stream without escaping it.
     def text(string)
-      @children << Text.new(string)
+      add_child Text.new(string)
       nil
     end
     alias_method :<<, :text
@@ -67,11 +67,11 @@ module Hpricot
               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
@@ -105,14 +105,15 @@ module Hpricot
       end
 
       # create the element itself
-      f = Elem.new(STag.new(tag, attrs), childs, ETag.new(tag))
+      tag = tag.to_s
+      f = Elem.new(tag, attrs, childs, ETag.new(tag))
 
       # build children from the block
       if block
         build(f, &block)
       end
 
-      @children << f
+      add_child f
       f
     end
 
@@ -145,11 +146,11 @@ module Hpricot
     end
 
     def doctype(target, pub, sys)
-      @children << DocType.new(target, pub, sys)
+      add_child 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)
@@ -193,7 +194,7 @@ module Hpricot
     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)
@@ -207,7 +208,7 @@ module Hpricot
         args.push(@attrs)
         return @builder.tag!(@sym, *args, &block)
       end
-      
+
       return self
     end
 

data/lib/hpricot/elements.rb

@@ -168,7 +168,7 @@ module Hpricot
         end
         x.parent.replace_child(x, wrap)
         nest = nest.children.first until nest.empty?
-        nest.html(nest.children + [x])
+        nest.html([x])
       end
     end
 
@@ -275,7 +275,7 @@ module Hpricot
             expr = $'
             m.compact!
             if m[0] == '@'
-                m[0] = "@#{m.slice!(2,1)}"
+                m[0] = "@#{m.slice!(2,1).join}"
             end
 
             if m[0] == '[' && m[1] =~ /^\d+$/
@@ -300,10 +300,10 @@ module Hpricot
                         args = m[1..-1]
                     end
                 end
-                i = -1
+                args << -1
                 nodes = Elements[*nodes.find_all do |x| 
-                                      i += 1
-                                      x.send(meth, *([*args] + [i])) ? truth : !truth
+                                      args[-1] += 1
+                                      x.send(meth, *args) ? truth : !truth
                                   end]
             end
         end
@@ -422,7 +422,7 @@ module Hpricot
       case arg 
       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])
+      else         self == (parent.containers[arg.to_i - 1])
       end
     end
 
@@ -446,23 +446,23 @@ module Hpricot
       parent.containers.length == 1
     end
 
-    filter :parent do
+    filter :parent do |*a|
       containers.length > 0
     end
 
-    filter :empty do
+    filter :empty do |*a|
       containers.length == 0
     end
 
-    filter :root do
+    filter :root do |*a|
       self.is_a? Hpricot::Doc
     end
     
-    filter 'text' do
+    filter 'text' do |*a|
       self.text?
     end
 
-    filter 'comment' do
+    filter 'comment' do |*a|
       self.comment?
     end
 
@@ -495,7 +495,7 @@ module Hpricot
     end
 
     filter 'text()' do |val,i|
-      !self.inner_text.strip.empty?
+      self.children.grep(Hpricot::Text).detect { |x| x.content =~ /\S/ } if self.children
     end
 
     filter '@' do |attr,val,i|

data/lib/hpricot/htmlinfo.rb

@@ -473,9 +473,23 @@ module Hpricot
    "menu", "noframes", "noscript", "object", "ol", "p", "pre", "q", "s",
    "samp", "script", "select", "small", "span", "strike", "strong", "sub",
    "sup", "table", "textarea", "tt", "u", "ul", "var"]}
+  ElementContent.keys.each do |k|
+    v = ElementContent[k]
+    if v.is_a? Array
+      ElementContent[k] = v.inject({}) do |h, name|
+        h[name.hash] = true
+        h
+      end
+    end
+  end
 
   ElementInclusions =
 {"head"=>["link", "meta", "object", "script", "style"], "body"=>["del", "ins"]}
+  ElementInclusions.each do |k, v|
+    v.each do |name|
+      ElementContent[k][name.hash] = :allow
+    end
+  end
 
   ElementExclusions =
 {"button"=>
@@ -496,6 +510,11 @@ module Hpricot
    "h1", "h2", "h3", "h4", "h5", "h6", "hr", "isindex", "menu", "noframes",
    "noscript", "ol", "p", "pre", "table", "ul"],
  "label"=>["label"]}
+  ElementExclusions.each do |k, v|
+    v.each do |name|
+      ElementContent[k][name.hash] = :deny
+    end
+  end
 
   OmittedAttrName =
 {"h6"=>

data/lib/hpricot/inspect.rb

@@ -11,28 +11,7 @@ module Hpricot
 
   class Doc
     def pretty_print(q)
-      q.object_group(self) { @children.each {|elt| q.breakable; q.pp elt } }
-    end
-    alias inspect pretty_print_inspect
-  end
-
-  class Elem
-    def pretty_print(q)
-      if empty?
-        q.group(1, '{emptyelem', '}') {
-          q.breakable; q.pp @stag
-        }
-      else
-        q.group(1, "{elem", "}") {
-          q.breakable; q.pp @stag
-          if @children
-            @children.each {|elt| q.breakable; q.pp elt }
-          end
-          if @etag
-            q.breakable; q.pp @etag
-          end
-        }
-      end
+      q.object_group(self) { children.each {|elt| q.breakable; q.pp elt } }
     end
     alias inspect pretty_print_inspect
   end
@@ -41,7 +20,7 @@ module Hpricot
     def pretty_print(q)
       q.group(1, '{', '}') {
         q.text self.class.name.sub(/.*::/,'').downcase
-        if rs = @raw_string
+        if rs = raw_string
           rs.scan(/[^\r\n]*(?:\r\n?|\n|[^\r\n]\z)/) {|line|
             q.breakable
             q.pp line
@@ -55,13 +34,30 @@ module Hpricot
     alias inspect pretty_print_inspect
   end
 
-  class STag
+  class Elem
     def pretty_print(q)
+      if empty?
+        q.group(1, '{emptyelem', '}') {
+          q.breakable; pretty_print_stag q
+        }
+      else
+        q.group(1, "{elem", "}") {
+          q.breakable; pretty_print_stag q
+          if children
+            children.each {|elt| q.breakable; q.pp elt }
+          end
+          if etag
+            q.breakable; q.pp etag
+          end
+        }
+      end
+    end
+    def pretty_print_stag(q)
       q.group(1, '<', '>') {
-        q.text @name
+        q.text name
 
-        if @raw_attributes
-          @raw_attributes.each {|n, t|
+        if raw_attributes
+          raw_attributes.each {|n, t|
             q.breakable
             if t
               q.text "#{n}=\"#{Hpricot.uxs(t)}\""
@@ -78,7 +74,7 @@ module Hpricot
   class ETag
     def pretty_print(q)
       q.group(1, '</', '>') {
-        q.text @name
+        q.text name
       }
     end
     alias inspect pretty_print_inspect
@@ -86,7 +82,7 @@ module Hpricot
 
   class Text
     def pretty_print(q)
-      q.text @content.dump
+      q.text content.dump
     end
   end
 
@@ -94,11 +90,11 @@ module Hpricot
     def pretty_print(q)
       q.group(1, '{', '}') {
         q.text self.class.name.sub(/.*::/,'').downcase
-        if rs = @raw_string
+        if rs = raw_string
           q.breakable
           q.text rs
         else
-          q.text "</#{@name}>"
+          q.text "</#{name}>"
         end
       }
     end

data/lib/hpricot/modules.rb

@@ -4,7 +4,6 @@ module Hpricot
 
   # :stopdoc:
   module Tag; include Hpricot end
-    class STag; include Tag end
     class ETag; include Tag end
   # :startdoc:
 
@@ -12,6 +11,7 @@ module Hpricot
     module Container; include Node end
       class Doc; include Container end
       class Elem; include Container end
+
     module Leaf; include Node end
       class Text; include Leaf end
       class XMLDecl; include Leaf end
@@ -25,6 +25,7 @@ module Hpricot
   module Leaf::Trav; include Traverse end
   class Doc;       module Trav; include Container::Trav end; include Trav end
   class Elem;      module Trav; include Container::Trav end; include Trav end
+  class CData;     module Trav; include Leaf::Trav      end; include Trav end
   class Text;      module Trav; include Leaf::Trav      end; include Trav end
   class XMLDecl;   module Trav; include Leaf::Trav      end; include Trav end
   class DocType;   module Trav; include Leaf::Trav      end; include Trav end

data/lib/hpricot/parse.rb

@@ -1,7 +1,7 @@
 require 'hpricot/htmlinfo'
 
 def Hpricot(input = nil, opts = {}, &blk)
-  Hpricot.parse(input, opts, &blk)
+  Hpricot.make(input, opts, &blk)
 end
 
 module Hpricot
@@ -12,287 +12,27 @@ module Hpricot
   # Hpricot.parse parses <i>input</i> and return a document tree.
   # represented by Hpricot::Doc.
   def Hpricot.parse(input = nil, opts = {}, &blk)
-    Doc.new(make(input, opts, &blk), opts)
+    make(input, opts, &blk)
   end
 
   # Hpricot::XML parses <i>input</i>, disregarding all the HTML rules
   # and returning a document tree.
   def Hpricot.XML(input = nil, opts = {}, &blk)
     opts.merge! :xml => true
-    Doc.new(make(input, opts, &blk), opts)
+    make(input, opts, &blk)
   end
 
   # :stopdoc:
 
   def Hpricot.make(input = nil, opts = {}, &blk)
-    opts = {:fixup_tags => false}.merge(opts)
-    unless input or blk
-      raise ArgumentError, "An Hpricot document must be built from an input source (a String) or a block."
-    end
-
-    conv = opts[:xml] ? :to_s : :downcase
-
-    fragment =
-    if input
-      case opts[:encoding]
-      when nil
-      when 'utf-8'
-        unless defined? Encoding::Character::UTF8
-          raise EncodingError, "The ruby-character-encodings library could not be found for utf-8 mode."
-        end
-      else
-        raise EncodingError, "No encoding option `#{opts[:encoding]}' is available."
-      end
-
-      if opts[:xhtml_strict]
-        opts[:fixup_tags] = true
-      end
-
-      stack = [[nil, nil, [], [], [], []]]
-      Hpricot.scan(input) do |token|
-        if stack.last[5] == :CDATA and ![:procins, :comment, :cdata].include?(token[0]) and
-            !(token[0] == :etag and token[1].casecmp(stack.last[0]).zero?)
-          token[0] = :text
-          token[1] = token[3] if token[3]
-        end
-
-        if !opts[:xml] and token[0] == :emptytag
-          token[1] = token[1].send(conv)
-          if ElementContent[token[1].downcase] != :EMPTY
-            token[0] = :stag
-          end
-        end
-
-        # TODO: downcase instead when parsing attributes?
-        if !opts[:xml] and token[2].is_a?(Hash)
-          token[2] = token[2].inject({}) { |hsh,(k,v)| hsh[k.downcase] = v; hsh }
-        end
-
-        case token[0]
-        when :stag
-          case opts[:encoding] when 'utf-8'
-            token.map! { |str| u(str) if str.is_a? String }
-          end
-
-          stagname = token[0] = token[1] = token[1].send(conv)
-          if ElementContent[stagname] == :EMPTY and !opts[:xml]
-            token[0] = :emptytag
-            stack.last[2] << token
-          else
-            unless opts[:xml]
-              if opts[:fixup_tags]
-                # obey the tag rules set up by the current element
-                if ElementContent.has_key? stagname
-                  trans = nil
-                  (stack.length-1).downto(0) do |i|
-                    untags = stack[i][5]
-                    break unless untags.include? stagname
-                    # puts "** ILLEGAL #{stagname} IN #{stack[i][0]}"
-                    trans = i
-                  end
-                  if trans.to_i > 1
-                    eles = stack.slice!(trans..-1)
-                    stack.last[2] += eles
-                    # puts "** TRANSPLANTED #{stagname} TO #{stack.last[0]}"
-                  end
-                elsif opts[:xhtml_strict]
-                  token[2] = {'class' => stagname}
-                  stagname = token[0] = "div"
-                end
-              end
-
-              # setup tag rules for inside this element
-              if ElementContent[stagname] == :CDATA
-                uncontainable_tags = :CDATA
-              elsif opts[:fixup_tags]
-                possible_tags = ElementContent[stagname]
-                excluded_tags, included_tags = stack.last[3..4]
-                if possible_tags
-                  excluded_tags = excluded_tags | (ElementExclusions[stagname] || [])
-                  included_tags = included_tags | (ElementInclusions[stagname] || [])
-                  containable_tags = (possible_tags | included_tags) - excluded_tags
-                  uncontainable_tags = ElementContent.keys - containable_tags
-                else
-                  # If the tagname is unknown, it is assumed that any element
-                  # except excluded can be contained.
-                  uncontainable_tags = excluded_tags
-                end
-              end
-            end
-            unless opts[:xml]
-              case token[2] when Hash
-                token[2] = token[2].inject({}) { |hsh,(k,v)| hsh[k.downcase] = v; hsh }
-              end
-            end
-            stack << [stagname, token, [], excluded_tags, included_tags, uncontainable_tags]
-          end
-        when :etag
-          etagname = token[0] = token[1].send(conv)
-          if opts[:xhtml_strict] and not ElementContent.has_key? etagname
-            etagname = token[0] = "div"
-          end
-          matched_elem = nil
-          (stack.length-1).downto(0) do |i|
-            stagname, = stack[i]
-            if stagname == etagname
-              matched_elem = stack[i]
-              stack[i][1] += token
-              eles = stack.slice!((i+1)..-1)
-              stack.last[2] += eles if eles
-              break
-            end
-          end
-          unless matched_elem
-            stack.last[2] << [:bogus_etag, token.first, token.last]
-          else
-            ele = stack.pop
-            stack.last[2] << ele
-          end
-        when :text
-          l = stack.last[2].last
-          if l and l[0] == :text
-            l[1] += token[1]
-          else
-            stack.last[2] << token
-          end
-        else
-          stack.last[2] << token
-        end
-      end
-
-      while 1 < stack.length
-        ele = stack.pop
-        stack.last[2] << ele
-      end
-
-      structure_list = stack[0][2]
-      structure_list.map {|s| build_node(s, opts) }
-    elsif blk
-      Hpricot.build(&blk).children
-    end
-  end
-
-  def Hpricot.build_node(structure, opts = {})
-    case structure[0]
-    when String
-      tagname, _, attrs, sraw, _, _, _, eraw = structure[1]
-      children = structure[2]
-      etag = eraw && ETag.parse(tagname, eraw)
-      stag = STag.parse(tagname, attrs, sraw, true)
-      if !children.empty? || etag
-        Elem.new(stag,
-                  children.map {|c| build_node(c, opts) },
-                  etag)
-      else
-        Elem.new(stag)
-      end
-    when :text
-      Text.parse_pcdata(structure[1])
-    when :emptytag
-      Elem.new(STag.parse(structure[1], structure[2], structure[3], false))
-    when :bogus_etag
-      BogusETag.parse(structure[1], structure[2])
-    when :xmldecl
-      XMLDecl.parse(structure[2], structure[3])
-    when :doctype
-      if opts[:xhtml_strict]
-        structure[2]['system_id'] = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
-        structure[2]['public_id'] = "-//W3C//DTD XHTML 1.0 Strict//EN"
-      end
-      DocType.parse(structure[1], structure[2], structure[3])
-    when :procins
-      ProcIns.parse(structure[1])
-    when :comment
-      Comment.parse(structure[1])
-    when :cdata_content
-      Text.parse_cdata_content(structure[1])
-    when :cdata
-      Text.parse_cdata_section(structure[1])
+    if blk
+      doc = Hpricot.build(&blk)
+      doc.instance_variable_set("@options", opts)
+      doc
     else
-      raise "[bug] unknown structure: #{structure.inspect}"
+      Hpricot.scan(input, opts)
     end
   end
 
-  def STag.parse(qname, attrs, raw_string, is_stag)
-    result = STag.new(qname, attrs)
-    result.raw_string = raw_string
-    result
-  end
-
-  def ETag.parse(qname, raw_string)
-    result = self.new(qname)
-    result.raw_string = raw_string
-    result
-  end
-
-  def BogusETag.parse(qname, raw_string)
-    result = self.new(qname)
-    result.raw_string = raw_string
-    result
-  end
-
-  def Text.parse_pcdata(raw_string)
-    result = Text.new(raw_string)
-    result
-  end
-
-  def Text.parse_cdata_content(raw_string)
-    result = CData.new(raw_string)
-    result
-  end
-
-  def Text.parse_cdata_section(content)
-    result = CData.new(content)
-    result
-  end
-
-  def XMLDecl.parse(attrs, raw_string)
-    attrs ||= {}
-    version = attrs['version']
-    encoding = attrs['encoding']
-    case attrs['standalone']
-    when 'yes'
-      standalone = true
-    when 'no'
-      standalone = false
-    else
-      standalone = nil
-    end
-
-    result = XMLDecl.new(version, encoding, standalone)
-    result.raw_string = raw_string
-    result
-  end
-
-  def DocType.parse(root_element_name, attrs, raw_string)
-    if attrs
-      public_identifier = attrs['public_id']
-      system_identifier = attrs['system_id']
-    end
-
-    root_element_name = root_element_name.downcase
-
-    result = DocType.new(root_element_name, public_identifier, system_identifier)
-    result.raw_string = raw_string
-    result
-  end
-
-  def ProcIns.parse(raw_string)
-    _, target, content = *raw_string.match(/\A<\?(\S+)\s+(.+)/m)
-    result = ProcIns.new(target, content)
-    result
-  end
-
-  def Comment.parse(content)
-    result = Comment.new(content)
-    result
-  end
-
-  module Pat
-    NameChar = /[-A-Za-z0-9._:]/
-    Name = /[A-Za-z_:]#{NameChar}*/
-    Nmtoken = /#{NameChar}+/
-  end
-
   # :startdoc:
 end