sum_sum 0.0.3 → 0.0.4

data/CHANGES.md

@@ -1,6 +1,13 @@
 ### dev
 
-[full changelog](http://github.com/yolk/sum_sum/compare/v0.0.3...master)
+[full changelog](http://github.com/yolk/sum_sum/compare/v0.0.4...master)
+
+### 0.0.4 / 2011-01-27
+
+[full changelog](http://github.com/yolk/sum_sum/compare/v0.0.3...v0.0.4)
+
+* Fixed major bug on #sort!
+* Some pretty_print support
 
 ### 0.0.3 / 2011-01-27
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sum_sum (0.0.2)
+    sum_sum (0.0.3)
 
 GEM
   remote: http://rubygems.org/

data/lib/sum_sum.rb

@@ -24,9 +24,9 @@ class SumSum < Hash
   end
   
   def sort!
-    values.each(&:sort!) unless bottom?
-    to_a.tap do |array|
-      array.reverse!(&:count)
+    return self if bottom?
+    values.each(&:sort!)
+    to_a.sort_by{|it| it[1].count}.reverse.tap do |array|
       clear
       array.each{|k, v| self[k] = v }
     end
@@ -45,6 +45,11 @@ class SumSum < Hash
     bottom? ? "#{count}" : "{#{name}:#{count} #{super.gsub(/^\{|\}$/, "")}}"
   end
   
+  def pretty_print(pp)
+    return pp.text(" #{count}") if bottom?
+    super
+  end
+  
   def dump
     return count if bottom?
     hash = {}

data/lib/sum_sum/version.rb

@@ -1,3 +1,3 @@
 class SumSum < Hash
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/sum_sum_spec.rb

@@ -15,168 +15,166 @@ describe SumSum do
     end
   end
   
-  context "#add" do
-    let(:sum) { SumSum.new(:type, :name, :version) }
+  let(:sum) { SumSum.new(:type, :name, :version) }
+  
+  context "adding single hash" do
+    before do
+      sum.add({:type => :Browser, :name => :Firefox, :version => "3.6.0"})
+    end
     
-    context "adding single hash" do
-      before do
-        sum.add({:type => :Browser, :name => :Firefox, :version => "3.6.0"})
+    context "#count" do
+      it "should return 1 on all levels" do
+        sum.count.should eql(1)
+        sum[:Browser].count.should eql(1)
+        sum[:Browser][:Firefox].count.should eql(1)
+        sum[:Browser][:Firefox]["3.6.0"].count.should eql(1)
       end
-      
-      context "#count" do
-        it "should return 1 on all levels" do
-          sum.count.should eql(1)
-          sum[:Browser].count.should eql(1)
-          sum[:Browser][:Firefox].count.should eql(1)
-          sum[:Browser][:Firefox]["3.6.0"].count.should eql(1)
-        end
+    end
+    
+    context "#keys" do
+      it "should return correct keys on all levels" do
+        sum.keys.should eql([:Browser])
+        sum[:Browser].keys.should eql([:Firefox])
+        sum[:Browser][:Firefox].keys.should eql(["3.6.0"])
+        sum[:Browser][:Firefox]["3.6.0"].keys.should eql([])
       end
-      
-      context "#keys" do
-        it "should return correct keys on all levels" do
-          sum.keys.should eql([:Browser])
-          sum[:Browser].keys.should eql([:Firefox])
-          sum[:Browser][:Firefox].keys.should eql(["3.6.0"])
-          sum[:Browser][:Firefox]["3.6.0"].keys.should eql([])
-        end
+    end
+    
+    context "#dump" do
+      it "should output serializable array" do
+        sum.dump.should eql(
+          [[:type, :name, :version], {:Browser=>{:Firefox=>{"3.6.0"=>1}}}]
+        )
+      end
+    end
+    
+    context ".load" do
+      it "should restore everything from serializable array" do
+        SumSum.load(sum.dump).dump.should eql(sum.dump)
+      end
+    end
+  end
+  
+  context "adding multiple hashes" do
+    before do
+      sum.add({:type => :Crawler, :name => :GoogleBot, :version => "2.0"})
+      sum.add({:type => :Browser, :name => :Firefox, :version => "3.6.0"})
+      sum.add({:type => :Browser, :name => :Safari, :version => "4.0"})
+      sum.add({:type => :Browser, :name => :Safari, :version => "5.0"})
+      sum.add({:type => :Browser, :name => :Safari, :version => "5.0"})
+    end
+    
+    context "#add" do
+      it "should return itself" do
+        sum.add({:type => :Crawler, :name => :GoogleBot, :version => "2.0"}).should eql(sum)
       end
       
-      context "#dump" do
-        it "should output serializable array" do
-          sum.dump.should eql(
-            [[:type, :name, :version], {:Browser=>{:Firefox=>{"3.6.0"=>1}}}]
-          )
-        end
+      it "should add missing values as nil" do
+        sum.add({:type => :Crawler, :name => nil})
+        sum.add({:type => :Crawler})
+        
+        sum[:Crawler].keys.should eql([:GoogleBot, nil])
+        sum[:Crawler][nil].count.should eql(2)
+        sum[:Crawler][nil].keys.should eql([nil])
+        sum[:Crawler][nil][nil].count.should eql(2)
       end
       
-      context ".load" do
-        it "should restore everything from serializable array" do
-          SumSum.load(sum.dump).dump.should eql(sum.dump)
-        end
+      it "should allow to add multiple counts at once" do
+        sum.add({:type => :Crawler, :name => :DuckDuckGo, :version => "1.0"}, 10)
+        
+        sum[:Crawler].count.should eql(11)
+        sum[:Crawler][:DuckDuckGo].count.should eql(10)
+        sum[:Crawler][:DuckDuckGo]["1.0"].count.should eql(10)
       end
     end
     
-    context "adding multiple hashes" do
-      before do
-        sum.add({:type => :Crawler, :name => :GoogleBot, :version => "2.0"})
-        sum.add({:type => :Browser, :name => :Firefox, :version => "3.6.0"})
-        sum.add({:type => :Browser, :name => :Safari, :version => "4.0"})
-        sum.add({:type => :Browser, :name => :Safari, :version => "5.0"})
-        sum.add({:type => :Browser, :name => :Safari, :version => "5.0"})
-      end
-      
-      context "#add" do
-        it "should return itself" do
-          sum.add({:type => :Crawler, :name => :GoogleBot, :version => "2.0"}).should eql(sum)
-        end
+    context "#count" do
+      it "should return correct count on all levels" do
+        sum.count.should eql(5)
         
-        it "should add missing values as nil" do
-          sum.add({:type => :Crawler, :name => nil})
-          sum.add({:type => :Crawler})
-          
-          sum[:Crawler].keys.should eql([:GoogleBot, nil])
-          sum[:Crawler][nil].count.should eql(2)
-          sum[:Crawler][nil].keys.should eql([nil])
-          sum[:Crawler][nil][nil].count.should eql(2)
-        end
+        sum[:Browser].count.should eql(4)
+        sum[:Browser][:Firefox].count.should eql(1)
+        sum[:Browser][:Firefox]["3.6.0"].count.should eql(1)
+        sum[:Browser][:Safari].count.should eql(3)
+        sum[:Browser][:Safari]["5.0"].count.should eql(2)
+        sum[:Browser][:Safari]["4.0"].count.should eql(1)
         
-        it "should allow to add multiple counts at once" do
-          sum.add({:type => :Crawler, :name => :DuckDuckGo, :version => "1.0"}, 10)
-          
-          sum[:Crawler].count.should eql(11)
-          sum[:Crawler][:DuckDuckGo].count.should eql(10)
-          sum[:Crawler][:DuckDuckGo]["1.0"].count.should eql(10)
-        end
+        sum[:Crawler].count.should eql(1)
+        sum[:Crawler][:GoogleBot].count.should eql(1)
+        sum[:Crawler][:GoogleBot]["2.0"].count.should eql(1)
       end
-      
-      context "#count" do
-        it "should return correct count on all levels" do
-          sum.count.should eql(5)
-          
-          sum[:Browser].count.should eql(4)
-          sum[:Browser][:Firefox].count.should eql(1)
-          sum[:Browser][:Firefox]["3.6.0"].count.should eql(1)
-          sum[:Browser][:Safari].count.should eql(3)
-          sum[:Browser][:Safari]["5.0"].count.should eql(2)
-          sum[:Browser][:Safari]["4.0"].count.should eql(1)
-          
-          sum[:Crawler].count.should eql(1)
-          sum[:Crawler][:GoogleBot].count.should eql(1)
-          sum[:Crawler][:GoogleBot]["2.0"].count.should eql(1)
-        end
+    end
+    
+    context "#keys" do
+      it "should return correct keys on all levels" do
+        sum.keys.should eql([:Crawler, :Browser])
+        sum[:Browser].keys.should eql([:Firefox, :Safari])
+        sum[:Browser][:Firefox].keys.should eql(["3.6.0"])
+        sum[:Browser][:Firefox]["3.6.0"].keys.should eql([])
+        sum[:Browser][:Safari].keys.should eql(["4.0", "5.0"])
+        sum[:Browser][:Safari]["4.0"].keys.should eql([])
+        sum[:Browser][:Safari]["5.0"].keys.should eql([])
+        sum[:Crawler].keys.should eql([:GoogleBot])
+        sum[:Crawler][:GoogleBot].keys.should eql(["2.0"])
+        sum[:Crawler][:GoogleBot]["2.0"].keys.should eql([])
       end
-      
-      context "#keys" do
-        it "should return correct keys on all levels" do
-          sum.keys.should eql([:Crawler, :Browser])
-          sum[:Browser].keys.should eql([:Firefox, :Safari])
-          sum[:Browser][:Firefox].keys.should eql(["3.6.0"])
-          sum[:Browser][:Firefox]["3.6.0"].keys.should eql([])
-          sum[:Browser][:Safari].keys.should eql(["4.0", "5.0"])
-          sum[:Browser][:Safari]["4.0"].keys.should eql([])
-          sum[:Browser][:Safari]["5.0"].keys.should eql([])
-          sum[:Crawler].keys.should eql([:GoogleBot])
-          sum[:Crawler][:GoogleBot].keys.should eql(["2.0"])
-          sum[:Crawler][:GoogleBot]["2.0"].keys.should eql([])
-        end
+    end
+    
+    context "#sort" do
+      before do
+        sum.add({:type => :Browser, :name => :Safari, :version => "5.0.3"}, 3)
+        sum.add({:type => :Browser, :name => :Chrome, :version => "5.0"}, 2)
+        sum.sort!
       end
       
-      context "#sort" do
-        before do
-          sum.sort!
-        end
-        
-        it "should sort by count" do
-          sum.keys.should eql([:Browser, :Crawler])
-          sum[:Browser].keys.should eql([:Safari, :Firefox])
-          sum[:Browser][:Safari].keys.should eql(["5.0", "4.0"])
-        end
+      it "should sort by count" do
+        sum.keys.should eql([:Browser, :Crawler])
+        sum[:Browser].keys.should eql([:Safari, :Chrome, :Firefox])
+        sum[:Browser][:Safari].keys.should eql(["5.0.3", "5.0", "4.0"])
+      end
+    end
+    
+    context "#share" do
+      it "should return 1.0 on root" do
+        sum.share.should eql(1.0)
       end
       
-      context "#share" do
-        it "should return 1.0 on root" do
-          sum.share.should eql(1.0)
-        end
-        
-        it "should return 1.0 on branch with single entry" do
-          sum[:Crawler][:GoogleBot].share.should eql(1.0)
-        end
-        
-        it "should return 0.2 on branch with one out of five" do
-          sum[:Crawler].share.should eql(0.2)
-        end
-        
-        it "should return 0.8 on branch with four out of five" do
-          sum[:Browser].share.should eql(0.8)
-        end
-        
-        it "should return 0.25 on branch with one out of four" do
-          sum[:Browser][:Firefox].share.should eql(0.25)
-        end
+      it "should return 1.0 on branch with single entry" do
+        sum[:Crawler][:GoogleBot].share.should eql(1.0)
       end
-    
-      context "#dump" do
-        it "should output serializable array" do
-          sum.dump.should eql(
-            [[:type, :name, :version], {
-              :Crawler=>{:GoogleBot=>{"2.0"=>1}}, 
-              :Browser=>{
-                :Firefox=>{"3.6.0"=>1}, 
-                :Safari=>{"4.0"=>1, "5.0"=>2}
-              }
-            }]
-          )
-        end
+      
+      it "should return 0.2 on branch with one out of five" do
+        sum[:Crawler].share.should eql(0.2)
       end
       
-      context ".load" do
-        it "should restore everything from serializable array" do
-          SumSum.load(sum.dump).dump.should eql(sum.dump)
-        end
+      it "should return 0.8 on branch with four out of five" do
+        sum[:Browser].share.should eql(0.8)
       end
       
+      it "should return 0.25 on branch with one out of four" do
+        sum[:Browser][:Firefox].share.should eql(0.25)
+      end
     end
   
+    context "#dump" do
+      it "should output serializable array" do
+        sum.dump.should eql(
+          [[:type, :name, :version], {
+            :Crawler=>{:GoogleBot=>{"2.0"=>1}}, 
+            :Browser=>{
+              :Firefox=>{"3.6.0"=>1}, 
+              :Safari=>{"4.0"=>1, "5.0"=>2}
+            }
+          }]
+        )
+      end
+    end
+    
+    context ".load" do
+      it "should restore everything from serializable array" do
+        SumSum.load(sum.dump).dump.should eql(sum.dump)
+      end
+    end
     
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Sebastian Munz