csspool 0.2.6 → 2.0.0

data/test/test_selector_parser.rb

@@ -1,178 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class SelectorParserTest < Test::Unit::TestCase
-  def setup
-    @sac = CSS::SAC::Parser.new()
-    class << @sac.document_handler
-      attr_reader :selectors
-      def start_selector(selectors)
-        @selectors = selectors
-      end
-    end
-  end
-
-  def test_multiple_selectors
-    @sac.parse('h1, h2 { }')
-    selectors = @sac.document_handler.selectors
-    assert_equal(2, selectors.length)
-  end
-
-  def test_eql?
-    @sac.parse('h1, h1 { }')
-    selectors = @sac.document_handler.selectors
-    assert_equal(2, selectors.length)
-    assert_equal selectors[0], selectors[1]
-    assert selectors[0].eql?(selectors[1])
-  end
-
-  def test_adjacent
-    @sac.parse('h1 + h2 { }')
-    selectors = @sac.document_handler.selectors
-    assert_equal(1, selectors.length)
-
-    sel = selectors.first
-    assert_equal(:SAC_DIRECT_ADJACENT_SELECTOR, sel.selector_type)
-
-    sibling = sel.sibling_selector
-    assert sibling
-    assert_equal('h2', sibling.local_name)
-
-    first = sel.selector
-    assert first
-    assert_equal('h1', first.local_name)
-  end
-
-  def test_descendant_non_direct
-    @sac.parse('h1  h2 { }')
-    selectors = @sac.document_handler.selectors
-    assert_equal(1, selectors.length)
-
-    sel = selectors.first
-    assert_equal(:SAC_DESCENDANT_SELECTOR, sel.selector_type)
-
-    ancestor = sel.ancestor_selector
-    assert ancestor
-    assert_equal('h1', ancestor.local_name)
-
-    me = sel.selector
-    assert me
-    assert_equal('h2', me.local_name)
-  end
-
-  def test_descendant_direct
-    @sac.parse('h1 > h2 { }')
-    selectors = @sac.document_handler.selectors
-    assert_equal(1, selectors.length)
-
-    sel = selectors.first
-    assert_equal(:SAC_CHILD_SELECTOR, sel.selector_type)
-
-    ancestor = sel.ancestor_selector
-    assert ancestor
-    assert_equal('h1', ancestor.local_name)
-
-    me = sel.selector
-    assert me
-    assert_equal('h2', me.local_name)
-  end
-
-  @@single_selector_tests = {
-    :id => {
-      :css   => '#foo { }',
-      :value => 'foo',
-      :type  => :SAC_ID_CONDITION,
-    },
-    :class => {
-      :css    => '.foo { }',
-      :value  => 'foo',
-      :type   => :SAC_CLASS_CONDITION,
-    },
-    :attribute => {
-      :css    => '[foo=bar] { }',
-      :value  => 'bar',
-      :type   => :SAC_ATTRIBUTE_CONDITION,
-    },
-    :pseudo => {
-      :css    => ':clicked { }',
-      :value  => 'clicked',
-      :type   => :SAC_PSEUDO_CLASS_CONDITION,
-    }
-  }
-
-  @@multiple_selector_tests = {
-    :ids => {
-      :css    => '#foo#bar#baz { }',
-      :values => %w{ foo bar baz },
-      :types  => [:SAC_ID_CONDITION] * 3,
-    },
-    :classes => {
-      :css    => '.foo.bar.baz { }',
-      :values => %w{ foo bar baz },
-      :types  => [:SAC_CLASS_CONDITION] * 3,
-    },
-    :attributes => {
-      :css    => '[foo=bar][bar=baz] { }',
-      :values => %w{ bar baz },
-      :types  => [:SAC_ATTRIBUTE_CONDITION] * 2,
-    },
-    :pseudo => {
-      :css    => ':clicked:hover { }',
-      :values => %w{ clicked hover },
-      :types  => [:SAC_PSEUDO_CLASS_CONDITION] * 2,
-    }
-  }
-
-  @@single_selector_tests.each do |name,tests|
-    define_method :"test_single_#{name}" do
-      @sac.parse(tests[:css])
-      selectors = @sac.document_handler.selectors
-      assert_equal(1, selectors.length)
-
-      selector = selectors.first
-      assert_nil selector.simple_selector
-      assert selector.condition
-      assert_equal(:SAC_CONDITIONAL_SELECTOR, selector.selector_type)
-
-      condition = selector.condition
-      assert_equal(tests[:type], condition.condition_type)
-      assert_equal(tests[:value], condition.value)
-    end
-  end
-
-  @@multiple_selector_tests.each do |name,tests|
-    define_method :"test_multiple_#{name}" do
-      @sac.parse(tests[:css])
-      selectors = @sac.document_handler.selectors
-      assert_equal(1, selectors.length)
-
-      selector = selectors.first
-      assert_nil selector.simple_selector
-      assert selector.condition
-      assert_equal(:SAC_CONDITIONAL_SELECTOR, selector.selector_type)
-
-      combined = reduce_combinator_condition(selector.condition)
-      assert_equal(tests[:values].length, combined.length)
-      assert_equal(tests[:values], combined.map { |x| x.value })
-      assert_equal(tests[:types], combined.map { |x| x.condition_type })
-    end
-  end
-
-  def reduce_combinator_condition(condition)
-    conditions = []
-    assert_equal(:SAC_AND_CONDITION, condition.condition_type)
-    first = condition.first_condition
-    second = condition.second_condition
-
-    assert first
-    assert second
-    assert_not_equal(:SAC_AND_CONDITION, first.condition_type)
-    conditions << first
-
-    if second.condition_type == :SAC_AND_CONDITION
-      conditions += reduce_combinator_condition(second)
-    else
-      conditions << second
-    end
-    conditions
-  end
-end

