elskwid-munger 0.1.4.1

data/munger.gemspec

@@ -0,0 +1,36 @@
+Gem::Specification.new do |s|
+    s.platform  =  Gem::Platform::RUBY
+    s.name      =  "elskwid-munger"
+    s.version   =  "0.1.4.1"
+    s.authors   =  ['Scott Chacon', 'Brandon Mitchell', 'Don Morrison', 'Eric Lindvall']
+    s.email     =  "elskwid@gmail.com"
+    s.summary   =  "A reporting engine in Ruby - the elskwid fork!"
+    s.homepage  =  "http://github.com/elskwid/munger"
+    s.has_rdoc  =  true
+    s.files = ["munger.gemspec",
+               "Rakefile",
+               "README",
+               "examples/column_add.rb",
+               "examples/development.log",
+               "examples/example_helper.rb",
+               "examples/sinatra_app.rb",
+               "examples/test.html",
+               "lib/munger.rb",
+               "lib/munger/data.rb",
+               "lib/munger/item.rb",
+               "lib/munger/render.rb",
+               "lib/munger/report.rb",
+               "lib/munger/render/csv.rb",
+               "lib/munger/render/html.rb",
+               "lib/munger/render/sortable_html.rb",
+               "lib/munger/render/text.rb",
+               "spec/spec_helper.rb",
+               "spec/munger/data_spec.rb",
+               "spec/munger/item_spec.rb",
+               "spec/munger/render_spec.rb",
+               "spec/munger/report_spec.rb",
+               "spec/munger/data/new_spec.rb",
+               "spec/munger/render/csv_spec.rb",
+               "spec/munger/render/html_spec.rb",
+               "spec/munger/render/text_spec.rb"]
+end

data/spec/munger/data/new_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Munger::Data do
+  
+  describe '.new' do
+    
+    it 'initializes the data attribute to the :data value' do
+      data = [{:foo => '1'}, {:foo => 2}]
+      Munger::Data.new(:data => data).data.should == data
+    end
+    
+    it 'yields itself to the given block' do
+      Munger::Data.new { |data| data.should be_kind_of(Munger::Data) }
+    end
+    
+  end
+  
+end

data/spec/munger/data_spec.rb

@@ -0,0 +1,183 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Munger::Data do 
+  include MungerSpecHelper
+  
+  before(:each) do 
+    @data = Munger::Data.new(:data => test_data)
+  end
+
+  it "should accept an array of hashes" do
+    Munger::Data.new(:data => test_data).should be_valid
+  end
+  
+  it "should be able to set data after init" do
+    m = Munger::Data.new
+    m.data = test_data
+    m.should be_valid
+  end
+  
+  it "should be able to set data in init block" do
+    m = Munger::Data.new do |d|
+      d.data = test_data
+    end
+    m.should be_valid
+  end
+  
+  it "should be able to add more data after init" do
+    m = Munger::Data.new
+    m.data = test_data
+    m.add_data more_test_data
+    m.should be_valid
+    additional_names = m.data.select { |r| r[:name] == 'David' || r[:name] == 'Michael' }
+    additional_names.should have(4).items
+  end
+  
+  it "should be able to add data without initial data" do
+    m = Munger::Data.new
+    m.add_data more_test_data
+    m.should be_valid
+    m.should have(4).items
+  end
+  
+  it "should be able to extract columns from data" do
+    @titles = @data.columns
+    @titles.should have(4).items
+    @titles.should include(:name, :score, :age)
+  end
+
+  it "should be able to add a new column with a default value" do
+    @data.add_column('new_column', :default => 1)
+    @data.data.first['new_column'].should eql(1)
+  end
+  
+  it "should be able to add a new column with a block" do
+    @data.add_column('new_column') { |c| c.age + 1 }
+    @data.data.first['new_column'].should eql(24)
+  end
+
+  it "should be able to add multiple new columns with defaults" do
+    @data.add_column(['col1', 'col2'], :default => [1, 2])
+    @data.data.first['col1'].should eql(1)
+    @data.data.first['col2'].should eql(2)
+  end
+  
+  it "should be able to add multiple new columns with a block" do
+    @data.add_column(['col1', 'col2']) { |c| [c.age * 2, c.score * 3]}
+    @data.data.first['col1'].should eql(46)
+    @data.data.first['col2'].should eql(36)
+  end
+    
+  it "should work with add_columns, too" do
+    @data.add_columns(['col1', 'col2'], :default => [1, 2])
+    @data.data.first['col1'].should eql(1)
+    @data.data.first['col2'].should eql(2)
+  end
+  
+  it "should be able to transform a column" do
+    @data.data.first[:age].should eql(23)
+    @data.transform_column(:age) { |c| c.age * 2 }
+    @data.data.first[:age].should eql(46)
+  end
+  
+  it "should be able to transform multiple rows" do
+    @data.data.first[:age].should eql(23)
+    @data.data.first[:score].should eql(12)
+    @data.transform_columns([:age, :score]) { |c| [c.age * 2, c.score * 3] }
+    @data.data.first[:age].should eql(46)
+    @data.data.first[:score].should eql(36)
+  end
+
+  it "should be able to filter the data down" do
+    orig_size = @data.size
+    @data.filter_rows { |r| r.age < 30 }
+    @data.size.should < orig_size
+    @data.size.should eql(4)
+  end
+  
+  it "should be able to pivot the data (1 column)" do
+    orig_size = @data.size
+    new_keys = @data.pivot(:day, :name, :score)
+    @data.size.should < orig_size
+    new_keys.should include(1, 2)
+    scott = @data.data.select { |r| r.name == 'Scott' }.first
+    scott[1].should eql(43)
+  end
+
+  it "should be able to pivot the data with average aggregation" do
+    new_keys = @data.pivot(:day, :name, :score, :average)
+    new_keys.should include(1, 2)
+    scott = @data.data.select { |r| r.name == 'Scott' }.first
+    scott[1].should eql(21)
+  end
+  
+  it "should be able to pivot the data with count aggregation" do
+    new_keys = @data.pivot(:day, :name, :score, :count)
+    scott = @data.data.select { |r| r.name == 'Scott' }.first
+    scott[1].should eql(2)
+  end
+
+  it "should be able to pivot the data in three dimensions (1 col, 2 row)" do
+    new_keys = @data.pivot(:name, [:score, :age], :score, :count)
+    alice = @data.data.select { |r| r.name == 'Alice' }.first
+    alice.Alice.should eql(2)
+  end
+
+  it "should be able to add a column then pivot the data (1 column)" do
+    @data.add_column(:day_of_week) { |c| Date::DAYNAMES[c.day] }
+    orig_size = @data.size
+    new_keys = @data.pivot(:day_of_week, :name, :score)
+    @data.size.should < orig_size
+    new_keys.should include("Monday", "Tuesday")
+    alice = @data.data.select { |r| r.name == 'Alice' }.first
+    alice["Monday"].should eql(12)
+    alice["Tuesday"].should eql(24)
+  end
+  
+  # like sql group command, give aggregation block
+  it "should be able to group the data like sql" do
+    @data.group(:name)
+    @data.size.should eql(6)
+  end
+  
+  it "should be able to group on multiple columns" do
+    @data.group([:age, :score], :count => :day, :sum => :day, :average => :score)
+    alice = @data.data.select { |r| (r.score == 12) && (r.age == 33)}.first
+    alice.count_day.should eql(2)
+    alice.sum_day.should eql(3)
+    alice.average_day.should eql(nil)
+  end
+
+  it "should be able to group with a proc aggregation" do
+    pr = Proc.new {|arr| arr.inject(0) { |a,b| a + (b*2) }}
+    @data.group([:age, :score], :sum => :day, ['test', pr] => :age)    
+    alice = @data.data.select { |r| (r.score == 12) && (r.age == 33)}.first
+    alice.test_age.should eql(132)
+    alice.sum_day.should eql(3)
+  end
+
+  it "should be able to output an array" do
+    array = @data.to_a
+    array.should be_a_kind_of(Array)
+    array.first.size.should eql(@data.columns.size)
+  end
+  
+  it "should be able to output a filtered array" do
+    array = @data.to_a([:name, :age])
+    array.should be_a_kind_of(Array)
+    array.first.size.should eql(2)
+    scotts = array.select { |a| a.include? ('Scott') }
+    scotts.first.should include('Scott', 23)
+  end
+  
+  it "should be able to pivot the data in three dimensions (2 col, 1 row)"
+  
+  it "should be able to pivot the data in four dimensions (2 col, 2 row)"
+    
+  it "should be able to add two Munger::Datas together if they have the same columns"
+  
+  it "should be able to add data and check if it is Munger::Data"
+  
+  it "(maybe) should be able to zip two Munger::Datas together given a unique key column in each"
+  
+end

