crass 0.0.1 → 0.0.2

data/test/test_crass.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+require_relative 'support/common'
+
+describe 'Crass.parse' do
+  it 'should call Crass::Parser.parse_stylesheet with input and options' do
+    assert_equal(
+      CP.parse_stylesheet(" /**/ .foo {} #bar {}"),
+      Crass.parse(" /**/ .foo {} #bar {}")
+    )
+
+    assert_equal(
+      CP.parse_stylesheet(" /**/ .foo {} #bar {}", :preserve_comments => true),
+      Crass.parse(" /**/ .foo {} #bar {}", :preserve_comments => true)
+    )
+  end
+end

data/test/test_parse_stylesheet.rb

@@ -0,0 +1,380 @@
+# 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
+  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
+
+          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
+    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
+
+        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_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
+      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]
+
+      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
+    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 'should handle an at-rule following a selector-less style rule' do
+      tree = CP.parse_stylesheet("{}@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
+end

data/test/test_serialization.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+require_relative 'support/common'
+
+describe 'Serialization' do
+  Dir[File.join(File.dirname(__FILE__), 'support/serialization/*.css')].each do |filepath|
+    it "should parse and serialize #{filepath}" do
+      input  = File.read(filepath)
+
+      tree = Crass.parse(input,
+        :preserve_comments => true,
+        :preserve_hacks => true)
+
+      output = CP.stringify(tree)
+
+      assert_equal input, output
+    end
+  end
+end

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: crass
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors:
 - Ryan Grove
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-28 00:00:00.000000000 Z
+date: 2013-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,7 +27,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -38,49 +34,70 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 10.1.0
-description: 
-email: ryan@wonko.com
+description: Crass is a pure Ruby CSS parser based on the CSS Syntax Module Level
+  3 draft.
+email:
+- ryan@wonko.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
+- .travis.yml
+- .yardopts
+- Gemfile
 - HISTORY.md
 - LICENSE
 - README.md
+- Rakefile
+- crass.gemspec
+- lib/crass.rb
 - lib/crass/parser.rb
 - lib/crass/scanner.rb
 - lib/crass/token-scanner.rb
 - lib/crass/tokenizer.rb
 - lib/crass/version.rb
-- lib/crass.rb
+- test/support/common.rb
+- test/support/serialization/bootstrap-theme.css
+- test/support/serialization/bootstrap.css
+- test/support/serialization/pure.css
+- test/test_crass.rb
+- test/test_parse_stylesheet.rb
+- test/test_serialization.rb
 homepage: https://github.com/rgrove/crass/
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.1.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: CSS parser based on the CSS Syntax Module Level 3 draft.
-test_files: []
+test_files:
+- test/support/common.rb
+- test/support/serialization/bootstrap-theme.css
+- test/support/serialization/bootstrap.css
+- test/support/serialization/pure.css
+- test/test_crass.rb
+- test/test_parse_stylesheet.rb
+- test/test_serialization.rb
 has_rdoc: