crass 0.1.0 → 0.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OGNiZTc1MDI4ZWMwYmQxZGI4ODE4Yzc1YzNkNTU2MDJjODc1NTI0Mg==
+    MDM3ZDU2Y2U1NDBkNGQxMDQwMzNhNGM1YTRjM2UyM2RjMTA5MGU5MA==
   data.tar.gz: !binary |-
-    NTdlYmJkNTZlYjI3ZjE3Njc2ZDRiMzkxYWZjOTQ0OWE3ZTcxYWRiOQ==
+    YTMyMDVkZTViMjEyNjVlMGJkNjE2N2M0MWRhYmQ3Mzc3NGU0YzE3Mg==
 SHA512:
   metadata.gz: !binary |-
-    ZjA0NTZkOTAwYTYwZmNjMDgyMzE1N2NkZDQ5ZTlkNDg0NzZmYTk4OGNiMjli
-    MDdlNzQwNTAwZWZmMjkzY2U3N2NkMjEyOWU1ZDMyZWZlYjU1NGRjNzg1Y2Ez
-    ZWZiYjg5ZTk2YmFhNWQ4NDk1ZDEzNmUwYjg2NDE0NjkyNzFmMjY=
+    ZDkwYmUyNGVkZjA5NGMwOWRlNzVlYmIwMmM5NjJlMDYxYWYxMzE0YzE2YWNl
+    MTYwZDU4MzZmMTkwZGVmMDk3ODI4MTMwZmE0NWQ3Y2M5ODE1MTllYjhlZWI2
+    NmQxMjExYmEzMmI1MTQzOWExOTk1Yjg0NjlkODNiYzM5ZDIwZjk=
   data.tar.gz: !binary |-
-    NTE5NzI2MDViOWU5YzE4NzFmOWNlZmU0MWM5NTJhNGIyZTMyMTBkOGVjNWQ5
-    MmQ5NDZhYWY5YjIzMTgyNzNjNzZmY2I1NDE3YzFmMzM2Njk1NGQzMzQ3OTkw
-    MjFmODllYmM5NDQ5MTk3YjAwN2I3M2NmNzU4NDZkYzQwYzE1NWE=
+    OTQ4N2Y4MWNiYjQzNTdlN2MzMDVjMTRhY2U2NjE4YzczNDgwMzVhYzQ5ODcy
+    NjMwYTRhZmNiOTc5ZjViMjgyYzlhZThkOWU2Yjc5ODI4YTJlNDUzNmQ1ODAy
+    MTQ2YTA2ZDhmZWUzNDMwNDk2NjQ2MDk4OTBmNmI5NDdmOTNlNzE=

data/HISTORY.md

@@ -1,6 +1,20 @@
 Crass Change History
 ====================
 
+0.2.0 (2013-10-10)
+------------------
+
+* Added a `:children` field to `:property` nodes. It's an array containing all
+  the nodes that make up the property's value.
+
+* Fixed: Incorrect value was given for `:property` nodes whose values contained
+  functions.
+
+* Fixed: When parsing the value of an at-rule's block as a list of rules, a
+  selector containing a function (such as "#foo:not(.bar)") would cause that
+  property and the rest of the token stream to be discarded.
+
+
 0.1.0 (2013-10-04)
 ------------------
 

data/README.md

