one-pivot 0.9.3 → 0.9.7

data/Gemfile

@@ -1,7 +1,7 @@
 source :rubygems
 
-gem 'shoulda',   '2.11.3'
-gem 'yard',      '0.6.4'
-gem 'bluecloth', '2.0.10'
-
+gem 'eventmachine', '0.12.10'
 
+group :test do
+  gem 'shoulda',      '2.11.3'
+end

data/Gemfile.lock

@@ -1,14 +1,12 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    bluecloth (2.0.10)
+    eventmachine (0.12.10)
     shoulda (2.11.3)
-    yard (0.6.4)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bluecloth (= 2.0.10)
+  eventmachine (= 0.12.10)
   shoulda (= 2.11.3)
-  yard (= 0.6.4)

data/README.md

@@ -15,130 +15,113 @@ Lets have a look at some examples.
 _Note: there are a few advanced features not demonstrated in the examples below. For example, adding identifiers to pivots or attaching observers to pivot operations. We use these features at 1on1 to cache pivot results for each item. This gives us a big performance boost when the same item participates in multiple pivots during its lifetime... especially when the pivot Proc is an expensive operation.  Have a look at the [tests](https://github.com/one-on-one/pivot/tree/master/test) when you want to dig a little deeper._
 
 ##Installation
-<pre>
-<code>
-gem install one-pivot
-</code>
-</pre>
+    gem install one-pivot
 
 ##A simple single pivot
-<pre>
-<code>
-require 'one-pivot'
+    require 'one-pivot'
 
-# create the pivot instance
-pivoter = One::Pivoter.new
+    # create the pivot instance
+    pivoter = One::Pivoter.new
 
-# create a list of objects to pivot
-list = [1,2,3,4,5,6,7,8,9]
+    # create a list of objects to pivot
+    list = [1,2,3,4,5,6,7,8,9]
 
-# run a single pivot
-# note: the block passed to the pivot method is invoked for each item in the list
-# note: the result from the block will act as the 'key' in the resulting Hash
-result = pivoter.pivot(list) {|item| item <= 5}
-
-# 'result' will be a Hash with the following structure
-{
-  true => [1,2,3,4,5],
-  false => [6,7,8,9]
-}
-</code>
-</pre>
+    # run a single pivot
+    # note: the block passed to the pivot method is invoked for each item in the list
+    # note: the result from the block will act as the 'key' in the resulting Hash
+    result = pivoter.pivot(list) {|item| item <= 5}
 
+    # 'result' will be a Hash with the following structure
+    {
+      true => [1,2,3,4,5],
+      false => [6,7,8,9]
+    }
 
 ##A simple multi-pivot
-<pre>
-<code>
-require 'one-pivot'
+    require 'one-pivot'
 
-# create the pivot instance
-# note: the multi-pivot delimiter that was specified
-pivoter = One::Pivoter.new
+    # create the pivot instance
+    # note: the multi-pivot delimiter that was specified
+    pivoter = One::Pivoter.new
 
-# create a list of objects to pivot
-list = [1,2,3,4,5,6,7,8,9]
+    # create a list of objects to pivot
+    list = [1,2,3,4,5,6,7,8,9]
 
-# run several pivots together
-pivots = []
+    # run several pivots together
+    pivots = []
 
-pivots << lambda do |i|
-  key = "less than or equal to 5" if i <= 5
-  key ||= "greater than 5"
-end
+    pivots << lambda do |i|
+      key = "less than or equal to 5" if i <= 5
+      key ||= "greater than 5"
+    end
 
-pivots << lambda do |i|
-  key = "greater than or equal to 3" if i >= 3
-  key ||= "less than 3"
-end
+    pivots << lambda do |i|
+      key = "greater than or equal to 3" if i >= 3
+      key ||= "less than 3"
+    end
 
-pivots << {:delimiter => " & "}
+    pivots << {:delimiter => " & "}
 
-result = pivoter.multi_pivot(list, *pivots)
+    result = pivoter.multi_pivot(list, *pivots)
 
-# 'result' will be a Hash with the following structure
-{
-  "less than or equal to 5 & greater than or equal to 3" => [3, 4, 5], 
-  "less than or equal to 5 & less than 3" => [1, 2], 
-  "greater than 5 & greater than or equal to 3" => [6, 7, 8, 9]
-}
-</code>
-</pre>
+    # 'result' will be a Hash with the following structure
+    {
+      "less than or equal to 5 & greater than or equal to 3" => [3, 4, 5],
+      "less than or equal to 5 & less than 3" => [1, 2],
+      "greater than 5 & greater than or equal to 3" => [6, 7, 8, 9]
+    }
 
 ##A real world example
-<pre>
-<code>
-# we'll be working with ActiveRecord objects based on the following schema
-# ============================================================================
-# create_table "users", :force => true do |t|
-#   t.string   "name"
-#   t.datetime "created_at"
-#   t.datetime "updated_at"
-# end
-#
-# create_table "skills", :force => true do |t|
-#   t.string   "name"
-#   t.datetime "created_at"
-#   t.datetime "updated_at"
-# end
-#
-# create_table "skills_users", :id => false, :force => true do |t|
-#   t.integer "user_id"
-#   t.integer "skill_id"
-# end
-# 
-# and will seed the datbase with the following data
-# ============================================================================
-# ruby = Skill.create(:name => "Ruby")
-# python = Skill.create(:name => "Python")
-# php = Skill.create(:name => "PHP")
-# javascript = Skill.create(:name => "JavaScript")
-# 
-# users = User.create([
-#   {:name => "Ryan", :skills => [ruby]},
-#   {:name => "Dave", :skills => [php, javascript]},
-#   {:name => "Brett", :skills => [ruby, javascript]},
-#   {:name => "Jay", :skills => [ruby, python, php, javascript]},
-#   {:name => "Doug"}
-# ])
-#
-
-require 'one-pivot'
-
-pivoter = One::Pivoter.new
-# note that the pivot block returns an array
-# each unique value in the arrays returned will become a key in the resulting Hash
-result = pivoter.pivot(User.all) do |user|
-  user.skills
-end
-
-# 'result' will be Hash with the following structure
-# note: I've simplified the object structure (using names only) for clarity 
-{
-  "Ruby" => ["Brett", "Jay", "Ryan"],
-  "PHP" => ["Dave", "Jay"],
-  "JavaScript" => ["Brett", "Dave", "Jay"],
-  "Python" => ["Jay"],
-  nil => ["Doug"]
-} 
-</code>
-</pre>
+    # we'll be working with ActiveRecord objects based on the following schema
+    # ============================================================================
+    # create_table "users", :force => true do |t|
+    #   t.string   "name"
+    #   t.datetime "created_at"
+    #   t.datetime "updated_at"
+    # end
+    #
+    # create_table "skills", :force => true do |t|
+    #   t.string   "name"
+    #   t.datetime "created_at"
+    #   t.datetime "updated_at"
+    # end
+    #
+    # create_table "skills_users", :id => false, :force => true do |t|
+    #   t.integer "user_id"
+    #   t.integer "skill_id"
+    # end
+    #
+    # and will seed the datbase with the following data
+    # ============================================================================
+    # ruby = Skill.create(:name => "Ruby")
+    # python = Skill.create(:name => "Python")
+    # php = Skill.create(:name => "PHP")
+    # javascript = Skill.create(:name => "JavaScript")
+    #
+    # users = User.create([
+    #   {:name => "Ryan", :skills => [ruby]},
+    #   {:name => "Dave", :skills => [php, javascript]},
+    #   {:name => "Brett", :skills => [ruby, javascript]},
+    #   {:name => "Jay", :skills => [ruby, python, php, javascript]},
+    #   {:name => "Doug"}
+    # ])
+    #
+
+    require 'one-pivot'
+
+    pivoter = One::Pivoter.new
+    # note that the pivot block returns an array
+    # each unique value in the arrays returned will become a key in the resulting Hash
+    result = pivoter.pivot(User.all) do |user|
+      user.skills
+    end
+
+    # 'result' will be Hash with the following structure
+    # note: I've simplified the object structure (using names only) for clarity
+    {
+      "Ruby" => ["Brett", "Jay", "Ryan"],
+      "PHP" => ["Dave", "Jay"],
+      "JavaScript" => ["Brett", "Dave", "Jay"],
+      "Python" => ["Jay"],
+      nil => ["Doug"]
+    }

data/lib/one-pivot.rb

@@ -1,2 +1,3 @@
+require 'rubygems'
 require File.expand_path(File.join(File.dirname(__FILE__), 'one', 'pivot'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'one', 'pivoter'))

data/lib/one/pivoter.rb

@@ -1,4 +1,8 @@
+require 'rubygems'
 require 'observer'
+require 'eventmachine'
+require 'thread'
+
 
 # Namespace module for One on One Marketing.
 module One
@@ -16,44 +20,77 @@ module One
     #   # the result will be a Hash with the following structure
     #   {
     #     true=>[1, 2, 3, 4, 5],
-    #     false=>[6, 7, 8, 9] 
+    #     false=>[6, 7, 8, 9]
     #   }
     #
     # @param [Array<Object>] list The list to pivot
     # @param [optional, Hash] options Options to pivot with
-    # @option options [Object] :identifier A name that uniquely identifies the pivot operation 
-    # @yield [item] The block passed to pivot will be called for each item in the list 
+    # @option options [Object] :identifier A name that uniquely identifies the pivot operation
+    # @yield [item] The block passed to pivot will be called for each item in the list
     # @yieldparam [Object] item An item in the list
     # @yieldreturn [Object] The value returned from the pivot block will serve as the key in the pivot results
     # @return [Hash] The pivoted results
     def pivot(list, options={}, &block)
       pivoted = {}
-      list.each do |item|
-        value = yield(item)
-
-        # notify observers that a pivot block was just called
-        identifier = options[:identifier] || "#{item.hash}:#{block.hash}"
-        changed
-        notify_observers(identifier, item, value) 
-
-        if value.is_a?(Array)
-          if value.empty?
-            pivoted[nil] ||= []
-            pivoted[nil] << item 
-          else
-            value.each do |val|
-              pivoted[val] ||= []
-              pivoted[val] << item 
+      semaphore = Mutex.new
+
+      lists = list.each_slice(chunk_size(list)).to_a
+      loops = 0
+
+      reactor_running = EM.reactor_running?
+
+      work = Proc.new do
+        lists.each do |sub_list|
+
+          pivot_operation = Proc.new do
+            sub_list.each do |item|
+              # potential long running operation with blocking IO
+              value = yield(item)
+
+              # notify observers that a pivot block was just called
+              identifier = options[:identifier] || "#{item.hash}:#{block.hash}"
+              changed
+              # potential long running operation with blocking IO
+              notify_observers(identifier, item, value)
+
+              semaphore.synchronize {
+                if value.is_a?(Array)
+                  if value.empty?
+                      pivoted[nil] ||= []
+                      pivoted[nil] << item
+                  else
+                    value.each do |val|
+                      pivoted[val] ||= []
+                      pivoted[val] << item
+                    end
+                  end
+                else
+                  pivoted[value] ||= []
+                  pivoted[value] << item
+                end
+              }
             end
           end
-        else
-          pivoted[value] ||= []
-          pivoted[value] << item 
+
+          pivot_callback = Proc.new do
+            semaphore.synchronize {
+              loops += 1
+              EM.stop if loops == lists.length && !reactor_running
+            }
+          end
+
+          EM.defer(pivot_operation, pivot_callback)
         end
       end
 
+      if reactor_running
+        work.call
+      else
+        EM.run &work
+      end
+
       pivoted
-    end    
+    end
 
     # Runs multiple pivots against a list of Objects.
     #
@@ -70,17 +107,17 @@ module One
     #     key = "greater than or equal to 3" if i >= 3
     #     key ||= "less than 3"
     #   end
-    # 
+    #
     #   # note the last pivot is an options Hash
     #   pivots << {:delimiter => " & "}
-    #    
+    #
     #   pivoter = One::Pivot.new
-    #   result = pivoter.multi_pivot(list, *pivots) 
-    #   
+    #   result = pivoter.multi_pivot(list, *pivots)
+    #
     #   # the result will be a Hash with the following structure
     #   {
-    #     "less than or equal to 5 & greater than or equal to 3" => [3, 4, 5], 
-    #     "less than or equal to 5 & less than 3" => [1, 2], 
+    #     "less than or equal to 5 & greater than or equal to 3" => [3, 4, 5],
+    #     "less than or equal to 5 & less than 3" => [1, 2],
     #     "greater than 5 & greater than or equal to 3" => [6, 7, 8, 9]
     #   }
     #
@@ -99,7 +136,7 @@ module One
 
       while pivots.length > 0
         p = pivots.shift
-        
+
         # handle the case where the pivots are One::Pivot objects
         pivot_options = {}
         if p.is_a?(One::Pivot)
@@ -134,6 +171,17 @@ module One
       key.to_s
     end
 
+    def chunk_size(list)
+      len = list.length
+      case len
+      when 0..100 then len
+      when 100..1000 then len / 2
+      when 1000..10000 then len / 4
+      when 10000..100000 then len / 8
+      else len / 16
+      end
+    end
+
   end
 end
 

data/test/pivoter_test.rb

@@ -1,6 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'one', 'pivot'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'one', 'pivoter'))
+require 'eventmachine'
 
 class PivotTest < Test::Unit::TestCase
 