data/test/test_sibling_selector.rb

@@ -1,42 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class SiblingSelectorTest < SelectorTestCase
-  def test_hash
-    first = SiblingSelector.new(1,1)
-    second = SiblingSelector.new(1,1)
-    assert_equal first.hash, second.hash
-
-    third = SiblingSelector.new(1,2)
-    assert_not_equal first.hash, third.hash
-  end
-
-  def test_equals2
-    first = SiblingSelector.new(1,1)
-    second = SiblingSelector.new(1,1)
-    assert_equal first, second
-
-    third = SiblingSelector.new(1,2)
-    assert_not_equal first, third
-
-    fourth = SiblingSelector.new(2,1)
-    assert_not_equal first, fourth
-  end
-
-  def test_equals_tilde
-    selector = ElementSelector.new('div')
-    sibling = ElementSelector.new('p')
-    sel = SiblingSelector.new(selector, sibling)
-
-    sibling = Node.new('p', nil, nil, nil) 
-    node = Node.new('div', nil, nil, sibling)
-    assert sel =~ node
-
-    sibling1 = Node.new('div', nil, nil, nil) 
-    node1 = Node.new('p', nil, nil, sibling)
-    assert(! (sel =~ node1))
-
-    assert(! (sel =~ NoParentNode.new('div')))
-    assert(! (sel =~ Node.new('div', nil, nil)))
-  end
-end
-

data/test/test_simple_selector.rb

@@ -1,9 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class SimpleSelectorTest < SelectorTestCase
-  def test_equals_tilde
-    sel = SimpleSelector.new
-    assert(! (sel =~ nil))
-    assert(sel =~ Node.new)
-  end
-end

data/test/test_specificity.rb

