Refactors analyzer to return sorted hash and implements reporter

Author: zmoazeni

lib/csscss.rb

@@ -1,10 +1,12 @@
+require "stringio"
+
 require "parslet"
 require "csspool"
 
 require "csscss/version"
 require "csscss/types"
 require "csscss/redundancy_analyzer"
+require "csscss/reporter"
 
 module Csscss
-  # Your code goes here...
 end

lib/csscss/redundancy_analyzer.rb

@@ -7,41 +7,38 @@ def initialize(raw_css)
 
   def redundancies(minimum = nil)
     rule_sets = CSSPool.CSS(@raw_css).rule_sets
-    {}.tap do |matches|
-      used = {}
-      rule_sets.each {|rs| downcase_all_expressions(rs) }
-      rule_sets[0..-2].each.with_index do |rule_set1, index|
-        rule_sets[(index + 1)..-1].each do |rule_set2|
-          rule_set1.declarations.each do |dec|
-            unless used[[rule_set1, dec]]
-              if rule_set2.declarations.include?(dec)
-                sel1 = Selector.new(rule_set1.selectors.map(&:to_s))
-                sel2 = Selector.new(rule_set2.selectors.map(&:to_s))
-                dec_key = Declaration.from_csspool(dec)
-                matches[sel1] ||= {}
-                matches[sel1][dec_key] ||= []
-                matches[sel1][dec_key] << sel2
-                used[[rule_set2,dec]] = true
-              end
-            end
-          end
+    matches = {}
+    rule_sets.each do |rule_set|
+      rule_set.declarations.each do |dec|
+        dec.property.downcase!
+        dec.expressions do |exp|
+          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
       end
+    end
 
-      if minimum
-        matches.each do |rs1, dec_map|
-          dec_map.each do |dec, other_rule_sets|
-            dec_map.delete(dec) if other_rule_sets.size < minimum - 1
-          end
+    inverted_matches = {}
+    matches.each do |declaration, selector_groups|
+      inverted_matches[selector_groups] ||= []
+      inverted_matches[selector_groups] << declaration
+    end
 
-          matches.delete(rs1) if dec_map.keys.size == 0
-        end
+    if minimum
+      inverted_matches.delete_if do |_, declarations|
+        declarations.size < minimum
       end
     end
-  end
 
-  private
-  def downcase_all_expressions(rule_set)
-    rule_set.declarations.each {|dec| dec.property.downcase! }
+    sorted_array = inverted_matches.sort {|(_, v1), (_, v2)| v2.size <=> v1.size }
+    {}.tap do |sorted_hash|
+      sorted_array.each do |key, value|
+        sorted_hash[key] = value
+      end
+    end
   end
 end

lib/csscss/reporter.rb

@@ -0,0 +1,20 @@
+class Csscss::Reporter
+  def initialize(redundancies)
+    @redundancies = redundancies
+  end
+
+  def report
+    io = StringIO.new
+    @redundancies.each do |selector_groups, declarations|
+      selector_groups = selector_groups.map {|selectors| "{#{selectors.selectors.join(", ")}}" }
+      last_selector = selector_groups.pop
+      count = declarations.size
+      unless selector_groups.empty?
+        io.puts %Q(#{selector_groups.join(", ")} and #{last_selector} share #{count} rule#{"s" if count > 1})
+      end
+    end
+
+    io.rewind
+    io.read
+  end
+end

spec/csscss/redundancy_analyzer_spec.rb

@@ -6,22 +6,22 @@ module Csscss
       css = %$
         h1, h2 { display: none; position: relative; outline:none}
         .foo { display: none; width: 1px }
-        .bar { position: relative; width: 1px }
+        .bar { position: relative; width: 1px; outline: none }
         .baz { display: none }
       $
 
       RedundancyAnalyzer.new(css).redundancies.must_equal({
-        sel(%w(h1 h2)) => {
-          dec("display", "none") => [sel(".foo"), sel(".baz")],
-          dec("position", "relative") => [sel(".bar")]
-        },
-        sel(".foo") => { dec("width", "1px") => [sel(".bar")] },
+        [sel(%w(h1 h2)), sel(".bar")] => [dec("position", "relative"), dec("outline", "none")],
+        [sel(%w(h1 h2)), sel(".foo"), sel(".baz")] => [dec("display", "none")],
+        [sel(".foo"), sel(".bar")] => [dec("width", "1px")]
       })
 
-      RedundancyAnalyzer.new(css).redundancies(3).must_equal({
-        sel(%w(h1 h2)) => {
-          dec("display", "none") => [sel(".foo"), sel(".baz")]
-        }
+      RedundancyAnalyzer.new(css).redundancies.first.must_equal [
+        [sel(%w(h1 h2)), sel(".bar")], [dec("position", "relative"), dec("outline", "none")]
+      ]
+
+      RedundancyAnalyzer.new(css).redundancies(2).must_equal({
+        [sel(%w(h1 h2)), sel(".bar")] => [dec("position", "relative"),dec("outline", "none")]
       })
     end
 
@@ -32,9 +32,7 @@ module Csscss
       $
 
       RedundancyAnalyzer.new(css).redundancies.must_equal({
-        sel(".foo") => {
-          dec("width", "1px") => [sel(".bar")]
-        }
+        [sel(".foo"), sel(".bar")] => [dec("width", "1px")]
       })
     end
   end

test/csscss/redundancy_analyzer_test.rb

@@ -0,0 +1,21 @@
+require "test_helper"
+
+module Csscss
+  describe Reporter do
+    it "formats string result" do
+      reporter = Reporter.new({
+        [sel(".foo"), sel(".bar")] => [dec("width", "1px"), dec("border", "black")],
+        [sel(%w(h1 h2)), sel(".foo"), sel(".baz")] => [dec("display", "none")],
+        [sel(%w(h1 h2)), sel(".bar")] => [dec("position", "relative")],
+        [sel(%w(h1 h2))] => [dec("outline", "none")]
+      })
+
+     expected =<<-EXPECTED
+{.foo} and {.bar} share 2 rules
+{h1, h2}, {.foo} and {.baz} share 1 rule
+{h1, h2} and {.bar} share 1 rule
+EXPECTED
+     reporter.report.must_equal expected
+    end
+  end
+end