kbaum-munger 0.1.4

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,140 @@
+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 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
+
+  # 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 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 "(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,148 @@
+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 aggregate rows into new column"
+  
+  
+end