css_parser 1.7.1 → 1.8.0

data/lib/css_parser/regexps.rb

@@ -1,65 +1,68 @@
+# frozen_string_literal: true
+
 module CssParser
-  def self.regex_possible_values *values
+  def self.regex_possible_values(*values)
     Regexp.new("([\s]*^)?(#{values.join('|')})([\s]*$)?", 'i')
   end
 
   # :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_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_STRING1 = /("(.[^\n\r\f"]*|\\#{RE_NL}|#{RE_ESCAPE})*")/.freeze
+  RE_STRING2 = /('(.[^\n\r\f']*|\\#{RE_NL}|#{RE_ESCAPE})*')/.freeze
   RE_STRING = Regexp.union(RE_STRING1, RE_STRING2)
 
   RE_INHERIT = regex_possible_values 'inherit'
 
-  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
-  RE_GRADIENT = /[-a-z]*gradient\([-a-z0-9 .,#%()]*\)/im
+  RE_URI = /(url\(\s*(\s*#{RE_STRING}\s*)\s*\))|(url\(\s*([!#$%&*\-~]|#{RE_NON_ASCII}|#{RE_ESCAPE})*\s*)\)/ixm.freeze
+  URI_RX = /url\(("([^"]*)"|'([^']*)'|([^)]*))\)/im.freeze
+  RE_GRADIENT = /[-a-z]*gradient\([-a-z0-9 .,#%()]*\)/im.freeze
 
   # Initial parsing
-  RE_AT_IMPORT_RULE = /\@import\s+(url\()?["']?(.[^'"\s]*)["']?\)?([\w\s\,^\])]*)\)?;?/
+  RE_AT_IMPORT_RULE = /@import\s+(url\()?["']?(.[^'"\s]*)["']?\)?([\w\s,^\])]*)\)?;?/.freeze
 
   #--
-  #RE_AT_MEDIA_RULE = Regexp.new('(\"(.[^\n\r\f\\"]*|\\\\' + RE_NL.to_s + '|' + RE_ESCAPE.to_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
+  # 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\b[\s]*/i
+  IMPORTANT_IN_PROPERTY_RX = /\s*!important\b\s*/i.freeze
 
   RE_INSIDE_OUTSIDE = regex_possible_values 'inside', 'outside'
   RE_SCROLL_FIXED = regex_possible_values 'scroll', 'fixed'
   RE_REPEAT = regex_possible_values 'repeat(\-x|\-y)*|no\-repeat'
-  RE_LIST_STYLE_TYPE = regex_possible_values 'disc', 'circle', 'square', 'decimal-leading-zero', 'decimal', 'lower-roman',
-                                             'upper-roman', 'lower-greek', 'lower-alpha', 'lower-latin', 'upper-alpha',
-                                             'upper-latin', 'hebrew', 'armenian', 'georgian', 'cjk-ideographic', 'hiragana',
-                                             'hira-gana-iroha', 'katakana-iroha', 'katakana', 'none'
+  RE_LIST_STYLE_TYPE = regex_possible_values(
+    'disc', 'circle', 'square', 'decimal-leading-zero', 'decimal', 'lower-roman',
+    'upper-roman', 'lower-greek', 'lower-alpha', 'lower-latin', 'upper-alpha',
+    'upper-latin', 'hebrew', 'armenian', 'georgian', 'cjk-ideographic', 'hiragana',
+    'hira-gana-iroha', 'katakana-iroha', 'katakana', 'none'
+  )
 
-  STRIP_CSS_COMMENTS_RX = /\/\*.*?\*\//m
-  STRIP_HTML_COMMENTS_RX = /\<\!\-\-|\-\-\>/m
+  STRIP_CSS_COMMENTS_RX = %r{/\*.*?\*/}m.freeze
+  STRIP_HTML_COMMENTS_RX = /<!--|-->/m.freeze
 
   # Special units
-  BOX_MODEL_UNITS_RX = /(auto|inherit|0|([\-]*([0-9]+|[0-9]*\.[0-9]+)(rem|vw|vh|vm|vmin|vmax|e[mx]+|px|[cm]+m|p[tc+]|in|\%)))([\s;]|\Z)/imx
+  BOX_MODEL_UNITS_RX = /(auto|inherit|0|(-*([0-9]+|[0-9]*\.[0-9]+)(rem|vw|vh|vm|vmin|vmax|e[mx]+|px|[cm]+m|p[tc+]|in|%)))([\s;]|\Z)/imx.freeze
   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)[\s]*){1,2})", Regexp::IGNORECASE | Regexp::EXTENDED)
   RE_BACKGROUND_SIZE = Regexp.new("\\s*/\\s*((((#{RE_LENGTH_OR_PERCENTAGE})|auto|cover|contain|initial|inherit)[\\s]*){1,2})", 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
-  RE_BORDER_STYLE = /([\s]*^)?(none|hidden|dotted|dashed|solid|double|dot-dash|dot-dot-dash|wave|groove|ridge|inset|outset)([\s]*$)?/imx
+  FONT_UNITS_RX = /((x+-)*small|medium|larger*|auto|inherit|([0-9]+|[0-9]*\.[0-9]+)(e[mx]+|px|[cm]+m|p[tc+]|in|%)*)/i.freeze
+  RE_BORDER_STYLE = /(\s*^)?(none|hidden|dotted|dashed|solid|double|dot-dash|dot-dot-dash|wave|groove|ridge|inset|outset)(\s*$)?/imx.freeze
   RE_BORDER_UNITS = Regexp.union(BOX_MODEL_UNITS_RX, /(thin|medium|thick)/i)
 
-
   # Patterns for specificity calculations
-  NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES_RX_NC= /
-    (?:\.[\w]+)                     # classes
+  NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES_RX_NC = /
+    (?:\.\w+)                     # classes
     |
     \[(?:\w+)                       # attributes
     |
-    (?:\:(?:                          # pseudo classes
+    (?::(?:                          # pseudo classes
       link|visited|active
       |hover|focus
       |lang
@@ -71,16 +74,16 @@ module CssParser
       |only-child|only-of-type
       |empty|contains
     ))
-  /ix
+  /ix.freeze
   ELEMENTS_AND_PSEUDO_ELEMENTS_RX_NC = /
-    (?:(?:^|[\s\+\>\~]+)[\w]+       # elements
+    (?:(?:^|[\s+>~]+)\w+       # elements
     |
-    \:{1,2}(?:                    # pseudo-elements
+    :{1,2}(?:                    # pseudo-elements
       after|before
       |first-letter|first-line
       |selection
     )
-  )/ix
+  )/ix.freeze
 
   # Colours
   NAMED_COLOURS = %w[
@@ -235,11 +238,11 @@ module CssParser
     transparent
     inherit
     currentColor
-  ]
-  RE_COLOUR_NUMERIC = /\b(hsl|rgb)\s*\(-?\s*-?\d+(\.\d+)?%?\s*%?,-?\s*-?\d+(\.\d+)?%?\s*%?,-?\s*-?\d+(\.\d+)?%?\s*%?\)/i
-  RE_COLOUR_NUMERIC_ALPHA = /\b(hsla|rgba)\s*\(-?\s*-?\d+(\.\d+)?%?\s*%?,-?\s*-?\d+(\.\d+)?%?\s*%?,-?\s*-?\d+(\.\d+)?%?\s*%?,-?\s*-?\d+(\.\d+)?%?\s*%?\)/i
-  RE_COLOUR_HEX = /\s*#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})\b/
-  RE_COLOUR_NAMED = /\s*\b(#{NAMED_COLOURS.join('|')})\b/i
+  ].freeze
+  RE_COLOUR_NUMERIC = /\b(hsl|rgb)\s*\(-?\s*-?\d+(\.\d+)?%?\s*%?,-?\s*-?\d+(\.\d+)?%?\s*%?,-?\s*-?\d+(\.\d+)?%?\s*%?\)/i.freeze
+  RE_COLOUR_NUMERIC_ALPHA = /\b(hsla|rgba)\s*\(-?\s*-?\d+(\.\d+)?%?\s*%?,-?\s*-?\d+(\.\d+)?%?\s*%?,-?\s*-?\d+(\.\d+)?%?\s*%?,-?\s*-?\d+(\.\d+)?%?\s*%?\)/i.freeze
+  RE_COLOUR_HEX = /\s*#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})\b/.freeze
+  RE_COLOUR_NAMED = /\s*\b(#{NAMED_COLOURS.join('|')})\b/i.freeze
   RE_COLOUR = Regexp.union(RE_COLOUR_NUMERIC, RE_COLOUR_NUMERIC_ALPHA, RE_COLOUR_HEX, RE_COLOUR_NAMED)
   # :startdoc:
 end

data/lib/css_parser/rule_set.rb

@@ -1,92 +1,255 @@
 # frozen_string_literal: true
+
+require 'forwardable'
+
 module CssParser
   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
+    RE_ELEMENTS_AND_PSEUDO_ELEMENTS = /((^|[\s+>]+)\w+|:(first-line|first-letter|before|after))/i.freeze
+    RE_NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES = /(\.\w+)|(\[\w+)|(:(link|first-child|lang))/i.freeze
 
-    BACKGROUND_PROPERTIES = ['background-color', 'background-image', 'background-repeat', 'background-position', 'background-size', 'background-attachment']
-    LIST_STYLE_PROPERTIES = ['list-style-type', 'list-style-position', 'list-style-image']
-    FONT_STYLE_PROPERTIES = ['font-style', 'font-variant', 'font-weight', 'font-size', 'line-height', 'font-family']
-    BORDER_STYLE_PROPERTIES = ['border-width', 'border-style', 'border-color']
-    BORDER_PROPERTIES = ['border', 'border-left', 'border-right', 'border-top', 'border-bottom']
+    BACKGROUND_PROPERTIES = ['background-color', 'background-image', 'background-repeat', 'background-position', 'background-size', 'background-attachment'].freeze
+    LIST_STYLE_PROPERTIES = ['list-style-type', 'list-style-position', 'list-style-image'].freeze
+    FONT_STYLE_PROPERTIES = ['font-style', 'font-variant', 'font-weight', 'font-size', 'line-height', 'font-family'].freeze
+    BORDER_STYLE_PROPERTIES = ['border-width', 'border-style', 'border-color'].freeze
+    BORDER_PROPERTIES = ['border', 'border-left', 'border-right', 'border-top', 'border-bottom'].freeze
 
     NUMBER_OF_DIMENSIONS = 4
 
     DIMENSIONS = [
-      ['margin', %w(margin-top margin-right margin-bottom margin-left)],
-      ['padding', %w(padding-top padding-right padding-bottom padding-left)],
-      ['border-color', %w(border-top-color border-right-color border-bottom-color border-left-color)],
-      ['border-style', %w(border-top-style border-right-style border-bottom-style border-left-style)],
-      ['border-width', %w(border-top-width border-right-width border-bottom-width border-left-width)],
-    ]
+      ['margin', %w[margin-top margin-right margin-bottom margin-left]],
+      ['padding', %w[padding-top padding-right padding-bottom padding-left]],
+      ['border-color', %w[border-top-color border-right-color border-bottom-color border-left-color]],
+      ['border-style', %w[border-top-style border-right-style border-bottom-style border-left-style]],
+      ['border-width', %w[border-top-width border-right-width border-bottom-width border-left-width]]
+    ].freeze
+
+    class Declarations
+      class Value
+        attr_reader :value
+        attr_accessor :important
+
+        def initialize(value, important: nil)
+          self.value = value
+          @important = important unless important.nil?
+        end
+
+        def value=(value)
+          value = value.to_s.sub(/\s*;\s*\Z/, '')
+          self.important = !value.slice!(CssParser::IMPORTANT_IN_PROPERTY_RX).nil?
+          value.strip!
+          raise ArgumentError, 'value is empty' if value.empty?
+
+          @value = value.freeze
+        end
+
+        def to_s
+          return value unless important
+
+          "#{value} !important"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(self.class)
+
+          value == other.value && important == other.important
+        end
+      end
+
+      extend Forwardable
+
+      def_delegators :declarations, :each
+
+      def initialize(declarations = {})
+        self.declarations = {}
+        declarations.each { |property, value| add_declaration!(property, value) }
+      end
+
+      # Add a CSS declaration
+      # @param [#to_s] property that should be added
+      # @param [Value, #to_s] value of the property
+      #
+      # @example
+      #   declarations['color'] = 'blue'
+      #
+      #   puts declarations['color']
+      #   => #<CssParser::RuleSet::Declarations::Value:0x000000000305c730 @important=false, @order=1, @value="blue">
+      #
+      # @example
+      #   declarations['margin'] = '0px auto !important'
+      #
+      #   puts declarations['margin']
+      #   => #<CssParser::RuleSet::Declarations::Value:0x00000000030c1838 @important=true, @order=2, @value="0px auto">
+      #
+      # If the property already exists its value will be over-written.
+      # If the value is empty - property will be deleted
+      def []=(property, value)
+        property = normalize_property(property)
+
+        if value.is_a?(Value)
+          declarations[property] = value
+          return
+        end
+
+        if value.to_s.strip.empty?
+          delete(property)
+          return
+        end
+
+        declarations[property] = Value.new(value)
+      end
+      alias add_declaration! []=
+
+      def [](property)
+        declarations[normalize_property(property)]
+      end
+      alias get_value []
+
+      def key?(property)
+        declarations.key?(normalize_property(property))
+      end
+
+      def size
+        declarations.size
+      end
+
+      # Remove CSS declaration
+      # @param [#to_s] property property to be removed
+      #
+      # @example
+      #   declarations.delete('color')
+      def delete(property)
+        declarations.delete(normalize_property(property))
+      end
+      alias remove_declaration! delete
+
+      # Replace CSS property with multiple declarations
+      # @param [#to_s] property property name to be replaces
+      # @param [Hash<String => [String, Value]>] replacements hash with properties to replace with
+      #
+      # @example
+      #  declarations = Declarations.new('line-height' => '0.25px', 'font' => 'small-caps', 'font-size' => '12em')
+      #  declarations.replace_declaration!('font', {'line-height' => '1px', 'font-variant' => 'small-caps', 'font-size' => '24px'})
+      #  declarations
+      #  => #<CssParser::RuleSet::Declarations:0x00000000029c3018
+      #  @declarations=
+      #  {"line-height"=>#<CssParser::RuleSet::Declarations::Value:0x00000000038ac458 @important=false, @value="1px">,
+      #   "font-variant"=>#<CssParser::RuleSet::Declarations::Value:0x00000000039b3ec8 @important=false, @value="small-caps">,
+      #   "font-size"=>#<CssParser::RuleSet::Declarations::Value:0x00000000029c2c80 @important=false, @value="12em">}>
+      def replace_declaration!(property, replacements, preserve_importance: false)
+        property = normalize_property(property)
+        raise ArgumentError, "property #{property} does not exist" unless key?(property)
+
+        replacement_declarations = self.class.new(replacements)
+
+        if preserve_importance
+          importance = get_value(property).important
+          replacement_declarations.each { |_key, value| value.important = importance }
+        end
+
+        replacement_keys = declarations.keys
+        replacement_values = declarations.values
+        property_index = replacement_keys.index(property)
+
+        # We should preserve subsequent declarations of the same properties
+        # and prior important ones if replacement one is not important
+        replacements = replacement_declarations.each.with_object({}) do |(key, value), result|
+          # Replacement property doesn't exist, adding
+          next result[key] = value unless declarations.key?(key)
+
+          # Replacement property is important while existing one is not,
+          # replacing unconditionally
+          if value.important && !declarations[key].important
+            result[key] = value
+            replaced_index = replacement_keys.index(key)
+            replacement_keys.delete_at(replaced_index)
+            replacement_values.delete_at(replaced_index)
+            property_index -= 1 if replaced_index < property_index
+            next
+          end
+
+          # Existing value is important while replacing is not, existing one
+          # takes precedence
+          next if !value.important && declarations[key].important
+
+          # Importance of existing and replacement values are the same,
+          # value which is declared later wins
+          result[key] = value if property_index > replacement_keys.index(key)
+        end
+
+        return if replacements.empty?
+
+        replacement_keys.delete_at(property_index)
+        replacement_keys.insert(property_index, *replacements.keys)
+
+        replacement_values.delete_at(property_index)
+        replacement_values.insert(property_index, *replacements.values)
+
+        self.declarations = replacement_keys.zip(replacement_values).to_h
+      end
+
+      def to_s(options = {})
+        str = declarations.reduce(String.new) do |memo, (prop, value)|
+          importance = options[:force_important] || value.important ? ' !important' : ''
+          memo << "#{prop}: #{value.value}#{importance}; "
+        end
+        # TODO: Clean-up regexp doesn't seem to work
+        str.gsub!(/^[\s^({)]+|[\n\r\f\t]*|\s+$/mx, '')
+        str.strip!
+        str
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+
+        declarations == other.declarations && declarations.keys == other.declarations.keys
+      end
+
+    protected
+
+      attr_reader :declarations
+
+    private
+
+      attr_writer :declarations
+
+      def normalize_property(property)
+        property = property.to_s.downcase
+        property.strip!
+        property
+      end
+    end
+
+    extend Forwardable
 
     # Array of selector strings.
-    attr_reader   :selectors
+    attr_reader :selectors
 
     # Integer with the specificity to use for this RuleSet.
-    attr_accessor   :specificity
+    attr_accessor :specificity
+
+    # @!method add_declaration!
+    #   @see CssParser::RuleSet::Declarations#add_declaration!
+    # @!method delete
+    #   @see CssParser::RuleSet::Declarations#delete
+    def_delegators :declarations, :add_declaration!, :delete
+    alias []= add_declaration!
+    alias remove_declaration! delete
 
     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(String.new) 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
-
-    # Add a CSS declaration to the current RuleSet.
-    #
-    #  rule_set.add_declaration!('color', 'blue')
-    #
-    #  puts rule_set['color']
-    #  => 'blue;'
-    #
-    #  rule_set.add_declaration!('margin', '0px auto !important')
-    #
-    #  puts rule_set['margin']
-    #  => '0px auto !important;'
-    #
-    # If the property already exists its value will be over-written.
-    def add_declaration!(property, value)
-      if value.nil? or value.empty?
-        @declarations.delete(property)
-        return
-      end
+      return '' unless declarations.key?(property)
 
-      value.gsub!(/;\Z/, '')
-      is_important = !value.gsub!(CssParser::IMPORTANT_IN_PROPERTY_RX, '').nil?
-      property = property.downcase
-      property.strip!
-      #puts "SAVING #{property}  #{value} #{is_important.inspect}"
-      @declarations[property] = {
-        :value => value, :is_important => is_important, :order => @order += 1
-      }
-    end
-    alias_method :[]=, :add_declaration!
-
-    # Remove CSS declaration from the current RuleSet.
-    #
-    #  rule_set.remove_declaration!('color')
-    def remove_declaration!(property)
-      @declarations.delete(property)
+      "#{declarations[property]};"
     end
+    alias [] get_value
 
     # Iterate through selectors.
     #
@@ -98,42 +261,29 @@ module CssParser
     #     ...
     #   end
     def each_selector(options = {}) # :yields: selector, declarations, specificity
-      declarations = declarations_to_s(options)
+      decs = declarations.to_s(options)
       if @specificity
-        @selectors.each { |sel| yield sel.strip, declarations, @specificity }
+        @selectors.each { |sel| yield sel.strip, decs, @specificity }
       else
-        @selectors.each { |sel| yield sel.strip, declarations, CssParser.calculate_specificity(sel) }
+        @selectors.each { |sel| yield sel.strip, decs, CssParser.calculate_specificity(sel) }
       end
     end
 
     # Iterate through declarations.
     def each_declaration # :yields: property, value, is_important
-      decs = @declarations.sort { |a,b| a[1][:order].nil? || b[1][:order].nil? ? 0 : a[1][:order] <=> b[1][:order] }
-      decs.each do |property, data|
-        value = data[:value]
-        yield property.downcase.strip, value.strip, data[:is_important]
+      declarations.each do |property_name, value|
+        yield property_name, value.value, value.important
       end
     end
 
     # Return all declarations as a string.
-    #--
-    # TODO: Clean-up regexp doesn't seem to work
-    #++
     def declarations_to_s(options = {})
-      str = String.new
-      each_declaration do |prop, val, is_important|
-        importance = (options[:force_important] || is_important) ? ' !important' : ''
-        str << "#{prop}: #{val}#{importance}; "
-      end
-      str.gsub!(/^[\s^(\{)]+|[\n\r\f\t]*|[\s]+$/mx, '')
-      str.strip!
-      str
+      declarations.to_s(options)
     end
 
     # Return the CSS rule set as a string.
     def to_s
-      decs = declarations_to_s
-      "#{@selectors.join(',')} { #{decs} }"
+      "#{@selectors.join(',')} { #{declarations} }"
     end
 
     # Split shorthand declarations (e.g. +margin+ or +font+) into their constituent parts.
@@ -151,45 +301,44 @@ module CssParser
     #
     # 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]
-
-      if value =~ CssParser::RE_INHERIT
-        BACKGROUND_PROPERTIES.each do |prop|
-          split_declaration('background', prop, 'inherit')
-        end
-      end
-
-      split_declaration('background', 'background-image', value.slice!(Regexp.union(CssParser::URI_RX, CssParser::RE_GRADIENT, /none/i)))
-      split_declaration('background', 'background-attachment', value.slice!(CssParser::RE_SCROLL_FIXED))
-      split_declaration('background', 'background-repeat', value.slice!(CssParser::RE_REPEAT))
-      split_declaration('background', 'background-color', value.slice!(CssParser::RE_COLOUR))
-      split_declaration('background', 'background-size', extract_background_size_from(value))
-      split_declaration('background', 'background-position', value.slice(CssParser::RE_BACKGROUND_POSITION))
+      return unless declarations.key?('background')
+
+      value = declarations['background'].value.dup
+
+      replacement = BACKGROUND_PROPERTIES.map { |key| [key, 'inherit'] }.to_h if value.match(CssParser::RE_INHERIT)
+      replacement ||= {
+        'background-image' => value.slice!(Regexp.union(CssParser::URI_RX, CssParser::RE_GRADIENT, /none/i)),
+        'background-attachment' => value.slice!(CssParser::RE_SCROLL_FIXED),
+        'background-repeat' => value.slice!(CssParser::RE_REPEAT),
+        'background-color' => value.slice!(CssParser::RE_COLOUR),
+        'background-size' => extract_background_size_from(value),
+        'background-position' => value.slice!(CssParser::RE_BACKGROUND_POSITION)
+      }
 
-      @declarations.delete('background')
+      declarations.replace_declaration!('background', replacement, preserve_importance: true)
     end
 
     def extract_background_size_from(value)
       size = value.slice!(CssParser::RE_BACKGROUND_SIZE)
 
-      size.sub(/^\s*\/\s*/, '') if size
+      size.sub(%r{^\s*/\s*}, '') if size
     end
 
     # Split shorthand border declarations (e.g. <tt>border: 1px red;</tt>)
     # Additional splitting happens in expand_dimensions_shorthand!
     def expand_border_shorthand! # :nodoc:
       BORDER_PROPERTIES.each do |k|
-        next unless @declarations.has_key?(k)
+        next unless declarations.key?(k)
 
-        value = @declarations[k][:value]
+        value = declarations[k].value.dup
 
-        split_declaration(k, "#{k}-width", value.slice!(CssParser::RE_BORDER_UNITS))
-        split_declaration(k, "#{k}-color", value.slice!(CssParser::RE_COLOUR))
-        split_declaration(k, "#{k}-style", value.slice!(CssParser::RE_BORDER_STYLE))
+        replacement = {
+          "#{k}-width" => value.slice!(CssParser::RE_BORDER_UNITS),
+          "#{k}-color" => value.slice!(CssParser::RE_COLOUR),
+          "#{k}-style" => value.slice!(CssParser::RE_BORDER_STYLE)
+        }
 
-        @declarations.delete(k)
+        declarations.replace_declaration!(k, replacement, preserve_importance: true)
       end
     end
 
@@ -197,15 +346,16 @@ module CssParser
     # into their constituent parts.  Handles margin, padding, border-color, border-style and border-width.
     def expand_dimensions_shorthand! # :nodoc:
       DIMENSIONS.each do |property, (top, right, bottom, left)|
-        next unless @declarations.has_key?(property)
-        value = @declarations[property][:value]
+        next unless declarations.key?(property)
+
+        value = declarations[property].value.dup
 
         # RGB and HSL values in borders are the only units that can have spaces (within params).
         # We cheat a bit here by stripping spaces after commas in RGB and HSL values so that we
         # can split easily on spaces.
         #
         # TODO: rgba, hsl, hsla
-        value.gsub!(RE_COLOUR) { |c| c.gsub(/(\s*\,\s*)/, ',') }
+        value.gsub!(RE_COLOUR) { |c| c.gsub(/(\s*,\s*)/, ',') }
 
         matches = value.strip.split(/\s+/)
 
@@ -223,58 +373,54 @@ module CssParser
 
         t, r, b, l = values
 
-        split_declaration(property, top, t)
-        split_declaration(property, right, r)
-        split_declaration(property, bottom, b)
-        split_declaration(property, left, l)
-
-        @declarations.delete(property)
+        declarations.replace_declaration!(
+          property,
+          {top => t, right => r, bottom => b, left => l},
+          preserve_importance: true
+        )
       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')
+      return unless declarations.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-style', 'font-variant', 'font-weight', 'font-size', 'line-height'].each do |prop|
         font_props[prop] = 'normal'
-       end
+      end
 
-      value = @declarations['font'][:value]
-      value.gsub!(/\/\s+/, '/') # handle spaces between font size and height shorthand (e.g. 14px/ 16px)
-      is_important = @declarations['font'][:is_important]
-      order = @declarations['font'][:order]
+      value = declarations['font'].value.dup
+      value.gsub!(%r{/\s+}, '/') # handle spaces between font size and height shorthand (e.g. 14px/ 16px)
 
       in_fonts = false
 
       matches = value.scan(/("(.*[^"])"|'(.*[^'])'|(\w[^ ,]+))/)
       matches.each do |match|
         m = match[0].to_s.strip
-        m.gsub!(/[;]$/, '')
+        m.gsub!(/;$/, '')
 
         if in_fonts
-          if font_props.has_key?('font-family')
-            font_props['font-family'] += ', ' + m
+          if font_props.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)
+            font_props[font_prop] = m unless font_props.key?(font_prop)
           end
         elsif m =~ /italic|oblique/i
           font_props['font-style'] = m
-        elsif m =~ /small\-caps/i
+        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 =~ CssParser::FONT_UNITS_RX
-          if m =~ /\//
+          if m =~ %r{/}
             font_props['font-size'], font_props['line-height'] = m.split('/')
           else
             font_props['font-size'] = m
@@ -283,9 +429,7 @@ module CssParser
         end
       end
 
-      font_props.each { |font_prop, font_val| @declarations[font_prop] = {:value => font_val, :is_important => is_important, :order => order} }
-
-      @declarations.delete('font')
+      declarations.replace_declaration!('font', font_props, preserve_importance: true)
     end
 
     # Convert shorthand list-style declarations (e.g. <tt>list-style: lower-alpha outside;</tt>)
@@ -293,21 +437,18 @@ module CssParser
     #
     # See http://www.w3.org/TR/CSS21/generate.html#lists
     def expand_list_style_shorthand! # :nodoc:
-      return unless @declarations.has_key?('list-style')
+      return unless declarations.key?('list-style')
 
-      value = @declarations['list-style'][:value]
-
-      if value =~ CssParser::RE_INHERIT
-        LIST_STYLE_PROPERTIES.each do |prop|
-          split_declaration('list-style', prop, 'inherit')
-        end
-      end
+      value = declarations['list-style'].value.dup
 
-      split_declaration('list-style', 'list-style-type', value.slice!(CssParser::RE_LIST_STYLE_TYPE))
-      split_declaration('list-style', 'list-style-position', value.slice!(CssParser::RE_INSIDE_OUTSIDE))
-      split_declaration('list-style', 'list-style-image', value.slice!(Regexp.union(CssParser::URI_RX, /none/i)))
+      replacement = LIST_STYLE_PROPERTIES.map { |key| [key, 'inherit'] }.to_h if value =~ CssParser::RE_INHERIT
+      replacement ||= {
+        'list-style-type' => value.slice!(CssParser::RE_LIST_STYLE_TYPE),
+        'list-style-position' => value.slice!(CssParser::RE_INSIDE_OUTSIDE),
+        'list-style-image' => value.slice!(Regexp.union(CssParser::URI_RX, /none/i))
+      }
 
-      @declarations.delete('list-style')
+      declarations.replace_declaration!('list-style', replacement, preserve_importance: true)
     end
 
     # Create shorthand declarations (e.g. +margin+ or +font+) whenever possible.
@@ -321,23 +462,23 @@ module CssParser
     end
 
     # Combine several properties into a shorthand one
-    def create_shorthand_properties! properties, shorthand_property # :nodoc:
+    def create_shorthand_properties!(properties, shorthand_property) # :nodoc:
       values = []
       properties_to_delete = []
       properties.each do |property|
-        if @declarations.has_key?(property) and not @declarations[property][:is_important]
-          values << @declarations[property][:value]
+        if declarations.key?(property) and not declarations[property].important
+          values << declarations[property].value
           properties_to_delete << property
         end
       end
 
-      if values.length > 1
-        properties_to_delete.each do |property|
-          @declarations.delete(property)
-        end
+      return if values.length <= 1
 
-        @declarations[shorthand_property] = {:value => values.join(' ')}
+      properties_to_delete.each do |property|
+        declarations.delete(property)
       end
+
+      declarations[shorthand_property] = values.join(' ')
     end
 
     # Looks for long format CSS background properties (e.g. <tt>background-color</tt>) and
@@ -349,12 +490,12 @@ module CssParser
       # background-position by preceding it with a backslash. In this case we also need to
       # have a background-position property, so we set it if it's missing.
       # http://www.w3schools.com/cssref/css3_pr_background.asp
-      if @declarations.has_key?('background-size') and not @declarations['background-size'][:is_important]
-        unless @declarations.has_key?('background-position')
-          @declarations['background-position'] = {:value => '0% 0%'}
+      if declarations.key?('background-size') and not declarations['background-size'].important
+        unless declarations.key?('background-position')
+          declarations['background-position'] = '0% 0%'
         end
 
-        @declarations['background-size'][:value] = "/ #{@declarations['background-size'][:value]}"
+        declarations['background-size'].value = "/ #{declarations['background-size'].value}"
       end
 
       create_shorthand_properties! BACKGROUND_PROPERTIES, 'background'
@@ -368,89 +509,67 @@ module CssParser
       values = []
 
       BORDER_STYLE_PROPERTIES.each do |property|
-        if @declarations.has_key?(property) and not @declarations[property][:is_important]
-          # can't merge if any value contains a space (i.e. has multiple values)
-          # we temporarily remove any spaces after commas for the check (inside rgba, etc...)
-          return if @declarations[property][:value].gsub(/\,[\s]/, ',').strip =~ /[\s]/
-          values << @declarations[property][:value]
-        end
+        next unless declarations.key?(property) and not declarations[property].important
+        # can't merge if any value contains a space (i.e. has multiple values)
+        # we temporarily remove any spaces after commas for the check (inside rgba, etc...)
+        return nil if declarations[property].value.gsub(/,\s/, ',').strip =~ /\s/
+
+        values << declarations[property].value
+        declarations.delete(property)
       end
 
-      BORDER_STYLE_PROPERTIES.each { |prop| @declarations.delete(prop)}
+      return if values.empty?
 
-      unless values.empty?
-        @declarations['border'] = {:value => values.join(' ')}
-      end
+      declarations['border'] = values.join(' ')
     end
 
     # Looks for long format CSS dimensional properties (margin, padding, border-color, border-style and border-width)
     # and converts them into shorthand CSS properties.
     def create_dimensions_shorthand! # :nodoc:
-      return if @declarations.size < NUMBER_OF_DIMENSIONS
+      return if declarations.size < NUMBER_OF_DIMENSIONS
 
       DIMENSIONS.each do |property, dimensions|
-        (top, right, bottom, left) = dimensions
+        values = %i[top right bottom left].each_with_index.with_object({}) do |(side, index), result|
+          next unless declarations.key?(dimensions[index])
+
+          result[side] = declarations[dimensions[index]].value
+        end
+
         # All four dimensions must be present
-        if dimensions.count { |d| @declarations[d] } == NUMBER_OF_DIMENSIONS
-          values = {}
-
-          [
-            [:top, top],
-            [:right, right],
-            [:bottom, bottom],
-            [:left, left],
-          ].each { |d, key| values[d] = @declarations[key][: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
+        next if values.size != dimensions.size
 
-          new_value.strip!
-          @declarations[property] = {:value => new_value.strip} unless new_value.empty?
+        new_value = values.values_at(*compute_dimensions_shorthand(values)).join(' ').strip
+        declarations[property] = new_value unless new_value.empty?
 
-          # Delete the longhand values
-          [top, right, bottom, left].each { |d| @declarations.delete(d) }
-        end
+        # Delete the longhand values
+        dimensions.each { |d| declarations.delete(d) }
       end
     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_PROPERTIES.each do |prop|
-        return unless @declarations.has_key?(prop)
-      end
+      return unless FONT_STYLE_PROPERTIES.all? { |prop| declarations.key?(prop) }
 
       new_value = String.new
       ['font-style', 'font-variant', 'font-weight'].each do |property|
-        unless @declarations[property][:value] == 'normal'
-          new_value << @declarations[property][:value] << ' '
+        unless declarations[property].value == 'normal'
+          new_value << declarations[property].value << ' '
         end
       end
 
-      new_value << @declarations['font-size'][:value]
+      new_value << declarations['font-size'].value
 
-      unless @declarations['line-height'][:value] == 'normal'
-        new_value << '/' << @declarations['line-height'][:value]
+      unless declarations['line-height'].value == 'normal'
+        new_value << '/' << declarations['line-height'].value
       end
 
-      new_value << ' ' << @declarations['font-family'][:value]
+      new_value << ' ' << declarations['font-family'].value
 
-      @declarations['font'] = {:value => new_value.gsub(/[\s]+/, ' ').strip}
+      declarations['font'] = new_value.gsub(/\s+/, ' ')
 
-      FONT_STYLE_PROPERTIES.each { |prop| @declarations.delete(prop) }
+      FONT_STYLE_PROPERTIES.each { |prop| declarations.delete(prop) }
     end
 
     # Looks for long format CSS list-style properties (e.g. <tt>list-style-type</tt>) and
@@ -463,37 +582,32 @@ module CssParser
 
   private
 
-    # utility method for re-assign shorthand elements to longhand versions
-    def split_declaration(src, dest, v)  # :nodoc:
-      return unless v and not v.empty?
+    attr_accessor :declarations
 
-      if @declarations.has_key?(dest)
-        #puts "dest #{dest} already exists"
+    def compute_dimensions_shorthand(values)
+      # All four sides are equal, returning single value
+      return %i[top] if values.values.uniq.count == 1
 
-        if @declarations[src][:order].nil? || (!@declarations[dest][:order].nil? && @declarations[dest][:order] > @declarations[src][:order])
-          #puts "skipping #{dest}:#{v} due to order "
-          return
-        else
-          @declarations[dest] = {}
-        end
-      end
+      # `/* top | right | bottom | left */`
+      return %i[top right bottom left] if values[:left] != values[:right]
 
-      @declarations[dest] = @declarations[src].dup
-      @declarations[dest][:value] = v.to_s.strip
+      # Vertical are the same & horizontal are the same, `/* vertical | horizontal */`
+      return %i[top left] if values[:top] == values[:bottom]
+
+      %i[top left bottom]
     end
 
     def parse_declarations!(block) # :nodoc:
-      @declarations = {}
+      self.declarations = Declarations.new
 
       return unless block
 
       continuation = nil
-      block.split(/[\;$]+/m).each do |decs|
+      block.split(/[;$]+/m).each do |decs|
         decs = continuation ? continuation + decs : decs
         if decs =~ /\([^)]*\Z/ # if it has an unmatched parenthesis
-          continuation = decs + ';'
-
-        elsif matches = decs.match(/\s*(.[^:]*)\s*:\s*(.+?)(;?\s*\Z)/i)
+          continuation = "#{decs};"
+        elsif (matches = decs.match(/\s*(.[^:]*)\s*:\s*(.+?)(;?\s*\Z)/i))
           # skip end_of_declaration
           property = matches[1]
           value = matches[2]
@@ -516,7 +630,6 @@ module CssParser
   end
 
   class OffsetAwareRuleSet < RuleSet
-
     # File offset range
     attr_reader :offset