ruport 0.2.9 → 0.3.8

data/lib/ruport/report/engine.rb

@@ -1,201 +0,0 @@
-#!/usr/local/bin/ruby
-# engine.rb
-# Created by Gregory Thomas Brown on 2005-08-02
-# Copyright 2005 (Gregory Brown) All rights reserved.
-#
-# This product is free software, you may distribute it as such
-# under your choice of the Ruby license or the GNU GPL
-# See LICENSE for details
-#
-# Special thanks and acknowledgement go to James Edward Gray II
-# for providing the original source code for this application
-require "dbi"
-require "rubygems"
-require "erb"
-require "csv"
-require "yaml"
-require "date"
-require "logger"
-require "fileutils"
-module Ruport
-  module Report
-    class Engine 
-      def initialize( dsn, user, password, mailer=nil )
-        
-        File.exists?("log") or FileUtils.mkdir("log")
-        @logger      = Logger.new("log/ruport.log")
-        
-        @dsn         = dsn
-        @user        = user
-        @password    = password
-        @mailer      = mailer
-        @generate    = true
-        @report_name = ""
-        @report      = ""
-        @query_table = nil
-        @file        = nil
-        @config      = nil
-        @databases   = Hash.new
-        @databases[:default] = { :dsn      => @dsn,
-                                 :user     => @user,
-                                 :password => @password
-                               }
-      end
-      
-      attr_accessor :query_table, :file
-      attr_reader   :mailer, :generate, :config, :logger  
-      
-      # Takes a query and an optional sourcetype and then runs the query 
-      # against the database.  The return from the query is then converted
-      # into a DataSet which can then be manipulated.
-      #
-      # Example:
-      # query("SELECT * FROM address_book") do |data|
-      #   @report << data.to_csv
-      # end
-      # 
-      # The above would select all from the _address_book_ table
-      # and then convert the DataSet to a csv and then add it to the report
-
-      def query ( statement, source = :string, &action )
-        query_text = get_query(source,statement)
-        data = DataSet.new
-        DBI.connect(@dsn, @user, @password) do |dbh|
-          dbh.execute(query_text) do |sth|
-            if sth.rows > 0
-              results = sth.fetch_all
-              data.fields = sth.column_names
-              results.each { |row| data << row }
-              action.call(data) if block_given?
-            else
-              data = nil
-            end
-          end
-        end
-        return data || "command succeeded. 0 rows returned"
-      end 
-
-      # Evaluates _code_ from _filename_ as pure ruby code for files ending in
-      # .rb, and as ERb templates for anything else.
-      def eval_report( filename, code )
-        if filename =~ /\.rb/
-          eval(code)
-        else
-          ERB.new(code, 0, "%").run(binding)
-        end
-      end
-
-      # Loads a yaml file into the @config variable which is accessible in
-      # templates.  If _interactive_ is set to true, the user will
-      # be prompted to enter information for each key.
-      def load_yaml(file, interactive=false)
-        file = "config/#{file}" unless File.exists? file
-        @config = YAML.load(File.open(file))
-        if (interactive)
-          @config.keys.map { |c| c.to_s }.sort.each do |property|
-              $stderr.print "#{property} (#{@config[property.to_sym]}): "
-              entered = $stdin.gets.strip
-            @config[property] = entered unless entered.eql?("")
-          end
-        end
-      end
-      
-      # Creates an SQL Object.  The block is evaluated within the SQL
-      # instance so you may use any methods available to the SQL class.
-      # The generated query is returned.
-      #
-      # Example
-      # fetch { from :address_book order :name }
-      # => "SELECT * FROM address_book ORDER BY name
-      
-      def fetch( &dsl )
-        begin
-          SQL.new(:SELECT, &dsl).to_s
-        rescue Exception
-          @logger.fatal "Error generating SQL."
-          raise "Error generating SQL."
-        end  
-      end
-      
-      # Returns the query string for queries of type string, file, or db
-      def get_query(type,query)
-        case (type)
-        when :string
-           query
-        when :file
-          load_file( query )
-        when :db
-          query ( "SELECT query FROM #{@query_table} WHERE " +
-                  "label LIKE '#{query}';" ) do |data|
-                    return data[0]["query"] 
-          end
-        end
-      end
-          
-      # Loads a query from file.  Accepts absolute paths, relative paths from
-      # the toplevel directory, and relative paths from _queries/_.
-      # If you've been putting all your database queries in _queries_, you can
-      # just call them by name.
-      def load_file( query_file )
-        begin
-          File.read( query_file ).strip
-        rescue
-          @logger.fatal "Could not open #{query_file}"
-          raise "Could not open #{query_file}"; exit
-        end
-      end
-
-      def render ( data ) 
-        builder = Format::Builder.new( data )
-        yield(builder)
-        builder.render
-      end
-      
-      # Generates the report.  If @pre or @post are defined with lambdas,
-      # they will be called before and after the main code.  generate_report
-      # will automatically be run at the end of the execution
-      # of a ruport template unless @generate is set to false.  
-      #
-      # If @file != nil, ruport will print to the
-      # file with the specified name.  Otherwise, it will print to STDOUT by
-      # default.  @file can be set implictly by a file argument, i.e.
-      # ruport templates/foo.rb reports/foo_out.html =>  @file =
-      # 'reports/foo_out.html'  It can also be set explicitly within a template. 
-      # A good way to define a default value is @file ||= "reports/somefile"
-      #
-      # Lastly, if you have your mailer configuration set up and
-      # you've specified recipients, the contents of @mailer.body will
-      # be automatically emailed by this fuction.
-      #
-      # The source for this function is probably easier to read than this
-      # explanation, so you may want to start there.     
-      def generate_report
-        @pre.call if @pre
-        if (@file.nil?) 
-          puts(@report)
-        else 
-          File.open(@file,"w") { |f| f.puts @report }
-        end
-        unless @mailer.nil? || @mailer.recipients.empty?
-          @mailer.body = @report unless not @mailer.body.empty?
-          @mailer.send_report(@report_name) 
-        end
-        @post.call if @post
-      
-      end
-
-      def add_dsn(label, dsn, user, password )
-        @databases[label] = { :dsn => dsn, :user => user,
-                             :password => password }
-      end
-
-      def select_dsn(label)
-        @dsn      = @databases[label][:dsn]
-        @user     = @databases[label][:user]
-        @password = @databases[label][:password]
-      end
-      
-    end
-  end
-end
-

