excession 0.0.3

data/lib/excession/css_regex_hue_mod.rb

@@ -0,0 +1,281 @@
+module Excession
+  class CssRegexHueMod
+
+    HASHSIX = /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})(\s|;|})/i
+    HASHTHREE = /#([a-f0-9])([a-f0-9])([a-f0-9])(\s|;|})/i
+    RGBCALL = /rgb\(\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\s*,\s*(-?[0-9]+)\)/i
+    RGBPCTCALL = /rgb\(\s*(-?[0-9]+)\s*%\s*,\s*(-?[0-9]+)\s*%\s*,\s*(-?[0-9]+)\s*%\s*\)/i
+
+
+    # Use this entry point.
+    def rotate_hue(angle_degrees, str)
+      replace_colours(str) do |hsl| 
+        h,s,l = *hsl
+        [h+angle_degrees, s, l]
+      end
+    end
+
+
+
+    def rgb_to_hsl(rgbint)
+      rgb = rgbint.map{|i| i/255.0}
+      maxcolour = rgb.max
+      mincolour = rgb.min
+
+      #puts "maxcolour: #{maxcolour}"
+      #puts "mincolour: #{mincolour}"
+
+      cdiff = (maxcolour-mincolour)
+      csum = (maxcolour + mincolour)
+
+      #puts "cdiff: #{cdiff}"
+      #puts "csum: #{csum}"
+
+      l = csum/2
+      #puts "l: #{l}"
+      h,s = 0,0
+      if maxcolour != mincolour
+        s = l < 0.5 ? cdiff/csum : cdiff/(2.0-csum)
+        #puts "s: #{s}"
+        r,g,b = rgb
+        h = if r == maxcolour
+              (g-b)/cdiff
+            elsif g == maxcolour
+              2.0+(b-r)/cdiff
+            else
+              4.0+(r-g)/cdiff
+            end
+        #puts "h: #{h}"
+      end
+
+      return [(h*360)%360,s,l]
+    end
+
+    def hsl_to_rgb(hsl)
+      hdeg,s,l = *hsl
+
+      rgb = nil
+      if s == 0
+        rgb = [l,l,l]
+      else
+        temp2 =  l < 0.5 ? l*(1+s) : l+s-l*s
+        temp1 = 2.0*l-temp2
+        h = hdeg/360.0
+        temp3 = [h+1.0/3.0, h, h-1.0/3.0].map{|i| i < 0 ? i+1 : (i > 1 ? i-1 : i)}
+        rgb = temp3.map do |i|
+          if 6.0*i < 1
+            temp1 + (temp2-temp1)*6.0*i
+          elsif 2*i < 1
+            temp2
+          elsif 3*i < 2
+            temp1 + (temp2-temp1)*((2.0/3.0)-i)*6.0
+          else
+            temp1
+          end
+        end
+      end
+      rgb.map{|i| (i*255).floor}
+    end
+
+    def rgb_to_hashsix(rgb)
+      "#" + rgb.map do |i| 
+        str = i.to_s(16)
+        raise "Invalid colour (#{rgb.inspect})!" if str.length > 2
+        str="0"+str if str.length<2
+        str
+      end.join
+    end
+
+    def modify_hsl(hsl, &blk)
+      newhsl = blk.call(hsl)
+      newhsl[0] %= 360
+      newhsl
+    end
+
+    def modify_rgb(rgb, &blk)
+      rgb_to_hashsix(hsl_to_rgb(modify_hsl(rgb_to_hsl(rgb), &blk)))
+    end
+
+    def replace_colours(str, &blk)
+
+      str.gsub!(HASHSIX) do
+        hexr, hexg, hexb, tend = $1, $2, $3, $4
+        modify_rgb([hexr, hexg, hexb].map(&:hex), &blk)+tend
+      end
+
+      str.gsub!(HASHTHREE) do 
+        hexr, hexg, hexb, tend = $1, $2, $3, $4
+        modify_rgb([hexr*2,hexg*2,hexb*2].map(&:hex), &blk)+tend
+      end
+
+      str.gsub!(RGBCALL) do
+        strr, strg, strb = $1, $2, $3
+        modify_rgb([strr, strg, strb].map{|s|Integer(s)}, &blk)
+      end
+      
+      str.gsub!(RGBPCTCALL) do
+        strr, strg, strb = $1, $2, $3
+        modify_rgb([strr, strg, strb].
+                   map{|s|Integer(s)}.
+                   map{|i| (i/100.0) * 255 }, # Don't just multiply by 2.55, it's not accurate
+                   &blk)
+      end
+      
+      str
+    end
+
+  end # class CssRegexHueMod
+end # module Excession
+
+
+=begin
+COLOUR_LOOKUP = {
+  "AliceBlue" =>"#F0F8FF",
+  "AntiqueWhite" =>"#FAEBD7",
+  "Aqua" =>"#00FFFF",
+  "Aquamarine" =>"#7FFFD4",
+  "Azure" =>"#F0FFFF",
+  "Beige" =>"#F5F5DC",
+  "Bisque" =>"#FFE4C4",
+  "Black" =>"#000000",
+  "BlanchedAlmond" =>"#FFEBCD",
+  "Blue" =>"#0000FF",
+  "BlueViolet" =>"#8A2BE2",
+  "Brown" =>"#A52A2A",
+  "BurlyWood" =>"#DEB887",
+  "CadetBlue" =>"#5F9EA0",
+  "Chartreuse" =>"#7FFF00",
+  "Chocolate" =>"#D2691E",
+  "Coral" =>"#FF7F50",
+  "CornflowerBlue" =>"#6495ED",
+  "Cornsilk" =>"#FFF8DC",
+  "Crimson" =>"#DC143C",
+  "Cyan" =>"#00FFFF",
+  "DarkBlue" =>"#00008B",
+  "DarkCyan" =>"#008B8B",
+  "DarkGoldenRod" =>"#B8860B",
+  "DarkGray" =>"#A9A9A9",
+  "DarkGrey" =>"#A9A9A9",
+  "DarkGreen" =>"#006400",
+  "DarkKhaki" =>"#BDB76B",
+  "DarkMagenta" =>"#8B008B",
+  "DarkOliveGreen" =>"#556B2F",
+  "Darkorange" =>"#FF8C00",
+  "DarkOrchid" =>"#9932CC",
+  "DarkRed" =>"#8B0000",
+  "DarkSalmon" =>"#E9967A",
+  "DarkSeaGreen" =>"#8FBC8F",
+  "DarkSlateBlue" =>"#483D8B",
+  "DarkSlateGray" =>"#2F4F4F",
+  "DarkSlateGrey" =>"#2F4F4F",
+  "DarkTurquoise" =>"#00CED1",
+  "DarkViolet" =>"#9400D3",
+  "DeepPink" =>"#FF1493",
+  "DeepSkyBlue" =>"#00BFFF",
+  "DimGray" =>"#696969",
+  "DimGrey" =>"#696969",
+  "DodgerBlue" =>"#1E90FF",
+  "FireBrick" =>"#B22222",
+  "FloralWhite" =>"#FFFAF0",
+  "ForestGreen" =>"#228B22",
+  "Fuchsia" =>"#FF00FF",
+  "Gainsboro" =>"#DCDCDC",
+  "GhostWhite" =>"#F8F8FF",
+  "Gold" =>"#FFD700",
+  "GoldenRod" =>"#DAA520",
+  "Gray" =>"#808080",
+  "Grey" =>"#808080",
+  "Green" =>"#008000",
+  "GreenYellow" =>"#ADFF2F",
+  "HoneyDew" =>"#F0FFF0",
+  "HotPink" =>"#FF69B4",
+  "IndianRed" =>"#CD5C5C",
+  "Indigo" =>"#4B0082",
+  "Ivory" =>"#FFFFF0",
+  "Khaki" =>"#F0E68C",
+  "Lavender" =>"#E6E6FA",
+  "LavenderBlush" =>"#FFF0F5",
+  "LawnGreen" =>"#7CFC00",
+  "LemonChiffon" =>"#FFFACD",
+  "LightBlue" =>"#ADD8E6",
+  "LightCoral" =>"#F08080",
+  "LightCyan" =>"#E0FFFF",
+  "LightGoldenRodYellow" =>"#FAFAD2",
+  "LightGray" =>"#D3D3D3",
+  "LightGrey" =>"#D3D3D3",
+  "LightGreen" =>"#90EE90",
+  "LightPink" =>"#FFB6C1",
+  "LightSalmon" =>"#FFA07A",
+  "LightSeaGreen" =>"#20B2AA",
+  "LightSkyBlue" =>"#87CEFA",
+  "LightSlateGray" =>"#778899",
+  "LightSlateGrey" =>"#778899",
+  "LightSteelBlue" =>"#B0C4DE",
+  "LightYellow" =>"#FFFFE0",
+  "Lime" =>"#00FF00",
+  "LimeGreen" =>"#32CD32",
+  "Linen" =>"#FAF0E6",
+  "Magenta" =>"#FF00FF",
+  "Maroon" =>"#800000",
+  "MediumAquaMarine" =>"#66CDAA",
+  "MediumBlue" =>"#0000CD",
+  "MediumOrchid" =>"#BA55D3",
+  "MediumPurple" =>"#9370D8",
+  "MediumSeaGreen" =>"#3CB371",
+  "MediumSlateBlue" =>"#7B68EE",
+  "MediumSpringGreen" =>"#00FA9A",
+  "MediumTurquoise" =>"#48D1CC",
+  "MediumVioletRed" =>"#C71585",
+  "MidnightBlue" =>"#191970",
+  "MintCream" =>"#F5FFFA",
+  "MistyRose" =>"#FFE4E1",
+  "Moccasin" =>"#FFE4B5",
+  "NavajoWhite" =>"#FFDEAD",
+  "Navy" =>"#000080",
+  "OldLace" =>"#FDF5E6",
+  "Olive" =>"#808000",
+  "OliveDrab" =>"#6B8E23",
+  "Orange" =>"#FFA500",
+  "OrangeRed" =>"#FF4500",
+  "Orchid" =>"#DA70D6",
+  "PaleGoldenRod" =>"#EEE8AA",
+  "PaleGreen" =>"#98FB98",
+  "PaleTurquoise" =>"#AFEEEE",
+  "PaleVioletRed" =>"#D87093",
+  "PapayaWhip" =>"#FFEFD5",
+  "PeachPuff" =>"#FFDAB9",
+  "Peru" =>"#CD853F",
+  "Pink" =>"#FFC0CB",
+  "Plum" =>"#DDA0DD",
+  "PowderBlue" =>"#B0E0E6",
+  "Purple" =>"#800080",
+  "Red" =>"#FF0000",
+  "RosyBrown" =>"#BC8F8F",
+  "RoyalBlue" =>"#4169E1",
+  "SaddleBrown" =>"#8B4513",
+  "Salmon" =>"#FA8072",
+  "SandyBrown" =>"#F4A460",
+  "SeaGreen" =>"#2E8B57",
+  "SeaShell" =>"#FFF5EE",
+  "Sienna" =>"#A0522D",
+  "Silver" =>"#C0C0C0",
+  "SkyBlue" =>"#87CEEB",
+  "SlateBlue" =>"#6A5ACD",
+  "SlateGray" =>"#708090",
+  "SlateGrey" =>"#708090",
+  "Snow" =>"#FFFAFA",
+  "SpringGreen" =>"#00FF7F",
+  "SteelBlue" =>"#4682B4",
+  "Tan" =>"#D2B48C",
+  "Teal" =>"#008080",
+  "Thistle" =>"#D8BFD8",
+  "Tomato" =>"#FF6347",
+  "Turquoise" =>"#40E0D0",
+  "Violet" =>"#EE82EE",
+  "Wheat" =>"#F5DEB3",
+  "White" =>"#FFFFFF",
+  "WhiteSmoke" =>"#F5F5F5",
+  "Yellow" =>"#FFFF00",
+  "YellowGreen" =>"#9ACD32"
+}
+=end

