Sync with latest HTML5lib and latest Maruku

vendor/plugins/HTML5lib/lib/html5/treewalkers/base.rb

@@ -0,0 +1,156 @@
+require 'html5/constants'
+module HTML5
+module TreeWalkers
+
+module TokenConstructor
+    def error(msg)
+        return {:type => "SerializeError", :data => msg}
+    end
+
+    def normalizeAttrs(attrs)
+        attrs.to_a
+    end
+
+    def emptyTag(name, attrs, hasChildren=false)
+        error(_("Void element has children")) if hasChildren
+        return({:type => :EmptyTag, :name => name, \
+                :data => normalizeAttrs(attrs)})
+    end
+
+    def startTag(name, attrs)
+        return {:type => :StartTag, :name => name, \
+                 :data => normalizeAttrs(attrs)}
+    end
+
+    def endTag(name)
+        return {:type => :EndTag, :name => name, :data => []}
+    end
+
+    def text(data)
+        if data =~ /\A([#{SPACE_CHARACTERS.join('')}]+)/m
+          yield({:type => :SpaceCharacters, :data => $1})
+          data = data[$1.length .. -1]
+          return if data.empty?
+        end
+
+        if data =~ /([#{SPACE_CHARACTERS.join('')}]+)\Z/m
+          yield({:type => :Characters, :data => data[0 ... -$1.length]})
+          yield({:type => :SpaceCharacters, :data => $1})
+        else
+          yield({:type => :Characters, :data => data})
+        end
+    end
+
+    def comment(data)
+        return {:type => :Comment, :data => data}
+    end
+
+    def doctype(name)
+        return {:type => :Doctype, :name => name, :data => name.upcase() == "HTML"}
+    end
+
+    def unknown(nodeType)
+        return error(_("Unknown node type: ") + nodeType.to_s)
+    end
+
+    def _(str)
+      str
+    end
+end
+
+class Base
+    include TokenConstructor
+
+    def initialize(tree)
+        @tree = tree
+    end
+
+    def each
+        raise NotImplementedError
+    end
+
+    alias walk each
+end
+
+class NonRecursiveTreeWalker < TreeWalkers::Base
+    def node_details(node)
+        raise NotImplementedError
+    end
+
+    def first_child(node)
+        raise NotImplementedError
+    end
+
+    def next_sibling(node)
+        raise NotImplementedError
+    end
+
+    def parent(node)
+        raise NotImplementedError
+    end
+
+    def each
+        currentNode = @tree
+        while currentNode != nil
+            details = node_details(currentNode)
+            hasChildren = false
+
+            case details.shift
+            when :DOCTYPE
+                yield doctype(*details)
+
+            when :TEXT
+                text(*details) {|token| yield token}
+
+            when :ELEMENT
+                name, attributes, hasChildren = details
+                if VOID_ELEMENTS.include?(name)
+                    yield emptyTag(name, attributes.to_a, hasChildren)
+                    hasChildren = false
+                else
+                    yield startTag(name, attributes.to_a)
+                end
+
+            when :COMMENT
+                yield comment(details[0])
+
+            when :DOCUMENT, :DOCUMENT_FRAGMENT
+                hasChildren = true
+
+            when nil
+                # ignore (REXML::XMLDecl is an example)
+
+            else
+                yield unknown(details[0])
+            end
+
+            firstChild = hasChildren ? first_child(currentNode) : nil
+            if firstChild != nil
+                currentNode = firstChild
+            else
+                while currentNode != nil
+                    details = node_details(currentNode)
+                    if details.shift == :ELEMENT
+                        name, attributes, hasChildren = details
+                        yield endTag(name) if !VOID_ELEMENTS.include?(name)
+                    end
+
+                    if @tree == currentNode
+                        currentNode = nil
+                    else
+                        nextSibling = next_sibling(currentNode)
+                        if nextSibling != nil
+                            currentNode = nextSibling
+                            break
+                        end
+
+                        currentNode = parent(currentNode)
+                    end
+                end
+            end
+        end
+    end
+end
+
+end
+end

vendor/plugins/HTML5lib/lib/html5/treewalkers/hpricot.rb

@@ -0,0 +1,48 @@
+require 'html5/treewalkers/base'
+require 'rexml/document'
+
+module HTML5
+  module TreeWalkers
+    module Hpricot
+      class TreeWalker < HTML5::TreeWalkers::NonRecursiveTreeWalker
+
+        def node_details(node)
+          case node
+          when ::Hpricot::Elem
+            if node.name.empty?
+              [:DOCUMENT_FRAGMENT]
+            else
+              [:ELEMENT, node.name,
+                node.attributes.map {|name,value| [name,value]},
+                !node.empty?]
+            end
+          when ::Hpricot::Text
+            [:TEXT, node.to_plain_text]
+          when ::Hpricot::Comment
+            [:COMMENT, node.content]
+          when ::Hpricot::Doc
+            [:DOCUMENT]
+          when ::Hpricot::DocType
+            [:DOCTYPE, node.target]
+          when ::Hpricot::XMLDecl
+            [nil]
+          else
+            [:UNKNOWN, node.class.inspect]
+          end
+        end
+
+        def first_child(node)
+          node.children.first
+        end
+
+        def next_sibling(node)
+          node.next_node
+        end
+
+        def parent(node)
+          node.parent
+        end
+      end
+    end
+  end
+end

vendor/plugins/HTML5lib/lib/html5/treewalkers/rexml.rb

@@ -0,0 +1,48 @@
+require 'html5/treewalkers/base'
+require 'rexml/document'
+
+module HTML5
+  module TreeWalkers
+    module REXML
+      class TreeWalker < HTML5::TreeWalkers::NonRecursiveTreeWalker
+
+        def node_details(node)
+          case node
+          when ::REXML::Document
+            [:DOCUMENT]
+          when ::REXML::Element
+            if !node.name
+              [:DOCUMENT_FRAGMENT]
+            else
+              [:ELEMENT, node.name,
+                node.attributes.map {|name,value| [name,value]},
+                node.has_elements? || node.has_text?]
+            end
+          when ::REXML::Text
+            [:TEXT, node.value]
+          when ::REXML::Comment
+            [:COMMENT, node.string]
+          when ::REXML::DocType
+            [:DOCTYPE, node.name]
+          when ::REXML::XMLDecl
+            [nil]
+          else
+            [:UNKNOWN, node.class.inspect]
+          end
+        end
+
+        def first_child(node)
+          node.children.first
+        end
+
+        def next_sibling(node)
+          node.next_sibling
+        end
+
+        def parent(node)
+          node.parent
+        end
+      end
+    end
+  end
+end

vendor/plugins/HTML5lib/lib/html5/treewalkers/simpletree.rb

@@ -0,0 +1,48 @@
+require 'html5/treewalkers/base'
+
+module HTML5
+  module TreeWalkers
+    module SimpleTree
+      class TreeWalker < HTML5::TreeWalkers::Base
+        include HTML5::TreeBuilders::SimpleTree
+
+        def walk(node)
+          case node
+          when Document, DocumentFragment
+            return
+
+          when DocumentType
+            yield doctype(node.name)
+
+          when TextNode
+            text(node.value) {|token| yield token}
+
+          when Element
+            if VOID_ELEMENTS.include?(node.name)
+              yield emptyTag(node.name, node.attributes, node.hasContent())
+            else
+              yield startTag(node.name, node.attributes)
+              for child in node.childNodes
+                walk(child) {|token| yield token}
+              end
+              yield endTag(node.name)
+            end
+
+          when CommentNode
+            yield comment(node.value)
+
+          else
+            puts '?'
+            yield unknown(node.class)
+          end
+        end
+
+        def each
+          for child in @tree.childNodes
+            walk(child) {|node| yield node}
+          end
+        end
+      end
+    end
+  end
+end