ruport 0.6.1 → 0.7.0

data/lib/ruport/format/pdf.rb

@@ -0,0 +1,78 @@
+module Ruport::Format
+
+  # PDF generation plugin
+  #
+  #  layout options:
+  #     General:
+  #       * paper_size  #=> "LETTER"
+  #       * orientation #=> :center
+  #     
+  #     Table:
+  #       * table_width
+  #       * max_table_width #=> 500
+  #
+  class PDF < Plugin
+    attr_writer :pdf_writer
+    attr_accessor :table_header_proc
+    attr_accessor :table_footer_proc
+
+    def initialize
+      require "pdf/writer"
+      require "pdf/simpletable"
+    end
+
+    def pdf_writer
+      @pdf_writer ||= 
+        ::PDF::Writer.new( :paper => layout.paper_size || "LETTER" )
+    end
+
+    def build_table_header
+       table_header_proc[pdf_writer] if table_header_proc
+    end
+
+    def build_table_body
+      draw_table
+    end
+
+    def build_table_footer
+      table_footer_proc[pdf_writer] if table_footer_proc
+    end
+
+    def finalize_table
+      output << pdf_writer.render
+    end
+
+    def add_text(*args)
+      pdf_writer.text(*args)
+    end
+
+    def move_cursor(n) 
+      pdf_writer.y += n
+    end
+
+    def move_cursor_to(n)
+      pdf_writer.y = n
+    end
+
+    def pad(y,&block)
+      move_cursor -y
+      block.call
+      move_cursor -y
+    end
+
+    def draw_table
+      m = "Sorry, cant build PDFs from array like things (yet)"
+      raise m if data.column_names.empty?
+      ::PDF::SimpleTable.new do |table|
+        table.maximum_width = layout.max_table_width || 500
+        table.width         = layout.table_width if layout.table_width
+        table.orientation   = layout.orientation || :center
+        table.data          = data
+        table.column_order  = data.column_names
+        table.render_on(pdf_writer)
+      end
+    end
+
+
+  end
+end

data/lib/ruport/format/plugin.rb

@@ -1,76 +1,31 @@
-class InvalidGraphDataError < RuntimeError; end
-class InvalidGraphOptionError < RuntimeError; end
-
-require 'bigdecimal'
-require 'tempfile'
-
-class RenderingError < RuntimeError; end
+# format/plugin.rb : Generalized formatting plugin base class for Ruby Reports
+#
+# Created by Gregory Brown.  Copyright December 2006, All Rights Reserved.
+#
+# This is free software, please see LICENSE and COPYING for details.
 
 module Ruport
-  class Format::Plugin
-    
-    class << self
+  module Format
+    class Plugin
 
+      attr_accessor :layout
       attr_accessor :data
-      attr_accessor :options 
-      
-      include MetaTools
-
-      def helper(name,options={},&block)
-        if options[:engines]
-          options[:engines].each { |e| 
-            helpers[e].send(:define_method, "#{name}_helper", &block)
-          }
-        elsif options[:engine]
-          helpers[options[:engine]].send(  :define_method, 
-                                         "#{name}_helper", &block)
-        else
-          singleton_class.send( :define_method, "#{name}_helper", &block )
-        end
-      end
 
-      def helpers
-        @helpers ||= Hash.new { |h,k| h[k] = Module.new }
+      # Stores a string used for outputting formatted data.
+      def output
+        @output ||= ""
       end
 
-      private :singleton_class, :attribute, :attributes, :action
-     
-      def plugin_name(name=nil); @name ||= name; end
-      
-      def renderer(render_type,&block)
-        m = "render_#{render_type}".to_sym
-        block ||= lambda { data } 
-        singleton_class.send(:define_method, m, &block)
-      end
-
-      def format_field_names(&block)
-        singleton_class.send( :define_method, :build_field_names, &block)
-      end
+      # Provides a generic OpenStruct for storing plugin options
+      def options
+        @options ||= OpenStruct.new
+      end 
 
-      def register_on(*args)
-        args.each { |klass|
-          if klass.kind_of? Symbol
-            klass = Format::Engine.engine_classes[klass]
-          end
-        
-          klass.accept_format_plugin(self)
-        }
-      rescue NoMethodError
-        p caller
-      end
-      
-      def rendering_options(hash={})
-        @rendering_options ||= {}
-        @rendering_options.merge!(hash)
-        @rendering_options.dup
+      # clears output.  Useful if you are building your own interface to
+      # plugins.
+      def clear_output
+        @output.replace("")
       end
-     
-      attr_accessor :rendered_field_names
-      attr_accessor :pre, :post
-      attr_accessor :header, :footer
-      
     end
-  end       
+  end
 end
-plugins = %w[text csv pdf svg html latex]
-plugins.each { |p| require "ruport/format/plugin/#{p}_plugin" }

