crass 0.0.2 → 0.1.0

data/test/test_parse_rules.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+# Includes tests based on Simon Sapin's CSS parsing tests:
+# https://github.com/SimonSapin/css-parsing-tests/
+
+require_relative 'support/common'
+require_relative 'shared/parse_rules'
+
+describe 'Crass::Parser' do
+  make_my_diffs_pretty!
+  parallelize_me!
+
+  describe '#parse_rules' do
+    def parse(*args)
+      CP.parse_rules(*args)
+    end
+
+    behaves_like 'parsing a list of rules'
+
+    it 'with CDO/CDC before rule' do
+      tree = parse(" <!-- --> {")
+
+      assert_equal(2, tree.size)
+      assert_tokens(" ", tree[0])
+
+      rule = tree[1]
+      assert_equal(:style_rule, rule[:node])
+      assert_equal([], rule[:children])
+
+      selector = rule[:selector]
+      assert_equal(:selector, selector[:node])
+      assert_equal("<!-- -->", selector[:value])
+      assert_tokens("<!-- --> ", selector[:tokens], 1)
+    end
+
+    it 'followed by CDC' do
+      # TODO: This should be a parse error.
+      tree = parse("div {} -->")
+
+      assert_equal(2, tree.size)
+
+      rule = tree[0]
+      assert_equal(:style_rule, rule[:node])
+      assert_equal([], rule[:children])
+
+      selector = rule[:selector]
+      assert_equal(:selector, selector[:node])
+      assert_equal("div", selector[:value])
+      assert_tokens("div ", selector[:tokens])
+
+      assert_tokens(" ", tree[1], 6)
+    end
+
+    it 'should parse the block of an at-rule' do
+      rule = CP.parse_stylesheet("@media (max-width: 400px) {.foo{color:#fff;}}")[0]
+      assert_equal(:at_rule, rule[:node])
+
+      style_rule = parse(rule[:block][:value])[0]
+      assert_equal(:style_rule, style_rule[:node])
+      assert_equal(".foo", style_rule[:selector][:value])
+      assert_equal(1, style_rule[:children].size)
+
+      prop = style_rule[:children][0]
+      assert_equal(:property, prop[:node])
+      assert_equal("color", prop[:name])
+      assert_equal("#fff", prop[:value])
+    end
+  end
+end

data/test/test_parse_stylesheet.rb

@@ -4,377 +4,53 @@
 # https://github.com/SimonSapin/css-parsing-tests/
 
 require_relative 'support/common'
+require_relative 'shared/parse_rules'
 
 describe 'Crass::Parser' do
