Changeset 123

Timestamp:

03/23/2007 11:53:54 (20 months ago)

Author:

why

Message:

• lib/hpricot: messing around with using Hpricot and inline Markaby.
  

Location:

trunk/lib

Files:

• hpricot.rb (modified) (1 diff)
• hpricot/blankslate.rb (added)
• hpricot/builder.rb (added)
• hpricot/elements.rb (modified) (2 diffs)
• hpricot/parse.rb (modified) (3 diffs)
• hpricot/tag.rb (modified) (3 diffs)
• hpricot/tags.rb (added)
• hpricot/traverse.rb (modified) (4 diffs)

trunk/lib/hpricot.rb

@@ -24 +24 @@
 require 'hpricot/inspect'
 require 'hpricot/parse'
+require 'hpricot/builder'

trunk/lib/hpricot/elements.rb

@@ -129 +129 @@
     # Add to the end of the contents inside each element in this list.
     # Pass in an HTML +str+, which is turned into Hpricot elements.
-    def append(str)
-      each { |x| x.inner_html += str }
+    def append(str = nil, &blk)
+      each { |x| x.html(x.children + Hpricot.make(str, &blk)) }
     end
 
     # Add to the start of the contents inside each element in this list.
     # Pass in an HTML +str+, which is turned into Hpricot elements.
-    def prepend(str)
-      each { |x| x.inner_html = str + x.inner_html }
+    def prepend(str = nil, &blk)
+      each { |x| x.html(Hpricot.make(str, &blk) + x.children) }
     end
  
     # Add some HTML just previous to each element in this list.
     # Pass in an HTML +str+, which is turned into Hpricot elements.
-    def before(str)
-      each { |x| x.parent.insert_before Hpricot.make(str), x }
+    def before(str = nil, &blk)
+      each { |x| x.parent.insert_before Hpricot.make(str, &blk), x }
     end
 
     # Just after each element in this list, add some HTML.
     # Pass in an HTML +str+, which is turned into Hpricot elements.
-    def after(str)
-      each { |x| x.parent.insert_after Hpricot.make(str), x }
+    def after(str = nil, &blk)
+      each { |x| x.parent.insert_after Hpricot.make(str, &blk), x }
     end
 
@@ -159 +159 @@
     #
     # This code wraps every link on the page inside a +div.link+ and a +div.link_inner+ nest.
-    def wrap(str)
+    def wrap(str = nil, &blk)
       each do |x|
-        wrap = Hpricot.make(str)
+        wrap = Hpricot.make(str, &blk)
         nest = wrap.detect { |w| w.respond_to? :children }
         unless nest

trunk/lib/hpricot/parse.rb

@@ -1 +1 @@
 require 'hpricot/htmlinfo'
 
-def Hpricot(input, opts = {})
-  Hpricot.parse(input, opts)
+def Hpricot(input = nil, opts = {}, &blk)
+  Hpricot.parse(input, opts, &blk)
 end
 
@@ -12 +12 @@
   # 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
 
@@ -24 +24 @@
   # :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."
-    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].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 }
+    unless input or blk
+      raise ArgumentError, "An Hpricot document must be built from an input source (a String) or a block."
+    end
+
+    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
-
-        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
+      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].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 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
-              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
             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]
-          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]
+          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
-      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) }
+      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
 

trunk/lib/hpricot/tag.rb

@@ -4 +4 @@
   class Doc
     attr_accessor :children
-    def initialize(children)
+    def initialize(children = [])
       @children = children ? children.each { |c| c.parent = self }  : []
     end
@@ -85 +85 @@
   class STag < BaseEle
     def initialize(name, attributes=nil)
-      @name = name.downcase
+      @name = name.to_s.downcase
       @attributes = {}
       if attributes
-        @attributes = attributes.inject({}) { |hsh,(k,v)| hsh[k.downcase] = v; hsh }
+        @attributes = attributes.inject({}) { |hsh,(k,v)| hsh[k.to_s.downcase] = v; hsh }
       end
     end
@@ -112 +112 @@
   class ETag < BaseEle
     def initialize(qualified_name)
-      @name = qualified_name
+      @name = qualified_name.to_s
     end
     alterable :name

trunk/lib/hpricot/traverse.rb

@@ -90 +90 @@
 
     # Adds elements immediately after this element, contained in the +html+ string.
-    def after(html)
-      parent.insert_after(Hpricot.make(html), self)
+    def after(html = nil, &blk)
+      parent.insert_after(Hpricot.make(html, &blk), self)
     end
 
     # Adds elements immediately before this element, contained in the +html+ string.
-    def before(html)
-      parent.insert_before(Hpricot.make(html), self)
+    def before(html = nil, &blk)
+      parent.insert_before(Hpricot.make(html, &blk), self)
     end
 
@@ -102 +102 @@
     # Replace this element and its contents with the nodes contained
     # in the +html+ string.
-    def swap(html)
+    def swap(html = nil, &blk)
       parent.altered!
-      parent.replace_child(self, Hpricot.make(html))
+      parent.replace_child(self, Hpricot.make(html, &blk))
     end
 
@@ -133 +133 @@
 
     # Builds an HTML string from the contents of this node.
-    def inner_html
-      if respond_to? :children
-        children.map { |x| x.output("") }.join
-      end
-    end
+    def html(inner = nil, &blk)
+      if inner or blk
+        altered!
+        case inner
+        when Array
+          self.children = inner
+        else
+          self.children = Hpricot.make(inner, &blk)
+        end
+        reparent self.children
+      else
+        if respond_to? :children
+          children.map { |x| x.output("") }.join
+        end
+      end
+    end
+    alias_method :inner_html, :html
     alias_method :innerHTML, :inner_html
 
@@ -143 +155 @@
     # the HTML contained in string +inner+.
     def inner_html=(inner)
-      altered!
-      case inner
-      when String, IO
-        self.children = Hpricot.parse(inner).children
-      when Array
-        self.children = inner
-      when nil
-        self.children = []
-      end
-      reparent self.children
+      html(inner || [])
     end
     alias_method :innerHTML=, :inner_html=