data/lib/ruport/report/fake_db.rb

@@ -1,54 +0,0 @@
-#!/usr/local/bin/ruby
-# fake_db.rb
-# Created by Gregory Thomas Brown on 2005-08-02
-# Copyright 2005 (Gregory Brown) All rights reserved.
-#
-# This product is free software, you may distribute it as such
-# under your choice of the Ruby license or the GNU GPL
-# See LICENSE for details
-
-module Ruport
-  module Report
-    class FakeDB
-      
-      # Creates a new FakeDB e.g.
-      #
-      #  FakeDB.new([ "ruport",    "ruport_example",
-      #               "localhost", "test", "123"] )
-      #
-      # Which would create a fake database ruport_example at
-      # localhost with the  username test and the password 123
-      # using the driver 'ruport'
-      def initialize(args)
-        @db_driver, @db_name, @db_host, @username, @password = *args
-        @data = Hash.new
-      end
-
-
-      # Verifies account info and retrieves information
-      def process( dsn, user, password, query )
-        if  ( dsn.eql?("#{@db_driver}:#{@db_name}:#{@db_host}") and
-              user.eql?(@username) and password.eql?(@password) )
-          @data[query]
-        else
-          throw "Processing Error"
-        end
-      end
-      
-
-      # Allows query to be looked up in the data
-      def [](query)
-        @data[query]
-      end
-
-      # Used to setup fake queries E.g:
-      #
-      # DataSet#fake_db["SELECT * FROM address_book"] =
-      #   DataSet.load("data/addressbook.csv")
-      def []=(query, contents)
-        @data[query] = contents
-      end
-
-    end
-  end
-end

data/lib/ruport/report/fake_engine.rb

