oga 0.2.3 → 0.3.0

data/lib/oga/lru.rb

@@ -0,0 +1,158 @@
+module Oga
+  ##
+  # Thread-safe LRU cache using a Hash as the underlying storage engine.
+  # Whenever the size of the cache exceeds the given limit the oldest keys are
+  # removed (base on insert order).
+  #
+  # This class uses its own list of keys (as returned by {LRU#keys}) instead of
+  # relying on `Hash#keys` as the latter allocates a new Array upon every call.
+  #
+  # This class doesn't use MonitorMixin due to the extra overhead it adds
+  # compared to using a Mutex directly.
+  #
+  # Example usage:
+  #
+  #     cache = LRU.new(3)
+  #
+  #     cache[:a] = 10
+  #     cache[:b] = 20
+  #     cache[:c] = 30
+  #     cache[:d] = 40
+  #
+  #     cache.keys # => [:b, :c, :d]
+  #
+  class LRU
+    ##
+    # @param [Fixnum] maximum
+    #
+    def initialize(maximum = 1024)
+      @maximum = maximum
+      @cache   = {}
+      @keys    = []
+      @mutex   = Mutex.new
+      @owner   = Thread.current
+    end
+
+    ##
+    # @param [Fixnum] value
+    #
+    def maximum=(value)
+      synchronize do
+        @maximum = value
+
+        resize
+      end
+    end
+
+    ##
+    # @return [Fixnum]
+    #
+    def maximum
+      return synchronize { @maximum }
+    end
+
+    ##
+    # Returns the value of the key.
+    #
+    # @param [Mixed] key
+    # @return [Mixed]
+    #
+    def [](key)
+      return synchronize { @cache[key] }
+    end
+
+    ##
+    # Sets the key and its value. Old keys are discarded if the LRU size exceeds
+    # the limit.
+    #
+    # @param [Mixed] key
+    # @param [Mixed] value
+    #
+    def []=(key, value)
+      synchronize do
+        @cache[key] = value
+
+        @keys.delete(key) if @keys.include?(key)
+
+        @keys << key
+
+        resize
+      end
+    end
+
+    ##
+    # Returns a key if it exists, otherwise yields the supplied block and uses
+    # its return value as the key value.
+    #
+    # @param [Mixed] key
+    # @return [Mixed]
+    #
+    def get_or_set(key)
+      return synchronize { self[key] ||= yield }
+    end
+
+    ##
+    # @return [Array]
+    #
+    def keys
+      return synchronize { @keys }
+    end
+
+    ##
+    # @param [Mixed] key
+    # @return [TrueClass|FalseClass]
+    #
+    def key?(key)
+      return synchronize { @cache.key?(key) }
+    end
+
+    ##
+    # Removes all keys from the cache.
+    #
+    def clear
+      synchronize do
+        @keys.clear
+        @cache.clear
+      end
+    end
+
+    ##
+    # @return [Fixnum]
+    #
+    def size
+      return synchronize { @cache.size }
+    end
+
+    alias_method :length, :size
+
+    private
+
+    ##
+    # Yields the supplied block in a synchronized manner (if needed). This
+    # method is heavily based on `MonitorMixin#mon_enter`.
+    #
+    def synchronize
+      if @owner != Thread.current
+        @mutex.synchronize do
+          @owner = Thread.current
+
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    ##
+    # Removes old keys until the size of the hash no longer exceeds the maximum
+    # size.
+    #
+    def resize
+      return unless size > @maximum
+
+      to_remove = @keys.shift(size - @maximum)
+
+      to_remove.each { |key| @cache.delete(key) }
+    end
+  end # LRU
+end # Oga

data/lib/oga/version.rb

@@ -1,3 +1,3 @@
 module Oga
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
 end # Oga

data/lib/oga/xml/attribute.rb

@@ -29,7 +29,7 @@ module Oga
       #
       DEFAULT_NAMESPACE = Namespace.new(
         :name => 'xml',
-        :uri  => 'http://www.w3.org/XML/1998/namespace'
+        :uri  => XML::DEFAULT_NAMESPACE.uri
       ).freeze
 
       ##

data/lib/oga/xml/default_namespace.rb

@@ -0,0 +1,13 @@
+module Oga
+  module XML
+    ##
+    # The default XML namespace.
+    #
+    # @return [Oga::XML::Namespace]
+    #
+    DEFAULT_NAMESPACE = Namespace.new(
+      :name => 'xmlns',
+      :uri  => 'http://www.w3.org/XML/1998/namespace'
+    ).freeze
+  end # XML
+end # Oga

