ruport 1.0.1 → 1.0.2

data/Rakefile

@@ -3,7 +3,7 @@ require "rake/testtask"
 require "rake/gempackagetask"
 
 
-RUPORT_VERSION = "1.0.1"
+RUPORT_VERSION = "1.0.2"
 
 begin
   require "rubygems"

data/examples/trac_ticket_status.rb

@@ -32,7 +32,7 @@ class TracSummaryReport
     table = Table([:title, :date], :record_class => TicketStatus) do |table|
       (feed/"item").each do |r|
          title = (r/"title").innerHTML
-         next unless title =~ /Ticket.*(created|closed|reopene)/
+         next unless title =~ /Ticket.*(created|closed|reopened)/
          table <<  { :title => title,
                      :date  => Date.parse((r/"pubdate").innerHTML) }
        end

data/lib/ruport/data/table.rb

@@ -40,7 +40,7 @@ module Ruport::Data
       #   table = Table.load('mydata.csv',:has_names => false)
       #
       #   # pass in FasterCSV options, such as column separators
-      #   table = Table.load('mydata.csv',:csv_opts => { :col_sep => "\t" })
+      #   table = Table.load('mydata.csv',:csv_options => { :col_sep => "\t" })
       #
       def load(csv_file, options={},&block)
         get_table_from_csv(:foreach, csv_file, options,&block)
@@ -144,7 +144,7 @@ module Ruport::Data
                r.attributes.all? { |a| a.kind_of?(Numeric) }
               r.to_a
             else
-              r.to_hash  
+              r.to_hash.values_at(*@column_names)  
             end
           }
         end 

data/lib/ruport/formatter.rb

@@ -122,7 +122,9 @@ module Ruport
       private
 
       def render_helper(rend_klass, source_data,options={},&block)
-        options = {:data => source_data, :io => output}.merge(options)
+        options = {:data => source_data, 
+                   :io => output,
+                   :layout => false }.merge(options)
         rend_klass.render(format,options) do |rend|
           block[rend] if block
         end

data/lib/ruport/renderer.rb

@@ -191,7 +191,7 @@ class Ruport::Renderer
 
       prepare self.class.first_stage if self.class.first_stage
                 
-      if formatter.respond_to?(:layout)
+      if formatter.respond_to?(:layout)  && options.layout != false
         formatter.layout do execute_stages end
       else
         execute_stages
@@ -382,7 +382,7 @@ class Ruport::Renderer
       rend = build(*args) { |r|        
           yield(r) if block_given?   
         r.setup if r.respond_to? :setup
-      }
+      }  
       if rend.respond_to? :run
         rend.run
       else

data/lib/ruport/renderer.rb.orig

