rapport 0.0.4

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.tmtags

@@ -0,0 +1,96 @@
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR	Darren Hiebert	/dhiebert@users.sourceforge.net/
+!_TAG_PROGRAM_NAME	Exuberant Ctags	//
+!_TAG_PROGRAM_URL	http://ctags.sourceforge.net	/official site/
+!_TAG_PROGRAM_VERSION	5.7	//
+Bypass	test/test_helper.rb	/^  class Bypass$/;"	class	line:22
+CellFormatter	lib/rapport/report_generator.rb	/^  class CellFormatter$/;"	class	line:89
+ClassMethods	lib/rapport/report.rb	/^    module ClassMethods$/;"	module	line:15
+ClassMethods	lib/rapport/report_generator.rb	/^    module ClassMethods$/;"	module	line:20
+Foo	lib/test.rb	/^class Foo$/;"	class	line:1
+Object	test/test_helper.rb	/^class Object$/;"	class	line:21
+Rapport	lib/helpers.rb	/^module Rapport$/;"	module	line:1
+Rapport	lib/rapport/report.rb	/^module Rapport$/;"	module	line:1
+Rapport	lib/rapport/report_generator.rb	/^module Rapport$/;"	module	line:3
+Rapport	lib/rapport/report_generators/report_generator_csv.rb	/^module Rapport$/;"	module	line:3
+Rapport	lib/rapport/report_generators/report_generator_fake.rb	/^module Rapport$/;"	module	line:1
+Rapport	test/test_helper.rb	/^module Rapport$/;"	module	line:47
+Report	lib/rapport/report.rb	/^  module Report$/;"	module	line:2
+ReportGenerator	lib/rapport/report_generator.rb	/^  module ReportGenerator$/;"	module	line:4
+ReportGeneratorCsv	lib/rapport/report_generators/report_generator_csv.rb	/^  class ReportGeneratorCsv$/;"	class	line:4
+ReportGeneratorFake	lib/rapport/report_generators/report_generator_fake.rb	/^  class ReportGeneratorFake$/;"	class	line:2
+ReportGeneratorTest	test/test_helper.rb	/^  class ReportGeneratorTest$/;"	class	line:79
+ReportTest	test/rapport/report_generator_test.rb	/^class ReportTest < Test::Unit::TestCase$/;"	class	line:3
+ReportTest	test/rapport/report_test.rb	/^class ReportTest < Test::Unit::TestCase$/;"	class	line:3
+Test	build/test/helper.rb	/^class Test::Unit::TestCase$/;"	class	line:17
+Test	test/test_helper.rb	/^class Test::Unit::TestCase$/;"	class	line:41
+TestBuild	build/test/test_build.rb	/^class TestBuild < Test::Unit::TestCase$/;"	class	line:3
+TestReport	test/test_helper.rb	/^  class TestReport$/;"	class	line:48
+_calculators	lib/rapport/report.rb	/^    def _calculators$/;"	method	line:120
+add_calculator	lib/rapport/report.rb	/^      def add_calculator(symbol, options)$/;"	method	line:34
+add_cell_format	lib/rapport/report_generator.rb	/^    def add_cell_format(type, &block)$/;"	method	line:99
+base_calculator	lib/rapport/report.rb	/^    def base_calculator(key, calculator)$/;"	method	line:157
+bypass	test/test_helper.rb	/^  def bypass$/;"	method	line:36
+cell_calculator_for	lib/rapport/report.rb	/^    def cell_calculator_for(key,row_type)$/;"	method	line:124
+cell_format	lib/rapport/report_generator.rb	/^      def cell_format(type, &block)$/;"	method	line:48
+cell_format_for	lib/rapport/report.rb	/^    def cell_format_for(key)$/;"	method	line:166
+cell_formatter	lib/rapport/report_generator.rb	/^    def cell_formatter$/;"	method	line:59
+column	lib/rapport/report.rb	/^      def column(*args, &block)$/;"	method	line:16
+column_headers	lib/rapport/report.rb	/^    def column_headers$/;"	method	line:68
+column_symbols	lib/rapport/report.rb	/^    def column_symbols$/;"	method	line:72
+columns	lib/rapport/report.rb	/^    def columns$/;"	method	line:60
+dup	lib/rapport/report_generator.rb	/^    def dup$/;"	method	line:95
+each_model	lib/rapport/report.rb	/^    def each_model(&block)$/;"	method	line:105
+each_model	test/test_helper.rb	/^    def each_model$/;"	method	line:55
+each_row	lib/rapport/report.rb	/^    def each_row$/;"	method	line:53
+each_row	lib/rapport/report_generator.rb	/^    def each_row$/;"	method	line:79
+format	lib/rapport/report_generator.rb	/^    def format(type, value)$/;"	method	line:63
+format	lib/rapport/report_generator.rb	/^    def format(type,value)$/;"	method	line:111
+format for class	test/rapport/report_generator_test.rb	/^      share_should("format for class") do$/;"	shared_should	line:96
+format for symbol	test/rapport/report_generator_test.rb	/^      share_should("format for symbol") do$/;"	shared_should	line:92
+format_camel_case	lib/helpers.rb	/^    def format_camel_case(value)$/;"	method	line:22
+format_underscore	lib/helpers.rb	/^    def format_underscore(value)$/;"	method	line:18
+formatted_cell_value	lib/rapport/report.rb	/^    def formatted_cell_value(key, model, row_type)$/;"	method	line:88
+formatted_row	lib/rapport/report.rb	/^    def formatted_row(model, row_type)$/;"	method	line:111
+from	lib/rapport/report_generator.rb	/^      def from(report)$/;"	method	line:23
+from	lib/rapport/report_generator.rb	/^    def self.from(report)$/;"	singleton method	line:6
+generate	lib/rapport/report.rb	/^    def generate$/;"	method	line:45
+generate_internal	lib/rapport/report_generators/report_generator_fake.rb	/^    def generate_internal$/;"	method	line:11
+generate_with	lib/rapport/report_generator.rb	/^      def generate_with(&block)$/;"	method	line:29
+hello	lib/test.rb	/^  def self.hello$/;"	singleton method	line:8
+included	lib/rapport/report.rb	/^    def self.included(base)$/;"	singleton method	line:4
+included	lib/rapport/report_generator.rb	/^    def self.included(base)$/;"	singleton method	line:11
+inherited	lib/rapport/report.rb	/^      def base.inherited(subclass)$/;"	singleton method	line:8
+inherited	lib/rapport/report_generator.rb	/^      def base.inherited(subclass)$/;"	singleton method	line:14
+inherited	lib/test.rb	/^  def self.inherited(subclass)$/;"	singleton method	line:4
+initialize	lib/rapport/report_generator.rb	/^    def initialize(procs = {})$/;"	method	line:91
+initialize	lib/rapport/report_generators/report_generator_fake.rb	/^    def initialize(report)$/;"	method	line:7
+initialize	test/test_helper.rb	/^    def initialize$/;"	method	line:84
+initialize	test/test_helper.rb	/^    def initialize(options = {})$/;"	method	line:51
+initialize	test/test_helper.rb	/^    def initialize(ref)$/;"	method	line:27
+logger	test/test_helper.rb	/^    def logger$/;"	method	line:88
+method_missing	lib/rapport/report_generator.rb	/^    def method_missing(method, *args)$/;"	method	line:67
+method_missing	test/test_helper.rb	/^    def method_missing(sym, *args)$/;"	method	line:31
+options	lib/rapport/report.rb	/^    def options$/;"	method	line:49
+options	lib/rapport/report_generator.rb	/^    def options$/;"	method	line:55
+output_filename	lib/rapport/report_generator.rb	/^    def output_filename$/;"	method	line:83
+raw_cell_value	lib/rapport/report.rb	/^    def raw_cell_value(key, model, row_type)$/;"	method	line:84
+report_generator	lib/rapport/report.rb	/^    def report_generator$/;"	method	line:41
+report_name	lib/rapport/report_generators/report_generator_csv.rb	/^    def report_name$/;"	method	line:31
+return a proc	test/rapport/report_test.rb	/^    share_should("return a proc") do$/;"	shared_should	line:77
+return a proc never sending	test/rapport/report_test.rb	/^    share_should("return a proc never sending") do |symbols|$/;"	shared_should	line:98
+return a proc sending	test/rapport/report_test.rb	/^    share_should("return a proc sending") do |symbols|$/;"	shared_should	line:89
+return nil	test/test_helper.rb	/^  share_should("return nil") do$/;"	shared_should	line:42
+return the lambda	test/rapport/report_test.rb	/^    share_should "return the lambda" do$/;"	shared_should	line:81
+return value	test/rapport/report_generator_test.rb	/^      share_should "return value" do$/;"	shared_should	line:123
+safe_proc	lib/helpers.rb	/^    def safe_proc(proc)$/;"	method	line:4
+safe_send	lib/helpers.rb	/^    def safe_send(key)$/;"	method	line:14
+section	lib/rapport/report.rb	/^    def section(section_data = {}, &block)$/;"	method	line:99
+table_name	lib/rapport/report.rb	/^    def table_name$/;"	method	line:80
+through_calculator	lib/rapport/report.rb	/^    def through_calculator(throughs, base_calculator)$/;"	method	line:144
+to_model_class	lib/rapport/report.rb	/^    def to_model_class$/;"	method	line:76
+to_s	lib/rapport/report.rb	/^    def to_s$/;"	method	line:93
+with :through	test/rapport/report_test.rb	/^    share_setup("with :through") do$/;"	shared_should	line:73
+wrap the lambda	test/rapport/report_test.rb	/^    share_should "wrap the lambda" do$/;"	shared_should	line:85
+zip_output_file!	lib/rapport/report_generators/report_generator_csv.rb	/^    def zip_output_file!$/;"	method	line:23

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rake", "0.8.7"
+  gem "shoulda", "~> 2.11.3", :require => nil
+  gem "mocha", "0.9.8", :require => nil  
+  gem "shared_should", "0.8.1", :require => nil
+  gem "always_execute", "0.0.2", :require => nil
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+  gem "rubyzip", "0.9.5"
+  gem "fastercsv", "1.5.1"  
+end