@@ -83,47 +83,57 @@ This returns a big fat ugly parse tree, which looks like this:
 ```ruby
 [{:node=>:comment, :pos=>0, :raw=>"/* Comment! */", :value=>" Comment! "},
  {:node=>:whitespace, :pos=>14, :raw=>"\n"},
- {:node=>:style_rule,
-  :selector=>
-   {:node=>:selector,
-    :value=>"a:hover",
-    :tokens=>
-     [{:node=>:ident, :pos=>15, :raw=>"a", :value=>"a"},
-      {:node=>:colon, :pos=>16, :raw=>":"},
-      {:node=>:ident, :pos=>17, :raw=>"hover", :value=>"hover"},
-      {:node=>:whitespace, :pos=>22, :raw=>" "}]},
+ {:node=>:property,
+  :name=>"a",
+  :value=>"hover {\n  color: #0d8bfa",
   :children=>
-   [{:node=>:whitespace, :pos=>24, :raw=>"\n  "},
-    {:node=>:property,
-     :name=>"color",
-     :value=>"#0d8bfa",
-     :important=>false,
-     :tokens=>
-      [{:node=>:ident, :pos=>27, :raw=>"color", :value=>"color"},
-       {:node=>:colon, :pos=>32, :raw=>":"},
-       {:node=>:whitespace, :pos=>33, :raw=>" "},
-       {:node=>:hash,
-        :pos=>34,
-        :raw=>"#0d8bfa",
-        :type=>:unrestricted,
-        :value=>"0d8bfa"},
-       {:node=>:semicolon, :pos=>41, :raw=>";"}]},
-    {:node=>:whitespace, :pos=>42, :raw=>"\n  "},
-    {:node=>:property,
-     :name=>"text-decoration",
-     :value=>"underline",
-     :important=>false,
-     :tokens=>
-      [{:node=>:ident,
-        :pos=>45,
-        :raw=>"text-decoration",
-        :value=>"text-decoration"},
-       {:node=>:colon, :pos=>60, :raw=>":"},
-       {:node=>:whitespace, :pos=>61, :raw=>" "},
-       {:node=>:ident, :pos=>62, :raw=>"underline", :value=>"underline"},
-       {:node=>:semicolon, :pos=>71, :raw=>";"}]},
-    {:node=>:whitespace, :pos=>72, :raw=>"\n"}]},
- {:node=>:whitespace, :pos=>74, :raw=>"\n"}]
+   [{:node=>:ident, :pos=>17, :raw=>"hover", :value=>"hover"},
+    {:node=>:whitespace, :pos=>22, :raw=>" "},
+    {:node=>:"{", :pos=>23, :raw=>"{"},
+    {:node=>:whitespace, :pos=>24, :raw=>"\n  "},
+    {:node=>:ident, :pos=>27, :raw=>"color", :value=>"color"},
+    {:node=>:colon, :pos=>32, :raw=>":"},
+    {:node=>:whitespace, :pos=>33, :raw=>" "},
+    {:node=>:hash,
+     :pos=>34,
+     :raw=>"#0d8bfa",
+     :type=>:unrestricted,
+     :value=>"0d8bfa"}],
+  :important=>false,
+  :tokens=>
+   [{:node=>:ident, :pos=>15, :raw=>"a", :value=>"a"},
+    {:node=>:colon, :pos=>16, :raw=>":"},
+    {:node=>:ident, :pos=>17, :raw=>"hover", :value=>"hover"},
+    {:node=>:whitespace, :pos=>22, :raw=>" "},
+    {:node=>:"{", :pos=>23, :raw=>"{"},
+    {:node=>:whitespace, :pos=>24, :raw=>"\n  "},
+    {:node=>:ident, :pos=>27, :raw=>"color", :value=>"color"},
+    {:node=>:colon, :pos=>32, :raw=>":"},
+    {:node=>:whitespace, :pos=>33, :raw=>" "},
+    {:node=>:hash,
+     :pos=>34,
+     :raw=>"#0d8bfa",
+     :type=>:unrestricted,
+     :value=>"0d8bfa"},
+    {:node=>:semicolon, :pos=>41, :raw=>";"}]},
+ {:node=>:whitespace, :pos=>42, :raw=>"\n  "},
+ {:node=>:property,
+  :name=>"text-decoration",
+  :value=>"underline",
+  :children=>
+   [{:node=>:whitespace, :pos=>61, :raw=>" "},
+    {:node=>:ident, :pos=>62, :raw=>"underline", :value=>"underline"}],
+  :important=>false,
+  :tokens=>
+   [{:node=>:ident,
+     :pos=>45,
+     :raw=>"text-decoration",
+     :value=>"text-decoration"},
+    {:node=>:colon, :pos=>60, :raw=>":"},
+    {:node=>:whitespace, :pos=>61, :raw=>" "},
+    {:node=>:ident, :pos=>62, :raw=>"underline", :value=>"underline"},
+    {:node=>:semicolon, :pos=>71, :raw=>";"}]},
+ {:node=>:whitespace, :pos=>72, :raw=>"\n"}]
 ```
 
 If you want, you can stringify the parse tree:

data/lib/crass/parser.rb

@@ -26,7 +26,7 @@ module Crass
       Parser.new(input, options).parse_properties
     end
 
-    # Parses a CSS rules (such as the content of a `@media` block) and returns a
+    # Parses CSS rules (such as the content of a `@media` block) and returns a
     # parse tree. The only difference from {#parse_stylesheet} is that CDO/CDC
     # nodes (`<!--` and `-->`) aren't ignored.
     #
@@ -143,10 +143,13 @@ module Crass
 
         while token = input.consume
           case token[:node]
-          when :comment then next
-          when :semicolon, :eof then break
+          when :comment
+            next
 
-          when :'{' then
+          when :semicolon
+            break
+
+          when :'{'
             rule[:block] = consume_simple_block(input)
             break
 
@@ -171,14 +174,24 @@ module Crass
 
     # Consumes a component value and returns it.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-component-value0
+    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-component-value
     def consume_component_value(input = @tokens)
       return nil unless token = input.consume
 
       case token[:node]
-      when :'{', :'[', :'(' then consume_simple_block(input)
-      when :function then consume_function(input)
-      else token
+      when :'{', :'[', :'('
+        consume_simple_block(input)
+
+      when :function
+        if token.key?(:name)
+          # This is a parsed function, not a function token.
+          token
+        else
+          consume_function(input)
+        end
+
+      else
+        token
       end
     end
 
@@ -291,18 +304,21 @@ module Crass
         :tokens => [input.current]
       }
 
-      function[:tokens].concat(input.collect do
+      function[:tokens].concat(input.collect {
         while token = input.consume
           case token[:node]
-          when :')', :eof then break
-          when :comment then next
+          when :')'
+            break
+
+          when :comment
+            next
 
           else
             input.reconsume
             function[:value] << consume_component_value(input)
           end
         end
-      end)
+      })
 
       create_node(:function, function)
     end
@@ -340,12 +356,10 @@ module Crass
     def consume_rules(flags = {})
       rules = []
 
-      while true
-        return rules unless token = @tokens.consume
-
+      while token = @tokens.consume
         case token[:node]
-          when :comment, :whitespace then rules << token
-          when :eof then return rules
+          when :comment, :whitespace
+            rules << token
 
           when :cdc, :cdo
             unless flags[:top_level]
@@ -365,6 +379,8 @@ module Crass
             rules << rule if rule
         end
       end
+
+      rules
     end
 
     # Consumes and returns a simple block associated with the current input
