crass 0.0.2 → 0.1.0

data/lib/crass/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Crass
-  VERSION = '0.0.2'
+  VERSION = '0.1.0'
 end

data/test/shared/parse_rules.rb

@@ -0,0 +1,345 @@
+# 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([], parse('foo'))
+    assert_equal([], parse('foo 4'))
+  end
+
+  describe 'should parse an at-rule' do
+    describe 'without a block' do
+      it 'without a prelude' do
+        tree = parse('@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 = parse("@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    = parse("@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 = parse("@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 = parse("@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 = parse(" /**/ @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)
+
+        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    = parse(" /**/ @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
+  end
+
+  describe 'should parse a style rule' do
+    it 'with preceding comment, selector, block, comment' do
+      tree = parse(" /**/ div > p { color: #aaa;  } /**/ ")
+
+      assert_equal(5, tree.size)
+      assert_tokens(" /**/ ", tree[0..1])
+      assert_tokens(" /**/ ", tree[3..4], 31)
+
+      rule = tree[2]
+      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)
+
+      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_equal(false, property[:important])
+      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    = parse(" /**/ 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_equal(false, property[:important])
+      assert_tokens("color: #aaa;", property[:tokens], 16, options)
+    end
+
+    it 'unclosed, with preceding comment, no selector' do
+      tree = parse(" /**/ { 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_equal(false, property[:important])
+      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    = parse(" /**/ { 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_equal(false, property[:important])
+      assert_tokens("color: #aaa  ", property[:tokens], 8, options)
+    end
+  end
+
+  it 'should parse multiple style rules' do
+    tree = parse("div { color: #aaa; } p{}")
+
+    assert_equal(3, tree.size)
+
+    rule = tree[0]
+    assert_equal(:style_rule, rule[:node])
+
+    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_equal(false, prop[:important])
+    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)
+  end
+
+  it 'should ignore a block-less selector following a selector-less style rule' do
+    tree = parse("{}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 'should handle an at-rule following a selector-less style rule' do
+    tree = parse("{}@a")
+    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("", selector[:value])
+    assert_equal([], 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)
+  end
+end

data/test/support/common.rb

@@ -7,6 +7,26 @@ 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)

data/test/test_crass.rb

@@ -1,8 +1,23 @@
 # encoding: utf-8
 require_relative 'support/common'
 
-describe 'Crass.parse' do
-  it 'should call Crass::Parser.parse_stylesheet with input and options' do
+describe 'Crass' do
+  make_my_diffs_pretty!
+  parallelize_me!
+
+  it 'parse_properties() should call Crass::Parser.parse_properties' do
+    assert_equal(
+      CP.parse_properties("a:b; c:d 42!important;\n"),
+      Crass.parse_properties("a:b; c:d 42!important;\n")
+    )
+
+    assert_equal(
+      CP.parse_properties(";; /**/ ; ;", :preserve_comments => true),
+      Crass.parse_properties(";; /**/ ; ;", :preserve_comments => true)
+    )
+  end
+
+  it 'parse() should call Crass::Parser.parse_stylesheet' do
     assert_equal(
       CP.parse_stylesheet(" /**/ .foo {} #bar {}"),
       Crass.parse(" /**/ .foo {} #bar {}")

data/test/test_parse_properties.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+
+# Includes tests based on Simon Sapin's CSS parsing tests:
+# https://github.com/SimonSapin/css-parsing-tests/
+
+require_relative 'support/common'
+
+describe 'Crass::Parser' do
+  make_my_diffs_pretty!
+  parallelize_me!
+
+  describe '#parse_properties' do
+    def parse(*args)
+      CP.parse_properties(*args)
+    end
+
+    it 'should return an empty tree when given an empty string' do
+      assert_equal([], parse(""))
+    end
+
+    # Note: The next two tests verify augmented behavior that isn't defined in
+    # CSS Syntax Module Level 3.
+    it 'should include semicolon and whitespace tokens' do
+      assert_tokens(";; /**/ ; ;", parse(";; /**/ ; ;"))
+    end
+
+    it 'should include semicolon, whitespace, and comment tokens when :preserve_comments == true' do
+      tree = parse(";; /**/ ; ;", :preserve_comments => true)
+      assert_tokens(";; /**/ ; ;", tree, 0, :preserve_comments => true)
+    end
+
+    it 'should parse a list of declarations' do
+      tree = parse("a:b; c:d 42!important;\n")
+      assert_equal(4, tree.size)
+
+      prop = tree[0]
+      assert_equal(:property, prop[:node])
+      assert_equal("a", prop[:name])
+      assert_equal("b", prop[:value])
+      assert_equal(false, prop[:important])
+      assert_tokens("a:b;", prop[:tokens])
+
+      assert_tokens(" ", tree[1], 4)
+
+      prop = tree[2]
+      assert_equal(:property, prop[:node])
+      assert_equal("c", prop[:name])
+      assert_equal("d 42", prop[:value])
+      assert_equal(true, prop[:important])
+      assert_tokens("c:d 42!important;", prop[:tokens], 5)
+
+      assert_tokens("\n", tree[3], 22)
+    end
+
+    it 'should parse at-rules even though they may be invalid in the given context' do
+      tree = parse("@import 'foo.css'; a:b; @import 'bar.css'")
+      assert_equal(5, tree.size)
+
+      rule = tree[0]
+      assert_equal(:at_rule, rule[:node])
+      assert_equal("import", rule[:name])
+      assert_tokens(" 'foo.css'", rule[:prelude], 7)
+      assert_tokens("@import 'foo.css';", rule[:tokens])
+
+      assert_tokens(" ", tree[1], 18)
+
+      prop = tree[2]
+      assert_equal(:property, prop[:node])
+      assert_equal("a", prop[:name])
+      assert_equal("b", prop[:value])
+      assert_equal(false, prop[:important])
+      assert_tokens("a:b;", prop[:tokens], 19)
+
+      assert_tokens(" ", tree[3], 23)
+
+      rule = tree[4]
+      assert_equal(:at_rule, rule[:node])
+      assert_equal("import", rule[:name])
+      assert_tokens(" 'bar.css'", rule[:prelude], 31)
+      assert_tokens("@import 'bar.css'", rule[:tokens], 24)
+    end
+
+    it 'should not be fazed by extra semicolons or unclosed blocks' do
+      tree = parse("@media screen { div{;}} a:b;; @media print{div{")
+      assert_equal(6, tree.size)
+
+      rule = tree[0]
+      assert_equal(:at_rule, rule[:node])
+      assert_equal("media", rule[:name])
+      assert_tokens(" screen ", rule[:prelude], 6)
+      assert_tokens("@media screen { div{;}}", rule[:tokens])
+
+      block = rule[:block]
+      assert_equal(:simple_block, block[:node])
+      assert_equal("{", block[:start])
+      assert_equal("}", block[:end])
+      assert_tokens("{ div{;}}", block[:tokens], 14)
+
+      value = block[:value]
+      assert_equal(3, value.size)
+      assert_tokens(" div", value[0..1], 15)
+
+      block = value[2]
+      assert_equal(:simple_block, block[:node])
+      assert_equal("{", block[:start])
+      assert_equal("}", block[:end])
+      assert_tokens(";", block[:value], 20)
+      assert_tokens("{;}", block[:tokens], 19)
+
+      assert_tokens(" ", tree[1], 23)
+
+      prop = tree[2]
+      assert_equal(:property, prop[:node])
+      assert_equal("a", prop[:name])
+      assert_equal("b", prop[:value])
+      assert_equal(false, prop[:important])
+      assert_tokens("a:b;", prop[:tokens], 24)
+
+      assert_tokens("; ", tree[3..4], 28)
+
+      rule = tree[5]
+      assert_equal(:at_rule, rule[:node])
+      assert_equal("media", rule[:name])
+      assert_tokens(" print", rule[:prelude], 36)
+      assert_tokens("@media print{div{", rule[:tokens], 30)
+
+      block = rule[:block]
+      assert_equal(:simple_block, block[:node])
+      assert_equal("{", block[:start])
+      assert_equal("}", block[:end])
+      assert_tokens("{div{", block[:tokens], 42)
+
+      value = block[:value]
+      assert_equal(2, value.size)
+      assert_tokens("div", value[0], 43)
+
+      block = value[1]
+      assert_equal(:simple_block, block[:node])
+      assert_equal("{", block[:start])
+      assert_equal("}", block[:end])
+      assert_equal([], block[:value])
+      assert_tokens("{", block[:tokens], 46)
+    end
+
+    it 'should discard invalid nodes' do
+      tree = parse("@ media screen { div{;}} a:b;; @media print{div{")
+      assert_equal(3, tree.size)
+
+      assert_tokens("; ", tree[0..1], 29)
+
+      rule = tree[2]
+      assert_equal(:at_rule, rule[:node])
+      assert_equal("media", rule[:name])
+      assert_tokens(" print", rule[:prelude], 37)
+      assert_tokens("@media print{div{", rule[:tokens], 31)
+
+      block = rule[:block]
+      assert_equal(:simple_block, block[:node])
+      assert_equal("{", block[:start])
+      assert_equal("}", block[:end])
+      assert_tokens("{div{", block[:tokens], 43)
+
+      value = block[:value]
+      assert_equal(2, value.size)
+      assert_tokens("div", value[0], 44)
+
+      block = value[1]
+      assert_equal(:simple_block, block[:node])
+      assert_equal("{", block[:start])
+      assert_equal("}", block[:end])
+      assert_equal([], block[:value])
+      assert_tokens("{", block[:tokens], 47)
+    end
+  end
+end