@@ -1,26 +0,0 @@
-#!/usr/local/bin/ruby
-# fake_engine.rb
-# Created by Gregory Thomas Brown on 2005-08-02
-# Copyright 2005 (Gregory Brown) All rights reserved.
-#
-# This product is free software, you may distribute it as such
-# under your choice of the Ruby license or the GNU GPL
-# See LICENSE for details
-
-module Ruport
-  module Report
-    class FakeEngine < Ruport::Report::Engine
-      
-      attr_accessor :fake_db
-      
-
-      def query ( query, source = :string, &action)
-        query = get_query(source, query)
-        data = @fake_db.process(@dsn,@user,@password, query)
-        action.call(data) if block_given?
-        return data
-      end
-
-    end
-  end
-end

data/lib/ruport/report/fake_mailer.rb

@@ -1,23 +0,0 @@
-module Ruport
-  module Report
-    class FakeMailer < Mailer
-      
-      @@fake_server = Hash.new
-      @@fake_server[:port] = 25
-      
-      def self.[]=(key,value)
-        @@fake_server[key] = value
-      end
-        
-      def send_report(report_name="No Subject")
-        raise "Invalid Host" unless @@fake_server[:host].eql?(@host)
-        raise "Invalid Account" unless @@fake_server[:account].eql?(@account)
-        raise "Bad Email Address" unless @@fake_server[:address].eql?(@address)
-        raise "Bad Password" unless @@fake_server[:password].eql?(@password)
-        raise "Invalid Port" unless @@fake_server[:port].eql?(@port)
-        raise "Bad Authorization Type" unless @@fake_server[:auth].eql?(@auth)
-      end
-
-    end
-  end
-end

data/lib/ruport/report/sql.rb

@@ -1,95 +0,0 @@
-#!/usr/local/bin/ruby -w
-# sql.rb:
-# Generates queries from simple ruby syntax 
-#
-# Created by Gregory Thomas Brown on 2005-08-02
-# Copyright 2005 (Gregory Brown) All rights reserved.
-#
-# This product is free software, you may distribute it as such
-# under your choice of the Ruby license or the GNU GPL
-# See LICENSE for details
-#
-# Special thanks and acknowledgement go to James Edward Gray II
-# for providing the original source code for this application
-module Ruport
-  module Report
-    class SQL
-      
-      # Generates an SQL object which can generate queries.
-      def initialize( statement, &init )
-        @statement = statement
-        
-        @fields     = Array.new
-        @tables     = Array.new
-        @conditions = Array.new
-        @order_by   = Array.new
-        
-        instance_eval(&init) unless init.nil?
-      end
-      
-      #Specifies the fields to select from
-      def columns( *fields )
-        fields.each { |field| @fields << "'#{field}'" }
-      end
-      
-      #generates an FROM clause for the given tables
-      def from( *tables )
-        tables.each { |table| @tables << table }
-      end
-      
-      # generates a conditional expression.
-      # condition :name, :LIKE, :jim -> "name LIKE 'jim'"
-      def condition( field, operator, match )
-        @conditions << "#{field} #{operator.to_s.upcase} '#{match}'"
-      end
-      
-      # generates an ORDER BY clause for list +order+
-      def order( *order )
-        order.each { |table| @order_by << table }
-      end
-      
-      # Converts SQL object into a query string
-      def to_s
-        sql = "#{@statement} "
-        
-        sql << if @fields.empty?
-          "* "
-        else
-          @fields.join(", ") + " "
-        end
-        
-        sql << "FROM #{@tables.join(', ')} "
-        
-        unless @conditions.empty?
-          sql << "WHERE #{@conditions.join(' AND ')} "
-        end
-
-        unless @order_by.empty?
-          sql << "ORDER BY #{@order_by.join(', ')} "
-        end
-        
-        sql.sub!(/ \Z/, "")
-        sql << ";"
-        
-        sql
-      end
-    end    
-  end
-end
-class String
-  def with( other_table, field = nil )
-   if field.nil?
-     "#{self} NATURAL JOIN #{other_table}"
-    else
-     "#{self} LEFT JOIN #{other_table} " +
-     "ON #{self}.#{field} = #{other_table}.#{field}"
-   end
-  end
-end
-
-class Symbol
-  def with( other_table, field = nil )
-   to_s.with(other_table, field)
-  end
-end
-

data/lib/ruportlib.rb

