csspool-st 3.1.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

@@ -0,0 +1,65 @@
+require "test/unit"
+require "csspool"
+
+module CSSPool
+  class TestCase < Test::Unit::TestCase
+    unless RUBY_VERSION >= '1.9'
+      undef :default_test
+    end
+
+    ASSET_DIR = File.join(File.dirname(__FILE__), 'files')
+
+    class MyDoc < CSSPool::CSS::DocumentHandler
+      attr_accessor :start_documents, :end_documents
+      attr_accessor :charsets, :import_styles, :comments, :start_selectors
+      attr_accessor :end_selectors, :properties
+
+      def initialize
+        @start_documents  = []
+        @end_documents    = []
+        @charsets         = []
+        @import_styles    = []
+        @comments         = []
+        @start_selectors  = []
+        @end_selectors    = []
+        @properties       = []
+      end
+
+      def property name, expression, important
+        @properties << [name, expression]
+      end
+
+      def start_document
+        @start_documents << true
+      end
+
+      def end_document
+        @end_documents << true
+      end
+
+      def charset name, location
+        @charsets << [name, location]
+      end
+
+      def import_style media_list, uri, default_ns = nil, location = {}
+        @import_styles << [media_list, uri, default_ns, location]
+      end
+
+      def namespace_declaration prefix, uri, location
+        @import_styles << [prefix, uri, location]
+      end
+
+      def comment string
+        @comments << string
+      end
+
+      def start_selector selectors
+        @start_selectors << selectors
+      end
+
+      def end_selector selectors
+        @end_selectors << selectors
+      end
+    end
+  end
+end

data/test/sac/test_parser.rb

@@ -0,0 +1,123 @@
+require 'helper'
+
+module CSSPool
+  module SAC
+    class TestParser < CSSPool::TestCase
+      def setup
+        super
+        @doc = MyDoc.new
+        @css = <<-eocss
+          @charset "UTF-8";
+          @import url("foo.css") screen;
+          /* This is a comment */
+          div a.foo, #bar, * { background: red; }
+          div#a, a.foo, a:hover, a[href][int="10"]{ background: red; }
+          ::selection, q:before { background: red; }
+        eocss
+        @parser = CSSPool::SAC::Parser.new(@doc)
+        @parser.parse(@css)
+      end
+
+      def test_start_and_end_called_with_the_same
+        assert_equal @doc.start_selectors, @doc.end_selectors
+      end
+
+      def test_parse_no_doc
+        parser = CSSPool::SAC::Parser.new
+        parser.parse(@css)
+      end
+
+      def test_start_document
+        assert_equal [true], @doc.start_documents
+      end
+
+      def test_end_document
+        assert_equal [true], @doc.end_documents
+      end
+
+      def test_charset
+        assert_equal("UTF-8", @doc.charsets.first.first)
+      end
+
+      def test_import_style
+        styles = @doc.import_styles.first
+        assert_equal "screen", styles.first.first.first.value
+        assert_equal "foo.css", styles[1].value
+        assert_nil styles[2]
+      end
+
+      def test_start_selector
+        selectors_for_rule = @doc.start_selectors.first
+        assert selectors_for_rule
+        assert_equal 3, selectors_for_rule.length
+      end
+
+      def test_simple_selector
+        selectors_for_rule = @doc.start_selectors.first
+        selector = selectors_for_rule.first # => div a.foo
+        assert_equal 2, selector.simple_selectors.length
+      end
+
+      def test_additional_selector_list
+        selectors_for_rule = @doc.start_selectors.first
+        selector = selectors_for_rule.first # => div a.foo
+        simple_selector = selector.simple_selectors[1] # => a.foo
+        assert additional_selectors = simple_selector.additional_selectors
+        assert_equal 1, additional_selectors.length
+      end
+
+      def test_additional_selector_class_name
+        selectors_for_rule = @doc.start_selectors.first
+        selector = selectors_for_rule.first # => div a.foo
+        simple_selector = selector.simple_selectors[1] # => a.foo
+        assert additional_selectors = simple_selector.additional_selectors
+        foo_class = additional_selectors.first
+        assert_equal 'foo', foo_class.name
+      end
+
+      def test_id_additional_selector
+        selectors_for_rule = @doc.start_selectors[1]
+        selector = selectors_for_rule.first # => div#a
+        simple_selector = selector.simple_selectors.first # => div#a
+        assert_equal 'a', simple_selector.additional_selectors.first.name
+      end
+
+      def test_pseudo_additional_selector
+        selectors_for_rule = @doc.start_selectors[1]
+        selector = selectors_for_rule[2] # => 'a:hover'
+        simple_selector = selector.simple_selectors.first # => a:hover
+        assert_equal 'hover', simple_selector.additional_selectors.first.name
+        assert_nil simple_selector.additional_selectors.first.extra
+      end
+
+      def test_attribute_selector
+        selectors_for_rule = @doc.start_selectors[1]
+        selector = selectors_for_rule[3] # => a[href][int="10"]
+        simple_selector = selector.simple_selectors.first
+
+        assert_equal 'href', simple_selector.additional_selectors.first.name
+        assert_nil simple_selector.additional_selectors.first.value
+        assert_equal 1, simple_selector.additional_selectors.first.match_way
+
+        assert_equal 'int', simple_selector.additional_selectors[1].name
+        assert_equal '10', simple_selector.additional_selectors[1].value
+        assert_equal 2, simple_selector.additional_selectors[1].match_way
+      end
+
+      def test_pseudo_element_additional_selector
+        selectors_for_rule = @doc.start_selectors[2]
+        selector = selectors_for_rule[0]
+
+        simple_selector = selector.simple_selectors[0] # ::selection
+        assert_equal 'selection', simple_selector.additional_selectors.first.name
+        assert_nil simple_selector.additional_selectors.first.css2
+
+        selector = selectors_for_rule[1]
+        simple_selector = selector.simple_selectors[0] # q.before
+        assert_equal 'before', simple_selector.additional_selectors.first.name
+        assert_equal true, simple_selector.additional_selectors.first.css2
+      end
+
+    end
+  end
+end

data/test/sac/test_properties.rb

@@ -0,0 +1,43 @@
+require 'helper'
+
+module CSSPool
+  module SAC
+    class TestProperties < CSSPool::TestCase
+      def setup
+        super
+        @doc = MyDoc.new
+        @css = <<-eocss
+          @charset "UTF-8";
+          @import url("foo.css") screen;
+          /* This is a comment */
+          div a.foo, #bar, * { background: red; }
+          div#a, a.foo, a:hover, a[href][int="10"]{ background: red; }
+        eocss
+        @parser = CSSPool::SAC::Parser.new(@doc)
+        @parser.parse(@css)
+      end
+
+      def test_properties
+        assert_equal ['background'], @doc.properties.map { |x| x.first }.uniq
+        @doc.properties.each do |property|
+          assert_equal 1, property[1].length
+        end
+        assert_equal ['red'], @doc.properties.map { |x| x[1].first.value }.uniq
+      end
+
+      def test_ident_with_comma
+        doc = MyDoc.new
+        parser = CSSPool::SAC::Parser.new(doc)
+        parser.parse <<-eocss
+          h1 { font-family: Verdana, sans-serif, monospace; }
+        eocss
+        assert_equal 1, doc.properties.length
+        values = doc.properties.first[1]
+        assert_equal 3, values.length
+        assert_equal [nil, ',', ','],
+          values.map { |value| value.operator }
+        values.each { |value| assert value.parse_location }
+      end
+    end
+  end
+end