csspool 2.0.0 → 3.0.0

data/test/css/test_tokenizer.rb

@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+
+require "helper"
+
+module CSSPool
+  module CSS
+    class TestTokenizer < CSSPool::TestCase
+      def setup
+        super
+        @scanner = Class.new(CSSPool::CSS::Tokenizer) {
+          def do_parse
+          end
+        }.new
+      end
+
+      {
+        'em'    => :EMS,
+        'ex'    => :EXS,
+        'px'    => :LENGTH,
+        'cm'    => :LENGTH,
+        'mm'    => :LENGTH,
+        'in'    => :LENGTH,
+        'pt'    => :LENGTH,
+        'pc'    => :LENGTH,
+        'deg'   => :ANGLE,
+        'rad'   => :ANGLE,
+        'grad'  => :ANGLE,
+        'ms'    => :TIME,
+        's'     => :TIME,
+        'hz'    => :FREQ,
+        'khz'   => :FREQ,
+        '%'     => :PERCENTAGE,
+      }.each do |unit,sym|
+        define_method :"test_#{unit}" do
+          ['10', '0.1'].each do |num|
+            num = "#{num}#{unit}"
+            [num, "  #{num}", "#{num}  ", " #{num} "].each do |str|
+              @scanner.scan str
+              assert_tokens([[sym, str]], @scanner)
+            end
+          end
+        end
+      end
+
+      def test_num
+        ['10', '0.1'].each do |num|
+          [num, "  #{num}", "#{num}  ", " #{num} "].each do |str|
+            @scanner.scan str
+            assert_tokens([[:NUMBER, str]], @scanner)
+          end
+        end
+      end
+
+      def test_important
+        [
+          '!important',
+          '  !important',
+          '!important  ',
+          '!  important  ',
+          '  !  important  ',
+        ].each do |str|
+          @scanner.scan str
+          assert_tokens([[:IMPORTANT_SYM, str]], @scanner)
+        end
+      end
+
+      {
+        '@page'     => :PAGE_SYM,
+        '@import'   => :IMPORT_SYM,
+        '@media'    => :MEDIA_SYM,
+        '@charset'  => :CHARSET_SYM,
+      }.each do |k,v|
+        define_method(:"test_#{k.sub(/@/, '')}") do
+          [k, "  #{k}", "#{k}  ", " #{k} "].each do |str|
+            @scanner.scan str
+            assert_tokens([[v, str]], @scanner)
+          end
+        end
+      end
+
+      def test_invalid
+        str = "'internet"
+        @scanner.scan str
+        assert_tokens([[:INVALID, str]], @scanner)
+
+        str = '"internet'
+        @scanner.scan str
+        assert_tokens([[:INVALID, str]], @scanner)
+      end
+
+      #def test_comment
+      #  str = "/**** Hello World ***/"
+      #  @scanner.scan str
+      #  assert_tokens([[:COMMENT, str]], @scanner)
+
+      #  str = "/* Hello World */"
+      #  @scanner.scan str
+      #  assert_tokens([[:COMMENT, str]], @scanner)
+      #end
+
+      def test_rbrace
+        str = "  }  \n  "
+        @scanner.scan str
+        assert_tokens([[:RBRACE, str]], @scanner)
+      end
+
+      def test_lbrace
+        str = "  {    "
+        @scanner.scan str
+        assert_tokens([[:LBRACE, str]], @scanner)
+      end
+
+      def test_semi
+        str = "  ;    "
+        @scanner.scan str
+        assert_tokens([[:SEMI, ';']], @scanner)
+      end
+
+      def test_cdc
+        @scanner.scan("-->")
+        assert_tokens([[:CDC, "-->"]], @scanner)
+      end
+
+      def test_cdo
+        @scanner.scan("<!--")
+        assert_tokens([[:CDO, "<!--"]], @scanner)
+      end
+
+      def test_unicode_range
+        @scanner.scan("U+0-10FFFF")
+        assert_tokens([[:UNICODE_RANGE, "U+0-10FFFF"]], @scanner)
+      end
+
+      def test_url_with_string
+        @scanner.scan("url('http://tlm.com')")
+        assert_tokens([[:URI, "url('http://tlm.com')"]], @scanner)
+      end
+
+      def test_url_with_others
+        @scanner.scan("url(http://tlm.com?f&b)")
+        assert_tokens([[:URI, "url(http://tlm.com?f&b)"]], @scanner)
+      end
+
+      def test_unicode
+        @scanner.scan("a日本語")
+        assert_tokens([[:IDENT, 'a日本語']], @scanner)
+      end
+
+      def test_tokenize_bad_percent
+        @scanner.scan("%")
+        assert_tokens([["%", "%"]], @scanner)
+      end
+
+      def test_not_equal
+        @scanner.scan("h1[a!='Tender Lovemaking']")
+        assert_tokens([ [:IDENT, 'h1'],
+                        [:LSQUARE, '['],
+                        [:IDENT, 'a'],
+                        [:NOT_EQUAL, '!='],
+                        [:STRING, "'Tender Lovemaking'"],
+                        [:RSQUARE, ']'],
+        ], @scanner)
+      end
+
+      def test_negation
+        @scanner.scan("p:not(.a)")
+        assert_tokens([ [:IDENT, 'p'],
+                        [:NOT, ':not('],
+                        ['.', '.'],
+                        [:IDENT, 'a'],
+                        [:RPAREN, ')'],
+        ], @scanner)
+      end
+
+      def test_function
+        @scanner.scan("script comment()")
+        assert_tokens([ [:IDENT, 'script'],
+                        [:S, ' '],
+                        [:FUNCTION, 'comment('],
+                        [:RPAREN, ')'],
+        ], @scanner)
+      end
+
+      def test_preceding_selector
+        @scanner.scan("E ~ F")
+        assert_tokens([ [:IDENT, 'E'],
+                        [:TILDE, ' ~ '],
+                        [:IDENT, 'F'],
+        ], @scanner)
+      end
+
+      def test_scan_attribute_string
+        @scanner.scan("h1[a='Tender Lovemaking']")
+        assert_tokens([ [:IDENT, 'h1'],
+                        [:LSQUARE, '['],
+                        [:IDENT, 'a'],
+                        [:EQUAL, '='],
+                        [:STRING, "'Tender Lovemaking'"],
+                        [:RSQUARE, ']'],
+        ], @scanner)
+        @scanner.scan('h1[a="Tender Lovemaking"]')
+        assert_tokens([ [:IDENT, 'h1'],
+                        [:LSQUARE, '['],
+                        [:IDENT, 'a'],
+                        [:EQUAL, '='],
+                        [:STRING, '"Tender Lovemaking"'],
+                        [:RSQUARE, ']'],
+        ], @scanner)
+      end
+
+      def test_scan_id
+        @scanner.scan('#foo')
+        assert_tokens([ [:HASH, '#foo'] ], @scanner)
+      end
+
+      def test_scan_pseudo
+        @scanner.scan('a:visited')
+        assert_tokens([ [:IDENT, 'a'],
+                        [':', ':'],
+                        [:IDENT, 'visited']
+        ], @scanner)
+      end
+
+      def test_scan_star
+        @scanner.scan('*')
+        assert_tokens([ [:STAR, '*'], ], @scanner)
+      end
+
+      def test_ident_with_minus
+        @scanner.scan('-book')
+        assert_tokens([ [:IDENT, '-book'], ], @scanner)
+      end
+
+      def test_scan_class
+        @scanner.scan('x.awesome')
+        assert_tokens([ [:IDENT, 'x'],
+                        ['.', '.'],
+                        [:IDENT, 'awesome'],
+        ], @scanner)
+      end
+
+      def test_scan_greater
+        @scanner.scan('x > y')
+        assert_tokens([ [:IDENT, 'x'],
+                        [:GREATER, ' > '],
+                        [:IDENT, 'y']
+        ], @scanner)
+      end
+
+      def test_scan_slash
+        @scanner.scan('x/y')
+        assert_tokens([ [:IDENT, 'x'],
+                        [:SLASH, '/'],
+                        [:IDENT, 'y']
+        ], @scanner)
+      end
+
+      def test_scan_doubleslash
+        @scanner.scan('x//y')
+        assert_tokens([ [:IDENT, 'x'],
+                        [:DOUBLESLASH, '//'],
+                        [:IDENT, 'y']
+        ], @scanner)
+      end
+
+      def test_scan_function_selector
+        @scanner.scan('x:eq(0)')
+        assert_tokens([ [:IDENT, 'x'],
+                        [':', ':'],
+                        [:FUNCTION, 'eq('],
+                        [:NUMBER, "0"],
+                        [:RPAREN, ')'],
+        ], @scanner)
+      end
+
+      def test_scan_an_plus_b
+        @scanner.scan('x:nth-child(5n+3)')
+        assert_tokens([ [:IDENT, 'x'],
+                        [':', ':'],
+                        [:FUNCTION, 'nth-child('],
+                        [:NUMBER, '5'],
+                        [:IDENT, 'n'],
+                        [:PLUS, '+'],
+                        [:NUMBER, '3'],
+                        [:RPAREN, ')'],
+        ], @scanner)
+
+        @scanner.scan('x:nth-child(-1n+3)')
+        assert_tokens([ [:IDENT, 'x'],
+                        [':', ':'],
+                        [:FUNCTION, 'nth-child('],
+                        [:MINUS, '-'],
+                        [:NUMBER, '1'],
+                        [:IDENT, 'n'],
+                        [:PLUS, '+'],
+                        [:NUMBER, '3'],
+                        [:RPAREN, ')'],
+        ], @scanner)
+
+        @scanner.scan('x:nth-child(-n+3)')
+        assert_tokens([ [:IDENT, 'x'],
+                        [':', ':'],
+                        [:FUNCTION, 'nth-child('],
+                        [:IDENT, '-n'],
+                        [:PLUS, '+'],
+                        [:NUMBER, '3'],
+                        [:RPAREN, ')'],
+        ], @scanner)
+      end
+
+      def assert_tokens(tokens, scanner)
+        toks = []
+        while tok = @scanner.next_token
+          toks << tok
+        end
+        assert_equal(tokens, toks)
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -9,7 +9,7 @@ module CSSPool
 
     ASSET_DIR = File.join(File.dirname(__FILE__), 'files')
 
-    class MyDoc < CSSPool::SAC::Document
+    class MyDoc < CSSPool::CSS::DocumentHandler
       attr_accessor :start_documents, :end_documents
       attr_accessor :charsets, :import_styles, :comments, :start_selectors
       attr_accessor :end_selectors, :properties
@@ -41,7 +41,7 @@ module CSSPool
         @charsets << [name, location]
       end
 
-      def import_style media_list, uri, default_ns, location
+      def import_style media_list, uri, default_ns = nil, location = {}
         @import_styles << [media_list, uri, default_ns, location]
       end
 

data/test/sac/test_parser.rb

@@ -35,15 +35,13 @@ module CSSPool
       end
 
       def test_charset
-        assert_equal(
-          [["UTF-8", { :line => 1, :byte_offset => 10, :column => 11}]],
-          @doc.charsets)
+        assert_equal("UTF-8", @doc.charsets.first.first)
       end
 
       def test_import_style
         styles = @doc.import_styles.first
-        assert_equal ["screen"], styles.first
-        assert_equal "foo.css", styles[1]
+        assert_equal "screen", styles.first.first.value
+        assert_equal "foo.css", styles[1].value
         assert_nil styles[2]
       end
 
@@ -57,9 +55,6 @@ module CSSPool
         selectors_for_rule = @doc.start_selectors.first
         selector = selectors_for_rule.first # => div a.foo
         assert_equal 2, selector.simple_selectors.length