data/spec/munger/item_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Munger::Item do 
+  include MungerSpecHelper
+  
+  before(:all) do 
+    @data = Munger::Data.new(:data => test_data)
+  end
+
+  it "should accept a hash with symbols" do
+    hash = {'key1' => 'value1', 'key2' => 'value2'}
+    item = Munger::Item.ensure(hash)
+    item.key1.should eql('value1')
+  end
+  
+  it "should accept a hash with strings" do
+    hash = {:key1 => 'value1', :key2 => 'value2'}
+    item = Munger::Item.ensure(hash)
+    item.key1.should eql('value1')
+    item.key2.should_not eql('value1')
+    item.key3.should be(nil)
+  end
+
+  it "should accept mixed types" do
+    hash = {:key1 => 'value1', 'key2' => 'value2'}
+    item = Munger::Item.ensure(hash)
+    item.key1.should eql('value1')
+    item.key2.should eql('value2')
+  end
+
+  it "should be able to access hash values indifferently" do
+    hash = {:key1 => 'value1', 'key2' => 'value2'}
+    item = Munger::Item.ensure(hash)
+    item['key1'].should eql('value1')
+    item[:key2].should eql('value2')
+  end
+end

data/spec/munger/render/csv_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe Munger::Render::CSV do 
+  include MungerSpecHelper
+  
+  before(:each) do 
+    @data = Munger::Data.new(:data => test_data)
+    @report = Munger::Report.new(:data => @data)
+  end
+
+  it "should accept a Munger::Report object" do
+    Munger::Render::Text.new(@report.process).should be_valid
+  end
+  
+  it "should render a basic text table" do
+    @render = Munger::Render::CSV.new(@report.process)
+    count = @report.rows
+    text = @render.render
+    text.split("\n").should have_at_least(count).items
+  end
+end

