rapport 0.0.4

data/lib/rapport/report_generators/report_generator_csv.rb

@@ -0,0 +1,58 @@
+require 'zip/zip'
+require 'fastercsv'
+
+module Rapport
+  class ReportGeneratorCsv
+    include ReportGenerator
+
+    generate_with do |report|
+      if report.options[:to_string].nil?
+        FasterCSV.open(output_filename, 'w') {|csv| generate_internal(report, csv) }
+
+        zip_output_file! if report.options[:zip]
+    
+        output_filename
+      else
+        FasterCSV.generate {|csv| generate_internal(report, csv) }
+      end
+    end
+    
+    cell_format(:cents) do |value| 
+      !value.nil? && 
+      ("%.2f" % (value.to_s.to_d / '100'.to_d))
+    end
+    
+    cell_format(Time) do |value|
+      value.strftime('%B %e, %Y')
+    end
+    
+    cell_format(Date) do |value|
+      format_as(Time,Time.utc(value.year, value.month, value.day))
+    end
+
+    def zip_output_file!
+      zip_file_name = output_filename.sub(/(\.[^\.]*)?$/,'.zip')
+      Zip::ZipFile.open(zip_file_name, Zip::ZipFile::CREATE) do |zipfile|
+        zipfile.add(File.basename(output_filename),output_filename)
+      end
+      @output_filename = zip_file_name
+    end
+  
+    def report_name
+      report.table_name.sub('reports_','')
+    end
+    
+    private
+    
+    def self.generate_internal(report, csv)
+      i = 0
+      csv << report.column_headers
+      report.each_row do |row|
+        csv << row
+        Rapport.logger.debug(row.inspect) if i%1000==0
+        i+=1
+      end      
+    end
+
+  end
+end

data/lib/rapport/report_generators/report_generator_fake.rb

@@ -0,0 +1,16 @@
+module Rapport
+  class ReportGeneratorFake
+    include ReportGenerator
+
+    attr_accessor :output
+
+    generate_with do |report|
+      @output << report.column_headers
+      report.each_row do |row|
+        @output << row
+      end
+      @output
+    end
+
+  end
+end

data/lib/rapport.rb

@@ -0,0 +1,5 @@
+require 'helpers'
+require 'rapport/report'
+require 'rapport/report_generator'
+require 'rapport/report_generators/report_generator_fake'
+

data/lib/test.rb

@@ -0,0 +1,12 @@
+class Foo
+  instance_variable_set(:@hello, [1])
+  
+  def self.inherited(subclass)
+    subclass.instance_variable_set( :@hello, self.instance_variable_get(:@hello).dup )
+  end
+  
+  def self.hello
+    @hello
+  end
+  
+end

data/rapport.gemspec