-        selector.simple_selectors.each do |ss|
-          assert ss.parse_location
-        end
       end
 
       def test_additional_selector_list

data/test/sac/test_terms.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'helper'
 
 module CSSPool
@@ -21,23 +22,21 @@ module CSSPool
           div { border: rgb(1,2,3); }
         eocss
         color = @doc.properties.first[1].first
-        assert_equal 1, color.red
-        assert_equal 2, color.green
-        assert_equal 3, color.blue
-        assert !color.percentage?
-        assert_match('rgb(1,2,3)', color.to_css)
+        assert_equal 1, color.red.value
+        assert_equal 2, color.green.value
+        assert_equal 3, color.blue.value
+        assert_match('rgb(1, 2, 3)', color.to_css)
       end
 
       def test_rgb_with_percentage
         @parser.parse <<-eocss
-          div { border: rgb(100%,2%,3%); }
+          div { border: rgb(100%, 2%, 3%); }
         eocss
         color = @doc.properties.first[1].first
-        assert_equal 100, color.red
-        assert_equal 2, color.green
-        assert_equal 3, color.blue
-        assert color.percentage?
-        assert_match('rgb(100%,2%,3%)', color.to_css)
+        assert_equal 100, color.red.value
+        assert_equal 2, color.green.value
+        assert_equal 3, color.blue.value
+        assert_match('rgb(100%, 2%, 3%)', color.to_css)
       end
 
       def test_negative_number
@@ -48,8 +47,8 @@ module CSSPool
         size = @doc.properties.first[1].first
         assert_equal :minus, size.unary_operator
         assert_equal 1, size.value
-        assert_equal '-1.0px', size.to_s
-        assert_equal '-1.0px', size.to_css
+        assert_equal '-1px', size.to_s
+        assert_equal '-1px', size.to_css
       end
 
       def test_positive_number
