goldmine 2.1.0 → 3.0.0

data/lib/goldmine.rb

@@ -1,16 +1,10 @@
-$:.unshift File.join(File.dirname(__FILE__), "goldmine")
-require "cache"
-require "rollup_context"
-require "hash_rollup"
-require "array_miner"
-require "hash_miner"
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "goldmine")
+require "version"
+require "miner"
 
 module Goldmine
-  class << self
-    def miner(object)
-      return ArrayMiner.new(object) if object.is_a?(Array)
-      return HashMiner.new(object) if object.is_a?(Hash)
-      nil
-    end
-  end
+end
+
+def Goldmine(list)
+  Goldmine::Miner.new(list)
 end

data/lib/goldmine/miner.rb

@@ -0,0 +1,20 @@
+require "forwardable"
+require "pivot"
+
+module Goldmine
+  class Miner
+    extend Forwardable
+    include Enumerable
+    def_delegators :@array, :each, :to_a
+    attr_reader :pivots
+
+    def initialize(array=[])
+      @pivots = []
+      @array = array.to_a
+    end
+
+    def pivot(name, &block)
+      Pivot.new(name, self, block)
+    end
+  end
+end

data/lib/goldmine/pivot.rb

@@ -0,0 +1,52 @@
+require "pivot_result"
+
+module Goldmine
+  class Pivot
+    attr_reader :name, :proc
+
+    def initialize(name, array_miner, block)
+      @array_miner = array_miner
+      @name = name
+      @proc = block
+      array_miner.pivots << self
+    end
+
+    def pivot(name, &block)
+      self.class.new(name, array_miner, block)
+    end
+
+    def result
+      PivotResult.new.tap do |pivot_result|
+        array_miner.each do |item|
+          key_data = array_miner.pivots.each_with_object(key: [], keys: []) do |pivot, memo|
+            value = pivot.proc.call(item)
+            if value.is_a?(Array)
+              if value.empty?
+                memo[:key] << key_for(pivot.name, nil)
+              else
+                value.each { |v| memo[:keys] << key_for(pivot.name, v) }
+              end
+            else
+              memo[:key] << key_for(pivot.name, value)
+            end
+          end
+          (pivot_result[key_data[:key]] ||= []) << item unless key_data[:key].empty?
+          key_data[:keys].each do |key|
+            (pivot_result[key] ||= []) << item
+          end
+        end
+      end
+    end
+
+    private
+
+    attr_reader :array_miner
+
+    def key_for(name, value)
+      Array.new(2).tap do |key|
+        key[0] = name
+        key[1] = value
+      end
+    end
+  end
+end

data/lib/goldmine/pivot_result.rb

@@ -0,0 +1,21 @@
+require "forwardable"
+require "rollup"
+
+module Goldmine
+  class PivotResult
+    extend Forwardable
+    include Enumerable
+    def_delegators :@hash, :[], :[]=, :each, :to_h
+    attr_reader :rollups, :cache
+
+    def initialize(hash={})
+      @rollups = []
+      @hash = hash
+      @cache = {}
+    end
+
+    def rollup(name, &block)
+      Rollup.new(name, self, block)
+    end
+  end
+end

data/lib/goldmine/rollup.rb

@@ -0,0 +1,41 @@
+require "rollup_clean_room"
+require "rollup_result"
+
+module Goldmine
+  class Rollup
+    attr_reader :name, :proc
+
+    def initialize(name, pivot_result, block)
+      @name = name
+      @pivot_result = pivot_result
+      @proc = block
+      pivot_result.rollups << self
+    end
+
+    def rollup(name, &block)
+      self.class.new(name, pivot_result, block)
+    end
+
+    def result(cache: false)
+      RollupResult.new.tap do |rollup_result|
+        pivot_result.each do |pivot_key, pivoted_list|
+          stash = {} if cache
+          pivot_result.rollups.each do |rollup|
+            Array.new(2).tap do |computed_value|
+              key = rollup.name
+              value = RollupCleanRoom.new(key, stash).rollup(pivoted_list, &rollup.proc) if cache
+              value ||= rollup.proc.call(pivoted_list)
+              computed_value[0] = key
+              computed_value[1] = value
+              (rollup_result[pivot_key] ||= []) << computed_value
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    attr_reader :pivot_result
+  end
+end

data/lib/goldmine/rollup_clean_room.rb

@@ -0,0 +1,21 @@
+module Goldmine
+  class RollupCleanRoom
+    attr_reader :name, :cache
+
+    def initialize(name, cache={})
+      @name = name
+      @cache = cache
+    end
+
+    def eigen
+      class << self
+        self
+      end
+    end
+
+    def rollup(pivoted_list, &block)
+      eigen.instance_eval { define_method(:do_rollup, &block) }
+      @cache[name] = do_rollup(pivoted_list)
+    end
+  end
+end

data/lib/goldmine/rollup_result.rb

@@ -0,0 +1,45 @@
+require "forwardable"
+require "csv"
+
+module Goldmine
+  class RollupResult
+    extend Forwardable
+    include Enumerable
+    def_delegators :@pivot_result, :[], :[]=, :each, :to_h
+
+    def initialize(pivot_result={})
+      @pivot_result = pivot_result
+    end
+
+    def to_rows
+      pivot_result.each_with_object([]) do |pair, memo|
+        memo << pair.first + pair.last
+      end
+    end
+
+    def to_hash_rows
+      pivot_result.each_with_object([]) do |pair, memo|
+        memo << (pair.first + pair.last).to_h
+      end
+    end
+
+    def to_tabular
+      rows = to_rows
+      values = rows.map { |r| r.map(&:last) }
+      sample = rows.first || []
+      values.unshift sample.map(&:first)
+      values
+    end
+
+    def to_csv_table
+      rows = to_tabular
+      header = rows.shift
+      csv_rows = rows.map { |row| CSV::Row.new(header, row) }
+      CSV::Table.new csv_rows
+    end
+
+    private
+
+    attr_reader :pivot_result
+  end
+end

data/lib/goldmine/version.rb

@@ -1,3 +1,3 @@
 module Goldmine
-  VERSION = "2.1.0"
+  VERSION = "3.0.0".freeze
 end

data/test/test_goldmine.rb

@@ -6,124 +6,58 @@ require File.expand_path("../../lib/goldmine", __FILE__)
 
 class TestGoldmine < PryTest::Test
 
-  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
+  # pivots .....................................................................
 
   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 = {
-      true  => [1, 2, 3, 4],
-      false => [5, 6, 7, 8, 9]
-    }
-
-    assert data == expected
-  end
-
-  test "simple pivot 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 }
-
-    expected = {
-      true => { count: 4 },
-      false => { count: 5 }
-    }
-
-    assert rolled == expected
-  end
-
-  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 }
+    pivot = Goldmine(list).pivot("< 5") { |i| i < 5 }
 
     expected = {
-      true  => {:count=>4, :div_by_3=>1},
-      false => {:count=>5, :div_by_3=>2}
+      [["< 5", true]]  => [1, 2, 3, 4],
+      [["< 5", false]] => [5, 6, 7, 8, 9]
     }
 
-    assert rolled == expected
+    assert pivot.result.to_h == 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 = [
-      ["column1", "count"],
-      [true, 4],
-      [false, 5]
-    ]
-
-    assert rolled.to_tabular == expected
-  end
-
-  test "simple pivot rollup to_csv_table" 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)
-    csv = rolled.to_csv_table
-
-    assert csv.headers == ["column1", "count"]
-    assert csv.to_a == [["column1", "count"], [true, 4], [false, 5]]
-  end
-
-  test "named pivot" do
+  test "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 = Goldmine(list)
+      .pivot("< 5") { |i| i < 5 }
+      .pivot("even") { |i| i % 2 == 0 }
 
     expected = {
-      { "less than 5" => true }  => [1, 2, 3, 4],
-      { "less than 5" => false } => [5, 6, 7, 8, 9]
+      [["< 5", true],  ["even", false]] => [1, 3],
+      [["< 5", true],  ["even", true]]  => [2, 4],
+      [["< 5", false], ["even", false]] => [5, 7, 9],
+      [["< 5", false], ["even", true]]  => [6, 8]
     }
 
-    assert data == expected
+    assert pivot.result.to_h == expected
   end
 
-  test "named pivot rollup" do
+  test "deep 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 }
-    rolled = data.rollup(:count) { |row| row.size }
+    pivot = Goldmine(list)
+      .pivot("< 3") { |i| i < 3 }
+      .pivot("< 6") { |i| i < 6 }
+      .pivot("< 9") { |i| i < 9 }
+      .pivot("even") { |i| i % 2 == 0 }
+      .pivot("odd") { |i| i % 3 == 0 || i == 1 }
 
     expected = {
-      { "less than 5" => true }  => { count: 4 },
-      { "less than 5" => false } => { count: 5 }
+      [["< 3", true],  ["< 6", true],  ["< 9", true],  ["even", false], ["odd", true]]  => [1],
+      [["< 3", true],  ["< 6", true],  ["< 9", true],  ["even", true],  ["odd", false]] => [2],
+      [["< 3", false], ["< 6", true],  ["< 9", true],  ["even", false], ["odd", true]]  => [3],
+      [["< 3", false], ["< 6", true],  ["< 9", true],  ["even", true],  ["odd", false]] => [4],
+      [["< 3", false], ["< 6", true],  ["< 9", true],  ["even", false], ["odd", false]] => [5],
+      [["< 3", false], ["< 6", false], ["< 9", true],  ["even", true],  ["odd", true]]  => [6],
+      [["< 3", false], ["< 6", false], ["< 9", true],  ["even", false], ["odd", false]] => [7],
+      [["< 3", false], ["< 6", false], ["< 9", true],  ["even", true],  ["odd", false]] => [8],
+      [["< 3", false], ["< 6", false], ["< 9", false], ["even", false], ["odd", true]]  => [9]
     }
 
-    assert rolled == expected
-  end
-
-  test "named pivot rollup to_tabular" do
-    list = [1,2,3,4,5,6,7,8,9]
-    list = Goldmine::ArrayMiner.new(list)
-    rolled = list.pivot("less than 5") { |i| i < 5 }.rollup(:count, &:size)
-
-    expected = [
-      ["less than 5", "count"],
-      [true, 4],
-      [false, 5]
-    ]
-
-    assert rolled.to_tabular == expected
+    assert pivot.result.to_h == expected
   end
 
   test "pivot of list values" do
@@ -133,23 +67,17 @@ class TestGoldmine < PryTest::Test
       { :name => "three", :list => [1, 2, 3] },
       { :name => "four",  :list => [1, 2, 3, 4] },
     ]
-    list = Goldmine::ArrayMiner.new(list)
-    data = list.pivot { |record| record[:list] }
+    pivot = Goldmine(list)
+      .pivot("list value") { |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] } ]
+      ["list value", 1] => [{:name=>"one", :list=>[1]}, {:name=>"two", :list=>[1, 2]}, {:name=>"three", :list=>[1, 2, 3]}, {:name=>"four", :list=>[1, 2, 3, 4]}],
+      ["list value", 2] => [{:name=>"two", :list=>[1, 2]}, {:name=>"three", :list=>[1, 2, 3]}, {:name=>"four", :list=>[1, 2, 3, 4]}],
+      ["list value", 3] => [{:name=>"three", :list=>[1, 2, 3]}, {:name=>"four", :list=>[1, 2, 3, 4]}],
+      ["list value", 4] => [{:name=>"four", :list=>[1, 2, 3, 4]}]
     }
 
-    assert data == expected
+    assert pivot.result.to_h == expected
   end
 
   test "pivot of list values with empty list" do
@@ -160,243 +88,187 @@ class TestGoldmine < PryTest::Test
       { :name => "three", :list => [1, 2, 3] },
       { :name => "four",  :list => [1, 2, 3, 4] },
     ]
-    list = Goldmine::ArrayMiner.new(list)
-    data = list.pivot { |record| record[:list] }
+    pivot = Goldmine(list)
+      .pivot("list value") { |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] } ]
+      [["list value", nil]] => [{:name=>"empty", :list=>[]}],
+      ["list value", 1]     => [{:name=>"one", :list=>[1]}, {:name=>"two", :list=>[1, 2]}, {:name=>"three", :list=>[1, 2, 3]}, {:name=>"four", :list=>[1, 2, 3, 4]}],
+      ["list value", 2]     => [{:name=>"two", :list=>[1, 2]}, {:name=>"three", :list=>[1, 2, 3]}, {:name=>"four", :list=>[1, 2, 3, 4]}],
+      ["list value", 3]     => [{:name=>"three", :list=>[1, 2, 3]}, {:name=>"four", :list=>[1, 2, 3, 4]}],
+      ["list value", 4]     => [{:name=>"four", :list=>[1, 2, 3, 4]}]
     }
 
-    assert data == expected
+    assert pivot.result.to_h == expected
   end
 
-  test "chained pivots" do
+  # rollups ...................................................................
+
+  test "simple pivot rollup" 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 }
+    rollup = Goldmine(list)
+      .pivot("< 5") { |i| i < 5 }
+      .result
+      .rollup(:count) { |items| items.size }
 
     expected = {
-      [true, false]  => [1, 3],
-      [true, true]   => [2, 4],
-      [false, false] => [5, 7, 9],
-      [false, true]  => [6, 8]
+      [["< 5", true]]  => [[:count, 4]],
+      [["< 5", false]] => [[:count, 5]]
     }
 
