hpricot 0.4-mswin32 → 0.5-mswin32

data/lib/hpricot/inspect.rb

@@ -2,6 +2,13 @@ require 'pp'
 
 module Hpricot
   # :stopdoc:
+  class Elements
+    def pretty_print(q)
+      q.object_group(self) { super }
+    end
+    alias inspect pretty_print_inspect
+  end
+
   class Doc
     def pretty_print(q)
       q.object_group(self) { @children.each {|elt| q.breakable; q.pp elt } }
@@ -73,6 +80,12 @@ module Hpricot
     alias inspect pretty_print_inspect
   end
 
+  class Text
+    def pretty_print(q)
+      q.text @content.dump
+    end
+  end
+
   class BogusETag
     def pretty_print(q)
       q.group(1, '{', '}') {

data/lib/hpricot/parse.rb

@@ -5,69 +5,107 @@ def Hpricot(input, opts = {})
 end
 
 module Hpricot
+  # Exception class used for any errors related to deficiencies in the system when
+  # handling the character encodings of a document.
+  class EncodingError < StandardError; end
+
   # Hpricot.parse parses <i>input</i> and return a document tree.
   # represented by Hpricot::Doc.
   def Hpricot.parse(input, opts = {})
     Doc.new(make(input, opts))
   end
 
+  # Hpricot::XML parses <i>input</i>, disregarding all the HTML rules
+  # and returning a document tree.
+  def Hpricot.XML(input, opts = {})
+    Doc.new(make(input, opts.merge(:xml => true)))
+  end
+
   # :stopdoc:
 
   def Hpricot.make(input, opts = {})
     opts = {:fixup_tags => false}.merge(opts)
+
+    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 !(token[0] == :etag and token[1].downcase == stack.last[0])
+      if stack.last[5] == :CDATA and ![:procins, :comment, :cdata].include?(token[0]) and
+          !(token[0] == :etag and token[1].downcase == stack.last[0])
         token[0] = :text
         token[1] = token[3] if token[3]
       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].downcase
-        if ElementContent[stagname] == :EMPTY
+        if ElementContent[stagname] == :EMPTY and !opts[:xml]
           token[0] = :emptytag
           stack.last[2] << token
         else
-          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]}"
+          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
-          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
+            # 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
           stack << [stagname, token, [], excluded_tags, included_tags, uncontainable_tags]
         end
       when :etag
         etagname = token[0] = token[1].downcase
+        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]
@@ -80,7 +118,7 @@ module Hpricot
           end
         end
         unless matched_elem
-          stack.last[2] << [:bogus_etag, token]
+          stack.last[2] << [:bogus_etag, token.first, token.last]
         else
           ele = stack.pop
           stack.last[2] << ele
@@ -103,63 +141,10 @@ module Hpricot
     end
 
     structure_list = stack[0][2]
-    structure_list.map {|s| build_node(s) }
-  end
-
-  def Hpricot.fix_element(elem, excluded_tags, included_tags)
-    tagname, _, attrs, sraw, _, _, _, eraw = elem[1]
-    children = elem[2]
-    if eraw
-      elem[2] = fix_structure_list(children)
-      return elem, []
-    else
-      if ElementContent[tagname] == :EMPTY
-        elem[2] = []
-        return elem, children
-      else
-        if ElementContent[tagname] == :CDATA
-          possible_tags = []
-        else
-          possible_tags = ElementContent[tagname]
-        end
-        if possible_tags
-          excluded_tags2 = ElementExclusions[tagname]
-          included_tags2 = ElementInclusions[tagname]
-          excluded_tags |= excluded_tags2 if excluded_tags2
-          included_tags |= included_tags2 if included_tags2
-          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
-        fixed_children = []
-        rest = children
-        until rest.empty?
-          if String === rest[0][0]
-            elem = rest.shift
-            elem_tagname = elem[0]
-            elem_tagname = elem_tagname.downcase
-            if uncontainable_tags.include? elem_tagname
-              rest.unshift elem
-              break
-            else
-              fixed_elem, rest2 = fix_element(elem, excluded_tags, included_tags)
-              fixed_children << fixed_elem
-              rest = rest2 + rest
-            end
-          else
-            fixed_children << rest.shift
-          end
-        end
-        elem[2] = fixed_children
-        return elem, rest
-      end
-    end
+    structure_list.map {|s| build_node(s, opts) }
   end
 
