pivot_table 0.0.3 → 0.1.1

data/.rvmrc

@@ -1,21 +1,22 @@
-ruby_version="1.9.2"
-gemset_name="pivot"
+#!/usr/bin/env bash
 
-ok="\033[10;32m"
-warn="\033[1;31m"
-reset="\033[0m"
+environment_id="ruby-1.9.2-p290@pivot_table"
 
-if rvm list strings | grep -q "${ruby_version}" ; then
-  rvm use ${ruby_version}
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
 
-  if rvm gemset list | grep -q "${gemset_name}" ; then
-    echo -e "${ok}Using the ${gemset_name} gemset${reset}"
-    rvm gemset use ${gemset_name}
-  else
-    echo -e "${ok}The ${gemset_name} gemset does not exist, using global gemset${reset}"
+  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
+  then
+    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
   fi
-
+  echo "RVM environment: ${environment_id}"
 else
-  echo -e "${warn}You do not have the required Ruby installed: ${ruby_version}${reset}"
-
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  if ! rvm --create  "$environment_id"
+  then
+    echo "Failed to create RVM environment '${environment_id}'."
+    exit 1
+  fi
 fi

data/.travis.yml

@@ -0,0 +1,2 @@
+rvm:
+  - 1.9.2

data/Gemfile

@@ -3,12 +3,15 @@ source "http://rubygems.org"
 # Specify your gem's dependencies in pivot.gemspec
 gemspec
 
+gem 'rake'
+
 group :development, :test do
   gem 'autotest'
-  gem 'autotest-growl'
+  #gem 'autotest-growl'
   gem 'autotest-notification'
   gem 'bundler'
   gem 'launchy'
   gem 'rcov'
   gem 'rspec'
+  gem 'shoulda-matchers'
 end

data/README.md

