ruport 0.6.1 → 0.7.0

data/lib/ruport/format/plugin/pdf_plugin.rb

@@ -1,126 +0,0 @@
-module Ruport
-  class Format::Plugin    
-    class PDFPlugin < Format::Plugin
-      attribute :pdf
-      attribute :paper
-
-      helper(:init_plugin) {
-        require "pdf/writer"
-        require "pdf/simpletable"
-        self.pdf = PDF::Writer.new( :paper => paper || "LETTER" )
-      }
-
-      renderer :table do
-        pre[pdf] if pre
-        PDF::SimpleTable.new do |table|
-          table.maximum_width = 500
-          table.orientation = :center
-          table.data = data
-          m = "Sorry, cant build PDFs from array like things (yet)"      
-          raise m if self.rendered_field_names.empty? 
-          table.column_order = self.rendered_field_names
-          table.render_on(pdf)
-        end
-        post[pdf] if post
-        pdf.render
-      end
-
-      format_field_names { data.column_names }
-      
-      renderer(:invoice) { pdf.render }
-
-      # Company Information in top lefthand corner
-      helper(:build_company_header, :engine => :invoice_engine) { |eng| 
-        @tod = pdf.y
-        text_box(eng.company_info)
-      }
-
-      helper(:build_headers, :engine => :invoice_engine) { |eng|
-        build_company_header_helper(eng)
-        build_customer_header_helper(eng)
-        build_title_helper(eng)
-        build_order_header_helper(eng)
-      }
-
-      helper(:build_order_header, :engine => :invoice_engine) { |eng|
-        if eng.order_info
-          text_box(eng.order_info, :position => 350)
-        end
-      }
-
-      helper(:build_title, :engine => :invoice_engine) { |eng|
-        pdf.y = @tod
-        if eng.title
-          pdf.text eng.title, :left => 350, :font_size => 14
-          pdf.y -= 10
-        end
-      }
-
-      helper(:build_footer, :engine => :invoice_engine) { |eng|
-        # footer
-        pdf.open_object do |footer|
-          pdf.save_state
-          pdf.stroke_color! Color::RGB::Black
-          pdf.stroke_style! PDF::Writer::StrokeStyle::DEFAULT
-          if eng.comments  
-            pdf.y -= 20
-            text_box eng.comments, :position => 110, :width => 400, 
-                                   :font_size => 14
-          end
-          pdf.add_text_wrap( 50, 20, 200, "Printed at " + 
-                             Time.now.strftime("%H:%M %d/%m/%Y"), 8)
-
-          pdf.restore_state
-          pdf.close_object
-          pdf.add_object(footer, :all_pages)
-        end
-        pdf.stop_page_numbering(true, :current)
-      } 
-       
-      helper(:build_body, :engine => :invoice_engine) do
-       pdf.start_page_numbering(500, 20, 8, :right)
-       
-        # order contents 
-        pdf.y = 620
-        
-        PDF::SimpleTable.new do |table|
-          table.width = 450
-          table.orientation = :center
-          table.data = data
-          table.show_lines = :outer
-          table.column_order = data.column_names
-          table.render_on(pdf)
-          table.font_size = 12
-        end
-      end
-
-      # Order details
-      helper(:build_customer_header, :engine => :invoice_engine) { |eng| 
-        pdf.y -= 10
-        text_box(eng.customer_info)
-      }
-     
-      def self.text_box(content,options={})
-        PDF::SimpleTable.new do |table| 
-          table.data = content.to_a.inject([]) do |s,line|
-            s << { "value" => line }
-          end
-          table.column_order = "value"
-          table.show_headings = false
-          table.show_lines  = :outer
-          table.shade_rows  = :none
-          table.width       = options[:width] || 200
-          table.orientation = options[:orientation] || :right
-          table.position = options[:position] || :left
-          table.font_size = options[:font_size] || 10
-          table.render_on(pdf)
-        end
-      end
-       
-      plugin_name :pdf
-      register_on :table_engine
-      register_on :invoice_engine     
-    end
-  end
-end
-

data/lib/ruport/format/plugin/svg_plugin.rb

