html5 0.1.0

data/lib/html5/treebuilders/rexml.rb

@@ -0,0 +1,208 @@
+require 'html5/treebuilders/base'
+require 'rexml/document'
+require 'forwardable'
+
+module HTML5
+  module TreeBuilders
+    module REXML
+
+      class Node < Base::Node
+        extend Forwardable
+        def_delegators :@rxobj, :name, :attributes
+        attr_accessor :rxobj
+
+        def initialize name
+          super name
+          @rxobj = self.class.rxclass.new name
+        end
+
+        def appendChild node
+          if node.kind_of?(TextNode) && childNodes.length > 0 && childNodes.last.kind_of?(TextNode)
+            childNodes.last.rxobj.value = childNodes.last.rxobj.to_s + node.rxobj.to_s
+            childNodes.last.rxobj.raw = true
+          else
+            childNodes.push node
+            rxobj.add node.rxobj
+          end
+          node.parent = self
+        end
+
+        def removeChild node
+           childNodes.delete node
+           rxobj.delete node.rxobj
+           node.parent = nil
+        end
+
+        def insertText data, before=nil
+          if before
+            insertBefore TextNode.new(data), before
+          else
+            appendChild TextNode.new(data)
+          end
+        end
+
+        def insertBefore node, refNode
+          index = childNodes.index(refNode)
+          if node.kind_of?(TextNode) and index > 0 && childNodes[index-1].kind_of?(TextNode)
+            childNodes[index-1].rxobj.value = childNodes[index-1].rxobj.to_s + node.rxobj.to_s
+            childNodes[index-1].rxobj.raw = true
+          else
+            childNodes.insert index, node
+            refNode.rxobj.parent.insert_before(refNode.rxobj,node.rxobj)
+          end
+        end
+
+        def hasContent
+          (childNodes.length > 0)
+        end
+      end
+
+      class Element < Node
+        def self.rxclass
+          ::REXML::Element
+        end
+
+        def initialize name
+          super name
+        end
+
+        def cloneNode
+          newNode = self.class.new name
+          attributes.each {|name,value| newNode.attributes[name] = value}
+          newNode
+        end
+
+        def attributes= value
+          value.each {|name, value| rxobj.attributes[name] = value}
+        end
+
+        def printTree indent=0
+          tree = "\n|#{' ' * indent}<#{name}>"
+          indent += 2
+          for name, value in attributes
+            next if name == 'xmlns'
+            tree += "\n|#{' ' * indent}#{name}=\"#{value}\""
+          end
+          for child in childNodes
+            tree += child.printTree(indent)
+          end
+          tree
+        end
+      end
+
+      class Document < Node
+        def self.rxclass
+          ::REXML::Document
+        end
+
+        def initialize
+          super nil
+        end
+
+        def appendChild node
+           if node.kind_of? Element and node.name == 'html'
+             node.rxobj.add_namespace('http://www.w3.org/1999/xhtml')
+           end
+           super node
+        end
+
+        def printTree indent=0
+          tree = "#document"
+          for child in childNodes
+            tree += child.printTree(indent + 2)
+          end
+          return tree
+        end
+      end
+
+      class DocumentType < Node
+        def_delegator :@rxobj, :public, :public_id
+
+        def_delegator :@rxobj, :system, :system_id
+
+        def self.rxclass
+          ::REXML::DocType
+        end
+
+        def initialize name, public_id, system_id
+            super(name)
+            if public_id
+              @rxobj = ::REXML::DocType.new [name, ::REXML::DocType::PUBLIC, public_id, system_id]
+            elsif system_id
+              @rxobj = ::REXML::DocType.new [name, ::REXML::DocType::SYSTEM, nil, system_id]
+            else
+              @rxobj = ::REXML::DocType.new name
+            end
+        end
+
+        def printTree indent=0
+          "\n|#{' ' * indent}<!DOCTYPE #{name}>"
+        end
+      end
+
+      class DocumentFragment < Element
+        def initialize
+          super nil
+        end
+
+        def printTree indent=0
+          tree = ""
+          for child in childNodes
+            tree += child.printTree(indent+2)
+          end
+          return tree
+        end
+      end
+
+      class TextNode < Node
+        def initialize data
+          raw = data.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+          @rxobj = ::REXML::Text.new(raw, true, nil, true)
+        end
+
+        def printTree indent=0
+          "\n|#{' ' * indent}\"#{rxobj.value}\""
+        end
+      end
+
+      class CommentNode < Node
+        def self.rxclass
+          ::REXML::Comment
+        end
+
+        def printTree indent=0
+          "\n|#{' ' * indent}<!-- #{rxobj.string} -->"
+        end
+      end
+
+      class TreeBuilder < Base::TreeBuilder
+        def initialize
+          @documentClass = Document
+          @doctypeClass  = DocumentType
+          @elementClass  = Element
+          @commentClass  = CommentNode
+          @fragmentClass = DocumentFragment
+        end
+
+        def insertDoctype(name, public_id, system_id)
+          doctype = @doctypeClass.new(name, public_id, system_id)
+          @document.appendChild(doctype)
+        end
+
+        def testSerializer node
+          node.printTree
+        end
+
+        def get_document
+          @document.rxobj
+        end
+
+        def get_fragment
+          @document = super
+          return @document.rxobj.children
+        end
+      end
+
+    end
+  end
+end

