crosstab 0.1.0

data/lib/crosstab/table.rb

@@ -0,0 +1,85 @@
+class Crosstab::Table < Crosstab::Generic
+  # Pass in a block and we'll execute it within the context of this class.
+  # 
+  # Example:
+  # 
+  #   my_crosstab = Crosstab.new do
+  #     table do
+  #       row "Male", :a => 1
+  #       row "Female", :a => 2
+  #     end
+  #   end
+  #   
+  def initialize(&block)
+    instance_eval(&block) if block
+  end
+
+  # attr_reader for the rows attribute which should contain an empty array, or a list of rows
+  # 
+  # Example: 
+  # 
+  #   rows
+  #   #=> []
+  #
+  #   row "Male", :a => 1
+  # 
+  #   rows
+  #   #=> [Crosstab::Row...]
+  #   
+  def rows
+    @rows ||= []
+  end
+  
+  # Creates a new Crosstab::Row and appends it to the rows array.
+  # 
+  # Example: 
+  # 
+  #   rows
+  #   #=> []
+  #
+  #   row "Male", :a => 1
+  # 
+  #   rows
+  #   #=> [Crosstab::Row...]
+  # 
+  def row(name,qualification)
+    rows << Crosstab::Row.new(name, qualification)
+  end  
+  
+  # DSL child setter, creates a new Group, and rows created within its block will be assigned to that group.
+  # 
+  # Example: 
+  # 
+  #   rows
+  #   #=> []
+  #
+  #   group "Gender" do
+  #     row "Male", :a => 1
+  #     row "Female", :a => 2
+  #   end
+  # 
+  #   rows
+  #   #=> [Crosstab::Row..., Crosstab::Row...]
+  #   
+  #   rows[0].group.title
+  #   # => "Gender"
+  # 
+  #   rows[1].group.title
+  #   # => "Gender"
+  
+  def group(name=nil, &block)
+    if block
+      old_rows = rows.dup # Save current state
+
+      instance_eval(&block) # Execute block within current scope
+
+      g = Crosstab::Group.new(name) # Create new group
+      
+      # Set group for all of the new rows
+      (rows - old_rows).each do |row|
+        row.group g 
+      end
+    end
+  end
+  
+end

data/test/test_banner.rb

@@ -0,0 +1,81 @@
+$LOAD_PATH.unshift "../lib" if __FILE__ == $0
+
+require 'test/unit'
+require 'crosstab'
+
+class BannerTests < Test::Unit::TestCase
+  def setup
+    @banner = Crosstab::Banner.new
+  end
+  
+  # Responds to these public methods
+  def test_respond_methods
+    [:title, :qualification, :qualifies?, :columns, :column, :group].each do |method|
+      assert_respond_to @banner, method, "Hey, an instantiated banner should have a `#{method}` method."
+    end
+  end
+
+  # Test defaults for reader methods 
+  def test_default_columns
+    assert_kind_of Array, @banner.columns
+
+    # Should have a total column by default
+    assert_equal 1, @banner.columns.length
+    assert_kind_of Crosstab::Column, @banner.columns.first
+    assert_equal "Total", @banner.columns.first.title
+    assert_equal true, @banner.columns.first.qualifies?(Hash.new)
+  end
+  
+  def test_default_title
+    assert_nil @banner.title
+  end
+  
+  def test_default_qualifies?
+    assert_equal true, @banner.qualifies?(Hash.new)
+  end
+  
+  # Test behavior of setter methods
+  def test_set_title
+    @banner.title "Test Title"
+    assert_equal "Test Title", @banner.title  
+  end
+  
+  def test_set_qualification   
+    @banner.qualification :a => 1
+    
+    assert_equal true, @banner.qualifies?(:a => 1, :b => 1)
+    assert_equal false, @banner.qualifies?(:a => 2, :b => 1)
+  end
+  
+  def test_set_column
+    # erase the default column
+    @banner.columns.pop           
+    
+    @banner.column "New Column", :a => 2
+    
+    assert_equal 1, @banner.columns.length
+    assert_kind_of Crosstab::Column, @banner.columns.first
+    assert_equal "New Column", @banner.columns.first.title
+  end
+
+  def test_set_group
+    # erase the default column
+    @banner.columns.pop           
+    
+    @banner.group "Gender" do
+      column "Male", :a => 1
+      column "Female", :a => 2
+    end
+    
+    assert_equal 2, @banner.columns.length
+    assert_kind_of Crosstab::Column, @banner.columns.first
+    assert_kind_of Crosstab::Column, @banner.columns.last
+    
+    assert_equal "Male", @banner.columns.first.title
+    assert_equal "Female", @banner.columns.last.title    
+    
+    assert_equal "Gender", @banner.columns.first.group.title
+    assert_equal "Gender", @banner.columns.last.group.title
+  end
+end
+

