hpricot 0.6-jruby

data/lib/hpricot/inspect.rb

@@ -0,0 +1,107 @@
+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 } }
+    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 @raw_attributes
+          @raw_attributes.each {|n, t|
+            q.breakable
+            if t
+              q.text "#{n}=\"#{Hpricot.uxs(t)}\""
+            else
+              q.text n
+            end
+          }
+        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 Text
+    def pretty_print(q)
+      q.text @content.dump
+    end
+  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,297 @@
+require 'hpricot/htmlinfo'
+
+def Hpricot(input = nil, opts = {}, &blk)
+  Hpricot.parse(input, opts, &blk)
+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 = nil, opts = {}, &blk)
+    Doc.new(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, opts = {})
+    Doc.new(make(input, opts.merge(:xml => true)))
+  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
+              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])
+    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
+  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

data/lib/hpricot/tag.rb

@@ -0,0 +1,228 @@
+module Hpricot
+  # :stopdoc:
+
+  class Doc
+    attr_accessor :children
+    def initialize(children = [])
+      @children = children ? children.each { |c| c.parent = self }  : []
+    end
+    def output(out, opts = {})
+      @children.each do |n|
+        n.output(out, opts)
+      end
+      out
+    end
+    def altered!; end
+  end
+
+  class BaseEle
+    attr_accessor :raw_string, :parent
+    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
+    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, :raw_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 attributes
+      if raw_attributes
+        raw_attributes.inject({}) do |hsh, (k, v)|
+          hsh[k] = Hpricot.uxs(v)
+          hsh
+        end
+      end
+    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 pathname; self.name end
+    def output(out, opts = {})
+      if empty? and ElementContent[@stag.name] == :EMPTY
+        @stag.output(out, opts.merge(:style => :empty))
+      else
+        @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
+  end
+
+  class STag < BaseEle
+    def initialize(name, attributes=nil)
+      @name = name.to_s
+      @raw_attributes = attributes || {}
+    end
+    alterable :name, :raw_attributes
+    def attributes_as_html
+      if @raw_attributes
+        @raw_attributes.map do |aname, aval|
+          " #{aname}" +
+            (aval ? "=\"#{aval}\"" : "")
+        end.join
+      end
+    end
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          "<#{@name}#{attributes_as_html}" +
+            (opts[:style] == :empty ? " /" : "") +
+            ">"
+        end
+    end
+  end
+
+  class ETag < BaseEle
+    def initialize(qualified_name)
+      @name = qualified_name.to_s
+    end
+    alterable :name
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          "</#{@name}>"
+        end
+    end
+  end
+
+  class BogusETag < ETag
+    def output(out, opts = {}); out << if_output(opts) { '' }; end
+  end
+
+  class Text < BaseEle
+    def initialize(text)
+      @content = text
+    end
+    alterable :content
+    def pathname; "text()" end
+    def to_s
+      Hpricot.uxs(@content)
+    end
+    alias_method :inner_text, :to_s
+    alias_method :to_plain_text, :to_s
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          @content
+        end
+    end
+  end
+
+  class CData < Text
+    alias_method :to_s, :content
+    alias_method :to_plain_text, :content
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          "<![CDATA[#@content]]>"
+        end
+    end
+  end
+
+  class XMLDecl < BaseEle
+    def initialize(version, encoding, standalone)
+      @version, @encoding, @standalone = version, encoding, standalone
+    end
+    alterable :version, :encoding, :standalone
+    def pathname; "xmldecl()" end
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          "<?xml version=\"#{@version}\"" +
+            (@encoding ? " encoding=\"#{encoding}\"" : "") +
+            (@standalone != nil ? " standalone=\"#{standalone ? 'yes' : 'no'}\"" : "") +
+            "?>"
+        end
+    end
+  end
+
+  class DocType < BaseEle
+    def initialize(target, pubid, sysid)
+      @target, @public_id, @system_id = target, pubid, sysid
+    end
+    alterable :target, :public_id, :system_id
+    def pathname; "doctype()" end
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          "<!DOCTYPE #{@target} " +
+            (@public_id ? "PUBLIC \"#{@public_id}\"" : "SYSTEM") +
+            (@system_id ? " #{html_quote(@system_id)}" : "") + ">"
+        end
+    end
+  end
+
+  class ProcIns < BaseEle
+    def initialize(target, content)
+      @target, @content = target, content
+    end
+    def pathname; "procins()" end
+    alterable :target, :content
+    def output(out, opts = {})
+      out << 
+        if_output(opts) do
+          "<?#{@target}" +
+           (@content ? " #{@content}" : "") +
+           "?>"
+        end
+    end
+  end
+
+  class Comment < BaseEle
+    def initialize(content)
+      @content = content
+    end
+    def pathname; "comment()" end
+    alterable :content
+    def output(out, opts = {})
+      out <<
+        if_output(opts) do
+          "<!--#{@content}-->"
+        end
+    end
+  end
+
+  # :startdoc:
+end