test/test_parse_properties.rb in crass-0.1.0 vs test/test_parse_properties.rb in crass-0.2.0

@@ -38,19 +38,34 @@
       assert_equal("a", prop[:name])
       assert_equal("b", prop[:value])
       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]
       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_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
 
     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'")
@@ -69,10 +84,14 @@
       assert_equal("a", prop[:name])
       assert_equal("b", prop[:value])
       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]
       assert_equal(:at_rule, rule[:node])
       assert_equal("import", rule[:name])
@@ -113,10 +132,13 @@
       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_equal([
+        {:node=>:ident, :pos=>26, :raw=>"b", :value=>"b"}
+      ], prop[:children])
 
       assert_tokens("; ", tree[3..4], 28)
 
       rule = tree[5]
       assert_equal(:at_rule, rule[:node])
@@ -168,8 +190,74 @@
       assert_equal(:simple_block, block[:node])
       assert_equal("{", block[:start])
       assert_equal("}", block[:end])
       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