@@ -1,4 +1,4 @@
-Pivot Table
+Pivot Table  [![Build Status](https://secure.travis-ci.org/edjames/pivot_table.png)](http://travis-ci.org/edjames/pivot_table)
 ===========
 
 A handy tool for transforming a dataset into a spreadsheet-style pivot table.
@@ -7,7 +7,7 @@ Why make this?
 --------------
 
 One of the most powerful and underrated features of spreadhseet packages is their ability to create pivot tables. I'm often asked
-to replicate this functionality in a web application...
+to replicate this functionality in a web application, so I decided to share. This is a simple gem for a specific job, I hope it helps.
 
 Installation
 ------------
@@ -26,47 +26,70 @@ At the very least, you will need to provide four things to create a pivot table.
 * a dataset (this doesn't necessarily have to be an ActiveRecord dataset, but it should at least behave like ActiveRecord e.g. OpenStruct)
 * the method to be used as column names
 * the method to be used as row names
-* the method to be used as the pivot
-
-Let's say you have a dataset that looks like this (I'll use OpenStruct, but this could easily be ActiveRecord, or even a custom object):
-
-    my_data = []
-    my_data << OpenStruct.new(:city => 'London',   :quarter => 'Q1', :sales => 100)
-    my_data << OpenStruct.new(:city => 'London',   :quarter => 'Q2', :sales => 200)
-    my_data << OpenStruct.new(:city => 'London',   :quarter => 'Q3', :sales => 300)
-    my_data << OpenStruct.new(:city => 'London',   :quarter => 'Q4', :sales => 400)
-    my_data << OpenStruct.new(:city => 'New York', :quarter => 'Q1', :sales => 10)
-    my_data << OpenStruct.new(:city => 'New York', :quarter => 'Q2', :sales => 20)
-    my_data << OpenStruct.new(:city => 'New York', :quarter => 'Q3', :sales => 30)
-    my_data << OpenStruct.new(:city => 'New York', :quarter => 'Q4', :sales => 40)
-
-You can then generate a pivot table like so...
-
-    p = PivotTable::Table.new do |p|
-      p.data     = my_data
-      p.column   = :quarter
-      p.row      = :city
-      p.pivot_on = :sales
+
+Let's say you have a collection of Order objects that looks like this:
+
+    obj_1 = Order.new(:city => 'London',   :quarter => 'Q1')
+    obj_2 = Order.new(:city => 'London',   :quarter => 'Q2')
+    obj_3 = Order.new(:city => 'London',   :quarter => 'Q3')
+    obj_4 = Order.new(:city => 'London',   :quarter => 'Q4')
+    obj_5 = Order.new(:city => 'New York', :quarter => 'Q1')
+    obj_6 = Order.new(:city => 'New York', :quarter => 'Q2')
+    obj_7 = Order.new(:city => 'New York', :quarter => 'Q3')
+    obj_8 = Order.new(:city => 'New York', :quarter => 'Q4')
+
+    data = [ obj_1, obj_2, obj_3, obj_4, obj_5, obj_6, obj_7, obj_8 ]
+
+Instantiate a new PivotTable::Grid object like this...
+
+    grid = PivotTable::Grid.new do |g|
+      g.sourcedata   = data
+      g.column_name  = :quarter
+      g.row_name     = :city
     end
-    p.generate
 
-...which will give you a hash that looks like this...
 
-    {
-      :headers => ['', 'Q1', 'Q2', 'Q3', 'Q4', 'Total'],
-      :rows => [
-        ['London',  100, 200, 300, 400, 1000],
-        ['New York', 10,  20,  30,  40, 100]
-      ],
-      :totals => ['Total', 110, 220, 330, 440, 1100]
-    }
+All you have to do now is build the grid...
+
+    g.build
+
+This will give you a logical grid (represented by an two-dimensional array) which can be likened to this table:
+
+    --------------------------------------------
+    |          |  Q1   |  Q2   |  Q3   |  Q4   |
+    |----------|--------------------------------
+    | London   | obj_1 | obj_2 | obj_3 | obj_4 |
+    | New York | obj_5 | obj_6 | obj_7 | obj_8 |
+    --------------------------------------------
+
+Then you have the following aspects of the pivot table grid available to you...
 
-...which makes it easy-peasy to print a pivot table that looks like this...
+    g.row_headers => ['London', 'New York']
+    g.rows.length => 2
 
-               Q1    Q2    Q3    Q4   Total
-    London    100   200   300   400    1000
-    New York   10    20    30    40     100
-    Total     110   220   330   440    1100
+    g.rows[0].header => 'London'
+    g.rows[0].data   => [obj_1, obj_2, obj_3, obj_4]
+
+    g.rows[1].header => 'New York'
+    g.rows[1].data   => [obj_5, obj_6, obj_7, obj_8]
+
+    g.column_headers => ['Q1', 'Q2', 'Q3', 'Q4']
+    g.columns.length => 4
+
+    g.columns[0].header => 'Q1'
+    g.columns[0].data   => [obj_1, obj_5]
+
+    g.columns[1].header => 'Q2'
+    g.columns[1].data   => [obj_2, obj_6]
+
+    g.columns[2].header => 'Q3'
+    g.columns[2].data   => [obj_3, obj_7]
+
+    g.columns[3].header => 'Q4'
+    g.columns[3].data   => [obj_4, obj_8]
+
+The API should give you a lot of flexibility with regards to rendering this information in your views.
+E.g. The rows and columns collections make it very easy to produce horizontal, vertical and overall total values.
 
 Ah, that's better.
 
@@ -76,6 +99,12 @@ Still to come
 PivotTable is still in the very early stages of development. As my personal needs for evolve, I'll update the gem with new functionality accordingly.
 Feel free to fork and/or suggest new features.
 
+Ruby 1.9 only...for now
+----------------
+
+Right now PivotTable only supports Ruby 1.9. If you need support for 1.8 please feel free to fork and merge. I will not however be adding
+support for 1.8.
+
 Contributing to PivotTable
 ---------------------
 

data/Rakefile

@@ -1,2 +1,7 @@
 require 'bundler/gem_tasks'
 Bundler::GemHelper.install_tasks
+
+desc "Fix the xml column types from a SqlServer database in schema.rb"
+task :default do
+  exec 'rspec spec'
+end

data/lib/pivot_table.rb

@@ -1,6 +1,9 @@
 $: << File.dirname(__FILE__)
-require "pivot_table/table"
+
+require "pivot_table/grid"
+require "pivot_table/column"
+require "pivot_table/row"
 
 module PivotTable
-  VERSION = "0.0.3"
+  VERSION = "0.1.1"
 end

data/lib/pivot_table/column.rb

@@ -0,0 +1,17 @@
+module PivotTable
+  class Column
+
+    ACCESSORS = [:header, :data, :total]
+
+    ACCESSORS.each do |a|
+      self.send(:attr_accessor, a)
+    end
+
+    def initialize(options = {})
+      ACCESSORS.each do |a|
+        self.send("#{a}=", options[a]) if options.has_key?(a)
+      end
+    end
+
+  end
+end

data/lib/pivot_table/grid.rb

@@ -0,0 +1,66 @@
+module PivotTable
+  class Grid
+
+    attr_accessor :source_data, :row_name, :column_name
+    attr_reader :columns, :rows, :data_grid
+
+    def initialize(&block)
+      yield(self) if block_given?
+    end
+
+    def build
+      populate_grid
+      build_rows
+      build_columns
+      self
+    end
+
+    def build_rows
+      @rows = []
+      @data_grid.each_with_index do |data, index|
+        @rows << Row.new(:header => row_headers[index], :data => data)
+      end
+    end
+
+    def build_columns
+      @columns = []
+      @data_grid.transpose.each_with_index do |data, index|
+        @columns << Column.new(:header => column_headers[index], :data => data)
+      end
+    end
+
+    def column_headers
+      headers @column_name
+    end
+
+    def row_headers
+      headers @row_name
+    end
+
+    def prepare_grid
+      @data_grid = []
+      row_headers.count.times do
+        @data_grid << column_headers.count.times.inject([]) { |col| col << nil }
+      end
+      @data_grid
+    end
+
+    def populate_grid
+      prepare_grid
+      row_headers.each_with_index do |row, row_index|
+        current_row = []
+        column_headers.each_with_index do |col, col_index|
+          current_row[col_index] = @source_data.find { |item| item.send(row_name) == row && item.send(column_name) == col }
+        end
+        @data_grid[row_index] = current_row
+      end
+      @data_grid
+    end
+
+    private
+    def headers method
+      @source_data.collect { |c| c.send method }.uniq.sort
+    end
+
+  end
+end

data/lib/pivot_table/row.rb

@@ -0,0 +1,17 @@
+module PivotTable
+  class Row
+
+    ACCESSORS = [:header, :data, :total]
+
+    ACCESSORS.each do |a|
+      self.send(:attr_accessor, a)
+    end
+
+    def initialize(options = {})
+      ACCESSORS.each do |a|
+        self.send("#{a}=", options[a]) if options.has_key?(a)
+      end
+    end
+
+  end
+end

data/pivot_table.gemspec

@@ -9,9 +9,10 @@ Gem::Specification.new do |s|
   s.email       = Base64.decode64("ZWQuamFtZXMuZW1haWxAZ21haWwuY29t\n")
   s.homepage    = "https://github.com/edjames/pivot_table"
   s.summary     = "pivot_table-#{s.version}"
-  s.description = "Transform an ActiveRecord-ish data set into pivot table"
+  s.description = "Transform an ActiveRecord-ish data set into a pivot table of objects"
 
   s.platform    = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.9'
   
   s.rubyforge_project = "pivot_table"
   s.rubygems_version = ">= 1.6.1"

data/spec/pivot_table/column_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+module PivotTable
+  describe Column do
+
+    let(:klass) { Column }
+
+    before { @instance = klass.new }
+
+    it { should respond_to :header }
+    it { should respond_to :data }
+    it { should respond_to :total }
+
+    context 'initialize with hash' do
+      subject { klass.new(header: 'header', data: 'data', total: 'total')}
+
+      its(:header) { should == 'header' }
+      its(:data) { should == 'data' }
+      its(:total) { should == 'total' }
+    end
+
+  end
+end

data/spec/pivot_table/grid_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+module PivotTable
+  describe Grid do
+    def build_object(id, row, column)
+      OpenStruct.new id: id, row_name: row, column_name: column
+    end
+
+    let(:d1) { build_object(1, 'r1', 'c1') }
+    let(:d2) { build_object(2, 'r1', 'c2') }
+    let(:d3) { build_object(3, 'r1', 'c3') }
+    let(:d4) { build_object(4, 'r2', 'c1') }
+    let(:d5) { build_object(5, 'r2', 'c2') }
+    let(:d6) { build_object(6, 'r2', 'c3') }
+
+    let(:data) { [d1, d2, d3, d4, d5, d6] }
+
+    let(:column_headers) { %w(c1 c2 c3) }
+    let(:row_headers) { %w(r1 r2) }
+    let(:row_0) { [d1, d2, d3] }
+    let(:row_1) { [d4, d5, d6] }
+    let(:column_0) { [d1, d4] }
+    let(:column_1) { [d2, d5] }
+    let(:column_2) { [d3, d6] }
+
+    let(:instance) do
+      Grid.new do |g|
+        g.source_data = data
+        g.row_name    = :row_name
+        g.column_name = :column_name
+      end
+    end
+
+    context 'accessors' do
+      subject { Grid.new }
+      it { should respond_to :source_data }
+      it { should respond_to :row_name }
+      it { should respond_to :column_name }
+      it { should respond_to :columns }
+      it { should respond_to :rows }
+    end
+
+    describe 'build' do
+      subject { instance.build }
+      its(:class) { should == Grid }
+    end
+
+    describe 'columns' do
+      let(:build_result) { instance.build }
+      specify { build_result.columns.length.should == 3 }
+
+      context 'column headers' do
+        subject { build_result.column_headers }
+        it { should == column_headers }
+      end
+
+      context '1st column' do
+        subject { build_result.columns[0] }
+        its(:header) { should == column_headers[0] }
+        its(:data) { should = column_0 }
+      end
+
+      context '2nd column' do
+        subject { build_result.columns[1] }
+        its(:header) { should == column_headers[1] }
+        its(:data) { should = column_1 }
+      end
+
+      context '3rd column' do
+        subject { build_result.columns[2] }
+        its(:header) { should == column_headers[2] }
+        its(:data) { should = column_2 }
+      end
+    end
+
+    describe 'rows' do
+      let(:build_result) { instance.build }
+      specify { build_result.rows.length.should == 2 }
+
+      context 'row headers' do
+        subject { build_result.row_headers }
+        it { should == row_headers }
+      end
+
+      context '1st row' do
+        subject { build_result.rows[0] }
+        its(:header) { should == row_headers[0] }
+        its(:data) { should = row_0 }
+      end
+
+      context '2nd row' do
+        subject { build_result.rows[1] }
+        its(:header) { should == row_headers[1] }
+        its(:data) { should = row_1 }
+      end
+    end
+
+    describe 'data grid' do
+      let(:build_result) { instance.build }
+
+      context 'preparing the grid' do
+        subject { build_result.prepare_grid }
+        it { should == [[nil, nil, nil], [nil, nil, nil]] }
+      end
+
+      context 'populating the grid' do
+        subject { build_result.data_grid }
+        it { should == [[d1, d2, d3], [d4, d5, d6]] }
+      end
+    end
+  end
+end

data/spec/pivot_table/row_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+module PivotTable
+  describe Row do
+
+    let(:klass) { Row }
+
+    before { @instance = klass.new }
+
+    it { should respond_to :header }
+    it { should respond_to :data }
+    it { should respond_to :total }
+
+    context 'initialize with hash' do
+      subject { klass.new(header: 'header', data: 'data', total: 'total')}
+
+      its(:header) { should == 'header' }
+      its(:data) { should == 'data' }
+      its(:total) { should == 'total' }
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pivot_table
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-29 00:00:00.000000000Z
+date: 2011-09-28 00:00:00.000000000Z
 dependencies: []
-description: Transform an ActiveRecord-ish data set into pivot table
+description: Transform an ActiveRecord-ish data set into a pivot table of objects
 email: ed.james.email@gmail.com
 executables: []
 extensions: []
@@ -20,15 +20,20 @@ files:
 - .gitignore
 - .rspec
 - .rvmrc
+- .travis.yml
 - CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/pivot_table.rb
-- lib/pivot_table/table.rb
+- lib/pivot_table/column.rb
+- lib/pivot_table/grid.rb
+- lib/pivot_table/row.rb
 - pivot_table.gemspec
-- spec/pivot_table/table_spec.rb
+- spec/pivot_table/column_spec.rb
+- spec/pivot_table/grid_spec.rb
+- spec/pivot_table/row_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/edjames/pivot_table
 licenses: []
@@ -41,7 +46,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -50,8 +55,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: pivot_table
-rubygems_version: 1.8.10
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: pivot_table-0.0.3
+summary: pivot_table-0.1.1
 test_files: []

data/lib/pivot_table/table.rb

@@ -1,73 +0,0 @@
-module PivotTable
-  class Table
-
-    attr_accessor :data, :column, :row, :pivot_on
-
-    def initialize(&block)
-      yield(self) if block_given?
-    end
-
-    def column_headers
-      @data.collect { |c| c.send @column }.uniq.sort
-    end
-
-    def row_headers
-      @data.collect { |r| r.send @row }.uniq.sort
-    end
-
-    def initialize_grid(rows, columns, default_value = 0)
-      @grid = []
-      rows.times do
-        @grid << columns.times.inject([]) { |col| col << default_value }
-      end
-      @grid
-    end
-
-    def matching_data(row_header, column_header)
-      data.select { |item| item.send(@row) == row_header && item.send(@column) == column_header }
-    end
-
-    def populate_grid
-      row_headers.each_with_index do |row_header, row_index|
-        column_headers.each_with_index do |column_header, column_index|
-          collected                      = matching_data row_header, column_header
-          total                          = collected.inject(0) { |sum, item| sum += item.send(@pivot_on) }
-          @grid[row_index][column_index] += total
-        end
-      end
-      @grid
-    end
-
-    def row_sum row
-      row.inject(0) { |sum, value| sum += value }
-    end
-
-    def calculate_row_totals
-      @grid.each { |row| row << row_sum(row) }
-    end
-
-    def add_row_headers
-      @grid.each_with_index do |row, index|
-        row.unshift row_headers[index]
-      end
-    end
-
-    def calculate_column_totals data
-      numeric_data = data.dup
-      numeric_data.transpose.map { |row| row_sum row }
-    end
-
-    def generate
-      initialize_grid row_headers.size, column_headers.size, 0
-      populate_grid
-      calculate_row_totals
-      totals = calculate_column_totals @grid
-
-      {
-          :headers => ['', column_headers, 'Total'].flatten,
-          :rows    => add_row_headers,
-          :totals  => ['Total', totals].flatten
-      }
-    end
-  end
-end

data/spec/pivot_table/table_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-module PivotTable
-  describe Table do
-    context 'accessors' do
-      subject { Table.new }
-      it { should respond_to :data }
-      it { should respond_to :column }
-      it { should respond_to :row }
-      it { should respond_to :pivot_on }
-    end
-
-    context 'instantiate using explicit block form' do
-      subject do
-        Table.new do |i|
-          i.data     = :data
-          i.column   = :column
-          i.row      = :row
-          i.pivot_on = :pivot_on
-        end
-      end
-
-      specify { subject.data.should == :data }
-      specify { subject.column.should == :column }
-      specify { subject.row.should == :row }
-      specify { subject.pivot_on.should == :pivot_on }
-    end
-
-    before do
-      @data = []
-      @data << OpenStruct.new(:city => 'London', :quarter => 'Q1', :sales => 100)
-      @data << OpenStruct.new(:city => 'London', :quarter => 'Q2', :sales => 200)
-      @data << OpenStruct.new(:city => 'London', :quarter => 'Q3', :sales => 300)
-      @data << OpenStruct.new(:city => 'London', :quarter => 'Q4', :sales => 400)
-      @data << OpenStruct.new(:city => 'Cape Town', :quarter => 'Q1', :sales => 5)
-      @data << OpenStruct.new(:city => 'Cape Town', :quarter => 'Q1', :sales => 15)
-      @data << OpenStruct.new(:city => 'Cape Town', :quarter => 'Q1', :sales => 30)
-      @data << OpenStruct.new(:city => 'New York', :quarter => 'Q1', :sales => 10)
-      @data << OpenStruct.new(:city => 'New York', :quarter => 'Q2', :sales => 20)
-      @data << OpenStruct.new(:city => 'New York', :quarter => 'Q3', :sales => 30)
-      @data << OpenStruct.new(:city => 'New York', :quarter => 'Q4', :sales => 10)
-      @data << OpenStruct.new(:city => 'New York', :quarter => 'Q4', :sales => 30)
-      @instance = Table.new do |i|
-        i.data     = @data
-        i.column   = :quarter
-        i.row      = :city
-        i.pivot_on = :sales
-      end
-    end
-
-    subject { @instance }
-
-    context 'column headers' do
-      subject { @instance.column_headers }
-      it { should == ['Q1', 'Q2', 'Q3', 'Q4'] }
-    end
-
-    context 'row headers' do
-      subject { @instance.row_headers }
-      it { should == ['Cape Town', 'London', 'New York'] }
-    end
-
-    context 'initializing the grid' do
-      before do
-        @expected_result = [
-            [0, 0, 0],
-            [0, 0, 0]
-        ]
-      end
-      subject { @instance.initialize_grid 2, 3, 0 }
-      it { should == @expected_result }
-    end
-
-    context 'matching data' do
-      context 'single matching data item' do
-        subject { @instance.matching_data 'London', 'Q1' }
-        specify { subject.size.should == 1 }
-        specify { subject.first.should == @data.first }
-      end
-
-      context 'multiple matching data items' do
-        subject { @instance.matching_data 'Cape Town', 'Q1' }
-        specify { subject.size.should == 3 }
-        specify { subject[0].should == @data[4] }
-        specify { subject[1].should == @data[5] }
-        specify { subject[2].should == @data[6] }
-      end
-    end
-
-    context 'aggregating the data in the grid' do
-      before do
-        @instance.initialize_grid 3, 4, 0
-        @expected_result = [
-            [50, 0, 0, 0],
-            [100, 200, 300, 400],
-            [10, 20, 30, 40]
-        ]
-      end
-      subject { @instance.populate_grid }
-      it { should == @expected_result }
-    end
-
-    context 'generate' do
-      before do
-        @expected_result = {
-            :headers => ['', 'Q1', 'Q2', 'Q3', 'Q4', 'Total'],
-            :rows    => [
-                ['Cape Town', 50, 0, 0, 0, 50],
-                ['London', 100, 200, 300, 400, 1000],
-                ['New York', 10, 20, 30, 40, 100]
-            ],
-            :totals  => ['Total', 160, 220, 330, 440, 1150]
-        }
-      end
-      subject { @instance.generate }
-      it { should == @expected_result }
-    end
-
-  end
-end