oga 0.1.3 → 0.2.0

data/lib/oga/css/parser.rb

@@ -0,0 +1,828 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.12
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+module Oga
+  module CSS
+    class Parser < Racc::Parser
+
+  ##
+  # @param [String] data The input to parse.
+  #
+  def initialize(data)
+    @lexer = Lexer.new(data)
+  end
+
+  ##
+  # Resets the internal state of the parser.
+  #
+  def reset
+    @current_element = nil
+  end
+
+  ##
+  # @param [Symbol] type
+  # @param [Array] children
+  # @return [AST::Node]
+  #
+  def s(type, *children)
+    return AST::Node.new(type, children)
+  end
+
+  ##
+  # Yields the next token from the lexer.
+  #
+  # @yieldparam [Array]
+  #
+  def yield_next_token
+    @lexer.advance do |*args|
+      yield args
+    end
+
+    yield [false, false]
+  end
+
+  ##
+  # Returns the node test for the current element.
+  #
+  # @return [AST::Node]
+  #
+  def current_element
+    return @current_element ||= s(:test, nil, '*')
+  end
+
+  ##
+  # Parses the input and returns the corresponding AST.
+  #
+  # @example
+  #  parser = Oga::CSS::Parser.new('foo.bar')
+  #  ast    = parser.parse
+  #
+  # @return [AST::Node]
+  #
+  def parse
+    reset
+
+    ast = yyparse(self, :yield_next_token)
+
+    return ast
+  end
+
+  ##
+  # Generates the AST for a node test.
+  #
+  # @param [String] namespace
+  # @param [String] name
+  # @return [AST::Node]
+  #
+  def on_test(namespace, name)
+    @current_element = s(:test, namespace, name)
+
+    return @current_element
+  end
+
+  ##
+  # @param [String] name
+  # @param [AST::Node] arg
+  # @return [AST::Node]
+  #
+  def on_pseudo_class(name, arg = nil)
+    handler = "on_pseudo_class_#{name.gsub('-', '_')}"
+
+    return arg ? send(handler, arg) : send(handler)
+  end
+
+  ##
+  # Generates the AST for the `root` pseudo class.
+  #
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_root
+    return s(:call, 'not', s(:axis, 'parent', s(:test, nil, '*')))
+  end
+
+  ##
+  # Generates the AST for the `nth-child` pseudo class.
+  #
+  # @param [AST::Node] arg
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_nth_child(arg)
+    return generate_nth_child('preceding-sibling', arg)
+  end
+
+  ##
+  # Generates the AST for the `nth-last-child` pseudo class.
+  #
+  # @param [AST::Node] arg
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_nth_last_child(arg)
+    return generate_nth_child('following-sibling', arg)
+  end
+
+  ##
+  # Generates the AST for the `nth-of-type` pseudo class.
+  #
+  # @param [AST::Node] arg
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_nth_of_type(arg)
+    return generate_nth_child('preceding-sibling', arg, current_element)
+  end
+
+  ##
+  # Generates the AST for the `nth-last-of-type` pseudo class.
+  #
+  # @param [AST::Node] arg
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_nth_last_of_type(arg)
+    return generate_nth_child('following-sibling', arg, current_element)
+  end
+
+  ##
+  # Generates the AST for the `:first-child` selector.
+  #
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_first_child
+    return generate_no_siblings('preceding-sibling')
+  end
+
+  ##
+  # Generates the AST for the `:last-child` selector.
+  #
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_last_child
+    return generate_no_siblings('following-sibling')
+  end
+
+  ##
+  # Generates the AST for the `:first-of-type` selector.
+  #
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_first_of_type
+    return generate_no_siblings('preceding-sibling', current_element)
+  end
+
+  ##
+  # Generates the AST for the `:last-of-type` selector.
+  #
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_last_of_type
+    return generate_no_siblings('following-sibling', current_element)
+  end
+
+  ##
+  # Generates the AST for the `:only-child` selector.
+  #
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_only_child
+    return s(:and, on_pseudo_class_first_child, on_pseudo_class_last_child)
+  end
+
+  ##
+  # Generates the AST for the `:only-of-type` selector.
+  #
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_only_of_type
+    return s(:and, on_pseudo_class_first_of_type, on_pseudo_class_last_of_type)
+  end
+
+  ##
+  # Generates the AST for the `:empty` selector.
+  #
+  # @return [AST::Node]
+  #
+  def on_pseudo_class_empty
+    return s(:call, 'not', s(:axis, 'child', s(:type_test, 'node')))
+  end
+
+  private
+
+  ##
+  # @param [String] count_axis
+  # @param [AST::Node] arg
+  # @param [AST::Node] count_test
+  # @return [AST::Node]
+  #
+  def generate_nth_child(count_axis, arg, count_test = s(:test, nil, '*'))
+    count_call = s(:call, 'count', s(:axis, count_axis, count_test))
+
+   # literal 2, 4, etc
+    if int_node?(arg)
+      node = s(:eq, count_call, s(:int, arg.children[0] - 1))
+    else
+      step, offset = *arg
+      before_count = s(:add, count_call, s(:int, 1))
+      compare      = step_comparison(step)
+
+      # 2n+2, 2n-4, etc
+      if offset
+        mod_val = step_modulo_value(step)
+        node    = s(
+          :and,
+          s(compare, before_count, offset),
+          s(:eq, s(:mod, s(:sub, before_count, offset), mod_val), s(:int, 0))
+        )
+
+      # 2n, n, -2n
+      else
+        node = s(:eq, s(:mod, before_count, step), s(:int, 0))
+      end
+    end
+
+    return node
+  end
+
+  ##
+  # @param [String] axis
+  # @param [AST::Node] test
+  # @return [AST::Node]
+  #
+  def generate_no_siblings(axis, test = s(:test, nil, '*'))
+    return s(:eq, s(:call, 'count', s(:axis, axis, test)), s(:int, 0))
+  end
+
+  ##
+  # @param [AST::Node] node
+  # @return [TrueClass|FalseClass]
+  #
+  def int_node?(node)
+    return node.type == :int
+  end
+
+  ##
+  # @param [AST::Node] node
+  # @return [TrueClass|FalseClass]
+  #
+  def non_positive_number?(node)
+    return node.children[0] <= 0
+  end
+
+  ##
+  # @param [AST::Node] node
+  # @return [Symbol]
+  #
+  def step_comparison(node)
+    return node.children[0] >= 0 ? :gte : :lte
+  end
+
+  ##
+  # @param [AST::Node] step
+  # @return [AST::Node]
+  #
+  def step_modulo_value(step)
+    # -2n
+    if step and non_positive_number?(step)
+      mod_val = s(:int, -step.children[0])
+
+    # 2n
+    elsif step
+      mod_val = step
+
+    else
+      mod_val = s(:int, 1)
+    end
+
+    return mod_val
+  end
+
+# vim: set ft=racc:
+##### State transition tables begin ###
+
+racc_action_table = [
+    13,    41,    19,    43,    23,    13,    44,    45,    26,    25,
+    13,    40,    19,    13,    23,     9,    10,    11,    64,    48,
+     9,    10,    11,    20,    21,     9,    10,    11,    63,    62,
+    49,    65,    66,    20,    21,    13,    35,    19,    13,    23,
+    19,    24,    23,    19,    68,    23,    19,    68,    23,    68,
+     9,    10,    11,     9,    10,    11,    68,    68,    20,    21,
+    68,    20,    21,    13,    20,    21,    13,    20,    21,    19,
+    74,    23,    19,    75,    23,    19,    62,    23,     9,    10,
+    11,     9,    10,    11,    50,    51,    52,    53,    54,    55,
+    20,    21,    77,    20,    21,    62,    20,    21,    62 ]
+
+racc_action_check = [
+     0,    21,     0,    22,     0,    11,    23,    24,     4,     3,
+    43,    20,    43,    19,    43,     0,     0,     0,    43,    35,
+    11,    11,    11,     0,     0,    43,    43,    43,    43,    43,
+    36,    43,    43,    43,    43,    25,    13,    25,    26,    25,
+    26,     1,    26,     5,    50,     5,     6,    51,     6,    52,
+    25,    25,    25,    26,    26,    26,    53,    54,    25,    25,
+    55,    26,    26,    10,     5,     5,     9,     6,     6,     7,
+    56,     7,    28,    57,    28,    29,    63,    29,    10,    10,
+    10,     9,     9,     9,    37,    37,    37,    37,    37,    37,
+     7,     7,    64,    28,    28,    75,    29,    29,    77 ]
+
+racc_action_pointer = [
+    -2,    41,   nil,     2,     1,    39,    42,    65,   nil,    64,
+    61,     3,   nil,    33,   nil,   nil,   nil,   nil,   nil,    11,
+     9,    -1,    -5,     4,     7,    33,    36,   nil,    68,    71,
+   nil,   nil,   nil,   nil,   nil,    17,    25,    73,   nil,   nil,
+   nil,   nil,   nil,     8,   nil,   nil,   nil,   nil,   nil,   nil,
+    22,    25,    27,    34,    35,    38,    61,    53,   nil,   nil,
+   nil,   nil,   nil,    55,    72,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,    74,   nil,    77,   nil,   nil ]
+
+racc_action_default = [
+    -2,   -59,    -1,    -3,    -4,    -7,    -8,   -10,   -12,   -16,
+   -16,   -16,   -19,   -20,   -23,   -24,   -25,   -26,   -27,   -59,
+   -59,   -59,   -40,   -59,   -59,   -59,   -59,   -22,    -9,   -11,
+   -13,   -17,   -18,   -14,   -15,   -59,   -59,   -29,   -30,   -31,
+   -38,   -39,   -41,   -59,   -42,    80,    -6,    -5,   -21,   -28,
+   -59,   -59,   -59,   -59,   -59,   -59,   -59,   -44,   -45,   -46,
+   -47,   -48,   -50,   -51,   -59,   -57,   -58,   -32,   -49,   -33,
+   -34,   -35,   -36,   -37,   -43,   -55,   -52,   -53,   -56,   -54 ]
+
+racc_goto_table = [
+     3,    57,    28,    29,    27,    67,    69,    70,    71,    72,
+    73,    31,    31,    31,    32,    32,    32,    30,    33,    34,
+    36,    76,     4,    39,    37,    46,    47,    27,    27,    38,
+     1,    42,    56,    78,     2,    79,    58,    59,    60,   nil,
+   nil,   nil,   nil,    61 ]
+
+racc_goto_check = [
+     3,    23,     5,     5,    11,    19,    19,    19,    19,    19,
+    19,     8,     8,     8,     7,     7,     7,     9,     9,     9,
+    16,    23,     4,    10,    17,     3,     3,    11,    11,    18,
+     1,    21,    22,    23,     2,    23,    24,    25,    26,   nil,
+   nil,   nil,   nil,     3 ]
+
+racc_goto_pointer = [
+   nil,    30,    34,     0,    22,    -4,   nil,     5,     2,     8,
+     4,    -1,   nil,   nil,   nil,   nil,     1,     5,    10,   -45,
+   nil,     9,   -11,   -42,    -7,    -6,    -5 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,     5,     6,     7,     8,   nil,
+    12,    14,    15,    16,    17,    18,   nil,   nil,   nil,   nil,
+    22,   nil,   nil,   nil,   nil,   nil,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 28, :_reduce_1,
+  0, 28, :_reduce_2,
+  1, 29, :_reduce_3,
+  1, 29, :_reduce_4,
+  3, 31, :_reduce_5,
+  3, 31, :_reduce_6,
+  1, 30, :_reduce_7,
+  1, 30, :_reduce_none,
+  2, 30, :_reduce_9,
+  1, 30, :_reduce_none,
+  2, 30, :_reduce_11,
+  1, 33, :_reduce_12,
+  2, 34, :_reduce_13,
+  2, 34, :_reduce_14,
+  2, 34, :_reduce_15,
+  0, 36, :_reduce_none,
+  1, 36, :_reduce_none,
+  1, 36, :_reduce_none,
+  1, 35, :_reduce_19,
+  1, 37, :_reduce_20,
+  3, 37, :_reduce_21,
+  2, 32, :_reduce_22,
+  1, 32, :_reduce_none,
+  1, 38, :_reduce_none,
+  1, 38, :_reduce_none,
+  1, 38, :_reduce_none,
+  1, 38, :_reduce_none,
+  3, 42, :_reduce_28,
+  1, 43, :_reduce_none,
+  1, 43, :_reduce_none,
+  1, 44, :_reduce_31,
+  3, 45, :_reduce_32,
+  3, 45, :_reduce_33,
+  3, 45, :_reduce_34,
+  3, 45, :_reduce_35,
+  3, 45, :_reduce_36,
+  3, 45, :_reduce_37,
+  2, 39, :_reduce_38,
+  2, 40, :_reduce_39,
+  1, 41, :_reduce_40,
+  2, 41, :_reduce_41,
+  2, 47, :_reduce_42,
+  3, 48, :_reduce_43,
+  1, 49, :_reduce_none,
+  1, 49, :_reduce_none,
+  1, 49, :_reduce_none,
+  1, 49, :_reduce_none,
+  1, 49, :_reduce_none,
+  1, 46, :_reduce_49,
+  1, 50, :_reduce_50,
+  1, 53, :_reduce_51,
+  2, 53, :_reduce_52,
+  2, 53, :_reduce_53,
+  3, 53, :_reduce_54,
+  2, 53, :_reduce_55,
+  3, 53, :_reduce_56,
+  1, 51, :_reduce_57,
+  1, 52, :_reduce_58 ]
+
+racc_reduce_n = 59
+
+racc_shift_n = 80
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :T_IDENT => 2,
+  :T_PIPE => 3,
+  :T_LBRACK => 4,
+  :T_RBRACK => 5,
+  :T_COLON => 6,
+  :T_SPACE => 7,
+  :T_LPAREN => 8,
+  :T_RPAREN => 9,
+  :T_MINUS => 10,
+  :T_EQ => 11,
+  :T_SPACE_IN => 12,
+  :T_STARTS_WITH => 13,
+  :T_ENDS_WITH => 14,
+  :T_IN => 15,
+  :T_HYPHEN_IN => 16,
+  :T_GREATER => 17,
+  :T_TILDE => 18,
+  :T_PLUS => 19,
+  :T_NTH => 20,
+  :T_INT => 21,
+  :T_STRING => 22,
+  :T_ODD => 23,
+  :T_EVEN => 24,
+  :T_DOT => 25,
+  :T_HASH => 26 }
+
+racc_nt_base = 27
+
+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_IDENT",
+  "T_PIPE",
+  "T_LBRACK",
+  "T_RBRACK",
+  "T_COLON",
+  "T_SPACE",
+  "T_LPAREN",
+  "T_RPAREN",
+  "T_MINUS",
+  "T_EQ",
+  "T_SPACE_IN",
+  "T_STARTS_WITH",
+  "T_ENDS_WITH",
+  "T_IN",
+  "T_HYPHEN_IN",
+  "T_GREATER",
+  "T_TILDE",
+  "T_PLUS",
+  "T_NTH",
+  "T_INT",
+  "T_STRING",
+  "T_ODD",
+  "T_EVEN",
+  "T_DOT",
+  "T_HASH",
+  "$start",
+  "css",
+  "selectors",
+  "selector",
+  "selectors_",
+  "predicates",
+  "descendant_or_self",
+  "axis",
+  "node_test",
+  "axis_selector",
+  "node_name",
+  "predicate",
+  "class",
+  "id",
+  "pseudo_class",
+  "attribute_predicate",
+  "attribute_predicate_members",
+  "attribute",
+  "operator",
+  "string",
+  "pseudo_name",
+  "pseudo_args",
+  "pseudo_arg",
+  "integer",
+  "odd",
+  "even",
+  "nth" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values)
+ val[0] 
+end
+
+def _reduce_2(val, _values)
+ nil 
+end
+
+def _reduce_3(val, _values)
+        # a single "+ y" selector
+        if val[0].is_a?(Array)
+          return s(:path, *val[0])
+        else
+          return val[0]
+        end
+      
+end
+
+def _reduce_4(val, _values)
+ s(:path, *val[0].flatten) 
+end
+
+def _reduce_5(val, _values)
+ val[0] << val[2] 
+end
+
+def _reduce_6(val, _values)
+ [val[0], val[2]] 
+end
+
+def _reduce_7(val, _values)
+        s(:predicate, s(:axis, 'descendant', on_test(nil, '*')), val[0])
+      
+end
+
+# reduce 8 omitted
+
+def _reduce_9(val, _values)
+ s(:predicate, val[0], val[1]) 
+end
+
+# reduce 10 omitted
+
+def _reduce_11(val, _values)
+ s(:predicate, val[0], val[1]) 
+end
+
+def _reduce_12(val, _values)
+ s(:axis, 'descendant', val[0]) 
+end
+
+def _reduce_13(val, _values)
+        s(:axis, 'child', val[1])
+      
+end
+
+def _reduce_14(val, _values)
+        s(:axis, 'following-sibling', val[1])
+      
+end
+
+def _reduce_15(val, _values)
+        [
+          s(
+            :predicate,
+            s(:axis, 'following-sibling', on_test(nil, '*')),
+            s(:int, 1)
+          ),
+          s(:axis, 'self', val[1])
+        ]
+      
+end
+
+# reduce 16 omitted
+
+# reduce 17 omitted
+
+# reduce 18 omitted
+
+def _reduce_19(val, _values)
+ on_test(*val[0]) 
+end
+
+def _reduce_20(val, _values)
+ [nil, val[0]] 
+end
+
+def _reduce_21(val, _values)
+ [val[0], val[2]] 
+end
+
+def _reduce_22(val, _values)
+ s(:and, val[0], val[1]) 
+end
+
+# reduce 23 omitted
+
+# reduce 24 omitted
+
+# reduce 25 omitted
+
+# reduce 26 omitted
+
+# reduce 27 omitted
+
+def _reduce_28(val, _values)
+ val[1] 
+end
+
+# reduce 29 omitted
+
+# reduce 30 omitted
+
+def _reduce_31(val, _values)
+ s(:axis, 'attribute', on_test(*val[0])) 
+end
+
+def _reduce_32(val, _values)
+        s(:eq, val[0], val[2])
+      
+end
+
+def _reduce_33(val, _values)
+        s(
+          :call,
+          'contains',
+          s(:call, 'concat', s(:string, ' '), val[0], s(:string, ' ')),
+          s(:call, 'concat', s(:string, ' '), val[2], s(:string, ' '))
+        )
+      
+end
+
+def _reduce_34(val, _values)
+        s(:call, 'starts-with', val[0], val[2])
+      
+end
+
+def _reduce_35(val, _values)
+        s(
+          :eq,
+          s(
+            :call,
+            'substring',
+            val[0],
+            s(
+              :add,
+              s(
+                :sub,
+                s(:call, 'string-length', val[0]),
+                s(:call, 'string-length', val[2])
+              ),
+              s(:int, 1)
+            ),
+            s(:call, 'string-length', val[2])
+          ),
+          val[2]
+        )
+      
+end
+
+def _reduce_36(val, _values)
+        s(:call, 'contains', val[0], val[2])
+      
+end
+
+def _reduce_37(val, _values)
+        s(
+          :or,
+          s(:eq, val[0], val[2]),
+          s(
+            :call,
+            'starts-with',
+            val[0],
+            s(:call, 'concat', val[2], s(:string, '-'))
+          )
+        )
+      
+end
+
+def _reduce_38(val, _values)
+        axis = s(:axis, 'attribute', s(:test, nil, 'class'))
+
+        s(
+          :call,
+          'contains',
+          s(:call, 'concat', s(:string, ' '), axis, s(:string, ' ')),
+          s(:string, " #{val[1]} ")
+        )
+      
+end
+
+def _reduce_39(val, _values)
+        s(
+          :eq,
+          s(:axis, 'attribute', s(:test, nil, 'id')),
+          s(:string, val[1])
+        )
+      
+end
+
+def _reduce_40(val, _values)
+ on_pseudo_class(val[0]) 
+end
+
+def _reduce_41(val, _values)
+ on_pseudo_class(val[0], val[1]) 
+end
+
+def _reduce_42(val, _values)
+ val[1] 
+end
+
+def _reduce_43(val, _values)
+ val[1] 
+end
+
+# reduce 44 omitted
+
+# reduce 45 omitted
+
+# reduce 46 omitted
+
+# reduce 47 omitted
+
+# reduce 48 omitted
+
+def _reduce_49(val, _values)
+ s(:string, val[0]) 
+end
+
+def _reduce_50(val, _values)
+ s(:int, val[0].to_i) 
+end
+
+def _reduce_51(val, _values)
+ s(:nth, s(:int, 1)) 
+end
+
+def _reduce_52(val, _values)
+ s(:nth, s(:int, 1), val[1]) 
+end
+
+def _reduce_53(val, _values)
+ s(:nth, s(:int, 1)) 
+end
+
+def _reduce_54(val, _values)
+ s(:nth, s(:int, -1), val[2]) 
+end
+
+def _reduce_55(val, _values)
+ s(:nth, val[0]) 
+end
+
+def _reduce_56(val, _values)
+        a = val[0]
+        b = val[2]
+
+        # 2n-1 gets turned into 2n+1
+        if b.children[0] < 0
+          b = s(:int, a.children[0] - (b.children[0] % a.children[0]))
+        end
+
+        s(:nth, a, b)
+      
+end
+
+def _reduce_57(val, _values)
+ s(:nth, s(:int, 2), s(:int, 1)) 
+end
+
+def _reduce_58(val, _values)
+ s(:nth, s(:int, 2)) 
+end
+
+def _reduce_none(val, _values)
+  val[0]
+end
+
+    end   # class Parser
+    end   # module CSS
+  end   # module Oga