data/spec/munger/render/html_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe Munger::Render::Html do 
+  include MungerSpecHelper
+  
+  before(:each) do 
+    @data = Munger::Data.new(:data => test_data)
+    @report = Munger::Report.new(:data => @data)
+  end
+
+  it "should accept a Munger::Report object" do
+    Munger::Render::Html.new(@report.process).should be_valid
+  end
+
+  it "should render a basic html table" do
+    @render = Munger::Render::Html.new(@report.process)
+    count = @report.rows
+    
+    html = @render.render
+    html.should have_tag('table')
+    html.should have_tag('tr', :count => count + 1) # rows plus header
+  end
+  
+  it "should accept a custom table class" do
+    rep = Munger::Render::Html.new(@report.process, :classes => {:table => 'helloClass'})
+    html = rep.render
+    html.should have_tag('table.helloClass')
+  end
+  
+  it "should use aliased column titles" do
+    @report = @report.columns([:age, :name, :score])
+    @report.column_titles = {:age => "The Age", :name => "The Name"}
+    html = Munger::Render::Html.new(@report.process).render
+    html.should match(/The Age/)
+  end
+  
+  it "should render columns in the right order" do
+    @report = @report.columns([:age, :name]).process
+    html = Munger::Render::Html.new(@report).render
+    html.should have_tag('th', :count => 2) # rows plus header
+    html.should match(/age(.*?)name/)
+  end
+  
+  it "should render groups" do
+    @report = @report.subgroup(:age).aggregate(:sum => :score).process
+    html = Munger::Render::Html.new(@report).render
+    html.should match(/151/) # only in the aggregate group
+    html.should have_tag('tr.group0', :count => 1) 
+    html.should have_tag('tr.group1', :count => 9) 
+  end
+  
+  it "should render group headers" do
+    @report = @report.subgroup(:age, :with_headers => true).process
+    html = Munger::Render::Html.new(@report).render
+    html.should have_tag('tr.groupHeader1', :count => 9) 
+  end
+  
+  it "should render cell styles" do
+    @report.process.style_rows('over_thirty') { |row| row.age > 29 }
+    
+    html = Munger::Render::Html.new(@report).render
+    html.should have_tag('tr.over_thirty', :count => 6)
+  end
+
+  it "should render row styles" do
+    @report.process.style_cells('highlight', :only => :age) { |c, r| c == 32 }
+    html = Munger::Render::Html.new(@report).render
+    html.should have_tag('td.highlight')
+  end
+  
+  it "should render column styles"
+
+  it "should render default css if you ask" 
+
+end

data/spec/munger/render/text_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe Munger::Render::Text do 
+  include MungerSpecHelper
+  
+  before(:each) do 
+    @data = Munger::Data.new(:data => test_data)
+    @report = Munger::Report.new(:data => @data)
+  end
+
+  it "should accept a Munger::Report object" do
+    Munger::Render::Text.new(@report.process).should be_valid
+  end
+  
+  it "should render a basic text table" do
+    @render = Munger::Render::Text.new(@report.process)
+    count = @report.rows
+    text = @render.render
+    text.split("\n").should have_at_least(count).items
+  end
+  
+end

data/spec/munger/render_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Munger::Render do 
+  include MungerSpecHelper
+  
+  before(:each) do 
+    @data = Munger::Data.new(:data => test_data)
+    @report = Munger::Report.new(:data => @data).process
+  end
+
+  it "should render html" do
+    html = Munger::Render.to_html(@report)
+    html.should have_tag('table')
+  end
+  
+  it "should render text" do
+    text = Munger::Render.to_text(@report)
+    text.should_not have_tag('table')
+    text.split("\n").should have_at_least(5).items
+  end
+
+  it "should render xls"
+
+  it "should render csv"
+
+  it "should render pdf"
+  
+end

data/spec/munger/report_spec.rb