@@ -384,7 +400,7 @@ module Crass
 
       block[:tokens].concat(input.collect do
         while token = input.consume
-          break if token[:node] == end_token || token[:node] == :eof
+          break if token[:node] == end_token
 
           input.reconsume
           block[:value] << consume_component_value(input)
@@ -435,9 +451,13 @@ module Crass
           next
         end
 
+        children = decl[:value].dup
+        children.pop if children.last[:node] == :semicolon
+
         properties << create_node(:property,
           :name      => decl[:name],
           :value     => parse_value(decl[:value]),
+          :children  => children,
           :important => decl[:important] == true,
           :tokens    => decl[:tokens])
       end
@@ -452,7 +472,8 @@ module Crass
 
       nodes.each do |node|
         case node[:node]
-        when :comment, :semicolon then next
+        when :comment, :semicolon
+          next
 
         when :at_keyword, :ident
           string << node[:value]
@@ -460,8 +481,9 @@ module Crass
         when :function
           if node[:value].is_a?(String)
             string << node[:value]
+            string << '('
           else
-            string << parse_value(node[:value])
+            string << parse_value(node[:tokens])
           end
 
         else

data/lib/crass/version.rb

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

data/test/shared/parse_rules.rb

@@ -188,6 +188,11 @@ shared_tests_for 'parsing a list of rules' do
       assert_equal("#aaa", property[:value])
       assert_equal(false, property[:important])
       assert_tokens("color: #aaa;", property[:tokens], 16)
+
+      assert_equal([
+        {:node=>:whitespace, :pos=>22, :raw=>" "},
+        {:node=>:hash, :pos=>23, :raw=>"#aaa", :type=>:id, :value=>"aaa"},
+      ], property[:children])
     end
 
     it 'with preceding comment, selector, block, comment, when :preserve_comments == true' do
@@ -217,6 +222,11 @@ shared_tests_for 'parsing a list of rules' do
       assert_equal("#aaa", property[:value])
       assert_equal(false, property[:important])
       assert_tokens("color: #aaa;", property[:tokens], 16, options)
+
+      assert_equal([
+        {:node=>:whitespace, :pos=>22, :raw=>" "},
+        {:node=>:hash, :pos=>23, :raw=>"#aaa", :type=>:id, :value=>"aaa"}
+      ], property[:children])
     end
 
     it 'unclosed, with preceding comment, no selector' do
@@ -243,6 +253,12 @@ shared_tests_for 'parsing a list of rules' do
       assert_equal("#aaa", property[:value])
       assert_equal(false, property[:important])
       assert_tokens("color: #aaa  ", property[:tokens], 8)
+
+      assert_equal([
+        {:node=>:whitespace, :pos=>14, :raw=>" "},
+        {:node=>:hash, :pos=>15, :raw=>"#aaa", :type=>:id, :value=>"aaa"},
+        {:node=>:whitespace, :pos=>19, :raw=>"  "}
+      ], property[:children])
     end
 
     it 'unclosed, with preceding comment, no selector, when :preserve_comments == true' do
@@ -270,6 +286,12 @@ shared_tests_for 'parsing a list of rules' do
       assert_equal("#aaa", property[:value])
       assert_equal(false, property[:important])
       assert_tokens("color: #aaa  ", property[:tokens], 8, options)
+
+      assert_equal([
+        {:node=>:whitespace, :pos=>14, :raw=>" "},
+        {:node=>:hash, :pos=>15, :raw=>"#aaa", :type=>:id, :value=>"aaa"},
+        {:node=>:whitespace, :pos=>19, :raw=>"  "}
+      ], property[:children])
     end
   end
 
@@ -298,6 +320,11 @@ shared_tests_for 'parsing a list of rules' do
     assert_equal(false, prop[:important])
     assert_tokens("color: #aaa;", prop[:tokens], 6)
 
+    assert_equal([
+      {:node=>:whitespace, :pos=>12, :raw=>" "},
+      {:node=>:hash, :pos=>13, :raw=>"#aaa", :type=>:id, :value=>"aaa"}
+    ], prop[:children])
+
     assert_tokens(" ", tree[1], 20)
 
     rule = tree[2]
@@ -342,4 +369,152 @@ shared_tests_for 'parsing a list of rules' do
     assert_equal([], rule[:prelude])
     assert_tokens("@a", rule[:tokens], 2)
   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) \" \"",
+          :important=>false,
+          :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=>" "}],
+          :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))",
+          :important=>false,
+          :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=>")"}]}],
+          :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/test_parse_properties.rb

@@ -40,6 +40,10 @@ describe 'Crass::Parser' do
       assert_equal(false, prop[:important])
       assert_tokens("a:b;", prop[:tokens])
 
+      assert_equal([
+        {:node=>:ident, :pos=>2, :raw=>"b", :value=>"b"}
+      ], prop[:children])
+
       assert_tokens(" ", tree[1], 4)
 
       prop = tree[2]
@@ -49,6 +53,17 @@ describe 'Crass::Parser' do
       assert_equal(true, prop[:important])
       assert_tokens("c:d 42!important;", prop[:tokens], 5)
 
+      assert_equal([
+        {:node=>:ident, :pos=>7, :raw=>"d", :value=>"d"},
+        {:node=>:whitespace, :pos=>8, :raw=>" "},
+        {:node=>:number,
+         :pos=>9,
+         :raw=>"42",
+         :repr=>"42",
+         :type=>:integer,
+         :value=>42}
+      ], prop[:children])
+
       assert_tokens("\n", tree[3], 22)
     end
 
@@ -71,6 +86,10 @@ describe 'Crass::Parser' do
       assert_equal(false, prop[:important])
       assert_tokens("a:b;", prop[:tokens], 19)
 
+      assert_equal([
+        {:node=>:ident, :pos=>21, :raw=>"b", :value=>"b"}
+      ], prop[:children])
+
       assert_tokens(" ", tree[3], 23)
 
       rule = tree[4]
@@ -115,6 +134,9 @@ describe 'Crass::Parser' do
       assert_equal("b", prop[:value])
       assert_equal(false, prop[:important])
       assert_tokens("a:b;", prop[:tokens], 24)
