crass 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Y2NmZWM1MTg3MjVmNjcxN2ZjN2JhZmE4YzU0NjUxYWFjMDI0MjQwMA==
+  data.tar.gz: !binary |-
+    NmZmMGJmM2JkYmRiY2JhYjI2N2E1NzVhNDFjNzc3ZjJiZDViNzg3ZQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZjRkYzI5Zjk1NGZlOTEzOGI2YTRmMThhMTdiYzNjNDYyNGU4NzhiMjExYTY4
+    NDQ4ZDJlYjlhYTBiNTE0OTcwNTk4ZTgxM2VjNGNkMmVkNjgwYzcwNmZiZGRh
+    MDM5OWE4YzM3NWIwZjhkN2VhODVlZmJkMDYzMGJjMjgyM2NkNjY=
+  data.tar.gz: !binary |-
+    ZmMyOWZiNWNkYmQ5OGE3MGFkOWEyMWJiY2JmODYwM2Y0MTRhNzhhZWM1NGE0
+    NTU2NTI1MGYyNzVlZDE3ZTZmYWQ4NjkyMmY2NWU4NDA4NGNlNDAyOWIxYWY4
+    NmEzNmVkYjYyNTNhMjkwODFkMDU2MmMzOGJkNGZlM2RlYmMwY2E=

data/.gitignore

@@ -0,0 +1,4 @@
+.yardoc/
+doc/
+.DS_Store
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/HISTORY.md

@@ -1,4 +1,14 @@
 Crass Change History
 ====================
 
-?????
+0.0.2 (2013-09-30)
+------------------
+
+* Fixed: `:at_rule` nodes now have a `:name` key.
+
+
+0.0.1 (2013-09-27)
+------------------
+
+* Initial release.
+

data/README.md

@@ -6,6 +6,8 @@ Crass is a Ruby CSS parser based on the [CSS Syntax Module Level 3][css] draft.
 * [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)
+
 Features
 --------
 
@@ -41,15 +43,19 @@ Problems
   (except for wholesale removal of nodes) are not reflected in the serialized
   output.
 
-* It doesn't have any unit tests yet, because it's very, very new and I'm
-  still experimenting with its architecture.
+* Unit tests aren't complete yet.
 
-* Probably plenty of other things. Did I mention it's very new?
+* Probably tons of other things. Did I mention it's very new and experimental?
 
 Installing
 ----------
 
-Don't install it yet. It's not finished.
+```
+gem install crass
+```
+
+...but only if you're brave. Seriously, this thing will almost certainly kill
+your family and poop on your pets.
 
 Examples
 --------
@@ -134,6 +140,34 @@ a:hover {
 
 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].
+
+[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.
+
+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
+you to change things.
+
+If you want to add a feature or refactor something, please get in touch first to
+make sure I'm on board with your idea and approach; I'm pretty picky, and I'd
+hate to have to turn down a pull request you spent a lot of time on.
+
+[issue]: https://github.com/rgrove/crass/issues/new
+
 License
 -------
 

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new
+task :default => [:test]

data/crass.gemspec

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require './lib/crass/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'crass'
+  s.summary     = 'CSS parser based on the CSS Syntax Module Level 3 draft.'
+  s.description = 'Crass is a pure Ruby CSS parser based on the CSS Syntax Module Level 3 draft.'
+  s.version     = Crass::VERSION
+  s.authors     = ['Ryan Grove']
+  s.email       = ['ryan@wonko.com']
+  s.homepage    = 'https://github.com/rgrove/crass/'
+  s.license     = 'MIT'
+
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = Gem::Requirement.new('>= 1.9.2')
+
+  s.require_paths = ['lib']
+
+  s.files      = `git ls-files`.split($/)
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+
+  # Development dependencies.
+  s.add_development_dependency 'minitest', '~> 5.0.8'
+  s.add_development_dependency 'rake',     '~> 10.1.0'
+end

data/lib/crass.rb

@@ -10,4 +10,5 @@ module Crass
   def self.parse(input, options = {})
     Parser.parse_stylesheet(input, options)
   end
+
 end

data/lib/crass/parser.rb

@@ -28,7 +28,7 @@ module Crass
       rules.map do |rule|
         case rule[:node]
         # TODO: handle at-rules
-        when :qualified_rule then parser.parse_style_rule(rule)
+        when :qualified_rule then parser.create_style_rule(rule)
         else rule
         end
       end
@@ -91,29 +91,33 @@ module Crass
 
     # Consumes an at-rule and returns it.
     #
-    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-an-at-rule0
-    def consume_at_rule(tokens = @tokens)
-      rule = {:prelude => []}
+    # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-an-at-rule
+    def consume_at_rule(input = @tokens)
+      rule = {}
+
+      rule[:tokens] = input.collect do
+        rule[:name]    = parse_value(input.consume)
+        rule[:prelude] = []
 
-      rule[:tokens] = tokens.collect do
-        while token = tokens.consume
+        while token = input.consume
           case token[:node]
           when :comment then next
           when :semicolon, :eof then break
 
           when :'{' then
-            rule[:block] = consume_simple_block(tokens)
+            rule[:block] = consume_simple_block(input)
             break
 
-          # TODO: At this point, the spec says we should check for a "simple block
-          # with an associated token of <<{-token>>", but isn't that exactly what
-          # we just did above? And the tokenizer only ever produces standalone
-          # <<{-token>>s, so how could the token stream ever contain one that's
-          # already associated with a simple block? What am I missing?
+          # TODO: At this point, the spec says we should check for a "simple
+          # block with an associated token of <<{-token>>", but isn't that
+          # exactly what we just did above? And the tokenizer only ever produces
+          # standalone <<{-token>>s, so how could the token stream ever contain
+          # one that's already associated with a simple block? What am I
+          # missing?
 
           else
-            tokens.reconsume
-            rule[:prelude] << consume_component_value(tokens)
+            input.reconsume
+            rule[:prelude] << consume_component_value(input)
           end
         end
       end
@@ -124,12 +128,12 @@ module Crass
     # Consumes a component value and returns it.
     #
     # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-component-value0
-    def consume_component_value(tokens = @tokens)
-      return nil unless token = tokens.consume
+    def consume_component_value(input = @tokens)
+      return nil unless token = input.consume
 
       case token[:node]
-      when :'{', :'[', :'(' then consume_simple_block(tokens)
-      when :function then consume_function(tokens)
+      when :'{', :'[', :'(' then consume_simple_block(input)
+      when :function then consume_function(input)
       else token
       end
     end
@@ -137,19 +141,19 @@ 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-declaration0
-    def consume_declaration(tokens = @tokens)
+    def consume_declaration(input = @tokens)
       declaration = {}
 
-      declaration[:tokens] = tokens.collect do
-        declaration[:name] = tokens.consume[:value]
+      declaration[:tokens] = input.collect do
+        declaration[:name] = input.consume[:value]
 
         value = []
-        token = tokens.consume
-        token = tokens.consume while token[:node] == :whitespace
+        token = input.consume
+        token = input.consume while token[:node] == :whitespace
 
         return nil if token[:node] != :colon # TODO: parse error
 
-        value << token while token = tokens.consume
+        value << token while token = input.consume
         declaration[:value] = value
 
         maybe_important = value.reject {|v| v[:node] == :whitespace }[-2, 2]
@@ -173,10 +177,10 @@ module Crass
     # `:whitespace` nodes, which is non-standard.
     #
     # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-list-of-declarations0
-    def consume_declarations(tokens = @tokens)
+    def consume_declarations(input = @tokens)
       declarations = []
 
-      while token = tokens.consume
+      while token = input.consume
         case token[:node]
         when :comment, :semicolon, :whitespace
           declarations << token
@@ -184,16 +188,19 @@ module Crass
         when :at_keyword
           # TODO: this is technically a parse error when parsing a style rule,
           # but not necessarily at other times.
-          declarations << consume_at_rule(tokens)
+
+          # TODO: It seems like we should reconsume the current token here,
+          # since that's what happens when consuming a list of rules.
+          declarations << consume_at_rule(input)
 
         when :ident
           decl_tokens = [token]
-          tokens.consume
+          input.consume
 
-          while tokens.current
-            decl_tokens << tokens.current
-            break if tokens.current[:node] == :semicolon
-            tokens.consume
+          while input.current
+            decl_tokens << input.current
+            break if input.current[:node] == :semicolon
+            input.consume
           end
 
           if decl = consume_declaration(TokenScanner.new(decl_tokens))
@@ -203,7 +210,7 @@ module Crass
         else
           # TODO: parse error (invalid property name, etc.)
           while token && token[:node] != :semicolon
-            token = consume_component_value(tokens)
+            token = consume_component_value(input)
           end
         end
       end
@@ -214,22 +221,22 @@ module Crass
     # Consumes a function and returns it.
     #
     # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-function
-    def consume_function(tokens = @tokens)
+    def consume_function(input = @tokens)
       function = {
-        :name   => tokens.current[:value],
+        :name   => input.current[:value],
         :value  => [],
-        :tokens => [tokens.current]
+        :tokens => [input.current]
       }
 
-      function[:tokens].concat(tokens.collect do
-        while token = tokens.consume
+      function[:tokens].concat(input.collect do
+        while token = input.consume
           case token[:node]
           when :')', :eof then break
           when :comment then next
 
           else
-            tokens.reconsume
-            function[:value] << consume_component_value(tokens)
+            input.reconsume
+            function[:value] << consume_component_value(input)
           end
         end
       end)
@@ -241,15 +248,15 @@ module Crass
     # occurs.
     #
     # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-qualified-rule0
-    def consume_qualified_rule(tokens = @tokens)
+    def consume_qualified_rule(input = @tokens)
       rule = {:prelude => []}
 
-      rule[:tokens] = tokens.collect do
+      rule[:tokens] = input.collect do
         while true
-          return nil unless token = tokens.consume
+          return nil unless token = input.consume
 
           if token[:node] == :'{'
-            rule[:block] = consume_simple_block(tokens)
+            rule[:block] = consume_simple_block(input)
             break
 
           # elsif [simple block with an associated <<{-token>>??]
@@ -261,8 +268,8 @@ module Crass
           # already associated with a simple block? What am I missing?
 
           else
-            tokens.reconsume
-            rule[:prelude] << consume_component_value(tokens)
+            input.reconsume
+            rule[:prelude] << consume_component_value(input)
           end
         end
       end
@@ -307,23 +314,23 @@ module Crass
     # token.
     #
     # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#consume-a-simple-block0
-    def consume_simple_block(tokens = @tokens)
-      start_token = tokens.current[:node]
+    def consume_simple_block(input = @tokens)
+      start_token = input.current[:node]
       end_token   = BLOCK_END_TOKENS[start_token]
 
       block = {
         :start  => start_token.to_s,
         :end    => end_token.to_s,
         :value  => [],
-        :tokens => [tokens.current]
+        :tokens => [input.current]
       }
 
-      block[:tokens].concat(tokens.collect do
-        while token = tokens.consume
+      block[:tokens].concat(input.collect do
+        while token = input.consume
           break if token[:node] == end_token || token[:node] == :eof
 
-          tokens.reconsume
-          block[:value] << consume_component_value(tokens)
+          input.reconsume
+          block[:value] << consume_component_value(input)
         end
       end)
 
@@ -335,21 +342,22 @@ module Crass
       {:node => type}.merge!(properties)
     end
 
-    # Parses the given _tokens_ into a selector node and returns it.
+    # Parses the given _input_ tokens into a selector node and returns it.
     #
     # Doesn't bother splitting the selector list into individual selectors or
     # validating them. Feel free to do that yourself! It'll be fun!
-    def parse_selector(tokens)
+    def create_selector(input)
       create_node(:selector,
-        :value  => parse_value(tokens),
-        :tokens => tokens)
+        :value  => parse_value(input),
+        :tokens => input)
     end
 
-    # Parses a style rule and returns the result.
+    # 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 parse_style_rule(rule)
+    # * 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)
       children = []
       tokens   = TokenScanner.new(rule[:block][:value])
 
@@ -366,7 +374,7 @@ module Crass
       end
 
       create_node(:style_rule,
-        :selector => parse_selector(rule[:prelude]),
+        :selector => create_selector(rule[:prelude]),
         :children => children
       )
     end
@@ -375,10 +383,14 @@ module Crass
     def parse_value(nodes)
       string = ''
 
+      nodes = [nodes] unless nodes.is_a?(Array)
+
       nodes.each do |node|
         case node[:node]
         when :comment, :semicolon then next
-        when :ident then string << node[:value]
+
+        when :at_keyword, :ident
+          string << node[:value]
 
         when :function
           if node[:value].is_a?(String)