goldmine 0.0.4 → 0.9.0

data/Gemfile

@@ -1,5 +1,5 @@
 source :rubygems
 
-group :development do
-  gem "pry"
-end
+gem "minitest", :group => :test
+gem "turn", :group => :test
+gem "pry", :group => [:development, :test]

data/Gemfile.lock

@@ -1,16 +1,22 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    ansi (1.4.2)
     coderay (1.0.6)
     method_source (0.7.1)
+    minitest (3.1.0)
     pry (0.9.9.6)
       coderay (~> 1.0.5)
       method_source (~> 0.7.1)
       slop (>= 2.4.4, < 3)
     slop (2.4.4)
+    turn (0.9.5)
+      ansi
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  minitest
   pry
+  turn

data/Rakefile

@@ -1,9 +1,11 @@
 require 'rake'
 require 'rake/testtask'
-require 'rake/rdoctask'
+require 'rdoc/task'
+require 'bundler'
+Bundler.require :development, :test
 
 Rake::TestTask.new(:test) do |t|
-  t.test_files = FileList['test/*_test.rb']
+  t.test_files = FileList['test/test_*.rb']
 end
 
 task 'test:units' => ['test'] do

data/lib/goldmine.rb

@@ -1,7 +1,49 @@
 require "rubygems"
 
+# Goldmine brings pivot table behavior to Arrays.
 module Goldmine
+
+  # Extends Array with a pivot method.
   module ArrayMiner
+
+    # Pivots the Array into a Hash of mined data.
+    # Think of it as creating a pivot table or perhaps an OLAP cube.
+    #
+    # @example Simple pivot
+    #   list = [1,2,3,4,5,6,7,8,9]
+    #   data = list.pivot { |i| i < 5 }
+    #
+    #   # resulting data
+    #   # {
+    #   #   true  => [1, 2, 3, 4],
+    #   #   false => [5, 6, 7, 8, 9]
+    #   # }
+    #
+    # @example Named pivot
+    #   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]
+    #   # }
+    #
+    # @example Chained pivot
+    #   list = [1,2,3,4,5,6,7,8,9]
+    #   data = list.pivot { |i| i < 5 }.pivot { |i| i % 2 == 0 }
+    #
+    #   # resulting data
+    #   {
+    #     [true, false]  => [1, 3],
+    #     [true, true]   => [2, 4],
+    #     [false, false] => [5, 7, 9],
+    #     [false, true]  => [6, 8]
+    #   }
+    #
+    # @param [String] name The named of the pivot.
+    # @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|
         value = yield(item)
@@ -22,8 +64,31 @@ module Goldmine
     end
   end
 
+  # Extends Hash with a pivot method.
   module HashMiner
+
     attr_accessor :goldmine
+
+    # Further pivots the Hash into mined data.
+    # This method is what enables the pivot method chaining.
+    #
+    # @example Chained pivot
+    #   list = [1,2,3,4,5,6,7,8,9]
+    #   data = list.pivot { |i| i < 5 }.pivot { |i| i % 2 == 0 }
+    #
+    #   # resulting data
+    #   {
+    #     [true, false]  => [1, 3],
+    #     [true, true]   => [2, 4],
+    #     [false, false] => [5, 7, 9],
+    #     [false, true]  => [6, 8]
+    #   }
+    #
+    # @note This method should not be called directly. Call Array#pivot instead.
+    #
+    # @param [String] name The named of the pivot.
+    # @yield [Object] Yields once for each item in the Array
+    # @return [Hash] The pivoted Hash of data.
     def pivot(name=nil, &block)
       return self unless goldmine
       reduce({}) do |memo, item|
@@ -34,7 +99,8 @@ module Goldmine
             k = { block.to_s => k } unless k.is_a?(Hash)
             new_key = key.merge(k)
           else
-            new_key = [key, k]
+            new_key = key.push(k) if key.is_a?(Array)
+            new_key ||= [key, k]
           end
           memo[new_key] = v
         end
@@ -43,16 +109,26 @@ module Goldmine
       end
     end
 
+    # Assigns a key/value pair to the Hash.
+    # @param [String] name The name of a pivot (can be null).
+    # @param [Object] key The key to use.
+    # @param [Object] value The value to assign
+    # @return [Object] The result of the assignment.
     def assign_mined(name, key, value)
-      mine_key = goldmine_key(name, key)
-      self[mine_key] ||= []
-      self[goldmine_key(name, key)] << value
+      goldmine_key = goldmine_key(name, key)
+      self[goldmine_key] ||= []
+      self[goldmine_key] << value
     end
 
+    # Creates a key for a pivot-name/key combo.
+    # @param [String] name The name of a pivot (can be null).
+    # @param [Object] key The key to use.
+    # @return [Object] The constructed key.
     def goldmine_key(name, key)
-      mine_key = { name => key } if name
-      mine_key ||= key
+      goldmine_key = { name => key } if name
+      goldmine_key ||= key
     end
+
   end
 end
 

data/test/test_goldmine.rb

@@ -0,0 +1,105 @@
+require "test/unit"
+require "turn"
+require File.join(File.dirname(__FILE__), "..", "lib", "goldmine")
+
+class TestGoldmine < MiniTest::Unit::TestCase
+
+  def test_simple_pivot
+    list = [1,2,3,4,5,6,7,8,9]
+    data = list.pivot { |i| i < 5 }
+
+    expected = {
+      true  => [1, 2, 3, 4],
+      false => [5, 6, 7, 8, 9]
+    }
+
+    assert_equal expected, data
+  end
+
+  def test_named_pivot
+    list = [1,2,3,4,5,6,7,8,9]
+    data = list.pivot("less than 5") { |i| i < 5 }
+
+    expected = {
+      { "less than 5" => true }  => [1, 2, 3, 4],
+      { "less than 5" => false } => [5, 6, 7, 8, 9]
+    }
+
+    assert_equal expected, data
+  end
+
+  def test_pivot_of_list_values
+    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] }
+
+    expected = {
+      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_equal expected, data
+  end
+
+  def test_chained_pivots
+    list = [1,2,3,4,5,6,7,8,9]
+    data = list.pivot { |i| i < 5 }.pivot { |i| i % 2 == 0 }
+
+    expected = {
+      [true, false]  => [1, 3],
+      [true, true]   => [2, 4],
+      [false, false] => [5, 7, 9],
+      [false, true]  => [6, 8]
+    }
+
+    assert_equal expected, data
+  end
+
+  def test_deep_chained_pivots
+    list = [1,2,3,4,5,6,7,8,9]
+    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 }
+
+    expected1 = {
+      {"a"=>true, "b"=>true, "c"=>true, "d"=>false, "e"=>false}=>[1],
+      {"a"=>true, "b"=>true, "c"=>true, "d"=>true, "e"=>false}=>[2],
+      {"a"=>false, "b"=>true, "c"=>true, "d"=>false, "e"=>true}=>[3],
+      {"a"=>false, "b"=>true, "c"=>true, "d"=>false, "e"=>false}=>[5],
+      {"a"=>false, "b"=>true, "c"=>true, "d"=>true, "e"=>false}=>[4],
+      {"a"=>false, "b"=>false, "c"=>true, "d"=>true, "e"=>true}=>[6],
+      {"a"=>false, "b"=>false, "c"=>true, "d"=>true, "e"=>false}=>[8],
+      {"a"=>false, "b"=>false, "c"=>true, "d"=>false, "e"=>false}=>[7],
+      {"a"=>false, "b"=>false, "c"=>false, "d"=>false, "e"=>true}=>[9]
+    }
+
+    assert_equal expected1, data
+  end
+
+  def test_named_chained_pivots
+    list = [1,2,3,4,5,6,7,8,9]
+    data = list.pivot("less than 5") { |i| i < 5 }.pivot("divisible by 2") { |i| i % 2 == 0 }
+
+    expected = {
+      { "less than 5" => true, "divisible by 2" => false } => [1, 3],
+      { "less than 5" => true, "divisible by 2" => true}   => [2, 4],
+      { "less than 5" => false, "divisible by 2" => false} => [5, 7, 9],
+      { "less than 5" => false, "divisible by 2" => true}  => [6, 8]
+    }
+
+    assert_equal expected, data
+  end
+
+
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: goldmine
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-19 00:00:00.000000000 Z
+date: 2012-06-20 00:00:00.000000000 Z
 dependencies: []
 description: ! '    Goldmine allows you to apply pivot table logic to any list for
   powerful data mining capabilities.
@@ -26,6 +26,7 @@ files:
 - Gemfile.lock
 - Rakefile
 - README.md
+- test/test_goldmine.rb
 homepage: http://hopsoft.github.com/goldmine/
 licenses:
 - MIT