@@ -1,76 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-# http://www.w3.org/TR/REC-CSS2/cascade.html#specificity
-# *             {}  /* a=0 b=0 c=0 -> specificity =   0 */
-# LI            {}  /* a=0 b=0 c=1 -> specificity =   1 */
-# UL LI         {}  /* a=0 b=0 c=2 -> specificity =   2 */
-# UL OL+LI      {}  /* a=0 b=0 c=3 -> specificity =   3 */
-# H1 + *[REL=up]{}  /* a=0 b=1 c=1 -> specificity =  11 */
-# UL OL LI.red  {}  /* a=0 b=1 c=3 -> specificity =  13 */ 
-# LI.red.level  {}  /* a=0 b=2 c=1 -> specificity =  21 */
-# #x34y         {}  /* a=1 b=0 c=0 -> specificity = 100 */ 
-class SpecificityTest < Test::Unit::TestCase
-  def setup
-    @sac = CSS::SAC::Parser.new()
-    class << @sac.document_handler
-      attr_accessor :selectors
-      alias :start_selector :selectors=
-    end
-  end
-
-  def test_star
-    @sac.parse('* {}')
-    selector = @sac.document_handler.selectors.first
-    assert_not_nil selector
-    assert_equal [0, 0, 0, 0], selector.specificity
-  end
-
-  def test_li
-    @sac.parse('li {}')
-    selector = @sac.document_handler.selectors.first
-    assert_not_nil selector
-    assert_equal [0, 0, 0, 1], selector.specificity
-  end
-
-  def test_ul_li
-    @sac.parse('ul li {}')
-    selector = @sac.document_handler.selectors.first
-    assert_not_nil selector
-    assert_equal [0, 0, 0, 2], selector.specificity
-  end
-
-  def test_ul_ol_plus_li
-    @sac.parse('ul ol+li {}')
-    selector = @sac.document_handler.selectors.first
-    assert_not_nil selector
-    assert_equal [0, 0, 0, 3], selector.specificity
-  end
-
-  def test_h1_attributes
-    @sac.parse('h1 + *[REL=up] {}')
-    selector = @sac.document_handler.selectors.first
-    assert_not_nil selector
-    assert_equal [0, 0, 1, 1], selector.specificity
-  end
-
-  def test_one_class_selector
-    @sac.parse('ul ol li.red {}')
-    selector = @sac.document_handler.selectors.first
-    assert_not_nil selector
-    assert_equal [0, 0, 1, 3], selector.specificity
-  end
-
-  def test_two_class_selectors
-    @sac.parse('li.red.level {}')
-    selector = @sac.document_handler.selectors.first
-    assert_not_nil selector
-    assert_equal [0, 0, 2, 1], selector.specificity
-  end
-
-  def test_id_selector
-    @sac.parse('#x34y {}')
-    selector = @sac.document_handler.selectors.first
-    assert_not_nil selector
-    assert_equal [0, 1, 0, 0], selector.specificity
-  end
-end

data/test/test_stylesheet.rb

@@ -1,95 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class StyleSheetTest < SelectorTestCase
-  def setup
-    @sac = CSS::SAC::Parser.new
-  end
-
-  def test_rules_matching
-    doc = @sac.parse("div > p { letter-spacing: 1px; }")
-    node = parent_child_tree('div', 'p')
-    expected = doc.rules.first
-
-    found = doc.rules_matching(node)
-    assert_equal 1, found.length
-    assert_equal expected.selector, found.first.selector
-
-    found2 = (doc =~ node)
-    assert_equal 1, found2.length
-    assert_equal expected.selector, found2.first.selector
-  end
-
-  def test_find_rule
-    doc = @sac.parse("h1 { letter-spacing: 1px; }")
-    expected = doc.rules.first
-    assert_equal expected, doc.find_rule('h1')
-    assert_equal expected, doc['h1']
-    assert_equal expected, doc[expected]
-  end
-
-  def test_create_rule
-    doc = @sac.parse("h1 { letter-spacing: 1px; }")
-    rule = doc.create_rule('h1')
-    assert_equal doc.rules.first.selector, rule.selector
-  end
-
-  def test_reduce!
-    doc = @sac.parse(<<END
-  h1 {
-    background-color: red;
-    border-color: green;
-  }
-  h1 { letter-spacing: 1px; }
-END
-    )
-    assert_equal(1, doc.rules.length)
-  end
-
-  def test_rules_by_property
-    doc = @sac.parse(<<END
-  h1 {
-    background-color: red;
-    padding: 100px;
-    border-color: green;
-  }
-  div {
-    border-color: green;
-    background-color: red;
-    padding: 100px;
-  }
-END
-    )
-    assert_equal(2, doc.rules.length)
-    assert_equal(doc.rules[0].properties, doc.rules[1].properties)
-    assert_equal(1, doc.rules_by_property.keys.length)
-    assert_equal(2, doc.rules_by_property.values.first.length)
-  end
-
-  def test_to_css
-    doc = @sac.parse(<<END
-  h1 {
-    background-color: red;
-    padding: 100px;
-    border-color: green;
-  }
-  div {
-    border-color: green;
-    background-color: red;
-    padding: 100px;
-  }
-  .marquee { background: url(images/sfx1_bg.gif) bottom repeat-x;}
-  SELECT {font-family: Arial, Verdana, Geneva, sans-serif; font-size: small; }
-END
-    )
-    css = doc.to_css
-    assert_match('div, h1 {', css)
-
-    [ 'border-color:green;',
-      'background-color:red;',
-      'url(images/sfx1_bg.gif',
-      'Arial, Verdana, Geneva, sans-serif;',
-      'padding:100px;'].each do |attribute|
-      assert_match(attribute, css)
-    end
-  end
-end