data/lib/oga/xml/element.rb

@@ -23,7 +23,9 @@ module Oga
     class Element < Node
       include Querying
 
-      attr_accessor :name, :namespace_name, :attributes, :namespaces
+      attr_accessor :name, :namespace_name, :attributes
+
+      attr_writer :namespaces
 
       ##
       # The attribute prefix/namespace used for registering element namespaces.
@@ -166,6 +168,26 @@ module Oga
         return @namespace
       end
 
+      ##
+      # Returns the namespaces registered on this element, or an empty Hash in
+      # case of an HTML element.
+      #
+      # @return [Hash]
+      #
+      def namespaces
+        return html? ? {} : @namespaces
+      end
+
+      ##
+      # Returns true if the current element resides in the default XML
+      # namespace.
+      #
+      # @return [TrueClass|FalseClass]
+      #
+      def default_namespace?
+        return namespace == DEFAULT_NAMESPACE || namespace.nil?
+      end
+
       ##
       # Returns the text of all child nodes joined together.
       #
@@ -284,6 +306,8 @@ module Oga
       # @return [Hash]
       #
       def available_namespaces
+        return {} if html? # HTML(5) completely ignores namespaces
+
         merged = namespaces.dup
         node   = parent
 

data/lib/oga/xml/entities.rb

@@ -1,5 +1,9 @@
 module Oga
   module XML
+    ##
+    # Module for encoding/decoding XML and HTML entities. The mapping of HTML
+    # entities can be found in {Oga::HTML::Entities::DECODE_MAPPING}.
+    #
     module Entities
       ##
       # Hash containing XML entities and the corresponding characters.
@@ -11,15 +15,10 @@ module Oga
       #
       DECODE_MAPPING = {
         '&lt;'   => '<',
-        '&#60;'  => '<',
         '&gt;'   => '>',
-        '&#62;'  => '>',
         '&apos;' => "'",
-        '&#39;'  => "'",
         '&quot;' => '"',
-        '&#34;'  => '"',
         '&amp;'  => '&',
-        '&#38;'  => '&',
       }
 
       ##
@@ -35,16 +34,45 @@ module Oga
         '<' => '&lt;',
       }
 
+      ##
+      # @return [String]
+      #
+      AMPERSAND = '&'.freeze
+
+      ##
+      # Regexp for matching XML/HTML entities such as "&nbsp;".
+      #
+      # @return [Regexp]
+      #
+      REGULAR_ENTITY = /&[a-zA-Z]+;/
+
+      ##
+      # Regexp for matching XML/HTML entities such as "&#38;".
+      #
+      # @return [Regexp]
+      #
+      CODEPOINT_ENTITY = /&#(x)?([a-zA-Z0-9]+);/
+
+      ##
+      # @return [Regexp]
+      #
+      ENCODE_REGEXP = Regexp.new(ENCODE_MAPPING.keys.join('|'))
+
       ##
       # Decodes XML entities.
       #
       # @param [String] input
+      # @param [Hash] mapping
       # @return [String]
       #
-      def self.decode(input)
-        if input.include?('&')
-          DECODE_MAPPING.each do |find, replace|
-            input = input.gsub(find, replace)
+      def self.decode(input, mapping = DECODE_MAPPING)
+        return input unless input.include?(AMPERSAND)
+
+        input = input.gsub(REGULAR_ENTITY, mapping)
+
+        if input.include?(AMPERSAND)
+          input = input.gsub(CODEPOINT_ENTITY) do |match|
+            [$1 ? Integer($2, 16) : Integer($2)].pack('U')
           end
         end
 
@@ -55,14 +83,11 @@ module Oga
       # Encodes special characters as XML entities.
       #
       # @param [String] input
+      # @param [Hash] mapping
       # @return [String]
       #
-      def self.encode(input)
-        ENCODE_MAPPING.each do |from, to|
-          input = input.gsub(from, to) if input.include?(from)
-        end
-
-        return input
+      def self.encode(input, mapping = ENCODE_MAPPING)
+        return input.gsub(ENCODE_REGEXP, mapping)
       end
     end # Entities
   end # XML

data/lib/oga/xml/lexer.rb

@@ -217,7 +217,7 @@ module Oga
       # @param [String] value The data between the quotes.
       #
       def on_string_body(value)
-        add_token(:T_STRING_BODY, Entities.decode(value))
+        add_token(:T_STRING_BODY, value)
       end
 
       ##
@@ -373,7 +373,7 @@ module Oga
       def on_text(value)
         return if value.empty?
 
-        add_token(:T_TEXT, Entities.decode(value))
+        add_token(:T_TEXT, value)
       end
 
       ##

data/lib/oga/xml/namespace.rb

@@ -37,6 +37,14 @@ module Oga
       def inspect
         return "Namespace(name: #{name.inspect} uri: #{uri.inspect})"
       end
+
+      ##
+      # @param [Oga::XML::Namespace] other
+      # @return [TrueClass|FalseClass]
+      #
+      def ==(other)
+        return other.is_a?(self.class) && name == other.name && uri == other.uri
+      end
     end # Namespace
   end # XML
 end # Oga

data/lib/oga/xml/node.rb

@@ -163,6 +163,22 @@ module Oga
 
         node_set.insert(index, other)
       end
+
+      ##
+      # @return [TrueClass|FalseClass]
+      #
+      def html?
+        root = root_node
+
+        return root.is_a?(Document) && root.html?
+      end
+
+      ##
+      # @return [TrueClass|FalseClass]
+      #
+      def xml?
+        return !html?
+      end
     end # Element
   end # XML
 end # Oga

data/lib/oga/xml/node_set.rb

@@ -44,10 +44,10 @@ module Oga
       # @param [Oga::XML::NodeSet] owner The owner of the set.
       #
       def initialize(nodes = [], owner = nil)
-        @nodes = nodes.uniq
+        @nodes = nodes
         @owner = owner
 
-        @nodes.each { |node| take_ownership(node) }
+        @nodes.each { |node| take_ownership(node) } if owner
       end
 
       ##

data/lib/oga/xml/parser.rb

@@ -1,13 +1,170 @@
-#
-# DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.4.12
-# from Racc grammer file "".
-#
+# This file is automatically generated by ruby-ll. Manually changing this file
+# is not recommended as any changes will be lost the next time this parser is
+# re-generated.
+require 'll/setup'
 
-require 'racc/parser.rb'
 module Oga
