spk-html5 0.10.1

data/lib/html5/treebuilders/rexml.rb

@@ -0,0 +1,215 @@
+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
+        attr_reader :namespace
+        def self.rxclass
+          ::REXML::Element
+        end
+
+        def initialize name, namespace=nil
+          super name
+          @namespace = namespace
+        end
+
+        def cloneNode
+          newNode = self.class.new name
+          attributes.each {|name,value| newNode.attributes[name] = value}
+          newNode
+        end
+
+        def attributes= value
+          value.each {|name, v| rxobj.attributes[name] = v}
+        end
+
+        def printTree indent=0
+          tree = "\n|#{' ' * indent}<#{namespace ? namespace.to_s + ' ' : ''}#{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
+
+        # ryansking: not sure why this was here. removing it doesn't cause any tests to fail
+        # 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}" + ([public_id, system_id].any? ? " \"#{public_id}\" \"#{system_id}\"" : "") + ">"
+        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;')
+          if String.method_defined? :encode
+            @rxobj = ::REXML::Text.new(raw.force_encoding('UTF-8'), true, nil, true)
+          else
+            @rxobj = ::REXML::Text.new(raw, true, nil, true)
+          end
+        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,191 @@
+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
+        attr_accessor :namespace
+        def initialize(name, namespace=nil)
+          super(name)
+          @namespace = namespace
+        end
+
+        def to_s
+           "<#{namespace ? namespace.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}" + ([@public_id, @system_id].any? ? " \"#{@public_id}\" \"#{@system_id}\"" : '') + ">"
+        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
+        end
+      end
+
+    end
+  end
+end

data/lib/html5/treewalkers.rb

@@ -0,0 +1,26 @@
+require 'html5/treewalkers/base'
+
+module HTML5
+  module TreeWalkers
+
+    class << self
+      def [](name)
+        case name.to_s.downcase
+        when 'simpletree'
+          require 'html5/treewalkers/simpletree'
+          SimpleTree::TreeWalker
+        when 'rexml'
+          require 'html5/treewalkers/rexml'
+          REXML::TreeWalker
+        when 'hpricot'
+          require 'html5/treewalkers/hpricot'
+          Hpricot::TreeWalker
+        else
+          raise "Unknown TreeWalker #{name}"
+        end
+      end
+
+      alias :get_tree_walker :[]
+    end
+  end
+end

data/lib/html5/treewalkers/base.rb

@@ -0,0 +1,162 @@
+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
+
+    def to_ary
+      a = []
+      each do |i|
+        a << i
+      end
+      a
+    end
+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