@@ -13,33 +14,44 @@ class PivotTest < Test::Unit::TestCase
       list = [1,2,3,4,5,6,7,8,9]
       result = @pivoter.pivot(list) {|item| item <= 5}
       assert_equal [6,7,8,9], result[false]
-      assert_equal [1,2,3,4,5], result[true] 
+      assert_equal [1,2,3,4,5], result[true]
     end
 
-    should "multi pivot a simple array properly" do 
+    should "pivot inside of an existing EventMachine reactor" do
+      EM.run do
+        list = [1,2,3,4,5,6,7,8,9]
+        result = @pivoter.pivot(list) {|item| item <= 5}
+        sleep(0.01) # allow enough time for the pivot to complete
+        assert_equal [6,7,8,9], result[false]
+        assert_equal [1,2,3,4,5], result[true]
+        EM.stop
+      end
+    end
+
+    should "multi pivot a simple array properly" do
       list = [1,2,3,4,5,6,7,8,9]
       pivots = []
-    
+
       pivots << lambda do |i|
         key = "less than or equal to 5" if i <= 5
         key ||= "greater than 5"
       end
-    
+
       pivots << lambda do |i|
         key = "greater than or equal to 3" if i >= 3
         key ||= "less than 3"
       end
-        
+
       pivots << {:delimiter => " & "}
 
       result = @pivoter.multi_pivot(list, *pivots)