@@ -1,61 +0,0 @@
-module Ruport
-  class Format::Plugin
-    class SVGPlugin < Format::Plugin
-      helper(:init_plugin) { |eng|
-        # check the supplied data can be used for graphing
-        data.each { |r|
-          if data.column_names.size != r.data.size
-            raise InvalidGraphDataError, 
-            "Column names and data do not match"           
-          end 
-          r.data.each { |c|
-            begin
-              c = BigDecimal.new(c) unless c.kind_of?(Float) || 
-                c.kind_of?(Fixnum) || c.kind_of?(BigDecimal)
-            rescue
-              raise InvalidGraphDataError, 
-              "Unable to convert #{c.to_s} into a number" 
-            end
-          }
-        }
-        
-        raise InvalidGraphOptionError, 
-        'You must provide a width before rendering a graph' if eng.width.nil?
-        raise InvalidGraphOptionError, 
-        'You must provide a height before rendering a graph' if eng.height.nil?
-        raise InvalidGraphOptionError, 
-        'You must provide a style before rendering a graph' if eng.style.nil?
-        if eng.style != :area && eng.style != :bar &&
-                                 eng.style != :line &&
-                                 eng.style != :smiles &&
-                                 eng.style != :stacked 
-          raise InvalidGraphOptionError, 'Invalid graph style'
-        end
-
-        require 'scruffy'
-        @graph = Scruffy::Graph.new
-        @graph.title = eng.title unless eng.title.nil?
-        @graph.theme = Scruffy::Themes::Mephisto.new  
-        @graph.point_markers = @data.column_names  
-        @graph_style = eng.style
-        @graph_width = eng.width
-        @graph_height = eng.height
-      }
-
-      renderer :graph do
-        
-        data.each_with_index { |r,i|
-          @graph.add(@graph_style, 
-                     r.tags[0] || 'series ' + (i+1).to_s, 
-                     r.data)
-        }
-        
-        # return the rendered graph
-        @graph.render(:size => [@graph_width, @graph_height])
-      end
-      
-      plugin_name :svg
-      register_on :graph_engine
-    end
-  end
-end

data/lib/ruport/format/plugin/text_plugin.rb