data/lib/ruport/format/svg.rb

@@ -0,0 +1,39 @@
+module Ruport::Format
+  class SVG < Plugin
+
+
+    def themes
+      { :mephisto => Scruffy::Themes::Mephisto.new,
+        :keynote  => Scruffy::Themes::Keynote.new,
+        :ruby_blog => Scruffy::Themes::RubyBlog.new }
+    end
+
+    def initialize
+      require 'scruffy'
+      
+      @graph = Scruffy::Graph.new
+    end
+
+    attr_reader :graph
+
+    def prepare_graph 
+      @graph.title ||= options.title
+      @graph.theme = layout.theme if layout.theme
+      @graph.point_markers ||= data.column_names
+
+    end
+
+    def build_graph
+      data.each_with_index do |r,i|
+        add_line(r.data,r.tags[0] || "series #{i+1}")
+      end
+
+      output << @graph.render(:size => [layout.width, layout.height])
+    end
+    
+    def add_line(row,label)
+      @graph.add( layout.style, label, row )
+    end
+
+  end
+end

data/lib/ruport/format/text.rb

@@ -0,0 +1,77 @@
+module Ruport
+  module Format
+    class Text < Plugin
+
+      def prepare_table
+        raise "Can't output empty table" if data.empty?
+        calculate_max_col_widths
+      end
+
+      def build_table_header
+        return if data.column_names.empty? || !layout.show_table_headers
+        c = data.column_names.dup
+        c.each_with_index { |f,i|
+          c[i] = f.to_s.center(layout.max_col_width[i])
+        }
+        output << fit_to_width("#{hr}| #{c.to_a.join(' | ')} |\n")
+      end
+
+      def build_table_body
+        s = hr
+  
+        data.each { |r|
+          line = Array.new
+          r.each_with_index { |f,i|
+            if layout.alignment.eql? :center
+              line << f.to_s.center(layout.max_col_width[i])
+            else
+              align = f.is_a?(Numeric) ? :rjust : :ljust
+              line << f.to_s.send(align, layout.max_col_width[i])
+            end
+          }
+          s += "| #{line.join(' | ')} |\n"
+        }
+        s += hr
+
+        output << fit_to_width(s)
+      end
+
+      def hr
+        len = layout.max_col_width.inject(data[0].to_a.length * 3) {|s,e|s+e}+1
+        "+" + "-"*(len-2) + "+\n"
+      end
+
+      def width
+        require "ruport/system_extensions"
+        layout.table_width || SystemExtensions.terminal_width
+      end
+
+      def fit_to_width(s)
+        s.split("\n").each { |r|
+           r.gsub!(/\A.{#{width+1},}/) { |m| m[0,width-2] + ">>" }
+        }.join("\n") + "\n"
+      end
+
+      def calculate_max_col_widths
+        # allow override
+        return if layout.max_col_width
+
+        layout.max_col_width=Array.new
+        unless data.column_names.empty?
+          data.column_names.each_index do |i| 
+            layout.max_col_width[i] = data.column_names[i].to_s.length
+          end
+        end
+            
+        data.each { |r|
+          r.each_with_index { |f,i|
+            if !layout.max_col_width[i] || f.to_s.length > layout.max_col_width[i]
+              layout.max_col_width[i] = f.to_s.length
+            end
+          }
+        } 
+      end
+
+    end
+  end
+end

data/lib/ruport/format/xml.rb

@@ -0,0 +1,32 @@
+module Ruport::Format
+  class XML < Plugin
+
+    def prepare_graph
+      require_gem "builder"
+      @builder = Builder::XmlMarkup.new(:indent => 2)
+    end
+
+    def build_graph
+      output << @builder.chart do |b|
+        b.chart_type(layout.style.to_s)
+
+        b.chart_data do |cd|
+          
+          cd.row { |first|
+            first.null
+            data.column_names.each { |c| first.string(c) }
+          }
+
+          data.each_with_index { |r,i|
+            label = r.tags[0] || "Region #{i}"
+            cd.row { |data_row|
+              data_row.string(label)
+              r.each { |e| data_row.number(e) }
+            }
+          }
+        end
+      end
+    end
+
+  end
+end

data/lib/ruport/format.rb

@@ -1,159 +1 @@
-# format.rb : Ruby Reports formatting module
-#
-# Author: Gregory T. Brown (gregory.t.brown at gmail dot com)
-#
-# Copyright (c) 2006, All Rights Reserved.
-#
-# This is free software.  You may modify and redistribute this freely under
-# your choice of the GNU General Public License or the Ruby License. 
-#
-# See LICENSE and COPYING for details
-module Ruport
-
-  # Ruport makes heavy use of ruby's advanced meta programming features in 
-  # this Class.
-  #
-  # All subclasses of Ruport::Format::Engine and Ruport::Format::Plugin
-  # (both Ruports' internal ones and any custom ones outside the Ruport 
-  # library) should dynamically register themselves with this class.
-  #
-  # All report generation is then done via Format, not with the engines
-  # and plugins directly.
-  #
-  # For each engine that is registered with Format, 2 methods are created:
-  #  - <enginename>; and
-  #  - <enginename>_object
-  #
-  # Either one of these methods can be used to create your report, depending
-  # on your requirments.
-  #
-  # = Format.enginename
-  #
-  # A brief example of creating a simple report with the table engine
-  #   
-  #   data = [[1,2],[5,3],[3,10]].to_table(%w[a b])
-  #   File.open("myreport.pdf","w") { |f| f.puts Ruport::Format.table(:plugin => :pdf, :data => data)}
-  #
-  # = Format.enginename_object
-  # 
-  # A slightly different way to create a simple report with the table engine. 
-  # This technique gives you a chance to modify some of the engines settings
-  # before calling render manually.
-  #
-  #   data = [[1,2],[5,3],[3,10]].to_table(%w[a b])
-  #   myreport = Ruport::Format.table_object :plugin => :pdf, :data => data
-  #   File.open("myreport.pdf","w") { |f| f.puts myreport.render }
-  # 
-  class Format
-    
-    # Builds a simple interface to a formatting engine.
-    # Two of these interfaces are built into Ruport:
-    # Format.document and Format.table
-    #
-    # These interfaces pass a hash of keywords to the associative engine.  
-    # Here is a simple example:
-    # 
-    # Format.build_interface_for Format::Engine::Table, "table"
-    # 
-    # This will allow the following code to work:
-    # 
-    # Format.table :data => [[1,2],[3,4]], :plugin => :csv
-    #  
-    # So, if you want to create a standard interface to a 
-    # custom built engine, you could simply do something like:
-    # 
-    # Format.build_interface_for MyCustomEngine, "my_name"
-    #
-    # which would be accessible via
-    #
-    # Format.my_name ...
-    def self.build_interface_for(engine,name)
-      singleton_class.send(:define_method, name, 
-        lambda { |options| simple_interface(engine, options) })
-      singleton_class.send(:define_method, "#{name}_object",
-        lambda { |options|
-          options[:auto_render] = false; simple_interface(engine,options) })
-    end
-
-    %w[engine plugin].each { |lib|
-       require "ruport/format/#{lib}" 
-    }
-
-    @@filters ||= Hash.new
-    
-    # To hook up a Format object to your current class, you need to pass it a
-    # binding.  This way, when filters are being processed, they will be
-    # evaluated in the context of the object they are being called from, rather
-    # than within an instance of Format.
-    #
-    def initialize(class_binding=binding)
-      @binding = class_binding
-    end
-    
-    # This is the text to be processed by the filters
-    attr_accessor :content
-    
-    # This is the binding to the object Format is tied to
-    attr_accessor :binding
-    
-    # Processes the ERB text in <tt>@content</tt> in the context
-    # of the object that Format is bound to.
-    def filter_erb  
-      self.class.document :data => @content, 
-                          :class_binding => @binding,
-                          :plugin => :text
-    end
-    
-    # Processes the RedCloth text in <tt>@content</tt> in the context
-    # of the object that Format is bound to.
-    def filter_red_cloth
-      self.class.document :data => @content, :plugin => :html
-    end
-    
-    # Takes a name and a block and creates a filter method
-    # This will define methods in the form of 
-    # <tt>Format#filter_my_filter_name</tt>.
-    #
-    # This code will run as an instance method on Format.
-    # You can access format and binding through their accessors,
-    # as well as any other filters.
-    #
-    # Example:
-    #
-    #   Format.register_filter :no_ohz do
-    #     content.gsub(/O/i,"")
-    #   end
-    def self.register_filter(name,&filter_proc)
-      @@filters["filter_#{name}".to_sym] = filter_proc 
-    end
-
-    def method_missing(m,*args)
-      @@filters[m] ? @@filters[m][@content] : super
-    end
-
-
-    private
-
-     def self.simple_interface(engine, options={})
-        my_engine = engine.dup
-        
-        my_engine.send(:plugin=,options[:plugin])
-        options = my_engine.active_plugin.rendering_options.merge(options)
-       
-        options[:auto_render] = true unless options.has_key? :auto_render
-        
-
-        options[:data] = options[:data].dup if options[:data]
-        
-        options.each do |k,v|
-          my_engine.send("#{k}=",v) if my_engine.respond_to? k
-        end
-        
-        options[:auto_render] ? my_engine.render : my_engine.dup
-      end
-
-
-    
-  end
-end
-
+require "ruport/format/plugin"

data/lib/ruport/generator.rb

@@ -0,0 +1,158 @@
+module Ruport
+  class Generator
+  extend FileUtils
+
+  begin
+    require "rubygems"
+  rescue LoadError
+    nil
+  end
+  require "ruport"
+
+  def self.build(proj)
+    @project = proj
+    build_directory_structure
+    build_init
+    build_config
+    build_rakefile
+    build_utils
+  end
+
+  def self.build_init
+    File.open("#{project}/app/init.rb","w") { |f| f << INIT }
+  end
+
+  # Generates a trivial rakefile for use with Ruport.
+  def self.build_rakefile
+    File.open("#{project}/Rakefile","w") { |f| f << RAKEFILE }
+  end
+
+  # Generates the build.rb, sql_exec.rb, and cabinet.rb utilities
+  def self.build_utils
+    File.open("#{project}/util/build.rb","w") { |f| f << BUILD }
+    File.open("#{project}/util/sql_exec.rb","w") { |f| f << SQL_EXEC }
+  end
+
+  # sets up the basic directory layout for a Ruport application
+  def self.build_directory_structure
+    mkdir project
+    %w[ test config output data app app/reports 
+        templates sql log util].each do |d|
+      mkdir "#{project}/#{d}"
+    end
+
+    touch("#{project}/app/reports.rb")
+    touch("#{project}/app/helpers.rb")
+  end
+
+  # Builds a file called config/ruport_config.rb which stores a Ruport::Config
+  # skeleton
+  def self.build_config
+    File.open("#{project}/config/ruport_config.rb","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
+END_RAKEFILE
+
+CONFIG = <<END_CONFIG
+require "ruport"
+
+# For details, see Ruport::Config documentation
+Ruport.configure { |c|
+  c.source :default, :user     => "root", 
+                     :dsn      =>  "dbi:mysql:mydb"
+  c.log_file "log/ruport.log"
+}
+END_CONFIG
+
+BUILD = <<'END_BUILD'
+require 'fileutils'
+include FileUtils
+
+def format_class_name(string)
+  string.downcase.split("_").map { |s| s.capitalize }.join
+end
+
+unless ARGV.length > 1
+  puts "usage build.rb [command] [options]"
+  exit
+end
+
+class_name = format_class_name(ARGV[1])
+
+exit if File.exist? "app/reports/#{ARGV[1]}.rb"
+if ARGV[0].eql? "report"
+  File.open("app/reports.rb", "a") { |f| 
+    f.puts("require \"app/reports/#{ARGV[1]}\"")
+  }
+REP = <<EOR
+require "app/init"
+class #{class_name} < Ruport::Report
+  
+  def prepare
+
+  end
+ 
+  def generate
+
+  end
+
+  def cleanup
+
+  end
+
+end
+
+if __FILE__ == $0
+   #{class_name}.run { |res| puts res.results }
+end
+EOR
+
+TEST = <<EOR
+require "test/unit"
+require "app/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("app/reports/#{ARGV[1]}.rb", "w") { |f| f << REP }
+  File.open("test/test_#{ARGV[1]}.rb","w") { |f| f << TEST } 
+end
+END_BUILD
+
+SQL_EXEC = <<'END_SQL'
+require "app/init"
+
+puts Ruport::Query.new(ARGF.read).result
+END_SQL
+
+INIT = <<END_INIT
+begin
+  require "rubygems"
+  require_gem "ruport","=#{Ruport::VERSION}"
+rescue LoadError 
+  nil
+end
+require "ruport"
+require "app/helpers"
+require "config/ruport_config"
+END_INIT
+
+  end
+end

data/lib/ruport/layout/component.rb

@@ -0,0 +1,7 @@
+require "ostruct"
+module Ruport
+  class Layout #:nodoc:
+    class Component < OpenStruct #:nodoc:
+    end
+  end
+end

data/lib/ruport/layout.rb

@@ -0,0 +1 @@
+require "ruport/layout/component" #:nodoc:

data/lib/ruport/query.rb

@@ -78,8 +78,8 @@ module Ruport
       options = { :source => :default, :origin => :string }.merge(options)
       options[:binding] ||= binding
       options[:origin] = :file if sql =~ /.sql$/
-      q = Format.document :data => get_query(options[:origin],sql),
-                          :plugin => :text, :class_binding => options[:binding]
+
+      q = ERB.new(get_query(options[:origin],sql)).result(options[:binding])
       @statements = SqlSplit.new(q)
       @sql = @statements.join
       
@@ -181,7 +181,7 @@ module Ruport
 
     # Returns a csv dump of the query.
     def to_csv
-      Format.table :plugin => :csv, :data => fetch
+      fetch.to_csv
     end
 
     # Returns a Generator object of the result set.