crass 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a113964aef62593fb97ac9cb48a4e5a0c9f20428
-  data.tar.gz: 01c82afdd4fa11e034f8b4a89751d7e9712d2893
+  metadata.gz: 519ff6d013ecd7ec215befe0c10a19b571146ccd
+  data.tar.gz: 0ec0589dec0731c6dcff90172dc0dd6196093cde
 SHA512:
-  metadata.gz: e534077f4b8c368a8a469451bc9d713df4d69edc68554d461276d35075e1c77c17c2dec95c2a2b1e9d8833fbeeb912683206305991d015bfd8e369842b4fb14d
-  data.tar.gz: 1e78567ce0c1f91f232cd52e676bb4ef6826d207eb5e6c52b6ff0af924d122c4289d6c4bfedbe57f6ffa8616b46e51537dac3e1415dc03d64339efe1501f9592
+  metadata.gz: 54d9075e9e17ef59cee418d81a46c654bc9aadffe944f9d15cd487f182de84c345fb8b8f7e03f73be8aa5d6796caf8d2ac1cdb372f7c9cb891ae26e9ee8363a8
+  data.tar.gz: 965e9c63add2a8c2e34a50a9424ec9cba73f67e3a7aed615e8a494e8e0724a3762381fbae022452c19a69203ffd4e0f0471e16514dc84454d4d8f22acad7c2ec

data/.travis.yml

@@ -3,3 +3,7 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.3
+  - 2.1.4
+  - 2.1.5
+  - ruby-head

data/HISTORY.md

@@ -1,6 +1,27 @@
 Crass Change History
 ====================
 
+1.0.0 (2014-11-16)
+------------------
+
+* Many parsing and tokenization tweaks to bring us into full compliance with the
+  [14 November 2014 editor's draft][css-syntax-draft] of the CSS syntax spec.
+  The most significant outwardly visible change is that quoted URLs like
+  `url("foo")` are now returned as `:function` tokens and not `:url` tokens due
+  to a change in the tokenization spec.
+
+* Teensy tiny speed and memory usage improvements that you almost certainly
+  won't notice.
+
+* Fixed: A semicolon following a `@charset` rule would be omitted during
+  serialization.
+
+* Fixed: A multibyte char at the beginning of an id token could trigger an
+  encoding error because `StringScanner#peek` is a jerkface.
+
+[css-syntax-draft]:http://dev.w3.org/csswg/css-syntax-3/
+
+
 0.2.1 (2014-07-22)
 ------------------
 
@@ -20,7 +41,7 @@ Crass Change History
   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
+  selector containing a function (such as `#foo:not(.bar)`) would cause that
   property and the rest of the token stream to be discarded.
 
 

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Ryan Grove (ryan@wonko.com)
+Copyright (c) 2014 Ryan Grove (ryan@wonko.com)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the ‘Software’), to deal in

data/README.md

@@ -1,22 +1,22 @@
 Crass
 =====
 