-  def Hpricot.build_node(structure)
+  def Hpricot.build_node(structure, opts = {})
     case structure[0]
     when String
       tagname, _, attrs, sraw, _, _, _, eraw = structure[1]
@@ -168,7 +153,7 @@ module Hpricot
       stag = STag.parse(tagname, attrs, sraw, true)
       if !children.empty? || etag
         Elem.new(stag,
-                  children.map {|c| build_node(c) },
+                  children.map {|c| build_node(c, opts) },
                   etag)
       else
         Elem.new(stag)
@@ -182,9 +167,13 @@ module Hpricot
     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], structure[2], structure[3])
+      ProcIns.parse(structure[1])
     when :comment
       Comment.parse(structure[1])
     when :cdata_content
@@ -216,20 +205,16 @@ module Hpricot
 
   def Text.parse_pcdata(raw_string)
     result = Text.new(raw_string)
-    result.raw_string = raw_string
     result
   end
 
   def Text.parse_cdata_content(raw_string)
-    result = Text.new(raw_string)
-    result.raw_string = raw_string
-    result.instance_variable_set( "@cdata", true )
+    result = CData.new(raw_string)
     result
   end
 
   def Text.parse_cdata_section(content)
-    result = Text.new(content)
-    result.raw_string = "<![CDATA[" + content + "]]>"
+    result = CData.new(content)
     result
   end
 
@@ -264,15 +249,14 @@ module Hpricot
     result
   end
 
-  def ProcIns.parse(target, content, raw_string)
+  def ProcIns.parse(raw_string)
+    _, target, content = *raw_string.match(/\A<\?(\S+)\s+(.+)/m)
     result = ProcIns.new(target, content)
-    result.raw_string = raw_string
     result
   end
 
   def Comment.parse(content)
     result = Comment.new(content)
-    result.raw_string = "<!--" + content + "-->"
     result
   end
 

data/lib/hpricot/tag.rb

@@ -6,12 +6,13 @@ module Hpricot
     def initialize(children)
       @children = children ? children.each { |c| c.parent = self }  : []
     end
-    def output(out)
+    def output(out, opts = {})
       @children.each do |n|
-        n.output(out)
+        n.output(out, opts)
       end
       out
     end
+    def altered!; end
   end
 
   class BaseEle
@@ -19,6 +20,26 @@ module Hpricot
     def html_quote(str)
       "\"" + str.gsub('"', '\\"') + "\""
     end
+    def if_output(opts)
+      if opts[:preserve] and not @raw_string.nil?
+        @raw_string
+      else
+        yield opts
+      end
+    end
+    def pathname; self.name end
+    def altered!
+      @raw_string = nil
+    end
+    def self.alterable(*fields)
+      attr_accessor(*fields)
+      fields.each do |f|
+        define_method("#{f}=") do |v|
+          altered!
+          instance_variable_set("@#{f}", v)
+        end
+      end
+    end
   end
 
   class Elem
@@ -28,16 +49,34 @@ module Hpricot
       @children = children ? children.each { |c| c.parent = self }  : []
     end
     def empty?; @children.empty? end
-    [:name, :attributes, :parent].each do |m|
-      [m, "#{m}="].each { |m2| define_method(m2) { |*a| @stag.send(m2, *a) } }
+    [:name, :attributes, :parent, :altered!].each do |m|
+      [m, "#{m}="].each { |m2| define_method(m2) { |*a| [@etag, @stag].inject { |_,t| t.send(m2, *a) if t and t.respond_to?(m2) } } }
+    end
+    def to_plain_text
+      if self.name == 'br'
+        "\n"
+      elsif self.name == 'p'
+        "\n\n" + super + "\n\n"
+      elsif self.name == 'a' and self.has_attribute?('href')
+        "#{super} [#{self['href']}]"
+      elsif self.name == 'img' and self.has_attribute?('src')
+        "[img:#{self['src']}]"
+      else
+        super
+      end
     end
-    def output(out)
+    def pathname; self.name end
+    def output(out, opts = {})
       if empty? and ElementContent[@stag.name] == :EMPTY
-        @stag.output(out, :style => :empty)
+        @stag.output(out, opts.merge(:style => :empty))
       else
-        @stag.output(out)
-        @children.each { |n| n.output(out) }
-        @stag.output(out, :style => :end)
+        @stag.output(out, opts)
+        @children.each { |n| n.output(out, opts) }
+        if @etag
+          @etag.output(out, opts)
+        elsif !opts[:preserve]
+          ETag.new(@stag.name).output(out, opts)
+        end
       end
       out
     end
