hpricot 0.4

data/lib/hpricot/inspect.rb

@@ -0,0 +1,90 @@
+require 'pp'
+
+module Hpricot
+  # :stopdoc:
+  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
+    end
+    alias inspect pretty_print_inspect
+  end
+
+  module Leaf
+    def pretty_print(q)
+      q.group(1, '{', '}') {
+        q.text self.class.name.sub(/.*::/,'').downcase
+        if rs = @raw_string
+          rs.scan(/[^\r\n]*(?:\r\n?|\n|[^\r\n]\z)/) {|line|
+            q.breakable
+            q.pp line
+          }
+        elsif self.respond_to? :to_s
+          q.breakable
+          q.text self.to_s
+        end
+      }
+    end
+    alias inspect pretty_print_inspect
+  end
+
+  class STag
+    def pretty_print(q)
+      q.group(1, '<', '>') {
+        q.text @name
+
+        if @attributes
+          @attributes.each {|n, t|
+            q.breakable
+            q.text "#{n}=\"#{t}\""
+          }
+        end
+      }
+    end
+    alias inspect pretty_print_inspect
+  end
+
+  class ETag
+    def pretty_print(q)
+      q.group(1, '</', '>') {
+        q.text @name
+      }
+    end
+    alias inspect pretty_print_inspect
+  end
+
+  class BogusETag
+    def pretty_print(q)
+      q.group(1, '{', '}') {
+        q.text self.class.name.sub(/.*::/,'').downcase
+        if rs = @raw_string
+          q.breakable
+          q.text rs
+        else
+          q.text "</#{@name}>"
+        end
+      }
+    end
+  end
+  # :startdoc:
+end

data/lib/hpricot/modules.rb

@@ -0,0 +1,37 @@
+module Hpricot
+  class Name; include Hpricot end
+  class Context; include Hpricot end
+
+  # :stopdoc:
+  module Tag; include Hpricot end
+    class STag; include Tag end
+    class ETag; include Tag end
+  # :startdoc:
+
+  module Node; include Hpricot end
+    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
+      class DocType; include Leaf end
+      class ProcIns; include Leaf end
+      class Comment; include Leaf end
+      class BogusETag; include Leaf end
+
+  module Traverse end
+  module Container::Trav; include Traverse end
+  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 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
+  class ProcIns;   module Trav; include Leaf::Trav      end; include Trav end
+  class Comment;   module Trav; include Leaf::Trav      end; include Trav end
+  class BogusETag; module Trav; include Leaf::Trav      end; include Trav end
+
+  class Error < StandardError; end
+end
+

data/lib/hpricot/parse.rb

@@ -0,0 +1,286 @@
+require 'hpricot/htmlinfo'
+
+def Hpricot(input, opts = {})
+  Hpricot.parse(input, opts)
+end
+
+module Hpricot
+  # 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
+
+  # :stopdoc:
+
+  def Hpricot.make(input, opts = {})
+    opts = {:fixup_tags => false}.merge(opts)
+    stack = [[nil, nil, [], [], [], []]]
+    Hpricot.scan(input) do |token|
+      if stack.last[5] == :CDATA 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
+        stagname = token[0] = token[1].downcase
+        if ElementContent[stagname] == :EMPTY
+          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]}"
+              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
+            end
+          end
+          stack << [stagname, token, [], excluded_tags, included_tags, uncontainable_tags]
+        end
+      when :etag
+        etagname = token[0] = token[1].downcase
+        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
+            break
+          end
+        end
+        unless matched_elem
+          stack.last[2] << [:bogus_etag, token]
+        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) }
+  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
+  end
+
+  def Hpricot.build_node(structure)
+    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) },
+                  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
+      DocType.parse(structure[1], structure[2], structure[3])
+    when :procins
+      ProcIns.parse(structure[1], structure[2], structure[3])
+    when :comment
+      Comment.parse(structure[1])
+    when :cdata_content
+      Text.parse_cdata_content(structure[1])
+    when :cdata
+      Text.parse_cdata_section(structure[1])
+    else
+      raise Exception, "[bug] unknown structure: #{structure.inspect}"
+    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.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
+  end
+
+  def Text.parse_cdata_section(content)
+    result = Text.new(content)
+    result.raw_string = "<![CDATA[" + 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(target, content, raw_string)
+    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
+
+  module Pat
+    NameChar = /[-A-Za-z0-9._:]/
+    Name = /[A-Za-z_:]#{NameChar}*/
+    Nmtoken = /#{NameChar}+/
+  end
+
+  # :startdoc:
+end

