csspool 0.1.0

data/lib/css/sac/lexeme.rb

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,111 @@
+module CSS
+  module SAC
+    class LexicalUnit
+      attr_accessor :dimension_unit_text,
+                    :lexical_unit_type,
+                    :float_value,
+                    :integer_value,
+                    :string_value,
+                    :parameters,
+                    :function_name
+
+      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
+    end
+
+    class Color < LexicalUnit
+      def initialize(value)
+        self.string_value = value
+        self.lexical_unit_type = :SAC_RGBCOLOR
+        if value =~ /^#(\d{1,2})(\d{1,2})(\d{1,2})$/
+          self.parameters = [
+            Number.new($1.hex, '', :SAC_INTEGER),
+            Number.new($2.hex, '', :SAC_INTEGER),
+            Number.new($3.hex, '', :SAC_INTEGER)
+          ]
+        else
+          self.parameters = [LexicalIdent.new(value)]
+        end
+      end
+    end
+
+    class LexicalString < LexicalUnit
+      def initialize(value)
+        self.string_value = value
+        self.lexical_unit_type = :SAC_STRING_VALUE
+      end
+    end
+
+    class LexicalIdent < LexicalUnit
+      def initialize(value)
+        self.string_value = value
+        self.lexical_unit_type = :SAC_IDENT
+      end
+    end
+
+    class LexicalURI < LexicalUnit
+      def initialize(value)
+        self.string_value = value.gsub(/^url\(/, '').gsub(/\)$/, '')
+        self.lexical_unit_type = :SAC_URI
+      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
+    end
+  end
+end

data/lib/css/sac/parse_exception.rb

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

data/lib/css/sac/parser.rb

@@ -0,0 +1,98 @@
+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/condition"
+require "css/sac/attribute_condition"
+require "css/sac/selectors"
+
+module CSS
+  module SAC
+    class Parser < CSS::SAC::GeneratedParser
+      # The version of CSSPool you're using
+      VERSION = '0.1.0'
+
+      TOKENIZER = Tokenizer.new
+      
+      attr_accessor :document_handler, :error_handler, :logger
+
+      def initialize(document_handler = nil)
+        @error_handler = ErrorHandler.new
+        @document_handler = document_handler || DocumentHandler.new()
+        @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)
+      end
+
+      alias :parse :parse_style_sheet
+      alias :parse_rule :parse_style_sheet
+
+      # 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
+            break if token[1] == pairs[error_value]
+          }
+        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

@@ -0,0 +1,47 @@
+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.rb

@@ -0,0 +1,87 @@
+module CSS
+  module SAC
+    class Selector
+      attr_reader :selector_type
+    end
+
+    class SimpleSelector < Selector
+      def initialize
+        @selector_type = :SAC_ANY_NODE_SELECTOR
+      end
+
+      def to_css
+        case @selector_type
+        when :SAC_ANY_NODE_SELECTOR
+          '*'
+        end
+      end
+    end
+
+    class ElementSelector < SimpleSelector
+      attr_reader :local_name
+      alias :name :local_name
+
+      def initialize(name)
+        super()
+        @selector_type = :SAC_ELEMENT_NODE_SELECTOR
+        @local_name = name
+      end
+
+      def to_css
+        local_name
+      end
+    end
+
+    class ConditionalSelector < SimpleSelector
+      attr_accessor :condition, :simple_selector
+      alias :selector :simple_selector
+
+      def initialize(selector, condition)
+        @condition  = condition
+        @simple_selector   = selector
+        @selector_type = :SAC_CONDITIONAL_SELECTOR
+      end
+
+      def to_css
+        [selector, condition].map { |x|
+          x ? x.to_css : ''
+        }.join('')
+      end
+    end
+
+    class DescendantSelector < SimpleSelector
+      attr_accessor :ancestor_selector, :simple_selector
+      alias :selector :simple_selector
+
+      def initialize(ancestor, selector, type)
+        @ancestor_selector = ancestor
+        @simple_selector = selector
+        @selector_type = type
+      end
+
+      def to_css
+        descent_token =
+          case @selector_type
+          when :SAC_CHILD_SELECTOR
+            ' > '
+          when :SAC_DESCENDANT_SELECTOR
+            ' '
+          end
+        ancestor_selector.to_css + descent_token + selector.to_css
+      end
+    end
+
+    class SiblingSelector < SimpleSelector
+      attr_accessor :selector, :sibling_selector
+      def initialize(selector, sibling)
+        @selector = selector
+        @sibling_selector = sibling
+        @selector_type = :SAC_DIRECT_ADJACENT_SELECTOR
+      end
+
+      def to_css
+        selector.to_css + ' + ' + sibling_selector.to_css
+      end
+    end
+  end
+end

