ruport 0.8.14 → 0.10.0

data/lib/ruport/formatter/text.rb

@@ -0,0 +1,151 @@
+module Ruport
+  class Formatter::Text < Formatter
+   
+    renders :text, :for => [ Renderer::Row, Renderer::Table,
+                             Renderer::Group, Renderer::Grouping ]
+
+    opt_reader :max_col_width, :alignment, :table_width, 
+               :show_table_headers, :show_group_headers
+    
+    # Checks to ensure the table is not empty and then calls
+    # calculate_max_col_widths
+    #
+    def prepare_table
+      raise "Can't output empty table" if data.empty?
+      calculate_max_col_widths
+    end
+
+    # Uses the column names from the given Data::Table to generate a table
+    # header.
+    #
+    # Calls fit_to_width to truncate table heading if necessary.
+    #
+    def build_table_header
+      return unless should_render_column_names?
+
+      c = data.column_names.enum_for(:each_with_index).map { |f,i|
+        f.to_s.center(max_col_width[i])
+      }
+
+      output << fit_to_width("#{hr}| #{c.join(' | ')} |\n")
+    end
+
+    # Generates the body of the text table. 
+    #
+    # Defaults to numeric values being right justified, and other values being
+    # left justified.  Can be changed to support centering of output by
+    # setting options.alignment to :center
+    #
+    # Uses fit_to_width to truncate table if necessary.
+    #
+    def build_table_body
+      output << fit_to_width(hr)
+
+      calculate_max_col_widths unless max_col_width
+
+      render_data_by_row do |rend|
+        rend.options do |o|
+          o.max_col_width = max_col_width
+          o.alignment     = alignment
+          o.table_width   = table_width
+        end
+      end
+
+      output << fit_to_width(hr)
+    end
+
+    def build_row
+      max_col_widths_for_row(data) unless max_col_width
+
+      data.enum_for(:each_with_index).inject(line=[]) { |s,e|
+        field,index = e
+        if alignment.eql? :center
+          line << field.to_s.center(max_col_width[index])
+        else
+          align = field.is_a?(Numeric) ? :rjust : :ljust
+          line << field.to_s.send(align, max_col_width[index])
+        end
+      }
+      output << fit_to_width("| #{line.join(' | ')} |\n")
+    end
+
+    # Renders the header for a group using the group name.
+    #
+    def build_group_header
+      output << "#{data.name}:\n\n"
+    end
+    
+    # Creates the group body. Since group data is a table, just uses the
+    # Table renderer.
+    #
+    def build_group_body
+      render_table data, options
+    end
+
+    # Generates the body for a grouping. Iterates through the groups and
+    # renders them using the group renderer.
+    #
+    def build_grouping_body
+      render_inline_grouping(options)
+    end
+    
+    # Returns false if column_names are empty or options.show_table_headers
+    # is false/nil.  Returns true otherwise.
+    #
+    def should_render_column_names?
+      not data.column_names.empty? || !show_table_headers
+    end
+
+    # Generates the horizontal rule by calculating the total table width and
+    # then generating a bar that looks like this:
+    #
+    #   "+------------------+"
+    def hr
+      len = max_col_width.inject(data[0].to_a.length * 3) {|s,e|s+e}+1
+      "+" + "-"*(len-2) + "+\n"
+    end
+    
+    # Returns options.table_width if specified.
+    #
+    # Otherwise, uses SystemExtensions to determine terminal width.
+    def width
+      table_width || SystemExtensions.terminal_width
+    end
+
+    # Truncates a string so that it does not exceed Text#width
+    def fit_to_width(s)
+      # workaround for Rails setting terminal_width to 1
+      max_width = width < 2 ? 80 : width
+      
+      s.split("\n").each { |r|
+         r.gsub!(/\A.{#{max_width+1},}/) { |m| m[0,max_width-2] + ">>" }
+      }.join("\n") + "\n"
+    end
+
+    # determines the text widths for each column.
+    def calculate_max_col_widths
+      # allow override
+      return if max_col_width
+
+      options.max_col_width = []
+
+      unless data.column_names.empty?
+        data.column_names.each_index do |i| 
+          max_col_width[i] = data.column_names[i].to_s.length
+        end
+      end
+          
+      data.each { |r| max_col_widths_for_row(r) } 
+    end
+
+    def max_col_widths_for_row(row)
+      options.max_col_width ||= []
+      row.each_with_index do |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
+    end
+
+  end
+end

data/lib/ruport/generator.rb

@@ -2,6 +2,22 @@ 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
@@ -19,6 +35,7 @@ module Ruport
     puts "\nSuccessfully generated project: #{proj}"
   end
 
+
   def self.build_init
     m = "#{project}/lib/init.rb" 
     puts "  #{m}"
@@ -32,7 +49,7 @@ module Ruport
     File.open(m,"w") { |f| f << RAKEFILE }
   end
 
-  # Generates the build.rb, sql_exec.rb, and cabinet.rb utilities
+  # Generates the build.rb and sql_exec.rb utilities
   def self.build_utils           
     
     m = "#{project}/util/build"   
@@ -51,24 +68,22 @@ module Ruport
     mkdir project        
     puts "creating directories.."
     %w[ test config output data lib lib/reports 
-        templates sql log util].each do |d|
+        lib/renderers templates sql log util].each do |d|
       m="#{project}/#{d}" 
       puts "  #{m}"
       mkdir(m)
     end
     
     puts "creating files.."
-    %w[reports helpers].each { |f|
+    %w[reports helpers renderers].each { |f|
       m = "#{project}/lib/#{f}.rb"
       puts "  #{m}"
       touch(m)
     }
   end
 
-  # Builds a file called config/ruport_config.rb which stores a Ruport::Config
-  # skeleton
   def self.build_config
-    m = "#{project}/config/ruport_config.rb"
+    m = "#{project}/config/environment.rb"
     puts "  #{m}"
     File.open(m,"w") { |f| f << CONFIG }
   end
@@ -89,34 +104,50 @@ Rake::TestTask.new do |test|
 end
 
 task :build do
-  sh "ruby util/build report #{ENV['report']}"
+  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
+
+task :use_utils do
+  raise "File lib/init_utils.rb exists!" if File.exist?('lib/init_utils.rb')
+  File.open('lib/init_utils.rb','w') { |f|
+    if ENV['only']
+      ENV['only'].split(',').each { |e|
+        f.puts "require 'ruport/util/#{e}'"
+      }
+    else
+      f.puts "require 'ruport/util'"
+    end
+  }
+  File.open('lib/init.rb','a') { |f|
+    f.puts '#comment out the line below to disable auto-loading of utils'
+    f.puts 'require "lib/init_utils.rb"'
+  }        
+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"
-}
+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/generator"
 include FileUtils
-
-def format_class_name(string)
-  string.downcase.split("_").map { |s| s.capitalize }.join
-end
+include Ruport::Generator::Helpers
 
 unless ARGV.length > 1
   puts "usage: build [command] [options]"
@@ -125,31 +156,23 @@ end
 
 class_name = format_class_name(ARGV[1])
 
-exit if File.exist? "lib/reports/#{ARGV[1]}.rb"
 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 prepare
 
-  end
- 
   def generate
 
   end
-
-  def cleanup
-
-  end
-
+  
 end
 
 if __FILE__ == $0
-   #{class_name}.run { |res| puts res.results }
+  puts #{class_name}.run
 end
 EOR
 
@@ -163,11 +186,54 @@ class Test#{class_name} < Test::Unit::TestCase
   end
 end
 EOR
-  puts "report file: lib/reports/#{ARGV[1]}.rb"
+
   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
@@ -190,8 +256,39 @@ rescue LoadError
 end
 require "ruport"
 require "lib/helpers"
-require "config/ruport_config"
+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/query.rb

@@ -3,7 +3,6 @@ require "ruport/query/sql_split"
 
 module Ruport
   
-  #
   # === Overview
   # 
   # Query offers a way to interact with databases via DBI. It supports
@@ -19,32 +18,17 @@ module Ruport
     
     include Enumerable
     
-    #
-    # Queries are initialized with some SQL and a number of options that 
-    # affect their operation. They are NOT executed at initialization. This 
-    # is important to note as they will not query the database until either
-    # Query#result, Query#execute, Query#generator, or an Enumerable method 
-    # is called on them. 
-    #
-    # This kind of laziness is supposed to be A Good Thing, and
-    # as long as you keep it in mind, it should not cause any problems.
-    #
+    # Ruport::Query provides an interface for dealing with raw SQL queries.
     # The SQL can be single or multistatement, but the resulting Data::Table 
-    # will consist only of the result of the last statement which returns 
-    # something.
+    # will consist only of the result of the last statement.
     #
     # Available options:
     #
     # <b><tt>:source</tt></b>::         A source specified in 
-    #                                   Ruport::Config.sources, defaults to 
+    #                                   Ruport::Query.sources, defaults to 
     #                                   <tt>:default</tt>.
-    # <b><tt>:origin</tt></b>::         Query origin, defaults to 
-    #                                   <tt>:string</tt>, but it can be set to 
-    #                                   <tt>:file</tt>, loading the path 
-    #                                   specified by the <tt>sql</tt> 
-    #                                   parameter.
     # <b><tt>:dsn</tt></b>::            If specifed, the Query object will 
-    #                                   manually override Ruport::Config.
+    #                                   manually override Ruport::Query.
     # <b><tt>:user</tt></b>::           If a DSN is specified, the user can 
     #                                   be set with this option.
     # <b><tt>:password</tt></b>::       If a DSN is specified, the password 
@@ -58,10 +42,10 @@ module Ruport
     #
     # Examples:
     #   
-    #   # uses Ruport::Config's default source
+    #   # uses Ruport::Query's default source
     #   Ruport::Query.new("select * from fo")
     #   
-    #   # uses the Ruport::Config's source labeled :my_source
+    #   # uses the Ruport::Query's source labeled :my_source
     #   Ruport::Query.new("select * from fo", :source => :my_source)
     #
     #   # uses a manually entered source
@@ -76,101 +60,69 @@ module Ruport
     #
     def initialize(sql, options={})
       options = { :source => :default, :origin => :string }.merge(options)
-      options[:binding] ||= binding
       options[:origin] = :file if sql =~ /.sql$/
-
-      q = ERB.new(get_query(options[:origin],sql)).result(options[:binding])
-      @statements = SqlSplit.new(q)
+      @statements = SqlSplit.new(get_query(options[:origin],sql))
       @sql = @statements.join
       
       if options[:dsn]
-        Ruport::Config.source :temp, :dsn      => options[:dsn],
-                                     :user     => options[:user],
+        Ruport::Query.add_source :temp, :dsn      => options[:dsn],
+                                        :user     => options[:user],
                                      :password => options[:password]
         options[:source] = :temp
       end
       
       select_source(options[:source])
       
-      @raw_data = options[:raw_data]
-      @cache_enabled  = options[:cache_enabled]
+      @raw_data = options[:row_type].eql?(:raw)
       @params = options[:params]
-      @cached_data = nil
     end
-    
-    #
-    # Set this to <tt>true</tt> to get DBI:Rows, <tt>false</tt> to get Ruport 
-    # constructs.
-    #
+
+    def self.default_source
+      sources[:default]
+    end
+
+    def self.sources
+      @sources ||= {}
+    end
+
+    def self.add_source(name,options={})
+      sources[name] = OpenStruct.new(options)
+      check_source(sources[name],name)
+    end
+
+    private
+
+    def self.check_source(settings,label) # :nodoc:
+      raise ArgumentError unless settings.dsn
+    end
+
+    public
+
     attr_accessor :raw_data
     
-    # The data stored by Ruport when caching.
-    attr_accessor :cached_data
-    
     # The original SQL for the Query object
     attr_reader :sql
     
-    #
     # This will set the <tt>dsn</tt>, <tt>username</tt>, and <tt>password</tt> 
-    # to one specified by a source in Ruport::Config.
+    # to one specified by a source in Ruport::Query.
     #
     def select_source(label)
-      @dsn      = Ruport::Config.sources[label].dsn
-      @user     = Ruport::Config.sources[label].user
-      @password = Ruport::Config.sources[label].password
+      @dsn      = Ruport::Query.sources[label].dsn
+      @user     = Ruport::Query.sources[label].user
+      @password = Ruport::Query.sources[label].password
     end 
     
-    #
-    # Standard <tt>each</tt> iterator, iterates through the result set row by 
-    # row.
-    #
-    def each(&action) 
-      Ruport.log(
-        "no block given!", :status => :fatal,
-        :level => :log_only, :raises => LocalJumpError 
-      ) unless action
+    def each(&action)
+      raise(LocalJumpError, "No block given!") unless action
       fetch(&action)
       self
     end
     
-    #
-    # Grabs the result set as a Data::Table or an Array of DBI::Row objects 
-    # if in <tt>raw_data</tt> mode.
-    #
     def result; fetch; end
     
     # Runs the query without returning its results.
     def execute; fetch; nil; end
     
-    # Clears the contents of the cache.
-    def clear_cache
-      @cached_data = nil
-    end
-
-    #
-    # Clears the contents of the cache, then runs the query, filling the
-    # cache with the new result.
-    #
-    def update_cache
-      return unless @cache_enabled
-      clear_cache; fetch
-    end
-    
-    #
-    # Turns on caching.  New data will not be loaded until the cache is clear 
-    # or caching is disabled.
-    #
-    def enable_caching
-      @cache_enabled = true
-    end
-
-    # Turns off caching and flushes the cached data.
-    def disable_caching
-      clear_cache
-      @cache_enabled = false
-    end
-    
-    #
     # Returns a Data::Table, even if in <tt>raw_data</tt> mode.
     # This doesn't work with raw data if the cache is enabled and filled.
     #
@@ -224,24 +176,19 @@ module Ruport
       type.eql?(:file) ? load_file( query ) : query
     end
     
-    def load_file( query_file )
-      begin; File.read( query_file ).strip ; rescue
-        Ruport.log "Could not open #{query_file}",
-          :status => :fatal, :exception => LoadError
+    def load_file(query_file)
+      begin
+        File.read( query_file ).strip
+      rescue
+        raise LoadError, "Could not open #{query_file}"
       end
     end
     
     def fetch(&block)
       data = nil
-      if @cache_enabled and @cached_data
-        data = @cached_data
-        data.each { |r| yield(r) } if block_given?
-      else
-        final = @statements.size - 1
-        @statements.each_with_index do |query_text, index|
-          data = query_data(query_text, &(index == final ? block : nil))
-        end
-        @cached_data = data if @cache_enabled
+      final = @statements.size - 1
+      @statements.each_with_index do |query_text, index|
+        data = query_data(query_text, &(index == final ? block : nil))
       end
       return data
     end