@@ -0,0 +1,542 @@
+# renderer.rb : General purpose formatted data renderer for Ruby Reports
+#
+# Copyright December 2006, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+
+# This class implements the core renderer for Ruport's formatting system.  It is
+# designed to implement the low level tools necessary to build report renderers
+# for different kinds of tasks.  See Renderer::Table for a tabular data
+# renderer.  
+#
+class Ruport::Renderer
+  
+  class RequiredOptionNotSet < RuntimeError #:nodoc:
+  end
+  class UnknownFormatError < RuntimeError #:nodoc:
+  end
+  class StageAlreadyDefinedError < RuntimeError #:nodoc: 
+  end
+  class RendererNotSetError < RuntimeError #:nodoc:
+  end
+                                          
+  require "ostruct"              
+  
+  # Structure for holding renderer options.  
+  # Simplified version of HashWithIndifferentAccess
+  class Options < OpenStruct  
+    # returns a Hash object.  Use this if you need methods other than []
+    def to_hash
+      @table
+    end            
+    # indifferent lookup of an attribute, e.g.
+    #
+    #  options[:foo] == options["foo"]
+    def [](key)
+      send(key)
+    end 
+    
+    # Sets an attribute, with indifferent access.
+    #  
+    #  options[:foo] = "bar"  
+    #
+    #  options[:foo] == options["foo"] #=> true
+    #  options["foo"] == options.foo #=> true
+    #  options.foo #=> "bar"
+    def []=(key,value)
+      send("#{key}=",value)
+    end
+  end
+   
+  # This module provides hooks into Ruport's formatting system.
+  # It is used to implement the as() method for all of Ruport's datastructures,
+  # as well as the renders_with and renders_as_* helpers.
+  #
+  # You can actually use this with any data structure, it will look for a
+  # renderable_data method to pass to the <tt>renderer</tt> you specify, 
+  # but if that is not defined, it will pass <tt>self</tt> 
+  #
+  # Examples:
+  #
+  #   # Render Arrays with Ruport's Row Renderer
+  #   class Array
+  #     include Ruport::Renderer::Hooks
+  #     renders_as_row
+  #   end
+  #
+  #   # >> [1,2,3].as(:csv) 
+  #   # => "1,2,3\n" 
+  #
+  #   # Render Hashes with Ruport's Row Renderer
+  #   class Hash
+  #      include Ruport::Renderer::Hooks
+  #      renders_as_row
+  #      attr_accessor :column_order
+  #      def renderable_data
+  #         column_order.map { |c| self[c] }
+  #      end
+  #   end       
+  #
+  #   # >> a = { :a => 1, :b => 2, :c => 3 }
+  #   # >> a.column_order = [:b,:a,:c]
+  #   # >> a.as(:csv)
+  #   # => "2,1,3\n"
+  module Hooks 
+    module ClassMethods 
+      
+      # Tells the class which renderer as() will forward to.
+      #
+      # usage:
+      #
+      #   class MyStructure
+      #     include Renderer::Hooks
+      #     renders_with CustomRenderer
+      #   end
+      #   
+      # You can also specify default rendering options, which will be used
+      # if they are not overriden by the options passed to as()
+      #
+      #   class MyStructure
+      #      include Renderer::Hooks
+      #      renders_with CustomRenderer, :font_size => 14
+      #   end
+      def renders_with(renderer,opts={})
+        @renderer = renderer.name
+        @rendering_options=opts
+      end  
+      
+      # The default rendering options for a class, stored as a hash.
+      def rendering_options
+        @rendering_options
+      end
+       
+      # Shortcut for renders_with(Ruport::Renderer::Table), you
+      # may wish to override this if you build a custom table renderer.
+      def renders_as_table(options={})
+        renders_with Ruport::Renderer::Table,options
+      end
+      
+      # Shortcut for renders_with(Ruport::Renderer::Row), you
+      # may wish to override this if you build a custom row renderer. 
+      def renders_as_row(options={})
+        renders_with Ruport::Renderer::Row, options
+      end
+      
+      # Shortcut for renders_with(Ruport::Renderer::Group), you
+      # may wish to override this if you build a custom group renderer.  
+      def renders_as_group(options={})
+        renders_with Ruport::Renderer::Group,options
+      end 
+      
+      # Shortcut for renders_with(Ruport::Renderer::Grouping), you
+      # may wish to override this if you build a custom grouping renderer.
+      def renders_as_grouping(options={})
+        renders_with Ruport::Renderer::Grouping,options
+      end
+      
+      # The class of the renderer object for the base class.
+      #
+      # Example
+      # 
+      #   >> Ruport::Data::Table.renderer
+      #   => Ruport::Renderer::Table
+      def renderer
+        return unless @renderer
+        @renderer.split("::").inject(Class) { |c,el| c.const_get(el) }
+      end
+    end
+
+    def self.included(base) #:nodoc:
+      base.extend(ClassMethods)
+    end      
+    
+    # Uses the Renderer specified by renders_with to generate formatted
+    # output.  Passes the return value of the <tt>renderable_data</tt> method if
+    # the method is defined, otherwise passes <tt>self</tt> as :data
+    #
+    # The remaining options are converted to a Renderer::Options object and
+    # accessible in both the renderer and formatter.
+    #
+    #  Example:
+    #
+    #    table.as(:csv, :show_table_headers => false)
+    def as(format,options={})
+      raise RendererNotSetError unless self.class.renderer
+      unless self.class.renderer.formats.include?(format)
+        raise UnknownFormatError
+      end
+      self.class.renderer.render(format,
+       self.class.rendering_options.merge(options)) do |rend|
+         rend.data = respond_to?(:renderable_data) ? renderable_data : self
+         yield(rend) if block_given?  
+      end
+    end  
+  end
+
+                          
+  module AutoRunner  #:nodoc:
+    # called automagically when the report is rendered. Uses the
+    # data collected from the earlier methods.
+    def _run_
+
+      # ensure all the required options have been set
+      unless self.class.required_options.nil?
+        self.class.required_options.each do |opt|
+          if options.__send__(opt).nil?
+            raise RequiredOptionNotSet, "Required option #{opt} not set"
+          end
+        end
+      end
+
+      prepare self.class.first_stage if self.class.first_stage
+                
+      if formatter.respond_to?(:layout)
+        formatter.layout do execute_stages end
+      else
+        execute_stages
+      end
+
+      finalize self.class.final_stage if self.class.final_stage
+
+    end  
+    
+    def execute_stages
+      # call each stage to build the report
+      unless self.class.stages.nil?
+        self.class.stages.each do |stage|
+          self.send(:build,stage)
+        end
+      end
+    end
+  end
+  
+  class << self
+    
+    attr_accessor :first_stage,:final_stage,:required_options,:stages #:nodoc: 
+    
+    # Registers a hook to look for in the Formatter object when the render()
+    # method is called.                           
+    #
+    # Usage:
+    #
+    #   class MyRenderer < Ruport::Renderer
+    #      # other details omitted...
+    #      finalize :apple
+    #   end
+    #
+    #   class MyFormatter < Ruport::Formatter
+    #      renders :example, :for => MyRenderer
+    # 
+    #      # other details omitted... 
+    #    
+    #      def finalize_apple
+    #         # this method will be called when MyRenderer tries to render
+    #         # the :example format
+    #      end
+    #   end  
+    #
+    #  If a formatter does not implement this hook, it is simply ignored.
+    def finalize(stage)
+      if final_stage
+        raise StageAlreadyDefinedError, 'final stage already defined'      
+      end
+      self.final_stage = stage
+    end
+    
+    # Registers a hook to look for in the Formatter object when the render()
+    # method is called.                           
+    #
+    # Usage:
+    #
+    #   class MyRenderer < Ruport::Renderer
+    #      # other details omitted...
+    #      prepare :apple
+    #   end
+    #
+    #   class MyFormatter < Ruport::Formatter
+    #      renders :example, :for => MyRenderer
+    #
+    #      def prepare_apple
+    #         # this method will be called when MyRenderer tries to render
+    #         # the :example format
+    #      end        
+    #      
+    #      # other details omitted...
+    #   end  
+    #
+    #  If a formatter does not implement this hook, it is simply ignored.
+    def prepare(stage)
+      if first_stage
+        raise StageAlreadyDefinedError, "prepare stage already defined"      
+      end 
+      self.first_stage = stage
+    end
+    
+    # Registers hooks to look for in the Formatter object when the render()
+    # method is called.                           
+    #
+    # Usage:
+    #
+    #   class MyRenderer < Ruport::Renderer
+    #      # other details omitted...
+    #      stage :apple,:banana
+    #   end
+    #
+    #   class MyFormatter < Ruport::Formatter
+    #      renders :example, :for => MyRenderer
+    #
+    #      def build_apple
+    #         # this method will be called when MyRenderer tries to render
+    #         # the :example format
+    #      end 
+    #   
+    #      def build_banana
+    #         # this method will be called when MyRenderer tries to render
+    #         # the :example format
+    #      end    
+    #      
+    #      # other details omitted...
+    #   end  
+    #
+    #  If a formatter does not implement these hooks, they are simply ignored.          
+    def stage(*stage_list)
+      self.stages ||= []
+      stage_list.each { |stage|
+        self.stages << stage.to_s 
+      }
+    end
+     
+    # Defines attribute writers for the Renderer::Options object shared
+    # between Renderer and Formatter
+    #
+    # usage:
+    #   
+    #   class MyRenderer < Ruport::Renderer
+    #      option :font_size, :font_style
+    #      # other details omitted
+    #   end
+    def option(*opts)       
+      opts.each do |opt|                                  
+        o = opt 
+        unless instance_methods(false).include?(o.to_s)   
+          define_method(o) {
+             options.send(o.to_s) 
+          }     
+        end
+        opt = "#{opt}="
+        define_method(opt) {|t| options.send(opt, t) }
+      end
+    end
+    
+    # Defines attribute writers for the Renderer::Options object shared
+    # between Renderer and Formatter. Will throw an error if the user does
+    # not provide values for these options upon rendering.
+    #
+    # usage:
+    #   
+    #   class MyRenderer < Ruport::Renderer
+    #      required_option :employee_name, :address
+    #      # other details omitted
+    #   end
+    def required_option(*opts) 
+      self.required_options ||= []
+      opts.each do |opt|
+        self.required_options << opt 
+        option opt
+      end
+    end
+    
+
+    # Lists the formatters that are currently registered on a renderer,
+    # as a hash keyed by format name.
+    #
+    # Example:
+    # 
+    #   >> Ruport::Renderer::Table.formats
+    #   => {:html=>Ruport::Formatter::HTML, 
+    #   ?>  :csv=>Ruport::Formatter::CSV, 
+    #   ?>  :text=>Ruport::Formatter::Text, 
+    #   ?>  :pdf=>Ruport::Formatter::PDF}
+    def formats
+      @formats ||= {}
+    end
+    
+    # Builds up a renderer object, looks up the appropriate formatter,
+    # sets the data and options, and then does the following process:
+    #
+    #   * If the renderer contains a module Helpers, mix it in to the instance.
+    #   * If a block is given, yield the Renderer instance  
+    #   * If a setup() method is defined on the Renderer, call it
+    #   * If the renderer has defined a run() method, call it, otherwise,
+    #     include Renderer::AutoRunner. (you usually won't need a run() method )
+    #   * call _run_ if it exists (This is provided by default, by AutoRunner)
+    #   * return the results of formatter.output
+    #
+    # Note that the only time you will need a run() method is if you can't
+    # do what you need to via a helpers module or via setup()
+    #
+    # Please see the examples/ directory for custom renderer examples, because
+    # this is not nearly as complicated as it sounds in most cases.
+    def render(*args)
+      rend = build(*args) { |r|        
+          yield(r) if block_given?   
+        r.setup if r.respond_to? :setup
+      }
+      if rend.respond_to? :run
+        rend.run
+      else
+        include AutoRunner
+      end
+      rend._run_ if rend.respond_to? :_run_
+      return rend.formatter.output
+    end
+
+    # Allows you to set class_wide default options
+    # 
+    # Example:
+    #  
+    #  options { |o| o.style = :justified }
+    #
+    def options
+      @options ||= Ruport::Renderer::Options.new
+      yield(@options) if block_given?
+
+      return @options
+    end
+
+    # Creates a new instance of the renderer and sets it to use the specified
+    # formatter (by name).  If a block is given, the renderer instance is
+    # yielded.  
+    #
+    # Returns the renderer instance.
+    #
+    def build(*args)
+      rend = self.new
+
+      rend.send(:use_formatter,args[0])
+      rend.send(:options=, options.dup)
+      if rend.class.const_defined? :Helpers
+        rend.formatter.extend(rend.class.const_get(:Helpers))
+      end
+      if args[1].kind_of?(Hash)
+        d = args[1].delete(:data)
+        rend.data = d if d
+        args[1].each {|k,v| rend.options.send("#{k}=",v) }
+      end
+
+      yield(rend) if block_given?
+      return rend
+    end
+    
+    private
+    
+    # Allows you to register a format with the renderer.
+    #
+    # example:
+    #
+    #   class MyFormatter < Ruport::Formatter
+    #     # formatter code ...
+    #     SomeRenderer.add_format self, :my_formatter
+    #   end
+    #
+    def add_format(format,name=nil)
+      formats[name] = format
+    end
+    
+  end
+  
+  # The name of format being used
+  attr_accessor :format  
+  
+  # The formatter object being used
+  attr_writer :formatter  
+  
+  # The +data+ that has been passed to the active formatter.
+  def data
+    formatter.data
+  end
+
+  # Sets +data+ attribute on the active formatter.
+  def data=(val)
+    formatter.data = val.dup 
+  end
+
+  # Renderer::Options object which is shared with the current formatter.
+  def options
+    yield(formatter.options) if block_given?
+    formatter.options
+  end
+  
+  # If an IO object is given, Formatter#output will use it instead of 
+  # the default String.  For Ruport's core renderers, we technically
+  # can use any object that supports the << method, but it's meant
+  # for IO objects such as File or STDOUT
+  #
+  def io=(obj)
+    options.io=obj    
+  end
+
+  # When no block is given, returns active formatter.
+  #
+  # When a block is given with a block variable, sets the block variable to the
+  # formatter.  
+  #
+  # When a block is given without block variables, instance_evals the block
+  # within the context of the formatter.
+  #
+  def formatter(&block)
+    if block.nil?
+      return @formatter
+    elsif block.arity > 0
+      yield(@formatter)
+    else
+      @formatter.instance_eval(&block)
+    end
+    return @formatter
+  end
+
+  # Provides a shortcut to render() to allow
+  # render(:csv) to become render_csv
+  #
+  def self.method_missing(id,*args,&block)
+    id.to_s =~ /^render_(.*)/
+    unless args[0].kind_of? Hash
+      args = [ (args[1] || {}).merge(:data => args[0]) ]
+    end
+    $1 ? render($1.to_sym,*args,&block) : super
+  end
+  
+  private  
+
+  def prepare(name)
+    maybe "prepare_#{name}"
+  end
+
+  def build(names,prefix=nil)
+    return maybe("build_#{names}") if prefix.nil?
+    names.each { |n| maybe "build_#{prefix}_#{n}" }
+  end
+
+  def finalize(name)
+    maybe "finalize_#{name}"
+  end      
+  
+  def maybe(something)
+    formatter.send something if formatter.respond_to? something
+  end    
+
+  def options=(o)
+    formatter.options = o
+  end
+  
+  # selects a formatter for use by format name
+  def use_formatter(format)
+    self.formatter = self.class.formats[format].new
+    self.formatter.format = format
+  end
+
+end
+
+require "ruport/renderer/table"
+require "ruport/renderer/grouping"         