-  module XML
-    class Parser < Racc::Parser
+module XML
+##
+# DOM parser for both XML and HTML.
+#
+# This parser does not produce a dedicated AST, instead it emits XML nodes
+# directly. Basic usage of this parser is as following:
+#
+#     parser   = Oga::XML::Parser.new('<foo></foo>')
+#     document = parser.parse
+#
+# To enable HTML parsing you'd use the following instead:
+#
+#     parser   = Oga::XML::Parser.new('<foo></foo>', :html => true)
+#     document = parser.parse
+#
+# In both cases you can use either a String or an IO as the parser input. IO
+# instances will result in lower memory overhead, especially when parsing large
+# files.
+#
+class Parser < LL::Driver
+  CONFIG = LL::DriverConfig.new
+
+  CONFIG.terminals = [
+    :$EOF, # 0
+    :T_TEXT, # 1
+    :T_STRING_SQUOTE, # 2
+    :T_STRING_DQUOTE, # 3
+    :T_STRING_BODY, # 4
+    :T_DOCTYPE_START, # 5
+    :T_DOCTYPE_END, # 6
+    :T_DOCTYPE_TYPE, # 7
+    :T_DOCTYPE_NAME, # 8
+    :T_DOCTYPE_INLINE, # 9
+    :T_CDATA, # 10
+    :T_COMMENT, # 11
+    :T_ELEM_START, # 12
+    :T_ELEM_NAME, # 13
+    :T_ELEM_NS, # 14
+    :T_ELEM_END, # 15
+    :T_ATTR, # 16
+    :T_ATTR_NS, # 17
+    :T_XML_DECL_START, # 18
+    :T_XML_DECL_END, # 19
+    :T_PROC_INS_START, # 20
+    :T_PROC_INS_NAME, # 21
+    :T_PROC_INS_END, # 22
+  ].freeze
+
+  CONFIG.rules = [
+    [3, 0, 0, 1], # 0
+    [3, 1, 4, 19, 6, 0], # 1
+    [3, 2, 0, 3], # 2
+    [3, 3, 0, 7], # 3
+    [3, 4, 0, 8], # 4
+    [3, 5, 0, 9], # 5
+    [3, 6, 0, 16], # 6
+    [3, 7, 0, 12], # 7
+    [3, 8, 0, 15], # 8
+    [3, 9, 0, 4, 1, 8, 1, 5], # 9
+    [3, 10, 1, 6], # 10
+    [3, 11, 0, 6, 1, 7], # 11
+    [3, 12, 1, 6, 0, 5], # 12
+    [3, 13, 5, 20, 6, 0], # 13
+    [3, 14, 1, 6, 8, 21, 0, 17], # 14
+    [3, 15, 1, 6], # 15
+    [3, 16, 1, 10], # 16
+    [3, 17, 1, 11], # 17
+    [3, 18, 1, 22, 8, 22, 1, 21, 1, 20], # 18
+    [3, 19, 1, 13], # 19
+    [3, 20, 1, 13, 1, 14], # 20
+    [3, 21, 0, 13, 0, 10, 1, 12], # 21
+    [3, 22, 1, 15, 0, 1, 0, 11], # 22
+    [3, 23, 4, 23, 6, 0], # 23
+    [3, 24, 8, 24, 1, 16, 1, 17], # 24
+    [3, 25, 8, 25, 1, 16], # 25
+    [3, 26, 1, 19, 0, 13, 1, 18], # 26
+    [3, 27, 1, 1], # 27
+    [3, 28, 1, 3, 0, 18, 1, 3], # 28
+    [3, 29, 1, 2, 0, 18, 1, 2], # 29
+    [3, 30, 4, 26, 6, 0], # 30
+    [3, 31, 0, 2], # 31
+    [3, 32, 1, 9], # 32
+    [3, 33, 0, 17], # 33
+    [3, 34, 1, 1], # 34
+    [3, 35, 0, 14], # 35
+    [3, 36, 0, 17], # 36
+    [3, 37, 0, 17], # 37
+    [3, 38, 1, 4], # 38
+  ].freeze
+
+  CONFIG.table = [
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], # 0
+    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], # 1
+    [-1, 6, -1, -1, -1, 2, -1, -1, -1, -1, 3, 4, 7, -1, -1, -1, -1, -1, 8, -1, 5, -1, -1], # 2
+    [-1, -1, -1, -1, -1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 3
+    [12, 12, 12, 12, 12, 12, 10, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12], # 4
+    [13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13], # 5
+    [-1, -1, 14, 14, -1, -1, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 6
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 7
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 8
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 18, -1, -1], # 9
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 19, 20, -1, -1, -1, -1, -1, -1, -1, -1], # 10
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 11
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 12
+    [23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23], # 13
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 25, 24, -1, -1, -1, -1, -1], # 14
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, -1, -1, -1, -1], # 15
+    [-1, 27, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 16
+    [-1, -1, 29, 28, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 17
+    [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30], # 18
+    [-1, 31, -1, -1, -1, 31, -1, -1, -1, -1, 31, 31, 31, -1, -1, -1, -1, -1, 31, -1, 31, -1, -1], # 19
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, 32, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 20
+    [-1, -1, 33, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 21
+    [-1, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 22
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 35, 35, -1, -1, -1, -1, -1], # 23
+    [-1, -1, 36, 36, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 24
+    [-1, -1, 37, 37, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 25
+    [-1, -1, -1, -1, 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # 26
+  ].freeze
+
+  CONFIG.actions = [
+    [:_rule_0, 1], # 0
+    [:_rule_1, 1], # 1
+    [:_rule_2, 1], # 2
+    [:_rule_3, 1], # 3
+    [:_rule_4, 1], # 4
+    [:_rule_5, 1], # 5
+    [:_rule_6, 1], # 6
+    [:_rule_7, 1], # 7
+    [:_rule_8, 1], # 8
+    [:_rule_9, 3], # 9
+    [:_rule_10, 1], # 10
+    [:_rule_11, 2], # 11
+    [:_rule_12, 2], # 12
+    [:_rule_13, 1], # 13
+    [:_rule_14, 3], # 14
+    [:_rule_15, 1], # 15
+    [:_rule_16, 1], # 16
+    [:_rule_17, 1], # 17
+    [:_rule_18, 4], # 18
+    [:_rule_19, 1], # 19
+    [:_rule_20, 2], # 20
+    [:_rule_21, 3], # 21
+    [:_rule_22, 3], # 22
+    [:_rule_23, 1], # 23
+    [:_rule_24, 3], # 24
+    [:_rule_25, 2], # 25
+    [:_rule_26, 3], # 26
+    [:_rule_27, 1], # 27
+    [:_rule_28, 3], # 28
+    [:_rule_29, 3], # 29
+    [:_rule_30, 1], # 30
+    [:_rule_31, 1], # 31
+    [:_rule_32, 1], # 32
+    [:_rule_33, 1], # 33
+    [:_rule_34, 1], # 34
+    [:_rule_35, 1], # 35
+    [:_rule_36, 1], # 36
+    [:_rule_37, 1], # 37
+    [:_rule_38, 1], # 38
+  ].freeze
 
   ##
   # Hash mapping token types and dedicated error labels.
@@ -15,27 +172,27 @@ module Oga
   # @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'
+    :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',
+    -1                => 'end of input'
   }
 
   ##
@@ -64,44 +221,49 @@ module Oga
   #
   # @yieldparam [Array]
   #
-  def yield_next_token
+  def each_token
     @lexer.advance do |type, value, line|
       @line = line if line
 
       yield [type, value]
     end
 
-    yield [false, false]
+    yield [-1, -1]
   end
 
   ##
-  # @param [Fixnum] type The type of token the error occured on.
-  # @param [String] value The value of the token.
-  # @param [Array] stack The current stack of parsed nodes.
-  # @raise [Racc::ParseError]
+  # @param [Fixnum] stack_type
+  # @param [Fixnum] stack_value
+  # @param [Symbol] token_type
+  # @param [String] token_value
   #
-  def on_error(type, value, stack)
-    name = token_to_str(type)
-    name = TOKEN_ERROR_MAPPING[name] || name
+  def parser_error(stack_type, stack_value, token_type, token_value)
+    case id_to_type(stack_type)
+    when :rule
+      message = "Unexpected #{token_type} for rule #{stack_value}"
+    when :terminal
+      expected = id_to_terminal(stack_value)
+      expected = TOKEN_ERROR_MAPPING[expected]   || expected
+      got      = TOKEN_ERROR_MAPPING[token_type] || token_type
+      message  = "Unexpected #{got}, expected #{expected} instead"
+    when :eof
+      message = 'Unexpected end of input'
+    end
+
+    message += " on line #{@line}"
 
-    raise Racc::ParseError, "Unexpected #{name} on line #{@line}"
+    raise LL::ParserError, message
   end
 
   ##
-  # Parses the input and returns the corresponding AST.
-  #
-  # @example
-  #  parser = Oga::Parser.new('<foo>bar</foo>')
-  #  ast    = parser.parse
-  #
-  # @return [Oga::AST::Node]
+  # @see [LL::Driver#parse]
   #
   def parse
-    ast = yyparse(self, :yield_next_token)
+    retval = super
 
     reset
 
-    return ast
+    return retval
   end
 
   ##
@@ -109,9 +271,7 @@ module Oga
   # @return [Oga::XML::Document]
   #
   def on_document(children = [])
-    document = Document.new(
-      :type => @lexer.html ? :html : :xml
-    )
+    document = Document.new(:type => @lexer.html ? :html : :xml)
 
     children.each do |child|
       if child.is_a?(Doctype)
@@ -217,404 +377,203 @@ module Oga
     return element
   end
 
-# vim: set ft=racc:
-##### State transition tables begin ###
-
-racc_action_table = [
-    41,    20,    48,    47,    54,    12,    52,    55,    25,    26,
-    13,    14,    16,    20,    21,    48,    47,    12,    19,    62,
-    15,    40,    13,    14,    16,    20,    60,    23,    59,    12,
-    19,    66,    15,    65,    13,    14,    16,    36,    37,    24,
-    39,    35,    19,    42,    15,    31,    32,    31,    32,    31,
-    32,    48,    47,    57,    59,    64,    65,    49,    50,    51,
-    56,    67 ]
-
-racc_action_check = [
-    24,     0,    37,    37,    38,     0,    37,    38,    16,    16,
-     0,     0,     0,     3,     1,    53,    53,     3,     0,    53,
-     0,    24,     3,     3,     3,    18,    48,    12,    48,    18,
-     3,    61,     3,    61,    18,    18,    18,    23,    23,    15,
-    23,    21,    18,    26,    18,    17,    17,    19,    19,    28,
-    28,    30,    30,    47,    47,    58,    58,    32,    33,    34,
-    41,    63 ]
-
-racc_action_pointer = [
-    -1,    14,   nil,    11,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    18,   nil,   nil,    17,    -6,    28,    23,    30,
-   nil,    41,   nil,    30,    -2,   nil,    29,   nil,    32,   nil,
-    48,   nil,    40,    42,    39,   nil,   nil,    -1,    -3,   nil,
-   nil,    37,   nil,   nil,   nil,   nil,   nil,    49,    23,   nil,
-   nil,   nil,   nil,    12,   nil,   nil,   nil,   nil,    51,   nil,
-   nil,    28,   nil,    54,   nil,   nil,   nil,   nil ]
-
-racc_action_default = [
-    -3,   -46,    -1,    -2,    -5,    -6,    -7,    -8,    -9,   -10,
-   -11,   -12,   -46,   -20,   -21,   -46,   -46,   -29,    -3,   -29,
-   -37,   -46,    -4,   -46,   -46,   -24,   -46,   -26,   -28,   -31,
-   -32,   -34,   -46,   -46,   -46,    68,   -13,   -46,   -46,   -18,
-   -22,   -46,   -25,   -30,   -33,   -38,   -39,   -46,   -46,   -35,
-   -27,   -36,   -14,   -46,   -17,   -19,   -23,   -40,   -46,   -44,
-   -42,   -46,   -15,   -46,   -41,   -45,   -43,   -16 ]
-
-racc_goto_table = [
-    44,     2,    27,     1,    34,    58,    61,    53,    22,    38,
-    43,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    33,
-   nil,   nil,   nil,    63 ]
-
-racc_goto_check = [
-    12,     2,    16,     1,    16,    22,    22,    12,     4,    13,
-    18,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     2,
-   nil,   nil,   nil,    12 ]
-
-racc_goto_pointer = [
-   nil,     3,     1,   nil,     5,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   -30,   -14,   nil,   nil,   -15,   nil,   -18,   nil,
-   nil,   nil,   -42 ]
-
-racc_goto_default = [
-   nil,   nil,   nil,     3,     4,     5,     6,     7,     8,     9,
-    10,    11,   nil,   nil,    17,    18,   nil,    28,    29,    30,
-    45,    46,   nil ]
-
-racc_reduce_table = [
-  0, 0, :racc_error,
-  1, 25, :_reduce_1,
-  1, 26, :_reduce_2,
-  0, 26, :_reduce_3,
-  2, 27, :_reduce_4,
-  1, 27, :_reduce_5,
-  1, 28, :_reduce_none,
-  1, 28, :_reduce_none,
-  1, 28, :_reduce_none,
-  1, 28, :_reduce_none,
-  1, 28, :_reduce_none,
-  1, 28, :_reduce_none,
-  1, 28, :_reduce_none,
-  3, 29, :_reduce_13,
-  4, 29, :_reduce_14,
-  5, 29, :_reduce_15,
-  6, 29, :_reduce_16,
-  4, 29, :_reduce_17,
-  1, 37, :_reduce_18,
-  2, 37, :_reduce_19,
-  1, 30, :_reduce_20,
-  1, 31, :_reduce_21,
-  3, 35, :_reduce_22,
-  4, 35, :_reduce_23,
-  2, 38, :_reduce_24,
-  3, 38, :_reduce_25,
-  2, 39, :_reduce_26,
-  3, 32, :_reduce_27,
-  1, 40, :_reduce_28,
-  0, 40, :_reduce_29,
-  2, 41, :_reduce_30,
-  1, 41, :_reduce_31,
-  1, 42, :_reduce_32,
-  2, 42, :_reduce_33,
-  1, 43, :_reduce_34,
-  2, 43, :_reduce_35,
-  3, 34, :_reduce_36,
-  1, 33, :_reduce_37,
-  1, 36, :_reduce_none,
-  1, 36, :_reduce_none,
-  2, 44, :_reduce_40,
-  3, 44, :_reduce_41,
-  2, 45, :_reduce_42,
-  3, 45, :_reduce_43,
-  1, 46, :_reduce_44,
-  2, 46, :_reduce_45 ]
-
-racc_reduce_n = 46
-
-racc_shift_n = 68
-
-racc_token_table = {
-  false => 0,
-  :error => 1,
-  :T_TEXT => 2,
-  :T_STRING_SQUOTE => 3,
-  :T_STRING_DQUOTE => 4,
-  :T_STRING_BODY => 5,
-  :T_DOCTYPE_START => 6,
-  :T_DOCTYPE_END => 7,
-  :T_DOCTYPE_TYPE => 8,
-  :T_DOCTYPE_NAME => 9,
-  :T_DOCTYPE_INLINE => 10,
-  :T_CDATA => 11,
-  :T_COMMENT => 12,
-  :T_ELEM_START => 13,
-  :T_ELEM_NAME => 14,
-  :T_ELEM_NS => 15,
-  :T_ELEM_END => 16,
-  :T_ATTR => 17,
-  :T_ATTR_NS => 18,
-  :T_XML_DECL_START => 19,
-  :T_XML_DECL_END => 20,
-  :T_PROC_INS_START => 21,
-  :T_PROC_INS_NAME => 22,
-  :T_PROC_INS_END => 23 }
-
-racc_nt_base = 24
-
-racc_use_result_var = false
-
-Racc_arg = [
-  racc_action_table,
-  racc_action_check,
-  racc_action_default,
-  racc_action_pointer,
-  racc_goto_table,
-  racc_goto_check,
-  racc_goto_default,
-  racc_goto_pointer,
-  racc_nt_base,
-  racc_reduce_table,
-  racc_token_table,
-  racc_shift_n,
-  racc_reduce_n,
-  racc_use_result_var ]
-
-Racc_token_to_s_table = [
-  "$end",
-  "error",
-  "T_TEXT",
-  "T_STRING_SQUOTE",
-  "T_STRING_DQUOTE",
-  "T_STRING_BODY",
-  "T_DOCTYPE_START",
-  "T_DOCTYPE_END",
-  "T_DOCTYPE_TYPE",
-  "T_DOCTYPE_NAME",
-  "T_DOCTYPE_INLINE",
-  "T_CDATA",
-  "T_COMMENT",
-  "T_ELEM_START",
-  "T_ELEM_NAME",
-  "T_ELEM_NS",
-  "T_ELEM_END",
-  "T_ATTR",
-  "T_ATTR_NS",
-  "T_XML_DECL_START",
-  "T_XML_DECL_END",
-  "T_PROC_INS_START",
-  "T_PROC_INS_NAME",
-  "T_PROC_INS_END",
-  "$start",
-  "document",
-  "expressions",
-  "expressions_",
-  "expression",
-  "doctype",
-  "cdata",
-  "comment",
-  "element",
-  "text",
-  "xmldecl",
-  "proc_ins",
-  "string",
-  "doctype_inline",
-  "element_open",
-  "element_start",
-  "attributes",
-  "attributes_",
-  "attribute",
-  "attribute_name",
-  "string_dquote",
-  "string_squote",
-  "string_body" ]
-
-Racc_debug_parser = false
-
-##### State transition tables end #####
-
-# reduce 0 omitted
-
-def _reduce_1(val, _values)
- on_document(val[0]) 
-end
-
-def _reduce_2(val, _values)
- val[0] 
-end
-
-def _reduce_3(val, _values)
- [] 
-end
-
-def _reduce_4(val, _values)
- val[0] << val[1] 
-end
+  ##
+  # @param [String] name
+  # @param [String] ns_name
+  # @param [String] value
+  # @return [Oga::XML::Attribute]
+  #
+  def on_attribute(name, ns_name = nil, value = nil)
+    return Attribute.new(
+      :namespace_name => ns_name,
+      :name           => name,
+      :value          => value
+    )
+  end
 
-def _reduce_5(val, _values)
- val 
-end
+  ##
+  # @param [Array] attrs
+  #
+  def on_attributes(attrs)
+    return attrs
+  end
 
-# reduce 6 omitted
+  def _rule_0(val)
+     on_document(val[0]) 
+  end
 
-# reduce 7 omitted
+  def _rule_1(val)
+    val[0]
+  end
 
-# reduce 8 omitted
+  def _rule_2(val)
+    val[0]
+  end
 
-# reduce 9 omitted
+  def _rule_3(val)
+    val[0]
+  end
 
-# reduce 10 omitted
+  def _rule_4(val)
+    val[0]
+  end
 
-# reduce 11 omitted
+  def _rule_5(val)
+    val[0]
+  end
 
-# reduce 12 omitted
+  def _rule_6(val)
+    val[0]
+  end
 
-def _reduce_13(val, _values)
-        on_doctype(:name => val[1])
-      
-end
+  def _rule_7(val)
+    val[0]
+  end
 
-def _reduce_14(val, _values)
-        on_doctype(:name => val[1], :type => val[2])
-      
-end
+  def _rule_8(val)
+    val[0]
+  end
 
-def _reduce_15(val, _values)
-        on_doctype(:name => val[1], :type => val[2], :public_id => val[3])
-      
-end
+  def _rule_9(val)
+    
+      name   = val[1]
+      follow = val[2]
+
+      on_doctype(
+        :name         => name,
+        :type         => follow[0],
+        :public_id    => follow[1],
+        :system_id    => follow[2],
+        :inline_rules => follow[3]
+      )
+    
+  end
 
-def _reduce_16(val, _values)
-        on_doctype(
-          :name      => val[1],
-          :type      => val[2],
-          :public_id => val[3],
-          :system_id => val[4]
-        )
-      
-end
+  def _rule_10(val)
+     [] 
+  end
 
-def _reduce_17(val, _values)
-        on_doctype(:name => val[1], :inline_rules => val[2])
-      
-end
+  def _rule_11(val)
+     [val[0], *val[1]] 
+  end
 
-def _reduce_18(val, _values)
- val[0] 
-end
+  def _rule_12(val)
+     [nil, nil, nil, val[0]] 
+  end
 
-def _reduce_19(val, _values)
- val[0] + val[1] 
-end
+  def _rule_13(val)
+     val[0].inject(:+) 
+  end
 
-def _reduce_20(val, _values)
- on_cdata(val[0]) 
-end
+  def _rule_14(val)
+     [val[0], val[1]] 
+  end
 
-def _reduce_21(val, _values)
- on_comment(val[0]) 
-end
+  def _rule_15(val)
+     nil 
+  end
 
-def _reduce_22(val, _values)
-        on_proc_ins(val[1])
-      
-end
+  def _rule_16(val)
+     on_cdata(val[0]) 
+  end
 
-def _reduce_23(val, _values)
-        on_proc_ins(val[1], val[2])
-      
-end
+  def _rule_17(val)
+     on_comment(val[0]) 
+  end
 
-def _reduce_24(val, _values)
- [nil, val[1]] 
-end
+  def _rule_18(val)
+    
+      on_proc_ins(val[1], val[2])
+    
+  end
 
-def _reduce_25(val, _values)
- [val[1], val[2]] 
-end
+  def _rule_19(val)
+     [nil, val[0]] 
+  end
 
-def _reduce_26(val, _values)
- on_element(val[0][0], val[0][1], val[1]) 
-end
+  def _rule_20(val)
+     val 
+  end
 
-def _reduce_27(val, _values)
-        if val[0]
-          on_element_children(val[0], val[1])
-        end
+  def _rule_21(val)
+    
+      on_element(val[1][0], val[1][1], val[2])
+    
+  end
 
-        after_element(val[0])
-      
-end
+  def _rule_22(val)
+    
+      if val[0]
+        on_element_children(val[0], val[1])
+      end
 
-def _reduce_28(val, _values)
- val[0] 
-end
+      after_element(val[0])
+    
+  end
 
-def _reduce_29(val, _values)
- [] 
-end
+  def _rule_23(val)
+     on_attributes(val[0]) 
+  end
 
-def _reduce_30(val, _values)
- val[0] << val[1] 
-end
+  def _rule_24(val)
+     on_attribute(val[1], val[0], val[2]) 
+  end
 
-def _reduce_31(val, _values)
- val 
-end
+  def _rule_25(val)
+     on_attribute(val[0], nil, val[1]) 
+  end
 
-def _reduce_32(val, _values)
- val[0] 
-end
+  def _rule_26(val)
+     on_xml_decl(val[1]) 
+  end
 
-def _reduce_33(val, _values)
-        val[0].value = val[1]
-        val[0]
-      
-end
+  def _rule_27(val)
+     on_text(val[0]) 
+  end
 
-def _reduce_34(val, _values)
- Attribute.new(:name => val[0]) 
-end
+  def _rule_28(val)
+     val[1] 
+  end
 
-def _reduce_35(val, _values)
-        Attribute.new(:namespace_name => val[0], :name => val[1])
-      
-end
+  def _rule_29(val)
+     val[1] 
+  end
 
-def _reduce_36(val, _values)
- on_xml_decl(val[1]) 
-end
+  def _rule_30(val)
+     val[0].inject(:+) || '' 
+  end
 
-def _reduce_37(val, _values)
- on_text(val[0]) 
-end
+  def _rule_31(val)
+    val[0]
+  end
 
-# reduce 38 omitted
+  def _rule_32(val)
+    val[0]
+  end
 
-# reduce 39 omitted
+  def _rule_33(val)
+    val[0]
+  end
 
-def _reduce_40(val, _values)
- '' 
-end
+  def _rule_34(val)
+    val[0]
+  end
 
-def _reduce_41(val, _values)
- val[1] 
-end
+  def _rule_35(val)
+    val[0]
+  end
 
-def _reduce_42(val, _values)
- '' 
-end
+  def _rule_36(val)
+    val[0]
+  end
 
-def _reduce_43(val, _values)
- val[1] 
-end
+  def _rule_37(val)
+    val[0]
+  end
 
-def _reduce_44(val, _values)
- val[0] 
+  def _rule_38(val)
+    val[0]
+  end
 end
-
-def _reduce_45(val, _values)
- val[0] + val[1] 
 end
-
-def _reduce_none(val, _values)
-  val[0]
 end
-
-    end   # class Parser
-    end   # module XML
-  end   # module Oga