data/test/test_token.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class TokenTest < Test::Unit::TestCase
-  include CSS
-
-  def test_tokens_have_a_name_value_and_position
-    token = SAC::Token.new(:foo, "bar", 14)
-    assert_equal(:foo, token.name)
-    assert_equal("bar", token.value)
-    assert_equal(14, token.position)
-  end
-  
-  def test_to_racc_token_returns_a_name_value_array
-    assert_equal([:foo, "bar"], SAC::Token.new(:foo, "bar", 99).to_racc_token)
-  end
-  
-  def test_delimiter_token_is_always_delim
-    assert_equal(:delim, SAC::DelimiterToken.new(";", 99).name)
-  end
-  
-  def test_delimiter_token_just_returns_values_for_racc
-    assert_equal(%w(; ;), SAC::DelimiterToken.new(";", 99).to_racc_token)
-  end
-end

data/test/test_tokenizer.rb

@@ -1,127 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class TokenizerTest < Test::Unit::TestCase
-  include CSS::SAC
-  
-  def setup
-    @tokenizer = Tokenizer.new
-  end
-  
-  def test_tokenize
-    assert_equal([], @tokenizer.tokenize(""))
-  end
-  
-  def test_parse_simple
-    text = '
-      @import "subs.css";
-      * {  margin: 0px; }
-      body {
-        margin: 0px;
-        padding: 0px;
-      }'
-    
-    assert_tokens(text,
-      [:IMPORT_SYM, "@import"],
-      [:STRING, "\"subs.css\""],
-      [:delim, ";"],
-      [:delim, "*"],
-      [:LBRACE, " {"],
-      [:IDENT, "margin"],
-      [:delim, ":"],
-      [:LENGTH, "0px"],
-      [:delim, ";"],
-      [:delim, "}"],
-      [:IDENT, "body"],
-      [:LBRACE, " {"],
-      [:IDENT, "margin"],
-      [:delim, ":"],
-      [:LENGTH, "0px"],
-      [:delim, ";"],
-      [:IDENT, "padding"],
-      [:delim, ":"],
-      [:LENGTH, "0px"],
-      [:delim, ";"],
-      [:delim, "}"])
-  end
-  
-  def test_at_import
-    tokens = @tokenizer.tokenize('@import "subs.css" print;')
-    assert_equal(6, tokens.length)
-  end
-  
-  def test_at_media
-    assert_tokens('@media print { h1 { color: black; } }',
-      [:MEDIA_SYM, "@media"],
-      [:IDENT, "print"],
-      [:LBRACE, " {"],
-      [:IDENT, "h1"],
-      [:LBRACE, " {"],
-      [:IDENT, "color"],
-      [:delim, ":"],
-      [:IDENT, "black"],
-      [:delim, ";"],
-      [:delim, "}"],
-      [:delim, "}"])
-  end
-  
-  def test_at_page
-    tokens = @tokenizer.tokenize('@page print { color: black; }')
-    assert_equal(12, tokens.length)
-  
-    tokens = @tokenizer.tokenize('@page :left { color: black; }')
-    assert_equal(13, tokens.length)
-  
-    tokens = @tokenizer.tokenize('@page print :left { color: black; }')
-    assert_equal(15, tokens.length)
-  end
-  
-  def test_two_strings
-    tokens = @tokenizer.tokenize('"one" "two"')
-    assert_equal(3, tokens.length)
-  end
-
-  def test_at_font_face
-    tokens = @tokenizer.tokenize('@font-face { color: black; }')
-    assert_equal(11, tokens.length)
-  end
-  
-  def test_ignorable_at
-    tokens = @tokenizer.tokenize('@aaron { color: black; }')
-    assert_equal(11, tokens.length)
-  end
-  
-  def test_function_token
-    assert_tokens("foo(aaron)", :FUNCTION, :IDENT, :delim)
-  end
-
-  def test_an_example_of_assert_tokens
-    assert_tokens("body { color: pink; }",
-      :IDENT, :LBRACE, :IDENT, :delim, [:IDENT, "pink"], :delim, :delim)
-  end
-  
-  def test_comment_with_an_asterisk_in_it
-    assert_tokens("/* * */", :COMMENT)
-  end
-  
-  def assert_tokens(text, *expected)
-    tokens = @tokenizer.tokenize(text).reject { |t| t.name == :S }
-    
-    assert_equal(expected.size, tokens.size)
-    
-    count = 1
-        
-    tokens.zip(expected).each do |sets|
-      token, expected_name, expected_value = sets.flatten
-      assert_equal(expected_name, token.name, "token #{count} name")
-      assert_equal(expected_value, token.value, "token #{count} value") if expected_value
-      count += 1
-    end
-  end
-  
-  def test_comments_pattern_is_lazy
-    text = "/* * HAI * */ a {display:block} /* * BAI * */ em {font-style:normal}"
-    assert_tokens text,
-      :COMMENT, :IDENT, :LBRACE, :IDENT, :delim, [:IDENT, "block"], :delim,
-      :COMMENT, :IDENT, :LBRACE, :IDENT, :delim, [:IDENT, "normal"], :delim
-  end
-end