data/lib/excession/parser.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Excession
+
+  module Parser
+    
+    def self.parse(str)
+      CssTransform.new.apply(CssParser.new.parse(str))
+    end # def self.parse
+  
+
+    
+    class CssTransform < Parslet::Transform
+      rule(:comment => simple(:content)){CommentNode.new(content)}
+      rule(:whitespace => simple(:content)){WhitespaceNode.new(content)}
+      rule(:selectors => simple(:selectors)){SelectorsNode.new(selectors)}
+      rule(:ruleset => simple(:ruleset)){RulesetNode.new(ruleset)}
+      rule(:children => sequence(:children)){CssFile.new(children)}
+    end
+
+
+    class CssFile < Struct.new(:children)
+
+    end
+  
+
+    class CommentNode < Struct.new(:content)
+    end
+
+    class WhitespaceNode < Struct.new(:content)
+    end
+
+    class SelectorsNode < Struct.new(:selectors)
+    end
+
+    class RulesetNode < Struct.new(:selectors, :children)
+    end
+
+
+  end # class Parser
+
+
+  
+
+
+
+end # module Excession

data/lib/excession/parser/css_parser.rb

@@ -0,0 +1,391 @@
+# encoding: utf-8
+require 'parslet'
+
+module Excession
+
+  module Parser
+    
+
+    class CssParser < Parslet::Parser
+      def initialize(strict=false)
+        @strict=strict
+        super()
+      end
+
+      rule(:h){  match["0-9a-fA-F"] }
+      rule(:nonascii){ match["\200-\377".force_encoding("BINARY")] }
+      rule(:unicode){ 
+        str("\\") >> h.repeat(1,6) >> (str("\r\n") | match[" \t\r\n\f"]).maybe 
+      }
+      rule(:escape){
+       (unicode | (str("\\\\") >> match["\r\n\f0-9a-fA-F"].absnt? >> any))
+      }
+      rule(:nmstart){ match["_a-zA-Z"] | nonascii | escape }
+      rule(:nmchar){ match["_a-zA-Z0-9-"] | nonascii | escape }
+      rule(:nl){ str("\n") | str("\r\n") | str("\r") | str("\f") }
+      rule(:dqstring_contents){
+        (
+         (match["\n\r\f\""].absnt? >> any) |
+         (str("\\\\") >> nl) |
+         escape
+        ).repeat
+      }
+      rule(:sqstring_contents){
+        (
+         (match["\n\r\f'"].absnt? >> any) |
+         (str("\\\\") >> nl) |
+         escape
+        ).repeat
+      }
+      rule(:string1){ str('"') >> dqstring_contents  >>  str('"') }
+      rule(:string2){ str("'") >> sqstring_contents >>   str("'") }
+      rule(:badstring1){ str('"') >> dqstring_contents >> str("\\").maybe }
+      rule(:badstring2){ str("'") >> sqstring_contents >> str("\\").maybe }
+      rule(:badcomment1){ 
+        str("/*") >> 
+        (match["*"].absnt? >> any).repeat >>
+        str("*").repeat(1) >>
+        (
+         match["/*"].absnt? >> any >>
+         (match["*"].absnt? >> any).repeat >>
+         str("*").repeat(1)
+         ).repeat
+      }
+      rule(:badcomment2){
+        str("/*") >>
+        (match["*"].absnt? >> any).repeat >>
+        (
+         str("*").repeat(1) >>
+         match["/*"].absnt? >> any >>
+         (match["*"].absnt? >> any).repeat
+         ).repeat
+      }
+
+
+      # These are used to get the JS in an expression() declaration.
+      # Since we don't care much for parsing JS here, I'm just using
+      # the rule that valid JS must have balanced parens, and ignore
+      # unbalanced parens in comments and strings. For now.
+      # Thanks, IE.
+      rule(:js_chars){ (match["()"].absnt? >> any).repeat(1) }
+      rule(:js_bracketed){ str("(") >> js_balancing.maybe >> str(")") }
+      rule(:js_balancing){ ( js_chars | js_bracketed ).repeat(1) }
+      
+
+      rule(:s){ match[" \t\r\n\f"].repeat(1) }
+      rule(:w){ s.repeat(0) }
+
+      rule(:baduri1){
+        str("url(") >> w >> 
+        (
+         match['!#$%&*-\[\]-~'] |
+         nonascii |
+         escape
+         ).repeat >>
+        w
+      }
+
+      rule(:string){ string1 | string2  }
+      
+      rule(:baduri2){ str("url(") >> w >> string >> w  }
+
+      rule(:badstring){ badstring1 | badstring2 }
+      rule(:baduri3){ str("url(") >> w >> badstring }
+
+
+      rule(:comment){ 
+        str("/*") >>
+        (
+         match["*"].absnt? >> any
+         ).repeat >>
+        str("*").repeat(1) >> 
+        (
+         match["*/"].absnt? >> any >>
+         (match["*"].absnt? >> any).repeat >>
+         str("*").repeat(1)
+         ).repeat >>
+        str("/")
+      }
+      
+
+      rule(:ident){
+        str("-").maybe >> nmstart >> nmchar.repeat
+      }
+
+      rule(:name){ nmchar.repeat(1) }
+      rule(:num){ 
+        (
+         match["0-9"].repeat(0) >> 
+         str(".") >> 
+         match["0-9"].repeat(1)
+         ) |
+        match["0-9"].repeat(1) 
+      }
+
+
+      rule(:badcomment){ badcomment1 | badcomment2 }
+      
+      rule(:baduri){ baduri2 | baduri3 | baduri1 }
+
+      rule(:url){
+        (
+         match['!#$%&*-~'] |
+         nonascii |
+         escape
+         ).repeat
+      }
+      
+      # Case insensitive character match with escaped character codes.
+      #
+      # TODO: The CSS2.1 spec allows all letters apart from
+      # a,c,d and e to be specified like "\g". This is not supported
+      # here.
+      def cimatch(char)
+        upper = char.upcase.force_encoding("BINARY")
+        lower = char.downcase.force_encoding("BINARY")
+        return match["#{upper}#{lower}"] | 
+          ( str("\\") >> 
+            str("0").repeat(0,4) >>
+            (str(upper[0].ord.to_s(16)) | str(lower[0].ord.to_s(16))) >>
+            (str("\r\n") | match[" \t\r\n\f"]).maybe )
+      end
+    
+
+      def cimatch_word(word)
+        word.each_char.map{|c| self.cimatch(c)}.reduce(:>>)
+      end
+
+
+      rule(:sym_comment){ comment.as(:comment) }
+      # NB: Deviation. Comments are ignored in the 2.1 grammar, but I
+      # want to preserve them. I've made the S symbol cover comments
+      # as well.
+      rule(:sym_s){ sym_comment | s.as(:s) }
+      rule(:sym_s_star){ sym_s.repeat }
+      rule(:sym_badcomment){ badcomment.as(:badcomment) }
+      rule(:sym_cdo){ str("<!--").as(:cdo) }
+      rule(:sym_cdc){ str("-->").as(:cdc) }
+      rule(:sym_includes){ str("~=").as(:includes) }
+      rule(:sym_dashmatch){ str("|=").as(:dashmatch) }
+      rule(:sym_string){ string.as(:string) }
+      rule(:sym_badstring){ badstring.as(:badstring) }
+      rule(:sym_ident){ ident.as(:ident) }
+
+      rule(:sym_hash){ (str("#") >> name).as(:hash) }
+
+      rule(:sym_import_sym){
+        (str("@") >> cimatch_word("import")).as(:import_sym)
+      }
+      rule(:sym_page_sym){
+        (str("@") >> cimatch_word("page")).as(:page_sym)
+      }
+      rule(:sym_media_sym){
+        (str("@") >> cimatch_word("media")).as(:media_sym)
+      }
+
+      rule(:sym_charset_sym){
+        str("@charset ").as(:charset_sym)
+      }
+
+      rule(:sym_important_sym){
+        # NB deviation: s is a w in the spec
+        (str("!") >> 
+         (comment | s).repeat >> 
+         cimatch_word("important")
+         ).as(:important_sym)
+      }
+      
+
+      rule(:sym_ems){
+        (num.as(:num) >> cimatch_word("em").as(:unit)).as(:ems)
+      }
+      rule(:sym_exs){
+        (num.as(:num) >> cimatch_word("ex").as(:unit)).as(:exs)
+      }
+      rule(:sym_length){
+        units = %w{px cm mm in pt pc}
+        unit_matcher = units.map{|u| cimatch_word(u)}.reduce(:|)
+
+        (num.as(:num) >> unit_matcher.as(:unit)).as(:length)
+      }
+      rule(:sym_angle){
+        units = %w{deg rad grad}
+        unit_matcher = units.map{|u| cimatch_word(u)}.reduce(:|)
+
+        (num.as(:num) >> unit_matcher.as(:unit)).as(:angle)
+      }
+      rule(:sym_time){
+        units = %w{ms s}
+        unit_matcher = units.map{|u| cimatch_word(u)}.reduce(:|)
+
+        (num.as(:num) >> unit_matcher.as(:unit)).as(:time)
+      }
+      rule(:sym_freq){
+        units = %w{hz khz}
+        unit_matcher = units.map{|u| cimatch_word(u)}.reduce(:|)
+
+        (num.as(:num) >> unit_matcher.as(:unit)).as(:freq)
+      }
+      rule(:sym_dimension){
+        (num.as(:num) >> ident.as(:unit)).as(:dimension)
+      }
+      rule(:sym_percentage){
+        (num.as(:num) >> str("%").as(:unit)).as(:percentage)
+      }
+      rule(:sym_number){ (num.as(:num)).as(:number) }
+      rule(:sym_uri){
+        (cimatch_word("url") >> str("(") >> 
+         (string.as(:string) | url.as(:url)) >> 
+         str(")")).as(:uri)
+      }
+      rule(:sym_js){ js_balancing }
+
+      rule(:sym_baduri){ baduri.as(:baduri) }
+
+      rule(:sym_function){ (ident.as(:name) >> str("(")).as(:function) }
+      rule(:sym_expression){ cimatch_word("expression") >> str("(") }
+
+      
+
+      rule(:prod_hexcolor){ sym_hash >> sym_s_star }
+
+      rule(:prod_operator){ match["/,"] >> sym_s_star }
+      rule(:prod_unary_operator){ match["-+"] }
+      rule(:prod_combinator){ match["+>"] >> sym_s_star }
+
+      rule(:prod_function){
+        sym_function >> sym_s_star >> prod_function_arglist >> str(")") >> sym_s_star
+      }
+
+      rule(:prod_expression){
+        sym_expression >> sym_s_star >> sym_js.as(:js) >> str(")") >> sym_s_star
+      }
+      
+      rule(:prod_maybe_named_arg){
+        ((sym_ident >> str("=")).maybe >> prod_term)
+      }
+
+      rule(:prod_function_arglist){
+        if @strict
+          prod_expr
+        else
+          # This works around IE, which allows things like:
+          # filter: alpha(opacity=90)
+          prod_maybe_named_arg >> 
+            ( prod_operator.maybe >> 
+              prod_maybe_named_arg ).repeat
+        end
+      }
+
+      rule(:prod_term){
+        # expression() is a deprecated IE extension which allows arbitrary
+        # JS expressions (!) to be used for property values. This was a STUPID
+        # IDEA, but it's still used to give IE6 approximately modern functionality.
+        ( @strict ? prod_function : (prod_expression | prod_function) ) |
+        ( prod_unary_operator.maybe >> 
+          ( sym_percentage | sym_length | sym_ems | sym_exs | sym_angle | 
+            sym_time | sym_freq | sym_number ) >>
+          sym_s_star ) |
+        ( ( sym_string | sym_uri | sym_ident ) >> sym_s_star ) |
+        prod_hexcolor
+      }
+
+
+      rule(:prod_expr){
+        prod_term >> ( prod_operator.maybe >> prod_term ).repeat
+      }
+
+      rule(:prod_prio){ sym_important_sym >> sym_s_star }
+      rule(:prod_property){ sym_ident >> sym_s_star  }
+      rule(:prod_declaration){ 
+        base = ( prod_property.as(:property) >> str(":") >> 
+                 sym_s_star >> prod_expr.as(:value) >> prod_prio.maybe )
+        # Only old IE versions need to pay attention to this. Or rather,
+        # this is used to flag declarations as only applying to old IE versions,
+        # because they don't correctly ignore the declaration.
+        @strict ? base : ( str("*").maybe.as(:star) >> base )
+      }
+
+      rule(:prod_pseudo){
+        str(":") >> ( ( sym_function >> sym_s_star >> 
+                        ( sym_ident >> sym_s_star ).maybe >> str(")") ) | 
+                      sym_ident)
+      }
+
+      rule(:prod_attrib){
+        str("[") >> sym_s_star >> sym_ident.as(:key) >> sym_s_star >> 
+        (
+         ( sym_includes | sym_dashmatch | str("=") ) >> sym_s_star >>
+         ( sym_string | sym_ident ).as(:value) >> sym_s_star
+         ).maybe >>
+        str("]")
+      }
+      
+      rule(:prod_element_name){ sym_ident | str("*") }
+      rule(:prod_class){ str(".") >> sym_ident }
+
+      rule(:prod_simple_selector){
+        ( prod_element_name >>
+          ( sym_hash | prod_class | prod_attrib | prod_pseudo ).repeat ) |
+        ( sym_hash | prod_class | prod_attrib | prod_pseudo ).repeat(1)
+      }
+
+      rule(:prod_selector){
+        prod_simple_selector.as(:parent) >>
+        ( ( prod_combinator >> prod_selector.as(:child) ) |
+          ( sym_s.repeat(1) >> ( prod_combinator.maybe >> prod_selector.as(:child) ).maybe )
+          ).maybe
+      }
+
+      rule(:prod_ruleset){
+        prod_selector >> 
+        ( str(",") >> sym_s_star >> prod_selector ).repeat >> 
+        str("{") >> sym_s_star >>
+        prod_declaration.maybe >>
+        ( str(";") >> sym_s_star >> prod_declaration.maybe
+         ).repeat >>
+        str("}") >> sym_s_star
+      }
+
+      rule(:prod_pseudo_page){ str(":") >> sym_ident >> sym_s_star }
+      rule(:prod_page){ sym_page_sym >> sym_s_star >>
+        prod_pseudo_page.maybe >> str("{") >> sym_s_star >>
+        prod_declaration.maybe >>
+        ( str(";") >> sym_s_star >> prod_declaration.maybe
+          ).repeat >>
+        str("}") >> sym_s_star
+      }
+
+      rule(:prod_medium){ sym_ident >> sym_s_star }
+      rule(:prod_media_list){
+        # NB str(",") is for the missing COMMA symbol from the grammar
+        prod_medium >> (str(",") >> sym_s_star >> prod_medium).repeat
+      }
+      rule(:prod_media){
+        sym_media_sym >> sym_s_star >>  prod_media_list >> str("{") >> sym_s_star >>
+        prod_ruleset.repeat >>
+        str("}") >> sym_s_star
+      }
+
+      rule(:prod_import){
+        sym_import_sym >> sym_s_star >> (sym_string | sym_uri) >> sym_s_star >>
+        prod_media_list.maybe >>
+        str(";") >> sym_s_star
+      }
+
+      rule(:prod_stylesheet){
+        ( sym_charset_sym >> sym_string >> str(";") ).maybe >>
+        ( sym_s | sym_cdo | sym_cdc ).repeat >>
+        ( prod_import >>
+          ( ( sym_cdo >> sym_s_star ) | (sym_cdc >> sym_s_star ) ).repeat ).repeat >>
+        ( ( prod_ruleset | prod_media | prod_page ) >>
+          ( ( sym_cdo >> sym_s_star ) | (sym_cdc >> sym_s_star ) ).repeat ).repeat
+      }
+
+
+      root(:prod_stylesheet)
+    end # class CssLexer
+
+
+  end # module Parser
+end # module Excession

data/lib/excession/version.rb

@@ -0,0 +1,3 @@
+module Excession
+  VERSION="0.0.3"
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: excession
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 0
+    - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+  - Alex Young
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-20 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: |
+  Excession is a collection of code for parsing and otherwise
+  munging CSS files. It has sprung from a need to be able to
+  programmatically modify colours in a site's style sheets.
+
+email: 
+  - alex@blackkettle.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - lib/excession/parser.rb
+  - lib/excession/version.rb
+  - lib/excession/css_regex_hue_mod.rb
+  - lib/excession/parser/css_parser.rb
+has_rdoc: true
+homepage: http://github.com/regularfry/excession
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 1
+          - 3
+          - 6
+        version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Useful code for handling CSS files
+test_files: []
+