oga 0.1.1 → 0.1.2

data/ext/ragel/base_lexer.rl

@@ -292,6 +292,14 @@
     allowed_text   = any* -- terminate_text;
 
     text := |*
+        # Input such as just "</" or "<?". This rule takes precedence over the
+        # rules below, but only if those don't match.
+        terminate_text => {
+            callback("on_text", data, encoding, ts, te);
+
+            fnext main;
+        };
+
         # Text followed by a special tag, such as "foo<!--"
         allowed_text @{ mark = p; } terminate_text => {
             callback("on_text", data, encoding, ts, mark);

data/lib/oga.rb

@@ -1,3 +1,5 @@
+gem 'racc'
+
 require 'ast'
 require 'set'
 require 'stringio'
@@ -9,7 +11,6 @@ require_relative 'oga/oga'
 # Oga::XML namespace.
 require_relative 'oga/xml/lexer'
 require_relative 'oga/xml/parser'
-require_relative 'oga/xml/pull_parser'
 
 require_relative 'liboga'
 
@@ -19,6 +20,7 @@ if RUBY_PLATFORM == 'java'
 end
 #:nocov:
 
+require_relative 'oga/xml/html_void_elements'
 require_relative 'oga/xml/querying'
 require_relative 'oga/xml/traversal'
 require_relative 'oga/xml/node'
@@ -35,7 +37,11 @@ require_relative 'oga/xml/attribute'
 require_relative 'oga/xml/element'
 require_relative 'oga/xml/node_set'
 
+require_relative 'oga/xml/sax_parser'
+require_relative 'oga/xml/pull_parser'
+
 require_relative 'oga/html/parser'
+require_relative 'oga/html/sax_parser'
 
 require_relative 'oga/xpath/node'
 require_relative 'oga/xpath/lexer'

data/lib/oga/html/sax_parser.rb

@@ -0,0 +1,18 @@
+module Oga
+  module HTML
+    ##
+    # SAX parser for HTML documents. See the documentation of
+    # {Oga::XML::SaxParser} for more information.
+    #
+    class SaxParser < XML::SaxParser
+      ##
+      # @see [Oga::XML::SaxParser#initialize]
+      #
+      def initialize(handler, data, options = {})
+        options = options.merge(:html => true)
+
+        super(handler, data, options)
+      end
+    end # SaxParser
+  end # HTML
+end # Oga

data/lib/oga/oga.rb

@@ -24,4 +24,34 @@ module Oga
   def self.parse_html(html)
     return HTML::Parser.new(html).parse
   end
+
+  ##
+  # Parses the given XML document using the SAX parser.
+  #
+  # @example
+  #  handler = SomeSaxHandler.new
+  #
+  #  Oga.sax_parse_html(handler, '<root>Hello</root>')
+  #
+  # @param [Object] handler The SAX handler for the parser.
+  # @param [String|IO] xml The XML to parse.
+  #
+  def self.sax_parse_xml(handler, xml)
+    XML::SaxParser.new(handler, xml).parse
+  end
+
+  ##
+  # Parses the given HTML document using the SAX parser.
+  #
+  # @example
+  #  handler = SomeSaxHandler.new
+  #
+  #  Oga.sax_parse_html(handler, '<script>foo()</script>')
+  #
+  # @param [Object] handler The SAX handler for the parser.
+  # @param [String|IO] html The HTML to parse.
+  #
+  def self.sax_parse_html(handler, html)
+    HTML::SaxParser.new(handler, html).parse
+  end
 end # Oga

data/lib/oga/version.rb

@@ -1,3 +1,3 @@
 module Oga
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end # Oga

data/lib/oga/xml/cdata.rb

@@ -12,13 +12,6 @@ module Oga
       def to_xml
         return "<![CDATA[#{text}]]>"
       end
-
-      ##
-      # @return [Symbol]
-      #
-      def node_type
-        return :cdata
-      end
     end # Cdata
   end # XML
 end # Oga

data/lib/oga/xml/comment.rb

@@ -12,13 +12,6 @@ module Oga
       def to_xml
         return "<!--#{text}-->"
       end
-
-      ##
-      # @return [Symbol]
-      #
-      def node_type
-        return :comment
-      end
     end # Comment
   end # XML
 end # Oga

data/lib/oga/xml/doctype.rb

@@ -79,13 +79,6 @@ module Oga
 
         return "Doctype(#{segments.join(' ')})"
       end
-
-      ##
-      # @return [Symbol]
-      #
-      def node_type
-        return :doctype
-      end
     end # Doctype
   end # XML
 end # Oga

data/lib/oga/xml/document.rb

@@ -12,11 +12,15 @@ module Oga
     #  The XML declaration of the document.
     #  @return [Oga::XML::XmlDeclaration]
     #
+    # @!attribute [rw] type
+    #  The document type, either `:xml` or `:html`.
+    #  @return [Symbol]
+    #
     class Document
       include Querying
       include Traversal
 
-      attr_accessor :doctype, :xml_declaration
+      attr_accessor :doctype, :xml_declaration, :type
 
       ##
       # @param [Hash] options
@@ -24,10 +28,12 @@ module Oga
       # @option options [Oga::XML::NodeSet] :children
       # @option options [Oga::XML::Doctype] :doctype
       # @option options [Oga::XML::XmlDeclaration] :xml_declaration
+      # @option options [Symbol] :type
       #
       def initialize(options = {})
         @doctype         = options[:doctype]
         @xml_declaration = options[:xml_declaration]
+        @type            = options[:type] || :xml
 
         self.children = options[:children] if options[:children]
       end

data/lib/oga/xml/element.rb

@@ -144,7 +144,12 @@ module Oga
       # @return [Oga::XML::Namespace]
       #
       def namespace
-        return @namespace ||= available_namespaces[namespace_name]
+        unless @namespace
+          available  = available_namespaces
+          @namespace = available[namespace_name] || available[XMLNS_PREFIX]
+        end
+
+        return @namespace
       end
 
       ##
@@ -206,7 +211,12 @@ module Oga
       # @return [String]
       #
       def to_xml
-        ns    = namespace ? "#{namespace}:" : ''
+        if namespace_name
+          full_name = "#{namespace_name}:#{name}"
+        else
+          full_name = name
+        end
+
         body  = children.map(&:to_xml).join('')
         attrs = ''
 
@@ -214,7 +224,11 @@ module Oga
           attrs << " #{attr.to_xml}"
         end
 
-        return "<#{ns}#{name}#{attrs}>#{body}</#{ns}#{name}>"
+        if self_closing?
+          return "<#{full_name}#{attrs} />"
+        else
+          return "<#{full_name}#{attrs}>#{body}</#{full_name}>"
+        end
       end
 
       ##
@@ -236,13 +250,6 @@ module Oga
         return "Element(#{segments.join(' ')})"
       end
 
-      ##
-      # @return [Symbol]
-      #
-      def node_type
-        return :element
-      end
-
       ##
       # Registers a new namespace for the current element and its child
       # elements.
@@ -270,13 +277,33 @@ module Oga
         node   = parent
 
         while node && node.respond_to?(:namespaces)
-          merged = merged.merge(node.namespaces)
-          node   = node.parent
+          node.namespaces.each do |prefix, ns|
+            merged[prefix] = ns unless merged[prefix]
+          end
+
+          node = node.parent
         end
 
         return merged
       end
 
+      ##
+      # Returns `true` if the element is a self-closing element.
+      #
+      # @return [TrueClass|FalseClass]
+      #
+      def self_closing?
+        self_closing = children.empty?
+        root         = root_node
+
+        if root.is_a?(Document) and root.type == :html \
+        and !HTML_VOID_ELEMENTS.include?(name)
+          self_closing = false
+        end
+
+        return self_closing
+      end
+
       private
 
       ##
@@ -284,14 +311,12 @@ module Oga
       # has been registered the corresponding attribute is removed.
       #
       def register_namespaces_from_attributes
-        self.attributes = attributes.reject do |attr|
+        attributes.each do |attr|
           # We're using `namespace_name` opposed to `namespace.name` as "xmlns"
           # is not a registered namespace.
-          remove = attr.namespace_name && attr.namespace_name == XMLNS_PREFIX
-
-          register_namespace(attr.name, attr.value) if remove
-
-          remove
+          if attr.name == XMLNS_PREFIX or attr.namespace_name == XMLNS_PREFIX
+            register_namespace(attr.name, attr.value)
+          end
         end
       end
 

data/lib/oga/xml/html_void_elements.rb

@@ -0,0 +1,28 @@
+module Oga
+  module XML
+    ##
+    # Names of the HTML void elements that should be handled when HTML lexing
+    # is enabled.
+    #
+    # @return [Set]
+    #
+    HTML_VOID_ELEMENTS = Set.new([
+      'area',
+      'base',
+      'br',
+      'col',
+      'command',
+      'embed',
+      'hr',
+      'img',
+      'input',
+      'keygen',
+      'link',
+      'meta',
+      'param',
+      'source',
+      'track',
+      'wbr'
+    ])
+  end # XML
+end # Oga

data/lib/oga/xml/lexer.rb

@@ -40,31 +40,6 @@ module Oga
     class Lexer
       attr_reader :html
 
-      ##
-      # Names of the HTML void elements that should be handled when HTML lexing
-      # is enabled.
-      #
-      # @return [Set]
-      #
-      HTML_VOID_ELEMENTS = Set.new([
-        'area',
-        'base',
-        'br',
-        'col',
-        'command',
-        'embed',
-        'hr',
-        'img',
-        'input',
-        'keygen',
-        'link',
-        'meta',
-        'param',
-        'source',
-        'track',
-        'wbr'
-      ])
-
       ##
       # @param [String|IO] data The data to lex. This can either be a String or
       #  an IO instance.
@@ -347,7 +322,7 @@ module Oga
       # Called on the closing `>` of the open tag of an element.
       #
       def on_element_open_end
-        if html? and HTML_VOID_ELEMENTS.include?(current_element)
+        if html? and HTML_VOID_ELEMENTS.include?(current_element.downcase)
           add_token(:T_ELEM_END)
           @elements.pop
         end

data/lib/oga/xml/node.rb

@@ -163,13 +163,6 @@ module Oga
 
         node_set.insert(index, other)
       end
-
-      ##
-      # @return [Symbol]
-      #
-      def node_type
-        return :node
-      end
     end # Element
   end # XML
 end # Oga

data/lib/oga/xml/parser.rb

@@ -9,6 +9,35 @@ module Oga
   module XML
     class Parser < Racc::Parser
 
+  ##
+  # Hash mapping token types and dedicated error labels.
+  #
+  # @return [Hash]
+  #
+  TOKEN_ERROR_MAPPING = {
+    'T_STRING'         => 'string',
+    'T_TEXT'           => 'text',
+    'T_DOCTYPE_START'  => 'doctype start',
+    'T_DOCTYPE_END'    => 'doctype closing tag',
+    'T_DOCTYPE_TYPE'   => 'doctype type',
+    'T_DOCTYPE_NAME'   => 'doctype name',
+    'T_DOCTYPE_INLINE' => 'inline doctype rules',
+    'T_CDATA'          => 'CDATA',
+    'T_COMMENT'        => 'comment',
+    'T_ELEM_START'     => 'element start',
+    'T_ELEM_NAME'      => 'element name',
+    'T_ELEM_NS'        => 'element namespace',
+    'T_ELEM_END'       => 'element closing tag',
+    'T_ATTR'           => 'attribute',
+    'T_ATTR_NS'        => 'attribute namespace',
+    'T_XML_DECL_START' => 'XML declaration start',
+    'T_XML_DECL_END'   => 'XML declaration end',
+    'T_PROC_INS_START' => 'processing-instruction start',
+    'T_PROC_INS_NAME'  => 'processing-instruction name',
+    'T_PROC_INS_END'   => 'processing-instruction closing tag',
+    '$end'             => 'end of input'
+  }
+
   ##
   # @param [String|IO] data The input to parse.
   # @param [Hash] options
@@ -53,6 +82,7 @@ module Oga
   #
   def on_error(type, value, stack)
     name        = token_to_str(type)
+    name        = TOKEN_ERROR_MAPPING[name] || name
     index       = @line - 1
     index_range = (index - 5)..(index + 5)
     code        = ''
@@ -84,7 +114,7 @@ module Oga
     end
 
     raise Racc::ParseError, <<-EOF.strip
-Unexpected #{name} with value #{value.inspect} on line #{@line}:
+Unexpected #{name} on line #{@line}:
 
 #{code}
     EOF
@@ -112,7 +142,9 @@ Unexpected #{name} with value #{value.inspect} on line #{@line}:
   # @return [Oga::XML::Document]
   #
   def on_document(children = [])
-    document = Document.new
+    document = Document.new(
+      :type => @lexer.html ? :html : :xml
+    )
 
     children.each do |child|
       if child.is_a?(Doctype)

data/lib/oga/xml/pull_parser.rb

@@ -50,6 +50,21 @@ module Oga
         :on_proc_ins
       ]
 
+      ##
+      # Returns the shorthands that can be used for various node classes.
+      #
+      # @return [Hash]
+      #
+      NODE_SHORTHANDS = {
+        :text            => XML::Text,
+        :node            => XML::Node,
+        :cdata           => XML::Cdata,
+        :element         => XML::Element,
+        :doctype         => XML::Doctype,
+        :comment         => XML::Comment,
+        :xml_declaration => XML::XmlDeclaration
+      }
+
       ##
       # @see Oga::XML::Parser#reset
       #
@@ -89,8 +104,7 @@ module Oga
       # Instead of this:
       #
       #     parser.parse do |node|
-      #       if node.node_type == :text \
-      #       and parser.nesting == %w{people person name}
+      #       if node.is_a?(Oga::XML::Text) and parser.nesting == %w{people person name}
       #         puts node.text
       #       end
       #     end
@@ -113,7 +127,7 @@ module Oga
       # @param [Array] nesting The element name nesting to act upon.
       #
       def on(type, nesting = [])
-        if node.node_type == type
+        if node.is_a?(NODE_SHORTHANDS[type])
           if nesting.empty? or nesting == self.nesting
             yield
           end