Redundancy analyzer now parses shorthand rules and check for matches

There's quite a bit of looping and relooping that I'm not happy about,
but it might just be performant enough.

Author: zmoazeni

lib/csscss/redundancy_analyzer.rb

@@ -14,10 +14,24 @@ def redundancies(minimum = nil)
             exp.value.downcase!
           end
 
-          dec_key = Declaration.from_csspool(dec)
           sel = Selector.new(rule_set.selectors.map(&:to_s))
-          matches[dec_key] ||= []
-          matches[dec_key] << sel
+
+          original_dec = Declaration.from_csspool(dec)
+
+          if parser = shorthand_parser(dec.property)
+            if new_decs = parser.parse(dec.expressions)
+              new_decs.each do |new_dec|
+                # replace any non-derivatives with derivatives
+                existing = matches.delete(new_dec) || []
+                existing << sel
+                new_dec.parent = original_dec
+                matches[new_dec] = existing
+              end
+            end
+          end
+
+          matches[original_dec] ||= []
+          matches[original_dec] << sel
         end
       end
 
@@ -37,6 +51,7 @@ def redundancies(minimum = nil)
         end
       end
 
+      # combines selector keys by common declarations
       final_inverted_matches = inverted_matches.dup
       inverted_matches.to_a[0..-2].each_with_index do |(selector_group1, declarations1), index|
         inverted_matches.to_a[(index + 1)..-1].each do |selector_group2, declarations2|
@@ -50,12 +65,29 @@ def redundancies(minimum = nil)
         end
       end
 
+      # trims any derivative declarations alongside shorthand
+      final_inverted_matches.each do |selectors, declarations|
+        redundant_derivatives = declarations.select do |dec|
+          dec.derivative? && declarations.include?(dec.parent)
+        end
+        unless redundant_derivatives.empty?
+          final_inverted_matches[selectors] = declarations - redundant_derivatives
+        end
+      end
+
+      # sort hash by number of matches
       sorted_array = final_inverted_matches.sort {|(_, v1), (_, v2)| v2.size <=> v1.size }
       {}.tap do |sorted_hash|
         sorted_array.each do |key, value|
           sorted_hash[key.sort] = value.sort
         end
       end
     end
+
+    def shorthand_parser(property)
+      case property
+      when "background" then Parser::Background
+      end
+    end
   end
 end

test/csscss/redundancy_analyzer_test.rb

@@ -79,5 +79,61 @@ module Csscss
       redundancies = RedundancyAnalyzer.new(css).redundancies(3)
       redundancies[[sel(".bar"), sel(".baz")]].size.must_equal(5)
     end
+
+    it "also matches shorthand rules" do
+      css = %$
+        .foo { background-color: #fff }
+        .bar { background: #fff top }
+      $
+
+      RedundancyAnalyzer.new(css).redundancies.must_equal({
+        [sel(".bar"), sel(".foo")] => [dec("background-color", "#fff")]
+      })
+    end
+
+    it "keeps full shorthand together" do
+      css = %$
+        .baz { background-color: #fff }
+        .foo { background: #fff top }
+        .bar { background: #fff top }
+      $
+
+      RedundancyAnalyzer.new(css).redundancies.must_equal({
+        [sel(".bar"), sel(".foo")] => [dec("background", "#fff top")],
+        [sel(".bar"), sel(".baz"), sel(".foo")] => [dec("background-color", "#fff")]
+      })
+    end
+
+    it "doesn't consolidate explicit short/longhand" do
+      css = %$
+        .foo { background-color: #fff }
+        .bar { background: #fff }
+      $
+
+      RedundancyAnalyzer.new(css).redundancies.must_equal({
+        [sel(".bar"), sel(".foo")] => [dec("background-color", "#fff")]
+      })
+
+      css = %$
+        .bar { background: #fff }
+        .foo { background-color: #fff }
+      $
+
+      RedundancyAnalyzer.new(css).redundancies.must_equal({
+        [sel(".bar"), sel(".foo")] => [dec("background-color", "#fff")]
+      })
+    end
+
+    it "3-way case consolidation" do
+      css = %$
+        .bar { background: #fff }
+        .baz { background: #fff top }
+        .foo { background-color: #fff }
+      $
+
+      RedundancyAnalyzer.new(css).redundancies.must_equal({
+        [sel(".bar"), sel(".baz"), sel(".foo")] => [dec("background-color", "#fff")]
+      })
+    end
   end
 end