data/lib/html5/treebuilders/simpletree.rb

@@ -0,0 +1,185 @@
+require 'html5/treebuilders/base'
+
+module HTML5
+  module TreeBuilders
+    module SimpleTree
+
+      class Node < Base::Node
+        # Node representing an item in the tree.
+        # name - The tag name associated with the node
+        attr_accessor :name
+
+        # The value of the current node (applies to text nodes and 
+        # comments
+        attr_accessor :value
+
+        # a dict holding name, value pairs for attributes of the node
+        attr_accessor :attributes
+
+        def initialize name
+          super
+          @name       = name
+          @value      = nil
+          @attributes = {}
+        end
+
+        def appendChild node
+          if node.kind_of? TextNode and 
+            childNodes.length > 0 and childNodes.last.kind_of? TextNode
+            childNodes.last.value += node.value
+          else
+            childNodes << node
+          end
+          node.parent = self
+        end
+
+        def removeChild node
+           childNodes.delete node
+           node.parent = nil
+        end
+
+        def cloneNode
+          newNode = self.class.new name
+          attributes.each {|name,value| newNode.attributes[name] = value}
+          newNode.value = value
+          newNode
+        end
+
+        def insertText data, before=nil
+          if before
+            insertBefore TextNode.new(data), before
+          else
+            appendChild TextNode.new(data)
+          end
+        end
+
+        def insertBefore node, refNode
+          index = childNodes.index(refNode)
+          if node.kind_of?(TextNode) && index > 0 && childNodes[index-1].kind_of?(TextNode)
+            childNodes[index-1].value += node.value
+          else
+            childNodes.insert index, node
+          end
+        end
+
+        def printTree indent=0
+          tree = "\n|%s%s" % [' '* indent, self.to_s]
+          for child in childNodes
+            tree += child.printTree(indent + 2)
+          end
+          return tree
+        end
+
+        def hasContent
+          childNodes.length > 0
+        end
+      end
+
+      class Element < Node
+        def to_s
+           "<#{name}>"
+        end
+
+        def printTree indent=0
+          tree = "\n|%s%s" % [' '* indent, self.to_s]
+          indent += 2
+          for name, value in attributes
+            tree += "\n|%s%s=\"%s\"" % [' ' * indent, name, value]
+          end
+          for child in childNodes
+            tree += child.printTree(indent)
+          end
+          tree
+        end
+      end
+
+      class Document < Node
+        def to_s
+           "#document"
+        end
+
+        def initialize
+          super nil
+        end
+
+        def printTree indent=0
+          tree = to_s
+          for child in childNodes
+            tree += child.printTree(indent + 2)
+          end
+          tree
+        end
+      end
+
+      class DocumentType < Node
+        attr_accessor :public_id, :system_id
+
+        def to_s
+          "<!DOCTYPE #{name}>"
+        end
+
+        def initialize name
+          super name
+          @public_id = nil
+          @system_id = nil
+        end
+      end
+
+      class DocumentFragment < Element
+        def initialize
+          super nil
+        end
+
+        def printTree indent=0
+          tree = ""
+          for child in childNodes
+            tree += child.printTree(indent+2)
+          end
+          return tree
+        end
+      end
+
+      class TextNode < Node
+        def initialize value
+          super nil
+          @value = value
+        end
+
+        def to_s
+           '"%s"' % value
+        end
+      end
+
+      class CommentNode < Node
+        def initialize value
+          super nil
+          @value = value
+        end
+
+        def to_s
+          "<!-- %s -->" % value
+        end
+      end
+
+      class TreeBuilder < Base::TreeBuilder
+        def initialize
+          @documentClass = Document
+          @doctypeClass  = DocumentType
+          @elementClass  = Element
+          @commentClass  = CommentNode
+          @fragmentClass = DocumentFragment
+        end
+
+        def testSerializer node
+          node.printTree
+        end
+
+        def get_fragment
+          @document = super
+          @document.childNodes
+        end
+      end
+
+    end
+  end
+end