-Crass is a Ruby CSS parser based on the [CSS Syntax Level 3][css] draft
-specification.
+Crass is a Ruby CSS parser that's fully compliant with the
+[CSS Syntax Level 3][css] specification.
 
 * [Home](https://github.com/rgrove/crass/)
 * [API Docs](http://rubydoc.info/github/rgrove/crass/master)
 
-[![Build Status](https://travis-ci.org/rgrove/crass.png?branch=master)](https://travis-ci.org/rgrove/crass?branch=master)
-[![Gem Version](https://badge.fury.io/rb/crass.png)](http://badge.fury.io/rb/crass)
+[![Build Status](https://travis-ci.org/rgrove/crass.svg?branch=master)](https://travis-ci.org/rgrove/crass)
+[![Gem Version](https://badge.fury.io/rb/crass.svg)](http://badge.fury.io/rb/crass)
 
 Features
 --------
 
 * Pure Ruby, with no runtime dependencies other than Ruby 1.9.x or higher.
 
-* Tokenizes and parses CSS according to the rules defined in the 2013 draft of
-  the [CSS Syntax Level 3][css] specification.
+* Tokenizes and parses CSS according to the rules defined in the 14 November
+  2014 editor's draft of the [CSS Syntax Level 3][css] specification.
 
 * Extremely tolerant of broken or invalid CSS. If a browser can handle it, Crass
   should be able to handle it too.
@@ -29,7 +29,7 @@ Features
 * Capable of serializing the parse tree back to CSS while maintaining all
   original whitespace, comments, and indentation.
 
-[css]: http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/
+[css]: http://dev.w3.org/csswg/css-syntax/
 
 Problems
 --------
@@ -47,10 +47,8 @@ Problems
   (except for wholesale removal of nodes) are not reflected in the serialized
   output.
 
-* At the moment, Crass only supports UTF-8 input and doesn't respect `@charset`
-  rules. Input in any other encoding will be converted to UTF-8.
-
-* Probably other things. Did I mention Crass is pretty new?
+* Crass only supports UTF-8 input and doesn't respect `@charset` rules. Input in
+  any other encoding will be converted to UTF-8.
 
 Installing
 ----------
@@ -62,7 +60,7 @@ gem install crass
 Examples
 --------
 
-Say you have a string containing the following simple CSS:
+Say you have a string containing some CSS:
 
 ```css
 /* Comment! */
@@ -78,62 +76,61 @@ Parsing it is simple:
 tree = Crass.parse(css, :preserve_comments => true)
 ```
 
-This returns a big fat ugly parse tree, which looks like this:
+This returns a big fat beautiful parse tree, which looks like this:
 
 ```ruby
 [{:node=>:comment, :pos=>0, :raw=>"/* Comment! */", :value=>" Comment! "},
  {:node=>:whitespace, :pos=>14, :raw=>"\n"},
- {:node=>:property,
-  :name=>"a",
-  :value=>"hover {\n  color: #0d8bfa",
-  :children=>
-   [{: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",
+ {: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=>" "}]},
   :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"}]
+   [{:node=>:whitespace, :pos=>24, :raw=>"\n  "},
+    {:node=>:property,
+     :name=>"color",
+     :value=>"#0d8bfa",
+     :children=>
+      [{:node=>:whitespace, :pos=>33, :raw=>" "},
+       {:node=>:hash,
+        :pos=>34,
+        :raw=>"#0d8bfa",
+        :type=>:unrestricted,
+        :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",
+     :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:
@@ -157,20 +154,15 @@ Wasn't that exciting?
 A Note on Versioning
 --------------------
 
-Crass's version number currently has a "0.x" prefix, indicating that it's a new
-project under heavy development. **As long as the version number starts with
-"0.x", minor revisions may introduce breaking changes.** You've been warned!
-
-Once Crass reaches version 1.0.0, it will adhere strictly to
-[SemVer 2.0][semver].
+As of version 1.0.0, Crass adheres strictly to [SemVer 2.0][semver].
 
 [semver]:http://semver.org/spec/v2.0.0.html
 
 Contributing
 ------------
 
-The best way to contribute right now is to use Crass and [create issues][issue]
-when you run into problems.
+The best way to contribute is to use Crass and [create issues][issue] when you
+run into problems.
 
 Pull requests that fix bugs are more than welcome as long as they include tests.
 Please adhere to the style and format of the surrounding code, or I might ask
@@ -202,7 +194,7 @@ tokenizing and parsing rules that Crass implements.
 License
 -------
 
-Copyright (c) 2013 Ryan Grove (ryan@wonko.com)
+Copyright (c) 2014 Ryan Grove (ryan@wonko.com)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the ‘Software’), to deal in

data/Rakefile

@@ -5,3 +5,7 @@ Bundler::GemHelper.install_tasks
 
 Rake::TestTask.new
 task :default => [:test]
+
+task :'pull-css-tests' do
+  sh 'git subtree pull -P test/css-parsing-tests https://github.com/SimonSapin/css-parsing-tests.git master --squash'
+end

data/crass.gemspec

@@ -3,8 +3,8 @@ require './lib/crass/version'
 
 Gem::Specification.new do |s|
   s.name        = 'crass'
-  s.summary     = 'CSS parser based on the CSS Syntax Level 3 draft.'
-  s.description = 'Crass is a pure Ruby CSS parser based on the CSS Syntax Level 3 draft.'
+  s.summary     = 'CSS parser based on the CSS Syntax Level 3 spec.'
+  s.description = 'Crass is a pure Ruby CSS parser based on the CSS Syntax Level 3 spec.'
   s.version     = Crass::VERSION
   s.authors     = ['Ryan Grove']
   s.email       = ['ryan@wonko.com']

data/lib/crass.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require_relative 'crass/parser'
 
-# A CSS parser based on the CSS Syntax Module Level 3 draft.
+# A CSS parser based on the CSS Syntax Module Level 3 spec.
 module Crass
 
   # Parses _input_ as a CSS stylesheet and returns a parse tree.

data/lib/crass/parser.rb

@@ -6,7 +6,7 @@ module Crass
 
   # Parses a CSS string or list of tokens.
   #
-  # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#parsing
+  # 5. http://dev.w3.org/csswg/css-syntax/#parsing
   class Parser
     BLOCK_END_TOKENS = {
       :'{' => :'}',
@@ -21,18 +21,18 @@ module Crass
     #
     # See {Tokenizer#initialize} for _options_.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#parse-a-list-of-declarations
+    # 5.3.6. http://dev.w3.org/csswg/css-syntax/#parse-a-list-of-declarations
     def self.parse_properties(input, options = {})
       Parser.new(input, options).parse_properties
     end
 
     # 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
+    # parse tree. The only difference from {parse_stylesheet} is that CDO/CDC
     # nodes (`<!--` and `-->`) aren't ignored.
     #
     # See {Tokenizer#initialize} for _options_.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#parse-a-list-of-rules
+    # 5.3.3. http://dev.w3.org/csswg/css-syntax/#parse-a-list-of-rules
     def self.parse_rules(input, options = {})
       parser = Parser.new(input, options)
       rules  = parser.consume_rules
@@ -50,7 +50,7 @@ module Crass
     #
     # See {Tokenizer#initialize} for _options_.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#parse-a-stylesheet
+    # 5.3.2. http://dev.w3.org/csswg/css-syntax/#parse-a-stylesheet
     def self.parse_stylesheet(input, options = {})
       parser = Parser.new(input, options)
       rules  = parser.consume_rules(:top_level => true)
@@ -79,20 +79,9 @@ module Crass
         next if node.nil?
 
         case node[:node]
-        when :at_rule
-          string << node[:tokens].first[:raw]
-          string << self.stringify(node[:prelude], options)
-
-          if node[:block]
-            string << self.stringify(node[:block], options)
-          end
-
         when :comment
           string << node[:raw] unless options[:exclude_comments]
 
-        when :property
-          string << self.stringify(node[:tokens], options)
-
         when :simple_block
           string << node[:start]
           string << self.stringify(node[:value], options)
@@ -100,7 +89,7 @@ module Crass
 
         when :style_rule
           string << self.stringify(node[:selector][:tokens], options)
-          string << "{#{self.stringify(node[:children], options)}}"
+          string << '{' << self.stringify(node[:children], options) << '}'
 
         else
           if node.key?(:raw)
@@ -133,7 +122,7 @@ module Crass
 
     # Consumes an at-rule and returns it.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-an-at-rule
+    # 5.4.2. http://dev.w3.org/csswg/css-syntax-3/#consume-an-at-rule
     def consume_at_rule(input = @tokens)
       rule = {}
 
@@ -143,6 +132,7 @@ module Crass
 
         while token = input.consume
           case token[:node]
+          # Non-standard.
           when :comment
             next
 
@@ -150,17 +140,21 @@ module Crass
             break
 
           when :'{'
-            rule[:block] = consume_simple_block(input)
+            # Note: The spec says the block should _be_ the consumed simple
+            # block, but Simon Sapin's CSS parsing tests and tinycss2 expect
+            # only the _value_ of the consumed simple block here. I assume I'm
+            # interpreting the spec too literally, so I'm going with the
+            # tinycss2 behavior.
+            rule[:block] = consume_simple_block(input)[:value]
             break
 
-          when :simple_block
-            if token[:start] == '{'
-              rule[:block] = token
-              break
-            else
-              input.reconsume
-              rule[:prelude] << consume_component_value(input)
-            end
+          when :simple_block && token[:start] == '{'
+            # Note: The spec says the block should _be_ the simple block, but
+            # Simon Sapin's CSS parsing tests and tinycss2 expect only the
+            # _value_ of the simple block here. I assume I'm interpreting the
+            # spec too literally, so I'm going with the tinycss2 behavior.
+            rule[:block] = token[:value]
+            break
 
           else
             input.reconsume
@@ -172,9 +166,10 @@ module Crass
       create_node(:at_rule, rule)
     end
 
-    # Consumes a component value and returns it.
+    # Consumes a component value and returns it, or `nil` if there are no more
+    # tokens.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-component-value
+    # 5.4.6. http://dev.w3.org/csswg/css-syntax-3/#consume-a-component-value
     def consume_component_value(input = @tokens)
       return nil unless token = input.consume
 
@@ -184,7 +179,9 @@ module Crass
 
       when :function
         if token.key?(:name)
-          # This is a parsed function, not a function token.
+          # This is a parsed function, not a function token. This step isn't
+          # mentioned in the spec, but it's necessary to avoid re-parsing
+          # functions that have already been parsed.
           token
         else
           consume_function(input)
@@ -197,7 +194,7 @@ module Crass
 
     # Consumes a declaration and returns it, or `nil` on parse error.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-declaration
+    # 5.4.5. http://dev.w3.org/csswg/css-syntax-3/#consume-a-declaration
     def consume_declaration(input = @tokens)
       declaration = {}
       value       = []
@@ -205,78 +202,88 @@ module Crass
       declaration[:tokens] = input.collect do
         declaration[:name] = input.consume[:value]
 
-        token = input.consume
-        token = input.consume while token && token[:node] == :whitespace
-
-        return nil if !token || token[:node] != :colon # TODO: parse error
-        value << token while token = input.consume
-      end
-
-      # Look for !important.
-      pos = -1
-      while token = value[pos]
-        type = token[:node]
+        next_token = input.peek
 
-        if type == :whitespace || type == :comment || type == :semicolon
-          pos -= 1
-          next
+        while next_token && next_token[:node] == :whitespace
+          input.consume
+          next_token = input.peek
         end
 
-        if type == :ident && token[:value].downcase == 'important'
-          prev_token = value[pos - 1]
+        unless next_token && next_token[:node] == :colon
+          # Parse error.
+          #
+          # Note: The spec explicitly says to return nothing here, but Simon
+          # Sapin's CSS parsing tests expect an error node.
+          return create_node(:error, :value => 'invalid')
+        end
 
-          if prev_token && prev_token[:node] == :delim &&
-              prev_token[:value] == '!'
+        input.consume
 
-            declaration[:important] = true
-            value.slice!(pos - 1, 2)
-          else
-            break
-          end
-        else
-          break
+        until input.peek.nil?
+          value << consume_component_value(input)
         end
       end
 
+      # Look for !important.
+      important_tokens = value.reject {|token|
+        node = token[:node]
+        node == :whitespace || node == :comment || node == :semicolon
+      }.last(2)
+
+      if important_tokens.size == 2 &&
+          important_tokens[0][:node] == :delim &&
+          important_tokens[0][:value] == '!' &&
+          important_tokens[1][:node] == :ident &&
+          important_tokens[1][:value].downcase == 'important'
+
+        declaration[:important] = true
+        excl_index = value.index(important_tokens[0])
+
+        # Technically the spec doesn't require us to trim trailing tokens after
+        # the !important, but Simon Sapin's CSS parsing tests expect it and
+        # tinycss2 does it, so we'll go along with the cool kids.
+        value.slice!(excl_index, value.size - excl_index)
+      else
+        declaration[:important] = false
+      end
+
       declaration[:value] = value
       create_node(:declaration, declaration)
     end
 
     # Consumes a list of declarations and returns them.
     #
-    # NOTE: The returned list may include `:comment`, `:semicolon`, and
+    # By default, the returned list may include `:comment`, `:semicolon`, and
     # `:whitespace` nodes, which is non-standard.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-list-of-declarations
-    def consume_declarations(input = @tokens)
+    # Options:
+    #
+    #   * **:strict** - Set to `true` to exclude non-standard `:comment`,
+    #     `:semicolon`, and `:whitespace` nodes.
+    #
+    # 5.4.4. http://dev.w3.org/csswg/css-syntax/#consume-a-list-of-declarations
+    def consume_declarations(input = @tokens, options = {})
       declarations = []
 
       while token = input.consume
         case token[:node]
+
+        # Non-standard: Preserve comments, semicolons, and whitespace.
         when :comment, :semicolon, :whitespace
-          declarations << token
+          declarations << token unless options[:strict]
 
         when :at_keyword
-          # TODO: this is technically a parse error when parsing a style rule,
-          # but not necessarily at other times.
-
-          # Note: The spec doesn't say we should reconsume here, but it's
-          # necessary since `consume_at_rule` must consume the `:at_keyword` as
-          # the rule's name or it'll end up in the prelude. The spec *does* say
-          # we should reconsume when an `:at_keyword` is encountered in
-          # `consume_rules`, so we either have to reconsume in both places or in
-          # neither place. I've chosen to reconsume in both places.
+          # When parsing a style rule, this is a parse error. Otherwise it's
+          # not.
           input.reconsume
           declarations << consume_at_rule(input)
 
         when :ident
           decl_tokens = [token]
-          input.consume
 
-          while input.current
-            decl_tokens << input.current
-            break if input.current[:node] == :semicolon
-            input.consume
+          while next_token = input.peek
+            break if next_token[:node] == :semicolon
+            decl_tokens << consume_component_value(input)
           end
 
           if decl = consume_declaration(TokenScanner.new(decl_tokens))
@@ -284,9 +291,17 @@ module Crass
           end
 
         else
-          # TODO: parse error (invalid property name, etc.)
-          while token && token[:node] != :semicolon
-            token = consume_component_value(input)
+          # Parse error (invalid property name, etc.).
+          #
+          # Note: The spec doesn't say we should append anything to the list of
+          # declarations here, but Simon Sapin's CSS parsing tests expect an
+          # error node.
+          declarations << create_node(:error, :value => 'invalid')
+          input.reconsume
+
+          while next_token = input.peek
+            break if next_token[:node] == :semicolon
+            consume_component_value(input)
           end
         end
       end
@@ -296,12 +311,12 @@ module Crass
 
     # Consumes a function and returns it.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-function
+    # 5.4.8. http://dev.w3.org/csswg/css-syntax-3/#consume-a-function
     def consume_function(input = @tokens)
       function = {
         :name   => input.current[:value],
         :value  => [],
-        :tokens => [input.current]
+        :tokens => [input.current] # Non-standard, used for serialization.
       }
 
       function[:tokens].concat(input.collect {
@@ -310,6 +325,7 @@ module Crass
           when :')'
             break
 
+          # Non-standard.
           when :comment
             next
 
@@ -326,19 +342,34 @@ module Crass
     # Consumes a qualified rule and returns it, or `nil` if a parse error
     # occurs.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-qualified-rule
+    # 5.4.3. http://dev.w3.org/csswg/css-syntax-3/#consume-a-qualified-rule
     def consume_qualified_rule(input = @tokens)
       rule = {:prelude => []}
 
       rule[:tokens] = input.collect do
         while true
-          return nil unless token = input.consume
+          unless token = input.consume
+            # Parse error.
+            #
+            # Note: The spec explicitly says to return nothing here, but Simon
+            # Sapin's CSS parsing tests expect an error node.
+            return create_node(:error, :value => 'invalid')
+          end
 
           if token[:node] == :'{'
-            rule[:block] = consume_simple_block(input)
+            # Note: The spec says the block should _be_ the consumed simple
+            # block, but Simon Sapin's CSS parsing tests and tinycss2 expect
+            # only the _value_ of the consumed simple block here. I assume I'm
+            # interpreting the spec too literally, so I'm going with the
+            # tinycss2 behavior.
+            rule[:block] = consume_simple_block(input)[:value]
             break
-          elsif token[:node] == :simple_block
-            rule[:block] = token
+          elsif token[:node] == :simple_block && token[:start] == '{'
+            # Note: The spec says the block should _be_ the simple block, but
+            # Simon Sapin's CSS parsing tests and tinycss2 expect only the
+            # _value_ of the simple block here. I assume I'm interpreting the
+            # spec too literally, so I'm going with the tinycss2 behavior.
+            rule[:block] = token[:value]
             break
           else
             input.reconsume
@@ -352,12 +383,14 @@ module Crass
 
     # Consumes a list of rules and returns them.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-list-of-rules
+    # 5.4.1. http://dev.w3.org/csswg/css-syntax/#consume-a-list-of-rules
     def consume_rules(flags = {})
       rules = []
 
       while token = @tokens.consume
         case token[:node]
+          # Non-standard. Spec says to discard comments and whitespace, but we
+          # keep them so we can serialize faithfully.
           when :comment, :whitespace
             rules << token
 
@@ -386,7 +419,7 @@ module Crass
     # Consumes and returns a simple block associated with the current input
     # token.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-simple-block0
+    # 5.4.7. http://dev.w3.org/csswg/css-syntax/#consume-a-simple-block
     def consume_simple_block(input = @tokens)
       start_token = input.current[:node]
       end_token   = BLOCK_END_TOKENS[start_token]
@@ -395,7 +428,7 @@ module Crass
         :start  => start_token.to_s,
         :end    => end_token.to_s,
         :value  => [],
-        :tokens => [input.current]
+        :tokens => [input.current] # Non-standard. Used for serialization.
       }
 
       block[:tokens].concat(input.collect do
@@ -427,25 +460,96 @@ module Crass
 
     # Creates a `:style_rule` node from the given qualified _rule_, and returns
     # it.
-    #
-    # * http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#style-rules
-    # * http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-list-of-declarations0
     def create_style_rule(rule)
       create_node(:style_rule,
         :selector => create_selector(rule[:prelude]),
-        :children => parse_properties(rule[:block][:value]))
+        :children => parse_properties(rule[:block]))
+    end
+
+    # Parses a single component value and returns it.
+    #
+    # 5.3.7. http://dev.w3.org/csswg/css-syntax-3/#parse-a-component-value
+    def parse_component_value(input = @tokens)
+      input = TokenScanner.new(input) unless input.is_a?(TokenScanner)
+
+      while input.peek && input.peek[:node] == :whitespace
+        input.consume
+      end
+
+      if input.peek.nil?
+        return create_node(:error, :value => 'empty')
+      end
+
+      value = consume_component_value(input)
+
+      while input.peek && input.peek[:node] == :whitespace
+        input.consume
+      end
+
+      if input.peek.nil?
+        value
+      else
+        create_node(:error, :value => 'extra-input')
+      end
+    end
+
+    # Parses a list of component values and returns an array of parsed tokens.
+    #
+    # 5.3.8. http://dev.w3.org/csswg/css-syntax/#parse-a-list-of-component-values
+    def parse_component_values(input = @tokens)
+      input  = TokenScanner.new(input) unless input.is_a?(TokenScanner)
+      tokens = []
+
+      while token = consume_component_value(input)
+        tokens << token
+      end
+
+      tokens
+    end
+
+    # Parses a single declaration and returns it.
+    #
+    # 5.3.5. http://dev.w3.org/csswg/css-syntax/#parse-a-declaration
+    def parse_declaration(input = @tokens)
+      input = TokenScanner.new(input) unless input.is_a?(TokenScanner)
+
+      while input.peek && input.peek[:node] == :whitespace
+        input.consume
+      end
+
+      if input.peek.nil?
+        # Syntax error.
+        return create_node(:error, :value => 'empty')
+      elsif input.peek[:node] != :ident
+        # Syntax error.
+        return create_node(:error, :value => 'invalid')
+      end
+
+      if decl = consume_declaration(input)
+        return decl
+      end
+
+      # Syntax error.
+      create_node(:error, :value => 'invalid')
+    end
+
+    # Parses a list of declarations and returns them.
+    #
+    # See {#consume_declarations} for _options_.
+    #
+    # 5.3.6. http://dev.w3.org/csswg/css-syntax/#parse-a-list-of-declarations
+    def parse_declarations(input = @tokens, options = {})
+      input = TokenScanner.new(input) unless input.is_a?(TokenScanner)
+      consume_declarations(input, options)
     end
 
     # Parses a list of declarations and returns an array of `:property` nodes
     # (and any non-declaration nodes that were in the input). This is useful for
     # parsing the contents of an HTML element's `style` attribute.
-    #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#parse-a-list-of-declarations
     def parse_properties(input = @tokens)
-      input      = TokenScanner.new(input) unless input.is_a?(TokenScanner)
       properties = []
 
-      consume_declarations(input).each do |decl|
+      parse_declarations(input).each do |decl|
         unless decl[:node] == :declaration
           properties << decl
           next
@@ -458,13 +562,44 @@ module Crass
           :name      => decl[:name],
           :value     => parse_value(decl[:value]),
           :children  => children,
-          :important => decl[:important] == true,
+          :important => decl[:important],
           :tokens    => decl[:tokens])
       end
 
       properties
     end
 
+    # Parses a single rule and returns it.
+    #
+    # 5.3.4. http://dev.w3.org/csswg/css-syntax-3/#parse-a-rule
+    def parse_rule(input = @tokens)
+      input = TokenScanner.new(input) unless input.is_a?(TokenScanner)
+
+      while input.peek && input.peek[:node] == :whitespace
+        input.consume
+      end
+
+      if input.peek.nil?
+        # Syntax error.
+        return create_node(:error, :value => 'empty')
+      elsif input.peek[:node] == :at_keyword
+        rule = consume_at_rule(input)
+      else
+        rule = consume_qualified_rule(input)
+      end
+
+      while input.peek && input.peek[:node] == :whitespace
+        input.consume
+      end
+
+      if input.peek.nil?
+        rule
+      else
+        # Syntax error.
+        create_node(:error, :value => 'extra-input')
+      end
+    end
+
     # Returns the unescaped value of a selector name or property declaration.
     def parse_value(nodes)
       nodes  = [nodes] unless nodes.is_a?(Array)