@@ -0,0 +1,88 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rapport}
+  s.version = "0.0.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Andrew Wheeler}]
+  s.date = %q{2012-01-10}
+  s.description = %q{Allows you to create tablular reports and output them to various formats interchangeably.}
+  s.email = %q{andrew.wheeler@bookrenter.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".tmtags",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/helpers.rb",
+    "lib/load_rapport.rb",
+    "lib/rapport.rb",
+    "lib/rapport/report.rb",
+    "lib/rapport/report_generator.rb",
+    "lib/rapport/report_generators/report_generator_csv.rb",
+    "lib/rapport/report_generators/report_generator_fake.rb",
+    "lib/test.rb",
+    "rapport.gemspec",
+    "test/logs/test.log",
+    "test/rapport/report_generator_test.rb",
+    "test/rapport/report_generators/report_generator_csv_test.rb",
+    "test/rapport/report_test.rb",
+    "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/jawheeler/rapport}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{Rapport Reporting}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rake>, ["= 0.8.7"])
+      s.add_development_dependency(%q<shoulda>, ["~> 2.11.3"])
+      s.add_development_dependency(%q<mocha>, ["= 0.9.8"])
+      s.add_development_dependency(%q<shared_should>, ["= 0.8.1"])
+      s.add_development_dependency(%q<always_execute>, ["= 0.0.2"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<rubyzip>, ["= 0.9.5"])
+      s.add_development_dependency(%q<fastercsv>, ["= 1.5.1"])
+    else
+      s.add_dependency(%q<rake>, ["= 0.8.7"])
+      s.add_dependency(%q<shoulda>, ["~> 2.11.3"])
+      s.add_dependency(%q<mocha>, ["= 0.9.8"])
+      s.add_dependency(%q<shared_should>, ["= 0.8.1"])
+      s.add_dependency(%q<always_execute>, ["= 0.0.2"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<rubyzip>, ["= 0.9.5"])
+      s.add_dependency(%q<fastercsv>, ["= 1.5.1"])
+    end
+  else
+    s.add_dependency(%q<rake>, ["= 0.8.7"])
+    s.add_dependency(%q<shoulda>, ["~> 2.11.3"])
+    s.add_dependency(%q<mocha>, ["= 0.9.8"])
+    s.add_dependency(%q<shared_should>, ["= 0.8.1"])
+    s.add_dependency(%q<always_execute>, ["= 0.0.2"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<rubyzip>, ["= 0.9.5"])
+    s.add_dependency(%q<fastercsv>, ["= 1.5.1"])
+  end
+end
+

data/test/logs/test.log

@@ -0,0 +1,6 @@
+I, [2012-01-10T11:15:14.417199 #688]  INFO -- : Generating Rapport::TestReport csv...
+D, [2012-01-10T11:15:14.418053 #688] DEBUG -- : [0, "T0 0", "Formatted~0", "~0~0"]
+I, [2012-01-10T11:15:14.419484 #688]  INFO -- : Generated Rapport::TestReport csv.
+I, [2012-01-10T11:15:14.419983 #688]  INFO -- : Generating Rapport::TestReport csv...
+D, [2012-01-10T11:15:14.420228 #688] DEBUG -- : [0, "T0 0", "Formatted~0", "~0~0"]
+I, [2012-01-10T11:15:14.421822 #688]  INFO -- : Generated Rapport::TestReport csv.

data/test/rapport/report_generator_test.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ReportTest < Test::Unit::TestCase
+  setup do
+    @report = Rapport::TestReport.new(:format => 'test')
+    @report_generator = @report.report_generator
+  end
+  
+  context "ReportGenerator.generate_with" do
+    setup do
+      @class = Class.new
+      @class.send(:include, Rapport::ReportGenerator)
+      @proc = lambda { 'hello' }
+    end
+    
+    execute do
+      proc = @proc
+      @class.class_eval do
+        generate_with do
+          proc.call
+        end
+      end
+    end
+    
+    should "define #generate" do
+      assert @class.public_method_defined?(:generate)
+    end
+    
+    should "produce #generate with logging that returns whatever the generate_with block returns" do
+      rg = @class.new
+      rg.report = Rapport::TestReport.new
+      Logger.any_instance.expects(:info).twice
+      assert_equal 'hello', rg.generate
+    end
+    
+    context "error handling" do
+      setup do
+        @proc = lambda { @report.current_model = 'current_model'; raise "Boom!" }
+      end
+      
+      should "log the current model" do
+        rg = @class.new
+        rg.report = @report = Rapport::TestReport.new
+        @error = ''
+        Logger.any_instance.expects(:info)
+        Logger.any_instance.expects(:error).with{|message| @error = message }
+        rg.generate
+        assert_match /current_model/, @error
+        assert_match /#{@report}/, @error
+      end
+    end
+    
+  end
+  
+  context "cell formatter" do
+    setup do
+      @cf = @report_generator.cell_formatter
+    end
+
+    context ".dup" do
+      setup do
+        @cf.add_cell_format(:test) {|value| "Test#{value}" }
+        @dup = @cf.dup
+      end
+      
+      should "inherit procs from parent" do
+        assert_equal "TestMe", @dup.format(:test, "Me")
+      end
+      
+      should "added cell formats should not affect parent" do
+        @dup.add_cell_format(:dup_test) {|value| "Dup#{value}"}
+        assert_equal "DupMe", @dup.format(:dup_test, "Me")
+        assert_equal "Me", @cf.format(:dup_test, "Me")
+      end
+      
+      should "overridden cell formats should not affect parent" do
+        @dup.add_cell_format(:test) {|value| "DupTest#{value}" }
+        assert_equal "DupTestMe", @dup.format(:test, "Me")
+        assert_equal "TestMe", @cf.format(:test, "Me")        
+      end
+    end
+    
+    context ".add_cell_format" do
+      setup do
+        @proc = Proc.new {|x| "Test#{x}" } 
+      end
+      
+      execute do
+        @cf.add_cell_format(@type, &@proc)
+      end
+      
+      share_should("format for symbol") do
+        assert_equal "TestMe", @cf.format(:string, "Me")
+      end
+      
+      share_should("format for class") do
+        assert_equal "TestMe", @cf.format(nil, "Me")
+      end
+      
+      use_should("format for symbol").when("symbol type") do
+        @type = :string       
+      end
+      
+      context "symbol type" do
+        setup do
+          @type = String
+        end
+
+        use_should("format for symbol")
+        use_should("format for class")
+      end
+    end
+    
+    context ".format" do
+      setup do
+        @value = "Me"
+      end
+      
+      execute do
+        @cf.format(@type, @value)
+      end
+      
+      share_should "return value" do
+        assert_equal @value, @execute_result
+      end
+      
+      context "type is a proc" do
+        setup do
+          @type = lambda{|v| "Lambda#{v}" }
+        end
+        
+        should "call the lambda" do
+          assert_equal "LambdaMe", @execute_result
+        end
+      end
+      
+      context "type has been added" do
+        setup do
+          @type = :happy
+        end
+        
+        should "format happily" do
+          assert_equal "HappyMe", @execute_result
+        end
+      end
+      
+      use_should("return value").when("type has not been added") do
+        @type = :sad
+      end
+      
+      use_should("return value").when("type is nil") do
+        @type = nil
+      end 
+    end
+  end
+end
+  

data/test/rapport/report_generators/report_generator_csv_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'rapport/report_generators/report_generator_csv'
+
+class ReportTest < Test::Unit::TestCase
+  setup do
+    @rg_csv = Rapport::ReportGeneratorCsv.new
+  end
+  
+  context "cell_format Time" do
+    setup do
+      @time = Time.new
+    end
+    
+    execute do
+      @rg_csv.format(Time, @time)
+    end
+  
+    should "format as a string" do
+      assert_equal @time.strftime('%B %e, %Y'), @execute_result
+    end
+  end
+  
+  
+  context "cell_format Date" do
+    setup do
+      @date = Date.new
+    end
+    
+    execute do
+      @rg_csv.format(Date, @date)
+    end
+    
+    should "format the date as a time" do
+      assert_equal Time.utc(@date.year, @date.month, @date.day ).strftime('%B %e, %Y'), @execute_result
+    end
+  end
+  
+  context ".generate" do
+    setup do
+      @report = Rapport::TestReport.new(:format => 'csv', :to_string => true)
+    end
+    
+    execute do
+      @report.generate
+    end
+    
+    should "write the header" do
+      assert_match "Column 0,Column 1,Column 2,Column 3\n", @execute_result
+    end
+    
+    should "write rows" do
+      assert_match "1,T0 2,Formatted~2,~2~1\n", @execute_result
+      assert_match "1,T1 3,Formatted~3,~3~1\n", @execute_result
+    end
+  end
+end

data/test/rapport/report_test.rb

@@ -0,0 +1,253 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ReportTest < Test::Unit::TestCase
+  setup do
+    @report = Rapport::TestReport.new
+  end
+  
+  context ".each_row" do
+    execute do
+      execute_result = []
+      @report.each_row {|row| execute_result << row}
+      execute_result
+    end
+  
+    should "return a row for each raw row" do
+      raw_rows = []
+      @report.each_model {|row, type| raw_rows << row}
+      assert_equal raw_rows.length, @execute_result.length
+    end
+  
+    should "return formatted rows" do
+      assert_match /Formatted/, @execute_result[0][2]
+    end
+  end
+  
+  context ".column_headers" do
+    execute do
+      @report.column_headers
+    end
+  
+    should "return column headers only" do
+      @execute_result.each do |column_header|
+        assert_match /Column/, column_header
+      end
+    end
+  end
+  
+  context ".column_symbols" do
+    execute do
+      @report.column_symbols
+    end
+  
+    should "return symbols only" do
+      @execute_result.each do |column_symbol|
+        assert_match /calc/, column_symbol.to_s
+      end
+    end
+  end
+  
+  context ".table_name" do
+    should "return a configured table name" do
+      @report.options[:report_table_name] = 'llama'
+      assert_equal 'llama', @report.table_name
+    end
+  
+    should "return a table name based on the reports actual class if :report_class isn't configured" do
+      assert_equal 'reports_rapport_test', @report.table_name
+    end
+  
+  end
+  
+  context ".cell_calculator_for" do
+  
+    setup do
+      @lambda = lambda{ 'hi' }
+    end
+  
+    execute do
+      @report.bypass._calculators[:key] = @cell_calculator
+      @report.bypass.cell_calculator_for(:key, :row_type)
+    end
+  
+    share_setup("with :through") do
+      @cell_calculator[:through] = :child
+    end      
+  
+    share_should("return a proc") do
+      assert @execute_result.respond_to?(:call)
+    end
+  
+    share_should "return the lambda" do
+      assert_equal @lambda, @execute_result
+    end
+  
+    share_should "wrap the lambda" do
+      assert_equal 'hi', @execute_result.call(Struct.new(:child).new)
+    end
+  
+    share_should("return a proc sending") do |symbols|
+      model = mock('model')
+      symbols = [symbols] if symbols.is_a?(Symbol)
+      symbols.each do |symbol|
+        model.expects(symbol).returns(model)
+      end
+      @execute_result.call(model)
+    end     
+  
+    share_should("return a proc never sending") do |symbols|
+      model = mock('model')
+      symbols = [symbols] if symbols.is_a?(Symbol)
+      symbols.each do |symbol|
+        model.expects(symbol).never
+      end
+      @execute_result.call(model)
+    end      
+  
+    context "explicit row type with lambda" do
+      setup do
+        @cell_calculator = {
+          :row_type => @lambda
+        }
+      end
+    
+      use_should("return the lambda")
+      use_setup("with :through").use_should("return the lambda")
+    end
+  
+    context "explicit row type with symbol" do
+      setup do
+        @cell_calculator = {
+          :row_type => :foo
+        }
+      end
+    
+      use_should("return a proc sending").given("method"){ :foo }
+          
+      use_setup("with :through").context do
+        use_should("return a proc sending").given("method"){ :foo }
+        use_should("return a proc never sending").given("through"){ :child }
+      end
+    end
+  
+    context "map_to with lambda" do
+      setup do
+        @cell_calculator = {
+          :map_to => @lambda
+        }
+      end
+    
+      use_should("wrap the lambda")
+    
+      use_setup("with :through").context do
+        use_should("return a proc sending").given("through"){ :child }
+        use_should("wrap the lambda")
+      end
+    end
+  
+    context "map_to with symbol" do
+      setup do
+        @cell_calculator = {
+          :map_to => :foo
+        }
+      end
+    
+      use_should("return a proc")
+      use_should("return a proc sending").given("method"){ :foo }
+    
+      use_setup("with :through").use_should("return a proc sending").given("through and method"){ [:child, :foo] }
+  
+    end
+  
+    context "through list" do
+      setup do
+        @cell_calculator = {
+          :through => [:first, :second]
+        }
+      end
+    
+      should "work for a model with first and second" do
+        model = mock
+        first_model = mock
+        second_model = mock
+        model.expects(:first).returns(first_model)
+        first_model.expects(:second).returns(second_model)
+        second_model.expects(:key)
+        @execute_result.call(model)
+      end
+    
+      should "work for a model with only first" do
+        model = mock
+        first_model = mock
+        model.expects(:first).returns(first_model)
+        first_model.expects(:key)
+        @execute_result.call(model)
+      end
+    
+      should "use second if model returns nil for first" do
+        model = mock
+        second_model = mock
+        model.expects(:first).returns(nil)
+        model.expects(:second).returns(second_model)
+        second_model.expects(:key)
+        @execute_result.call(model)
+      end
+    
+      should "work for a model with only second" do
+        model = mock
+        second_model = mock
+        model.expects(:second).returns(second_model)
+        second_model.expects(:key)
+        @execute_result.call(model)
+      end
+    
+      should "work for a model with neither" do
+        model = mock
+        model.expects(:key)
+        @execute_result.call(model)
+      end
+    end
+  end # end .cell_calculator_for
+  
+  context ".safe_proc" do
+    setup do
+      @orig_proc = lambda{|m| m.foo }
+    end
+       
+    execute do
+      @proc = Rapport.safe_proc(@orig_proc)
+      @proc.call(@model)
+    end
+  
+    use_should("return nil").when("model doesn't respond correctly") { @model = Struct.new(:no_foo).new('happy') }
+  
+    context "nil model" do
+      setup do
+        @model = nil
+      end
+    
+    
+      use_should("return nil").when("unhappy proc")
+    
+      context "happy proc" do
+        setup do
+          @orig_proc = lambda { 'happy' }
+        end
+      
+        should "be happy" do
+          assert_equal 'happy', @execute_result
+        end          
+      end
+    end
+  
+    context "happy model" do
+      setup do
+        @model = Struct.new(:foo).new('happy')
+      end
+    
+      should "be happy" do
+        assert_equal 'happy', @execute_result
+      end
+    end
+  end
+end