ruport-util 0.3.0 → 0.4.0

data/Rakefile

@@ -18,7 +18,7 @@ end
 
 spec = Gem::Specification.new do |spec|
   spec.name = "ruport-util"
-  spec.version = "0.3.0"
+  spec.version = "0.4.0"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "A set of tools and helper libs for Ruby Reports"
   spec.files =  Dir.glob("{example,lib,test,bin}/**/**/*") +
@@ -28,6 +28,7 @@ spec = Gem::Specification.new do |spec|
   
   spec.test_files = Dir[ "test/test_*.rb" ]
   spec.bindir = "bin"
+  spec.executables = FileList["rope"]
   spec.has_rdoc = true
   spec.extra_rdoc_files = %w{}
   spec.rdoc_options << '--title' << 'Ruport Documentation' #<<

data/bin/rope

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require "fileutils"
+require "ruport/util/generator"
+include FileUtils
+
+if ARGV.empty?
+  puts "Usage: rope project_name"
+  exit
+end
+project = ARGV[0]
+
+Ruport::Generator.build(ARGV[0])

data/lib/ruport/util/generator.rb

@@ -0,0 +1,280 @@
+module Ruport
+  class Generator
+  extend FileUtils
+
+  module Helpers
+    def format_class_name(string)
+      string.downcase.split("_").map { |s| s.capitalize }.join
+    end
+
+    def check_for_files
+      if File.exist? "lib/reports/#{ARGV[1]}.rb"
+        raise "Report #{ARGV[1]} exists!"
+      end
+
+      if File.exist? "lib/renderers/#{ARGV[1]}.rb"
+        raise "Renderer #{ARGV[1]} exists!"
+      end
+    end
+  end
+
+  begin
+    require "rubygems"
+  rescue LoadError
+    nil
+  end
+  require "ruport"
+  require "ruport/util"
+
+  def self.build(proj)
+    @project = proj
+    build_directory_structure
+    build_init
+    build_config
+    build_utils         
+    build_rakefile  
+    puts "\nSuccessfully generated project: #{proj}"
+  end
+
+
+  def self.build_init
+    m = "#{project}/lib/init.rb" 
+    puts "  #{m}"
+    File.open(m,"w") { |f| f << INIT }
+  end
+
+  # Generates a trivial rakefile for use with Ruport.
+  def self.build_rakefile
+    m = "#{project}/Rakefile"
+    puts "  #{m}"
+    File.open(m,"w") { |f| f << RAKEFILE }
+  end
+
+  # Generates the build.rb and sql_exec.rb utilities
+  def self.build_utils           
+    
+    m = "#{project}/util/build"   
+    puts "  #{m}"
+    File.open(m,"w") { |f| f << BUILD } 
+    chmod(0755, m)
+    
+    m = "#{project}/util/sql_exec"  
+    puts "  #{m}"
+    File.open(m,"w") { |f| f << SQL_EXEC }
+    chmod(0755, m)
+  end
+
+  # sets up the basic directory layout for a Ruport application
+  def self.build_directory_structure
+    mkdir project        
+    puts "creating directories.."
+    %w[ test config output data lib lib/reports 
+        lib/renderers templates sql log util].each do |d|
+      m="#{project}/#{d}" 
+      puts "  #{m}"
+      mkdir(m)
+    end
+    
+    puts "creating files.."
+    %w[reports helpers renderers].each { |f|
+      m = "#{project}/lib/#{f}.rb"
+      puts "  #{m}"
+      touch(m)
+    }
+  end
+
+  def self.build_config
+    m = "#{project}/config/environment.rb"
+    puts "  #{m}"
+    File.open(m,"w") { |f| f << CONFIG }
+  end
+
+  # returns the project's name
+  def self.project; @project; end
+
+RAKEFILE = <<'END_RAKEFILE'
+begin; require "rubygems"; rescue LoadError; end
+require "rake/testtask"
+
+task :default => [:test]
+
+Rake::TestTask.new do |test|
+  test.libs    << "test"
+  test.pattern =  'test/**/test_*.rb'
+  test.verbose =  true
+end
+
+task :build do
+  if ENV['report']
+    sh "ruby util/build report #{ENV['report']}"
+  elsif ENV['renderer']
+    sh "ruby util/build renderer #{ENV['renderer']}"
+  end
+end
+
+task :run do
+  sh "ruby lib/reports/#{ENV['report']}.rb"
+end
+END_RAKEFILE
+
+CONFIG = <<END_CONFIG
+require "ruport"
+
+Ruport::Query.add_source :default, :user => "root",
+                                   :dsn  => "dbi:mysql:mydb"
+END_CONFIG
+
+BUILD = <<'END_BUILD'
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'lib/init.rb'
+require "ruport/util"
+include FileUtils
+include Ruport::Generator::Helpers
+
+unless ARGV.length > 1
+  puts "usage: build [command] [options]"
+  exit
+end
+
+class_name = format_class_name(ARGV[1])
+
+if ARGV[0].eql? "report"
+  check_for_files
+  File.open("lib/reports.rb", "a") { |f| 
+    f.puts("require \"lib/reports/#{ARGV[1]}\"")
+  }
+REP = <<EOR
+require "lib/init"
+class #{class_name} < Ruport::Report
+
+  def generate
+
+  end
+  
+end
+
+if __FILE__ == $0
+  puts #{class_name}.run
+end
+EOR
+
+TEST = <<EOR
+require "test/unit"
+require "lib/reports/#{ARGV[1]}"
+
+class Test#{class_name} < Test::Unit::TestCase
+  def test_flunk
+    flunk "Write your real tests here or in any test/test_* file"
+  end
+end
+EOR
+
+  File.open("lib/reports/#{ARGV[1]}.rb", "w") { |f| f << REP }
+  puts "reports file: lib/reports/#{ARGV[1]}.rb"
+  puts "test file: test/test_#{ARGV[1]}.rb"
+  puts "class name: #{class_name}" 
+  File.open("test/test_#{ARGV[1]}.rb","w") { |f| f << TEST }  
+
+elsif ARGV[0].eql? "renderer"
+
+  check_for_files
+  File.open("lib/renderers.rb","a") { |f|
+    f.puts("require \"lib/renderers/#{ARGV[1]}\"")
+  }
+REP = <<EOR
+require "lib/init"
+
+class #{class_name} < Ruport::Renderer
+  stage :#{class_name.downcase}
+end
+
+class #{class_name}Formatter < Ruport::Formatter
+
+  # change to your format name, or add additional formats
+  renders :my_format, :for => #{class_name}
+
+  def build_#{class_name.downcase}
+  
+  end
+
+end
+EOR
+
+TEST = <<EOR
+require "test/unit"
+require "lib/renderers/#{ARGV[1]}"
+
+class Test#{class_name} < Test::Unit::TestCase
+  def test_flunk
+    flunk "Write your real tests here or in any test/test_* file"
+  end
+end
+EOR
+  puts "renderer file: lib/renderers/#{ARGV[1]}.rb"
+  File.open("lib/renderers/#{ARGV[1]}.rb", "w") { |f| f << REP }
+  puts "test file: test/test_#{ARGV[1]}.rb"
+
+  puts "class name: #{class_name}"
+  File.open("test/test_#{ARGV[1]}.rb","w") { |f| f << TEST }
+else
+  puts "Incorrect usage."
+end
+END_BUILD
+
+SQL_EXEC = <<'END_SQL'
+#!/usr/bin/env ruby
+
+require "lib/init"
+
+puts Ruport::Query.new(ARGF.read).result
+END_SQL
+
+INIT = <<END_INIT
+begin
+  require "rubygems"
+  gem "ruport","=#{Ruport::VERSION}"
+  gem "ruport-util","=#{Ruport::Util::VERSION}"
+rescue LoadError 
+  nil
+end
+require "ruport"
+require "ruport/util"
+require "lib/helpers"
+require "config/environment"
+
+class String
+  def /(other)
+   self + "/" + other
+  end
+end
+
+class Ruport::Report
+  
+  def output_dir
+    config.output_dir or dir('output')
+  end
+
+  def data_dir
+    config.data_dir or dir('data')
+  end
+
+  def query_dir
+    config.query_dir or dir('sql')
+  end
+
+  def template_dir
+    config.template_dir or dir('templates')
+  end
+
+  private
+  def dir(name)
+    "#{FileUtils.pwd}/#{ARGV[0]}/\#{name}"
+  end
+end
+END_INIT
+
+
+  end
+end