@@ -1,11 +0,0 @@
-require "ruport/report/engine"
-require "ruport/report/mailer"
-require "ruport/report/sql"
-require "ruport/report/fake_db"
-require "ruport/report/fake_engine"
-require "ruport/report/data_set"
-require "ruport/report/data_row"
-require "ruport/report/fake_mailer"
-require "ruport/format/builder"
-require "faster_csv"
-include Ruport

data/test/tc_engine.rb

@@ -1,102 +0,0 @@
-#tc_engine.rb
-#
-#  Created by Gregory Thomas Brown on 2005-08-09
-#  Copyright 2005 (Gregory Brown) All rights reserved.
-
-require "test/unit"
-require "ruportlib"
-class TestEngine < Test::Unit::TestCase
-  def setup
-      @engine = Report::FakeEngine.new( "DBI:mysql:ruport:localhost",
-                                        "test", "123") 
-      @engine.query_table = "ruport_queries"
-
-      @engine.fake_db = Report::FakeDB.new([ "DBI:mysql","ruport",
-                                     "localhost",  "test", "123"])
-
-      @engine.fake_db["SELECT * FROM ruport_test"] = @data =
-        [ { "a" => "a column, row 1", "b" => "b column, row 1", 
-            "c" => "c column, row 1", "d" => "d column, row 1" },
-          { "a" => "a column, row 2", "b" => "b column, row 2",
-            "c" => "c column, row 2", "d" => "d column, row 2" },
-          { "a" => "a column, row 3", "b" => "b column, row 3",
-            "c" => "c column, row 3", "d" => "d column, row 3" } ]
-            
-       @engine.fake_db[ "SELECT query FROM #{@engine.query_table} " +
-                        "WHERE label LIKE 'sql_stored_test';"] =
-                        [ "query" => "SELECT * FROM ruport_test" ]
-  end
-  
-  def test_load_file
-    contents = "SELECT * FROM ruport_test"
-    
-    #relative to working dir
-    assert_equal(contents, @engine.load_file("test/test.sql"));
-    
-    #absolute path
-    assert_equal(contents, 
-                 @engine.load_file(File.expand_path("test/test.sql")))
-  end
-  
-  def test_sql_generation
-    sql = @engine.fetch do
-      from :ruport_test
-    end
-    assert_equal("SELECT * FROM ruport_test;", sql)
-    sql = @engine.fetch do
-      from :ruport_test
-      condition :last_name, :"=", "Brown"
-      order    :first_name
-    end
-    assert_equal("SELECT * FROM ruport_test WHERE last_name = 'Brown' " +
-           "ORDER BY first_name;",sql)  
-  end
-
-  def test_load_yaml
-    config_hash = { :name   => "Greg",
-                    :friend => "Rob",
-                    :job    => "Programmer" }
-    @engine.load_yaml "test/test.yaml"
-    config_hash.each do |key, value|
-      assert_equal(value,@engine.config[key])
-    end
-  end
-
-  def test_sql_file
-    @engine.query("test/test.sql",:file) do |result|
-      assert_equal(@data,result)
-    end
-  end
-
-  def test_sql_stored
-    @engine.query("sql_stored_test",:db) do |result|
-      assert_equal(@data,result)
-    end
-  end
-
-  def test_query
-    @engine.query("SELECT * FROM ruport_test") do |result|
-      assert_equal(@data,result)
-    end
-  end
-
-  def test_render
-    data = Report::DataSet.new
-    data.fields = %w[ col1 col2 col3]
-    data << %w[ a b c]
-    data << %w[ d e f]
-    assert_equal("col1,col2,col3\na,b,c\nd,e,f\n", 
-                 @engine.render(data) do |builder|
-                   builder.format = :csv
-                 end )
-
-    assert_equal("<table>\n  <tr>\n    <th>col1</th><th>col2</th>" +
-                 "<th>col3</th>\n  </tr>\n" +
-                 "  <tr>\n    <td>a</td><td>b</td><td>c</td>\n  </tr>\n" +
-                 "  <tr>\n    <td>d</td><td>e</td><td>f</td>\n  </tr>\n" +
-                 "</table>", @engine.render(data) do |builder|
-                   builder.format = :html
-                 end )  
-  end
-  
-end