data/test/test_cell.rb

@@ -0,0 +1,95 @@
+$LOAD_PATH.unshift "../lib" if __FILE__ == $0
+
+require 'test/unit'
+
+class TestCrosstabCell < Test::Unit::TestCase
+  def setup
+    @cell = Crosstab::Cell.new
+  end
+  
+  # Responds to these public methods
+  def test_respond_methods
+    [:base, :frequency, :percentage, :result, :significant_against?, :column].each do |method|
+      assert_respond_to @cell, method, "Hey, an instantiated cell should have a `#{method}` method."
+    end
+  end
+
+  # Test defaults for reader methods  
+  def test_default_base
+    assert_equal 0, @cell.base
+  end
+  
+  def test_default_frequency
+    assert_equal 0, @cell.frequency
+  end
+  
+  def test_default_percentage
+    assert_equal 0, @cell.percentage
+  end
+  
+  def test_default_result
+    assert_equal ["--"], @cell.result
+  end
+
+  def test_normal_result
+    @cell.base 100
+    @cell.frequency 75
+    
+    assert_equal [75, "75%"], @cell.result
+  end
+
+  def test_zero_frequency_result
+    @cell.base 100
+    @cell.frequency 0
+    
+    assert_equal ["--"], @cell.result
+  end
+
+  # Test behavior of setter methods
+  def test_set_base
+    @cell.base 999
+    assert_equal 999, @cell.base
+  end
+  
+  def test_set_frequency
+    @cell.frequency 999
+    assert_equal 999, @cell.frequency
+  end
+  
+  def test_default_column
+    assert_equal nil, @cell.column
+  end
+  
+  def test_set_column
+    column = Crosstab::Column.new
+    @cell.column column
+    assert_equal column, @cell.column
+  end
+  
+  def test_alternate_initialization
+    cell = Crosstab::Cell.new :frequency => 2, :base => 4
+    
+    assert_equal 2, cell.frequency
+    assert_equal 4, cell.base
+  end
+  
+  # Test behavior of complex methods
+  def test_percentage
+    @cell.base 100
+    @cell.frequency 75
+    
+    assert_equal 0.75, @cell.percentage
+  end
+    
+  def test_significant_against
+    @cell.base 100
+    @cell.frequency 50
+    
+    @test_cell_a = Crosstab::Cell.new :base => 100, :frequency => 63
+    @test_cell_b = Crosstab::Cell.new :base => 100, :frequency => 64
+    
+    assert_equal false, @test_cell_a.significant_against?(@cell) #63/100 against 50/100 is not significant at a 95% confidence level
+    assert_equal true, @test_cell_b.significant_against?(@cell)  #64/100 against 50/100, however, is.
+  end
+  
+end

data/test/test_column.rb

@@ -0,0 +1,60 @@
+$LOAD_PATH.unshift "../lib" if __FILE__ == $0
+
+require 'test/unit'
+
+
+class ColumnTests < Test::Unit::TestCase
+  def setup
+    @column = Crosstab::Column.new
+  end
+  
+  # Responds to these public methods
+  def test_respond_method
+    [:title, :qualification, :qualifies?, :records, :group].each do |method|
+      assert_respond_to @column, method, "Hey, an instantiated column should have a `#{method}` method."
+    end
+  end
+
+  # Test defaults for reader methods  
+  def test_default_title
+    assert_nil @column.title
+  end
+  
+  def test_default_qualifies?
+    assert_equal true, @column.qualifies?(Hash.new)
+  end
+
+  def test_default_records
+    assert_equal [], @column.records
+  end  
+  
+  def test_default_group
+    assert_equal nil, @column.group
+  end
+  
+  # Test behavior of setter methods
+  def test_set_title
+    @column.title "Test Title"
+    assert_equal "Test Title", @column.title  
+  end
+  
+  def test_set_qualification   
+    @column.qualification :a => 1
+    
+    assert_equal true, @column.qualifies?(:a => 1, :b => 1)
+    assert_equal false, @column.qualifies?(:a => 2, :b => 1)
+  end
+  
+  def test_set_records
+    record = {:a => 1}
+    
+    @column.records [record]
+    assert_equal [record], @column.records
+  end
+  
+  def test_set_group
+    @column.group Crosstab::Group.new("Group Title")
+    assert_equal "Group Title", @column.group.title    
+    assert_equal [ @column ], @column.group.children
+  end
+end