@@ -59,13 +58,12 @@ module CSSPool
         assert_equal 1, @doc.properties.length
         size = @doc.properties.first[1].first
         assert_equal 1, size.value
-        assert_equal '1.0px', size.to_s
+        assert_equal '1px', size.to_s
       end
 
       %w{
         1 1em 1ex 1px 1in 1cm 1mm 1pt 1pc 1% 1deg 1rad 1ms 1s 1Hz 1kHz
       }.each do |num|
-        expected = num.sub(/1/, '1.0')
         define_method(:"test_num_#{num}") do
           @parser.parse <<-eocss
             div { border: #{num}; }
@@ -73,19 +71,68 @@ module CSSPool
           assert_equal 1, @doc.properties.length
           size = @doc.properties.first[1].first
           assert_equal 1, size.value
-          assert_equal expected, size.to_s
-          assert_equal expected, size.to_css
+          assert_equal num, size.to_s
+          assert_equal num, size.to_css
         end
       end
 
+      def test_selector_attribute
+        @parser.parse <<-eocss
+          div[attr = value] { }
+          div[attr\\== value] { }
+          div[attr="\\"quotes\\""] { }
+          div[attr = unicode\\ \\1D11E\\BF ] { }
+        eocss
+
+        attrs = @doc.end_selectors.flatten.map(&:simple_selectors).flatten.map(&:additional_selectors).flatten
+        assert_equal 4, attrs.length
+
+        attrs.shift.tap do |attr|
+          assert_equal "attr", attr.name,
+              "Interprets name."
+          assert_equal "value", attr.value,
+              "Interprets bare value."
+        end
+
+        assert_equal "attr=", attrs.shift.name,
+            "Interprets identifier escapes."
+
+        assert_equal "\"quotes\"", attrs.shift.value,
+            "Interprets quoted values."
+
+        assert_equal "unicode \360\235\204\236\302\277", attrs.shift.value,
+            "Interprets unicode escapes."
+      end
+
       def test_string_term
         @parser.parse <<-eocss
-          div { border: "hello"; }
+          div { content: "basic"; }
+          div { content: "\\"quotes\\""; }
+          div { content: "unicode \\1D11E\\BF "; }
+          div { content: "contin\\\nuation"; }
+          div { content: "new\\aline"; }
+          div { content: "\\11FFFF "; }
         eocss
-        assert_equal 1, @doc.properties.length
-        string = @doc.properties.first[1].first
-        assert_equal 'hello', string.value
-        assert_equal '"hello"', string.to_css
+        terms = @doc.properties.map {|s| s[1].first}
+        assert_equal 6, terms.length
+
+        assert_equal 'basic', terms.shift.value,
+            "Recognizes a basic string"
+
+        assert_equal "\"quotes\"", terms.shift.value,
+            "Recognizes strings containing quotes."
+
+        assert_equal "unicode \360\235\204\236\302\277", terms.shift.value,
+            "Interprets unicode escapes."
+
+        assert_equal "continuation", terms.shift.value,
+            "Supports line continuation."
+
+        assert_equal "new\nline", terms.shift.value,
+            "Interprets newline escape."
+
+        assert_equal "\357\277\275", terms.shift.value,
+            "Kills absurd characters."
       end
 
       def test_inherit
@@ -108,26 +155,73 @@ module CSSPool
         assert_equal 'inherit', string.to_css
       end
 
+      def test_declaration
+        @parser.parse <<-eocss
+          div { property: value; }
+          div { colon\\:: value; }
+          div { space\\ : value; }
+        eocss
+        properties = @doc.properties.map {|s| s[0]}
+        assert_equal 3, properties.length
+
+        assert_equal 'property', properties.shift,
+            "Recognizes basic function."
+
+        assert_equal 'colon:', properties.shift,
+            "Recognizes property with escaped COLON."
+
+        assert_equal 'space ', properties.shift,
+            "Recognizes property with escaped SPACE."
+      end
+
       def test_function
         @parser.parse <<-eocss
-          div { border: foo("hello"); }
+          div { content: attr(\"value\", ident); }
+          div { content: \\30(\"value\", ident); }
+          div { content: a\\ function(\"value\", ident); }
+          div { content: a\\((\"value\", ident); }
         eocss
-        assert_equal 1, @doc.properties.length
-        func = @doc.properties.first[1].first
-        assert_equal 'foo', func.name
-        assert_equal 1, func.params.length
-        assert_equal 'hello', func.params.first.value
-        assert_match 'foo("hello")', func.to_css
+        terms = @doc.properties.map {|s| s[1].first}
+        assert_equal 4, terms.length
+
+        assert_equal 'attr', terms.shift.name,
+            "Recognizes basic function."
+
+        assert_equal '0', terms.shift.name,
+            "Recognizes numeric function."
+
+        assert_equal 'a function', terms.shift.name,
+            "Recognizes function with escaped SPACE."
+
+        assert_equal 'a(', terms.shift.name,
+            "Recognizes function with escaped LPAREN."
       end
 
       def test_uri
         @parser.parse <<-eocss
-          div { border: url(http://tenderlovemaking.com/); }
+          div { background: url(http://example.com/); }
+          div { background: url( http://example.com/ ); }
+          div { background: url("http://example.com/"); }
+          div { background: url( " http://example.com/ " ); }
+          div { background: url(http://example.com/\\"); }
         eocss
-        assert_equal 1, @doc.properties.length
-        url = @doc.properties.first[1].first
-        assert_equal 'http://tenderlovemaking.com/', url.value
-        assert_match 'url(http://tenderlovemaking.com/)', url.to_css
+        terms = @doc.properties.map {|s| s[1].first}
+        assert_equal 5, terms.length
+
+        assert_equal 'http://example.com/', terms.shift.value,
+            "Recognizes bare URI."
+
+        assert_equal 'http://example.com/', terms.shift.value,
+            "Recognize URI with spaces"
+
+        assert_equal 'http://example.com/', terms.shift.value,
+            "Recognize quoted URI"
+
+        assert_equal ' http://example.com/ ', terms.shift.value,
+            "Recognize quoted URI"
+
+        assert_equal 'http://example.com/"', terms.shift.value,
+            "Recognizes bare URI with quotes"
       end
     end
   end

data/test/test_collection.rb

@@ -65,7 +65,7 @@ module CSSPool
       }
 
       collection = CSSPool::Collection.new do |url|
-        css[url] || raise
+        css[url] || raise(url.inspect)
       end
 
       collection << '@import url(foo.css);'

data/test/test_parser.rb

@@ -85,7 +85,7 @@ module CSSPool
       doc = CSSPool.CSS <<-eocss
         div { border: foo(1, 2); }
       eocss
-      assert_match('foo(1.0, 2.0)', doc.to_css)
+      assert_match('foo(1, 2)', doc.to_css)
     end
   end
 end

data/test/visitors/test_children.rb

@@ -0,0 +1,20 @@
+require 'helper'
+
+module CSSPool
+  module Visitors
+    class TestChildren < CSSPool::TestCase
+      def test_iterate
+        doc = CSSPool.CSS <<-eocss
+          @charset "UTF-8";
+          @import url("foo.css") screen;
+          div#a, a.foo, a:hover, a[href][int="10"]{ background: red; }
+        eocss
+
+        stack = [doc]
+        until stack.empty? do
+          stack += stack.pop.children
+        end
+      end
+    end
+  end
+end

data/test/visitors/test_comparable.rb

@@ -7,6 +7,21 @@ module CSSPool
         doc1 = CSSPool.CSS css
         doc2 = CSSPool.CSS css
         assert_equal doc1, doc2
+
+        list1 = []
+        list2 = []
+
+        doc1.each { |node| list1 << node }
+        doc2.each { |node| list2 << node }
+
+        assert_equal list1, list2
+
+        stack = [doc1]
+        until stack.empty? do
+          stack += stack.pop.children
+        end
+
+        assert_equal doc1.hash, doc2.hash
       end
 
       def test_not_equal
@@ -18,6 +33,22 @@ module CSSPool
         equalitest 'div { border: #123; }'
       end
 
+      def test_div_with_id
+        equalitest 'div#foo { border: #123; }'
+      end
+
+      def test_div_with_pseudo
+        equalitest 'div:foo { border: #123; }'
+      end
+
+      def test_div_with_universal
+        equalitest '* { border: #123; }'
+      end
+
+      def test_simple
+        equalitest '.foo { border: #123; }'
+      end
+
       def test_rgb
         equalitest 'div { border: rgb(1,2,3); }'
       end
@@ -37,7 +68,6 @@ module CSSPool
       %w{
         1 1em 1ex 1px 1in 1cm 1mm 1pt 1pc 1% 1deg 1rad 1ms 1s 1Hz 1kHz
       }.each do |num|
-        expected = num.sub(/1/, '1.0')
         define_method(:"test_num_#{num}") do
           equalitest "div { border: #{num}; }"
         end