data/lib/html5/treebuilders.rb

@@ -0,0 +1,24 @@
+module HTML5
+  module TreeBuilders
+
+    class << self
+      def [](name)
+        case name.to_s.downcase
+        when 'simpletree' then
+          require 'html5/treebuilders/simpletree'
+          SimpleTree::TreeBuilder
+        when 'rexml' then
+          require 'html5/treebuilders/rexml'
+          REXML::TreeBuilder
+        when 'hpricot' then
+          require 'html5/treebuilders/hpricot'
+          Hpricot::TreeBuilder
+        else
+          raise "Unknown TreeBuilder #{name}"
+        end
+      end
+
+      alias :get_tree_builder :[]
+    end
+  end
+end

data/lib/html5/treewalkers/base.rb

@@ -0,0 +1,154 @@
+require 'html5/constants'
+module HTML5
+module TreeWalkers
+
+module TokenConstructor
+  def error(msg)
+    {:type => "SerializeError", :data => msg}
+  end
+
+  def normalize_attrs(attrs)
+    attrs.to_a
+  end
+
+  def empty_tag(name, attrs, has_children=false)
+    error(_("Void element has children")) if has_children
+    {:type => :EmptyTag, :name => name, :data => normalize_attrs(attrs)}
+  end
+
+  def start_tag(name, attrs)
+    {:type => :StartTag, :name => name, :data => normalize_attrs(attrs)}
+  end
+
+  def end_tag(name)
+    {: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)
+    {:type => :Comment, :data => data}
+  end
+
+  def doctype(name, public_id, system_id, correct=nil)
+    {:type => :Doctype, :name => name, :public_id => public_id, :system_id => system_id, :correct => correct}
+  end
+
+  def unknown(nodeType)
+    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
+    current_node = @tree
+    while current_node != nil
+      details = node_details(current_node)
+      has_children = false
+
+      case details.shift
+      when :DOCTYPE
+        yield doctype(*details)
+
+      when :TEXT
+        text(*details) {|token| yield token}
+
+      when :ELEMENT
+        name, attributes, has_children = details
+        if VOID_ELEMENTS.include?(name)
+          yield empty_tag(name, attributes.to_a, has_children)
+          has_children = false
+        else
+          yield start_tag(name, attributes.to_a)
+        end
+
+      when :COMMENT
+        yield comment(details[0])
+
+      when :DOCUMENT, :DOCUMENT_FRAGMENT
+        has_children = true
+
+      when nil
+        # ignore (REXML::XMLDecl is an example)
+
+      else
+        yield unknown(details[0])
+      end
+
+      first_child = has_children ? first_child(current_node) : nil
+      if first_child != nil
+        current_node = first_child
+      else
+        while current_node != nil
+          details = node_details(current_node)
+          if details.shift == :ELEMENT
+            name, attributes, has_children = details
+            yield end_tag(name) if !VOID_ELEMENTS.include?(name)
+          end
+
+          if @tree == current_node
+            current_node = nil
+          else
+            next_sibling = next_sibling(current_node)
+            if next_sibling != nil
+              current_node = next_sibling
+              break
+            end
+
+            current_node = parent(current_node)
+          end
+        end
+      end
+    end
+  end
+end
+
+end
+end

data/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.content]
+          when ::Hpricot::Comment
+            [:COMMENT, node.content]
+          when ::Hpricot::Doc
+            [:DOCUMENT]
+          when ::Hpricot::DocType
+            [:DOCTYPE, node.target, node.public_id, node.system_id]
+          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

data/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, node.public, node.system]
+          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

data/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, node.public_id, node.system_id)
+
+          when TextNode
+            text(node.value) {|token| yield token}
+
+          when Element
+            if VOID_ELEMENTS.include?(node.name)
+              yield empty_tag(node.name, node.attributes, node.hasContent())
+            else
+              yield start_tag(node.name, node.attributes)
+              for child in node.childNodes
+                walk(child) {|token| yield token}
+              end
+              yield end_tag(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