csspool 0.2.6 → 2.0.0

data/lib/css/sac/lexeme.rb

@@ -1,29 +0,0 @@
-module CSS
-  module SAC
-    class Lexeme
-      attr_reader :name, :pattern
-      
-      def initialize(name, pattern=nil, &block)
-        raise ArgumentError, "name required" unless name
-        
-        @name = name
-        patterns = []
-        
-        patterns << pattern if pattern
-        yield(patterns) if block_given?
-        
-        if patterns.empty?
-          raise ArgumentError, "at least one pattern required"
-        end
-        
-        patterns.collect! do |pattern|
-          source = pattern.source
-          source = "\\A#{source}"
-          Regexp.new(source, Regexp::IGNORECASE + Regexp::MULTILINE)
-        end
-
-        @pattern = Regexp.union(*patterns)
-      end
-    end
-  end
-end

data/lib/css/sac/lexical_unit.rb

@@ -1,203 +0,0 @@
-module CSS
-  module SAC
-    class LexicalUnit
-      attr_accessor :dimension_unit_text,
-                    :lexical_unit_type,
-                    :float_value,
-                    :integer_value,
-                    :string_value,
-                    :parameters,
-                    :function_name
-
-      def ==(other)
-        self.class === other && self.lexical_unit_type == other.lexical_unit_type
-      end
-
-      def eql?(other)
-        self == other
-      end
-
-      alias :to_s :string_value
-    end
-
-    class Function < LexicalUnit
-      FUNCTIONS = {
-        'counter'   => :SAC_COUNTER_FUNCTION,
-        'counters'  => :SAC_COUNTERS_FUNCTION,
-        'rect'      => :SAC_RECT_FUNCTION,
-      }
-      def initialize(name, params)
-        self.string_value = "#{name}#{params.join(', ')})"
-        name =~ /^(.*)\(/
-        self.function_name = $1
-        self.parameters = params
-        self.lexical_unit_type = FUNCTIONS[self.function_name] || :SAC_FUNCTION
-      end
-
-      def ==(other)
-        super && %w{ function_name parameters }.all? { |x|
-          self.send(x.to_sym) == other.send(x.to_sym)
-        }
-      end
-
-      def hash
-        ([self.function_name] + parameters).hash
-      end
-    end
-
-    class Color < LexicalUnit
-      def initialize(value)
-        self.string_value = value
-        self.lexical_unit_type = :SAC_RGBCOLOR
-        if value =~ /^#([A-F\d]{1,2})([A-F\d]{1,2})([A-F\d]{1,2})$/
-          self.parameters = [$1, $2, $3].map { |x|
-            x.length == 1 ? (x * 2).hex : x.hex
-          }.map { |x|
-            Number.new(x, '', :SAC_INTEGER)
-          }
-        else
-          self.parameters = [LexicalIdent.new(value)]
-        end
-      end
-
-      def ==(other)
-        super && self.parameters == other.parameters
-      end
-
-      def hash
-        self.parameters.hash
-      end
-
-      def to_s
-        if self.parameters.length < 3
-          super
-        else
-          hex = self.parameters.map { |x|
-            sprintf("%02X", x.integer_value).split('').uniq
-          }.flatten
-          hex.length != 3 ? super : "##{hex.join()}"
-        end
-      end
-    end
-
-    class LexicalString < LexicalUnit
-      def initialize(value)
-        self.string_value = value
-        self.lexical_unit_type = :SAC_STRING_VALUE
-      end
-
-      def ==(other)
-        super && self.string_value == other.string_value
-      end
-
-      def hash
-        self.string_value.hash
-      end
-    end
-
-    class LexicalIdent < LexicalUnit
-      def initialize(value)
-        self.string_value = value
-        self.lexical_unit_type = :SAC_IDENT
-      end
-
-      def ==(other)
-        super && self.string_value == other.string_value
-      end
-
-      def hash
-        self.string_value.hash
-      end
-    end
-
-    class LexicalURI < LexicalUnit
-      def initialize(value)
-        self.string_value = value.gsub(/^url\(/, '').gsub(/\)$/, '')
-        self.lexical_unit_type = :SAC_URI
-      end
-
-      def ==(other)
-        super && self.string_value == other.string_value
-      end
-
-      def hash
-        self.string_value.hash
-      end
-
-      def to_s
-        "url(#{string_value})"
-      end
-    end
-
-    class Number < LexicalUnit
-      NON_NEGATIVE_UNITS = [
-        :SAC_DEGREE,
-        :SAC_GRADIAN,
-        :SAC_RADIAN,
-        :SAC_MILLISECOND,
-        :SAC_SECOND,
-        :SAC_HERTZ,
-        :SAC_KILOHERTZ,
-      ]
-      UNITS = {
-        'deg'   => :SAC_DEGREE,
-        'rad'   => :SAC_RADIAN,
-        'grad'  => :SAC_GRADIAN,
-        'ms'    => :SAC_MILLISECOND,
-        's'     => :SAC_SECOND,
-        'hz'    => :SAC_HERTZ,
-        'khz'   => :SAC_KILOHERTZ,
-        'px'    => :SAC_PIXEL,
-        'cm'    => :SAC_CENTIMETER,
-        'mm'    => :SAC_MILLIMETER,
-        'in'    => :SAC_INCH,
-        'pt'    => :SAC_POINT,
-        'pc'    => :SAC_PICA,
-        '%'     => :SAC_PERCENTAGE,
-        'em'    => :SAC_EM,
-        'ex'    => :SAC_EX,
-      }
-      def initialize(value, unit = nil, type = nil)
-        if value.is_a?(String)
-          value =~ /^(-?[0-9.]*)(.*)$/
-          value = $1
-          unit  ||= $2
-        end
-        type  ||= UNITS[self.dimension_unit_text]
-        self.string_value = "#{value}#{unit}"
-        self.float_value = value.to_f
-        self.integer_value = value.to_i
-        self.dimension_unit_text = unit.downcase
-        self.lexical_unit_type = UNITS[self.dimension_unit_text] ||
-          (value =~ /\./ ? :SAC_NUMBER : :SAC_INTEGER)
-      end
-
-      def ==(other)
-        return true if self.float_value == 0 && other.float_value == 0
-        return false unless super
-        
-        %w{ float_value integer_value dimension_unit_text }.all? { |x|
-          self.send(x.to_sym) == other.send(x.to_sym)
-        }
-      end
-
-      def hash
-        if self.float_value == 0
-          self.float_value.hash
-        else
-          %w{ float_value integer_value dimension_unit_text }.map { |x|
-            self.send(x.to_sym)
-          }.hash
-        end
-      end
-
-      def to_s
-        if self.float_value == 0
-          "0"
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/css/sac/parse_exception.rb

@@ -1,6 +0,0 @@
-module CSS
-  module SAC
-    class ParseException < RuntimeError
-    end
-  end
-end

data/lib/css/sac/parser.rb

@@ -1,115 +0,0 @@
-require "css/sac/visitable"
-require "css/sac/document_handler"
-require "css/sac/error_handler"
-require "css/sac/generated_parser"
-require "css/sac/lexical_unit"
-require "css/sac/parse_exception"
-require "css/sac/tokenizer"
-require "css/sac/property_parser"
-
-require "css/sac/conditions"
-require "css/sac/selectors"
-
-module CSS
-  module SAC
-    class Parser < CSS::SAC::GeneratedParser
-      # The version of CSSPool you're using
-      VERSION = '0.2.6'
-
-      TOKENIZER = Tokenizer.new
-      
-      attr_accessor :document_handler, :error_handler, :logger
-
-      def initialize(document_handler = StyleSheet.new(self))
-        @error_handler = ErrorHandler.new
-        @document_handler = document_handler
-        @property_parser = PropertyParser.new()
-        @tokenizer = TOKENIZER
-        @logger = nil
-      end
-
-      def parse_style_sheet(string)
-        @yydebug = true
-        @tokens = TOKENIZER.tokenize(string)
-        @position = 0
-
-        self.document_handler.start_document(string)
-        do_parse
-        self.document_handler.end_document(string)
-        self.document_handler
-      end
-
-      alias :parse :parse_style_sheet
-
-      def parse_rule(rule)
-        returner = Class.new(DocumentHandler) {
-          attr_accessor :selector
-          alias :start_selector :selector=
-        }.new
-        old_document_handler = self.document_handler
-        self.document_handler = returner
-        self.parse("#{rule} { }")
-        self.document_handler = old_document_handler
-        returner.selector
-      end
-
-      # Returns the parser version.  We return CSS2, but its actually
-      # CSS2.1.  No font-face tags.  Sorry.
-      def parser_version
-        "http://www.w3.org/TR/REC-CSS2"
-      end
-
-      attr_reader :property_parser
-      attr_reader :tokenizer
-
-      private # Bro.
-
-      # We have to eliminate matching pairs.
-      # http://www.w3.org/TR/CSS21/syndata.html#parsing-errors
-      # See the malformed declarations section
-      def eliminate_pair_matches(error_value)
-        pairs = {}
-        pairs['"'] = '"'
-        pairs["'"] = "'"
-        pairs['{'] = '}'
-        pairs['['] = ']'
-        pairs['('] = ')'
-
-        error_value.strip!
-        if pairs[error_value]
-          logger.warn("Eliminating pair for: #{error_value}") if logger
-          loop {
-            token = next_token
-            eliminate_pair_matches(token[1])
-            logger.warn("Eliminated token: #{token.join(' ')}") if logger
-            if token[1] == pairs[error_value]
-              @position -= 1
-              @tokens[@position] = Token.new(:S, ' ', nil) # super hack
-              break
-            end
-          }
-        end
-      end
-
-      def on_error(error_token_id, error_value, value_stack)
-        if logger
-          logger.error(token_to_str(error_token_id))
-          logger.error("error value: #{error_value}")
-        end
-        eliminate_pair_matches(error_value)
-      end
-
-      def next_token
-        return [false, false] if @position >= @tokens.length 
-
-        n_token = @tokens[@position]
-        @position += 1
-        if n_token.name == :COMMENT
-          self.document_handler.comment(n_token.value)
-          return next_token
-        end
-        n_token.to_racc_token
-      end
-    end
-  end
-end

data/lib/css/sac/property_parser.rb

@@ -1,47 +0,0 @@
-require "css/sac/generated_property_parser"
-
-module CSS
-  module SAC
-    class PropertyParser < CSS::SAC::GeneratedPropertyParser
-      def initialize
-        @tokens = []
-        @token_table = Racc_arg[10]
-      end
-
-      def parse_tokens(tokens)
-        negate = false # Nasty hack for unary minus
-        @tokens = tokens.find_all { |x| x.name != :S }.map { |token|
-          tok = if @token_table.has_key?(token.value)
-                  [token.value, token.value]
-                else
-                  if token.name == :delim && !@token_table.has_key?(token.value)
-                    negate = true if token.value == '-'
-                    nil
-                  else
-                    token.to_racc_token
-                  end
-                end
-
-          if negate && tok
-            tok[1] = "-#{tok[1]}"
-            negate = false
-          end
-
-          tok
-        }.compact
-
-        begin
-          return do_parse
-        rescue ParseError => e
-          return nil
-        end
-      end
-
-      private
-      def next_token
-        return [false, false] if @tokens.empty?
-        @tokens.shift
-      end
-    end
-  end
-end

data/lib/css/sac/selectors/child_selector.rb

@@ -1,40 +0,0 @@
-require "css/sac/selectors"
-
-module CSS
-  module SAC
-    module Selectors
-      class ChildSelector < SimpleSelector
-        attr_accessor :ancestor_selector, :simple_selector
-        alias :parent :ancestor_selector
-        alias :selector :simple_selector
-
-        def initialize(parent, selector)
-          super(:SAC_CHILD_SELECTOR)
-          
-          @ancestor_selector = parent
-          @simple_selector = selector
-        end
-
-        def to_css
-          "#{parent.to_css} > #{selector.to_css}"
-        end
-
-        def to_xpath(prefix=true)
-          "#{parent.to_xpath(prefix)}/#{selector.to_xpath(false)}"
-        end
-
-        def specificity
-          parent.specificity.zip(selector.specificity).map { |x,y| x + y }
-        end
-
-        def ==(other)
-          super && parent == other.parent && selector == other.selector
-        end
-
-        def hash
-          [parent, selector].hash
-        end
-      end
-    end
-  end
-end

data/lib/css/sac/selectors/conditional_selector.rb

@@ -1,49 +0,0 @@
-require "css/sac/selectors"
-
-module CSS
-  module SAC
-    module Selectors
-      class ConditionalSelector < SimpleSelector
-        attr_accessor :condition, :simple_selector
-        alias :selector :simple_selector
-
-        def initialize(selector, condition)
-          super(:SAC_CONDITIONAL_SELECTOR)
-
-          @condition = condition
-          @simple_selector = selector
-        end
-
-        def to_css
-          [selector, condition].map { |x|
-            x ? x.to_css : ''
-          }.join('')
-        end
-
-        def to_xpath(prefix=true)
-          atoms = []
-          atoms << "//" if prefix
-          atoms << (selector ? selector.to_xpath(false) : "*")
-          atoms << condition.to_xpath
-
-          atoms.join("")
-        end
-
-        def specificity
-          (selector ? selector.specificity : ([0] * 4)).zip(
-            (condition ? condition.specificity : ([0] * 4))).map { |x,y|
-              x + y
-          }
-        end
-
-        def ==(other)
-          super && condition == other.condition && selector == other.selector
-        end
-
-        def hash
-          [condition, selector].hash
-        end
-      end
-    end
-  end
-end

data/lib/css/sac/selectors/descendant_selector.rb

@@ -1,40 +0,0 @@
-require "css/sac/selectors"
-
-module CSS
-  module SAC
-    module Selectors
-      class DescendantSelector < SimpleSelector
-        attr_accessor :ancestor_selector, :simple_selector
-        alias :ancestor :ancestor_selector
-        alias :selector :simple_selector
-
-        def initialize(ancestor, selector)
-          super(:SAC_DESCENDANT_SELECTOR)
-
-          @ancestor_selector = ancestor
-          @simple_selector = selector
-        end
-
-        def to_css
-          "#{ancestor.to_css} #{selector.to_css}"
-        end
-
-        def to_xpath(prefix=true)
-          "#{ancestor.to_xpath(prefix)}//#{selector.to_xpath(false)}"
-        end
-
-        def specificity
-          ancestor.specificity.zip(selector.specificity).map { |x,y| x + y }
-        end
-
-        def ==(other)
-          super && selector == other.selector && ancestor == other.ancestor
-        end
-        
-        def hash
-          [selector, ancestor].hash
-        end
-      end
-    end
-  end
-end

data/lib/css/sac/selectors/element_selector.rb

@@ -1,39 +0,0 @@
-require "css/sac/selectors"
-
-module CSS
-  module SAC
-    module Selectors
-      class ElementSelector < SimpleSelector
-        attr_reader :local_name
-        alias :name :local_name
-
-        def initialize(name)
-          super(:SAC_ELEMENT_NODE_SELECTOR)
-          @local_name = name
-        end
-
-        def to_css
-          local_name
-        end
-
-        def to_xpath(prefix=true)
-          atoms = [local_name]
-          atoms.unshift("//") if prefix
-          atoms.join
-        end
-
-        def specificity
-          [0, 0, 0, 1]
-        end
-
-        def ==(other)
-          super && name == other.name
-        end
-
-        def hash
-          name.hash
-        end
-      end
-    end
-  end
-end

data/lib/css/sac/selectors/selector.rb

@@ -1,31 +0,0 @@
-module CSS
-  module SAC
-    module Selectors
-      class Selector
-        include CSS::SAC::Visitable
-
-        attr_reader :selector_type
-        
-        def initialize(selector_type)
-          @selector_type = selector_type
-        end
-
-        def ==(other)
-          self.class === other && selector_type == other.selector_type
-        end
-        
-        def hash
-          selector_type.hash
-        end
-
-        def eql?(other)
-          self == other
-        end
-        
-        def =~(node)
-          MatchesVisitor.new(node).accept(self)
-        end
-      end
-    end
-  end
-end

data/lib/css/sac/selectors/sibling_selector.rb

@@ -1,39 +0,0 @@
-require "css/sac/selectors"
-
-module CSS
-  module SAC
-    module Selectors
-      class SiblingSelector < SimpleSelector
-        attr_accessor :selector, :sibling_selector
-        alias :sibling :sibling_selector
-        
-        def initialize(selector, sibling)
-          super(:SAC_DIRECT_ADJACENT_SELECTOR)
-          
-          @selector = selector
-          @sibling_selector = sibling
-        end
-
-        def to_css
-          "#{selector.to_css} + #{sibling.to_css}"
-        end
-
-        def to_xpath(prefix=true)
-          "#{selector.to_xpath(prefix)}/following-sibling::#{sibling.to_xpath(false)}"
-        end
-
-        def specificity
-          selector.specificity.zip(sibling.specificity).map { |x,y| x + y }
-        end
-
-        def ==(other)
-          super && selector == other.selector && sibling == other.sibling
-        end
-
-        def hash
-          [selector, sibling].hash
-        end
-      end
-    end
-  end
-end

data/lib/css/sac/selectors/simple_selector.rb

@@ -1,25 +0,0 @@
-require "css/sac/selectors"
-
-module CSS
-  module SAC
-    module Selectors
-      class SimpleSelector < Selector
-        def initialize(selector_type=:SAC_ANY_NODE_SELECTOR)
-          super(selector_type)
-        end
-
-        def to_css
-          '*'
-        end
-
-        def to_xpath
-          "//*"
-        end
-
-        def specificity
-          [0, 0, 0, 0]
-        end
-      end
-    end
-  end
-end

data/lib/css/sac/selectors.rb

@@ -1,5 +0,0 @@
-require "css/sac/selectors/selector"
-
-%w(simple child conditional descendant element sibling).each do |type|
-  require "css/sac/selectors/#{type}_selector"
-end

data/lib/css/sac/token.rb

@@ -1,27 +0,0 @@
-module CSS
-  module SAC
-    class Token
-      attr_reader :name, :value, :position
-      
-      def initialize(name, value, position)
-        @name = name
-        @value = value
-        @position = position
-      end
-
-      def to_racc_token
-        [name, value]
-      end
-    end
-    
-    class DelimiterToken < Token
-      def initialize(value, position)
-        super(:delim, value, position)
-      end
-      
-      def to_racc_token
-        [value, value]
-      end
-    end  
-  end
-end