data/lib/ruport/util/mailer.rb

@@ -6,6 +6,7 @@
 #  See LICENSE for details
 require "net/smtp"
 require "forwardable"
+require "ruport/util/report"
 
 module Ruport
   

data/lib/ruport/util/report.rb

@@ -0,0 +1,405 @@
+# report.rb : High Level Interface to Ruport
+#
+# Author: Gregory Brown
+# Copyright 2006, All Rights Reserved
+#
+# This is Free Software.  See LICENSE and COPYING files for details.
+
+#load the needed standard libraries.
+%w[erb yaml date logger fileutils].each { |lib| require lib }
+require "forwardable"
+
+module Ruport
+
+  require 'timeout'
+
+  class Attempt # :nodoc:
+    VERSION = '0.1.0 (vendored)'
+
+    # Number of attempts to make before failing.  The default is 3.
+    attr_accessor :tries
+
+    # Number of seconds to wait between attempts.  The default is 60.
+    attr_accessor :interval
+
+    # a level which ruport understands.  
+    attr_accessor :log_level
+
+    # If set, this increments the interval with each failed attempt by that
+    # number of seconds.
+    attr_accessor :increment
+
+    # If set, the code block is further wrapped in a timeout block.
+    attr_accessor :timeout
+
+    # Determines which exception level to check when looking for errors to
+    # retry.  The default is 'Exception' (i.e. all errors).
+    attr_accessor :level
+
+    # :call-seq:
+    #    Attempt.new{ |a| ... }
+    # 
+    # Creates and returns a new +Attempt+ object.  Use a block to set the
+    # accessors.
+    # 
+    def initialize           
+      @tries     = 3         # Reasonable default
+      @interval  = 60        # Reasonable default
+      @increment = nil       # Should be an int, if provided
+      @timeout   = nil       # Wrap the code in a timeout block if provided
+      @level     = Exception # Level of exception to be caught
+      
+      yield self if block_given?
+    end
+
+    def attempt
+      count = 1
+      begin
+         if @timeout
+            Timeout.timeout(@timeout){ yield }
+         else
+            yield
+         end
+      rescue @level => error
+         @tries -= 1
+         if @tries > 0
+            msg = "Error on attempt # #{count}: #{error}; retrying"
+            count += 1
+            @interval += @increment if @increment
+            sleep @interval
+            retry
+         end
+         raise
+      end
+    end
+  end
+
+
+
+  # === Overview
+  #
+  # The Ruport::Report class provides a high level interface to much of Ruport's
+  # functionality.  It is designed to allow you to build and run reports easily.
+  # If your needs are complicated, you will probably need to take a look at the
+  # individual classes of the library, but if they are fairly simple, you may be
+  # able to get away using this class alone. 
+  #
+  # Ruport::Report is primarily meant to be used with Ruport's code generator, 
+  # rope, and is less useful when integrated within another system, such as
+  # Rails or Camping.
+  #
+  # Below is a simple example of loading a report in from a CSV, performing a
+  # grouping operation, and then rendering the resulting PDF to file.
+  #
+  #   require "rubygems"
+  #   require "ruport"
+  #   class MyReport < Ruport::Report 
+  #
+  #     renders_as_grouping(:style => :inline)   
+  #
+  #     def generate
+  #       table = load_csv "foo.csv"
+  #       Grouping(table, :by => "username")
+  #     end  
+  #
+  #   end   
+  #
+  #   report = MyReport.new(:pdf) 
+  #   report.run { |results| results.write("bar.pdf") }
+  #
+  class Report   
+    extend Forwardable
+    include Renderer::Hooks
+        
+    # Builds a report instance.  If provided a format parameter, 
+    # this format will be used by default when rendering the report.
+    #
+    def initialize( format=nil )
+      use_source :default
+      @format      = format
+      @report_name = "" 
+      @results     = ""
+      @file        = nil
+    end
+    
+    # By default, this file will be used by Report#write.
+    attr_accessor :file
+
+    # This attribute will get the results of Report#generate when the report is
+    # run.
+    #
+    attr_accessor :results
+     
+    # This attribute defines which format the Report will render in by default.
+    attr_accessor :format
+
+    # This is a simplified interface to Ruport::Query.
+    #
+    # You can use it to read SQL statements from file or string:
+    #  
+    #   #from string 
+    #   result = query "select * from foo"
+    #
+    #   #from file 
+    #   result = query "my_query.sql", :origin => :file
+    # 
+    # You can use multistatement SQL:
+    #
+    #   # will return the value of the last statement, "select * from foo"
+    #   result = query "insert into foo values(1,2); select * from foo"
+    # 
+    # You can iterate by row:
+    #  
+    #   query("select * from foo") { |r|
+    #     #do something with the rows here
+    #   }
+    # 
+    # query() can return raw DBI:Row objects or Ruport's data structures:
+    # 
+    #   # will return an Array of DBI::Row objects
+    #   result = query "select * from foo", :raw_data => true
+    #
+    # You can quickly output in a number of formats:
+    # 
+    #   result = query "select * from foo", :as => :csv
+    #   result = query "select * from foo", :as => :html
+    #   result = query "select * from foo", :as => :pdf
+    #
+    # See Ruport::Query for details.
+    #
+    def query(sql, options={})
+      options[:origin] ||= :string
+      options[:source] ||= @source
+      q = options[:query_obj] || Query.new(sql, options)
+      if block_given?
+        q.each { |r| yield(r) }
+      elsif options[:as]
+        q.result.as(options[:as])
+      else
+        q.result
+      end
+    end
+    
+    # Sets the active source to the Ruport::Query source requested by
+    # <tt>label</tt>. 
+    #
+    # For example, if you have a data source :test, which is defined as such:
+    #
+    #   Ruport::Query.add_source(:test, :dsn => "dbi:mysql:test", 
+    #                                   :user => "root" ) 
+    #
+    #  
+    # The following report would use that data source rather than the
+    # <tt>:default</tt> source:
+    #
+    #   class MyReport < Ruport::Report
+    #
+    #     renders_as_table     
+    #
+    #     def generate
+    #        use_source :test
+    #        query "select * from foo" 
+    #     end             
+    #
+    #   end
+    def use_source(label)
+      @source = label
+    end
+     
+    # Writes the contents of Report#results to file.
+    # If given a string as a second argument, writes that to file, instead.
+    #
+    # Examples:
+    #   
+    #   # write the results of the report to a file
+    #   Report.run { |r| r.write("foo.txt") } 
+    #   
+    #   # write the results in reverse     
+    #   Report.run { |r| r.write("foo.txt",r.results.reverse) }     
+    #    
+    def write(my_file=file,my_results=results)
+      File.open(my_file,"w") { |f| f << my_results }
+    end
+    
+    # Behaves the same way as Report#write, but will append to a file rather
+    # than create a new file if it already exists.
+    #
+    def append(my_file=file,my_results=results)
+      File.open(my_file,"a") { |f| f << my_results }
+    end
+    
+    # This method passes <tt>self</tt> to Report.run.
+    #
+    # Please see the class method for details.
+    #
+    def run(options={},&block)
+      options[:reports] ||= [self]
+      self.class.run(options,&block)
+    end
+       
+    # Allows you to override the default format.
+    #
+    # Example:
+    #
+    #   my_report.as(:csv) 
+    #
+    def as(format,*args)   
+      self.format,old = format, self.format
+      results = run(*args)  
+      self.format = old 
+      return results
+    end
+                                 
+    # Provides syntactic sugar, allowing to_foo in place of as(:foo)
+    def method_missing(id,*args) 
+      id.to_s =~ /^to_(.*)/
+      $1 ? as($1.to_sym,*args) : super
+    end
+
+    # Loads a CSV in from  a file.
+    #
+    # Example:
+    #
+    #   my_table = load_csv "foo.csv"                 #=> Data::Table
+    #   my_array = load_csv "foo.csv", :as => :array  #=> Array
+    #
+    # See also Ruport::Data::Table.load and Table()
+    #
+    def load_csv(file,options={})
+      case options[:as]
+      when :array
+        a = []
+        Data::Table.load(file,options) { |s,r| a << r } ; a
+      else
+        Data::Table.load(file,options)
+      end
+    end
+
+    # Executes an erb template.  If a filename is given which matches the
+    # pattern /\.r\w+$/ (eg foo.rhtml, bar.rtxt, etc), 
+    # it will be loaded and evaluated.  Otherwise, the string will be processed
+    # directly.
+    #
+    # Examples:
+    #
+    #  @foo = 'greg'
+    #  erb "My name is <%= @foo %>" #=> "My name is greg"
+    #
+    #  erb "foo.rhtml" #=> contents of evaluated text in foo.rhtml
+    #
+    def erb(s)
+      if s =~ /\.r\w+$/
+        ERB.new(File.read(s)).result(binding)
+      else
+        ERB.new(s).result(binding)
+      end
+    end
+
+    class << self
+      
+      # Allows you to override the default format.
+      #
+      # Example:
+      #
+      #   my_report.as(:csv) 
+      #
+      def as(format,options={})
+        report = new(format)
+        report.run(rendering_options.merge(options))
+      end 
+      
+      # Provides syntactic sugar, allowing to_foo in place of as(:foo)        
+      def method_missing(id,*args) 
+        id.to_s =~ /^to_(.*)/
+        $1 ? as($1.to_sym,*args) : super
+      end
+
+      # Defines an instance method which will be run before the
+      # <tt>generate</tt> method when Ruport.run is executed.
+      #
+      # Good for setting config info and perhaps files and/or loggers.
+      #
+      def prepare(&block); define_method(:prepare,&block) end
+      
+      # Defines an instance method which will be executed by Report.run.
+      #
+      # The return value of this method is assigned to the <tt>results</tt>
+      # attribute.
+      #
+      def generate(&block); define_method(:generate,&block) end
+      
+      # Defines an instance method which will be executed after the object is
+      # yielded in Report.run.
+      #
+      def cleanup(&block); define_method(:cleanup,&block) end
+
+      private :prepare, :generate, :cleanup
+
+      # Runs the reports specified.  If no reports are specified, then it
+      # creates a new instance via <tt>self.new</tt>.
+      #
+      # Hooks called, in order:
+      #    * Report#prepare
+      #    * Report#generate #=> return value stored in @results
+      #    * yields self to block, if given   
+      #    * if a renderer is specified, passes along @results and options
+      #    * Report#cleanup    
+      #
+      # Options: 
+      #   :reports:  A list of reports to run, defaults to a single generic
+      #              instance of the current report (self.new).  
+      # 
+      #   :tries:, :timeout:, :interval:   Wrappers on attempt.rb
+      # 
+      #    all other options will be forwarded to a renderer if one is specified
+      #    via the Renderer::Hooks methods
+      def run(options={})
+        options[:reports] ||= [self.new]
+
+        formatting_options = ( options.keys - 
+                                [:reports,:tries,:timeout,:interval])
+
+        fopts = formatting_options.inject({}) { |s,k|
+          s.merge( k => options[k] )
+        }
+        
+
+        process = lambda do
+          options[:reports].each { |rep|
+            rep.prepare if rep.respond_to? :prepare
+            rep.results = rep.generate
+
+            if renderer
+              rep.results = 
+                renderer.render(rep.format,rendering_options.merge(fopts)) { |r| 
+                r.data = rep.results
+              }
+            end
+
+            yield(rep) if block_given?
+            rep.cleanup if rep.respond_to? :cleanup
+          }
+        end
+
+        if options[:tries] && (options[:interval] || options[:timeout])
+          code = Attempt.new { |a| 
+            a.tries = options[:tries]
+            a.interval = options[:interval] if options[:interval]
+            a.timeout = options[:timeout] if options[:timeout]
+          }
+          code.attempt(&process)
+        else
+          process.call
+        end
+
+        outs = options[:reports].map { |r| r.results }
+        if outs.length == 1
+          outs.last
+        else
+          outs
+        end
+        
+      end
+    end
+  end
+end

