css_parser_master 1.2.4

data/lib/css_parser_master/parser.rb

@@ -0,0 +1,388 @@
+module CssParserMaster
+  # Exception class used for any errors encountered while downloading remote files.
+  class RemoteFileError < IOError; end
+
+  # Exception class used if a request is made to load a CSS file more than once.
+  class CircularReferenceError < StandardError; end
+
+
+  # == Parser class
+  #
+  # All CSS is converted to UTF-8.
+  #
+  # When calling Parser#new there are some configuaration options:
+  # [<tt>absolute_paths</tt>] Convert relative paths to absolute paths (<tt>href</tt>, <tt>src</tt> and <tt>url('')</tt>. Boolean, default is <tt>false</tt>.
+  # [<tt>import</tt>] Follow <tt>@import</tt> rules. Boolean, default is <tt>true</tt>.
+  # [<tt>io_exceptions</tt>] Throw an exception if a link can not be found. Boolean, default is <tt>true</tt>.
+  class Parser
+    USER_AGENT   = "Ruby CSS Parser/#{CssParserMaster::VERSION} (http://code.dunae.ca/css_parser/)"
+
+    STRIP_CSS_COMMENTS_RX = /\/\*.*?\*\//m
+    STRIP_HTML_COMMENTS_RX = /\<\!\-\-|\-\-\>/m
+
+    # Initial parsing
+    RE_AT_IMPORT_RULE = /\@import[\s]+(url\()?["''"]?(.[^'"\s"']*)["''"]?\)?([\w\s\,^\])]*)\)?;?/
+
+    #--
+    # RE_AT_IMPORT_RULE = Regexp.new('@import[\s]*(' + RE_STRING.to_s + ')([\w\s\,]*)[;]?', Regexp::IGNORECASE) -- should handle url() even though it is not allowed
+    #++
+
+    # Array of CSS files that have been loaded.
+    attr_reader   :loaded_uris
+
+    #attr_reader   :rules
+
+    #--
+    # Class variable? see http://www.oreillynet.com/ruby/blog/2007/01/nubygems_dont_use_class_variab_1.html
+    #++
+    @folded_declaration_cache = {}
+    class << self; attr_reader :folded_declaration_cache; end
+
+    def initialize(options = {})
+      @options = {:absolute_paths => false,
+                  :import => true,
+                  :io_exceptions => true}.merge(options)
+
+      # array of RuleSets
+      @rules = []
+    
+      
+      @loaded_uris = []
+    
+      # unprocessed blocks of CSS
+      @blocks = []
+      reset!
+    end
+
+    # Get declarations by selector.
+    #
+    # +media_types+ are optional, and can be a symbol or an array of symbols.
+    # The default value is <tt>:all</tt>.
+    #
+    # ==== Examples
+    #  find_by_selector('#content')
+    #  => 'font-size: 13px; line-height: 1.2;'
+    #
+    #  find_by_selector('#content', [:screen, :handheld])
+    #  => 'font-size: 13px; line-height: 1.2;'
+    #
+    #  find_by_selector('#content', :print)
+    #  => 'font-size: 11pt; line-height: 1.2;'
+    #
+    # Returns an array of declarations.
+    def find_by_selector(selector, media_types = :all)
+      out = []
+      each_selector(media_types) do |sel|
+        # puts "selector declaration: #{sel.declarations_to_s}"
+        out << sel.declarations_to_s if sel.selector.strip == selector.strip
+      end
+      out
+    end
+    alias_method :[], :find_by_selector
+
+
+    # Add a raw block of CSS.
+    #
+    # In order to follow +@import+ rules you must supply either a
+    # +:base_dir+ or +:base_uri+ option.
+    #
+    # ==== Example
+    #   css = <<-EOT
+    #     body { font-size: 10pt }
+    #     p { margin: 0px; }
+    #     @media screen, print {
+    #       body { line-height: 1.2 }
+    #     }
+    #   EOT
+    #
+    #   parser = CssParserMaster::Parser.new
+    #   parser.add_block!(css)
+    #--
+    # TODO: add media_type
+    #++
+    def add_block!(block, options = {})
+      options = {:base_uri => nil, :base_dir => nil, :charset => nil, :media_types => :all}.merge(options)
+      
+      block = cleanup_block(block)
+
+      if options[:base_uri] and @options[:absolute_paths]
+        block = CssParserMaster.convert_uris(block, options[:base_uri])
+      end
+
+      # Load @imported CSS
+      block.scan(RE_AT_IMPORT_RULE).each do |import_rule|        
+        media_types = []
+        if media_string = import_rule[import_rule.length-1]
+          media_string.split(/\s|\,/).each do |t|
+            media_types << t.to_sym unless t.empty?
+          end
+        end
+
+        import_path = import_rule[1].to_s.gsub(/['"]*/, '').strip
+        
+        if options[:base_uri]
+          import_uri = URI.parse(options[:base_uri].to_s).merge(import_path)
+          load_uri!(import_uri, options[:base_uri], media_types)
+        elsif options[:base_dir]
+          load_file!(import_path, options[:base_dir], media_types)
+        end     
+      end
+
+      # Remove @import declarations
+      block.gsub!(RE_AT_IMPORT_RULE, '')      
+      parse_block_into_rule_sets!(block, options)
+      
+    end
+
+    # Add a CSS rule by setting the +selectors+, +declarations+ and +media_types+.
+    #
+    # +media_types+ can be a symbol or an array of symbols.
+    def add_rule!(selectors, declarations, media_types = :all)
+      rule_set = RuleSet.new(selectors, declarations)
+      # rule_set = RuleSet.new(Selectors.new(selectors), declarations)
+      add_rule_set!(rule_set, media_types)
+    end
+
+    # Add a CssParserMaster RuleSet object.
+    #
+    # +media_types+ can be a symbol or an array of symbols.
+    def add_rule_set!(ruleset, media_types = :all)
+      raise ArgumentError unless ruleset.kind_of?(CssParserMaster::RuleSet)
+
+      media_types = [media_types] if media_types.kind_of?(Symbol)
+
+      @rules << {:media_types => media_types, :rules => ruleset}
+    end
+
+    # Iterate through RuleSet objects.
+    #
+    # +media_types+ can be a symbol or an array of symbols.
+    def each_rule_set(media_types = :all) # :yields: rule_set
+      media_types = [:all] if media_types.nil?
+      media_types = [media_types] if media_types.kind_of?(Symbol)
+
+      @rules.each do |block|
+        if media_types.include?(:all) or block[:media_types].any? { |mt| media_types.include?(mt) }
+          yield block[:rules]
+        end
+      end
+    end
+
+    # go through all selector of the parser in order of specificity
+    # parse declarations for each selector
+    def selector_declarations(&block)
+      each_selector_sorted(:all, :order => :asc) do |sel|        
+        sel.declarations.each do |dec|
+          yield sel, dec              
+        end
+      end             
+    end
+
+    # Iterate through CSS selectors.
+    #
+    # +media_types+ can be a symbol or an array of symbols.
+    # See RuleSet#each_selector for +options+.
+    def each_selector(media_types = :all, options = {}) # :yields: selectors, declarations, specificity
+      each_rule_set(media_types) do |rule_set|
+        #puts rule_set
+        rule_set.each_selector(options) do |selector|
+          # puts "selector: #{selector.inspect}"
+          yield selector
+        end
+      end
+    end
+
+    # Iterate through CSS selectors.
+    #
+    # +media_types+ can be a symbol or an array of symbols.
+    # See RuleSet#each_selector for +options+.
+    def each_selector_sorted(media_types = :all, options = {}) # :yields: selectors, declarations, specificity
+      order = options.delete(:order) || :desc
+      sels = []
+      each_selector(media_types, options) do |sel|
+          sels << sel
+      end
+      sorted_sels = sels.sort_by(&:specificity).reverse
+      sorted_sels.reverse! if order == :asc
+      sorted_sels.each{|s| yield s}      
+    end
+
+
+    # Output all CSS rules as a single stylesheet.
+    def to_s(media_types = :all)
+      out = ''
+      each_selector(media_types) do |selector|
+        out << selector.to_s
+      end
+      out
+    end
+
+    # Merge declarations with the same selector.
+    def compact! # :nodoc:
+      compacted = []
+
+      compacted
+    end
+
+    def parse_block_into_rule_sets!(block, options = {}) # :nodoc:
+      options = {:media_types => :all}.merge(options)
+      media_types = options[:media_types]
+
+      in_declarations = false
+
+      block_depth = 0
+
+      # @charset is ignored for now
+      in_charset = false
+      in_string = false
+      in_at_media_rule = false
+
+      current_selectors = ''
+      current_declarations = ''
+
+      block.scan(/([\\]?[{}\s"]|(.[^\s"{}\\]*))/).each do |matches|
+      #block.scan(/((.[^{}"\n\r\f\s]*)[\s]|(.[^{}"\n\r\f]*)\{|(.[^{}"\n\r\f]*)\}|(.[^{}"\n\r\f]*)\"|(.*)[\s]+)/).each do |matches|
+        token = matches[0]
+        #puts "TOKEN: #{token}" unless token =~ /^[\s]*$/
+        if token =~ /\A"/ # found un-escaped double quote
+          in_string = !in_string
+        end       
+
+        if in_declarations
+          current_declarations += token
+
+          if token =~ /\}/ and not in_string
+            current_declarations.gsub!(/\}[\s]*$/, '')
+            
+            in_declarations = false
+
+            unless current_declarations.strip.empty?
+              #puts "SAVING #{current_selectors} -> #{current_declarations}"
+              add_rule!(current_selectors, current_declarations, media_types)
+            end
+
+            current_selectors = ''
+            current_declarations = ''
+          end
+        elsif token =~ /@media/i
+          # found '@media', reset current media_types
+          in_at_media_rule = true
+          media_types = []
+        elsif in_at_media_rule
+          if token =~ /\{/
+            block_depth = block_depth + 1
+            in_at_media_rule = false
+          else
+            token.gsub!(/[,\s]*/, '')
+            media_types << token.strip.downcase.to_sym unless token.empty?
+          end
+        elsif in_charset or token =~ /@charset/i
+          # iterate until we are out of the charset declaration
+          in_charset = (token =~ /;/ ? false : true)
+        else
+          if token =~ /\}/ and not in_string
+            block_depth = block_depth - 1
+          else
+            if token =~ /\{/ and not in_string
+              current_selectors.gsub!(/^[\s]*/, '')
+              current_selectors.gsub!(/[\s]*$/, '')
+              in_declarations = true
+            else
+              current_selectors += token
+            end
+          end
+        end
+      end
+    end
+
+    # Load a remote CSS file.
+    def load_uri!(uri, base_uri = nil, media_types = :all)
+      base_uri = uri if base_uri.nil?
+      src, charset = read_remote_file(uri)
+
+      add_block!(src, {:media_types => media_types, :base_uri => base_uri})
+    end
+    
+    # Load a local CSS file.
+    def load_file!(file_name, base_dir = nil, media_types = :all)
+      file_name = File.expand_path(file_name, base_dir)
+      return unless File.readable?(file_name)
+
+      src = IO.read(file_name)
+      base_dir = File.dirname(file_name)
+
+      add_block!(src, {:media_types => media_types, :base_dir => base_dir})
+    end
+    
+    
+
+  protected
+    # Strip comments and clean up blank lines from a block of CSS.
+    #
+    # Returns a string.
+    def cleanup_block(block) # :nodoc:
+      # Strip CSS comments
+      block.gsub!(STRIP_CSS_COMMENTS_RX, '')
+
+      # Strip HTML comments - they shouldn't really be in here but 
+      # some people are just crazy...
+      block.gsub!(STRIP_HTML_COMMENTS_RX, '')
+
+      # Strip lines containing just whitespace
+      block.gsub!(/^\s+$/, "")
+
+      block
+    end
+
+    # Download a file into a string.
+    #
+    # Returns the file's data and character set in an array.
+    #--
+    # TODO: add option to fail silently or throw and exception on a 404
+    #++
+    def read_remote_file(uri) # :nodoc:
+      raise CircularReferenceError, "can't load #{uri.to_s} more than once" if @loaded_uris.include?(uri.to_s)
+      @loaded_uris << uri.to_s
+
+      begin
+      #fh = open(uri, 'rb')
+        fh = open(uri, 'rb', 'User-Agent' => USER_AGENT, 'Accept-Encoding' => 'gzip')
+
+        if fh.content_encoding.include?('gzip')
+          remote_src = Zlib::GzipReader.new(fh).read
+        else
+          remote_src = fh.read
+        end
+
+        #puts "reading #{uri} (#{fh.charset})"
+
+        ic = Iconv.new('UTF-8//IGNORE', fh.charset)
+        src = ic.iconv(remote_src)
+
+        fh.close
+        return src, fh.charset
+      rescue
+        raise RemoteFileError if @options[:io_exceptions]
+        return '', nil
+      end
+    end
+
+  private
+    # Save a folded declaration block to the internal cache.
+    def save_folded_declaration(block_hash, folded_declaration) # :nodoc:
+      @folded_declaration_cache[block_hash] = folded_declaration
+    end
+
+    # Retrieve a folded declaration block from the internal cache.
+    def get_folded_declaration(block_hash) # :nodoc:
+      return @folded_declaration_cache[block_hash] ||= nil
+    end
+
+    def reset! # :nodoc:
+      @folded_declaration_cache = {}
+      @css_source = ''
+      @css_rules = []
+      @css_warnings = []
+    end
+  end
+end

data/lib/css_parser_master/regexps.rb

@@ -0,0 +1,46 @@
+module CssParserMaster
+  # :stopdoc:
+  # Base types
+  RE_NL = Regexp.new('(\n|\r\n|\r|\f)')
+  RE_NON_ASCII = Regexp.new('([\x00-\xFF])', Regexp::IGNORECASE, 'n')  #[^\0-\177]
+  RE_UNICODE = Regexp.new('(\\\\[0-9a-f]{1,6}(\r\n|[ \n\r\t\f])*)', Regexp::IGNORECASE | Regexp::EXTENDED | Regexp::MULTILINE, 'n')
+  RE_ESCAPE = Regexp.union(RE_UNICODE, '|(\\\\[^\n\r\f0-9a-f])')
+  RE_IDENT = Regexp.new("[\-]?([_a-z]|#{RE_NON_ASCII}|#{RE_ESCAPE})([_a-z0-9\-]|#{RE_NON_ASCII}|#{RE_ESCAPE})*", Regexp::IGNORECASE, 'n')
+
+  # General strings
+  RE_STRING1 = Regexp.new('(\"(.[^\n\r\f\\"]*|\\\\' + RE_NL.to_s + '|' + RE_ESCAPE.to_s + ')*\")')
+  RE_STRING2 = Regexp.new('(\'(.[^\n\r\f\\\']*|\\\\' + RE_NL.to_s + '|' + RE_ESCAPE.to_s + ')*\')')
+  RE_STRING = Regexp.union(RE_STRING1, RE_STRING2)
+
+  RE_URI = Regexp.new('(url\([\s]*([\s]*' + RE_STRING.to_s + '[\s]*)[\s]*\))|(url\([\s]*([!#$%&*\-~]|' + RE_NON_ASCII.to_s + '|' + RE_ESCAPE.to_s + ')*[\s]*)\)', Regexp::IGNORECASE | Regexp::EXTENDED  | Regexp::MULTILINE, 'n')
+  URI_RX = /url\(("([^"]*)"|'([^']*)'|([^)]*))\)/im
+
+  # Initial parsing
+  RE_AT_IMPORT_RULE = /\@import[\s]+(url\()?["''"]?(.[^'"\s"']*)["''"]?\)?([\w\s\,^\])]*)\)?;?/
+  
+  #--
+  #RE_AT_MEDIA_RULE = Regexp.new('(\"(.[^\n\r\f\\"]*|\\\\' + RE_NL.to_s + '|' + RE_ESCAPE.to_s + ')*\")')
+  
+  #RE_AT_IMPORT_RULE = Regexp.new('@import[\s]*(' + RE_STRING.to_s + ')([\w\s\,]*)[;]?', Regexp::IGNORECASE) -- should handle url() even though it is not allowed
+  #++
+  IMPORTANT_IN_PROPERTY_RX = /[\s]*\!important[\s]*/i
+  STRIP_CSS_COMMENTS_RX = /\/\*.*?\*\//m
+  STRIP_HTML_COMMENTS_RX = /\<\!\-\-|\-\-\>/m
+
+  # Special units
+  BOX_MODEL_UNITS_RX = /(auto|inherit|0|([\-]*([0-9]+|[0-9]*\.[0-9]+)(e[mx]+|px|[cm]+m|p[tc+]|in|\%)))([\s;]|\Z)/imx
+  RE_LENGTH_OR_PERCENTAGE = Regexp.new('([\-]*(([0-9]*\.[0-9]+)|[0-9]+)(e[mx]+|px|[cm]+m|p[tc+]|in|\%))', Regexp::IGNORECASE)
+  RE_BACKGROUND_POSITION = Regexp.new("((#{RE_LENGTH_OR_PERCENTAGE})|left|center|right|top|bottom)", Regexp::IGNORECASE | Regexp::EXTENDED)
+  FONT_UNITS_RX = /(([x]+\-)*small|medium|large[r]*|auto|inherit|([0-9]+|[0-9]*\.[0-9]+)(e[mx]+|px|[cm]+m|p[tc+]|in|\%)*)/i
+ 
+  # Patterns for specificity calculations
+  ELEMENTS_AND_PSEUDO_ELEMENTS_RX = /((^|[\s\+\>]+)[\w]+|\:(first\-line|first\-letter|before|after))/i
+  NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES_RX = /(\.[\w]+)|(\[[\w]+)|(\:(link|first\-child|lang))/i
+
+  # Colours
+  RE_COLOUR_RGB = Regexp.new('(rgb[\s]*\([\s-]*[\d]+(\.[\d]+)?[%\s]*,[\s-]*[\d]+(\.[\d]+)?[%\s]*,[\s-]*[\d]+(\.[\d]+)?[%\s]*\))', Regexp::IGNORECASE)
+  RE_COLOUR_HEX = /(#([0-9a-f]{6}|[0-9a-f]{3})([\s;]|$))/i
+  RE_COLOUR_NAMED = /([\s]*^)?(aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|transparent)([\s]*$)?/i
+  RE_COLOUR = Regexp.union(RE_COLOUR_RGB, RE_COLOUR_HEX, RE_COLOUR_NAMED)
+  # :startdoc:
+end

data/lib/css_parser_master/rule_set.rb

@@ -0,0 +1,337 @@
+require 'css_parser_master/selector'
+require 'css_parser_master/selectors'
+require 'css_parser_master/declaration'                             
+require 'css_parser_master/declaration_api'
+require 'css_parser_master/declarations' 
+
+module CssParserMaster
+  class RuleSet
+    # Patterns for specificity calculations
+    RE_ELEMENTS_AND_PSEUDO_ELEMENTS = /((^|[\s\+\>]+)[\w]+|\:(first\-line|first\-letter|before|after))/i
+    RE_NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES = /(\.[\w]+)|(\[[\w]+)|(\:(link|first\-child|lang))/i
+
+    include DeclarationAPI
+
+    # Array of selector strings.
+    attr_reader   :selectors
+    
+    # Integer with the specificity to use for this RuleSet.
+    attr_accessor   :specificity
+
+    def initialize(selectors, block, specificity = nil)
+      @selectors = []
+      @specificity = specificity
+      @declarations = {}
+      @order = 0
+      parse_selectors!(selectors) if selectors
+      parse_declarations!(block)
+    end
+
+
+    # Get the value of a property
+    def get_value(property)
+      return '' unless property and not property.empty?
+
+      property = property.downcase.strip
+      properties = @declarations.inject('') do |val, (key, data)|
+        #puts "COMPARING #{key} #{key.inspect} against #{property} #{property.inspect}"
+        importance = data[:is_important] ? ' !important' : ''
+        val << "#{data[:value]}#{importance}; " if key.downcase.strip == property
+        val
+      end
+      return properties ? properties.strip : ''
+    end
+    alias_method :[], :get_value
+
+    # Iterate through selectors.
+    #
+    # Options
+    # -  +force_important+ -- boolean
+    #
+    # ==== Example
+    #   ruleset.each_selector do |sel, dec, spec|
+    #     ...
+    #   end
+    def each_selector(options = {}) # :yields: selector, declarations, specificity
+      declarations = declarations_to_s(options)  
+      # puts "declarations: #{declarations.inspect}" 
+      if @specificity
+        @selectors.each { |sel| yield Selector.new sel.strip, declarations, @specificity }
+      else
+        @selectors.each { |sel| yield Selector.new sel.strip, declarations, CssParserMaster.calculate_specificity(sel) }
+      end
+    end
+
+    # Return the CSS rule set as a string.
+    def to_s
+      decs = declarations_to_s
+      "#{@selectors} { #{decs} }"
+    end
+
+    # Split shorthand declarations (e.g. +margin+ or +font+) into their constituent parts.
+    def expand_shorthand!
+      expand_dimensions_shorthand!
+      expand_font_shorthand!
+      expand_background_shorthand!
+    end
+
+    # Create shorthand declarations (e.g. +margin+ or +font+) whenever possible.
+    def create_shorthand!
+      create_background_shorthand!
+      create_dimensions_shorthand!
+      create_font_shorthand!
+    end
+
+private
+
+
+    #--
+    # TODO: way too simplistic
+    #++
+    def parse_selectors!(selectors) # :nodoc:
+      @selectors = selectors.split(',') 
+    end
+
+public
+    # Split shorthand dimensional declarations (e.g. <tt>margin: 0px auto;</tt>)
+    # into their constituent parts.
+    def expand_dimensions_shorthand! # :nodoc:
+      ['margin', 'padding'].each do |property|
+
+        next unless @declarations.has_key?(property)
+        
+        value = @declarations[property][:value]
+        is_important = @declarations[property][:is_important]
+        order = @declarations[property][:order]
+        t, r, b, l = nil
+
+        matches = value.scan(CssParserMaster::BOX_MODEL_UNITS_RX)
+
+        case matches.length
+          when 1
+            t, r, b, l = matches[0][0], matches[0][0], matches[0][0], matches[0][0]
+          when 2
+            t, b = matches[0][0], matches[0][0]
+            r, l = matches[1][0], matches[1][0]
+          when 3
+            t =  matches[0][0]
+            r, l = matches[1][0], matches[1][0]
+            b =  matches[2][0]
+          when 4
+            t =  matches[0][0]
+            r = matches[1][0]
+            b =  matches[2][0]
+            l = matches[3][0]
+        end
+
+        values = { :is_important => is_important, :order => order }
+        @declarations["#{property}-top"]    = values.merge(:value => t.to_s)
+        @declarations["#{property}-right"]  = values.merge(:value => r.to_s)
+        @declarations["#{property}-bottom"] = values.merge(:value => b.to_s)
+        @declarations["#{property}-left"]   = values.merge(:value => l.to_s)
+        @declarations.delete(property)
+      end
+    end
+
+    # Convert shorthand font declarations (e.g. <tt>font: 300 italic 11px/14px verdana, helvetica, sans-serif;</tt>)
+    # into their constituent parts.
+    def expand_font_shorthand! # :nodoc:
+      return unless @declarations.has_key?('font')
+
+      font_props = {}
+
+      # reset properties to 'normal' per http://www.w3.org/TR/CSS21/fonts.html#font-shorthand
+      ['font-style', 'font-variant', 'font-weight', 'font-size',
+       'line-height'].each do |prop|
+        font_props[prop] = 'normal'
+       end
+
+      value = @declarations['font'][:value]
+      is_important = @declarations['font'][:is_important]
+      order = @declarations['font'][:order]
+
+      in_fonts = false
+
+      matches = value.scan(/("(.*[^"])"|'(.*[^'])'|(\w[^ ,]+))/)
+      matches.each do |match|
+        m = match[0].to_s.strip
+        m.gsub!(/[;]$/, '')
+
+        if in_fonts
+          if font_props.has_key?('font-family')
+            font_props['font-family'] += ', ' + m
+          else
+            font_props['font-family'] = m
+          end
+        elsif m =~ /normal|inherit/i
+          ['font-style', 'font-weight', 'font-variant'].each do |font_prop|
+            font_props[font_prop] = m unless font_props.has_key?(font_prop)
+          end
+        elsif m =~ /italic|oblique/i
+          font_props['font-style'] = m
+        elsif m =~ /small\-caps/i
+          font_props['font-variant'] = m
+        elsif m =~ /[1-9]00$|bold|bolder|lighter/i
+          font_props['font-weight'] = m
+        elsif m =~ CssParserMaster::FONT_UNITS_RX
+          if m =~ /\//
+            font_props['font-size'], font_props['line-height'] = m.split('/')
+          else
+            font_props['font-size'] = m
+          end
+          in_fonts = true
+        end
+      end
+
+      font_props.each { |font_prop, font_val| @declarations[font_prop] = {:value => font_val, :is_important => is_important, :order => order} }
+
+      @declarations.delete('font')
+    end
+
+
+    # Convert shorthand background declarations (e.g. <tt>background: url("chess.png") gray 50% repeat fixed;</tt>)
+    # into their constituent parts.
+    #
+    # See http://www.w3.org/TR/CSS21/colors.html#propdef-background
+    def expand_background_shorthand! # :nodoc:
+      return unless @declarations.has_key?('background')
+
+      value = @declarations['background'][:value]
+      is_important = @declarations['background'][:is_important]
+      order = @declarations['background'][:order]
+
+      bg_props = {}
+
+
+      if m = value.match(Regexp.union(CssParserMaster::URI_RX, /none/i)).to_s
+        bg_props['background-image'] = m.strip unless m.empty?
+        value.gsub!(Regexp.union(CssParserMaster::URI_RX, /none/i), '')
+      end
+
+      if m = value.match(/([\s]*^)?(scroll|fixed)([\s]*$)?/i).to_s
+        bg_props['background-attachment'] = m.strip unless m.empty?
+      end
+
+      if m = value.match(/([\s]*^)?(repeat(\-x|\-y)*|no\-repeat)([\s]*$)?/i).to_s
+        bg_props['background-repeat'] = m.strip unless m.empty?
+      end
+
+      if m = value.match(CssParserMaster::RE_COLOUR).to_s
+        bg_props['background-color'] = m.strip unless m.empty?
+      end
+
+      value.scan(CssParserMaster::RE_BACKGROUND_POSITION).each do |m|
+        if bg_props.has_key?('background-position')
+          bg_props['background-position'] += ' ' + m[0].to_s.strip unless m.empty?
+        else
+          bg_props['background-position'] =  m[0].to_s.strip unless m.empty?
+        end
+      end
+
+
+      if value =~ /([\s]*^)?inherit([\s]*$)?/i
+        ['background-color', 'background-image', 'background-attachment', 'background-repeat', 'background-position'].each do |prop|
+            bg_props["#{prop}"] = 'inherit' unless bg_props.has_key?(prop) and not bg_props[prop].empty?
+        end
+      end
+
+      bg_props.each { |bg_prop, bg_val| @declarations[bg_prop] = {:value => bg_val, :is_important => is_important, :order => order} }
+
+      @declarations.delete('background')
+    end
+
+
+    # Looks for long format CSS background properties (e.g. <tt>background-color</tt>) and 
+    # converts them into a shorthand CSS <tt>background</tt> property.
+    def create_background_shorthand! # :nodoc:
+      new_value = ''
+      ['background-color', 'background-image', 'background-repeat', 
+       'background-position', 'background-attachment'].each do |property|
+        if @declarations.has_key?(property)
+          new_value += @declarations[property][:value] + ' '
+          @declarations.delete(property)
+        end
+      end
+
+      unless new_value.strip.empty?
+        @declarations['background'] = {:value => new_value.gsub(/[\s]+/, ' ').strip}
+      end
+    end
+
+    # Looks for long format CSS dimensional properties (i.e. <tt>margin</tt> and <tt>padding</tt>) and 
+    # converts them into shorthand CSS properties.
+    def create_dimensions_shorthand! # :nodoc:
+      # geometric
+      directions = ['top', 'right', 'bottom', 'left']
+      ['margin', 'padding'].each do |property|
+        values = {}      
+
+        foldable = @declarations.select { |dim, val| dim == "#{property}-top" or dim == "#{property}-right" or dim == "#{property}-bottom" or dim == "#{property}-left" }
+        # All four dimensions must be present
+        if foldable.length == 4
+          values = {}
+
+          directions.each { |d| values[d.to_sym] = @declarations["#{property}-#{d}"][:value].downcase.strip }
+
+          if values[:left] == values[:right]
+            if values[:top] == values[:bottom] 
+              if values[:top] == values[:left] # All four sides are equal
+                new_value = values[:top]
+              else # Top and bottom are equal, left and right are equal
+                new_value = values[:top] + ' ' + values[:left]
+              end
+            else # Only left and right are equal
+              new_value = values[:top] + ' ' + values[:left] + ' ' + values[:bottom]
+            end
+          else # No sides are equal
+            new_value = values[:top] + ' ' + values[:right] + ' ' + values[:bottom] + ' ' + values[:left]
+          end # done creating 'new_value'
+
+          # Save the new value
+          unless new_value.strip.empty?
+            @declarations[property] = {:value => new_value.gsub(/[\s]+/, ' ').strip}
+          end
+
+          # Delete the shorthand values
+          directions.each { |d| @declarations.delete("#{property}-#{d}") }
+        end
+      end # done iterating through margin and padding
+    end
+
+
+    # Looks for long format CSS font properties (e.g. <tt>font-weight</tt>) and 
+    # tries to convert them into a shorthand CSS <tt>font</tt> property.  All 
+    # font properties must be present in order to create a shorthand declaration.
+    def create_font_shorthand! # :nodoc:
+      ['font-style', 'font-variant', 'font-weight', 'font-size',
+       'line-height', 'font-family'].each do |prop|
+        return unless @declarations.has_key?(prop)
+      end
+
+      new_value = ''
+      ['font-style', 'font-variant', 'font-weight'].each do |property|
+        unless @declarations[property][:value] == 'normal'
+          new_value += @declarations[property][:value] + ' '
+        end
+      end
+
+      new_value += @declarations['font-size'][:value]
+
+      unless @declarations['line-height'][:value] == 'normal'
+        new_value += '/' + @declarations['line-height'][:value]
+      end
+
+      new_value += ' ' + @declarations['font-family'][:value]
+
+      @declarations['font'] = {:value => new_value.gsub(/[\s]+/, ' ').strip}
+
+      ['font-style', 'font-variant', 'font-weight', 'font-size',
+       'line-height', 'font-family'].each do |prop|
+       @declarations.delete(prop)
+      end
+
+    end
+  end
+end
+
+