data/test/test_xpath.rb

@@ -1,105 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-# Thanks, Joe!
-# http://www.joehewitt.com/blog/files/getElementsBySelector.js
-
-class XPathTest < Test::Unit::TestCase
-  def setup
-    @parser = CSS::SAC::Parser.new()
-    class << @parser.document_handler
-      attr_accessor :selectors
-      def start_selector(selectors)
-        @selectors = selectors
-      end
-    end
-  end
-  
-  # TODO: looks like attribute value quoting
-  # might be broken on the css side?
-  # this: input[type="text"] should be valid CSS
-  # and probably not return the quotes in the node
-  
-  def test_any
-    assert_xpath("//*", "*")
-  end
-  
-  def test_element
-    assert_xpath("//h1", "h1")
-  end
-  
-  def test_id
-    assert_xpath("//*[@id='foo']", "#foo")
-  end
-  
-  def test_class
-    assert_xpath("//*[contains(@class, 'foo')]", ".foo")
-  end
-    
-  def test_attribute_with_no_value
-    assert_xpath("//*[@checked]", "[checked]")
-  end
-  
-  def test_attribute_with_value
-    assert_xpath("//*[@type='text']", "[type=text]")
-  end
-  
-  def test_hyphen_separated_attribute
-    # the contains behavior is probably fine here
-    assert_xpath("//*[contains(@type, 'text')]", "[type~=text]")    
-  end
-  
-  def test_space_separated_attribute
-    # the contains behavior is probably fine here
-    assert_xpath("//*[contains(@type, 'text')]", "[type|=text]")    
-  end
-  
-  def test_element_with_id
-    assert_xpath("//h1[@id='monkey']", "h1#monkey")
-  end
-  
-  def test_element_with_class
-    assert_xpath("//h1[contains(@class, 'foo')]", "h1.foo")
-  end
-  
-  def test_element_with_id_and_class
-    assert_xpath("//h1[@id='monkey'][contains(@class, 'foo')]", "h1#monkey.foo")
-  end
-  
-  def test_element_with_multiple_classes
-    assert_xpath("//h1[contains(@class, 'foo')][contains(@class, 'bar')]", "h1.foo.bar")
-  end
-  
-  def test_descendant
-    assert_xpath("//div//p", "div p")
-    assert_xpath("//div//*[contains(@class, 'angry')]", "div .angry")
-  end
-  
-  def test_direct_descendant
-    assert_xpath("//div/p", "div > p")
-  end
-  
-  def test_sibling
-    assert_xpath("//div/following-sibling::p", "div + p")
-  end
-  
-  def test_safely_ignores_pseudoclasses
-    assert_xpath("//a", "a:hover")
-  end
-  
-  private
-  
-  def assert_xpath(xpath, css)
-    assert_equal(xpath, selector_for(css).to_xpath)
-  end
-  
-  def selector_for(string)
-    selectors = selectors_for(string)
-    assert_equal(1, selectors.length)
-    selectors.first
-  end
-  
-  def selectors_for(string)
-    @parser.parse("#{string} {}")
-    @parser.document_handler.selectors
-  end
-end