data/lib/ruport/util.rb

@@ -1,5 +1,12 @@
+module Ruport
+  module Util
+    VERSION = "0.4.0"
+  end
+end
+require "ruport/util/report"
 require "ruport/util/graph"
 require "ruport/util/invoice"
 require "ruport/util/report_manager"
 require "ruport/util/mailer"
 require "ruport/util/bench"
+require "ruport/util/generator"

data/test/samples/foo.rtxt

@@ -0,0 +1,3 @@
+<%= @results %>
+<%= 2 + 2 %>
+---

data/test/test_report.rb

@@ -0,0 +1,218 @@
+#tc_report.rb
+#
+#  Created by Gregory Thomas Brown on 2005-08-09
+#  Copyright 2005 (Gregory Brown) All rights reserved.
+
+require "test/unit"
+begin; require "rubygems"; rescue LoadError; nil; end
+require "ruport"
+require "ruport/util/report"
+
+begin
+  require 'mocha'
+  require 'stubba'
+  require 'net/smtp'
+rescue LoadError
+  $stderr.puts "Warning: Mocha not found -- skipping some Report tests"
+end
+
+class SampleReport < Ruport::Report
+  renders_with Ruport::Renderer::Table
+
+  def generate
+    Table(%w[not abc]) << %w[o r] << %w[one two] << %w[thr ee]
+  end
+end
+
+class TestReport < Test::Unit::TestCase
+  include Ruport
+
+  def setup
+    @report = Report.new
+  end
+
+  def test_renders_with_shortcuts
+    a = SampleReport.new(:csv)
+    assert_equal("not,abc\no,r\none,two\nthr,ee\n",a.run)
+    assert_equal("not,abc\no,r\none,two\nthr,ee\n",SampleReport.as(:csv))
+    assert_equal("not,abc\no,r\none,two\nthr,ee\n",SampleReport.to_csv)
+    assert_equal("not,abc\no,r\none,two\nthr,ee\n",a.to_csv)
+    a = SampleReport.new
+    assert_equal("not,abc\no,r\none,two\nthr,ee\n",a.to_csv)
+
+    assert_nil nil, a.format
+    a.to_text
+
+    assert_nil a.format
+  end
+
+  def test_erb
+    @report = Report.new
+    @report.results = "foo"
+    assert_equal "foo", @report.erb("<%= @results %>")
+    assert_equal "foo\n4\n---\n", @report.erb("test/samples/foo.rtxt")
+  end
+
+  class MyReport < Report; end
+  
+  def test_klass_methods
+    rep_klass = MyReport.dup
+    rep_klass.send(:prepare)  { self.file = "foo.csv" }
+    rep_klass.send(:generate) { "hello dolly" }
+    rep_klass.send(:cleanup) { @foo = "bar" }
+    report = rep_klass.new
+    report.run { |rep|  
+      assert_equal("foo.csv",rep.file)
+      assert_equal("hello dolly",rep.results)
+      assert_equal(nil,rep.instance_eval("@foo"))
+    }
+    assert_equal("bar",report.instance_eval("@foo"))
+  end
+
+  def test_multi_reports
+    rep_klass = MyReport.dup
+    
+    report1 = rep_klass.new
+    report2 = rep_klass.new
+
+    report1.file = "foo"
+    report2.file = "bar"
+
+    rep_klass.send(:generate) { file }
+
+    expected = %w[foo bar]
+
+    rep_klass.run :reports => [report1,report2] do |rep|
+      assert_equal expected.shift, rep.results
+    end
+
+  end
+
+
+  def test_timeout
+    rep_klass = MyReport.dup
+    rep_klass.send(:generate) { raise }
+
+    assert_raises(RuntimeError){ 
+      rep_klass.run(:tries => 3, :interval => 1)
+    }
+    
+    rep_klass.send(:generate) { sleep 1.1 }
+
+    assert_raises(Timeout::Error) {
+      rep_klass.run( :tries    => 2, 
+                     :timeout  => 1, 
+                     :interval => 1,
+                     :log_level => :log_only)
+    }
+
+  end
+  
+  def test_return_value
+    rep_klass = MyReport.dup
+    rep_klass.send(:generate) { "hello dolly" }
+
+    # single report
+    assert_equal "hello dolly", rep_klass.run 
+
+    # multiple reports
+    assert_equal ["hello dolly", "hello dolly"],
+      rep_klass.run(:reports => [rep_klass.new,rep_klass.new])
+  end
+
+   def test_write_to_file
+     return unless Object.const_defined? :Mocha
+     file = mock("file")
+ 
+     File.expects(:open).
+       with("foo.csv","w").yields(file).returns(file).at_least_once
+
+     file.expects(:<<).
+       with("results").returns(file).at_least_once
+     
+     @report = Report.new
+     assert @report.write("foo.csv", "results")
+   end
+ 
+   def test_append_to_file
+     return unless Object.const_defined? :Mocha
+     file = mock("file")
+     
+     File.expects(:open).
+       with("foo.csv","a").yields(file).returns(file).at_least_once
+
+     file.expects(:<<).
+       with("results").returns(file).at_least_once
+ 
+     @report = Report.new
+     assert @report.append("foo.csv", "results")
+   end
+ 
+   def test_load_csv
+     expected = [%w[a b c],['d', nil, 'e']].to_table(%w[col1 col2 col3])
+ 
+     @report = Report.new
+     table = @report.load_csv("test/samples/data.csv")
+ 
+     assert_equal expected, table
+   end
+ 
+   def test_load_csv_as_array
+     expected = [%w[a b c],['d', nil, 'e']]
+ 
+     @report = Report.new
+     array = @report.load_csv("test/samples/data.csv", :as => :array)
+ 
+     assert_equal expected, array
+   end
+
+   def test_renders_with
+    klass = MyReport.dup
+    klass.renders_with Ruport::Renderer::Table
+    klass.send(:generate) { [[1,2,3],[4,5,6]].to_table(%w[a b c]) }
+    a = klass.new(:csv)
+    assert_equal "a,b,c\n1,2,3\n4,5,6\n", a.run
+
+    klass.renders_with Ruport::Renderer::Table, :show_table_headers => false
+    a = klass.new(:csv)
+    assert_equal "1,2,3\n4,5,6\n", a.run
+    assert_equal "a,b,c\n1,2,3\n4,5,6\n", a.run(:show_table_headers => true)
+
+
+   end
+ 
+   def test_renders_as_table
+     klass = MyReport.dup
+     klass.renders_as_table
+     klass.send(:generate) { [[1,2,3],[4,5,6]].to_table(%w[a b c]) }
+     a = klass.new(:csv)
+     assert_equal "a,b,c\n1,2,3\n4,5,6\n", a.run
+   end      
+   
+   def test_renders_as_row
+     klass = MyReport.dup
+     klass.renders_as_row
+     klass.send(:generate) { [[1,2,3]].to_table(%w[a b c])[0] }
+     a = klass.new(:csv)
+     assert_equal "1,2,3\n", a.run
+   end      
+   
+   def test_renders_as_group
+     klass = MyReport.dup
+     klass.renders_as_group
+     klass.send(:generate) { [[1,2,3]].to_table(%w[a b c]).to_group("foo") }
+     a = klass.new(:csv)
+     assert_equal "foo\n\na,b,c\n1,2,3\n", a.run
+   end    
+   
+   def test_renders_as_grouping
+     klass = MyReport.dup
+     klass.renders_as_grouping
+     klass.send(:generate) { 
+       Grouping([[1,2,3],[4,5,6]].to_table(%w[a b c]),:by => "a")
+     }
+     a = klass.new(:csv)
+     assert_equal "1\n\nb,c\n2,3\n\n4\n\nb,c\n5,6\n\n", a.run
+   end
+
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: ruport-util
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
-date: 2007-04-22 00:00:00 -04:00
+  version: 0.4.0
+date: 2007-05-01 00:00:00 -04:00
 summary: A set of tools and helper libs for Ruby Reports
 require_paths: 
 - lib
@@ -29,38 +29,44 @@ post_install_message:
 authors: 
 - Gregory Brown
 files: 
+- example/graph_report.rb
 - example/invoice_report.rb
-- example/managed_report.rb
 - example/mailer.rb
-- example/graph_report.rb
+- example/managed_report.rb
 - lib/ruport
 - lib/ruport/util
 - lib/ruport/util.rb
-- lib/ruport/util/mailer.rb
 - lib/ruport/util/bench.rb
+- lib/ruport/util/generator.rb
 - lib/ruport/util/graph.rb
-- lib/ruport/util/report_manager.rb
 - lib/ruport/util/invoice.rb
-- test/samples
+- lib/ruport/util/mailer.rb
+- lib/ruport/util/report.rb
+- lib/ruport/util/report_manager.rb
 - test/init.rb
-- test/test_report_manager.rb
+- test/samples
 - test/test_graph_renderer.rb
-- test/test_mailer.rb
 - test/test_invoice.rb
+- test/test_mailer.rb
+- test/test_report.rb
+- test/test_report_manager.rb
 - test/samples/data.csv
+- test/samples/foo.rtxt
+- bin/rope
 - Rakefile
 test_files: 
-- test/test_report_manager.rb
 - test/test_graph_renderer.rb
-- test/test_mailer.rb
 - test/test_invoice.rb
+- test/test_mailer.rb
+- test/test_report.rb
+- test/test_report_manager.rb
 rdoc_options: 
 - --title
 - Ruport Documentation
 extra_rdoc_files: []
 
-executables: []
-
+executables: 
+- rope
 extensions: []
 
 requirements: []