data/lib/ruport.rb

@@ -12,7 +12,7 @@
 
 module Ruport #:nodoc:#
   
-  VERSION = "1.0.1"   
+  VERSION = "1.0.2"   
   
   class FormatterError < RuntimeError #:nodoc:
   end
@@ -70,10 +70,15 @@ module Ruport #:nodoc:#
     rescue LoadError             # If we're not on Windows try...
       # A Unix savvy method to fetch the console columns, and rows.
       def terminal_size
-        size = `stty size 2>/dev/null`.split.map { |x| x.to_i }.reverse
-        return $? == 0 ? size : [80,24]
+        size = if /solaris/ =~ RUBY_PLATFORM
+          output = `stty`
+          [output.match('columns = (\d+)')[1].to_i,
+          output.match('rows = (\d+)')[1].to_i]
+        else
+           `stty size`.split.map { |x| x.to_i }.reverse
+        end 
+        return $? == 0 ? size : [80,24] 
       end
-
    end
    
    def terminal_width

data/test/renderer_test.rb

@@ -147,6 +147,11 @@ class TestFormatterWithLayout < Test::Unit::TestCase
      assert_equal "---\nheader\nbody\nfooter\n---\n", 
                   VanillaRenderer.render_text_with_layout
   end
+  
+  def test_layout_disabled
+     assert_equal "header\nbody\nfooter\n",
+                  VanillaRenderer.render_text_with_layout(:layout => false)
+  end
 
 end
 

data/test/renderer_test.rb.orig

@@ -0,0 +1,512 @@
+require 'test/helpers'
+
+###########################################################################
+#
+#  NOTE:
+#
+#  As it stands, we haven't found a more clever way to test the formatting
+#  system than to just create a bunch of renderers and basic formatters for
+#  different concepts we're trying to test.  Patches and ideas welcome:
+#
+#  list.rubyreports.org
+############################################################################
+
+#============================================================================
+# These two renderers represent the two styles that can be used when defining
+# renderers in Ruport.  The OldSchoolRenderer approach has largely been
+# deprecated, but still has uses in edge cases that we need to support.
+#============================================================================
+
+class OldSchoolRenderer < Ruport::Renderer
+
+  def run
+    formatter do
+      build_header
+      build_body
+      build_footer
+    end
+  end
+
+end               
+
+class VanillaRenderer < Ruport::Renderer
+  stage :header,:body,:footer
+end
+
+
+# This formatter implements some junk output so we can be sure
+# that the hooks are being set up right.  Perhaps these could
+# be replaced by mock objects in the future.
+class DummyText < Ruport::Formatter
+  
+  renders :text, :for => OldSchoolRenderer
+  
+  def prepare_document
+    output << "p"
+  end
+
+  def build_header
+    output << "header\n"
+  end
+
+  def build_body
+    output << "body\n"
+  end
+
+  def build_footer
+    output << "footer\n"
+  end
+
+  def finalize_document
+    output << "f"
+  end
+end   
+
+
+class TestRenderer < Test::Unit::TestCase
+
+  def test_trivial
+    actual = OldSchoolRenderer.render(:text)
+    assert_equal "header\nbody\nfooter\n", actual
+  end
+
+  def test_using_io
+    require "stringio"
+    out = StringIO.new
+    a = OldSchoolRenderer.render(:text) { |r| r.io = out }
+    out.rewind
+    assert_equal "header\nbody\nfooter\n", out.read
+    assert_equal "", out.read
+  end
+
+  def test_formats
+    assert_equal( {}, Ruport::Renderer.formats )
+    assert_equal( { :text => DummyText },OldSchoolRenderer.formats )
+  end
+
+  def test_method_missing
+    actual = OldSchoolRenderer.render_text
+    assert_equal "header\nbody\nfooter\n", actual
+  end
+
+  def test_formatter
+    # normal instance mode
+    rend = OldSchoolRenderer.new
+    rend.send(:use_formatter,:text)
+
+    assert_kind_of Ruport::Formatter, rend.formatter
+    assert_kind_of DummyText, rend.formatter
+
+    # render mode
+    OldSchoolRenderer.render_text do |r|
+      assert_kind_of Ruport::Formatter, r.formatter
+      assert_kind_of DummyText, r.formatter
+    end
+
+    assert_equal "body\n", rend.formatter { build_body }.output
+
+    rend.formatter.clear_output
+    assert_equal "", rend.formatter.output
+  end  
+  
+  def test_options_act_like_indifferent_hash
+     opts = Ruport::Renderer::Options.new
+     opts.foo = "bar"
+     assert_equal "bar", opts[:foo]
+     assert_equal "bar", opts["foo"]    
+     
+     opts["f"] = "bar"
+     assert_equal "bar", opts[:f]
+     assert_equal "bar", opts.f
+     assert_equal "bar", opts["f"]
+     
+     opts[:apple] = "banana"
+     assert_equal "banana", opts.apple
+     assert_equal "banana", opts["apple"]
+     assert_equal "banana", opts[:apple]
+  end     
+  
+end
+
+
+class TestFormatterWithLayout < Test::Unit::TestCase
+  # This formatter is meant to check out a special case in Ruport's renderer,
+  # in which a layout method is called and yielded to when defined
+  class WithLayout < DummyText
+     renders :text_with_layout, :for => VanillaRenderer 
+     
+     def layout     
+       output << "---\n"
+       yield
+       output << "---\n"
+     end
+     
+  end
+
+  def test_layout
+     assert_equal "---\nheader\nbody\nfooter\n---\n", 
+                  VanillaRenderer.render_text_with_layout
+  end
+
+end
+
+
+class TestRendererWithManyHooks < Test::Unit::TestCase
+  # This provides a way to check several hooks that Renderer supports
+  class RendererWithManyHooks < Ruport::Renderer
+
+    add_format DummyText, :text
+
+    prepare :document
+
+    option :subtitle, :subsubtitle
+
+    stage :header
+    stage :body
+    stage :footer
+
+    finalize :document
+
+    def setup
+      options.apple = true
+    end
+
+  end
+
+  def test_hash_options_setters
+    a = RendererWithManyHooks.render(:text, :subtitle => "foo",
+                                       :subsubtitle => "bar") { |r|
+      assert_equal "foo", r.options.subtitle
+      assert_equal "bar", r.options.subsubtitle
+    }
+  end
+
+  def test_data_accessors
+   a = RendererWithManyHooks.render(:text, :data => [1,2,4]) { |r|
+     assert_equal [1,2,4], r.data
+   }
+  
+   b = RendererWithManyHooks.render_text(%w[a b c]) { |r|
+     assert_equal %w[a b c], r.data
+   }
+  
+   c = RendererWithManyHooks.render_text(%w[a b f],:snapper => :red) { |r|
+     assert_equal %w[a b f], r.data
+     assert_equal :red, r.options.snapper
+   }
+  end
+
+  def test_stage_helper
+    assert RendererWithManyHooks.stages.include?('body')
+  end
+ 
+  def test_finalize_helper
+    assert_equal :document, RendererWithManyHooks.final_stage
+  end
+
+  def test_prepare_helper
+   assert_equal :document, RendererWithManyHooks.first_stage
+  end
+
+  def test_finalize_again
+   assert_raise(Ruport::Renderer::StageAlreadyDefinedError) { 
+     RendererWithManyHooks.finalize :report 
+   }
+  end
+
+  def test_prepare_again
+   assert_raise(Ruport::Renderer::StageAlreadyDefinedError) { 
+     RendererWithManyHooks.prepare :foo 
+   }
+  end
+
+  def test_renderer_using_helpers
+   actual = RendererWithManyHooks.render(:text)
+   assert_equal "pheader\nbody\nfooter\nf", actual
+
+   actual = RendererWithManyHooks.render_text
+   assert_equal "pheader\nbody\nfooter\nf", actual
+  end
+
+  def test_option_helper
+   RendererWithManyHooks.render_text do |r|
+     r.subtitle = "Test Report"
+     assert_equal "Test Report", r.options.subtitle
+   end
+  end
+
+  def test_required_option_helper
+   a = RendererWithManyHooks.dup
+   a.required_option :title
+
+   a.render_text do |r|
+     r.title = "Test Report"
+     assert_equal "Test Report", r.options.title
+   end
+
+  end
+
+  def test_without_required_option
+   a = RendererWithManyHooks.dup
+   a.required_option :title
+
+   assert_raise(Ruport::Renderer::RequiredOptionNotSet) { a.render(:text) }
+  end
+ 
+end
+
+
+class TestRendererWithRunHook < Test::Unit::TestCase
+
+  class RendererWithRunHook < Ruport::Renderer
+    
+    include AutoRunner
+
+    add_format DummyText, :text
+
+    required_option :foo,:bar
+    stage :header
+    stage :body
+    stage :footer
+
+    def run
+      formatter.output << "|"
+    end
+
+  end
+
+  def test_renderer_with_run_hooks
+    assert_equal "|header\nbody\nfooter\n", 
+       RendererWithRunHook.render_text(:foo => "bar",:bar => "baz")
+  end
+
+end
+
+
+class TestRendererWithHelperModule < Test::Unit::TestCase
+
+  class RendererWithHelperModule < VanillaRenderer
+
+    add_format DummyText, :stub
+
+    module Helpers
+      def say_hello
+        "Hello Dolly"
+      end
+    end
+  end   
+
+  def test_renderer_helper_module
+    RendererWithHelperModule.render_stub do |r|
+      assert_equal "Hello Dolly", r.formatter.say_hello
+    end
+  end
+end
+
+
+class TestMultiPurposeFormatter < Test::Unit::TestCase
+  # This provides a way to check the multi-format hooks for the Renderer
+  class MultiPurposeFormatter < Ruport::Formatter 
+
+     renders [:html,:text], :for => VanillaRenderer
+
+     def build_header
+       a = 10
+
+       text { output << "Foo: #{a}\n" }
+       html { output << "<b>Foo: #{a}</b>\n" } 
+     end
+
+     def build_body
+       html { output << "<pre>\n" }
+       output << options.body_text
+       html { output << "\n</pre>\n" }
+     end
+
+  end   
+
+  def test_multi_purpose
+    text = VanillaRenderer.render_text(:body_text => "foo")
+    assert_equal "Foo: 10\nfoo", text
+    html = VanillaRenderer.render_html(:body_text => "bar")
+    assert_equal "<b>Foo: 10</b>\n<pre>\nbar\n</pre>\n",html
+  end
+
+
+  def test_method_missing_hack_formatter
+    assert_equal [:html,:text], MultiPurposeFormatter.formats
+
+    a = MultiPurposeFormatter.new
+    a.format = :html
+    
+    visited = false
+    a.html { visited = true }
+
+    assert visited
+    
+    visited = false
+    a.text { visited = true }
+    assert !visited
+
+    assert_raises(NoMethodError) do
+      a.pdf { 'do nothing' }
+    end
+  end
+
+end
+
+
+class TestFormatterErbHelper < Test::Unit::TestCase
+  class ErbFormatter < Ruport::Formatter
+     
+    renders :terb, :for  => VanillaRenderer
+    
+    def build_body    
+       # demonstrate local binding
+       @foo = "bar"                         
+       if options.binding
+         output << erb("Binding Override: <%= reverse %>", 
+                       :binding => options.binding) 
+       else   
+         output << erb("Default Binding: <%= @foo %>") 
+       end   
+    end
+    
+  end
+
+   #FIXME: need to test file
+
+   def test_self_bound
+     assert_equal "Default Binding: bar", VanillaRenderer.render_terb
+   end
+   
+   def test_custom_bound
+     a = [1,2,3]
+     arr_binding = a.instance_eval { binding }
+     assert_equal "Binding Override: 321", 
+                   VanillaRenderer.render_terb(:binding => arr_binding)
+   end
+end    
+
+
+class TestOptionReaders < Test::Unit::TestCase
+  
+  class RendererForCheckingOptionReaders < Ruport::Renderer
+    option :foo  
+  end 
+  
+  class RendererForCheckingPassivity < Ruport::Renderer
+    def foo
+      "apples"
+    end
+    option :foo    
+  end
+
+   def setup 
+     @renderer = RendererForCheckingOptionReaders.new 
+     @renderer.formatter = Ruport::Formatter.new 
+     
+     @passive = RendererForCheckingPassivity.new
+     @passive.formatter = Ruport::Formatter.new
+   end
+   
+   def test_options_are_readable
+      @renderer.foo = 5
+      assert_equal 5, @renderer.foo
+   end                                   
+   
+   def test_methods_are_not_overridden
+     @passive.foo = 5
+     assert_equal "apples", @passive.foo
+     assert_equal 5, @passive.options.foo
+     assert_equal 5, @passive.formatter.options.foo
+   end
+     
+end
+     
+class TestSetupOrdering < Test::Unit::TestCase
+   
+  class RendererWithSetup < Ruport::Renderer
+     option :foo
+     stage :bar
+     def setup
+        foo.capitalize!
+     end        
+  end           
+  
+  class BasicFormatter < Ruport::Formatter 
+    renders :text, :for => RendererWithSetup
+    
+    def build_bar
+      output << options.foo
+    end
+  end
+  
+  def test_render_hash_options_should_be_called_before_setup
+     assert_equal "Hello", RendererWithSetup.render_text(:foo => "hello")
+  end       
+  
+  def test_render_block_should_be_called_before_setup
+     assert_equal "Hello", 
+                   RendererWithSetup.render_text { |r| r.foo = "hello" }
+  end
+  
+end
+
+class TestRendererHooks < Test::Unit::TestCase
+
+  context "when renderable_data omitted" do
+
+    require "mocha"
+
+    class DummyObject 
+      include Ruport::Renderer::Hooks
+      renders_as_table
+    end
+
+    def specify_should_return_self
+      a = DummyObject.new
+      rend = mock("renderer")
+      rend.expects(:data=).with(a)
+      Ruport::Renderer::Table.expects(:render).with(:csv,{}).yields(rend)
+      a.as(:csv)
+    end
+
+  end
+
+  context "when using renderable_data" do
+
+    class DummyObject2
+      include Ruport::Renderer::Hooks
+      renders_as_table
+
+      def renderable_data
+        1
+      end
+    end
+
+    def specify_should_return_results_of_renderable_data
+      a = DummyObject2.new
+      rend = mock("renderer")
+      rend.expects(:data=).with(1)
+      Ruport::Renderer::Table.expects(:render).with(:csv,{}).yields(rend)
+      a.as(:csv)
+    end
+
+    class DummyObject3
+      include Ruport::Renderer::Hooks
+      renders_as_table
+      
+      def renderable_data
+        raise ArgumentError
+      end
+    end
+
+    def specify_should_not_mask_errors
+      assert_raises(ArgumentError) { DummyObject3.new.as(:csv) }
+    end
+
+
+  end
+
+end

data/test/table_test.rb

@@ -82,6 +82,14 @@ class TestTable < Test::Unit::TestCase
                 table.sub_table(2..-1)   
                   
   end
+  
+  def test_subtable_records_have_correct_data
+    table = [ [1,2,3,4],[5,6,7,9],
+              [10,11,12,13],[14,15,16,17] ].to_table(%w[a b c d])
+    sub = table.sub_table(%w[b c d]) {|r| r.a == 1 }
+    assert_equal({"b"=>2, "c"=>3, "d"=>4}, sub[0].data)
+    assert_equal(["b", "c", "d"], sub[0].attributes)
+  end
 
   def test_reduce
     table = [ [1,2,3,4],[5,6,7,9],

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: ruport
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
-date: 2007-06-12 00:00:00 -04:00
+  version: 1.0.2
+date: 2007-08-22 00:00:00 -04:00
 summary: A generalized Ruby report generation and templating engine.
 require_paths: 
 - lib
@@ -30,106 +30,108 @@ authors:
 - Gregory Brown
 files: 
 - examples/btree
-- examples/btree/commaleon
-- examples/btree/commaleon/sample_data
-- examples/btree/commaleon/sample_data/ticket_count.csv
-- examples/btree/commaleon/sample_data/ticket_count2.csv
-- examples/btree/commaleon/commaleon.rb
-- examples/data
-- examples/data/tattle.dump
-- examples/row_renderer.rb
-- examples/RWEmerson.jpg
 - examples/centered_pdf_text_box.rb
-- examples/tattle_rubygems_version.rb
-- examples/trac_ticket_status.rb
+- examples/data
+- examples/example.csv
 - examples/line_plotter.rb
-- examples/png_embed.rb
 - examples/pdf_report_with_common_base.rb
-- examples/example.csv
-- examples/tattle_ruby_version.rb
+- examples/png_embed.rb
 - examples/roadmap.png
+- examples/row_renderer.rb
+- examples/RWEmerson.jpg
 - examples/simple_pdf_lines.rb
+- examples/tattle_ruby_version.rb
+- examples/tattle_rubygems_version.rb
+- examples/trac_ticket_status.rb
+- examples/btree/commaleon
+- examples/btree/commaleon/commaleon.rb
+- examples/btree/commaleon/sample_data
+- examples/btree/commaleon/sample_data/ticket_count.csv
+- examples/btree/commaleon/sample_data/ticket_count2.csv
+- examples/data/tattle.dump
 - lib/ruport
-- lib/ruport/formatter
-- lib/ruport/formatter/html.rb
-- lib/ruport/formatter/text.rb
-- lib/ruport/formatter/pdf.rb
-- lib/ruport/formatter/csv.rb
-- lib/ruport/query
-- lib/ruport/query/sql_split.rb
-- lib/ruport/renderer
-- lib/ruport/renderer/table.rb
-- lib/ruport/renderer/grouping.rb
+- lib/ruport.rb
+- lib/uport.rb
+- lib/ruport/acts_as_reportable.rb
 - lib/ruport/data
-- lib/ruport/data/record.rb
-- lib/ruport/data/table.rb
-- lib/ruport/data/grouping.rb
+- lib/ruport/data.rb
 - lib/ruport/extensions.rb
+- lib/ruport/formatter
 - lib/ruport/formatter.rb
+- lib/ruport/query
 - lib/ruport/query.rb
+- lib/ruport/renderer
 - lib/ruport/renderer.rb
-- lib/ruport/data.rb
-- lib/ruport/acts_as_reportable.rb
-- lib/uport.rb
-- lib/ruport.rb
-- test/samples
-- test/samples/test.yaml
-- test/samples/query_test.sql
-- test/samples/data.csv
-- test/samples/data.tsv
-- test/samples/erb_test.sql
-- test/samples/ticket_count.csv
-- test/samples/ruport_test.sql
-- test/samples/addressbook.csv
-- test/samples/dates.csv
-- test/samples/test.sql
+- lib/ruport/renderer.rb.orig
+- lib/ruport/data/grouping.rb
+- lib/ruport/data/record.rb
+- lib/ruport/data/table.rb
+- lib/ruport/formatter/csv.rb
+- lib/ruport/formatter/html.rb
+- lib/ruport/formatter/pdf.rb
+- lib/ruport/formatter/text.rb
+- lib/ruport/query/sql_split.rb
+- lib/ruport/renderer/grouping.rb
+- lib/ruport/renderer/table.rb
+- test/acts_as_reportable_test.rb
 - test/csv_formatter_test.rb
-- test/record_test.rb
+- test/grouping_test.rb
 - test/helpers.rb
+- test/html_formatter_test.rb
+- test/pdf_formatter_test.rb
 - test/query_test.rb
+- test/record_test.rb
 - test/renderer_test.rb
-- test/html_formatter_test.rb
+- test/renderer_test.rb.orig
+- test/samples
+- test/sql_split_test.rb
 - test/table_test.rb
 - test/text_formatter_test.rb
-- test/grouping_test.rb
-- test/sql_split_test.rb
-- test/acts_as_reportable_test.rb
-- test/pdf_formatter_test.rb
+- test/samples/addressbook.csv
+- test/samples/data.csv
+- test/samples/data.tsv
+- test/samples/dates.csv
+- test/samples/erb_test.sql
+- test/samples/query_test.sql
+- test/samples/ruport_test.sql
+- test/samples/test.sql
+- test/samples/test.yaml
+- test/samples/ticket_count.csv
+- util/bench/data
 - util/bench/formatter
-- util/bench/formatter/bench_html.rb
-- util/bench/formatter/bench_text.rb
-- util/bench/formatter/bench_pdf.rb
-- util/bench/formatter/bench_csv.rb
 - util/bench/samples
-- util/bench/samples/tattle.csv
-- util/bench/data
+- util/bench/data/record
 - util/bench/data/table
+- util/bench/data/record/bench_as_vs_to.rb
+- util/bench/data/record/bench_constructor.rb
+- util/bench/data/record/bench_indexing.rb
+- util/bench/data/record/bench_reorder.rb
+- util/bench/data/record/bench_to_a.rb
 - util/bench/data/table/bench_column_manip.rb
+- util/bench/data/table/bench_dup.rb
 - util/bench/data/table/bench_init.rb
 - util/bench/data/table/bench_manip.rb
-- util/bench/data/table/bench_dup.rb
-- util/bench/data/record
-- util/bench/data/record/bench_reorder.rb
-- util/bench/data/record/bench_to_a.rb
-- util/bench/data/record/bench_constructor.rb
-- util/bench/data/record/bench_indexing.rb
-- util/bench/data/record/bench_as_vs_to.rb
+- util/bench/formatter/bench_csv.rb
+- util/bench/formatter/bench_html.rb
+- util/bench/formatter/bench_pdf.rb
+- util/bench/formatter/bench_text.rb
+- util/bench/samples/tattle.csv
 - Rakefile
 - README
 - LICENSE
 - AUTHORS
 test_files: 
+- test/acts_as_reportable_test.rb
 - test/csv_formatter_test.rb
-- test/record_test.rb
+- test/grouping_test.rb
+- test/html_formatter_test.rb
+- test/pdf_formatter_test.rb
 - test/query_test.rb
+- test/record_test.rb
 - test/renderer_test.rb
-- test/html_formatter_test.rb
+- test/sql_split_test.rb
 - test/table_test.rb
 - test/text_formatter_test.rb
-- test/grouping_test.rb
-- test/sql_split_test.rb
-- test/acts_as_reportable_test.rb
-- test/pdf_formatter_test.rb
 rdoc_options: 
 - --title
 - Ruport Documentation