hpricot 0.5-mswin32 → 0.6-mswin32

data/lib/hpricot/inspect.rb

@@ -60,10 +60,14 @@ module Hpricot
       q.group(1, '<', '>') {
         q.text @name
 
-        if @attributes
-          @attributes.each {|n, t|
+        if @raw_attributes
+          @raw_attributes.each {|n, t|
             q.breakable
-            q.text "#{n}=\"#{t}\""
+            if t
+              q.text "#{n}=\"#{Hpricot.uxs(t)}\""
+            else
+              q.text n
+            end
           }
         end
       }

data/lib/hpricot/parse.rb

@@ -1,7 +1,7 @@
 require 'hpricot/htmlinfo'
 
-def Hpricot(input, opts = {})
-  Hpricot.parse(input, opts)
+def Hpricot(input = nil, opts = {}, &blk)
+  Hpricot.parse(input, opts, &blk)
 end
 
 module Hpricot
@@ -11,8 +11,8 @@ 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))
+  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
@@ -23,125 +23,152 @@ module Hpricot
 
   # :stopdoc:
 
-  def Hpricot.make(input, opts = {})
+  def Hpricot.make(input = nil, opts = {}, &blk)
     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."
+    unless input or blk
+      raise ArgumentError, "An Hpricot document must be built from an input source (a String) or a block."
     end
 
-    if opts[:xhtml_strict]
-      opts[:fixup_tags] = true
-    end
+    conv = opts[:xml] ? :to_s : :downcase
 
-    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].downcase == stack.last[0])
-        token[0] = :text
-        token[1] = token[3] if token[3]
+    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
 
-      case token[0]
-      when :stag
-        case opts[:encoding] when 'utf-8'
-          token.map! { |str| u(str) if str.is_a? String }
+      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
 
-        stagname = token[0] = token[1].downcase
-        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
+        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
-                if trans.to_i > 1
-                  eles = stack.slice!(trans..-1)
-                  stack.last[2] += eles
-                  # puts "** TRANSPLANTED #{stagname} TO #{stack.last[0]}"
+              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
-              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
+            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
-          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]
-          if stagname == etagname
-            matched_elem = stack[i]
-            stack[i][1] += token
-            eles = stack.slice!((i+1)..-1)
-            stack.last[2] += eles
-            break
+        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
-        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
+      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) }
+      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 = {})

data/lib/hpricot/tag.rb

@@ -3,7 +3,7 @@ module Hpricot
 
   class Doc
     attr_accessor :children
-    def initialize(children)
+    def initialize(children = [])
       @children = children ? children.each { |c| c.parent = self }  : []
     end
     def output(out, opts = {})
@@ -49,9 +49,17 @@ module Hpricot
       @children = children ? children.each { |c| c.parent = self }  : []
     end
     def empty?; @children.empty? end