@@ -46,11 +85,12 @@ module Hpricot
   class STag < BaseEle
     def initialize(name, attributes=nil)
       @name = name.downcase
+      @attributes = {}
       if attributes
         @attributes = attributes.inject({}) { |hsh,(k,v)| hsh[k.downcase] = v; hsh }
       end
     end
-    attr_accessor :name, :attributes
+    alterable :name, :attributes
     def attributes_as_html
       if @attributes
         @attributes.map do |aname, aval|
@@ -61,10 +101,7 @@ module Hpricot
     end
     def output(out, opts = {})
       out <<
-        case opts[:style]
-        when :end
-          "</#{@name}>"
-        else
+        if_output(opts) do
           "<#{@name}#{attributes_as_html}" +
             (opts[:style] == :empty ? " /" : "") +
             ">"
@@ -76,20 +113,43 @@ module Hpricot
     def initialize(qualified_name)
       @name = qualified_name
     end
-    attr_reader :name
+    alterable :name
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          "</#{@name}>"
+        end
+    end
   end
 
   class BogusETag < ETag
-    def output(out); end
+    def output(out, opts = {}); out << if_output(opts) { '' }; end
   end
 
   class Text < BaseEle
     def initialize(text)
       @content = text
     end
-    attr_reader :content
-    def output(out)
-      out << @content
+    alterable :content
+    def pathname; "text()" end
+    alias_method :inner_text, :content
+    alias_method :to_plain_text, :content
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          @content
+        end
+    end
+  end
+
+  class CData < Text
+    alias_method :inner_text, :content
+    alias_method :to_plain_text, :content
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          "<![CDATA[#@content]]>"
+        end
     end
   end
 
@@ -97,26 +157,32 @@ module Hpricot
     def initialize(version, encoding, standalone)
       @version, @encoding, @standalone = version, encoding, standalone
     end
-    attr_reader :version, :encoding, :standalone
-    def output(out)
+    alterable :version, :encoding, :standalone
+    def pathname; "xmldecl()" end
+    def output(out, opts = {})
       out <<
-        "<?xml version=\"#{@version}\"" +
-          (@encoding ? " encoding=\"#{encoding}\"" : "") +
-          (@standalone != nil ? " standalone=\"#{standalone ? 'yes' : 'no'}\"" : "") +
-          "?>"
+        if_output(opts) do
+          "<?xml version=\"#{@version}\"" +
+            (@encoding ? " encoding=\"#{encoding}\"" : "") +
+            (@standalone != nil ? " standalone=\"#{standalone ? 'yes' : 'no'}\"" : "") +
+            "?>"
+        end
     end
   end
 
   class DocType < BaseEle
-    def initialize(name, pubid, sysid)
-      @name, @public_id, @system_id = name, pubid, sysid
+    def initialize(target, pubid, sysid)
+      @target, @public_id, @system_id = target, pubid, sysid
     end
-    attr_reader :name, :public_id, :system_id
-    def output(out)
+    alterable :target, :public_id, :system_id
+    def pathname; "doctype()" end
+    def output(out, opts = {})
       out <<
-        "<!DOCTYPE #{@name} " +
-          (@public_id ? "PUBLIC \"#{@public_id}\"" : "SYSTEM") +
-          (@system_id ? " #{html_quote(@system_id)}" : "") + ">"
+        if_output(opts) do
+          "<!DOCTYPE #{@target} " +
+            (@public_id ? "PUBLIC \"#{@public_id}\"" : "SYSTEM") +
+            (@system_id ? " #{html_quote(@system_id)}" : "") + ">"
+        end
     end
   end
 
@@ -124,11 +190,15 @@ module Hpricot
     def initialize(target, content)
       @target, @content = target, content
     end
-    attr_reader :target, :content
-    def output(out)
-      out << "<?#{@target}" +
-        (@content ? " #{@content}" : "") +
-        "?>"
+    def pathname; "procins()" end
+    alterable :target, :content
+    def output(out, opts = {})
+      out << 
+        if_output(opts) do
+          "<?#{@target}" +
+           (@content ? " #{@content}" : "") +
+           "?>"
+        end
     end
   end
 
@@ -136,9 +206,13 @@ module Hpricot
     def initialize(content)
       @content = content
     end
-    attr_reader :content
-    def output(out)
-      out << "<!--#{@content}-->"
+    def pathname; "comment()" end
+    alterable :content
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          "<!--#{@content}-->"
+        end
     end
   end