data/lib/css/sac/token.rb

@@ -0,0 +1,27 @@
+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

data/lib/css/sac/tokenizer.rb

@@ -0,0 +1,186 @@
+require "css/sac/lexeme"
+require "css/sac/token"
+
+module CSS
+  module SAC
+    class Tokenizer
+      def initialize(&block)
+        @lexemes = []
+        @macros = {}
+
+        # http://www.w3.org/TR/CSS21/syndata.html
+        macro(:h, /([0-9a-f])/ )
+        macro(:nonascii, /([\200-\377])/ )
+        macro(:nl, /(\n|\r\n|\r|\f)/ )
+        macro(:unicode, /(\\#{m(:h)}{1,6}(\r\n|[ \t\r\n\f])?)/ )
+        macro(:escape, /(#{m(:unicode)}|\\[^\r\n\f0-9a-f])/ )
+        macro(:nmstart, /([_a-z]|#{m(:nonascii)}|#{m(:escape)})/ )
+        macro(:nmchar, /([_a-z0-9-]|#{m(:nonascii)}|#{m(:escape)})/ )
+        macro(:string1, /(\"([^\n\r\f\\\"]|\\#{m(:nl)}|#{m(:escape)})*\")/ )
+        macro(:string2, /(\'([^\n\r\f\\']|\\#{m(:nl)}|#{m(:escape)})*\')/ )
+        macro(:invalid1, /(\"([^\n\r\f\\\"]|\\#{m(:nl)}|#{m(:escape)})*)/ )
+        macro(:invalid2, /(\'([^\n\r\f\\']|\\#{m(:nl)}|#{m(:escape)})*)/ )
+        macro(:comment, /(\/\*[^*]*\*+([^\/*][^*]*\*+)*\/)/ )
+        macro(:ident, /(-?#{m(:nmstart)}#{m(:nmchar)}*)/ )
+        macro(:name, /(#{m(:nmchar)}+)/ )
+        macro(:num, /([0-9]+|[0-9]*\.[0-9]+)/ )
+        macro(:string, /(#{m(:string1)}|#{m(:string2)})/ )
+        macro(:invalid, /(#{m(:invalid1)}|#{m(:invalid2)})/ )
+        macro(:url, /(([!#\$%&*-~]|#{m(:nonascii)}|#{m(:escape)})*)/ )
+        macro(:s, /([ \t\r\n\f]+)/ )
+        macro(:w, /(#{m(:s)}?)/ )
+        macro(:A, /(a|\\0{0,4}(41|61)(\r\n|[ \t\r\n\f])?)/ )
+        macro(:C, /(c|\\0{0,4}(43|63)(\r\n|[ \t\r\n\f])?)/ )
+        macro(:D, /(d|\\0{0,4}(44|64)(\r\n|[ \t\r\n\f])?)/ )
+        macro(:E, /(e|\\0{0,4}(45|65)(\r\n|[ \t\r\n\f])?)/ )
+        macro(:G, /(g|\\0{0,4}(47|67)(\r\n|[ \t\r\n\f])?|\\g)/ )
+        macro(:H, /(h|\\0{0,4}(48|68)(\r\n|[ \t\r\n\f])?|\\h)/ )
+        macro(:I, /(i|\\0{0,4}(49|69)(\r\n|[ \t\r\n\f])?|\\i)/ )
+        macro(:K, /(k|\\0{0,4}(4b|6b)(\r\n|[ \t\r\n\f])?|\\k)/ )
+        macro(:M, /(m|\\0{0,4}(4d|6d)(\r\n|[ \t\r\n\f])?|\\m)/ )
+        macro(:N, /(n|\\0{0,4}(4e|6e)(\r\n|[ \t\r\n\f])?|\\n)/ )
+        macro(:O, /(o|\\0{0,4}(51|71)(\r\n|[ \t\r\n\f])?|\\o)/ )
+        macro(:P, /(p|\\0{0,4}(50|70)(\r\n|[ \t\r\n\f])?|\\p)/ )
+        macro(:R, /(r|\\0{0,4}(52|72)(\r\n|[ \t\r\n\f])?|\\r)/ )
+        macro(:S, /(s|\\0{0,4}(53|73)(\r\n|[ \t\r\n\f])?|\\s)/ )
+        macro(:T, /(t|\\0{0,4}(54|74)(\r\n|[ \t\r\n\f])?|\\t)/ )
+        macro(:X, /(x|\\0{0,4}(58|78)(\r\n|[ \t\r\n\f])?|\\x)/ )
+        macro(:Z, /(z|\\0{0,4}(5a|7a)(\r\n|[ \t\r\n\f])?|\\z)/ )
+
+        #token :COMMENT do |patterns|
+        #  patterns << /\/\*[^*]*\*+([^\/*][^*]*\*+)*\//
+        #  patterns << /#{m(:s)}+\/\*[^*]*\*+([^\/*][^*]*\*+)*\//
+        #end
+
+        token(:LBRACE, /#{m(:w)}\{/)
+        token(:PLUS, /#{m(:w)}\+/)
+        token(:GREATER, /#{m(:w)}>/)
+        token(:COMMA, /#{m(:w)},/)
+
+        token(:S, /#{m(:s)}/)
+
+        #token :URI do |patterns|
+        #  patterns << /url\(#{m(:w)}#{m(:string)}#{m(:w)}\)/
+        #  patterns << /url\(#{m(:w)}#{m(:url)}#{m(:w)}\)/
+        #end
+
+        token(:FUNCTION, /#{m(:ident)}\(/)
+        token(:IDENT, /#{m(:ident)}/)
+
+        token(:CDO, /<!--/)
+        token(:CDC, /-->/)
+        token(:INCLUDES, /~=/)
+        token(:DASHMATCH, /\|=/)
+        #token(:STRING, /#{m(:string)}/)
+        token(:INVALID, /#{m(:invalid)}/)
+        token(:HASH, /##{m(:name)}/)
+        token(:IMPORT_SYM, /@#{m(:I)}#{m(:M)}#{m(:P)}#{m(:O)}#{m(:R)}#{m(:T)}/)
+        token(:PAGE_SYM, /@#{m(:P)}#{m(:A)}#{m(:G)}#{m(:E)}/)
+        token(:MEDIA_SYM, /@#{m(:M)}#{m(:E)}#{m(:D)}#{m(:I)}#{m(:A)}/)
+        token(:CHARSET_SYM, /@#{m(:C)}#{m(:H)}#{m(:A)}#{m(:R)}#{m(:S)}#{m(:E)}#{m(:T)}/)
+        token(:IMPORTANT_SYM, /!(#{m(:w)}|#{m(:comment)})*#{m(:I)}#{m(:M)}#{m(:P)}#{m(:O)}#{m(:R)}#{m(:T)}#{m(:A)}#{m(:N)}#{m(:T)}/)
+        token(:EMS, /#{m(:num)}#{m(:E)}#{m(:M)}/)
+        token(:EXS, /#{m(:num)}#{m(:E)}#{m(:X)}/)
+
+        token :LENGTH do |patterns|
+          patterns << /#{m(:num)}#{m(:P)}#{m(:X)}/
+          patterns << /#{m(:num)}#{m(:C)}#{m(:M)}/
+          patterns << /#{m(:num)}#{m(:M)}#{m(:M)}/
+          patterns << /#{m(:num)}#{m(:I)}#{m(:N)}/
+          patterns << /#{m(:num)}#{m(:P)}#{m(:T)}/
+          patterns << /#{m(:num)}#{m(:P)}#{m(:C)}/
+        end
+
+        token :ANGLE do |patterns|
+          patterns << /#{m(:num)}#{m(:D)}#{m(:E)}#{m(:G)}/
+          patterns << /#{m(:num)}#{m(:R)}#{m(:A)}#{m(:D)}/
+          patterns << /#{m(:num)}#{m(:G)}#{m(:R)}#{m(:A)}#{m(:D)}/
+        end
+
+        token :TIME do |patterns|
+          patterns << /#{m(:num)}#{m(:M)}#{m(:S)}/
+          patterns << /#{m(:num)}#{m(:S)}/
+        end
+
+        token :FREQ do |patterns|
+          patterns << /#{m(:num)}#{m(:H)}#{m(:Z)}/
+          patterns << /#{m(:num)}#{m(:K)}#{m(:H)}#{m(:Z)}/
+        end
+
+        token(:DIMENSION, /#{m(:num)}#{m(:ident)}/)
+        token(:PERCENTAGE, /#{m(:num)}%/)
+        token(:NUMBER, /#{m(:num)}/)
+
+
+        yield self if block_given?
+      end
+      
+      def tokenize(input_data)
+        tokens = []
+        pos = 0
+
+        comments = input_data.scan(/\/\*[^*]*\*+\//m)
+        non_comments = input_data.split(/\/\*[^*]*\*+\//m)
+
+        # Handle a small edge case, if our CSS is *only* comments,
+        # the split, zip, scan trick won't work
+        if non_comments.length == 0
+          tokens = comments.map { |x| Token.new(:COMMENT, x, nil) }
+        else
+          non_comments.zip(comments).each do |non_comment, comment|
+            non_comment.split(/url\([^\)]*\)/m).zip(
+              non_comment.scan(/url\([^\)]*\)/m)
+            ).each do |non_url, url|
+              non_url.split(/"[^"]*"|'[^']*'/m).zip(
+                non_url.scan(/"[^"]*"|'[^']*'/m)
+              ).each do |non_string, quoted_string|
+                if non_string.length > 0 && non_string =~ /\A\s*\Z/m
+                  tokens << Token.new(:S, non_string, nil)
+                else
+                  non_string.split(/[ \t\r\n\f]*(?![{}+>]*)/m).zip(
+                    non_string.scan(/[ \t\r\n\f]*(?![{}+>]*)/m)
+                  ).each do |string, whitespace|
+                    until string.empty?
+                      token = nil
+                      @lexemes.each do |lexeme|
+                        match = lexeme.pattern.match(string)
+                        if match
+                          token = Token.new(lexeme.name, match.to_s, pos)
+                          break
+                        end
+                      end
+
+                      token ||= DelimiterToken.new(/^./.match(string).to_s, pos)
+
+                      tokens << token
+                      string = string.slice(Range.new(token.value.length, -1))
+                      pos += token.value.length
+                    end
+                    tokens << Token.new(:S, whitespace, nil) if whitespace
+                  end
+                end
+                tokens << Token.new(:STRING, quoted_string, nil) if quoted_string
+              end
+              tokens << Token.new(:URI, url, nil) if url
+            end
+            tokens << Token.new(:COMMENT, comment, nil) if comment
+          end
+        end
+        
+        tokens
+      end
+      
+      private
+      
+      def token(name, pattern=nil, &block)
+        @lexemes << Lexeme.new(name, pattern, &block)
+      end
+
+      def macro(name, regex=nil)
+        regex ? @macros[name] = regex : @macros[name].source
+      end
+
+      alias :m :macro
+    end
+  end
+end

data/lib/css/sac.rb

@@ -0,0 +1,13 @@
+require "css/sac/parser"
+
+module CSS
+  module SAC
+    class << self
+      def parse(text)
+        parser = CSS::SAC::Parser.new
+        parser.parse(text)
+        parser
+      end      
+    end
+  end
+end