crass 1.0.3 → 1.0.6

data/test/shared/parse_rules.rb

@@ -1,463 +0,0 @@
-# encoding: utf-8
-
-# Includes tests based on Simon Sapin's CSS parsing tests:
-# https://github.com/SimonSapin/css-parsing-tests/
-
-shared_tests_for 'parsing a list of rules' do
-  it 'should parse an empty stylesheet' do
-    assert_equal([], parse(''))
-    assert_equal([{:node=>:error, :value=>"invalid"}], parse('foo'))
-    assert_equal([{:node=>:error, :value=>"invalid"}], parse('foo 4'))
-  end
-
-  describe 'should parse an at-rule' do
-    describe 'without a block' do
-      it 'without a prelude' do
-        tree = parse('@foo')
-
-        assert_equal([
-          {:node=>:at_rule,
-            :name=>"foo",
-            :prelude=>[],
-            :tokens=>[{:node=>:at_keyword, :pos=>0, :raw=>"@foo", :value=>"foo"}]}
-        ], tree)
-      end
-
-      it 'with a prelude followed by a comment' do
-        tree = parse("@foo bar; \t/* comment */")
-
-        assert_equal([
-          {:node=>:at_rule,
-            :name=>"foo",
-            :prelude=>
-             [{:node=>:whitespace, :pos=>4, :raw=>" "},
-              {:node=>:ident, :pos=>5, :raw=>"bar", :value=>"bar"}],
-            :tokens=>
-             [{:node=>:at_keyword, :pos=>0, :raw=>"@foo", :value=>"foo"},
-              {:node=>:whitespace, :pos=>4, :raw=>" "},
-              {:node=>:ident, :pos=>5, :raw=>"bar", :value=>"bar"},
-              {:node=>:semicolon, :pos=>8, :raw=>";"}]},
-           {:node=>:whitespace, :pos=>9, :raw=>" \t"}
-        ], tree)
-      end
-
-      it 'with a prelude followed by a comment, when :preserve_comments == true' do
-        options = {:preserve_comments => true}
-        tree    = parse("@foo bar; \t/* comment */", options)
-
-        assert_equal([
-          {:node=>:at_rule,
-            :name=>"foo",
-            :prelude=>
-             [{:node=>:whitespace, :pos=>4, :raw=>" "},
-              {:node=>:ident, :pos=>5, :raw=>"bar", :value=>"bar"}],
-            :tokens=>
-             [{:node=>:at_keyword, :pos=>0, :raw=>"@foo", :value=>"foo"},
-              {:node=>:whitespace, :pos=>4, :raw=>" "},
-              {:node=>:ident, :pos=>5, :raw=>"bar", :value=>"bar"},
-              {:node=>:semicolon, :pos=>8, :raw=>";"}]},
-          {:node=>:whitespace, :pos=>9, :raw=>" \t"},
-          {:node=>:comment, :pos=>11, :raw=>"/* comment */", :value=>" comment "}
-        ], tree)
-      end
-
-      it 'with a prelude containing a simple block' do
-        tree = parse("@foo [ bar")
-
-        assert_equal([
-          {:node=>:at_rule,
-            :name=>"foo",
-            :prelude=>
-             [{:node=>:whitespace, :pos=>4, :raw=>" "},
-              {:node=>:simple_block,
-               :start=>"[",
-               :end=>"]",
-               :value=>
-                [{:node=>:whitespace, :pos=>6, :raw=>" "},
-                 {:node=>:ident, :pos=>7, :raw=>"bar", :value=>"bar"}],
-               :tokens=>
-                [{:node=>:"[", :pos=>5, :raw=>"["},
-                 {:node=>:whitespace, :pos=>6, :raw=>" "},
-                 {:node=>:ident, :pos=>7, :raw=>"bar", :value=>"bar"}]}],
-            :tokens=>
-             [{:node=>:at_keyword, :pos=>0, :raw=>"@foo", :value=>"foo"},
-              {:node=>:whitespace, :pos=>4, :raw=>" "},
-              {:node=>:"[", :pos=>5, :raw=>"["},
-              {:node=>:whitespace, :pos=>6, :raw=>" "},
-              {:node=>:ident, :pos=>7, :raw=>"bar", :value=>"bar"}]}
-        ], tree)
-      end
-    end
-
-    describe 'with a block' do
-      it 'unclosed' do
-        tree = parse("@foo { bar")
-
-        assert_equal([
-          {:node=>:at_rule,
-            :name=>"foo",
-            :prelude=>[{:node=>:whitespace, :pos=>4, :raw=>" "}],
-            :block=>
-             [{:node=>:whitespace, :pos=>6, :raw=>" "},
-              {:node=>:ident, :pos=>7, :raw=>"bar", :value=>"bar"}],
-            :tokens=>
-             [{:node=>:at_keyword, :pos=>0, :raw=>"@foo", :value=>"foo"},
-              {:node=>:whitespace, :pos=>4, :raw=>" "},
-              {:node=>:"{", :pos=>5, :raw=>"{"},
-              {:node=>:whitespace, :pos=>6, :raw=>" "},
-              {:node=>:ident, :pos=>7, :raw=>"bar", :value=>"bar"}]}
-        ], tree)
-      end
-
-      it 'unclosed, preceded by a comment' do
-        tree = parse(" /**/ @foo bar{[(4")
-
-        assert_equal([
-          {:node=>:whitespace, :pos=>0, :raw=>" "},
-          {:node=>:whitespace, :pos=>5, :raw=>" "},
-          {:node=>:at_rule,
-           :name=>"foo",
-           :prelude=>
-            [{:node=>:whitespace, :pos=>10, :raw=>" "},
-             {:node=>:ident, :pos=>11, :raw=>"bar", :value=>"bar"}],
-           :block=>
-            [{:node=>:simple_block,
-              :start=>"[",
-              :end=>"]",
-              :value=>
-               [{:node=>:simple_block,
-                 :start=>"(",
-                 :end=>")",
-                 :value=>
-                  [{:node=>:number,
-                    :pos=>17,
-                    :raw=>"4",
-                    :repr=>"4",
-                    :type=>:integer,
-                    :value=>4}],
-                 :tokens=>
-                  [{:node=>:"(", :pos=>16, :raw=>"("},
-                   {:node=>:number,
-                    :pos=>17,
-                    :raw=>"4",
-                    :repr=>"4",
-                    :type=>:integer,
-                    :value=>4}]}],
-              :tokens=>
-               [{:node=>:"[", :pos=>15, :raw=>"["},
-                {:node=>:"(", :pos=>16, :raw=>"("},
-                {:node=>:number,
-                 :pos=>17,
-                 :raw=>"4",
-                 :repr=>"4",
-                 :type=>:integer,
-                 :value=>4}]}],
-           :tokens=>
-            [{:node=>:at_keyword, :pos=>6, :raw=>"@foo", :value=>"foo"},
-             {:node=>:whitespace, :pos=>10, :raw=>" "},
-             {:node=>:ident, :pos=>11, :raw=>"bar", :value=>"bar"},
-             {:node=>:"{", :pos=>14, :raw=>"{"},
-             {:node=>:"[", :pos=>15, :raw=>"["},
-             {:node=>:"(", :pos=>16, :raw=>"("},
-             {:node=>:number,
-              :pos=>17,
-              :raw=>"4",
-              :repr=>"4",
-              :type=>:integer,
-              :value=>4}]}
-        ], tree)
-      end
-
-      it 'unclosed, preceded by a comment, when :preserve_comments == true' do
-        options = {:preserve_comments => true}
-        tree    = parse(" /**/ @foo bar{[(4", options)
-
-        assert_equal([
-          {:node=>:whitespace, :pos=>0, :raw=>" "},
-          {:node=>:comment, :pos=>1, :raw=>"/**/", :value=>""},
-          {:node=>:whitespace, :pos=>5, :raw=>" "},
-          {:node=>:at_rule,
-           :name=>"foo",
-           :prelude=>
-            [{:node=>:whitespace, :pos=>10, :raw=>" "},
-             {:node=>:ident, :pos=>11, :raw=>"bar", :value=>"bar"}],
-           :block=>
-            [{:node=>:simple_block,
-              :start=>"[",
-              :end=>"]",
-              :value=>
-               [{:node=>:simple_block,
-                 :start=>"(",
-                 :end=>")",
-                 :value=>
-                  [{:node=>:number,
-                    :pos=>17,
-                    :raw=>"4",
-                    :repr=>"4",
-                    :type=>:integer,
-                    :value=>4}],
-                 :tokens=>
-                  [{:node=>:"(", :pos=>16, :raw=>"("},
-                   {:node=>:number,
-                    :pos=>17,
-                    :raw=>"4",
-                    :repr=>"4",
-                    :type=>:integer,
-                    :value=>4}]}],
-              :tokens=>
-               [{:node=>:"[", :pos=>15, :raw=>"["},
-                {:node=>:"(", :pos=>16, :raw=>"("},
-                {:node=>:number,
-                 :pos=>17,
-                 :raw=>"4",
-                 :repr=>"4",
-                 :type=>:integer,
-                 :value=>4}]}],
-           :tokens=>
-            [{:node=>:at_keyword, :pos=>6, :raw=>"@foo", :value=>"foo"},
-             {:node=>:whitespace, :pos=>10, :raw=>" "},
-             {:node=>:ident, :pos=>11, :raw=>"bar", :value=>"bar"},
-             {:node=>:"{", :pos=>14, :raw=>"{"},
-             {:node=>:"[", :pos=>15, :raw=>"["},
-             {:node=>:"(", :pos=>16, :raw=>"("},
-             {:node=>:number,
-              :pos=>17,
-              :raw=>"4",
-              :repr=>"4",
-              :type=>:integer,
-              :value=>4}]}
-        ], tree)
-      end
-
-    end
-  end
-
-  describe 'should parse a style rule' do
-    it 'with preceding comment, selector, block, comment' do
-      tree = parse(" /**/ div > p { color: #aaa;  } /**/ ")
-
-      assert_equal([
-        {:node=>:whitespace, :pos=>0, :raw=>" "},
-        {:node=>:whitespace, :pos=>5, :raw=>" "},
-        {:node=>:style_rule,
-         :selector=>
-          {:node=>:selector,
-           :value=>"div > p",
-           :tokens=>
-            [{:node=>:ident, :pos=>6, :raw=>"div", :value=>"div"},
-             {:node=>:whitespace, :pos=>9, :raw=>" "},
-             {:node=>:delim, :pos=>10, :raw=>">", :value=>">"},
-             {:node=>:whitespace, :pos=>11, :raw=>" "},
-             {:node=>:ident, :pos=>12, :raw=>"p", :value=>"p"},
-             {:node=>:whitespace, :pos=>13, :raw=>" "}]},
-         :children=>
-          [{:node=>:whitespace, :pos=>15, :raw=>" "},
-           {:node=>:property,
-            :name=>"color",
-            :value=>"#aaa",
-            :children=>
-             [{:node=>:whitespace, :pos=>22, :raw=>" "},
-              {:node=>:hash, :pos=>23, :raw=>"#aaa", :type=>:id, :value=>"aaa"}],
-            :important=>false,
-            :tokens=>
-             [{:node=>:ident, :pos=>16, :raw=>"color", :value=>"color"},
-              {:node=>:colon, :pos=>21, :raw=>":"},
-              {:node=>:whitespace, :pos=>22, :raw=>" "},
-              {:node=>:hash, :pos=>23, :raw=>"#aaa", :type=>:id, :value=>"aaa"}]},
-           {:node=>:semicolon, :pos=>27, :raw=>";"},
-           {:node=>:whitespace, :pos=>28, :raw=>"  "}]},
-        {:node=>:whitespace, :pos=>31, :raw=>" "},
-        {:node=>:whitespace, :pos=>36, :raw=>" "}
-      ], tree)
-    end
-
-    it 'with preceding comment, selector, block, comment, when :preserve_comments == true' do
-      options = {:preserve_comments => true}
-      tree    = parse(" /**/ div > p { color: #aaa;  } /**/ ", options)
-
-      assert_equal([
-        {:node=>:whitespace, :pos=>0, :raw=>" "},
-        {:node=>:comment, :pos=>1, :raw=>"/**/", :value=>""},
-        {:node=>:whitespace, :pos=>5, :raw=>" "},
-        {:node=>:style_rule,
-         :selector=>
-          {:node=>:selector,
-           :value=>"div > p",
-           :tokens=>
-            [{:node=>:ident, :pos=>6, :raw=>"div", :value=>"div"},
-             {:node=>:whitespace, :pos=>9, :raw=>" "},
-             {:node=>:delim, :pos=>10, :raw=>">", :value=>">"},
-             {:node=>:whitespace, :pos=>11, :raw=>" "},
-             {:node=>:ident, :pos=>12, :raw=>"p", :value=>"p"},
-             {:node=>:whitespace, :pos=>13, :raw=>" "}]},
-         :children=>
-          [{:node=>:whitespace, :pos=>15, :raw=>" "},
-           {:node=>:property,
-            :name=>"color",
-            :value=>"#aaa",
-            :children=>
-             [{:node=>:whitespace, :pos=>22, :raw=>" "},
-              {:node=>:hash, :pos=>23, :raw=>"#aaa", :type=>:id, :value=>"aaa"}],
-            :important=>false,
-            :tokens=>
-             [{:node=>:ident, :pos=>16, :raw=>"color", :value=>"color"},
-              {:node=>:colon, :pos=>21, :raw=>":"},
-              {:node=>:whitespace, :pos=>22, :raw=>" "},
-              {:node=>:hash, :pos=>23, :raw=>"#aaa", :type=>:id, :value=>"aaa"}]},
-           {:node=>:semicolon, :pos=>27, :raw=>";"},
-           {:node=>:whitespace, :pos=>28, :raw=>"  "}]},
-        {:node=>:whitespace, :pos=>31, :raw=>" "},
-        {:node=>:comment, :pos=>32, :raw=>"/**/", :value=>""},
-        {:node=>:whitespace, :pos=>36, :raw=>" "}
-      ], tree)
-    end
-  end
-
-  it 'should parse property values containing functions' do
-    tree = parse("p:before { content: a\\ttr(data-foo) \" \"; }")
-
-    assert_equal([
-      {:node=>:style_rule,
-        :selector=>
-         {:node=>:selector,
-          :value=>"p:before",
-          :tokens=>
-           [{:node=>:ident, :pos=>0, :raw=>"p", :value=>"p"},
-            {:node=>:colon, :pos=>1, :raw=>":"},
-            {:node=>:ident, :pos=>2, :raw=>"before", :value=>"before"},
-            {:node=>:whitespace, :pos=>8, :raw=>" "}]},
-        :children=>
-         [{:node=>:whitespace, :pos=>10, :raw=>" "},
-          {:node=>:property,
-           :name=>"content",
-           :value=>"attr(data-foo) \" \"",
-           :children=>
-            [{:node=>:whitespace, :pos=>19, :raw=>" "},
-             {:node=>:function,
-              :name=>"attr",
-              :value=>
-               [{:node=>:ident, :pos=>26, :raw=>"data-foo", :value=>"data-foo"}],
-              :tokens=>
-               [{:node=>:function, :pos=>20, :raw=>"a\\ttr(", :value=>"attr"},
-                {:node=>:ident, :pos=>26, :raw=>"data-foo", :value=>"data-foo"},
-                {:node=>:")", :pos=>34, :raw=>")"}]},
-             {:node=>:whitespace, :pos=>35, :raw=>" "},
-             {:node=>:string, :pos=>36, :raw=>"\" \"", :value=>" "}],
-           :important=>false,
-           :tokens=>
-            [{:node=>:ident, :pos=>11, :raw=>"content", :value=>"content"},
-             {:node=>:colon, :pos=>18, :raw=>":"},
-             {:node=>:whitespace, :pos=>19, :raw=>" "},
-             {:node=>:function,
-              :name=>"attr",
-              :value=>
-               [{:node=>:ident, :pos=>26, :raw=>"data-foo", :value=>"data-foo"}],
-              :tokens=>
-               [{:node=>:function, :pos=>20, :raw=>"a\\ttr(", :value=>"attr"},
-                {:node=>:ident, :pos=>26, :raw=>"data-foo", :value=>"data-foo"},
-                {:node=>:")", :pos=>34, :raw=>")"}]},
-             {:node=>:whitespace, :pos=>35, :raw=>" "},
-             {:node=>:string, :pos=>36, :raw=>"\" \"", :value=>" "}]},
-          {:node=>:semicolon, :pos=>39, :raw=>";"},
-          {:node=>:whitespace, :pos=>40, :raw=>" "}]}
-    ], tree)
-  end
-
-  it 'should parse property values containing nested functions' do
-    tree = parse("div { width: e\\78 pression(alert(1)); }")
-
-    assert_equal([
-      {:node=>:style_rule,
-        :selector=>
-         {:node=>:selector,
-          :value=>"div",
-          :tokens=>
-           [{:node=>:ident, :pos=>0, :raw=>"div", :value=>"div"},
-            {:node=>:whitespace, :pos=>3, :raw=>" "}]},
-        :children=>
-         [{:node=>:whitespace, :pos=>5, :raw=>" "},
-          {:node=>:property,
-           :name=>"width",
-           :value=>"expression(alert(1))",
-           :children=>
-            [{:node=>:whitespace, :pos=>12, :raw=>" "},
-             {:node=>:function,
-              :name=>"expression",
-              :value=>
-               [{:node=>:function,
-                 :name=>"alert",
-                 :value=>
-                  [{:node=>:number,
-                    :pos=>33,
-                    :raw=>"1",
-                    :repr=>"1",
-                    :type=>:integer,
-                    :value=>1}],
-                 :tokens=>
-                  [{:node=>:function, :pos=>27, :raw=>"alert(", :value=>"alert"},
-                   {:node=>:number,
-                    :pos=>33,
-                    :raw=>"1",
-                    :repr=>"1",
-                    :type=>:integer,
-                    :value=>1},
-                   {:node=>:")", :pos=>34, :raw=>")"}]}],
-              :tokens=>
-               [{:node=>:function,
-                 :pos=>13,
-                 :raw=>"e\\78 pression(",
-                 :value=>"expression"},
-                {:node=>:function, :pos=>27, :raw=>"alert(", :value=>"alert"},
-                {:node=>:number,
-                 :pos=>33,
-                 :raw=>"1",
-                 :repr=>"1",
-                 :type=>:integer,
-                 :value=>1},
-                {:node=>:")", :pos=>34, :raw=>")"},
-                {:node=>:")", :pos=>35, :raw=>")"}]}],
-           :important=>false,
-           :tokens=>
-            [{:node=>:ident, :pos=>6, :raw=>"width", :value=>"width"},
-             {:node=>:colon, :pos=>11, :raw=>":"},
-             {:node=>:whitespace, :pos=>12, :raw=>" "},
-             {:node=>:function,
-              :name=>"expression",
-              :value=>
-               [{:node=>:function,
-                 :name=>"alert",
-                 :value=>
-                  [{:node=>:number,
-                    :pos=>33,
-                    :raw=>"1",
-                    :repr=>"1",
-                    :type=>:integer,
-                    :value=>1}],
-                 :tokens=>
-                  [{:node=>:function, :pos=>27, :raw=>"alert(", :value=>"alert"},
-                   {:node=>:number,
-                    :pos=>33,
-                    :raw=>"1",
-                    :repr=>"1",
-                    :type=>:integer,
-                    :value=>1},
-                   {:node=>:")", :pos=>34, :raw=>")"}]}],
-              :tokens=>
-               [{:node=>:function,
-                 :pos=>13,
-                 :raw=>"e\\78 pression(",
-                 :value=>"expression"},
-                {:node=>:function, :pos=>27, :raw=>"alert(", :value=>"alert"},
-                {:node=>:number,
-                 :pos=>33,
-                 :raw=>"1",
-                 :repr=>"1",
-                 :type=>:integer,
-                 :value=>1},
-                {:node=>:")", :pos=>34, :raw=>")"},
-                {:node=>:")", :pos=>35, :raw=>")"}]}]},
-          {:node=>:semicolon, :pos=>36, :raw=>";"},
-          {:node=>:whitespace, :pos=>37, :raw=>" "}]}
-    ], tree)
-  end
-end

