ruport 0.2.0 → 0.2.2

data/lib/ruport/db/mailer.rb

@@ -1,42 +0,0 @@
-# mailer.rb
-#  Created by Gregory Brown on 2005-08-16
-#  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
-
-require "net/smtp"
-class Mailer
-  
-  # Creates a new Mailer object.  User must specify their mail host, email
-  # address, and account.  Password, port, and authentication method are all
-  # optional.
-  def initialize(host, address, account, password=nil, port=25, authentication=nil)
-    @host           = host
-    @account        = account
-    @password       = password
-    @address        = address
-    @port           = port
-    @auth       = authentication
-    @recipients     = []
-    @body           = ""
-  end
-  
-  #A list of email addresses to send the message to.
-  attr_accessor :recipients
-  
-  #The body of the message to be sent
-  attr_accessor :body
-
-  # This takes _report_name_ as argument and sends the contents of @body to
-  # @recipients
-  def send_report(report_name="No Subject")
-    return if @body.empty?
-    Net::SMTP.start(@host,@port,@host,@account,@password,@auth) do |smtp|
-      smtp.send_message( "Subject: #{report_name}\n\n#{@body}",
-                         @address, 
-                 @recipients )
-    end
-  end
-
-end

data/lib/ruport/db/mock_db.rb

@@ -1,49 +0,0 @@
-#!/usr/local/bin/ruby
-# mock_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
-
-class MockDB
-  # Creates a new MockDB e.g.
-  #
-  #  MockDB.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:
-  #
-  # self.fake_db["SELECT * FROM address_book"] =
-  #   DataSet.load("data/addressbook.csv")
-  def []=(query, contents)
-    @data[query] = contents
-  end
-
-end

data/lib/ruport/db/mock_report.rb

@@ -1,44 +0,0 @@
-#!/usr/local/bin/ruby
-# mock_report.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
-
-class MockReport < Report
-  
-  attr_accessor :fake_db
-  
-  def execute (query, source = :string)
-    query = get_query(source, query)
-    yield(@fake_db.process(@dsn,@user,@password, query))
-  end
-  
-  def select( query, source = :string, &action )
-    source != :string || query = "SELECT " + query
-    execute( query, source ) do |table|
-      if table.kind_of?(DataSet)
-        @column_names = table.fields
-      else
-        @column_names = table[0].keys
-      end
-      @first_row = true
-      table.each do |row|
-        row = row.to_hash if table.kind_of?(DataSet)
-        action.call(row) if block_given?
-        @first_row = false
-      end
-    end
-  end
-
-  def query ( query, source = :string, &action)
-    execute( query, source ) do |table|
-      action.call(table)
-    end
-  end
-
-end
-
-

data/lib/ruport/db/report.rb

@@ -1,212 +0,0 @@
-#!/usr/local/bin/ruby
-# report.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"
-class Report
-  def initialize( dsn, user, password, mailer=nil )
-    @dsn         = dsn
-    @user        = user
-    @password    = password
-    @report_name = ""
-    @mailer      = mailer
-    File.exists?("log") or FileUtils.mkdir("log")
-    @logger      = Logger.new("log/ruport.log")
-    @generate    = true
-    @report      = ""
-  end
-  
-  attr_accessor :query_table, :file
-  attr_reader   :mailer, :generate, :config, :logger  
-  
-  # * DEPRECATED:  Use query() *
-  #
-  # Takes a query, an optional sourcetype, and a block which is passed the
-  # results row by row.  When passed a query in string form, it adds the
-  # SELECT clause to the string and executes the query.  When passed a
-  # filename and a source :file, it looks in queries/ for the file specified.
-  # When given a database query label, it looks in config[query_table] for a
-  # query with the label specified.  If no source is specified, it uses
-  # string by default for the source.
-  #
-  # Example:
-  # 
-  # select ( "* FROM test" ) 
-  # Passes "SELECT * FROM test" to the database
-  #
-  # select ( "test.sql", :file )
-  # Passes the contents of queries/test.sql to the database
-  #  
-  # select ( "TEST", :db )
-  # Calls the query TEST stored in the database and query_table specified in
-  # config/ruport.yaml
-  
-  def select( query, source = :string, &action )
-    source != :string || query = "SELECT " + query
-    execute( query, source ) do |sth|
-      @column_names = sth.column_names
-      @first_row = true 
-      sth.fetch do |row|
-        action.call(row) if block_given?
-        @first_row = false 
-      end
-    end
-  end
-
-  # * DEPRECATED, Use query() * 
-  #
-  # Takes a query and an optional sourcetype and then runs the query
-  # against the database.  The output is not returned.  This is useful for
-  # doing construction and destruction actions.
-  def execute( query, source = :string )
-    query = get_query(source, query)
-    DBI.connect(@dsn, @user, @password) do |dbh|
-      dbh.prepare(query) do |sth|
-        sth.execute()
-        yield(sth)
-      end
-    end
-  end
-  
-  # 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)
-    DBI.connect(@dsn, @user, @password) do |dbh|
-      data = DataSet.new
-      sth = dbh.execute(query_text)
-      if block_given?
-        data.fields = sth.column_names
-        sth.each { |row| data << row }
-        action.call(data)
-      end
-    end
-  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
-      select ( "query FROM #{@query_table} WHERE " +
-      "label LIKE '#{query}';" ) do |row| return row["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
-  
-  # 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.
-  #
-  # I am aware of the fact that this function is a bear.  It will be cleaned up
-  # in future releases
- 
-  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
-
-end
-

data/lib/ruport/db/sql.rb

@@ -1,93 +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
-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
-
-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
-
-