-       
+
       # the result will be a Hash with the following structure:
       hash = {
-        "less than or equal to 5 & greater than or equal to 3" => [3, 4, 5], 
-        "less than or equal to 5 & less than 3" => [1, 2], 
+        "less than or equal to 5 & greater than or equal to 3" => [3, 4, 5],
+        "less than or equal to 5 & less than 3" => [1, 2],
         "greater than 5 & greater than or equal to 3" => [6, 7, 8, 9]
-      } 
+      }
 
       assert_equal hash, result
     end
@@ -47,38 +59,38 @@ class PivotTest < Test::Unit::TestCase
     should "support both procs and One::Pivot objects with multi_pivot" do
       list = [1,2,3,4,5,6,7,8,9]
       pivots = []
-    
+
       pivots << One::Pivot.new("comparison to 5") do |i|
         key = "less than or equal to 5" if i <= 5
         key ||= "greater than 5"
       end
-    
+
       pivots << One::Pivot.new("comparison to 3") do |i|
         key = "greater than or equal to 3" if i >= 3
         key ||= "less than 3"
       end
-        
+
       pivots << {:delimiter => " & "}
 
       result = @pivoter.multi_pivot(list, *pivots)
-       
+
       # the result will be a Hash with the following structure:
       hash = {
-        "less than or equal to 5 & greater than or equal to 3" => [3, 4, 5], 
-        "less than or equal to 5 & less than 3" => [1, 2], 
+        "less than or equal to 5 & greater than or equal to 3" => [3, 4, 5],
+        "less than or equal to 5 & less than 3" => [1, 2],
         "greater than 5 & greater than or equal to 3" => [6, 7, 8, 9]
-      } 
+      }
 
       assert_equal hash, result
     end
 
     should "support pivot observers (for example: to perform caching)" do
       # Pivot operations can be expensive.
-      # 
+      #
       # Demonstrate how you can use the observer pattern to cache
       # pivot results per item to save time on subsequent pivots for the same item.
-      # 
-      # This strategy can be helpful if each item remains in memory for a period of time 
+      #
+      # This strategy can be helpful if each item remains in memory for a period of time
       # that spans its participation in several pivot calls
 
       # extend Fixnum so we can cache pivot results
@@ -99,11 +111,11 @@ class PivotTest < Test::Unit::TestCase
         # this method gets invoked by the pivot object whenever a pivot block is executed
         def update(identifier, item, value)
           item.pivot_cache[identifier] = value
-        end 
-      end 
+        end
+      end
 
       observer = PivotObserver.new(@pivoter)
-  
+
       list = [1,2,3,4,5,6,7,8,9]
       result = @pivoter.pivot(list, :identifier => :less_than_5) do |item|
         if item.pivot_cache.has_key?(:less_than_5)
@@ -116,8 +128,8 @@ class PivotTest < Test::Unit::TestCase
       list.each do |item|
         assert item.pivot_cache.has_key?(:less_than_5)
       end
-     
-      # pivot again but this time use the pivot cache stored on each item 
+
+      # pivot again but this time use the pivot cache stored on each item
       cached_result = @pivoter.pivot(list, :identifier => :less_than_5) do |item|
         if item.pivot_cache.has_key?(:less_than_5)
           item.pivot_cache[:less_than_5]
@@ -131,11 +143,11 @@ class PivotTest < Test::Unit::TestCase
 
     should "support pivot observers when using multi_pivot (for example: to perform caching)" do
       # Pivot operations can be expensive.
-      # 
+      #
       # Demonstrate how you can use the observer pattern to cache
       # pivot results per item to save time on subsequent pivots for the same item.
-      # 
-      # This strategy can be helpful if each item remains in memory for a period of time 
+      #
+      # This strategy can be helpful if each item remains in memory for a period of time
       # that spans its participation in several pivot calls
 
       # extend Fixnum so we can cache pivot results
@@ -156,44 +168,44 @@ class PivotTest < Test::Unit::TestCase
         # this method gets invoked by the pivot object whenever a pivot block is executed
         def update(identifier, item, value)
           item.pivot_cache[identifier] = value
-        end 
-      end 
+        end
+      end
 
       observer = PivotObserver.new(@pivoter)
-  
+
       list = [1,2,3,4,5,6,7,8,9]
 
       pivots = []
-    
+
       pivots << One::Pivot.new("comparison to 5") do |i|
         key = "less than or equal to 5" if i <= 5
         key ||= "greater than 5"
       end
-    
+
       pivots << One::Pivot.new("comparison to 3") do |i|
         key = "greater than or equal to 3" if i >= 3
         key ||= "less than 3"
       end
 
-      result = @pivoter.multi_pivot(list, *pivots) 
+      result = @pivoter.multi_pivot(list, *pivots)
 
       list.each do |item|
         assert item.pivot_cache.has_key?("comparison to 5")
         assert item.pivot_cache.has_key?("comparison to 3")
       end
-     
-      # pivot again but this time use the pivot cache stored on each item 
+
+      # pivot again but this time use the pivot cache stored on each item
       pivots = []
-    
+
       pivots << One::Pivot.new("comparison to 5") do |i|
         i.pivot_cache["comparison to 5"]
       end
-    
+
       pivots << One::Pivot.new("comparison to 3") do |i|
         i.pivot_cache["comparison to 3"]
       end
 
-      cached_result = @pivoter.multi_pivot(list, *pivots) 
+      cached_result = @pivoter.multi_pivot(list, *pivots)
       assert_equal result, cached_result
     end
 
@@ -210,16 +222,16 @@ class PivotTest < Test::Unit::TestCase
 
         # Frank gets Read
         users[0][:roles] << "Read"
-       
+
         # Joe gets Write
-        users[1][:roles] << "Write" 
+        users[1][:roles] << "Write"
 
         # John gets Read & Write
-        users[2][:roles] << "Read" 
+        users[2][:roles] << "Read"
         users[2][:roles] << "Write"
 
         # Sally gets no roles
-       
+
         @users = users
       end
 
@@ -229,15 +241,15 @@ class PivotTest < Test::Unit::TestCase
         # this is what the resulting hash should look like:
         hash = {
           nil => [
-            {:name=>"Sally", :gender => "F", :roles=>[]}], 
+            {:name=>"Sally", :gender => "F", :roles=>[]}],
           "Read" => [
-            {:name=>"Frank", :gender => "M", :roles=>["Read"]}, 
-            {:name=>"John", :gender => "M", :roles=>["Read", "Write"]}], 
+            {:name=>"Frank", :gender => "M", :roles=>["Read"]},
+            {:name=>"John", :gender => "M", :roles=>["Read", "Write"]}],
           "Write" => [
-            {:name=>"Joe", :gender => "M", :roles=>["Write"]}, 
+            {:name=>"Joe", :gender => "M", :roles=>["Write"]},
             {:name=>"John", :gender => "M", :roles=>["Read", "Write"]}]
         }
-        
+
         assert_equal hash, result
       end
 
@@ -245,21 +257,21 @@ class PivotTest < Test::Unit::TestCase
         pivots = []
         pivots << lambda {|user| user[:gender]}
         pivots << lambda {|user| user[:roles]}
-        
+
         result = @pivoter.multi_pivot(@users, *pivots)
 
         # this is what the resulting hash should look like
         hash = {
           "M[PIVOT]Write" => [
-            {:name=>"Joe", :gender=>"M", :roles=>["Write"]}, 
-            {:name=>"John", :gender=>"M", :roles=>["Read", "Write"]}], 
+            {:name=>"Joe", :gender=>"M", :roles=>["Write"]},
+            {:name=>"John", :gender=>"M", :roles=>["Read", "Write"]}],
           "M[PIVOT]Read" => [
-            {:name=>"Frank", :gender=>"M", :roles=>["Read"]}, 
-            {:name=>"John", :gender=>"M", :roles=>["Read", "Write"]}], 
+            {:name=>"Frank", :gender=>"M", :roles=>["Read"]},
+            {:name=>"John", :gender=>"M", :roles=>["Read", "Write"]}],
           "F[PIVOT]nil" => [
             {:name=>"Sally", :gender=>"F", :roles=>[]}]
         }
-              
+
         assert_equal hash, result
       end
 

metadata

@@ -1,40 +1,47 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: one-pivot
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.9.7
   prerelease: 
-  version: 0.9.3
 platform: ruby
-authors: 
+authors:
 - Nathan Hopkins
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-02-23 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: shoulda
+date: 2011-11-08 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &2161266960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: *2161266960
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &2161266360 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
         version: 2.11.3
   type: :development
-  version_requirements: *id001
-description: "    Pivot provides basic pivoting functionality for sorting an Array of objects.\n"
-email: 
+  prerelease: false
+  version_requirements: *2161266360
+description: ! "    A simple and intuitive way to perform powerful data mining on
+  lists of objects.\n    Think of it as MapReduce for mortals.\n"
+email:
 - natehop@gmail.com
 - natehop@1on1.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/one/pivot.rb
 - lib/one/pivoter.rb
 - lib/one-pivot.rb
@@ -45,33 +52,29 @@ files:
 - test/pivot_test.rb
 - test/pivoter_test.rb
 - test/test_helper.rb
-has_rdoc: true
 homepage: https://github.com/one-on-one/pivot
-licenses: 
+licenses:
 - MIT
 post_install_message: 
 rdoc_options: []
-
-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 
-      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 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Pivot provides basic pivoting functionality for sorting an Array of objects.
+summary: Enumerable#group_by on steroids with an extra dash of awesome.
 test_files: []
-