-    assert data == expected
+    assert rollup.result.to_h == expected
   end
 
   test "chained pivots rollup" 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 = data.rollup(:count) { |row| row.size }
+    rollup = Goldmine(list)
+      .pivot("< 5") { |i| i < 5 }
+      .pivot("even") { |i| i % 2 == 0 }
+      .result
+      .rollup(:count) { |row| row.size }
 
     expected = {
-      [true, false]  => { count: 2 },
-      [true, true]   => { count: 2 },
-      [false, false] => { count: 3 },
-      [false, true]  => { count: 2 }
+      [["< 5", true],  ["even", false]] => [[:count, 2]],
+      [["< 5", true],  ["even", true]]  => [[:count, 2]],
+      [["< 5", false], ["even", false]] => [[:count, 3]],
+      [["< 5", false], ["even", true]]  => [[:count, 2]]
     }
 
-    assert rolled == expected
-  end
-
-  test "chained pivots 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 }.pivot { |i| i % 2 == 0 }.rollup(:count, &:size)
-
-    expected = [
-      ["column1", "column2", "count"],
-      [true, false, 2],
-      [true, true, 2],
-      [false, false, 3],
-      [false, true, 2]
-    ]
-
-    assert rolled.to_tabular == expected
+    assert rollup.result.to_h == expected
   end
 
-  test "deep chained pivots" 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 < 3 }
-      .pivot { |i| i < 6 }
-      .pivot { |i| i < 9 }
-      .pivot { |i| i % 2 == 0 }
-      .pivot { |i| i % 3 == 0 }
+    list = Goldmine(list)
+    rollup = list
+      .pivot("< 5") { |i| i < 5 }
+      .result
+      .rollup(:count) { |items| items.size }
+      .rollup(:div_by_3) { |items| items.keep_if { |i| i % 3 == 0 }.size }
 
     expected = {
-      [true,  true,  true,  false, false] => [1],
-      [true,  true,  true,  true,  false] => [2],
-      [false, true,  true,  false, true]  => [3],
-      [false, true,  true,  false, false] => [5],
-      [false, true,  true,  true,  false] => [4],
-      [false, false, true,  true,  true]  => [6],
-      [false, false, true,  true,  false] => [8],
-      [false, false, true,  false, false] => [7],
-      [false, false, false, false, true]  => [9]
+      [["< 5", true]]  => [[:count, 4], [:div_by_3, 1]],
+      [["< 5", false]] => [[:count, 5], [:div_by_3, 2]]
     }
 
-    assert data == expected
+    assert rollup.result.to_h == expected
   end
 
-  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 = {
-      {"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]
-    }
+  # to_rows ...................................................................
 
-    assert data == expected
-  end
-
-  test "named chained pivots" do
+  test "simple pivot rollup to_rows" 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 }
+    rollup = Goldmine(list)
+      .pivot("< 5") { |i| i < 5 }
+      .result
+      .rollup(:count) { |items| items.size }
 
-    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]
-    }
+    expected = [
+      [["< 5", true],  [:count, 4]],
+      [["< 5", false], [:count, 5]]
+    ]
 
-    assert data == expected
+    assert rollup.result.to_rows == expected
   end
 
-  test "named chained pivots rollup" do
+  test "chained pivots rollup to_rows" 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 = data.rollup(:count) { |row| row.size }
+    rollup = Goldmine(list)
+      .pivot("< 5") { |i| i < 5 }
+      .pivot("even") { |i| i % 2 == 0 }
+      .result
+      .rollup(:count) { |row| row.size }
 
