racc 1.5.2 → 1.6.0

data/test/assets/csspool.y

@@ -1,729 +0,0 @@
-class CSSPool::CSS::Parser
-
-token CHARSET_SYM IMPORT_SYM STRING SEMI IDENT S COMMA LBRACE RBRACE STAR HASH
-token LSQUARE RSQUARE EQUAL INCLUDES DASHMATCH LPAREN RPAREN FUNCTION GREATER PLUS
-token SLASH NUMBER MINUS LENGTH PERCENTAGE ANGLE TIME FREQ URI
-token IMPORTANT_SYM MEDIA_SYM NOT ONLY AND NTH_PSEUDO_CLASS
-token DOCUMENT_QUERY_SYM FUNCTION_NO_QUOTE
-token TILDE
-token PREFIXMATCH SUFFIXMATCH SUBSTRINGMATCH
-token NOT_PSEUDO_CLASS
-token KEYFRAMES_SYM
-token MATCHES_PSEUDO_CLASS
-token NAMESPACE_SYM
-token MOZ_PSEUDO_ELEMENT
-token RESOLUTION
-token COLON
-token SUPPORTS_SYM
-token OR
-token VARIABLE_NAME
-token CALC_SYM
-token FONTFACE_SYM
-token UNICODE_RANGE
-token RATIO
-
-rule
-  document
-    : { @handler.start_document }
-      stylesheet
-      { @handler.end_document }
-    ;
-  stylesheet
-    : charset stylesheet
-    | import stylesheet
-    | namespace stylesheet
-    | charset
-    | import
-    | namespace
-    | body
-    |
-    ;
-  charset
-    : CHARSET_SYM STRING SEMI { @handler.charset interpret_string(val[1]), {} }
-    ;
-  import
-    : IMPORT_SYM import_location medium SEMI {
-        @handler.import_style val[2], val[1]
-      }
-    | IMPORT_SYM import_location SEMI {
-        @handler.import_style [], val[1]
-      }
-    ;
-  import_location
-    : import_location S
-    | STRING { result = Terms::String.new interpret_string val.first }
-    | URI { result = Terms::URI.new interpret_uri val.first }
-    ;
-  namespace
-    : NAMESPACE_SYM ident import_location SEMI {
-        @handler.namespace val[1], val[2]
-      }
-    | NAMESPACE_SYM import_location SEMI {
-        @handler.namespace nil, val[1]
-      }
-    ;
-  medium
-    : medium COMMA IDENT {
-        result = val[0] << MediaType.new(val[2])
-      }
-    | IDENT {
-        result = [MediaType.new(val[0])]
-      }
-    ;
-  media_query_list
-    : media_query                           { result = MediaQueryList.new([ val[0] ]) }
-    | media_query_list COMMA media_query    { result = val[0] << val[2] }
-    |                                       { result = MediaQueryList.new }
-    ;
-  media_query
-    : optional_only_or_not media_type optional_and_exprs   { result = MediaQuery.new(val[0], val[1], val[2]) }
-    | media_expr optional_and_exprs                        { result = MediaQuery.new(nil, val[0], val[1]) }
-    ;
-  optional_only_or_not
-    : ONLY                { result = :only }
-    | NOT                 { result = :not }
-    |                     { result = nil }
-    ;
-  media_type
-    : IDENT               { result = MediaType.new(val[0]) }
-    ;
-  media_expr
-    : LPAREN optional_space IDENT optional_space RPAREN                            { result = MediaType.new(val[2]) }
-    | LPAREN optional_space IDENT optional_space COLON optional_space expr RPAREN  { result = MediaFeature.new(val[2], val[6][0]) }
-    ;
-  optional_space
-    : S                 { result = val[0] }
-    |                   { result = nil }
-    ;
-  optional_and_exprs
-    : optional_and_exprs AND media_expr  { result = val[0] << val[2] }
-    |                                    { result = [] }
-    ;
-  resolution
-    : RESOLUTION {
-        unit = val.first.gsub(/[\s\d.]/, '')
-        number = numeric(val.first)
-        result = Terms::Resolution.new(number, unit)
-      }
-    ;
-  body
-    : ruleset body
-    | conditional_rule body
-    | keyframes_rule body
-    | fontface_rule body
-    | ruleset
-    | conditional_rule
-    | keyframes_rule
-    | fontface_rule
-    ;
-  conditional_rule
-    : media
-    | document_query
-    | supports
-    ;
-  body_in_media
-    : body
-    | empty_ruleset
-    ;
-  media
-    : start_media body_in_media RBRACE { @handler.end_media val.first }
-    ;
-  start_media
-    : MEDIA_SYM media_query_list LBRACE {
-        result = val[1]
-        @handler.start_media result
-      }
-    ;
-  document_query
-    : start_document_query body RBRACE { @handler.end_document_query(before_pos(val), after_pos(val)) }
-    | start_document_query RBRACE { @handler.end_document_query(before_pos(val), after_pos(val)) }
-    ;
-  start_document_query
-    : start_document_query_pos url_match_fns LBRACE {
-        @handler.start_document_query(val[1], after_pos(val))
-      }
-    ;
-  start_document_query_pos
-    : DOCUMENT_QUERY_SYM {
-        @handler.node_start_pos = before_pos(val)
-      }
-    ;
-  url_match_fns
-    : url_match_fn COMMA url_match_fns {
-        result = [val[0], val[2]].flatten
-      }
-    | url_match_fn {
-        result = val
-      }
-    ;
-  url_match_fn
-    : function_no_quote
-    | function
-    | uri
-    ;
-  supports
-    : start_supports body RBRACE { @handler.end_supports }
-    | start_supports RBRACE { @handler.end_supports }
-    ;
-  start_supports
-    : SUPPORTS_SYM supports_condition_root LBRACE {
-        @handler.start_supports val[1]
-      }
-    ;
-  supports_condition_root
-    : supports_negation { result = val.join('') }
-    | supports_conjunction_or_disjunction { result = val.join('') }
-    | supports_condition_in_parens { result = val.join('') }
-    ;
-  supports_condition
-    : supports_negation { result = val.join('') }
-    | supports_conjunction_or_disjunction { result = val.join('') }
-    | supports_condition_in_parens { result = val.join('') }
-    ;
-  supports_condition_in_parens
-    : LPAREN supports_condition RPAREN { result = val.join('') }
-    | supports_declaration_condition { result = val.join('') }
-    ;
-  supports_negation
-    : NOT supports_condition_in_parens { result = val.join('') }
-    ;
-  supports_conjunction_or_disjunction
-    : supports_conjunction
-    | supports_disjunction
-    ;
-  supports_conjunction
-    : supports_condition_in_parens AND supports_condition_in_parens { result = val.join('') }
-    | supports_conjunction_or_disjunction AND supports_condition_in_parens { result = val.join('') }
-    ;
-  supports_disjunction
-    : supports_condition_in_parens OR supports_condition_in_parens { result = val.join('') }
-    | supports_conjunction_or_disjunction OR supports_condition_in_parens { result = val.join('') }
-    ;
-  supports_declaration_condition
-    : LPAREN declaration_internal RPAREN { result = val.join('') }
-    | LPAREN S declaration_internal RPAREN { result = val.join('') }
-  ;
-  keyframes_rule
-    : start_keyframes_rule keyframes_blocks RBRACE
-    | start_keyframes_rule RBRACE
-    ;
-  start_keyframes_rule
-    : KEYFRAMES_SYM IDENT LBRACE {
-        @handler.start_keyframes_rule val[1]
-      }
-    ;
-  keyframes_blocks
-    : keyframes_block keyframes_blocks
-    | keyframes_block
-    ;
-  keyframes_block
-    : start_keyframes_block declarations RBRACE { @handler.end_keyframes_block }
-    | start_keyframes_block RBRACE { @handler.end_keyframes_block }
-    ;
-  start_keyframes_block
-    : keyframes_selectors LBRACE {
-        @handler.start_keyframes_block val[0]
-      }
-    ;
-  keyframes_selectors
-    | keyframes_selector COMMA keyframes_selectors {
-         result = val[0] + ', ' + val[2]
-      }
-    | keyframes_selector
-    ;
-  keyframes_selector
-    : IDENT
-    | PERCENTAGE { result = val[0].strip }
-    ;
-  fontface_rule
-    : start_fontface_rule declarations RBRACE { @handler.end_fontface_rule }
-    | start_fontface_rule RBRACE { @handler.end_fontface_rule }
-    ;
-  start_fontface_rule
-    : FONTFACE_SYM LBRACE {
-        @handler.start_fontface_rule
-      }
-    ;
-  ruleset
-    : start_selector declarations RBRACE {
-        @handler.end_selector val.first
-      }
-    | start_selector RBRACE {
-        @handler.end_selector val.first
-      }
-    ;
-  empty_ruleset
-    : optional_space {
-        start = @handler.start_selector([])
-        @handler.end_selector(start)
-      }
-    ;
-  start_selector
-    : S start_selector { result = val.last }
-    | selectors LBRACE {
-        @handler.start_selector val.first
-      }
-    ;
-  selectors
-    : selector COMMA selectors
-      {
-        sel = Selector.new(val.first, {})
-        result = [sel].concat(val[2])
-      }
-    | selector
-      {
-        result = [Selector.new(val.first, {})]
-      }
-    ;
-  selector
-    : simple_selector combinator selector
-      {
-        val.flatten!
-        val[2].combinator = val.delete_at 1
-        result = val
-      }
-    | simple_selector
-    ;
-  combinator
-    : S       { result = :s }
-    | GREATER { result = :> }
-    | PLUS    { result = :+ }
-    | TILDE   { result = :~ }
-    ;
-  simple_selector
-    : element_name hcap {
-        selector = val.first
-        selector.additional_selectors = val.last
-        result = [selector]
-      }
-    | element_name { result = val }
-    | hcap
-      {
-        ss = Selectors::Simple.new nil, nil
-        ss.additional_selectors = val.flatten
-        result = [ss]
-      }
-    ;
-  simple_selectors
-    : simple_selector COMMA simple_selectors { result = [val[0], val[2]].flatten }
-    | simple_selector
-    ;
-  ident_with_namespace
-    : IDENT { result = [interpret_identifier(val[0]), nil] }
-    | IDENT '|' IDENT { result = [interpret_identifier(val[2]), interpret_identifier(val[0])] }
-    | '|' IDENT { result = [interpret_identifier(val[1]), nil] }
-    | STAR '|' IDENT { result = [interpret_identifier(val[2]), '*'] }
-    ;
-  element_name
-    : ident_with_namespace { result = Selectors::Type.new val.first[0], nil, val.first[1] }
-    | STAR { result = Selectors::Universal.new val.first }
-    | '|' STAR { result = Selectors::Universal.new val[1] }
-    | STAR '|' STAR { result = Selectors::Universal.new val[2], nil, val[0] }
-    | IDENT '|' STAR { result = Selectors::Universal.new val[2], nil, interpret_identifier(val[0]) }
-    ;
-  hcap
-    : hash        { result = val }
-    | class       { result = val }
-    | attrib      { result = val }
-    | pseudo      { result = val }
-    | hash hcap   { result = val.flatten }
-    | class hcap  { result = val.flatten }
-    | attrib hcap { result = val.flatten }
-    | pseudo hcap { result = val.flatten }
-    ;
-  hash
-    : HASH {
-        result = Selectors::Id.new interpret_identifier val.first.sub(/^#/, '')
-      }
-  class
-    : '.' IDENT {
-        result = Selectors::Class.new interpret_identifier val.last
-      }
-    ;
-  attrib
-    : LSQUARE ident_with_namespace EQUAL IDENT RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_identifier(val[3]),
-          Selectors::Attribute::EQUALS,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace EQUAL STRING RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_string(val[3]),
-          Selectors::Attribute::EQUALS,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace INCLUDES STRING RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_string(val[3]),
-          Selectors::Attribute::INCLUDES,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace INCLUDES IDENT RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_identifier(val[3]),
-          Selectors::Attribute::INCLUDES,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace DASHMATCH IDENT RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_identifier(val[3]),
-          Selectors::Attribute::DASHMATCH,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace DASHMATCH STRING RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_string(val[3]),
-          Selectors::Attribute::DASHMATCH,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace PREFIXMATCH IDENT RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_identifier(val[3]),
-          Selectors::Attribute::PREFIXMATCH,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace PREFIXMATCH STRING RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_string(val[3]),
-          Selectors::Attribute::PREFIXMATCH,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace SUFFIXMATCH IDENT RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_identifier(val[3]),
-          Selectors::Attribute::SUFFIXMATCH,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace SUFFIXMATCH STRING RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_string(val[3]),
-          Selectors::Attribute::SUFFIXMATCH,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace SUBSTRINGMATCH IDENT RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_identifier(val[3]),
-          Selectors::Attribute::SUBSTRINGMATCH,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace SUBSTRINGMATCH STRING RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          interpret_string(val[3]),
-          Selectors::Attribute::SUBSTRINGMATCH,
-          val[1][1]
-        )
-      }
-    | LSQUARE ident_with_namespace RSQUARE {
-        result = Selectors::Attribute.new(
-          val[1][0],
-          nil,
-          Selectors::Attribute::SET,
-          val[1][1]
-        )
-      }
-    ;
-  pseudo
-    : COLON IDENT {
-        result = Selectors::pseudo interpret_identifier(val[1])
-      }
-    | COLON COLON IDENT {
-        result = Selectors::PseudoElement.new(
-          interpret_identifier(val[2])
-        )
-      }
-    | COLON FUNCTION RPAREN {
-        result = Selectors::PseudoClass.new(
-          interpret_identifier(val[1].sub(/\($/, '')),
-          ''
-        )
-      }
-    | COLON FUNCTION IDENT RPAREN {
-        result = Selectors::PseudoClass.new(
-          interpret_identifier(val[1].sub(/\($/, '')),
-          interpret_identifier(val[2])
-        )
-      }
-    | COLON NOT_PSEUDO_CLASS simple_selector RPAREN {
-        result = Selectors::PseudoClass.new(
-          'not',
-          val[2].first.to_s
-        )
-      }
-    | COLON NTH_PSEUDO_CLASS {
-        result = Selectors::PseudoClass.new(
-          interpret_identifier(val[1].sub(/\(.*/, '')),
-          interpret_identifier(val[1].sub(/.*\(/, '').sub(/\).*/, ''))
-        )
-      }
-    | COLON MATCHES_PSEUDO_CLASS simple_selectors RPAREN {
-        result = Selectors::PseudoClass.new(
-          val[1].split('(').first.strip,
-          val[2].join(', ')
-        )
-      }
-    | COLON MOZ_PSEUDO_ELEMENT optional_space any_number_of_idents optional_space RPAREN {
-        result = Selectors::PseudoElement.new(
-          interpret_identifier(val[1].sub(/\($/, ''))
-        )
-      }
-    | COLON COLON MOZ_PSEUDO_ELEMENT optional_space any_number_of_idents optional_space RPAREN {
-        result = Selectors::PseudoElement.new(
-          interpret_identifier(val[2].sub(/\($/, ''))
-        )
-      }
-    ;
-  any_number_of_idents
-    :
-    | multiple_idents
-    ;
-  multiple_idents
-    : IDENT
-    | IDENT COMMA multiple_idents
-    ;
-  # declarations can be separated by one *or more* semicolons. semi-colons at the start or end of a ruleset are also allowed
-  one_or_more_semis
-    : SEMI
-    | SEMI one_or_more_semis
-    ;
-  declarations
-    : declaration one_or_more_semis declarations
-    | one_or_more_semis declarations
-    | declaration one_or_more_semis
-    | declaration
-    | one_or_more_semis
-    ;
-  declaration
-    : declaration_internal { @handler.property val.first }
-    ;
-  declaration_internal
-    : property COLON expr prio
-      { result = Declaration.new(val.first, val[2], val[3]) }
-    | property COLON S expr prio
-      { result = Declaration.new(val.first, val[3], val[4]) }
-    | property S COLON expr prio
-      { result = Declaration.new(val.first, val[3], val[4]) }
-    | property S COLON S expr prio
-      { result = Declaration.new(val.first, val[4], val[5]) }
-    ;
-  prio
-    : IMPORTANT_SYM { result = true }
-    |               { result = false }
-    ;
-  property
-    : IDENT { result = interpret_identifier val[0] }
-    | STAR IDENT { result = interpret_identifier val.join }
-    | VARIABLE_NAME { result = interpret_identifier val[0] }
-    ;
-  operator
-    : COMMA
-    | SLASH
-    | EQUAL
-    ;
-  expr
-    : term operator expr {
-        result = [val.first, val.last].flatten
-        val.last.first.operator = val[1]
-      }
-    | term expr { result = val.flatten }
-    | term      { result = val }
-    ;
-  term
-    : ident
-    | ratio
-    | numeric
-    | string
-    | uri
-    | hexcolor
-    | calc
-    | function
-    | resolution
-    | VARIABLE_NAME
-    | uranges
-    ;
-  function
-    : function S { result = val.first }
-    | FUNCTION expr RPAREN {
-        name = interpret_identifier val.first.sub(/\($/, '')
-        if name == 'rgb'
-          result = Terms::Rgb.new(*val[1])
-        else
-          result = Terms::Function.new name, val[1]
-        end
-      }
-    | FUNCTION RPAREN {
-        name = interpret_identifier val.first.sub(/\($/, '')
-        result = Terms::Function.new name
-      }
-    ;
-  function_no_quote
-    : function_no_quote S { result = val.first }
-    | FUNCTION_NO_QUOTE {
-        parts = val.first.split('(')
-        name = interpret_identifier parts.first
-        result = Terms::Function.new(name, [Terms::String.new(interpret_string_no_quote(parts.last))])
-      }
-    ;
-  uranges
-    : UNICODE_RANGE COMMA uranges
-    | UNICODE_RANGE
-    ;
-  calc
-    : CALC_SYM calc_sum RPAREN optional_space {
-       result = Terms::Math.new(val.first.split('(').first, val[1])
-      }
-    ;
-  # plus and minus are supposed to have whitespace around them, per http://dev.w3.org/csswg/css-values/#calc-syntax, but the numbers are eating trailing whitespace, so we inject it back in
-  calc_sum
-    : calc_product
-    | calc_product PLUS calc_sum { val.insert(1, ' '); result = val.join('') }
-    | calc_product MINUS calc_sum { val.insert(1, ' '); result = val.join('') }
-    ;
-  calc_product
-    : calc_value
-    | calc_value optional_space STAR calc_value { result = val.join('') }
-    | calc_value optional_space SLASH calc_value { result = val.join('') }
-    ;
-  calc_value
-    : numeric { result = val.join('') }
-    | function { result = val.join('') } # for var() variable references
-    | LPAREN calc_sum RPAREN { result = val.join('') }
-    ;
-  hexcolor
-    : hexcolor S { result = val.first }
-    | HASH { result = Terms::Hash.new val.first.sub(/^#/, '') }
-    ;
-  uri
-    : uri S { result = val.first }
-    | URI { result = Terms::URI.new interpret_uri val.first }
-    ;
-  string
-    : string S { result = val.first }
-    | STRING { result = Terms::String.new interpret_string val.first }
-    ;
-  numeric
-    : unary_operator numeric {
-        result = val[1]
-        val[1].unary_operator = val.first
-      }
-    | NUMBER {
-        result = Terms::Number.new numeric val.first
-      }
-    | PERCENTAGE {
-        result = Terms::Number.new numeric(val.first), nil, '%'
-      }
-    | LENGTH {
-        unit    = val.first.gsub(/[\s\d.]/, '')
-        result = Terms::Number.new numeric(val.first), nil, unit
-      }
-    | ANGLE {
-        unit    = val.first.gsub(/[\s\d.]/, '')
-        result = Terms::Number.new numeric(val.first), nil, unit
-      }
-    | TIME {
-        unit    = val.first.gsub(/[\s\d.]/, '')
-        result = Terms::Number.new numeric(val.first), nil, unit
-      }
-    | FREQ {
-        unit    = val.first.gsub(/[\s\d.]/, '')
-        result = Terms::Number.new numeric(val.first), nil, unit
-      }
-    ;
-  ratio
-    : RATIO {
-        result = Terms::Ratio.new(val[0], val[1])
-      }
-    ;
-  unary_operator
-    : MINUS { result = :minus }
-    | PLUS  { result = :plus }
-    ;
-  ident
-    : ident S { result = val.first }
-    | IDENT { result = Terms::Ident.new interpret_identifier val.first }
-    ;
-
----- inner
-
-def numeric thing
-  thing = thing.gsub(/[^\d.]/, '')
-  Integer(thing) rescue Float(thing)
-end
-
-def interpret_identifier s
-  interpret_escapes s
-end
-
-def interpret_uri s
-  interpret_escapes s.match(/^url\((.*)\)$/mui)[1].strip.match(/^(['"]?)((?:\\.|.)*)\1$/mu)[2]
-end
-
-def interpret_string_no_quote s
-  interpret_escapes s.match(/^(.*)\)$/mu)[1].strip.match(/^(['"]?)((?:\\.|.)*)\1$/mu)[2]
-end
-
-def interpret_string s
-  interpret_escapes s.match(/^(['"])((?:\\.|.)*)\1$/mu)[2]
-end
-
-def interpret_escapes s
-  token_exp = /\\(?:([0-9a-fA-F]{1,6}(?:\r\n|\s)?)|(.))/mu
-  return s.gsub(token_exp) do |escape_sequence|
-    if !$1.nil?
-      code = $1.chomp.to_i 16
-      code = 0xFFFD if code > 0x10FFFF
-      next [code].pack('U')
-    end
-    next '' if $2 == "\n"
-    next $2
-  end
-end
-
-# override racc's on_error so we can have context in our error messages
-def on_error(t, val, vstack)
-  errcontext = (@ss.pre_match[-10..-1] || @ss.pre_match) +
-                @ss.matched + @ss.post_match[0..9]
-  line_number = @ss.pre_match.lines.count
-  raise ParseError, sprintf("parse error on value %s (%s) " +
-                            "on line %s around \"%s\"",
-                            val.inspect, token_to_str(t) || '?',
-                            line_number, errcontext)
-end
-
-def before_pos(val)
-  # don't include leading whitespace
-  return current_pos - val.last.length + val.last[/\A\s*/].size
-end
-
-def after_pos(val)
-  # don't include trailing whitespace
-  return current_pos - val.last[/\s*\z/].size
-end
-
-# charpos will work with multibyte strings but is not available until ruby 2
-def current_pos
-  @ss.respond_to?('charpos') ? @ss.charpos : @ss.pos
-end