data/lib/hpricot/tag.rb

@@ -0,0 +1,146 @@
+module Hpricot
+  # :stopdoc:
+
+  class Doc
+    attr_accessor :children
+    def initialize(children)
+      @children = children ? children.each { |c| c.parent = self }  : []
+    end
+    def output(out)
+      @children.each do |n|
+        n.output(out)
+      end
+      out
+    end
+  end
+
+  class BaseEle
+    attr_accessor :raw_string, :parent
+    def html_quote(str)
+      "\"" + str.gsub('"', '\\"') + "\""
+    end
+  end
+
+  class Elem
+    attr_accessor :stag, :etag, :children
+    def initialize(stag, children=nil, etag=nil)
+      @stag, @etag = stag, etag
+      @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) } }
+    end
+    def output(out)
+      if empty? and ElementContent[@stag.name] == :EMPTY
+        @stag.output(out, :style => :empty)
+      else
+        @stag.output(out)
+        @children.each { |n| n.output(out) }
+        @stag.output(out, :style => :end)
+      end
+      out
+    end
+  end
+
+  class STag < BaseEle
+    def initialize(name, attributes=nil)
+      @name = name.downcase
+      if attributes
+        @attributes = attributes.inject({}) { |hsh,(k,v)| hsh[k.downcase] = v; hsh }
+      end
+    end
+    attr_accessor :name, :attributes
+    def attributes_as_html
+      if @attributes
+        @attributes.map do |aname, aval|
+          " #{aname}" +
+            (aval ? "=#{html_quote(aval)}" : "")
+        end.join
+      end
+    end
+    def output(out, opts = {})
+      out <<
+        case opts[:style]
+        when :end
+          "</#{@name}>"
+        else
+          "<#{@name}#{attributes_as_html}" +
+            (opts[:style] == :empty ? " /" : "") +
+            ">"
+        end
+    end
+  end
+
+  class ETag < BaseEle
+    def initialize(qualified_name)
+      @name = qualified_name
+    end
+    attr_reader :name
+  end
+
+  class BogusETag < ETag
+    def output(out); end
+  end
+
+  class Text < BaseEle
+    def initialize(text)
+      @content = text
+    end
+    attr_reader :content
+    def output(out)
+      out << @content
+    end
+  end
+
+  class XMLDecl < BaseEle
+    def initialize(version, encoding, standalone)
+      @version, @encoding, @standalone = version, encoding, standalone
+    end
+    attr_reader :version, :encoding, :standalone
+    def output(out)
+      out <<
+        "<?xml version=\"#{@version}\"" +
+          (@encoding ? " encoding=\"#{encoding}\"" : "") +
+          (@standalone != nil ? " standalone=\"#{standalone ? 'yes' : 'no'}\"" : "") +
+          "?>"
+    end
+  end
+
+  class DocType < BaseEle
+    def initialize(name, pubid, sysid)
+      @name, @public_id, @system_id = name, pubid, sysid
+    end
+    attr_reader :name, :public_id, :system_id
+    def output(out)
+      out <<
+        "<!DOCTYPE #{@name} " +
+          (@public_id ? "PUBLIC \"#{@public_id}\"" : "SYSTEM") +
+          (@system_id ? " #{html_quote(@system_id)}" : "") + ">"
+    end
+  end
+
+  class ProcIns < BaseEle
+    def initialize(target, content)
+      @target, @content = target, content
+    end
+    attr_reader :target, :content
+    def output(out)
+      out << "<?#{@target}" +
+        (@content ? " #{@content}" : "") +
+        "?>"
+    end
+  end
+
+  class Comment < BaseEle
+    def initialize(content)
+      @content = content
+    end
+    attr_reader :content
+    def output(out)
+      out << "<!--#{@content}-->"
+    end
+  end
+
+  # :startdoc:
+end