data/test/test_crosstab.rb

@@ -0,0 +1,214 @@
+$LOAD_PATH.unshift "../lib" if __FILE__ == $0
+
+require 'test/unit'
+require 'crosstab'
+
+class CrosstabTests < Test::Unit::TestCase
+  def setup
+    # Minimal crosstab for most tests
+    @crosstab = Crosstab::Crosstab.new
+    
+    # Complex crosstab for calculation tests
+    @calculated_crosstab = Crosstab::Crosstab.new do
+      data_source [{:a => 1, :b => 1, :c => 1},
+                   {:a => 1, :b => 2, :c => 2},
+                   {:a => 1, :b => 2, :c => 4}]
+      
+      banner do
+        column "Total"
+        group "Gender" do
+          column "Male", :a => 1
+          column "Female", :a => 2
+        end
+      end
+      
+      table do
+        title "Q.A Gender" 
+        row "Male", :a => 1
+        row "Female", :a => 2
+      end
+      
+      table do
+        title "Q.B Age"
+        row "18-34", :b => 1
+        row "35-54", :b => 2
+      end
+      
+      table do
+        title "Q.C Likelihood of purchasing"
+
+        group "Very/somewhat likely (Net)" do
+          row "Very likely", :c => 1
+          row "Somewhat likely", :c => 2
+        end
+        
+        group "Very/somewhat unlikely (Net)" do
+          row "Somewhat unlikely", :c => 3
+          row "Very unlikely", :c => 4
+        end
+      end
+    end
+    @calculated_crosstab.calculate    
+  end
+  
+  # Responds to these public methods
+  def test_respond_methods
+    [:data_source, :calculate, :title, :qualification, 
+     :qualifies?, :banner, :table, :tables, :printed?].each do |method|
+      assert_respond_to @crosstab, method, "Hey an instantiated crosstab should have a `#{method}` method."
+    end
+  end
+  
+  # Test defaults for reader methods 
+  def test_default_data_source
+    assert_equal [], @crosstab.data_source, "By default, `data_source` is supposed to respond with an empty array."
+  end
+  
+  def test_default_title
+    assert_nil @crosstab.title, "By default, `title` is supposed to be nil"
+  end
+
+  def test_default_qualifies?
+    record = Hash.new
+    
+    assert(@crosstab.qualifies?(record), "By default, `qualifies?` is supposed to respond with true.")
+  end
+  
+  def test_default_banner
+    assert_kind_of Crosstab::Banner, @crosstab.banner, "By default, `banner` is supposed to respond with a Crosstab::Banner kind of object.  The user shouldn't have to define their own unless they want more than a total column."    
+  end
+
+  def test_default_tables
+    assert_equal [], @crosstab.tables, "By default, `tables` is supposed to respond with an empty array."
+  end
+  
+  def test_default_printed?
+    assert_equal false, @crosstab.printed?
+  end
+   
+  # Test behavior of setter methods
+  def test_set_data_source
+    test_data = [{:a => 1}, {:a => 2}]
+    
+    @crosstab.data_source test_data    
+    assert_equal test_data, @crosstab.data_source, "`data_source [{:a => 1}, {:a => 2}]` is supposed to respond with the same thing it was set with."
+  end
+
+  def test_set_title
+    @crosstab.title "Test Title"
+    assert_equal "Test Title", @crosstab.title  
+  end
+  
+  def test_set_qualification
+    @crosstab.qualification :a => true
+    
+    assert_equal true, @crosstab.qualifies?({:a => true}), "`qualification :a => true` should redefine `qualifies?` so that it returns true on `qualifies? {:a => true}`"
+    assert_equal false, @crosstab.qualifies?({:a => false}), "`qualification :a => true` should redefine `qualifies?` so that it returns false on `qualifies? {:a => false}`"
+  end
+  
+  def test_set_banner
+    old_banner = @crosstab.banner
+    @crosstab.banner do
+      # empty on purpose
+    end
+    
+    assert_not_same old_banner, @crosstab.banner, "`banner` should create a new banner.  It didn't.  It still has the same ID."
+  end
+  
+  def test_set_table
+    @crosstab.table do
+      # empty on purpose
+    end
+    
+    assert_equal 1, @crosstab.tables.length, "`table {}` should push a new table onto `tables`. `tables` should now have a length of 1."
+    assert_kind_of Crosstab::Table, @crosstab.tables.first, "`table {}` should push a new Crosstab::Table object onto `tables`.  It didn't."
+  end
+  
+  def test_set_printed?
+    @crosstab.printed? true
+    assert_equal true, @crosstab.printed?
+  end
+
+  # Test the post-calculation methods
+  def test_calculate_adds_cells    
+    columns = @calculated_crosstab.banner.columns
+    rows = @calculated_crosstab.tables[0].rows
+    
+    assert_equal true, rows.all? { |row| row.cells.length == columns.length }, "Each row should have a number of cells equal to the number of columns in the banner."
+  end
+      
+  def test_calculate_cells_make_sense    
+   
+    tables = []
+
+    tables << []
+    tables.last << [{:frequency => 3, :base => 3},
+                    {:frequency => 3, :base => 3},
+                    {:frequency => 0, :base => 0}] # Male
+
+    tables.last << [{:frequency => 0, :base => 3},
+                    {:frequency => 0, :base => 3},
+                    {:frequency => 0, :base => 0}] # Female
+
+    tables << []
+    tables.last << [{:frequency => 1, :base => 3},
+                    {:frequency => 1, :base => 3},
+                    {:frequency => 0, :base => 0}] # 18-34
+    tables.last << [{:frequency => 2, :base => 3},
+                    {:frequency => 2, :base => 3},
+                    {:frequency => 0, :base => 0}] # 35+
+    
+    tables << []
+    tables.last << [{:frequency => 1, :base => 3},
+                    {:frequency => 1, :base => 3},
+                    {:frequency => 0, :base => 0}] # Very likely
+    tables.last << [{:frequency => 1, :base => 3},
+                    {:frequency => 1, :base => 3},
+                    {:frequency => 0, :base => 0}] # Somewhat likely
+    tables.last << [{:frequency => 0, :base => 3},
+                    {:frequency => 0, :base => 3},
+                    {:frequency => 0, :base => 0}] # Somewhat unlikely
+    tables.last << [{:frequency => 1, :base => 3},
+                    {:frequency => 1, :base => 3},
+                    {:frequency => 0, :base => 0}] # Very unlikely                        
+
+    tables.each_with_index do |table, table_index|
+      table.each_with_index do |row, row_index|
+        row.each_with_index do |cell, cell_index|
+          cell.each do |method,value|
+            assert_equal value, @calculated_crosstab.
+                                 tables[table_index].
+                                     rows[row_index].
+                                   cells[cell_index].
+                                     send(method), "for @calculated_crosstab.tables[#{table_index}].rows[#{row_index}].cells[#{cell_index}].send(#{method.inspect})"
+          end
+        end
+      end
+    end
+  end
+
+  def test_calculate_groups        
+    groups = []
+    groups << [{:frequency => 2, :base => 3},
+               {:frequency => 2, :base => 3},
+               {:frequency => 0, :base => 0}] # Very//somewhat likely
+    groups << [{:frequency => 1, :base => 3},
+               {:frequency => 1, :base => 3},
+               {:frequency => 0, :base => 0}] # Somewhat unlikely
+
+    groups.each_with_index do |row, index|
+      row.each_with_index do |cell, cell_index|
+        cell.each do |method, value|
+          # index + 1 is a cheat for referencing rows 1 & 2 which both have two different groups.
+          assert_equal value, 
+                      @calculated_crosstab.tables[2].rows[index + 1].group.cells[cell_index].send(method)  
+        end
+      end
+    end 
+  end
+  
+  def test_add_tests_for_to_s
+    assert false
+  end
+  
+end