@@ -1,77 +0,0 @@
-module Ruport
-  class Format::Plugin
-    class TextPlugin < Format::Plugin
-      rendering_options :erb_enabled => true, :red_cloth_enabled => false
-
-      renderer :document
-      
-      renderer :table do 
-        require "ruport/system_extensions" 
-        
-        return "" if data.length == 0; 
-
-        calculate_max_col_widths
-
-        width = self.right_margin || SystemExtensions.terminal_width
-
-        s = "#{rendered_field_names}#{hr}"
-  
-        data.each { |r|
-          line = Array.new
-          r.each_with_index { |f,i|
-            line << f.to_s.center(max_col_width[i])
-          }
-          s += "| #{line.join(' | ')} |\n"
-        }
-        s += hr
-
-        s.split("\n").each { |r|
-           r.gsub!(/\A.{#{width+1},}/) { |m| m[0,width-2] + ">>" }
-        }.join("\n") + "\n"
-        
-      end
-      
-      format_field_names do
-        return "" if data.length == 0
-        calculate_max_col_widths
-        c=data.column_names.dup
-        c.each_with_index { |f,i| 
-          c[i] = f.to_s.center(max_col_width[i])
-        }
-        "#{hr}| #{c.to_a.join(' | ')} |\n"
-      end
-
-      action :max_col_width do
-        @max_col_width
-      end
-
-      action :calculate_max_col_widths do
-        @max_col_width=Array.new
-        if defined?(data.column_names)
-          data.column_names.each_index do |i| 
-            @max_col_width[i] = data.column_names[i].to_s.length
-          end
-        end
-            
-        data.each {|r|
-          r.each_with_index { |f,i|
-            if !max_col_width[i] || f.to_s.length > max_col_width[i]
-              max_col_width[i] = f.to_s.length
-            end
-          }
-        }
-      end
-
-      action :hr do
-        len = max_col_width.inject(data[0].to_a.length * 3) {|s,e| s+e} + 1
-        "+" + "-"*(len-2) + "+\n"
-      end
-
-      attribute :right_margin
-      plugin_name :text
-      register_on :table_engine
-      register_on :document_engine
-    end
-  end
-end
-

data/lib/ruport/meta_tools.rb

@@ -1,66 +0,0 @@
-# Gets raised if you try to add the same action to an object more than once. 
-class ActionAlreadyDefinedError < RuntimeError; end
-
-module Ruport
-
-  # 
-  # === Overview
-  #
-  # This module provides a few tools for doing some manipulations of the
-  # singleton class of an object.  These are used in the implementation of 
-  # Ruport's formatting system, and might be useful for other things.
-  #
-  module MetaTools
-    #
-    # Allows you to define an attribute accessor on the singleton class.
-    #
-    # Example:
-    # 
-    #  class A
-    #     extend Ruport::MetaTools
-    #     attribute :foo
-    #  end
-    #
-    #  A.foo      #=> nil
-    #  A.foo = 7  #=> 7 
-    #
-    def attribute(sym,value = nil)
-      singleton_class.send(:attr_accessor, sym )
-      self.send("#{sym}=",value)
-    end
-
-    #
-    # Same as <tt>attribute</tt>, but takes an Array of attributes.
-    #
-    # Example:
-    # 
-    #   attributes [:foo,:bar,:baz]
-    #
-    def attributes(syms)
-      syms.each { |s| attribute s }
-    end
-    
-    #
-    # Allows you to define a method on the singleton class.
-    #
-    # Example:
-    #
-    #   class A
-    #     extend Ruport::MetaTools
-    #     action(:bar) { |x| x + 1 }
-    #   end
-    #
-    #   A.bar(3)  #=> 4
-    #
-    def action(name,&block)
-      raise ActionAlreadyDefinedError if respond_to? name
-      singleton_class.send(:define_method, name, &block)
-    end
-    
-  end
-end
-
-class Module
-  # Provides the singleton_class object.
-  def singleton_class; (class << self; self; end); end
-end

data/lib/ruport/report/invoice.rb

@@ -1,29 +0,0 @@
-module Ruport
-  class Report
-    module Invoice #:nodoc:
-      
-      # Returns a Format::Engine::Invoice object
-      #
-      # If a block is given, it is possible to customize this object before it
-      # is returned
-      #
-      # Example:
-      #
-      #   inv = build_invoice do |i|
-      #     i.company_info  = "Foo Inc.\n42 Front Street\nNew Haven CT"
-      #     i.customer_info = "Joe User\njoe@test.com"
-      #     i.data = [["Aspirin","$2.00"]].to_table(%w[item cost])
-      #   end
-      def build_invoice
-        a = Ruport::Format.invoice_object(:plugin => :pdf)
-        yield(a); return a
-      end
-
-      # Takes a block and calls build_invoice then calls render on the resulting
-      # Format::Engine::Invoice object
-      def render_invoice(&block)
-        build_invoice(&block).render
-      end
-    end
-  end
-end

data/test/test_format.rb

@@ -1,39 +0,0 @@
-require "ruport"
-require "test/unit"
-
-begin; require "rubygems"; rescue LoadError; nil; end
-class TestFormat < Test::Unit::TestCase
- 
-  def setup
-    @format = Ruport::Format.new(binding)
-  end
-  
-  def test_filter_erb
-    @format.content = "<%= 4 + 2 %>"
-    assert_equal "6", @format.filter_erb
-    @name = "awesome"
-    @format.content = " <%= @name %> "
-    assert_equal " awesome ", @format.filter_erb
-  end
-
-  def test_filter_red_cloth
-    if defined? RedCloth
-      @format.content = "* foo\n* bar"
-      assert_equal "<ul>\n\t<li>foo</li>\n\t\t<li>bar</li>\n\t</ul>",
-                   @format.filter_red_cloth
-     end
-  end
-
-  def filter_ruby
-    @format.content = "Hash.new"
-    assert_equal({},@format.filter_ruby)
-  end
-
-  def test_register_filter
-      Ruport::Format.register_filter(:lower) { |content| content.downcase }
-      @format.content = "FoO"
-      assert_equal("foo", @format.filter_lower)
-  end
-
-end
-

data/test/test_format_engine.rb

@@ -1,264 +0,0 @@
-require 'ruport'
-begin; require 'rubygems'; rescue LoadError; nil; end
-require 'test/unit'
-
-class Naked < Ruport::Format::Engine
-  alias_engine Naked, :naked_engine 
-  Ruport::Format.build_interface_for Naked, :naked
-end
-
-
-class MockPlugin < Ruport::Format::Plugin
-  
-  renderer(:table) { "#{rendered_field_names}#{data}" }
- 
-  format_field_names { "#{data.column_names}" }
-  
-  renderer(:document) { data }
-
-  rendering_options :red_cloth_enabled => true, 
-                    :erb_enabled => true
-  
-  action(:reverse_data) { data.reverse }
-  action(:mock_action)  { "mock" }
-
-  helper(:test) { |eng| eng }
-
-  attribute :apple
-
-  helper(:complex_test) { |eng|
-    eng.rewrite_column(0) { "a" } if apple 
-  }
-
-  helper(:init_plugin) { |eng|
-    eng.options ||= {}
-    eng.options = options.merge!(:init_ran => true)
-  }
-
-  plugin_name :mock
-  register_on :table_engine
-  register_on :document_engine
-  register_on :naked_engine
-
-end
-
-class MockForTestingTableEngine < Ruport::Format::Plugin
-
-  renderer(:table) {}
-
-  format_field_names { raise }
-  plugin_name :table_mock
-  register_on :table_engine
-
-end
-
-class TestFormatEngine < Test::Unit::TestCase
-
-  def test_no_data_required
-    assert_nothing_raised { 
-      Ruport::Format.naked_object(:plugin => :mock).render 
-    }
-  end
-  
-  def test_init_plugin_helper
-    a = Ruport::Format.naked_object(:plugin => :mock)
-    a.render
-    assert a.options[:init_ran]
-  end
-
-  def test_options_hash 
-    a = Ruport::Format.naked_object(:plugin => :mock, :data => [1,2,3])
-    assert(a.respond_to?(:options))
-    assert(a.active_plugin.respond_to?(:options))
-    a.render
-    assert_equal a.options, a.active_plugin.options
-  end
-
-end
-
-class TestTabularFormatEngine < Test::Unit::TestCase
-  
-  include Ruport
-  
-  def setup
-    @engine = Format::Engine::Table.dup
-  end
-
-  def test_plugin_attributes
-    assert_equal nil, @engine.active_plugin.apple
-    @engine.active_plugin.apple = :banana
-    assert_equal :banana, @engine.active_plugin.apple
-  end
-
-  def test_ensure_column_names_only_rendered_if_non_empty
-    @engine.plugin = :mock
-    @engine.data = [[1,2,3]].to_table
-    assert_nothing_raised { @engine.render }
-  end
-
-  def test_basic_render
-     @engine.plugin = :mock
-     @engine.data = [[1,2,3],[4,5,6],[7,8,9]]
-     assert_equal( "#{@engine.data}", @engine.render )
-  end
-
-  def test_plugin_actions
-    @engine.plugin = :mock
-    @engine.data = [1,2,3,4]
-    assert_equal( [4,3,2,1], @engine.active_plugin.reverse_data )
-    assert_equal( "mock", @engine.active_plugin.mock_action )
-  end
-
-  def test_helper
-    @engine.plugin = :mock
-    assert_equal @engine, @engine.test
-    @engine.data = [[1,2,3],[4,5,6]]
-    @engine.complex_test
-    assert_equal([[1,2,3],[4,5,6]],@engine.data)
-    @engine.active_plugin.apple = true
-    @engine.complex_test
-    assert_equal([['a',2,3],['a',5,6]],@engine.data)
-  end
-
-  def test_render_without_field_names
-    @engine.plugin = :mock
-    @engine.show_field_names = false
-    
-    @engine.data = [[1,2,3],[4,5,6],[7,8,9]]
-    assert_equal "#{@engine.data}", @engine.render 
-  end
-
-  # test that attempting to render using an invalid plugin returns an exception
-  # with a useful message
-  def test_render_with_invalid_plugin
-    assert_raises(InvalidPluginError) {
-      Format.table(:plugin => :monkeys, 
-                   :data => [[1,2,3],[4,5,6],[7,8,9]].to_table(%w[a b c]))
-    }
-  end
-  
-  def test_simple_interface
-    expected = "#{[[1,2],[3,4]]}"
-    actual = Format.table(:plugin => :mock, :data => [[1,2],[3,4]]) 
-    assert_equal(expected,actual)
-  end
-
-  def test_rewrite_column
-    a = @engine.dup
-    a.plugin = :mock
-    
-    a.data = [[1,2],[3,4]].to_table(:column_names =>%w[a b])
-    a.rewrite_column("a") { |r| r["a"] + 1 }
-    assert_equal([[2,2],[4,4]].to_table(:column_names => %w[a b]),a.data)
-    assert_nothing_raised { a.render }
-    
-    a.data = [[5,6],[7,8]]
-    a.rewrite_column(1) { "apple" }
-    assert_equal [[5,"apple"],[7,"apple"]], a.data
-    assert_nothing_raised { a.render }
-  end
-
-  def test_num_columns
-    @engine.data = [[1,2,3,4],[5,6,7,8]]
-    assert_equal(4,@engine.num_cols)
-
-    @engine.data = [[1,2,3],[4,5,6]].to_table(:column_names => %w[a b c])
-    assert_equal(3,@engine.num_cols)
-  end
-
-  def test_plugin_access
-    @engine.plugin = :mock
-    @engine.data   = [[1,5],[3,8]]
-
-    #normal access
-    assert_equal :mock, @engine.active_plugin.plugin_name
-    assert_equal [[1,5],[3,8]], @engine.active_plugin.data
-
-    #block access
-    @engine.active_plugin do |p|
-      assert_equal :mock, p.plugin_name
-      assert_equal [[1,5],[3,8]], p.data
-    end
-  end
-
-  def test_prune
-    @engine.plugin = :mock
-    @engine.data = [[1,2,3],[1,4,3],[2,4,1]]
-    @engine.prune
-    assert_equal([[1,2,3],[nil,4,3],[2,4,1]],@engine.data)
-    @engine.data = [[1,2,3],[2,4,1],[2,7,9],[1,2,3],[1,7,9]]
-    @engine.prune
-    assert_equal([[1,2,3],[2,4,1],[nil,7,9],[1,2,3],[nil,7,9]],
-                 @engine.data)
-    @engine.data = [[1,2,3],[1,2,4],[1,3,7],[2,1,9],[2,2,3],[2,2,9]]
-    @engine.prune
-    assert_equal( [[1,2,3],[nil,nil,4],[nil,3,7],
-                   [2,1,9],[nil,2,3],[nil,nil,9]], @engine.data)
-     
-    @engine.data = [[1,2,3],[1,2,4],[1,3,7],[2,1,9],[2,2,3],[2,2,9]]
-    @engine.prune(1)
-    assert_equal( [[1,2,3],[nil,2,4],[nil,3,7],
-                   [2,1,9],[nil,2,3],[nil,2,9]], @engine.data)
-
-    data = Ruport::Data::Table.new :column_names => %w[name date service amount]
-    data << [ "Greg Gibson", "1/1/2000",  "Prophy",  "100.00" ] <<
-            [ "Greg Gibson", "1/1/2000",  "Filling", "100.00" ] <<
-            [ "Greg Gibson", "1/12/2000", "Prophy",  "100.00" ] <<
-            [ "Greg Gibson", "1/12/2000", "Filling", "100.00" ] <<
-            [ "Greg Brown",  "1/12/2000", "Prophy",  "100.00" ]
-
-    @engine.data = data
-    @engine.prune(1)
-    data2 = data.dup
-    data2[1][0] = data2[2][0] = data2[3][0] = nil
-    assert_equal(data2, @engine.data)
-    
-    @engine.data=data
-
-    data3 = data2.dup
-    data3[1][1] = data3[3][1] = nil
-    @engine.prune(2)
-
-    assert_equal(data3, @engine.data)
-  end
-
-end
-
-class TestDocumentFormatEngine < Test::Unit::TestCase
-  
-  include Ruport
-  
-  def setup
-    @engine = Format::Engine::Document.dup
-  end
-
-  def test_basic_render
-    @engine.plugin = :mock
-    @engine.red_cloth_enabled = true
-    @engine.erb_enabled = true
-    @engine.data = "* <%= 3 + 2 %>\n* <%= 'apple'.reverse %>\n* <%= [1,2][0] %>"
-    h = "<ul>\n\t<li>5</li>\n\t\t<li>elppa</li>\n\t\t<li>1</li>\n\t</ul>"
-    assert_equal h, @engine.render
-  end
-
-  def test_simple_interface
-   
-   d = "*<%= 'apple'.reverse %>*"
-   opts = { :data => d, :plugin => :mock }
-   
-   a = Format.document opts
-   assert_equal "<p><strong>elppa</strong></p>", a
-   
-   a = Format.document opts.merge!({:red_cloth_enabled => false})
-   assert_equal "*elppa*", a
-
-   a = Format.document opts.merge!({:erb_enabled => false})
-   assert_equal d, a
-
-   a = Format.document :data => d, :plugin => :mock
-   assert_equal "<p><strong>elppa</strong></p>", a
-   
-  end
-end
-  
-