-    [:name, :attributes, :parent, :altered!].each do |m|
+    [: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"
@@ -84,18 +92,15 @@ 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
+      @name = name.to_s
+      @raw_attributes = attributes || {}
     end
-    alterable :name, :attributes
+    alterable :name, :raw_attributes
     def attributes_as_html
-      if @attributes
-        @attributes.map do |aname, aval|
+      if @raw_attributes
+        @raw_attributes.map do |aname, aval|
           " #{aname}" +
-            (aval ? "=#{html_quote(aval)}" : "")
+            (aval ? "=\"#{aval}\"" : "")
         end.join
       end
     end
@@ -111,7 +116,7 @@ module Hpricot
 
   class ETag < BaseEle
     def initialize(qualified_name)
-      @name = qualified_name
+      @name = qualified_name.to_s
     end
     alterable :name
     def output(out, opts = {})
@@ -132,8 +137,11 @@ module Hpricot
     end
     alterable :content
     def pathname; "text()" end
-    alias_method :inner_text, :content
-    alias_method :to_plain_text, :content
+    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
@@ -143,7 +151,7 @@ module Hpricot
   end
 
   class CData < Text
-    alias_method :inner_text, :content
+    alias_method :to_s, :content
     alias_method :to_plain_text, :content
     def output(out, opts = {})
       out <<

data/lib/hpricot/tags.rb

@@ -0,0 +1,164 @@
+module Hpricot
+
+  FORM_TAGS = [ :form, :input, :select, :textarea ]
+  SELF_CLOSING_TAGS = [ :base, :meta, :link, :hr, :br, :param, :img, :area, :input, :col ]
+
+  # Common sets of attributes.
+  AttrCore = [:id, :class, :style, :title]
+  AttrI18n = [:lang, 'xml:lang'.intern, :dir]
+  AttrEvents = [:onclick, :ondblclick, :onmousedown, :onmouseup, :onmouseover, :onmousemove, 
+      :onmouseout, :onkeypress, :onkeydown, :onkeyup]
+  AttrFocus = [:accesskey, :tabindex, :onfocus, :onblur]
+  AttrHAlign = [:align, :char, :charoff]
+  AttrVAlign = [:valign]
+  Attrs = AttrCore + AttrI18n + AttrEvents
+
+  # All the tags and attributes from XHTML 1.0 Strict
+  class XHTMLStrict
+    class << self
+      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
+    end
+    @doctype = ["-//W3C//DTD XHTML 1.0 Strict//EN", "DTD/xhtml1-strict.dtd"]
+    @tagset = {
+      :html => AttrI18n + [:id, :xmlns],
+      :head => AttrI18n + [:id, :profile],
+      :title => AttrI18n + [:id],
+      :base => [:href, :id],
+      :meta => AttrI18n + [:id, :http, :name, :content, :scheme, 'http-equiv'.intern],
+      :link => Attrs + [:charset, :href, :hreflang, :type, :rel, :rev, :media],
+      :style => AttrI18n + [:id, :type, :media, :title, 'xml:space'.intern],
+      :script => [:id, :charset, :type, :src, :defer, 'xml:space'.intern],
+      :noscript => Attrs,
+      :body => Attrs + [:onload, :onunload],
+      :div => Attrs,
+      :p => Attrs,
+      :ul => Attrs,
+      :ol => Attrs,
+      :li => Attrs,
+      :dl => Attrs,
+      :dt => Attrs,
+      :dd => Attrs,
+      :address => Attrs,
+      :hr => Attrs,
+      :pre => Attrs + ['xml:space'.intern],
+      :blockquote => Attrs + [:cite],
+      :ins => Attrs + [:cite, :datetime],
+      :del => Attrs + [:cite, :datetime],
+      :a => Attrs + AttrFocus + [:charset, :type, :name, :href, :hreflang, :rel, :rev, :shape, :coords],
+      :span => Attrs,
+      :bdo => AttrCore + AttrEvents + [:lang, 'xml:lang'.intern, :dir],
+      :br => AttrCore,
+      :em => Attrs,
+      :strong => Attrs,
+      :dfn => Attrs,
+      :code => Attrs,
+      :samp => Attrs,
+      :kbd => Attrs,
+      :var => Attrs,
+      :cite => Attrs,
+      :abbr => Attrs,
+      :acronym => Attrs,
+      :q => Attrs + [:cite],
+      :sub => Attrs,
+      :sup => Attrs,
+      :tt => Attrs,
+      :i => Attrs,
+      :b => Attrs,
+      :big => Attrs,
+      :small => Attrs,
+      :object => Attrs + [:declare, :classid, :codebase, :data, :type, :codetype, :archive, :standby, :height, :width, :usemap, :name, :tabindex],
+      :param => [:id, :name, :value, :valuetype, :type],
+      :img => Attrs + [:src, :alt, :longdesc, :height, :width, :usemap, :ismap],
+      :map => AttrI18n + AttrEvents + [:id, :class, :style, :title, :name],
+      :area => Attrs + AttrFocus + [:shape, :coords, :href, :nohref, :alt],
+      :form => Attrs + [:action, :method, :enctype, :onsubmit, :onreset, :accept, :accept],
+      :label => Attrs + [:for, :accesskey, :onfocus, :onblur],
+      :input => Attrs + AttrFocus + [:type, :name, :value, :checked, :disabled, :readonly, :size, :maxlength, :src, :alt, :usemap, :onselect, :onchange, :accept],
+      :select => Attrs + [:name, :size, :multiple, :disabled, :tabindex, :onfocus, :onblur, :onchange],
+      :optgroup => Attrs + [:disabled, :label],
+      :option => Attrs + [:selected, :disabled, :label, :value],
+      :textarea => Attrs + AttrFocus + [:name, :rows, :cols, :disabled, :readonly, :onselect, :onchange],
+      :fieldset => Attrs,
+      :legend => Attrs + [:accesskey],
+      :button => Attrs + AttrFocus + [:name, :value, :type, :disabled],
+      :table => Attrs + [:summary, :width, :border, :frame, :rules, :cellspacing, :cellpadding],
+      :caption => Attrs,
+      :colgroup => Attrs + AttrHAlign + AttrVAlign + [:span, :width],
+      :col => Attrs + AttrHAlign + AttrVAlign + [:span, :width],
+      :thead => Attrs + AttrHAlign + AttrVAlign,
+      :tfoot => Attrs + AttrHAlign + AttrVAlign,
+      :tbody => Attrs + AttrHAlign + AttrVAlign,
+      :tr => Attrs + AttrHAlign + AttrVAlign,
+      :th => Attrs + AttrHAlign + AttrVAlign + [:abbr, :axis, :headers, :scope, :rowspan, :colspan],
+      :td => Attrs + AttrHAlign + AttrVAlign + [:abbr, :axis, :headers, :scope, :rowspan, :colspan],
+      :h1 => Attrs,
+      :h2 => Attrs,
+      :h3 => Attrs,
+      :h4 => Attrs,
+      :h5 => Attrs,
+      :h6 => Attrs
+    }
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+
+  # Additional tags found in XHTML 1.0 Transitional
+  class XHTMLTransitional
+    class << self
+      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
+    end
+    @doctype = ["-//W3C//DTD XHTML 1.0 Transitional//EN", "DTD/xhtml1-transitional.dtd"]
+    @tagset = XHTMLStrict.tagset.merge \
+      :strike => Attrs,
+      :center => Attrs,
+      :dir => Attrs + [:compact], 
+      :noframes => Attrs,
+      :basefont => [:id, :size, :color, :face], 
+      :u => Attrs,
+      :menu => Attrs + [:compact], 
+      :iframe => AttrCore + [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :scrolling, :align, :height, :width],
+      :font => AttrCore + AttrI18n + [:size, :color, :face],
+      :s => Attrs,
+      :applet => AttrCore + [:codebase, :archive, :code, :object, :alt, :name, :width, :height, :align, :hspace, :vspace],
+      :isindex => AttrCore + AttrI18n + [:prompt]
+
+    # Additional attributes found in XHTML 1.0 Transitional
+    { :script => [:language],
+      :a => [:target],
+      :td => [:bgcolor, :nowrap, :width, :height],
+      :p => [:align],
+      :h5 => [:align],
+      :h3 => [:align],
+      :li => [:type, :value],
+      :div => [:align],
+      :pre => [:width],
+      :body => [:background, :bgcolor, :text, :link, :vlink, :alink],
+      :ol => [:type, :compact, :start],
+      :h4 => [:align],
+      :h2 => [:align],
+      :object => [:align, :border, :hspace, :vspace],
+      :img => [:name, :align, :border, :hspace, :vspace],
+      :link => [:target],
+      :legend => [:align],
+      :dl => [:compact],
+      :input => [:align],
+      :h6 => [:align],
+      :hr => [:align, :noshade, :size, :width],
+      :base => [:target],
+      :ul => [:type, :compact],
+      :br => [:clear],
+      :form => [:name, :target],
+      :area => [:target],
+      :h1 => [:align]
+    }.each do |k, v|
+        @tagset[k] += v
+    end
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+
+end