-  describe '#parse_stylesheet' do
-    it 'should parse an empty stylesheet' do
-      assert_equal [], CP.parse_stylesheet('')
-      assert_equal [], CP.parse_stylesheet('foo')
-      assert_equal [], CP.parse_stylesheet('foo 4')
-    end
-
-    describe 'should parse an at-rule' do
-      describe 'without a block' do
-        it 'without a prelude' do
-          tree = CP.parse_stylesheet('@foo')
-          rule = tree[0]
-
-          assert_equal 1, tree.size
-          assert_equal :at_rule, rule[:node]
-          assert_equal "foo", rule[:name]
-          assert_equal [], rule[:prelude]
-          assert_tokens "@foo", rule[:tokens]
-        end
-
-        it 'with a prelude followed by a comment' do
-          tree = CP.parse_stylesheet("@foo bar; \t/* comment */")
-          rule = tree[0]
-
-          assert_equal 2, tree.size
-          assert_equal :at_rule, rule[:node]
-          assert_equal "foo", rule[:name]
-          assert_tokens " bar", rule[:prelude], 4
-          assert_tokens "@foo bar;", rule[:tokens]
-          assert_tokens " \t", tree[1], 9
-        end
-
-        it 'with a prelude followed by a comment, when :preserve_comments == true' do
-          options = {:preserve_comments => true}
-          tree    = CP.parse_stylesheet("@foo bar; \t/* comment */", options)
-          rule    = tree[0]
-
-          assert_equal 3, tree.size
-          assert_equal :at_rule, rule[:node]
-          assert_equal "foo", rule[:name]
-          assert_tokens " bar", rule[:prelude], 4, options
-          assert_tokens "@foo bar;", rule[:tokens], 0, options
-          assert_tokens " \t", tree[1], 9, options
-          assert_tokens "/* comment */", tree[2], 11, options
-        end
-
-        it 'with a prelude containing a simple block' do
-          tree = CP.parse_stylesheet("@foo [ bar")
-          rule = tree[0]
-
-          assert_equal 1, tree.size
-          assert_equal :at_rule, rule[:node]
-          assert_equal "foo", rule[:name]
-          assert_tokens "@foo [ bar", rule[:tokens]
-
-          prelude = rule[:prelude]
-          assert_equal 2, prelude.size
-          assert_tokens " ", prelude[0], 4
-
-          block = prelude[1]
-          assert_equal :simple_block, block[:node]
-          assert_equal "[", block[:start]
-          assert_equal "]", block[:end]
-          assert_tokens "[ bar", block[:tokens], 5
-          assert_tokens " bar", block[:value], 6
-        end
-      end
-
-      describe 'with a block' do
-        it 'unclosed' do
-          tree = CP.parse_stylesheet("@foo { bar")
-          rule = tree[0]
-
-          assert_equal 1, tree.size
-          assert_equal :at_rule, rule[:node]
-          assert_equal "foo", rule[:name]
-          assert_tokens " ", rule[:prelude], 4
-          assert_tokens "@foo { bar", rule[:tokens]
-
-          block = rule[:block]
-          assert_equal :simple_block, block[:node]
-          assert_equal "{", block[:start]
-          assert_equal "}", block[:end]
-          assert_tokens "{ bar", block[:tokens], 5
-          assert_tokens " bar", block[:value], 6
-        end
-
-        it 'unclosed, preceded by a comment' do
-          tree = CP.parse_stylesheet(" /**/ @foo bar{[(4")
-          rule = tree[2]
-
-          assert_equal 3, tree.size
-          assert_tokens " /**/ ", tree[0..1]
-          assert_equal :at_rule, rule[:node]
-          assert_equal "foo", rule[:name]
-          assert_tokens " bar", rule[:prelude], 10
-          assert_tokens "@foo bar{[(4", rule[:tokens], 6
-
-          block = rule[:block]
-          assert_equal :simple_block, block[:node]
-          assert_equal "{", block[:start]
-          assert_equal "}", block[:end]
-          assert_tokens "{[(4", block[:tokens], 14
-          assert_equal 1, block[:value].size
-
-          block = block[:value].first
-          assert_equal :simple_block, block[:node]
-          assert_equal "[", block[:start]
-          assert_equal "]", block[:end]
-          assert_tokens "[(4", block[:tokens], 15
-          assert_equal 1, block[:value].size
+  make_my_diffs_pretty!
+  parallelize_me!
 
-          block = block[:value].first
-          assert_equal :simple_block, block[:node]
-          assert_equal "(", block[:start]
-          assert_equal ")", block[:end]
-          assert_tokens "(4", block[:tokens], 16
-          assert_tokens "4", block[:value], 17
-        end
-
-        it 'unclosed, preceded by a comment, when :preserve_comments == true' do
-          options = {:preserve_comments => true}
-          tree    = CP.parse_stylesheet(" /**/ @foo bar{[(4", options)
-          rule    = tree[3]
-
-          assert_equal 4, tree.size
-          assert_tokens " /**/ ", tree[0..2], 0, options
-
-          assert_equal :at_rule, rule[:node]
-          assert_equal "foo", rule[:name]
-          assert_tokens " bar", rule[:prelude], 10, options
-          assert_tokens "@foo bar{[(4", rule[:tokens], 6, options
-
-          block = rule[:block]
-          assert_equal :simple_block, block[:node]
-          assert_equal "{", block[:start]
-          assert_equal "}", block[:end]
-          assert_tokens "{[(4", block[:tokens], 14, options
-          assert_equal 1, block[:value].size
-
-          block = block[:value].first
-          assert_equal :simple_block, block[:node]
-          assert_equal "[", block[:start]
-          assert_equal "]", block[:end]
-          assert_tokens "[(4", block[:tokens], 15, options
-          assert_equal 1, block[:value].size
-
-          block = block[:value].first
-          assert_equal :simple_block, block[:node]
-          assert_equal "(", block[:start]
-          assert_equal ")", block[:end]
-          assert_tokens "(4", block[:tokens], 16, options
-          assert_tokens "4", block[:value], 17, options
-        end
-
-      end
+  describe '#parse_stylesheet' do
+    def parse(*args)
+      CP.parse_stylesheet(*args)
     end
 
-    describe 'should parse a style rule' do
-      it 'with preceding comment, selector, block, comment' do
-        tree = CP.parse_stylesheet(" /**/ div > p { color: #aaa;  } /**/ ")
-
-        assert_equal 5, tree.size
-        assert_tokens " /**/ ", tree[0..1]
-        assert_tokens " /**/ ", tree[3..4], 31
+    behaves_like 'parsing a list of rules'
 
-        rule = tree[2]
-        assert_equal :style_rule, rule[:node]
+    it 'with CDO/CDC before rule' do
+      tree = parse(" <!-- --> {")
 
-        selector = rule[:selector]
-        assert_equal :selector, selector[:node]
-        assert_equal "div > p", selector[:value]
-        assert_tokens "div > p ", selector[:tokens], 6
+      assert_equal(4, tree.size)
 
-        children = rule[:children]
-        assert_equal 3, children.size
-        assert_tokens " ", children[0], 15
-        assert_tokens "  ", children[2], 28
-
-        property = children[1]
-        assert_equal :property, property[:node]
-        assert_equal "color", property[:name]
-        assert_equal "#aaa", property[:value]
-        assert_tokens "color: #aaa;", property[:tokens], 16
-      end
-
-      it 'with preceding comment, selector, block, comment, when :preserve_comments == true' do
-        options = {:preserve_comments => true}
-        tree    = CP.parse_stylesheet(" /**/ div > p { color: #aaa;  } /**/ ", options)
-
-        assert_equal 7, tree.size
-        assert_tokens " /**/ ", tree[0..2], 0, options
-        assert_tokens " /**/ ", tree[4..6], 31, options
-
-        rule = tree[3]
-        assert_equal :style_rule, rule[:node]
-
-        selector = rule[:selector]
-        assert_equal :selector, selector[:node]
-        assert_equal "div > p", selector[:value]
-        assert_tokens "div > p ", selector[:tokens], 6, options
-
-        children = rule[:children]
-        assert_equal 3, children.size
-        assert_tokens " ", children[0], 15, options
-        assert_tokens "  ", children[2], 28, options
-
-        property = children[1]
-        assert_equal :property, property[:node]
-        assert_equal "color", property[:name]
-        assert_equal "#aaa", property[:value]
-        assert_tokens "color: #aaa;", property[:tokens], 16, options
+      tree[0..2].each do |node|
+        assert_equal(:whitespace, node[:node])
       end
 
-      it 'unclosed, with preceding comment, no selector' do
-        tree = CP.parse_stylesheet(" /**/ { color: #aaa  ")
-
-        assert_equal 3, tree.size
-        assert_tokens " /**/ ", tree[0..1]
-
-        rule = tree[2]
-        assert_equal :style_rule, rule[:node]
-
-        selector = rule[:selector]
-        assert_equal :selector, selector[:node]
-        assert_equal "", selector[:value]
-        assert_equal [], selector[:tokens]
-
-        children = rule[:children]
-        assert_equal 2, children.size
-        assert_tokens " ", children[0], 7
-
-        property = children[1]
-        assert_equal :property, property[:node]
-        assert_equal "color", property[:name]
-        assert_equal "#aaa", property[:value]
-        assert_tokens "color: #aaa  ", property[:tokens], 8
-      end
-
-      it 'unclosed, with preceding comment, no selector, when :preserve_comments == true' do
-        options = {:preserve_comments => true}
-        tree    = CP.parse_stylesheet(" /**/ { color: #aaa  ", options)
-
-        assert_equal 4, tree.size
-        assert_tokens " /**/ ", tree[0..2], 0, options
-
-        rule = tree[3]
-        assert_equal :style_rule, rule[:node]
-
-        selector = rule[:selector]
-        assert_equal :selector, selector[:node]
-        assert_equal "", selector[:value]
-        assert_equal [], selector[:tokens]
-
-        children = rule[:children]
-        assert_equal 2, children.size
-        assert_tokens " ", children[0], 7, options
-
-        property = children[1]
-        assert_equal :property, property[:node]
-        assert_equal "color", property[:name]
-        assert_equal "#aaa", property[:value]
-        assert_tokens "color: #aaa  ", property[:tokens], 8, options
-      end
-
-      it 'with CDO/CDC before rule' do
-        tree = CP.parse_stylesheet(" <!-- --> {")
-
-        assert_equal 4, tree.size
-
-        tree[0..2].each do |node|
-          assert_equal :whitespace, node[:node]
-        end
-
-        rule = tree[3]
-        assert_equal :style_rule, rule[:node]
-        assert_equal [], rule[:children]
-
-        selector = rule[:selector]
-        assert_equal :selector, selector[:node]
-        assert_equal "", selector[:value]
-        assert_equal [], selector[:tokens]
-      end
-
-      it 'followed by CDC' do
-        tree = CP.parse_stylesheet("div {} -->")
-
-        assert_equal 2, tree.size
-
-        rule = tree[0]
-        assert_equal :style_rule, rule[:node]
-        assert_equal [], rule[:children]
-
-        selector = rule[:selector]
-        assert_equal :selector, selector[:node]
-        assert_equal "div", selector[:value]
-        assert_tokens "div ", selector[:tokens]
-
-        assert_tokens " ", tree[1], 6
-      end
-    end
-
-    it 'should parse multiple style rules' do
-      tree = CP.parse_stylesheet("div { color: #aaa; } p{}")
-
-      assert_equal 3, tree.size
-
-      rule = tree[0]
-      assert_equal :style_rule, rule[:node]
+      rule = tree[3]
+      assert_equal(:style_rule, rule[:node])
+      assert_equal([], rule[:children])
 
       selector = rule[:selector]
-      assert_equal :selector, selector[:node]
-      assert_equal "div", selector[:value]
-      assert_tokens "div ", selector[:tokens]
-
-      children = rule[:children]
-      assert_equal 3, children.size
-      assert_tokens " ", children[0], 5
-      assert_tokens " ", children[2], 18
-
-      prop = children[1]
-      assert_equal :property, prop[:node]
-      assert_equal "color", prop[:name]
-      assert_equal "#aaa", prop[:value]
-      assert_tokens "color: #aaa;", prop[:tokens], 6
-
-      assert_tokens " ", tree[1], 20
-
-      rule = tree[2]
-      assert_equal :style_rule, rule[:node]
-
-      selector = rule[:selector]
-      assert_equal :selector, selector[:node]
-      assert_equal "p", selector[:value]
-      assert_tokens "p", selector[:tokens], 21
+      assert_equal(:selector, selector[:node])
+      assert_equal("", selector[:value])
+      assert_equal([], selector[:tokens])
     end
 
-    it 'should ignore a block-less selector following a selector-less style rule' do
-      tree = CP.parse_stylesheet("{}a")
-      assert_equal 1, tree.size
-
-      rule = tree[0]
-      assert_equal :style_rule, rule[:node]
-      assert_equal [], rule[:children]
-
-      selector = rule[:selector]
-      assert_equal :selector, selector[:node]
-      assert_equal "", selector[:value]
-      assert_equal [], selector[:tokens]
-    end
+    it 'followed by CDC' do
+      tree = parse("div {} -->")
 
-    it 'should handle an at-rule following a selector-less style rule' do
-      tree = CP.parse_stylesheet("{}@a")
-      assert_equal 2, tree.size
+      assert_equal(2, tree.size)
 
       rule = tree[0]
-      assert_equal :style_rule, rule[:node]
-      assert_equal [], rule[:children]
+      assert_equal(:style_rule, rule[:node])
+      assert_equal([], rule[:children])
 
       selector = rule[:selector]
-      assert_equal :selector, selector[:node]
-      assert_equal "", selector[:value]
-      assert_equal [], selector[:tokens]
+      assert_equal(:selector, selector[:node])
+      assert_equal("div", selector[:value])
+      assert_tokens("div ", selector[:tokens])
 
-      rule = tree[1]
-      assert_equal :at_rule, rule[:node]
-      assert_equal "a", rule[:name]
-      assert_equal [], rule[:prelude]
-      assert_tokens "@a", rule[:tokens], 2
+      assert_tokens(" ", tree[1], 6)
     end
   end
 end