-    expected = {
-      { "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 }
-    }
+    expected = [
+      [["< 5", true],  ["even", false], [:count, 2]],
+      [["< 5", true],  ["even", true],  [:count, 2]],
+      [["< 5", false], ["even", false], [:count, 3]],
+      [["< 5", false], ["even", true],  [:count, 2]]
+    ]
 
-    assert rolled == expected
+    assert rollup.result.to_rows == expected
   end
 
-  test "named chained pivots rollup to tabular" do
+  test "simple pivot rollup to_hash_rows" do
     list = [1,2,3,4,5,6,7,8,9]
-    list = Goldmine::ArrayMiner.new(list)
-    rolled = list.pivot("less than 5") { |i| i < 5 }.pivot("divisible by 2") { |i| i % 2 == 0 }.rollup(:count, &:size)
+    rollup = Goldmine(list)
+      .pivot("< 5") { |i| i < 5 }
+      .result
+      .rollup(:count) { |items| items.size }
 
     expected = [
-      ["less than 5", "divisible by 2", "count"],
-      [true, false, 2],
-      [true, true, 2],
-      [false, false, 3],
-      [false, true, 2]
+      {"< 5" => true,  :count => 4},
+      {"< 5" => false, :count => 5}
     ]
 
-    assert rolled.to_tabular == expected
+    assert rollup.result.to_hash_rows == expected
   end
 
-  test "named & chained pivots with rollup to_csv_table" do
-    list = [1,2,3,4,5,6,7,8,9]
-    list = Goldmine::ArrayMiner.new(list)
-    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 == rolled.to_tabular
-
-    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 ["count"] == 2
-  end
+  # to_tabular ................................................................
 
-  test "unnamed & chained pivots with rollup to rows" do
+  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 = Goldmine(list)
+      .pivot("< 5") { |i| i < 5 }
+      .result
       .rollup(:count, &:size)
-      .rollup(:evens) { |l| l.select { |i| i % 2 == 0 }.size }
-      .rollup(:even_percentage) { |l| computed(:evens).for(l) / computed(:count).for(l).to_f }
 
     expected = [
-      {"column1"=>true, "count"=>4, "evens"=>2, "even_percentage"=>0.5},
-      {"column1"=>false, "count"=>5, "evens"=>2, "even_percentage"=>0.4}
+      ["< 5", :count],
+      [true, 4],
+      [false, 5]
     ]
 
-    assert rolled.to_rows == expected
+    assert rollup.result.to_tabular == expected
   end
 
-  test "named & chained pivots with rollup to rows" do
+  test "chained pivots rollup to_tabular" do
     list = [1,2,3,4,5,6,7,8,9]
-    list = Goldmine::ArrayMiner.new(list)
-    rolled = list
-      .pivot(:less_than_5) { |i| i < 5 }
+    rollup = Goldmine(list)
+      .pivot("< 5") { |i| i < 5 }
+      .pivot(:even) { |i| i % 2 == 0 }
+      .result
       .rollup(:count, &:size)
-      .rollup(:evens) { |l| l.select { |i| i % 2 == 0 }.size }
-      .rollup(:even_percentage) { |l| computed(:evens).for(l) / computed(:count).for(l).to_f }
 
     expected = [
-      {"less_than_5"=>true, "count"=>4, "evens"=>2, "even_percentage"=>0.5},
-      {"less_than_5"=>false, "count"=>5, "evens"=>2, "even_percentage"=>0.4}
+      ["< 5", :even, :count],
+      [true, false, 2],
+      [true, true, 2],
+      [false, false, 3],
+      [false, true, 2]
     ]
 
-    assert rolled.to_rows == expected
+    assert rollup.result.to_tabular == expected
   end
 
-  test "access to prior-computed rollups" do
+  # to_csv_table ..............................................................
+
+  test "simple pivot rollup to_csv_table" do
     list = [1,2,3,4,5,6,7,8,9]
-    list = Goldmine::ArrayMiner.new(list)
-    rolled = list
-      .pivot("less than 5") { |i| i < 5 }
+    rollup = Goldmine(list)
+      .pivot("< 5") { |i| i < 5 }
+      .result
       .rollup(:count, &:size)
-      .rollup(:evens) { |pivoted_list| pivoted_list.select { |i| i % 2 == 0 }.size }
-      .rollup(:even_percentage) { |pivoted_list| computed(:evens).for(pivoted_list) / computed(:count).for(pivoted_list).to_f }
 
-    expected = [
-      ["less than 5", "count", "evens", "even_percentage"],
-      [true, 4, 2, 0.5],
-      [false, 5, 2, 0.4]
-    ]
-    assert rolled.to_tabular == expected
+    csv = rollup.result.to_csv_table
+    assert csv.to_s == "< 5,count\ntrue,4\nfalse,5\n"
   end
 
-  test "rollup names" do
+  # pivot_result cache ..........................................................
+
+  test "pivot_result cache is available to rollups" 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 }
+    cached_counts = []
+    Goldmine(list)
+      .pivot("< 5") { |i| i < 5 }
+      .result
+      .rollup(:count, &:size)
+      .rollup(:cached_count) { |_| cached_counts << cache[:count] }
+      .result(cache: true)
 
-    expected = [:count, :div_by_3]
-    assert rolled.names == expected
+    assert cached_counts.size == 2
+    assert cached_counts.first == 4
+    assert cached_counts.last == 5
   end
 
 end