oga 0.1.1-java → 0.1.2-java

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'
@@ -18,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'
@@ -34,8 +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/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
 
       ##
@@ -263,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
 
       ##
@@ -277,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/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/sax_parser.rb

@@ -0,0 +1,63 @@
+module Oga
+  module XML
+    ##
+    # The SaxParser class provides the basic interface for writing custom SAX
+    # parsers. All callback methods defined in {Oga::XML::Parser} are delegated
+    # to a dedicated handler class.
+    #
+    # To write a custom handler for the SAX parser, create a class that
+    # implements one (or many) of the following callback methods:
+    #
+    # * `on_document`
+    # * `on_doctype`
+    # * `on_cdata`
+    # * `on_comment`
+    # * `on_proc_ins`
+    # * `on_xml_decl`
+    # * `on_text`
+    # * `on_element`
+    # * `on_element_children`
+    # * `after_element`
+    #
+    # For example:
+    #
+    #     class SaxHandler
+    #       def on_element(namespace, name, attrs = {})
+    #         puts name
+    #       end
+    #     end
+    #
+    # You can then use it as following:
+    #
+    #     handler = SaxHandler.new
+    #     parser  = Oga::XML::SaxParser.new(handler, '<foo />')
+    #
+    #     parser.parse
+    #
+    # For information on the callback arguments see the documentation of the
+    # corresponding methods in {Oga::XML::Parser}.
+    #
+    class SaxParser < Parser
+      ##
+      # @param [Object] handler The SAX handler to delegate callbacks to.
+      # @see [Oga::XML::Parser#initialize]
+      #
+      def initialize(handler, *args)
+        @handler = handler
+
+        super(*args)
+      end
+
+      # Delegate all callbacks to the handler object.
+      instance_methods.grep(/^(on_|after_)/).each do |method|
+        eval <<-EOF, nil, __FILE__, __LINE__ + 1
+        def #{method}(*args)
+          @handler.#{method}(*args) if @handler.respond_to?(:#{method})
+
+          return
+        end
+        EOF
+      end
+    end # SaxParser
+  end # XML
+end # Oga

data/lib/oga/xpath/evaluator.rb

@@ -131,7 +131,8 @@ module Oga
           context = XML::NodeSet.new([@document])
         end
 
-        return on_path(ast_node, context)
+        # If the expression is just "/" we'll just return the current context.
+        return ast_node.children.empty? ? context : on_path(ast_node, context)
       end
 
       ##
@@ -1188,7 +1189,7 @@ module Oga
       # This function call returns the substring of the 1st argument that occurs
       # after the string given in the 2nd argument. For example:
       #
-      #     substring-before("2014-08-25", "-")
+      #     substring-after("2014-08-25", "-")
       #
       # This would return "08-25" as it occurs after the first "-".
       #