data/Gemfile.lock

@@ -0,0 +1,34 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    always_execute (0.0.2)
+      shoulda
+    fastercsv (1.5.1)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    mocha (0.9.8)
+      rake
+    rake (0.8.7)
+    rcov (0.9.11)
+    rubyzip (0.9.5)
+    shared_should (0.8.1)
+      shoulda
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  always_execute (= 0.0.2)
+  bundler (~> 1.0.0)
+  fastercsv (= 1.5.1)
+  jeweler (~> 1.6.4)
+  mocha (= 0.9.8)
+  rake (= 0.8.7)
+  rcov
+  rubyzip (= 0.9.5)
+  shared_should (= 0.8.1)
+  shoulda (~> 2.11.3)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Andrew Wheeler
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,93 @@
+# Rapport
+
+Rapport allows you to create tabular reports with a DSL, which can be outputted via customizable formatters.
+
+## Quick-Start
+
+Include the Rapport::Report module in any object to allow it to generate reports in the pre-built formatters (csv, fake) or
+in a custom formatter. Use an easy DSL to write all your reports once, and all your formats once, and then mix and match as you please.
+
+### Creating a Report
+
+    require 'rubygems'
+    require 'rapport'
+
+    class OrderReport
+      include Rapport::Report
+      
+      def initialize(options)
+        self.options = options
+      end
+      
+      # Add columns to the report with column(column_header, *args)
+      # Column Header is what appears in the report, and *args specify how to calculate the values using the model
+      #
+      #   examples:
+      #     column('column header')
+      #     column('column header', :column_symbol)
+      #     column('column header', :model_type => :column_symbol, ...)
+      #
+      # All equivalent:
+      # column 'Product ID', :map_to => lambda {|model| !model.nil? and model.respond_to?(:product_id) ? model.product_id : nil }
+      # column 'Product ID', :map_to => :product_id
+      # column 'Product ID', :product_id
+      column 'Product ID'         # by default converts 'Product ID' to :product_id
+      
+      # special calculation depending on type of model
+      column 'Price',         :additional_charge => :amount,
+                              :line_item => :price,  # not required; defaults to :price
+                              :special_line_item => lambda {|line_item| line_item.price - line_item.tax },
+                              # Display price (in cents) as dollars
+                              :format => :cents 
+      
+      # Navigate an object heirarchy using :through
+      column 'Order ID',      :through -> :order, :map_to => :id                    
+      column 'Customer Name', :through => [:order, :customer], :map_to => lambda {|customer| "#{customer.first_name} #{customer.last_name}" }
+
+      # Implement each_model to specify which models belong to the report.
+      # The method should yield each model, and optionally specify the model type in order to customize how the value is calculated.
+      def each_model
+        AdditionalCharge.in_order_report.each do |additional_charge|
+          yield additional_charge # equivalent to yield additional_charge, :additional_charge
+        end
+           
+        LineItem.in_order_report.each do |line_item|
+          if line_item.special?
+            yield line_item, :special_line_item  # uses special price calculation above 
+          else
+            yield line_item  # equivalent to yield line_item, :line_item
+          end
+        end
+      end
+    end
+
+### Running a Report
+
+    order_report = OrderReport.new(:format => 'csv', :output_dir => 'my_dir')
+    order_report.generate # generates a csv file named 'my_dir/OrderReport_{timestamp}.csv
+    
+    order_report = OrderReport.new(:format => 'my_custom')
+    order_report.generate # generates the same report, but in your custom format
+
+### Creating a Custom Format
+    module Rapport
+      class ReportGeneratorMyCustom
+        include ReportGenerator
+
+        generate_with do |report|
+          File.open(output_filename,'w') do |file|
+            file.puts(report.column_headers.join('|'))
+            report.each_row do |row|
+              file.puts(row.join('|'))
+            end
+          end
+        end
+
+      end
+    end
+
+## Copyright
+
+Copyright (c) 2011 Andrew Wheeler. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rapport"
+  gem.homepage = "http://github.com/jawheeler/rapport"
+  gem.license = "MIT"
+  gem.summary = %Q{Rapport Reporting}
+  gem.description = %Q{Allows you to create tablular reports and output them to various formats interchangeably.}
+  gem.email = "andrew.wheeler@bookrenter.com"
+  gem.authors = ["Andrew Wheeler"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rapport #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.4

data/lib/helpers.rb

@@ -0,0 +1,41 @@
+require 'logger'
+
+module Rapport
+  
+  class << self
+    def safe_proc(proc)
+      lambda do |m|
+        begin
+          proc.call(m) 
+        rescue NameError => ne
+          nil
+        end
+      end
+    end
+
+    def safe_send(key)
+      lambda{|m| !m.nil? and m.respond_to?(key) ? m.send(key) : nil }
+    end
+  
+    def format_underscore(value)
+      value.to_s.gsub(/\W/,'_').gsub(/(.)([A-Z])/,'\1_\2').gsub(/_+/,'_').downcase
+    end
+  
+    def format_camel_case(value)
+      value.to_s.capitalize.gsub(/_(.)/){ $1.upcase }
+    end
+    
+    def logger
+      if Module.const_defined?("Rails")
+        @_logger ||= Rails.logger
+      else
+        @_logger ||= Logger.new(STDERR)
+      end
+    end
+    
+    def logger=(logger)
+      @_logger = logger
+    end
+  end
+      
+end

data/lib/load_rapport.rb

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

data/lib/rapport/report.rb

@@ -0,0 +1,177 @@
+module Rapport
+  module Report
+  
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_variable_set(:@columns, [])
+      base.instance_variable_set(:@cell_calculators, {})
+      def base.inherited(subclass)
+        super(subclass)
+        subclass.instance_variable_set(:@columns, base.instance_variable_get(:@columns).dup )
+        subclass.instance_variable_set(:@cell_calculators, base.instance_variable_get(:@cell_calculators).dup )
+      end
+    end
+    
+    module ClassMethods
+      attr_accessor :row_data
+      
+      def column(*args, &block)
+        raise ArgumentError.new("wrong number of arguments (#{args.length} for 1,2, or 3)") unless args.length >= 1 and args.length <= 3
+        header = args[0]
+        if args.length == 3
+          symbol = args[1].to_sym; options = args[2].to_hash
+        elsif args.length == 2
+          if args[1].is_a?(Symbol)
+            symbol = args[1]; options = {}
+          else
+            symbol = Rapport.format_underscore(header.downcase).to_sym; options = args[1].to_hash
+          end
+        end
+        add_calculator(symbol, options) unless options.nil?
+        instance_variable_get(:@columns) << [header, symbol]
+      end
+      
+      private
+      
+      def add_calculator(symbol, options)
+        instance_variable_get(:@cell_calculators)[symbol] = options
+      end
+    end
+    
+    attr_accessor :section_data, :current_model, :options
+    
+    def row_data
+      self.class.row_data
+    end
+  
+    def report_generator
+      @_report_generator ||= ReportGenerator.from(self)
+    end
+  
+    def generate
+      report_generator.generate
+    end
+    
+    def options
+      @options ||= {:format => 'fake'}
+    end
+      
+    def each_row
+      each_model do |model, row_type|
+        self.current_model = model # For error reporting
+        yield formatted_row(model, row_type || Rapport.format_underscore(model.class.to_s))
+      end
+    end
+    
+    def columns
+      if @_columns.nil?
+        @_columns = []
+        self.class.send(:instance_variable_get, :@columns).each {|col| @_columns << col.dup }
+      end
+      @_columns
+    end
+  
+    def column_headers
+      @_column_headers ||= columns.map{|c| c[0]}
+    end
+  
+    def column_symbols
+      @_column_symbols ||= columns.map{|c| c[1]}
+    end
+    
+    def to_model_class
+      @_to_model_class ||= Struct.new("#{self.class}Model", *column_symbols)
+    end
+  
+    def table_name
+      @table_name ||= options[:report_table_name] || "reports_#{Rapport.format_underscore(self.class).sub(/_?report_?/,'')}"
+    end
+  
+    def raw_cell_value(key, model, row_type)
+      self.row_data[key] = cell_calculator_for(key,row_type).call(model)
+    end
+  
+    def formatted_cell_value(key, model, row_type)
+      row_data[key] = raw_value = raw_cell_value(key, model, row_type)
+      report_generator.format(cell_format_for(key), raw_value)
+    end  
+  
+    def to_s
+      [self.class, options[:format]].compact.map{|p| p.to_s }.join(' ')
+    end
+  
+    protected
+  
+    def section(section_data = {}, &block)
+      self.section_data = section_data
+      yield
+      self.section_data = nil
+    end
+  
+    def each_model(&block)
+      raise "#each_model has not been implemented"
+    end
+  
+    private
+  
+    def formatted_row(model, row_type)
+      self.class.row_data = {}
+      out = column_symbols.map do |key|
+        formatted_cell_value(key, model, row_type)
+      end
+      self.class.row_data = {}
+      out
+    end
+  
+    def _calculators
+      @_calculators ||= self.class.send(:instance_variable_get, :@cell_calculators).dup
+    end
+    
+    def cell_calculator_for(key,row_type)
+      calculator = _calculators[key] ||= {}
+    
+      if calculator[row_type].nil?
+        base_calculator = base_calculator(key,calculator)
+        calculator_for_row_type = if calculator[:through]
+          calculator[:through] = [calculator[:through]] unless calculator[:through].is_a?(Enumerable)
+          through_calculator(calculator[:through], base_calculator)
+        else
+          base_calculator
+        end
+        calculator[row_type] = calculator_for_row_type
+      elsif !calculator[row_type].respond_to?(:call) 
+        row_type_key = calculator[row_type]
+        calculator[row_type] = Rapport.safe_send(row_type_key)
+      end
+    
+      calculator[row_type]
+    end
+    
+    def through_calculator(throughs, base_calculator)
+      lambda do |m|
+        path = m
+        throughs.each do |hint|
+          if path.respond_to?(hint)
+            new_path = path.send(hint)
+            path = new_path unless new_path.nil?
+          end
+        end
+        base_calculator.call(path)
+      end      
+    end    
+  
+    def base_calculator(key, calculator)
+      base_key = key
+      if calculator[:map_to]
+        return Rapport.safe_proc(calculator[:map_to]) if calculator[:map_to].respond_to?(:call)
+        base_key = calculator[:map_to].to_sym
+      end
+      Rapport.safe_send(base_key)
+    end
+  
+    def cell_format_for(key)
+      _calculators[key][:"format_#{options[:format]}"] || _calculators[key][:format]
+    end
+  
+  end
+end

data/lib/rapport/report_generator.rb

@@ -0,0 +1,105 @@
+module Rapport
+  module ReportGenerator
+    
+    def self.from(report)
+      options = {:format => 'fake'}.merge(report.options)
+      Rapport.const_get("ReportGenerator#{Rapport.format_camel_case(options[:format].to_s)}").from(report)
+    end   
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_variable_set(:@cell_formatter, CellFormatter.new)
+      def base.inherited(subclass)
+        super(subclass)
+        subclass.instance_variable_set(:@cell_formatter, base.instance_variable_get(:@cell_formatter).dup)
+      end      
+    end
+    
+    module ClassMethods
+      # Override to customize the report generator based on the charactersistics of the report or its options
+      # Default implementation uses default constructor and assigns to the report attribute.
+      def from(report)
+        out = self.new
+        out.report = report
+        out
+      end
+      
+      # generate_with {|report| ... }
+      # Provides a logging/error handling wrapper for the passed block. Automatically cretes report_generator.generate.
+      def generate_with(&block)
+        raise "Only one call to generate_with is permitted (or none if #generate is implemented)" if public_method_defined?(:generate)
+        define_method :generate do
+          raise "No report to generate!" if report.nil?
+          out = nil
+          begin
+            Rapport.logger.info("Generating #{report}...")
+            out = block.call(report)
+            Rapport.logger.info("Generated #{report}.")
+          rescue Exception => e
+            error = report.current_model.nil? ? '' : "While processing:\n\n#{report.current_model.inspect}\n\n"
+            error += "#{report} failed:\n\n#{e.message}\n\n#{e.backtrace.join("\n")}"
+            Rapport.logger.error(error)
+            Rapport.logger.mail(:error,error) if Rapport.logger.respond_to?(:mail)
+          end
+          out
+        end
+      end
+      
+      def cell_format(type, &block)
+        instance_variable_get(:@cell_formatter).add_cell_format(type, &block)
+      end
+      
+      def format_as(type, value)
+        instance_variable_get(:@cell_formatter).format(type, value)
+      end
+    end
+    
+    attr_accessor :report
+    
+    def cell_formatter
+      @cell_formatter ||= self.class.instance_variable_get(:@cell_formatter).dup
+    end
+    
+    def format(type, value)
+      cell_formatter.format(type, value)
+    end
+    
+    def output_filename
+      @output_filename ||= File.join(@options[:output_dir] || '.', "#{report_name}_#{Time.now.strftime('%Y-%m-%d-%H%M%S')}.csv")
+    end     
+
+  end
+  
+  class CellFormatter
+    
+    def initialize(procs = {})
+      @procs = procs
+    end
+    
+    def dup
+      CellFormatter.new(@procs.dup)
+    end
+    
+    def add_cell_format(type, &block)
+      proc = Proc.new(&block)
+      @procs[type] = proc
+      @procs[Rapport.format_underscore(type.to_s)] = proc if type.is_a?(Class)
+      
+      # Support ActiveSupport::TimeWithZone automatically
+      if type == Time
+        add_cell_format(ActiveSupport::TimeWithZone, &block) rescue nil
+      end
+      
+    end
+
+    def format(type,value)     
+      if type.is_a?(Proc)
+        type.call(value)
+      else 
+        proc = @procs[type] || @procs[value.class]
+        proc.nil? ? value : proc.call(value)
+      end
+    end
+  end
+
+end