css_parser 1.1.9 → 1.2.1

data/lib/css_parser.rb

@@ -1,3 +1,4 @@
+require 'addressable/uri'
 require 'uri'
 require 'net/https'
 require 'open-uri'
@@ -7,7 +8,7 @@ require 'stringio'
 require 'iconv'
 
 module CssParser
-  VERSION = '1.1.9'
+  VERSION = '1.2.0'
 
   # Merge multiple CSS RuleSets by cascading according to the CSS 2.1 cascading rules 
   # (http://www.w3.org/TR/REC-CSS2/cascade.html#cascading-order).
@@ -139,21 +140,19 @@ module CssParser
   #               "http://example.org/style/basic.css").inspect
   #  => "body { background: url('http://example.org/style/yellow.png?abc=123') };"
   def self.convert_uris(css, base_uri)
-    out = ''
-    base_uri = URI.parse(base_uri) unless base_uri.kind_of?(URI)
+    base_uri = Addressable::URI.parse(base_uri) unless base_uri.kind_of?(Addressable::URI)
 
-    out = css.gsub(URI_RX) do |s|
+    css.gsub(URI_RX) do
       uri = $1.to_s
       uri.gsub!(/["']+/, '')
       # Don't process URLs that are already absolute
       unless uri =~ /^[a-z]+\:\/\//i
         begin
-          uri = base_uri.merge(uri) 
+          uri = base_uri + uri
         rescue; end
       end
-      "url('" + uri.to_s + "')"
+      "url('#{uri.to_s}')"
     end
-    out
   end
 end
 

data/lib/css_parser/parser.rb

@@ -121,7 +121,7 @@ module CssParser
         import_path = import_rule[0].to_s.gsub(/['"]*/, '').strip
 
         if options[:base_uri]
-          import_uri = URI.parse(options[:base_uri].to_s).merge(import_path)
+          import_uri = Addressable::URI.parse(options[:base_uri].to_s) + Addressable::URI.parse(import_path)
           load_uri!(import_uri, options[:base_uri], media_types)
         elsif options[:base_dir]
           load_file!(import_path, options[:base_dir], media_types)
@@ -293,7 +293,7 @@ module CssParser
     #
     # Deprecated: originally accepted three params: `uri`, `base_uri` and `media_types`
     def load_uri!(uri, options = {}, deprecated = nil)
-      uri = URI.parse(uri) unless uri.respond_to? :scheme
+      uri = Addressable::URI.parse(uri) unless uri.respond_to? :scheme
       #base_uri = nil, media_types = :all, options = {}
 
       opts = {:base_uri => nil, :media_types => :all}
@@ -324,6 +324,7 @@ module CssParser
     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)
+      return unless circular_reference_check(file_name)
 
       src = IO.read(file_name)
       base_dir = File.dirname(file_name)
@@ -334,6 +335,21 @@ module CssParser
     
 
   protected
+    # Check that a path hasn't been loaded already
+    #
+    # Raises a CircularReferenceError exception if io_exceptions are on, 
+    # otherwise returns true/false.
+    def circular_reference_check(path)
+      path = path.to_s
+      if @loaded_uris.include?(path)
+        raise CircularReferenceError, "can't load #{path} more than once" if @options[:io_exceptions]
+        return false
+      else
+        @loaded_uris << path
+        return true
+      end
+    end
+  
     # Strip comments and clean up blank lines from a block of CSS.
     #
     # Returns a string.
@@ -358,18 +374,12 @@ module CssParser
     # TODO: add option to fail silently or throw and exception on a 404
     #++
     def read_remote_file(uri) # :nodoc:
-      if @loaded_uris.include?(uri.to_s)
-        raise CircularReferenceError, "can't load #{uri.to_s} more than once" if @options[:io_exceptions]
-        return '', nil
-      end
-
-      @loaded_uris << uri.to_s
+      return nil, nil unless circular_reference_check(uri.to_s)    
 
       src = '', charset = nil
 
       begin
-        uri = URI.parse(uri.to_s)    
-        http = Net::HTTP.new(uri.host, uri.port)
+        uri = Addressable::URI.parse(uri.to_s)          
 
         if uri.scheme == 'file'
           # local file
@@ -379,8 +389,12 @@ module CssParser
         else
           # remote file
           if uri.scheme == 'https'
+            uri.port = 443 unless uri.port
+            http = Net::HTTP.new(uri.host, uri.port)
             http.use_ssl = true 
             http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          else
+            http = Net::HTTP.new(uri.host, uri.port)
           end
 
           res, src = http.get(uri.path, {'User-Agent' => USER_AGENT, 'Accept-Encoding' => 'gzip'})

data/lib/css_parser/regexps.rb

@@ -1,4 +1,10 @@
 module CssParser
+
+
+  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)')
@@ -12,6 +18,8 @@ module CssParser
   RE_STRING2 = Regexp.new('(\'(.[^\n\r\f\\\']*|\\\\' + RE_NL.to_s + '|' + RE_ESCAPE.to_s + ')*\')')
   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
 
@@ -23,24 +31,62 @@ module CssParser
   
   #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
+  IMPORTANT_IN_PROPERTY_RX = /[\s]*!important[\s]*/i
+
+  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'
+
   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)
+  RE_BACKGROUND_POSITION = Regexp.new("((((#{RE_LENGTH_OR_PERCENTAGE})|left|center|right|top|bottom)[\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
+  RE_BORDER_UNITS = Regexp.union(BOX_MODEL_UNITS_RX, /(thin|medium|thick)/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
+  NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES_RX= /
+    (\.[\w]+)                     # classes
+    |
+    \[(\w+)                       # attributes
+    |
+    (\:(                          # pseudo classes
+      link|visited|active
+      |hover|focus
+      |lang
+      |target
+      |enabled|disabled|checked|indeterminate
+      |root
+      |nth-child|nth-last-child|nth-of-type|nth-last-of-type
+      |first-child|last-child|first-of-type|last-of-type
+      |only-child|only-of-type
+      |empty|contains
+    ))
+  /ix
+  ELEMENTS_AND_PSEUDO_ELEMENTS_RX = /
+    ((^|[\s\+\>\~]+)[\w]+       # elements
+    |                   
+    \:{1,2}(                    # pseudo-elements
+      after|before
+      |first-letter|first-line
+      |selection
+    )
+  )/ix
 
   # Colours
-  RE_COLOUR_RGB = Regexp.new('(rgb[\s]*\([\s-]*[\d]+(\.[\d]+)?[%\s]*,[\s-]*[\d]+(\.[\d]+)?[%\s]*,[\s-]*[\d]+(\.[\d]+)?[%\s]*\))', Regexp::IGNORECASE)
+  RE_COLOUR_NUMERIC = Regexp.new('((hsl|rgb)[\s]*\([\s-]*[\d]+(\.[\d]+)?[%\s]*,[\s-]*[\d]+(\.[\d]+)?[%\s]*,[\s-]*[\d]+(\.[\d]+)?[%\s]*\))', Regexp::IGNORECASE)
+  RE_COLOUR_NUMERIC_ALPHA = Regexp.new('((hsla|rgba)[\s]*\([\s-]*[\d]+(\.[\d]+)?[%\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)
+  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

@@ -4,6 +4,9 @@ module CssParser
     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
 
+    BACKGROUND_PROPERTIES = ['background-color', 'background-image', 'background-repeat', 'background-position', 'background-attachment']
+    LIST_STYLE_PROPERTIES = ['list-style-type', 'list-style-position', 'list-style-image']
+
     # Array of selector strings.
     attr_reader   :selectors
     
@@ -109,65 +112,111 @@ module CssParser
        importance = (options[:force_important] || is_important) ? ' !important' : ''
        str += "#{prop}: #{val}#{importance}; "
      end
-     str.gsub(/^[\s]+|[\n\r\f\t]*|[\s]+$/mx, '').strip
+     str.gsub(/^[\s^(\{)]+|[\n\r\f\t]*|[\s]+$/mx, '').strip
     end
 
     # Return the CSS rule set as a string.
     def to_s
       decs = declarations_to_s
-      "#{@selectors} { #{decs} }"
+      "#{@selectors.join} { #{decs} }"
     end
 
     # Split shorthand declarations (e.g. +margin+ or +font+) into their constituent parts.
     def expand_shorthand!
+      # border must be expanded before dimensions
+      expand_border_shorthand!
       expand_dimensions_shorthand!
       expand_font_shorthand!
       expand_background_shorthand!
+      expand_list_style_shorthand!
     end
 
-    # Create shorthand declarations (e.g. +margin+ or +font+) whenever possible.
-    def create_shorthand!
-      create_background_shorthand!
-      create_dimensions_shorthand!
-      create_font_shorthand!
+    # 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]
+
+      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, /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-position', value.slice(CssParser::RE_BACKGROUND_POSITION))
+
+      @declarations.delete('background')
+    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', 'border-left', 'border-right', 'border-top', 'border-bottom'].each do |k|
+        next unless @declarations.has_key?(k)
+
+        value = @declarations[k][:value]
+
+        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))
+
+        @declarations.delete(k)   
+      end
     end
 
     # Split shorthand dimensional declarations (e.g. <tt>margin: 0px auto;</tt>)
-    # into their constituent parts.
+    # into their constituent parts.  Handles margin, padding, border-color, border-style and border-width.
     def expand_dimensions_shorthand! # :nodoc:
-      ['margin', 'padding'].each do |property|
+      {'margin'       => 'margin-%s',
+       'padding'      => 'padding-%s',
+       'border-color' => 'border-%s-color', 
+       'border-style' => 'border-%s-style', 
+       'border-width' => 'border-%s-width'}.each do |property, expanded|
 
         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(CssParser::BOX_MODEL_UNITS_RX)
+        # 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]+/, '') }
+
+        matches = value.strip.split(/[\s]+/)
+
+        t, r, b, l = nil
 
         case matches.length
           when 1
-            t, r, b, l = matches[0][0], matches[0][0], matches[0][0], matches[0][0]
+            t, r, b, l = matches[0], matches[0], matches[0], matches[0]
           when 2
-            t, b = matches[0][0], matches[0][0]
-            r, l = matches[1][0], matches[1][0]
+            t, b = matches[0], matches[0]
+            r, l = matches[1], matches[1]
           when 3
-            t =  matches[0][0]
-            r, l = matches[1][0], matches[1][0]
-            b =  matches[2][0]
+            t =  matches[0]
+            r, l = matches[1], matches[1]
+            b =  matches[2]
           when 4
-            t =  matches[0][0]
-            r = matches[1][0]
-            b =  matches[2][0]
-            l = matches[3][0]
+            t =  matches[0]
+            r = matches[1]
+            b =  matches[2]
+            l = matches[3]
         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)
+        split_declaration(property, expanded % 'top', t)
+        split_declaration(property, expanded % 'right', r)
+        split_declaration(property, expanded % 'bottom', b)
+        split_declaration(property, expanded % 'left', l)
+
         @declarations.delete(property)
       end
     end
@@ -227,92 +276,105 @@ module CssParser
       @declarations.delete('font')
     end
 
-
-    # Convert shorthand background declarations (e.g. <tt>background: url("chess.png") gray 50% repeat fixed;</tt>)
+    # Convert shorthand list-style declarations (e.g. <tt>list-style: lower-alpha outside;</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 = {}
+    # See http://www.w3.org/TR/CSS21/generate.html#lists
+    def expand_list_style_shorthand! # :nodoc:
+      return unless @declarations.has_key?('list-style')
 
+      value = @declarations['list-style'][:value]
 
-      if m = value.match(Regexp.union(CssParser::URI_RX, /none/i)).to_s
-        bg_props['background-image'] = m.strip unless m.empty?
-        value.gsub!(Regexp.union(CssParser::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?
+      if value =~ CssParser::RE_INHERIT
+        LIST_STYLE_PROPERTIES.each do |prop|
+          split_declaration('list-style', prop, 'inherit')
+        end
       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
+      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)))
 
-      if m = value.match(CssParser::RE_COLOUR).to_s
-        bg_props['background-color'] = m.strip unless m.empty?
-      end
+      @declarations.delete('list-style')
+    end
 
-      value.scan(CssParser::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
+    # Create shorthand declarations (e.g. +margin+ or +font+) whenever possible.
+    def create_shorthand!
+      create_background_shorthand!
+      create_dimensions_shorthand!
+      # border must be shortened after dimensions
+      create_border_shorthand!
+      create_font_shorthand!
+      create_list_style_shorthand!
+    end
 
+    # Combine several properties into a shorthand one
+    def create_shorthand_properties! properties, shorthand_property # :nodoc:
+      values = []
+      properties.each do |property|
+         if @declarations.has_key?(property) and not @declarations[property][:is_important]
+          values << @declarations[property][:value]
+           @declarations.delete(property)
+         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
+      unless values.empty?
+        @declarations[shorthand_property] = {:value => values.join(' ')}
       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 
+    # Looks for long format CSS background properties (e.g. <tt>background-color</tt>) and
     # converts them into a shorthand CSS <tt>background</tt> property.
     #
     # Leaves properties declared !important alone.
     def create_background_shorthand! # :nodoc:
-      new_value = ''
-      ['background-color', 'background-image', 'background-repeat', 
-       'background-position', 'background-attachment'].each do |property|
+      create_shorthand_properties! BACKGROUND_PROPERTIES, 'background'
+    end
+    
+    # Combine border-color, border-style and border-width into border
+    # Should be run after create_dimensions_shorthand!
+    #
+    # TODO: this is extremely similar to create_background_shorthand! and should be combined
+    def create_border_shorthand! # :nodoc:
+      values = []
+      
+      ['border-width', 'border-style', 'border-color'].each do |property|
         if @declarations.has_key?(property) and not @declarations[property][:is_important]
-          new_value += @declarations[property][:value] + ' '
-          @declarations.delete(property)
+          # 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
       end
 
-      unless new_value.strip.empty?
-        @declarations['background'] = {:value => new_value.gsub(/[\s]+/, ' ').strip}
+      @declarations.delete('border-width')
+      @declarations.delete('border-style')
+      @declarations.delete('border-color')
+
+      unless values.empty?
+        @declarations['border'] = {:value => values.join(' ')}
       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.
+    
+    # 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:
-      # 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" }
+      {'margin'       => 'margin-%s',
+       'padding'      => 'padding-%s',
+       'border-color' => 'border-%s-color', 
+       'border-style' => 'border-%s-style', 
+       'border-width' => 'border-%s-width'}.each do |property, expanded|
+
+        foldable = @declarations.select do |dim, val| 
+          dim == expanded % 'top' or dim == expanded % 'right' or dim == expanded % 'bottom' or dim == expanded % 'left'
+        end
         # All four dimensions must be present
         if foldable.length == 4
           values = {}
 
-          directions.each { |d| values[d.to_sym] = @declarations["#{property}-#{d}"][:value].downcase.strip }
+          directions.each { |d| values[d.to_sym] = @declarations[expanded % d][:value].downcase.strip }
 
           if values[:left] == values[:right]
             if values[:top] == values[:bottom] 
@@ -326,17 +388,15 @@ module CssParser
             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}") }
+          new_value.strip!
+          @declarations[property] = {:value => new_value.strip} unless new_value.empty?
+
+          # Delete the longhand values
+          directions.each { |d| @declarations.delete(expanded % d) }
         end
-      end # done iterating through margin and padding
+      end
     end
 
 
@@ -373,7 +433,33 @@ module CssParser
 
     end
 
+    # Looks for long format CSS list-style properties (e.g. <tt>list-style-type</tt>) and
+    # converts them into a shorthand CSS <tt>list-style</tt> property.
+    #
+    # Leaves properties declared !important alone.
+    def create_list_style_shorthand! # :nodoc:
+      create_shorthand_properties! LIST_STYLE_PROPERTIES, 'list-style'
+    end
+
   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?
+
+      if @declarations.has_key?(dest)
+        #puts "dest #{dest} already exists"
+      
+        if @declarations[dest][:order] > @declarations[src][:order]
+          #puts "skipping #{dest}:#{v} due to order "        
+          return
+        else
+          @declarations[dest] = {}    
+        end
+      end
+      @declarations[dest] = @declarations[src].merge({:value => v.to_s.strip})    
+    end
+  
     def parse_declarations!(block) # :nodoc:
       @declarations = {}
 

data/test/test_css_parser_loading.rb

@@ -52,7 +52,7 @@ class CssParserLoadingTests < Test::Unit::TestCase
   # http://github.com/alexdunae/css_parser/issues#issue/4
   def test_loading_a_remote_file_over_ssl
     # TODO: test SSL locally
-    @cp.load_uri!("https://www.expresspardons.com/inc/screen.css")
+    @cp.load_uri!("https://dialect.ca/inc/screen.css")
     assert_match /margin\: 0\;/, @cp.find_by_selector('body').join(' ')
   end
 
@@ -83,6 +83,14 @@ class CssParserLoadingTests < Test::Unit::TestCase
     # from '/subdir/../simple.css'
     assert_equal 'margin: 0px;', @cp.find_by_selector('p').join(' ')
   end
+  
+  def test_following_badly_escaped_import_rules
+    css_block = '@import "http://example.com/css?family=Droid+Sans:regular,bold|Droid+Serif:regular,italic,bold,bolditalic&subset=latin";'
+
+    assert_nothing_raised do
+      @cp.add_block!(css_block, :base_uri => "#{@uri_base}/subdir/")
+    end
+  end
 
   def test_following_at_import_rules_from_add_block
     css_block = '@import "../simple.css";'
@@ -101,20 +109,19 @@ class CssParserLoadingTests < Test::Unit::TestCase
     assert_equal '', @cp.find_by_selector('p', :tty).join(' ')
   end
 
-  def test_throwing_circular_reference_exception
+  def test_local_circular_reference_exception
     assert_raise CircularReferenceError do
-      @cp.load_uri!("#{@uri_base}/import-circular-reference.css")
+      @cp.load_file!(File.dirname(__FILE__) + '/fixtures/import-circular-reference.css')
     end
+  end
 
-    cp_without_exceptions = Parser.new(:io_exceptions => false)
-
-    assert_nothing_raised CircularReferenceError do
-      cp_without_exceptions.load_uri!("#{@uri_base}/import-circular-reference.css")
+  def test_remote_circular_reference_exception
+    assert_raise CircularReferenceError do
+      @cp.load_uri!("#{@uri_base}/import-circular-reference.css")
     end
-    
   end
 
-  def test_toggling_circular_reference_exception
+  def test_suppressing_circular_reference_exceptions
     cp_without_exceptions = Parser.new(:io_exceptions => false)
 
     assert_nothing_raised CircularReferenceError do

data/test/test_css_parser_misc.rb

@@ -139,4 +139,26 @@ class CssParserTests < Test::Unit::TestCase
     assert_equal ".specs {font-family:Helvetica;font-weight:bold;font-style:italic;color:#008CA8;font-size:1.4em;list-style-image:url('http://www.example.org/directory/images/bullet.gif');}", converted_css
   end
 
+  def test_ruleset_with_braces
+=begin  
+    parser = Parser.new
+    parser.add_block!("div { background-color: black !important; }")
+    parser.add_block!("div { background-color: red; }")
+
+    rulesets = []
+
+    parser['div'].each do |declaration|
+      rulesets << RuleSet.new('div', declaration)
+    end
+
+    merged = CssParser.merge(rulesets)
+
+    result: # merged.to_s => "{ background-color: black !important; }"
+=end
+
+    new_rule = RuleSet.new('div', "{ background-color: black !important; }")
+
+    assert_equal 'div { background-color: black !important; }', new_rule.to_s
+  end
+
 end

data/test/test_rule_set.rb

@@ -34,13 +34,13 @@ class RuleSetTests < Test::Unit::TestCase
        {:selector => "#content p", :declarations => "color: #fff;", :specificity => 101},
        {:selector => "a", :declarations => "color: #fff;", :specificity => 1}
     ]
-    
+
     actual = []
     rs = RuleSet.new('#content p, a', 'color: #fff;')
     rs.each_selector do |sel, decs, spec|
       actual << {:selector => sel, :declarations => decs, :specificity => spec}
     end
-    
+
     assert_equal(expected, actual)
   end
 
@@ -50,13 +50,13 @@ class RuleSetTests < Test::Unit::TestCase
        {:property => 'background', :value => 'white none no-repeat', :is_important => true},
        {:property => 'color', :value => '#fff', :is_important => false}
     ])
-    
+
     actual = Set.new
     rs = RuleSet.new(nil, 'color: #fff; Background: white none no-repeat !important; margin: 1px -0.25em;')
     rs.each_declaration do |prop, val, imp|
       actual << {:property => prop, :value => val, :is_important => imp}
     end
-    
+
     assert_equal(expected, actual)
   end
 

data/test/test_rule_set_creating_shorthand.rb

@@ -8,6 +8,35 @@ class RuleSetCreatingShorthandTests < Test::Unit::TestCase
     @cp = CssParser::Parser.new
   end
 
+# ==== Border shorthand
+  def test_combining_borders_into_shorthand
+    properties = {'border-top-width' => 'auto', 'border-right-width' => 'thin', 'border-bottom-width' => 'auto', 'border-left-width' => '0px'}
+
+    combined = create_shorthand(properties)
+
+    assert_equal('', combined['border'])
+    assert_equal('auto thin auto 0px;', combined['border-width'])
+
+    # after creating shorthand, all long-hand properties should be deleted
+    assert_properties_are_deleted(combined, properties)
+
+    # should not combine if any properties are missing
+    properties.delete('border-top-width')
+
+    combined = create_shorthand(properties)
+
+    assert_equal '', combined['border-width']
+    
+    properties = {'border-width' => '22%', 'border-color' => 'rgba(255, 0, 0)'}
+    combined = create_shorthand(properties)
+    assert_equal '22% rgba(255, 0, 0);', combined['border']
+    assert_equal '', combined['border-width']
+    
+    properties = {'border-top-style' => 'none', 'border-right-style' => 'none', 'border-bottom-style' => 'none', 'border-left-style' => 'none'}
+    combined = create_shorthand(properties)
+    assert_equal 'none;', combined['border']
+  end
+
 # ==== Dimensions shorthand
   def test_combining_dimensions_into_shorthand
     properties = {'margin-right' => 'auto', 'margin-bottom' => '0px', 'margin-left' => 'auto', 'margin-top' => '0px', 
@@ -64,6 +93,21 @@ class RuleSetCreatingShorthandTests < Test::Unit::TestCase
     assert_properties_are_deleted(combined, properties)
   end
 
+
+# ==== List-style shorthand
+  def test_combining_list_style_into_shorthand
+    properties = {'list-style-image' => 'url(\'chess.png\')', 'list-style-type' => 'katakana',
+                  'list-style-position' => 'inside'}
+
+    combined = create_shorthand(properties)
+
+    assert_equal('katakana inside url(\'chess.png\');', combined['list-style'])
+
+    # after creating shorthand, all long-hand properties should be deleted
+    assert_properties_are_deleted(combined, properties)
+  end
+
+
   def test_property_values_in_url
     rs = RuleSet.new('#header', "background:url(http://example.com/1528/www/top-logo.jpg) no-repeat top right; padding: 79px 0 10px 0;  text-align:left;")
     rs.expand_shorthand!

data/test/test_rule_set_expanding_shorthand.rb

@@ -7,6 +7,26 @@ class RuleSetExpandingShorthandTests < Test::Unit::TestCase
     @cp = CssParser::Parser.new
   end
 
+# ==== Dimensions shorthand
+  def test_expanding_border_shorthand
+    declarations = expand_declarations('border: none')
+    assert_equal 'none', declarations['border-right-style']
+
+    declarations = expand_declarations('border: 1px solid red')
+    assert_equal '1px', declarations['border-top-width']
+    assert_equal 'solid', declarations['border-bottom-style']  
+    
+    declarations = expand_declarations('border-color: red hsla(255, 0, 0, 5) rgb(2% ,2%,2%)')
+    assert_equal 'red', declarations['border-top-color']
+    assert_equal 'rgb(2%,2%,2%)', declarations['border-bottom-color']
+    assert_equal 'hsla(255,0,0,5)', declarations['border-left-color']
+
+    declarations = expand_declarations('border: thin dot-dot-dash')
+    assert_equal 'dot-dot-dash', declarations['border-left-style']
+    assert_equal 'thin', declarations['border-left-width']
+    assert_nil declarations['border-left-color']
+  end
+
 # ==== Dimensions shorthand
   def test_getting_dimensions_from_shorthand
     # test various shorthand forms
@@ -163,6 +183,31 @@ class RuleSetExpandingShorthandTests < Test::Unit::TestCase
     end
   end
 
+  # ==== List-style shorthand
+  def test_getting_list_style_properties_from_shorthand
+    expected = {'list-style-image' => 'url(\'chess.png\')', 'list-style-type' => 'katakana',
+                  'list-style-position' => 'inside'}
+
+    shorthand = "list-style: katakana inside url(\'chess.png\');"
+    declarations = expand_declarations(shorthand)
+    assert_equal expected, declarations
+  end
+
+  def test_getting_list_style_position_from_shorthand
+    ['inside', 'outside'].each do |position|
+      shorthand = "list-style: katakana #{position} url('chess.png');"
+      declarations = expand_declarations(shorthand)
+      assert_equal(position, declarations['list-style-position'])
+    end
+  end
+
+  def test_getting_list_style_type_from_shorthand
+    ['disc', 'circle', 'square', 'decimal', 'decimal-leading-zero', 'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha', 'lower-latin', 'upper-alpha', 'upper-latin', 'hebrew', 'armenian', 'georgian', 'cjk-ideographic', 'hiragana', 'katakana', 'hira-gana-iroha', 'katakana-iroha', 'none'].each do |type|
+      shorthand = "list-style: #{type} inside url('chess.png');"
+      declarations = expand_declarations(shorthand)
+      assert_equal(type, declarations['list-style-type'])
+    end
+  end
 
 protected
   def expand_declarations(declarations)

metadata

@@ -1,32 +1,33 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: css_parser
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 1
-  - 1
-  - 9
-  version: 1.1.9
+version: !ruby/object:Gem::Version
+  version: 1.2.1
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Alex Dunae
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-01 00:00:00 -07:00
-default_executable: 
-dependencies: []
-
+date: 2011-09-07 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: &2154706420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2154706420
 description: A set of classes for parsing CSS in Ruby.
 email: code@dunae.ca
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/css_parser.rb
 - lib/css_parser/parser.rb
 - lib/css_parser/regexps.rb
@@ -46,43 +47,36 @@ files:
 - test/test_rule_set.rb
 - test/test_rule_set_creating_shorthand.rb
 - test/test_rule_set_expanding_shorthand.rb
-has_rdoc: true
-homepage: http://github.com/alexdunae/css_parser
+homepage: https://github.com/alexdunae/css_parser
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --all
 - --inline-source
 - --line-numbers
 - --charset
 - utf-8
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: Ruby CSS parser.
-test_files: 
+test_files:
 - test/test_css_parser_basic.rb
 - test/test_css_parser_loading.rb
 - test/test_css_parser_media_types.rb