data/test/support/common.rb

@@ -1,170 +0,0 @@
-# encoding: utf-8
-gem 'minitest'
-require 'minitest/autorun'
-
-require_relative '../../lib/crass'
-
-CP = Crass::Parser
-CT = Crass::Tokenizer
-
-# Hack shared test support into MiniTest.
-MiniTest::Spec.class_eval do
-  def self.shared_tests
-    @shared_tests ||= {}
-  end
-end
-
-module MiniTest::Spec::SharedTests
-  def behaves_like(desc)
-    self.instance_eval(&MiniTest::Spec.shared_tests[desc])
-  end
-
-  def shared_tests_for(desc, &block)
-    MiniTest::Spec.shared_tests[desc] = block
-  end
-end
-
-Object.class_eval { include MiniTest::Spec::SharedTests }
-
-# Custom assertions and helpers.
-def assert_tokens(input, actual, offset = 0, options = {})
-  actual = [actual] unless actual.is_a?(Array)
-  tokens = tokenize(input, offset, options)
-
-  assert_equal tokens, actual
-end
-
-def reposition_tokens(tokens, offset)
-  tokens.each {|token| token[:pos] += offset }
-  tokens
-end
-
-def tokenize(input, offset = 0, options = {})
-  tokens = CT.tokenize(input, options)
-  reposition_tokens(tokens, offset) unless offset == 0
-  tokens
-end
-
-# Translates Crass tokens into a form that can be compared to the expected
-# values of Simon Sapin's CSS parsing tests.
-#
-# https://github.com/SimonSapin/css-parsing-tests/#result-representation
-def translate_tokens(tokens)
-  return [] if tokens.nil?
-
-  translated = []
-  tokens     = [tokens] unless tokens.is_a?(Array)
-
-  tokens.each do |token|
-    value = token[:value]
-
-    result = case token[:node]
-
-    # Rules and declarations.
-    when :at_rule
-      ['at-rule', token[:name], translate_tokens(token[:prelude]), token[:block] ? translate_tokens(token[:block]) : nil]
-
-    when :qualified_rule
-      ['qualified rule', translate_tokens(token[:prelude]), token[:block] ? translate_tokens(token[:block]) : nil]
-
-    when :declaration
-      ['declaration', token[:name], translate_tokens(value), token[:important]]
-
-    # Component values.
-    when :at_keyword
-      ['at-keyword', value]
-
-    when :bad_string
-      ['error', 'bad-string']
-
-    when :bad_url
-      ['error', 'bad-url']
-
-    when :cdc
-      '-->'
-
-    when :cdo
-      '<!--'
-
-    when :colon
-      ':'
-
-    when :column
-      '||'
-
-    when :comma
-      ','
-
-    when :dash_match
-      '|='
-
-    when :delim
-      value
-
-    when :dimension
-      ['dimension', token[:repr], value, token[:type].to_s, token[:unit]]
-
-    when :error
-      ['error', value]
-
-    when :function
-      if token[:name]
-        ['function', token[:name]].concat(translate_tokens(value))
-      else
-        ['function', value]
-      end
-
-    when :hash
-      ['hash', value, token[:type].to_s]
-
-    when :ident
-      ['ident', value]
-
-    when :include_match
-      '~='
-
-    when :number
-      ['number', token[:repr], value, token[:type].to_s]
-
-    when :percentage
-      ['percentage', token[:repr], value, token[:type].to_s]
-
-    when :prefix_match
-      '^='
-
-    when :semicolon
-      ';'
-
-    when :simple_block
-      [token[:start] + token[:end]].concat(translate_tokens(value))
-
-    when :string
-      ['string', value]
-
-    when :substring_match
-      '*='
-
-    when :suffix_match
-      '$='
-
-    when :unicode_range
-      ['unicode-range', token[:start], token[:end]]
-
-    when :url
-      ['url', value]
-
-    when :whitespace
-      ' '
-
-    when :'}', :']', :')'
-      ['error', token[:node].to_s]
-
-    else
-      nil
-    end
-
-    translated << result unless result.nil?
-  end
-
-  translated
-end