@@ -0,0 +1,155 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Munger::Report do 
+  include MungerSpecHelper
+  
+  before(:each) do 
+    @data = Munger::Data.new(:data => test_data)
+    @report = Munger::Report.new(:data => @data)
+  end
+
+  it "should accept a Munger::Data object" do
+    Munger::Report.new(:data => @data).should be_valid
+  end
+  
+  it "should accept a array of hashes" do
+    Munger::Report.new(:data => test_data).should be_valid
+    Munger::Report.new(:data => invalid_test_data).should_not be_valid
+  end
+
+  it "should be able to sort fields by array" do
+    @report.sort = 'name'
+    data = @report.process.process_data
+    data.map { |a| a[:data].name }[0, 4].join(',').should eql('Alice,Alice,Alice,Chaz')
+    
+    @report.sort = ['name', 'age']
+    data = @report.process.process_data
+    data.map { |a| a[:data].age }[0, 4].join(',').should eql('33,33,34,28')
+    
+    @report.sort = [['name', :asc], ['age', :desc]]
+    data = @report.process.process_data
+    data.map { |a| a[:data].age }[0, 4].join(',').should eql('34,33,33,28')
+  end
+
+  it "should be able to custom sort fields" do
+    @report.sort = [['name', Proc.new {|a, b| a[2] <=> b[2]} ]]
+    data = @report.process.process_data
+    data.map { |a| a[:data].name }[0, 4].join(',').should eql('Chaz,Rich,Alice,Alice')
+  end
+
+  it "should be able to order columns" do
+    @report.columns([:name, :age, :score])
+    @report.columns.should eql([:name, :age, :score])
+  end
+
+  it "should be able to alias column titles" do
+    titles = {:name => 'My Name', :age => 'The Age', :score => 'Super Score'}
+    @report.column_titles = titles
+    @report.column_titles.should eql(titles)
+  end
+  
+  it "should default to all columns" do
+    @report.columns.map { |c| c.to_s }.sort.join(',').should eql('age,day,name,score')
+  end
+
+
+  it "should be able to subgroup data" do
+    @report.sort('name').subgroup('name').process
+    @report.get_subgroup_rows.should have(6).items
+  end
+
+  it "should be able to add subgroup headers" do
+    @report.sort('score').subgroup('score', :with_headers => true)
+    @report.aggregate(:sum => :score).process
+    puts Munger::Render.to_text(@report)
+  end
+
+  it "should add the grouping name on the group line somewhere"
+  
+  it "should be able to subgroup in multiple dimensions"
+
+  it "should be able to aggregate columns into subgroup rows" do
+    @report.sort('name').subgroup('name').aggregate(:sum => :score).process
+    @report.get_subgroup_rows(1).should have(6).items
+    @report.get_subgroup_rows(0).should have(1).items
+    @report.get_subgroup_rows(0).first[:data][:score].should eql(151)
+  end
+  
+  it "should be able to aggregate multiple columns into subgroup rows" do
+    @report.sort('name').subgroup('name').aggregate(:sum => [:score, :age]).process
+    data = @report.get_subgroup_rows(0).first[:data]
+    data[:score].should eql(151)
+    data[:age].should eql(294)
+
+    @report.sort('name').subgroup('name').aggregate(:sum => :score, :average => :age).process
+    data = @report.get_subgroup_rows(0).first[:data]
+    data[:score].should eql(151)
+    data[:age].should eql(29)
+  end
+
+  it "should be able to aggregate with :average" do
+    @report.sort('name').subgroup('name').aggregate(:average => :score).process
+    @report.get_subgroup_rows(0).first[:data][:score].should eql(15)
+  end
+  
+  it "should be able to aggregate with :custom" do
+    @report.sort('name').subgroup('name')
+    @report.aggregate(Proc.new { |d| d.inject { |t, a| 2 * (t + a) } } => :score).process
+    @report.get_subgroup_rows(0).first[:data][:score].should eql(19508)
+  end
+
+  it "should be able to style cells" do
+    @report.process
+    @report.style_cells('highlight') { |c, r| c == 32 }
+    styles = @report.process_data.select { |r| r[:meta][:cell_styles] }
+    styles.should have(2).items
+  end
+
+  it "should be able to style cells in certain columns" do
+    @report.process
+    @report.style_cells('highlight', :only => :age) { |c, r| c == 32 }
+    @report.style_cells('big', :except => [:name, :day]) { |c, r| c.size > 2 }
+    styles = @report.process_data.select { |r| r[:meta][:cell_styles] }
+    styles.should have(10).items
+    
+    janet = @report.process_data.select { |r| r[:data].name == 'Janet' }.first
+    jstyles = janet[:meta][:cell_styles]
+    
+    jstyles[:age].sort.join(',').should eql('big,highlight')
+    jstyles[:score].should eql(["big"])
+  end
+  
+  it "should be able to style rows" do
+    @report.process
+    @report.style_rows('over_thirty') { |row| row.age > 29 }
+    @report.style_cells('highlight', :only => :age) { |c, r| c == 32 }
+    
+    janet = @report.process_data.select { |r| r[:data].name == 'Janet' }.first[:meta]
+    janet[:row_styles].should eql(["over_thirty"])
+    janet[:cell_styles].should have(1).item
+    janet[:cell_styles][:age].should eql(["highlight"])
+  end
+  
+  it "should know when it is processed" do
+    @report.should_not be_processed
+    @report.process
+    @report.should be_processed
+  end
+
+  it "should be able to style columns"
+    
+  it "should be able to attach formatting independent of content"
+  # so can format numbers without hurting ability to aggregate correctly
+  # or add hyperlinks using data from columns not being shown
+
+  it "should be able to add and retrieve column formatters" do
+    @report.column_formatters = {:name => :to_s}
+    @report.process
+    @report.column_formatters.should have(1).item
+    @report.column_formatter(:name).should eql(:to_s)
+  end
+  
+  it "should be able to aggregate rows into new column"
+  
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,106 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/munger")
+
+require 'rubygems'
+require 'spec'
+require 'fileutils'
+require 'logger'
+require 'pp'
+
+require 'rspec_hpricot_matchers'
+Spec::Runner.configure do |config|
+  config.include(RspecHpricotMatchers)
+end
+
+module MungerSpecHelper
+  def test_data
+    [{:name => 'Scott', :age => 23, :day => 1, :score => 12},
+     {:name => 'Chaz',  :age => 28, :day => 1, :score => 12},
+     {:name => 'Scott', :age => 23, :day => 2, :score => 1},
+     {:name => 'Janet', :age => 32, :day => 2, :score => 24},
+     {:name => 'Rich', :age => 32, :day => 2, :score => 14},
+     {:name => 'Gordon', :age => 33, :day => 1, :score => 21},
+     {:name => 'Scott', :age => 23, :day => 1, :score => 31},
+     {:name => 'Alice', :age => 33, :day => 1, :score => 12},
+     {:name => 'Alice', :age => 34, :day => 2, :score => 12},
+     {:name => 'Alice', :age => 33, :day => 2, :score => 12},
+      ]
+  end
+  
+  def more_test_data
+    [{:name => 'David', :age => 40, :day => 1, :score => 12},
+     {:name => 'Michael',  :age => 32, :day => 2, :score => 20},
+     {:name => 'David', :age => 40, :day => 2, :score => 13},
+     {:name => 'Michael',  :age => 28, :day => 1, :score => 15}]
+  end
+  
+  def invalid_test_data
+    ['one', 'two', 'three']
+  end
+  
+  def test_ar_data
+    test_data.map{|r| ARLike.new(r)}
+  end
+end
+
+  
+
+##
+# rSpec Hash additions.
+#
+# From 
+#   * http://wincent.com/knowledge-base/Fixtures_considered_harmful%3F
+#   * Neil Rahilly
+
+class Hash
+
+  ##
+  # Filter keys out of a Hash.
+  #
+  #   { :a => 1, :b => 2, :c => 3 }.except(:a)
+  #   => { :b => 2, :c => 3 }
+
+  def except(*keys)
+    self.reject { |k,v| keys.include?(k || k.to_sym) }
+  end
+
+  ##
+  # Override some keys.
+  #
+  #   { :a => 1, :b => 2, :c => 3 }.with(:a => 4)
+  #   => { :a => 4, :b => 2, :c => 3 }
+  
+  def with(overrides = {})
+    self.merge overrides
+  end
+
+  ##
+  # Returns a Hash with only the pairs identified by +keys+.
+  #
+  #   { :a => 1, :b => 2, :c => 3 }.only(:a)
+  #   => { :a => 1 }
+  
+  def only(*keys)
+    self.reject { |k,v| !keys.include?(k || k.to_sym) }
+  end
+
+end
+
+##
+# Gives us a hash that acts like an ActiveRecord dataset (sort of)
+#
+class ARLike
+  
+  attr_accessor :attributes
+  
+  def initialize(attributes)
+    @attributes = attributes
+  end
+  
+  def [](key)
+    attributes[key]
+  end
+  
+  def []=(key, value)
+    attributes[key] = value
+  end
+end