goldmine 0.9.2 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 657692c39740a0cf3b3c14851f886387616aa417
+  data.tar.gz: 8a611460c2a55d95d8e2d406dca9b1e72ab50682
+SHA512:
+  metadata.gz: c4821192a956bedf128bf1f9013712f12d11ff1b69e7b7decd14655998243bdc449775ae2ec0485f49f39cf7c1701134f46430c8b1e1ddc80e0f89848e6fff51
+  data.tar.gz: 987848b18ed99c765401567937b8ffcc80411248f1e07ccb1d649a8c5a2ccce41b0139168c4f9133a1553475dee1b69b2c434f01e2b7c7c2936dc4b8995afd50

data/Gemfile.lock

@@ -1,30 +1,34 @@
 PATH
   remote: .
   specs:
-    goldmine (0.9.2)
+    goldmine (1.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    ansi (1.4.3)
     coderay (1.0.9)
-    method_source (0.8.1)
-    minitest (4.7.2)
-    pry (0.9.12)
+    method_source (0.8.2)
+    micro_test (0.4.0)
+      os
+    multi_json (1.8.2)
+    os (0.9.6)
+    pry (0.9.12.2)
       coderay (~> 1.0.5)
       method_source (~> 0.8)
       slop (~> 3.4)
-    rake (10.0.4)
-    slop (3.4.4)
-    turn (0.9.6)
-      ansi
+    rake (10.1.0)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    slop (3.4.6)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   goldmine!
-  minitest
+  micro_test
   pry
   rake
-  turn
+  simplecov

data/README.md

@@ -4,113 +4,46 @@
 [![Dependency Status](https://gemnasium.com/hopsoft/goldmine.png)](https://gemnasium.com/hopsoft/goldmine)
 [![Code Climate](https://codeclimate.com/github/hopsoft/goldmine.png)](https://codeclimate.com/github/hopsoft/goldmine)
 
-## Pivot tables for the Rubyist
+### Extract a wealth of information from Arrays & Hashes
 
-![Goldmine GEM](http://hopsoft.github.com/goldmine/images/gold.jpg)
+Think of it as an enhanced `Enumerable#group_by`.
 
-### Pivot any list into a wealth of information
+## Uses
 
-Goldmine allows you to apply pivot table logic to any list for powerful data mining capabilities.
+- Data mining
+- Data transformation
+- CSV report generation
+- Prep for data visualization
+- Fact table creation
 
-### Reasons to love it
+The [demo project](http://hopsoft.github.io/goldmine/) demonstrates some of Goldmine's uses.
 
-* Provides ETL like functionality... but simple and elegant
-* Easily build OLAP cubes using Ruby
-* Supports method chaining for deep data mining
-* Handles values that are lists themselves
+## Quick Start
 
-[Why use it?](#putting-it-all-together)
-
-## Quick start
-
-Install
-
-```bash
-$gem install goldmine
 ```
-
-Use
-
-```ruby
-require "goldmine"
-[1,2,3,4,5,6,7,8,9].pivot { |i| i < 5 }
+gem install goldmine
+irb
 ```
 
-### Usage examples
-
-* [Pivot a list](#pivot-a-list-of-numbers-based-on-whether-or-not-they-are-less-than-5)
-* [Create a named pivot](#explicitly-name-a-pivot)
-* [Pivot values that are lists themselves](#pivot-values-that-are-lists-themselves)
-* [Chain pivots](#chain-pivots-together)
-* [Dig deep and extract meaningful data](#deep-cuts)
-
-## The Basics
-
-### Pivot a list of numbers based on whether or not they are less than 5
-
 ```ruby
-# operation
+require "goldmine"
 list = [1,2,3,4,5,6,7,8,9]
-data = list.pivot { |i| i < 5 }
-
-# resulting data
+list = Goldmine::ArrayMiner.new(list)
+list.pivot { |i| i < 5 }
+# result:
 {
   true  => [1, 2, 3, 4],
   false => [5, 6, 7, 8, 9]
 }
 ```
 
-### Explicitly name a pivot
-
-```ruby
-# operation
-list = [1,2,3,4,5,6,7,8,9]
-data = list.pivot("less than 5") { |i| i < 5 }
-
-# resulting data
-{
-  { "less than 5" => true }  => [1, 2, 3, 4],
-  { "less than 5" => false } => [5, 6, 7, 8, 9]
-}
-```
-
-## Next Steps
-
-### Pivot values that are lists themselves
-
-```ruby
-# operation
-list = [
-  { :name => "one",   :list => [1] },
-  { :name => "two",   :list => [1, 2] },
-  { :name => "three", :list => [1, 2, 3] },
-  { :name => "four",  :list => [1, 2, 3, 4] },
-]
-data = list.pivot { |record| record[:list] }
-
-# resulting data
-{
-  1 => [ { :name => "one",   :list => [1] },
-         { :name => "two",   :list => [1, 2] },
-         { :name => "three", :list => [1, 2, 3] },
-         { :name => "four",  :list => [1, 2, 3, 4] } ],
-  2 => [ { :name => "two",   :list => [1, 2] },
-         { :name => "three", :list => [1, 2, 3] },
-         { :name => "four",  :list => [1, 2, 3, 4] } ],
-  3 => [ { :name => "three", :list => [1, 2, 3] },
-         { :name => "four",  :list => [1, 2, 3, 4] } ],
-  4 => [ { :name => "four",  :list => [1, 2, 3, 4] } ]
-}
-```
-
-### Chain pivots together
+## Chained Pivots
 
 ```ruby
-# operation
 list = [1,2,3,4,5,6,7,8,9]
-data = list.pivot { |i| i < 5 }.pivot { |i| i % 2 == 0 }
-
-# resulting data
+list = Goldmine::ArrayMiner.new(list)
+list.pivot { |i| i < 5 }.pivot { |i| i % 2 == 0 }
+# result:
 {
   [true, false]  => [1, 3],
   [true, true]   => [2, 4],
@@ -119,261 +52,87 @@ data = list.pivot { |i| i < 5 }.pivot { |i| i % 2 == 0 }
 }
 ```
 
-## Deep Cuts
-
-### Build a moderately complex dataset of Cities
+## Named Pivots
 
 ```ruby
-cities = [
-  { :name => "San Francisco",
-    :state => "CA",
-    :population => 805235,
-    :airlines => [ "Delta", "United", "SouthWest" ]
-  },
-  {
-    :name => "Mountain View",
-    :state => "CA",
-    :population => 74066,
-    :airlines => [ "SkyWest", "United", "SouthWest" ]
-  },
-  {
-    :name => "Manhattan",
-    :state => "NY",
-    :population => 1586698,
-    :airlines => [ "Delta", "JetBlue", "United" ]
-  },
-  {
-    :name => "Brooklyn",
-    :state => "NY",
-    :population => 2504700,
-    :airlines => [ "Delta", "American", "US Airways" ]
-  },
-  {
-    :name => "Boston",
-    :state => "MA",
-    :population => 617594,
-    :airlines => [ "Delta", "JetBlue", "American" ]
-  },
-  {
-    :name => "Atlanta",
-    :state => "GA",
-    :population => 420003,
-    :airlines => [ "Delta", "United", "SouthWest" ]
-  },
-  {
-    :name => "Dallas",
-    :state => "TX",
-    :population => 1197816,
-    :airlines => [ "Delta", "SouthWest", "Frontier" ]
-  }
-]
+list = [1,2,3,4,5,6,7,8,9]
+list = Goldmine::ArrayMiner.new(list)
+list.pivot(:less_than_5) { |i| i < 5 }
+# result:
+{
+  { :less_than_5 => true }  => [1, 2, 3, 4],
+  { :less_than_5 => false } => [5, 6, 7, 8, 9]
+}
 ```
 
-### Pivot cities by state for population over 750k
+## Value Pivots
 
 ```ruby
-# operation
-data = cities
-  .pivot("state") { |city| city[:state] }
-  .pivot("population >= 750k") { |city| city[:population] >= 750000 }
-
-# resulting data
+list = [
+  { :name => "Sally",   :favorite_colors => [:blue] },
+  { :name => "John",    :favorite_colors => [:blue, :green] },
+  { :name => "Stephen", :favorite_colors => [:red, :pink, :purple] },
+  { :name => "Emily",   :favorite_colors => [:orange, :green] },
+  { :name => "Joe",     :favorite_colors => [:red] }
+]
+list = Goldmine::ArrayMiner.new(list)
+list.pivot { |record| record[:favorite_colors] }
+# result:
 {
-  { "state" => "CA", "population >= 750k" => true }  => [ { :name => "San Francisco", ... } ],
-  { "state" => "CA", "population >= 750k" => false } => [ { :name => "Mountain View", ... } ],
-  { "state" => "NY", "population >= 750k" => true }  => [ { :name => "Manhattan", ... }, { :name => "Brooklyn", ... } ],
-  { "state" => "MA", "population >= 750k" => false } => [ { :name => "Boston", ... } ],
-  { "state" => "GA", "population >= 750k" => false } => [ { :name => "Atlanta", ... } ],
-  { "state" => "TX", "population >= 750k" => true }  => [ { :name => "Dallas", ... } ]
+  :blue => [
+    { :name => "Sally", :favorite_colors => [:blue] },
+    { :name => "John",  :favorite_colors => [:blue, :green] }
+  ],
+  :green => [
+    { :name => "John",  :favorite_colors => [:blue, :green] },
+    { :name => "Emily", :favorite_colors => [:orange, :green] }
+  ],
+  :red => [
+    { :name => "Stephen", :favorite_colors => [:red, :pink, :purple] },
+    { :name => "Joe",     :favorite_colors => [:red] }
+  ],
+  :pink => [
+    { :name => "Stephen", :favorite_colors => [:red, :pink, :purple] }
+  ],
+  :purple => [
+    { :name => "Stephen", :favorite_colors => [:red, :pink, :purple] }
+  ],
+  :orange => [
+    { :name => "Emily", :favorite_colors => [:orange, :green] }
+  ]
 }
 ```
 
-### Putting it all together
-
-**The end goal of all this is to support the creation of aggregate reports.**
-
-*You can think of these reports as individual data cubes.*
-
-Here is a table view of the pivoted city data from above.
-
-<table class="table table-bordered table-striped">
-  <thead>
-    <tr>
-      <th>state</th>
-      <th>population >= 750k</th>
-      <th>cities</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>CA</td>
-      <td>true</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <td>CA</td>
-      <td>false</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <td>NY</td>
-      <td>true</td>
-      <td>2</td>
-    </tr>
-    <tr>
-      <td>MA</td>
-      <td>false</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <td>GA</td>
-      <td>false</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <td>TX</td>
-      <td>true</td>
-      <td>1</td>
-    </tr>
-  </tbody>
-</table>
-
-Lets try another one.
-
-### Determine which airlines service cities with fewer than 750k people
+# Stacked pivots
 
 ```ruby
-# operation
-data = cities
-  .pivot("airline") { |city| city[:airlines] }
-  .pivot("population < 750k") { |city| city[:population] < 750000 }
-
-# resulting data
+list = [
+  { :name => "Sally",   :age => 21 },
+  { :name => "John",    :age => 28 },
+  { :name => "Stephen", :age => 37 },
+  { :name => "Emily",   :age => 32 },
+  { :name => "Joe",     :age => 18 }
+]
+list = Goldmine::ArrayMiner.new(list)
+mined = list.pivot("Name has an 'e'") do |record|
+  !!record[:name].match(/e/i)
+end
+mined = mined.pivot(">= 21 years old") do |record|
+  record[:age] >= 21
+end
+# result:
 {
-  { "airline" => "Delta", "population < 750k" => false } => [
-    { :name => "San Francisco", ... },
-    { :name => "Manhattan", ... },
-    { :name => "Brooklyn", ... },
-    { :name => "Dallas", ... }],
-  { "airline" => "Delta", "population < 750k" => true } => [
-    { :name => "Boston", ... },
-    { :name => "Atlanta", ... }],
-  { "airline" => "United", "population < 750k" => false } => [
-    { :name => "San Francisco", ... },
-    { :name => "Manhattan", ... }],
-  { "airline" => "United", "population < 750k" => true } => [
-    { :name => "Mountain View", ... },
-    { :name => "Atlanta", ... }],
-  { "airline" => "SouthWest", "population < 750k" => false } => [
-    { :name => "San Francisco", ... },
-    { :name => "Dallas", ... }],
-  { "airline" => "SouthWest", "population < 750k" => true } => [
-    { :name => "Mountain View", ... },
-    { :name => "Atlanta", ... }],
-  { "airline" => "SkyWest", "population < 750k" => true } => [
-    { :name => "Mountain View", ... }],
-  { "airline" => "JetBlue", "population < 750k" => false } => [
-    { :name => "Manhattan", ... }],
-  { "airline" => "JetBlue", "population < 750k" => true } => [
-    { :name => "Boston", ... }],
-  { "airline" => "American", "population < 750k" => false } => [
-    { :name => "Brooklyn", ... }],
-  { "airline" => "American", "population < 750k" => true } => [
-    { :name => "Boston", ... }],
-  { "airline" => "US Airways", "population < 750k" => false } => [
-    { :name => "Brooklyn", ... }],
-  { "airline" => "Frontier", "population < 750k" => false } => [
-    { :name => "Dallas", ... }]
+  { "Name has an 'e'" => false, ">= 21 years old" => true } => [
+    { :name => "Sally", :age => 21 },
+    { :name => "John",  :age => 28 }
+  ],
+  { "Name has an 'e'" => true, ">= 21 years old" => true } => [
+    { :name => "Stephen", :age => 37 },
+    { :name => "Emily",   :age => 32 }
+  ],
+  { "Name has an 'e'" => true, ">= 21 years old" => false } => [
+    { :name => "Joe", :age => 18 }
+  ]
 }
 ```
 
-Here is the corresponding table view for the above dataset.
-
-<table class="table table-bordered table-striped">
-  <thead>
-    <tr>
-      <th>airline</th>
-      <th>population &lt; 750k</th>
-      <th>cities</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>Delta</td>
-      <td>false</td>
-      <td>4</td>
-    </tr>
-    <tr>
-      <td>Delta</td>
-      <td>true</td>
-      <td>2</td>
-    </tr>
-    <tr>
-      <td>United</td>
-      <td>false</td>
-      <td>2</td>
-    </tr>
-    <tr>
-      <td>United</td>
-      <td>true</td>
-      <td>2</td>
-    </tr>
-    <tr>
-      <td>SouthWest</td>
-      <td>false</td>
-      <td>2</td>
-    </tr>
-    <tr>
-      <td>SouthWest</td>
-      <td>true</td>
-      <td>2</td>
-    </tr>
-    <tr>
-      <td>SkyWest</td>
-      <td>true</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <td>JetBlue</td>
-      <td>false</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <td>JetBlue</td>
-      <td>true</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <td>American</td>
-      <td>false</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <td>American</td>
-      <td>true</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <td>US Airways</td>
-      <td>false</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <td>Frontier</td>
-      <td>false</td>
-      <td>1</td>
-    </tr>
-  </tbody>
-</table>
-
-Hopefully you can see the potential even though the above examples are somewhat contrived.
-
-## Special thanks
-
-* [One on One Marketing](http://www.1on1.com/) - for sponsoring the development of Goldmine
-* [Eric Berry](https://github.com/cavneb/) - for constructive feedback
-* [Spencer Roan](https://github.com/spencerroan) - for constructive feedback
-* [Brian Johnson](https://github.com/whap/) - for bringing some sanity to the recursion
-* [Josh Bowles](https://github.com/jbowles/) - for early adoption and feedback
-* [Brett Beers](https://github.com/beersbr/) - for early adoption and feedback
-

data/Rakefile

@@ -1,10 +1,7 @@
-require "rake"
-require "rake/testtask"
 require "bundler/gem_tasks"
 
 task :default => [:test]
 
-Rake::TestTask.new(:test) do |t|
-  t.test_files = Dir["test/test_*.rb"]
+task :test do
+  exec "bundle exec mt"
 end
-

data/lib/goldmine.rb

@@ -2,5 +2,10 @@ $:.unshift File.join(File.dirname(__FILE__), "goldmine")
 require "array_miner"
 require "hash_miner"
 
-::Array.send(:include, Goldmine::ArrayMiner)
-::Hash.send(:include, Goldmine::HashMiner)
+module Goldmine
+  def self.miner(object)
+    return ArrayMiner.new(object) if object.is_a?(Array)
+    return HashMiner.new(object) if object.is_a?(Hash)
+    nil
+  end
+end

data/lib/goldmine/array_miner.rb

@@ -1,7 +1,11 @@
+require "delegate"
+
 module Goldmine
+  class ArrayMiner < SimpleDelegator
 
-  # Extends Array with a pivot method.
-  module ArrayMiner
+    def initialize(array=[])
+      super array
+    end
 
     # Pivots the Array into a Hash of mined data.
     # Think of it as creating a pivot table or perhaps an OLAP cube.
@@ -42,7 +46,7 @@ module Goldmine
     # @yield [Object] Yields once for each item in the Array
     # @return [Hash] The pivoted Hash of data.
     def pivot(name=nil, &block)
-      reduce({}) do |memo, item|
+      reduce(HashMiner.new) do |memo, item|
         value = yield(item)
 
         if value.is_a?(Array)

data/lib/goldmine/hash_miner.rb

@@ -1,7 +1,12 @@
+require "delegate"
+require "hash_miner"
+
 module Goldmine
+  class HashMiner < SimpleDelegator
 
-  # Extends Hash with a pivot method.
-  module HashMiner
+    def initialize(hash={})
+      super hash
+    end
 
     attr_accessor :goldmine
 
@@ -28,9 +33,9 @@ module Goldmine
     def pivot(name=nil, &block)
       return self unless goldmine
 
-      reduce({}) do |memo, item|
+      reduce(HashMiner.new) do |memo, item|
         key = item.first
-        value = item.last
+        value = Goldmine.miner(item.last)
         value.pivot(name, &block).each do |k, v|
           if key.is_a? Hash
             k = { block.to_s => k } unless k.is_a?(Hash)

data/lib/goldmine/version.rb

@@ -1,3 +1,3 @@
 module Goldmine
-  VERSION = "0.9.2"
+  VERSION = "1.0.0"
 end

data/test/test_goldmine.rb

@@ -1,13 +1,26 @@
+require "micro_test"
 require "simplecov"
+SimpleCov.command_name "MicroTest"
 SimpleCov.start
-require "test/unit"
-require "turn"
-require File.join(File.dirname(__FILE__), "..", "lib", "goldmine")
+require File.expand_path("../../lib/goldmine", __FILE__)
 
-class TestGoldmine < MiniTest::Unit::TestCase
+class TestGoldmine < MicroTest::Test
 
-  def test_simple_pivot
+  test "miner from array" do
+    assert Goldmine.miner([]).is_a?(Goldmine::ArrayMiner)
+  end
+
+  test "miner from hash" do
+    assert Goldmine.miner({}).is_a?(Goldmine::HashMiner)
+  end
+
+  test "miner from usupported object" do
+    assert Goldmine.miner(Object.new).nil?
+  end
+
+  test "simple pivot" do
     list = [1,2,3,4,5,6,7,8,9]
+    list = Goldmine::ArrayMiner.new(list)
     data = list.pivot { |i| i < 5 }
 
     expected = {
@@ -15,11 +28,12 @@ class TestGoldmine < MiniTest::Unit::TestCase
       false => [5, 6, 7, 8, 9]
     }
 
-    assert_equal expected, data
+    assert data == expected
   end
 
-  def test_named_pivot
+  test "named pivot" do
     list = [1,2,3,4,5,6,7,8,9]
+    list = Goldmine::ArrayMiner.new(list)
     data = list.pivot("less than 5") { |i| i < 5 }
 
     expected = {
@@ -27,16 +41,17 @@ class TestGoldmine < MiniTest::Unit::TestCase
       { "less than 5" => false } => [5, 6, 7, 8, 9]
     }
 
-    assert_equal expected, data
+    assert data == expected
   end
 
-  def test_pivot_of_list_values
+  test "pivot of list values" do
     list = [
       { :name => "one",   :list => [1] },
       { :name => "two",   :list => [1, 2] },
       { :name => "three", :list => [1, 2, 3] },
       { :name => "four",  :list => [1, 2, 3, 4] },
     ]
+    list = Goldmine::ArrayMiner.new(list)
     data = list.pivot { |record| record[:list] }
 
     expected = {
@@ -52,11 +67,40 @@ class TestGoldmine < MiniTest::Unit::TestCase
       4 => [ { :name => "four",  :list => [1, 2, 3, 4] } ]
     }
 
-    assert_equal expected, data
+    assert data == expected
   end
 
-  def test_chained_pivots
+  test "pivot of list values with empty list" do
+    list = [
+      { :name => "empty", :list => [] },
+      { :name => "one",   :list => [1] },
+      { :name => "two",   :list => [1, 2] },
+      { :name => "three", :list => [1, 2, 3] },
+      { :name => "four",  :list => [1, 2, 3, 4] },
+    ]
+    list = Goldmine::ArrayMiner.new(list)
+    data = list.pivot { |record| record[:list] }
+
+    expected = {
+      nil => [ {:name => "empty", :list => [] } ],
+      1 => [ { :name => "one",   :list => [1] },
+             { :name => "two",   :list => [1, 2] },
+             { :name => "three", :list => [1, 2, 3] },
+             { :name => "four",  :list => [1, 2, 3, 4] } ],
+      2 => [ { :name => "two",   :list => [1, 2] },
+             { :name => "three", :list => [1, 2, 3] },
+             { :name => "four",  :list => [1, 2, 3, 4] } ],
+      3 => [ { :name => "three", :list => [1, 2, 3] },
+             { :name => "four",  :list => [1, 2, 3, 4] } ],
+      4 => [ { :name => "four",  :list => [1, 2, 3, 4] } ]
+    }
+
+    assert data == expected
+  end
+
+  test "chained pivots" do
     list = [1,2,3,4,5,6,7,8,9]
+    list = Goldmine::ArrayMiner.new(list)
     data = list.pivot { |i| i < 5 }.pivot { |i| i % 2 == 0 }
 
     expected = {
@@ -66,12 +110,12 @@ class TestGoldmine < MiniTest::Unit::TestCase
       [false, true]  => [6, 8]
     }
 
-    assert_equal expected, data
+    assert data == expected
   end
 
-  def test_deep_chained_pivots
+  test "deep chained pivots" do
     list = [1,2,3,4,5,6,7,8,9]
-    # list = [2,5,9]
+    list = Goldmine::ArrayMiner.new(list)
     data = list
       .pivot { |i| i < 3 }
       .pivot { |i| i < 6 }
@@ -91,11 +135,12 @@ class TestGoldmine < MiniTest::Unit::TestCase
       [false, false, false, false, true]  => [9]
     }
 
-    assert_equal expected, data
+    assert data == expected
   end
 
-  def test_named_deep_chained_pivots
+  test "named deep chained pivots" do
     list = [1,2,3,4,5,6,7,8,9]
+    list = Goldmine::ArrayMiner.new(list)
     data = list.pivot("a") { |i| i < 3 }.pivot("b") { |i| i < 6 }.pivot("c") { |i| i < 9 }.pivot("d") { |i| i % 2 == 0 }.pivot("e") { |i| i % 3 == 0 }
 
     expected = {
@@ -110,11 +155,12 @@ class TestGoldmine < MiniTest::Unit::TestCase
       {"a"=>false, "b"=>false, "c"=>false, "d"=>false, "e"=>true}  => [9]
     }
 
-    assert_equal expected, data
+    assert data == expected
   end
 
-  def test_named_chained_pivots
+  test "named chained pivots" do
     list = [1,2,3,4,5,6,7,8,9]
+    list = Goldmine::ArrayMiner.new(list)
     data = list.pivot("less than 5") { |i| i < 5 }.pivot("divisible by 2") { |i| i % 2 == 0 }
 
     expected = {
@@ -124,9 +170,7 @@ class TestGoldmine < MiniTest::Unit::TestCase
       { "less than 5" => false, "divisible by 2" => true}  => [6, 8]
     }
 
-    assert_equal expected, data
+    assert data == expected
   end
 
-
-
 end

metadata

@@ -1,97 +1,72 @@
 --- !ruby/object:Gem::Specification
 name: goldmine
 version: !ruby/object:Gem::Version
-  version: 0.9.2
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Nathan Hopkins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-19 00:00:00.000000000 Z
+date: 2013-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: micro_test
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: turn
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Pivot tables for the Rubyist.
+description: Extract a wealth of information from Arrays & Hashes
 email:
 - natehop@gmail.com
 executables: []
@@ -110,28 +85,27 @@ files:
 homepage: https://github.com/hopsoft/goldmine
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
-summary: Pivot tables for the Rubyist.
+specification_version: 4
+summary: Extract a wealth of information from Arrays & Hashes
 test_files:
 - test/test_goldmine.rb
 has_rdoc: