ruport 1.6.3 → 1.7.1

data/lib/ruport/formatter/prawn_pdf.rb

@@ -0,0 +1,72 @@
+module Ruport
+  class Formatter::PrawnPDF < Formatter
+
+    renders :prawn_pdf, :for =>[Controller::Row, Controller::Table,
+                              Controller::Group, Controller::Grouping]
+
+    attr_accessor :pdf
+
+    def method_missing(id,*args, &block)
+      pdf.send(id,*args, &block)
+    end
+
+    def initialize
+      require 'prawn'
+      require 'prawn/layout'
+    end
+
+    def pdf
+      @pdf ||= (options.formatter || 
+        ::Prawn::Document.new(options[:pdf_format] || {} ))
+    end
+
+    def draw_table(table, format_opts={})
+      m = "PDF Formatter requires column_names to be defined"
+      raise FormatterError, m if table.column_names.empty?
+
+      table.rename_columns { |c| c.to_s }
+
+      table_array = [table.column_names]
+      table_array += table_to_array(table)
+      table_array.map { |array| array.map! { |elem| elem.class != String ? elem.to_s : elem }}
+
+      if options[:table_format]
+        opt = options[:table_format] 
+      else
+        opt = {}
+      end
+
+      pdf.table(table_array,opt)
+
+    end
+
+    def table_to_array(tbl)
+      tbl.map { |row| row.to_a}
+    end
+
+    def finalize
+      output << pdf.render
+    end
+
+    def build_table_body
+      draw_table(data)
+    end
+
+    def build_group_body
+      render_table data, options.to_hash.merge(:formatter => pdf)
+    end
+
+    def build_grouping_body
+      data.each do |name,group|
+
+        # Group heading
+        move_down(20)
+        text name, :style => :bold, :size => 15
+
+        # Table
+        move_down(10)
+        draw_table group
+      end
+    end
+  end
+end

data/lib/ruport/formatter/template.rb

@@ -140,7 +140,7 @@ class Ruport::Formatter::TemplateNotDefined < StandardError; end
 # 
 #   format_options  All options         Corresponding values
 #                   available to
-#                   FasterCSV.new
+#                   ::CSV.new
 #
 class Ruport::Formatter::Template < Ruport::Controller::Options
   

data/lib/ruport/version.rb

@@ -1,3 +1,3 @@
 module Ruport
-  VERSION = "1.6.3"
+  VERSION = "1.7.1"
 end

data/test/controller_test.rb

@@ -94,7 +94,7 @@ class SpecialFinalize < Ruport::Formatter
   end
 end
 
-class TestController < Test::Unit::TestCase
+class TestController < Minitest::Test
 
   def teardown
     Ruport::Formatter::Template.instance_variable_set(:@templates, nil)
@@ -115,14 +115,14 @@ class TestController < Test::Unit::TestCase
   context "when using templates" do
     def specify_apply_template_should_be_called
       Ruport::Formatter::Template.create(:stub)
-      Table(%w[a b c]).to_csv(:template => :stub) do |r| 
+      Ruport.Table(%w[a b c]).to_csv(:template => :stub) do |r|
        r.formatter.expects(:apply_template)
       end  
     end 
 
     def specify_undefined_template_should_throw_sensible_error
       assert_raises(Ruport::Formatter::TemplateNotDefined) do
-        Table(%w[a b c]).to_csv(:template => :sub)
+        Ruport.Table(%w[a b c]).to_csv(:template => :sub)
       end 
     end
   end
@@ -130,7 +130,7 @@ class TestController < Test::Unit::TestCase
   context "when using default templates" do
     def specify_default_template_should_be_called
       Ruport::Formatter::Template.create(:default)
-      Table(%w[a b c]).to_csv do |r| 
+      Ruport.Table(%w[a b c]).to_csv do |r|
         r.formatter.expects(:apply_template)
         assert r.formatter.template == Ruport::Formatter::Template[:default]
       end  
@@ -139,7 +139,7 @@ class TestController < Test::Unit::TestCase
     def specify_specific_should_override_default
       Ruport::Formatter::Template.create(:default)
       Ruport::Formatter::Template.create(:stub)
-      Table(%w[a b c]).to_csv(:template => :stub) do |r| 
+      Ruport.Table(%w[a b c]).to_csv(:template => :stub) do |r|
         r.formatter.expects(:apply_template)
         assert r.formatter.template == Ruport::Formatter::Template[:stub]
       end  
@@ -147,7 +147,7 @@ class TestController < Test::Unit::TestCase
 
     def specify_should_be_able_to_disable_templates
       Ruport::Formatter::Template.create(:default)
-      Table(%w[a b c]).to_csv(:template => false) do |r| 
+      Ruport.Table(%w[a b c]).to_csv(:template => false) do |r|
         r.formatter.expects(:apply_template).never
       end  
     end
@@ -176,7 +176,7 @@ class TestController < Test::Unit::TestCase
   def test_using_file_via_rendering_tools     
     f = []
     File.expects(:open).yields(f)  
-    Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).save_as("foo.csv")      
+    Ruport.Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).save_as("foo.csv")
     assert_equal "a,b,c\n1,2,3\n4,5,6\n", f[0]  
   end
     
@@ -231,7 +231,7 @@ class TestController < Test::Unit::TestCase
 end
 
 
-class TestFormatterUsingBuild < Test::Unit::TestCase
+class TestFormatterUsingBuild < Minitest::Test
   # This formatter uses the build syntax
   class UsesBuild < Ruport::Formatter
      renders :text_using_build, :for => VanillaController 
@@ -261,7 +261,7 @@ class TestFormatterUsingBuild < Test::Unit::TestCase
 end
 
 
-class TestFormatterWithLayout < Test::Unit::TestCase
+class TestFormatterWithLayout < Minitest::Test
   # 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
@@ -288,7 +288,7 @@ class TestFormatterWithLayout < Test::Unit::TestCase
 end
 
 
-class TestControllerWithManyHooks < Test::Unit::TestCase
+class TestControllerWithManyHooks < Minitest::Test
   # This provides a way to check several hooks that controllers supports
   class ControllerWithManyHooks < Ruport::Controller
     add_format DummyText, :text
@@ -351,13 +351,13 @@ class TestControllerWithManyHooks < Test::Unit::TestCase
   end
 
   def test_finalize_again
-   assert_raise(Ruport::Controller::StageAlreadyDefinedError) { 
+   assert_raises(Ruport::Controller::StageAlreadyDefinedError) { 
      ControllerWithManyHooks.finalize :report 
    }
   end
 
   def test_prepare_again
-   assert_raise(Ruport::Controller::StageAlreadyDefinedError) { 
+   assert_raises(Ruport::Controller::StageAlreadyDefinedError) { 
      ControllerWithManyHooks.prepare :foo 
    }
   end
@@ -385,13 +385,13 @@ class TestControllerWithManyHooks < Test::Unit::TestCase
    a = ControllerWithManyHooks.dup
    a.required_option :title
 
-   assert_raise(Ruport::Controller::RequiredOptionNotSet) { a.render(:text) }
+   assert_raises(Ruport::Controller::RequiredOptionNotSet) { a.render(:text) }
   end
  
 end
 
 
-class TestControllerWithRunHook < Test::Unit::TestCase
+class TestControllerWithRunHook < Minitest::Test
 
   class ControllerWithRunHook < Ruport::Controller
     add_format DummyText, :text
@@ -416,7 +416,7 @@ class TestControllerWithRunHook < Test::Unit::TestCase
 end
 
 
-class TestControllerWithHelperModule < Test::Unit::TestCase
+class TestControllerWithHelperModule < Minitest::Test
 
   class ControllerWithHelperModule < VanillaController
 
@@ -437,7 +437,7 @@ class TestControllerWithHelperModule < Test::Unit::TestCase
 end
 
 
-class TestMultiPurposeFormatter < Test::Unit::TestCase
+class TestMultiPurposeFormatter < Minitest::Test
   # This provides a way to check the multi-format hooks for the Controller
   class MultiPurposeFormatter < Ruport::Formatter 
 
@@ -489,40 +489,40 @@ class TestMultiPurposeFormatter < Test::Unit::TestCase
 end
 
 
-class TestFormatterErbHelper < Test::Unit::TestCase
+class TestFormatterErbHelper < Minitest::Test
   class ErbFormatter < Ruport::Formatter
-     
+
     renders :terb, :for  => VanillaController
-    
-    def build_body    
+
+    def build_body
        # demonstrate local binding
-       @foo = "bar"                         
+       @foo = "bar"
        if options.binding
-         output << erb("Binding Override: <%= reverse %>", 
-                       :binding => options.binding) 
-       else   
-         output << erb("Default Binding: <%= @foo %>") 
-       end   
+         output << erb("Binding Override: <%= reverse.inspect %>",
+                       :binding => options.binding)
+       else
+         output << erb("Default Binding: <%= @foo %>")
+       end
     end
     
   end
 
-   #FIXME: need to test file
+  #FIXME: need to test file
 
    def test_self_bound
      assert_equal "Default Binding: bar", VanillaController.render_terb
    end
-   
+
    def test_custom_bound
      a = [1,2,3]
      arr_binding = a.instance_eval { binding }
-     assert_equal "Binding Override: 321", 
+     assert_equal "Binding Override: [3, 2, 1]",
                    VanillaController.render_terb(:binding => arr_binding)
    end
-end    
+end
 
 
-class TestOptionReaders < Test::Unit::TestCase
+class TestOptionReaders < Minitest::Test
   
   class ControllerForCheckingOptionReaders < Ruport::Controller
     required_option :foo  
@@ -557,7 +557,7 @@ class TestOptionReaders < Test::Unit::TestCase
      
 end
      
-class TestSetupOrdering < Test::Unit::TestCase
+class TestSetupOrdering < Minitest::Test
    
   class ControllerWithSetup < Ruport::Controller
     stage :bar
@@ -630,24 +630,20 @@ class ControllerWithAnonymousFormatters < Ruport::Controller
 
 end
 
-class TestAnonymousFormatter < Test::Unit::TestCase
-  context "When using built in Ruport formatters" do
+class TestAnonymousFormatter < Minitest::Test
 
-    def specify_text_formatter_shortcut_is_accessible
-      assert_equal "Hello world", ControllerWithAnonymousFormatters.render_text
-      assert_equal "1,2,3\n", ControllerWithAnonymousFormatters.render_csv
-      assert_equal "<h1>Hi there</h1>", ControllerWithAnonymousFormatters.render_html
+  def test_text_formatter_shortcut_is_accessible
+    assert_equal "Hello world", ControllerWithAnonymousFormatters.render_text
+    assert_equal "1,2,3\n", ControllerWithAnonymousFormatters.render_csv
+    assert_equal "<h1>Hi there</h1>", ControllerWithAnonymousFormatters.render_html
+    if RUBY_VERSION < "1.9"
       assert_not_nil ControllerWithAnonymousFormatters.render_pdf
     end
-    
   end
 
-  context "When using custom formatters" do
-    def specify_custom_formatter_shortcut_is_accessible
-      assert_equal "This is Custom!", ControllerWithAnonymousFormatters.render_custom
-    end
+  def test_custom_formatter_shortcut_is_accessible
+    assert_equal "This is Custom!", ControllerWithAnonymousFormatters.render_custom
   end
-
 end
 
 # Used to ensure that problems in controller code aren't mistakenly intercepted
@@ -663,106 +659,88 @@ class MisbehavingFormatter < Ruport::Formatter
   end
 end
 
-class TestMisbehavingController < Test::Unit::TestCase
+class TestMisbehavingController < Minitest::Test
 
-  context "using a controller that throws NoMethodError" do
-    def specify_controller_errors_should_bubble_up
-      assert_raises(NoMethodError) do
-        MisbehavingController.render :text
-      end
+  def test_controller_errors_should_bubble_up
+    assert_raises(NoMethodError) do
+      MisbehavingController.render :text
     end
   end
 
 end
 
-class TestControllerHooks < Test::Unit::TestCase
-
-  context "when renderable_data omitted" do
-
-    require "mocha"
-
-    class DummyObject 
-      include Ruport::Controller::Hooks
-      renders_as_table
-    end
+class TestControllerHooks < Minitest::Test
 
-    def specify_should_return_self
-      a = DummyObject.new
-      rend = mock("renderer")
-      rend.expects(:data=).with(a)
-      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
-      a.as(:csv)
-    end
+  require "mocha"
 
+  class DummyObject 
+    include Ruport::Controller::Hooks
+    renders_as_table
   end
 
-  context "when using renderable_data" do
-
-    class DummyObject2
-      include Ruport::Controller::Hooks
-      renders_as_table
-
-      def renderable_data(format)
-        1
-      end
-    end
-
-    def specify_should_return_results_of_renderable_data
-      a = DummyObject2.new
-      rend = mock("renderer")
-      rend.expects(:data=).with(1)
-      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
-      a.as(:csv)
-    end
+  def test_should_return_self
+    a = DummyObject.new
+    rend = mock("renderer")
+    rend.expects(:data=).with(a)
+    Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
+    a.as(:csv)
+  end
 
-    class DummyObject3
-      include Ruport::Controller::Hooks
-      renders_as_table
-      
-      def renderable_data
-        raise ArgumentError
-      end
-    end
+  class DummyObject2
+    include Ruport::Controller::Hooks
+    renders_as_table
 
-    def specify_should_not_mask_errors
-      assert_raises(ArgumentError) { DummyObject3.new.as(:csv) }
+    def renderable_data(format)
+      1
     end
+  end
 
-    class DummyObject4
-      include Ruport::Controller::Hooks
-      renders_as_table
-
-      def renderable_data(format)
-        case format
-        when :html
-          1
-        when :csv
-          2
-        end
-      end
-    end
+  def test_should_return_results_of_renderable_data
+    a = DummyObject2.new
+    rend = mock("renderer")
+    rend.expects(:data=).with(1)
+    Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
+    a.as(:csv)
+  end
 
-    def specify_should_return_results_of_renderable_data_using_format
-      a = DummyObject4.new
-      rend = mock("renderer")
-      rend.expects(:data=).with(2)
-      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
-      a.as(:csv)
+  class DummyObject3
+    include Ruport::Controller::Hooks
+    renders_as_table
+    
+    def renderable_data
+      raise ArgumentError
     end
+  end
 
-  end    
-
-  context "when attempting to render a format that doesn't exist" do
+  def test_should_not_mask_errors
+    assert_raises(ArgumentError) { DummyObject3.new.as(:csv) }
+  end
 
-    def specify_an_unknown_format_error_should_be_raised
+  class DummyObject4
+    include Ruport::Controller::Hooks
+    renders_as_table
 
-      assert_raises(Ruport::Controller::UnknownFormatError) do
-        Ruport::Controller.render_foo
+    def renderable_data(format)
+      case format
+      when :html
+        1
+      when :csv
+        2
       end
-
     end
   end
 
+  def test_should_return_results_of_renderable_data_using_format
+    a = DummyObject4.new
+    rend = mock("renderer")
+    rend.expects(:data=).with(2)
+    Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
+    a.as(:csv)
+  end
 
-
+  def test_an_unknown_format_error_should_be_raised
+    assert_raises(Ruport::Controller::UnknownFormatError) do
+      Ruport::Controller.render_foo
+    end
+  end
 end