+      assert_equal([
+        {:node=>:ident, :pos=>26, :raw=>"b", :value=>"b"}
+      ], prop[:children])
 
       assert_tokens("; ", tree[3..4], 28)
 
@@ -171,5 +193,71 @@ describe 'Crass::Parser' do
       assert_equal([], block[:value])
       assert_tokens("{", block[:tokens], 47)
     end
+
+    it 'should parse values containing functions' do
+      tree = parse("content: attr(data-foo) \" \";")
+
+      assert_equal([
+        {:node=>:property,
+         :name=>"content",
+         :value=>"attr(data-foo) \" \"",
+         :important=>false,
+         :children=>
+          [{:node=>:whitespace, :pos=>8, :raw=>" "},
+           {:node=>:function, :pos=>9, :raw=>"attr(", :value=>"attr"},
+           {:node=>:ident, :pos=>14, :raw=>"data-foo", :value=>"data-foo"},
+           {:node=>:")", :pos=>22, :raw=>")"},
+           {:node=>:whitespace, :pos=>23, :raw=>" "},
+           {:node=>:string, :pos=>24, :raw=>"\" \"", :value=>" "}],
+         :tokens=>
+          [{:node=>:ident, :pos=>0, :raw=>"content", :value=>"content"},
+           {:node=>:colon, :pos=>7, :raw=>":"},
+           {:node=>:whitespace, :pos=>8, :raw=>" "},
+           {:node=>:function, :pos=>9, :raw=>"attr(", :value=>"attr"},
+           {:node=>:ident, :pos=>14, :raw=>"data-foo", :value=>"data-foo"},
+           {:node=>:")", :pos=>22, :raw=>")"},
+           {:node=>:whitespace, :pos=>23, :raw=>" "},
+           {:node=>:string, :pos=>24, :raw=>"\" \"", :value=>" "},
+           {:node=>:semicolon, :pos=>27, :raw=>";"}]}
+        ], tree)
+    end
+
+    it 'should parse values containing nested functions' do
+      tree = parse("width: expression(alert(1));")
+
+      assert_equal([
+        {:node=>:property,
+         :name=>"width",
+         :value=>"expression(alert(1))",
+         :important=>false,
+         :children=>
+          [{:node=>:whitespace, :pos=>6, :raw=>" "},
+           {:node=>:function, :pos=>7, :raw=>"expression(", :value=>"expression"},
+           {:node=>:function, :pos=>18, :raw=>"alert(", :value=>"alert"},
+           {:node=>:number,
+            :pos=>24,
+            :raw=>"1",
+            :repr=>"1",
+            :type=>:integer,
+            :value=>1},
+           {:node=>:")", :pos=>25, :raw=>")"},
+           {:node=>:")", :pos=>26, :raw=>")"}],
+         :tokens=>
+          [{:node=>:ident, :pos=>0, :raw=>"width", :value=>"width"},
+           {:node=>:colon, :pos=>5, :raw=>":"},
+           {:node=>:whitespace, :pos=>6, :raw=>" "},
+           {:node=>:function, :pos=>7, :raw=>"expression(", :value=>"expression"},
+           {:node=>:function, :pos=>18, :raw=>"alert(", :value=>"alert"},
+           {:node=>:number,
+            :pos=>24,
+            :raw=>"1",
+            :repr=>"1",
+            :type=>:integer,
+            :value=>1},
+           {:node=>:")", :pos=>25, :raw=>")"},
+           {:node=>:")", :pos=>26, :raw=>")"},
+           {:node=>:semicolon, :pos=>27, :raw=>";"}]}
+        ], tree)
+    end
   end
 end

data/test/test_parse_rules.rb

@@ -52,12 +52,12 @@ describe 'Crass::Parser' do
     end
 
     it 'should parse the block of an at-rule' do
-      rule = CP.parse_stylesheet("@media (max-width: 400px) {.foo{color:#fff;}}")[0]
+      rule = CP.parse_stylesheet("@media (max-width: 400px) {#foo:not(.bar){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("#foo:not(.bar)", style_rule[:selector][:value])
       assert_equal(1, style_rule[:children].size)
 
       prop = style_rule[:children][0]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crass
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ryan Grove
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-04 00:00:00.000000000 Z
+date: 2013-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest