goldmine 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2de5d730c5afa6d7b115594a6a3b426d69cc7901
-  data.tar.gz: d3d9768c962046f97c223cca2d6bf1825ddcebdb
+  metadata.gz: 98cf471fea798a03ff6b2d00fd66f46a8e7314bc
+  data.tar.gz: 9f3504f492b1fe77c6e6a6be0c25ca8c15320a1b
 SHA512:
-  metadata.gz: 31343963f3b95dcfa233194f8663706f8a863f5b50660bc123c8f69df34a847453655ef31ff41320fff9544aea515ddc2b084bfaa9df0ea98d3f5fccb73262ab
-  data.tar.gz: 0fd12420956bcd9a9910b2006ead91b89a0df0dd90e59a798a7b35d0e0f9e7e2764804f776eda6fce21bd26981b95d7797832f8949514ce6b41c87a2c3617a18
+  metadata.gz: 5d8eb6c77e8a16834ad6c045040abb56d77fbd0b4fff6c5921cb96b17875de0152deaf874b85269836f7e18f6c194783a865d9dc4fb75c2eb65ed977e62a09c6
+  data.tar.gz: 869e2679c6f914fba82726834056420f00f7aee3597d514623b15d233b826936d29600729609e2e3ff6ad07d042f84cab0a5e8195f5b4a4b1e004c0fcc2f863c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    goldmine (1.2.0)
+    goldmine (1.2.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,4 +1,4 @@
-[![Lines of Code](http://img.shields.io/badge/lines_of_code-89-brightgreen.svg?style=flat)](http://blog.codinghorror.com/the-best-code-is-no-code-at-all/)
+[![Lines of Code](http://img.shields.io/badge/lines_of_code-132-brightgreen.svg?style=flat)](http://blog.codinghorror.com/the-best-code-is-no-code-at-all/)
 [![Code Status](http://img.shields.io/codeclimate/github/hopsoft/goldmine.svg?style=flat)](https://codeclimate.com/github/hopsoft/goldmine)
 [![Dependency Status](http://img.shields.io/gemnasium/hopsoft/goldmine.svg?style=flat)](https://gemnasium.com/hopsoft/goldmine)
 [![Build Status](http://img.shields.io/travis/hopsoft/goldmine.svg?style=flat)](https://travis-ci.org/hopsoft/goldmine)
@@ -14,14 +14,14 @@ Think of __Goldmine__ as `Enumerable#group_by` on steroids.
 
 - Data mining
 - Data transformation
+- Data blending
+- Data visualization prep
 - CSV report generation
-- Prep for data visualization
-- Fact table creation
 
 ---
 
 The [demo project](http://hopsoft.github.io/goldmine/) demonstrates some of Goldmine's uses.
-`TODO: update the demo project`
+`TODO: update the demo project to use the latest features`
 
 ---
 
@@ -143,64 +143,52 @@ end
 }
 ```
 
-## Rollups
+## Rollups, Tabular, & CSV
 
-Sometimes it's useful to roll pivots into a summary.
+Rollups provide a clean way to aggregate pivoted data.
+
+_NOTE: Rollups can also be chained._
 
 ```ruby
 list = [1,2,3,4,5,6,7,8,9]
 list = Goldmine::ArrayMiner.new(list)
-pivoted = list.pivot(:less_than_5) { |i| i < 5 }.pivot(:even) { |i| i % 2 == 0 }
-pivoted.rollup { |values| values.size }
+pivoted = list
+  .pivot(:less_than_5) { |i| i < 5 }
+  .pivot(:even) { |i| i % 2 == 0 }
 # result:
 {
-  { :less_than_5 => true, :even => false} => 2,
-  { :less_than_5 => true, :even => true} => 2,
-  { :less_than_5 => false, :even => false} => 3,
-  { :less_than_5 => false, :even => true} => 2
+  { :less_than_5 => true, :even => false } => [1, 3],
+  { :less_than_5 => true, :even => true } => [2, 4],
+  { :less_than_5 => false, :even => false} => [5, 7, 9],
+  { :less_than_5 => false, :even => true } => [6, 8]
 }
-```
-
-## Tabular data
 
-Tabular data provides a more streamlined summary view of a pivot.
+rollup = pivoted.rollup(:count) { |matched| matched.size }
+# result:
+{
+  {:less_than_5=>true, :even=>false}=>{:count=>2},
+  {:less_than_5=>true, :even=>true}=>{:count=>2},
+  {:less_than_5=>false, :even=>false}=>{:count=>3},
+  {:less_than_5=>false, :even=>true}=>{:count=>2}
+}
 
-```ruby
-list = [1,2,3,4,5,6,7,8,9]
-list = Goldmine::ArrayMiner.new(list)
-pivoted = list.pivot(:less_than_5) { |i| i < 5 }.pivot(:even) { |i| i % 2 == 0 }
-pivoted.to_tabular
+rollup.to_tabular
 # result:
 [
-  ["less_than_5", "even", "percent", "count"],
-  [true, false, 0.22, 2],
-  [true, true, 0.22, 2],
-  [false, false, 0.33, 3],
-  [false, true, 0.22, 2]
+  ["less_than_5", "even", "count"],
+  [true, false, 2],
+  [true, true, 2],
+  [false, false, 3],
+  [false, true, 2]
 ]
-```
 
-## CSV table
-
-CSV tables are a formalized version of tabular data.
-They simplify the complexity of working with tabular data.
-
-```ruby
-list = [1,2,3,4,5,6,7,8,9]
-list = Goldmine::ArrayMiner.new(list)
-pivoted = list.pivot(:less_than_5) { |i| i < 5 }.pivot(:even) { |i| i % 2 == 0 }
-csv = pivoted.to_csv
-
-csv.headers # => ["less_than_5", "even", "percent", "count"]
-
-csv.each do |row|
-  puts row["less_than_5"]
-  puts row["even"]
-end
+rollup.to_csv_table
+# result:
+#<CSV::Table mode:col_or_row row_count:5>
 
-csv.to_csv
+rollup.to_csv_table.to_csv
 # result:
-"less_than_5,even,percent,count\ntrue,false,0.22,2\ntrue,true,0.22,2\nfalse,false,0.33,3\nfalse,true,0.22,2\n"
+"less_than_5,even,count\ntrue,false,2\ntrue,true,2\nfalse,false,3\nfalse,true,2\n"
 ```
 
 ## Summary

data/lib/goldmine.rb

@@ -1,4 +1,5 @@
 $:.unshift File.join(File.dirname(__FILE__), "goldmine")
+require "hash_rollup"
 require "array_miner"
 require "hash_miner"
 

data/lib/goldmine/array_miner.rb

@@ -2,10 +2,7 @@ require "delegate"
 
 module Goldmine
   class ArrayMiner < SimpleDelegator
-    attr_reader :source_data
-
-    def initialize(array=[], source_data: [])
-      @source_data = source_data
+    def initialize(array=[])
       super array
     end
 
@@ -48,7 +45,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(HashMiner.new(source_data: self)) do |memo, item|
+      reduce(HashMiner.new) do |memo, item|
         value = yield(item)
 
         if value.is_a?(Array)

data/lib/goldmine/hash_miner.rb

@@ -1,13 +1,9 @@
 require "delegate"
-require "csv"
 
 module Goldmine
   class HashMiner < SimpleDelegator
-    attr_reader :source_data
-
-    def initialize(hash={}, source_data: [])
-      @source_data = source_data
-      super hash
+    def initialize(hash={})
+      super @hash = hash
     end
 
     attr_accessor :goldmine
@@ -35,7 +31,7 @@ module Goldmine
     def pivot(name=nil, &block)
       return self unless goldmine
 
-      reduce(HashMiner.new(source_data: source_data)) do |memo, item|
+      reduce(HashMiner.new) do |memo, item|
         key = item.first
         value = Goldmine.miner(item.last)
         value.pivot(name, &block).each do |k, v|
@@ -52,45 +48,12 @@ module Goldmine
       end
     end
 
-    # Returns a new "rolled up" Hash based on the return value of the yield.
+    # Returns a HashRollup with summarized data.
     #
-    # @yield [Object] Yields once for each pivoted group.
+    # @yield [Object] Yields once for each pivoted grouping of values.
     # @return [Hash] The rollup Hash of data.
-    def rollup
-      each_with_object({}) do |pair, memo|
-        memo[pair.first] = yield(pair.last)
-      end
-    end
-
-    # Returns a tabular representation of the pivot.
-    # Useful for building CSVs & data visualizations.
-    #
-    # @param percent_column_name [String] The name of the percent column (percent of total)
-    # @param count_column_name [String] The name of the count column (number of objects)
-    # @return [Array] The tabular representation of the data.
-    def to_tabular(percent_column_name: "percent", count_column_name: "count")
-      [].tap do |rows|
-        rows << tabular_header_from_key(first.first) + [percent_column_name, count_column_name]
-        rolled = rollup { |row| row.size }
-        rolled.each do |key, value|
-          tabular_row_from_key(key).tap do |row|
-            rows << row + [calculate_percentage(value, source_data.size), value]
-          end
-        end
-      end
-    end
-
-    # Returns an in memory CSV table representation of the pivot.
-    # Useful for working with data & building data visualizations.
-    #
-    # @param percent_column_name [String] The name of the percent column (percent of total)
-    # @param count_column_name [String] The name of the count column (number of objects)
-    # @return [CSV::Table] The CSV representation of the data.
-    def to_csv(percent_column_name: "percent", count_column_name: "count")
-      tabular = to_tabular(percent_column_name: percent_column_name, count_column_name: count_column_name)
-      header = tabular.shift
-      rows = tabular.map { |row| CSV::Row.new(header, row) }
-      CSV::Table.new rows
+    def rollup(name, &block)
+      HashRollup.new(@hash).rollup(name, &block)
     end
 
     # Assigns a key/value pair to the Hash.
@@ -113,24 +76,5 @@ module Goldmine
       goldmine_key ||= key
     end
 
-    private
-
-    def calculate_percentage(count, total)
-      return 0.0 unless total > 0
-      sprintf("%.2f", count / total.to_f).to_f
-    end
-
-    def tabular_header_from_key(key)
-      return key.keys.map(&:to_s) if key.is_a?(Hash)
-      key = [key] unless key.is_a?(Array)
-      (0..key.size-1).map { |i| "column#{i}" }
-    end
-
-    def tabular_row_from_key(key)
-      return key.dup if key.is_a?(Array)
-      return [key] unless key.is_a?(Hash)
-      key.values.dup
-    end
-
   end
 end

data/lib/goldmine/hash_rollup.rb

@@ -0,0 +1,65 @@
+require "delegate"
+require "csv"
+
+module Goldmine
+  class HashRollup < SimpleDelegator
+    def initialize(pivoted)
+      @pivoted = pivoted
+      super @rolled = {}
+    end
+
+    def rollup(name)
+      pivoted.each do |key, value|
+        rolled[key] ||= {}
+        rolled[key][name] = yield(value)
+      end
+      self
+    end
+
+    def to_tabular
+      [].tap do |rows|
+        rows << tabular_header
+        rows.concat tabular_rows
+      end
+    end
+
+    def to_csv_table
+      header = tabular_header
+      rows = tabular_rows.map { |row| CSV::Row.new(header, row) }
+      CSV::Table.new rows
+    end
+
+    private
+
+    attr_reader :pivoted, :rolled
+
+    def tabular_header
+      return [] if empty?
+      to_tabular_header keys.first, values.first
+    end
+
+    def tabular_rows
+      map do |pair|
+        to_tabular_row pair.first, pair.last
+      end
+    end
+
+    def to_tabular_row(key, value)
+      row = key.values.dup if key.is_a?(Hash)
+      row ||= as_array(key).dup
+      row.concat value.values
+    end
+
+    def to_tabular_header(key, value)
+      header = key.keys.map(&:to_s) if key.is_a?(Hash)
+      header ||= (1..as_array(key).size).map { |i| "column#{i}" }
+      header.concat value.keys.map(&:to_s)
+    end
+
+    def as_array(value)
+      return value if value.is_a?(Array)
+      [value]
+    end
+
+  end
+end

data/lib/goldmine/version.rb

@@ -1,3 +1,3 @@
 module Goldmine
-  VERSION = "1.2.1"
+  VERSION = "2.0.0"
 end

data/test/test_goldmine.rb

@@ -34,38 +34,54 @@ class TestGoldmine < PryTest::Test
     list = [1,2,3,4,5,6,7,8,9]
     list = Goldmine::ArrayMiner.new(list)
     data = list.pivot { |i| i < 5 }
-    rolled = data.rollup { |row| row.size }
+    rolled = data.rollup(:count) { |items| items.size }
 
     expected = {
-      true => 4,
-      false => 5
+      true => { count: 4 },
+      false => { count: 5 }
     }
 
     assert rolled == expected
   end
 
-  test "simple pivot to_tabular" do
+  test "pivot with chained rollup" do
     list = [1,2,3,4,5,6,7,8,9]
     list = Goldmine::ArrayMiner.new(list)
     data = list.pivot { |i| i < 5 }
+    rolled = data
+      .rollup(:count) { |items| items.size }
+      .rollup(:div_by_3) { |items| items.keep_if { |i| i % 3 == 0 }.size }
+
+    expected = {
+      true  => {:count=>4, :div_by_3=>1},
+      false => {:count=>5, :div_by_3=>2}
+    }
+
+    assert rolled == expected
+  end
+
+  test "simple pivot rollup to_tabular" do
+    list = [1,2,3,4,5,6,7,8,9]
+    list = Goldmine::ArrayMiner.new(list)
+    rolled = list.pivot { |i| i < 5 }.rollup(:count, &:size)
 
     expected = [
-      ["column0", "percent", "count"],
-      [true, 0.44, 4],
-      [false, 0.56, 5]
+      ["column1", "count"],
+      [true, 4],
+      [false, 5]
     ]
 
-    assert data.to_tabular == expected
+    assert rolled.to_tabular == expected
   end
 
-  test "simple pivot to_csv" do
+  test "simple pivot rollup to_csv_table" do
     list = [1,2,3,4,5,6,7,8,9]
     list = Goldmine::ArrayMiner.new(list)
-    data = list.pivot { |i| i < 5 }
-    csv = data.to_csv
+    rolled = list.pivot { |i| i < 5 }.rollup(:count, &:size)
+    csv = rolled.to_csv_table
 
-    assert csv.headers == ["column0", "percent", "count"]
-    assert csv.to_a == [["column0", "percent", "count"], [true, 0.44, 4], [false, 0.56, 5]]
+    assert csv.headers == ["column1", "count"]
+    assert csv.to_a == [["column1", "count"], [true, 4], [false, 5]]
   end
 
   test "named pivot" do
@@ -85,28 +101,28 @@ class TestGoldmine < PryTest::Test
     list = [1,2,3,4,5,6,7,8,9]
     list = Goldmine::ArrayMiner.new(list)
     data = list.pivot("less than 5") { |i| i < 5 }
-    rolled = data.rollup { |row| row.size }
+    rolled = data.rollup(:count) { |row| row.size }
 
     expected = {
-      { "less than 5" => true }  => 4,
-      { "less than 5" => false } => 5
+      { "less than 5" => true }  => { count: 4 },
+      { "less than 5" => false } => { count: 5 }
     }
 
     assert rolled == expected
   end
 
-  test "named pivot to_tabular" do
+  test "named pivot rollup to_tabular" 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 }
+    rolled = list.pivot("less than 5") { |i| i < 5 }.rollup(:count, &:size)
 
     expected = [
-      ["less than 5", "percent", "count"],
-      [true, 0.44, 4],
-      [false, 0.56, 5]
+      ["less than 5", "count"],
+      [true, 4],
+      [false, 5]
     ]
 
-    assert data.to_tabular == expected
+    assert rolled.to_tabular == expected
   end
 
   test "pivot of list values" do
@@ -182,32 +198,32 @@ class TestGoldmine < PryTest::Test
     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 }
-    rolled = data.rollup { |row| row.size }
+    rolled = data.rollup(:count) { |row| row.size }
 
     expected = {
-      [true, false]  => 2,
-      [true, true]   => 2,
-      [false, false] => 3,
-      [false, true]  => 2
+      [true, false]  => { count: 2 },
+      [true, true]   => { count: 2 },
+      [false, false] => { count: 3 },
+      [false, true]  => { count: 2 }
     }
 
     assert rolled == expected
   end
 
-  test "chained pivots to_tabular" do
+  test "chained pivots rollup to_tabular" 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 }
+    rolled = list.pivot { |i| i < 5 }.pivot { |i| i % 2 == 0 }.rollup(:count, &:size)
 
     expected = [
-      ["column0", "column1", "percent", "count"],
-      [true, false, 0.22, 2],
-      [true, true, 0.22, 2],
-      [false, false, 0.33, 3],
-      [false, true, 0.22, 2]
+      ["column1", "column2", "count"],
+      [true, false, 2],
+      [true, true, 2],
+      [false, false, 3],
+      [false, true, 2]
     ]
 
-    assert data.to_tabular == expected
+    assert rolled.to_tabular == expected
   end
 
   test "deep chained pivots" do
@@ -274,49 +290,48 @@ class TestGoldmine < PryTest::Test
     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 }
-    rolled = data.rollup { |row| row.size }
+    rolled = data.rollup(:count) { |row| row.size }
 
     expected = {
-      { "less than 5" => true, "divisible by 2" => false }  => 2,
-      { "less than 5" => true, "divisible by 2" => true }   => 2,
-      { "less than 5" => false, "divisible by 2" => false } => 3,
-      { "less than 5" => false, "divisible by 2" => true }  => 2
+      { "less than 5" => true, "divisible by 2" => false }  => { count: 2 },
+      { "less than 5" => true, "divisible by 2" => true }   => { count: 2 },
+      { "less than 5" => false, "divisible by 2" => false } => { count: 3 },
+      { "less than 5" => false, "divisible by 2" => true }  => { count: 2 }
     }
 
     assert rolled == expected
   end
 
-  test "named chained pivots to tabular" do
+  test "named chained pivots rollup to tabular" 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 }
+    rolled = list.pivot("less than 5") { |i| i < 5 }.pivot("divisible by 2") { |i| i % 2 == 0 }.rollup(:count, &:size)
 
     expected = [
-      ["less than 5", "divisible by 2", "percent", "count"],
-      [true, false, 0.22, 2],
-      [true, true, 0.22, 2],
-      [false, false, 0.33, 3],
-      [false, true, 0.22, 2]
+      ["less than 5", "divisible by 2", "count"],
+      [true, false, 2],
+      [true, true, 2],
+      [false, false, 3],
+      [false, true, 2]
     ]
 
-    assert data.to_tabular == expected
+    assert rolled.to_tabular == expected
   end
 
-  test "named chained pivots to csv" do
+  test "named chained pivots rollup to_csv_table" 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 }
-    csv = data.to_csv
+    rolled = list.pivot("less than 5") { |i| i < 5 }.pivot("divisible by 2") { |i| i % 2 == 0 }.rollup(:count, &:size)
+    csv = rolled.to_csv_table
 
-    assert csv.to_a == data.to_tabular
+    assert csv.to_a == rolled.to_tabular
 
-    expected = ["less than 5", "divisible by 2", "percent", "count"]
+    expected = ["less than 5", "divisible by 2", "count"]
     assert csv.headers == expected
 
     row = csv.first
     assert row["less than 5"] == true
     assert row["divisible by 2"] == false
-    assert row["percent"] == 0.22
     assert row ["count"] == 2
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goldmine
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Nathan Hopkins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-01 00:00:00.000000000 Z
+date: 2015-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -67,6 +67,7 @@ files:
 - lib/goldmine.rb
 - lib/goldmine/array_miner.rb
 - lib/goldmine/hash_miner.rb
+- lib/goldmine/hash_rollup.rb
 - lib/goldmine/version.rb
 - license.md
 - test/test_goldmine.rb