ruport 0.1.0 → 0.2.0

data/lib/ruport/db/data_row.rb

@@ -0,0 +1,64 @@
+#!/usr/local/bin/ruby
+# data_row.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 DataRow 
+  
+  attr_accessor :fields
+  
+
+  # DataRows are essentially arrays with named ordinal fields and awareness of
+  # their oddness and position.
+  def initialize( data, fields, oddness=nil, position=nil )
+    @data     = data
+    @fields   = fields
+    @oddness  = oddness
+    @position = position
+  end
+  
+
+  # Lets you access individual fields
+  #
+  # i.e. row["phone"]
+  def [](key)
+    key.kind_of?(String) ? @data[@fields.index(key)] : @data[key]
+  end
+  
+  # Lets you set field values
+  #
+  # i.e. row["phone"] = '2038291203'
+  def []=(key,value)
+    key.kind_of?(String) ?  @data[@fields.index(key)] = value :
+                           @data[key] = value    
+  end
+
+  # Converts the DataRow to a plain old Array
+  def to_a
+    @data
+  end
+
+  # Converts the DataRow to a string representation for outputting to screen.
+  def to_s
+    "[" + @data.join(",") + "]"
+  end
+
+  # implements 
+  # DataRow#first? DataRow#last? DataRow#middle? DataRow#odd? DataRow#even?
+  # which are all conditional methods.
+  def method_missing(method)
+    if %[last? first? middle?].include? method.to_s
+	  return @position.eql?(method.to_s[0..-2].to_sym)
+    elsif %[odd? even?].include? method.to_s
+      return @oddness.eql?(method.to_s[0..-2].to_sym)
+    end
+	super
+  end
+      
+  attr_accessor :position
+end

data/lib/ruport/db/data_set.rb

@@ -0,0 +1,101 @@
+#!/usr/local/bin/ruby
+# data_set.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 DataSet
+  def initialize
+    @data = []
+  end
+  
+  #fields are the column names, default is the default cell value
+  attr_accessor :fields, :default
+  
+  #data is the core Array that holds all the rows
+  attr_reader   :data
+  
+  
+  #Allows ordinal access to rows
+  def [](index)
+    @data[index]
+  end
+  
+  #allows setting of rows (providing a DataRow is passed in)
+  def []=(index,value)
+    throw "Invalid object type" unless value.kind_of?(DataRow)
+    @data[index] = value
+  end
+
+  # appends a row to the DataSet
+  # can be added as an array or a keyed hash.
+  # i.e if our DataSet have @fields = [:a, :b, :c]
+  # data << [ 1, 2, 3] and data << { :a => 1, :b => 2, :c => 3 } 
+  # are equivalent.
+  def << ( stuff )
+    new_row = Array.new
+    fields.each_with_index do |key, index|
+      if stuff.kind_of?(Array)
+        new_row[index] = stuff.shift || @default
+      else
+        new_row[index] = stuff[key] || @default
+      end
+    end
+    
+    oddness  = (@data.length % 2 == 0 ? :even  : :odd)
+    position = (@data.length == 0 ? :first : :last)
+    @data[@data.length - 1].position = :middle if @data.length > 1
+    @data << DataRow.new(new_row,@fields,oddness,position)
+  end
+
+  # This works in best case scenario.  It should return true if both DataSets
+  # have the same values.  Still working out the kinks here.
+  def eql?(data2)
+    return false unless (@data.length == data2.data.length)
+    0.upto(@data.length - 1) do |index|
+      (@fields + data2.fields).uniq.each do |key|
+        return false unless @data[index][key] == data2[index][key]
+      end
+    end
+    return true
+  end
+  
+
+  # Allows loading of CSV files or YAML dumps.  Returns a DataSet
+  def self.load ( source, default="")
+    
+    return YAML.load(File.open(source)) if source =~ /\.(yaml|yml)/ 
+    
+    input = CSV.read(source) if source =~ /\.csv/
+    loaded_data = self.new
+    loaded_data.fields = input[0]
+    loaded_data.default = default
+    input[1..-1].each do |row|
+      loaded_data << row
+    end
+    return loaded_data	
+  end
+ 
+  # Converts a DataSet to CSV
+  def to_csv
+    output = CSV.generate_line(@fields) + "\n"
+    @data.each do |row|
+      output << CSV.generate_line(@fields.map { |f| row[f] }) + "\n"
+    end
+    return output
+  end
+
+  # Works like a standard each iterator
+  def each(&action)
+    @data[0..-1].each(&action)
+  end
+
+  # Works like a standard each_with_index iterator
+  def each_with_index(&action)
+    @data[0..-1].each_with_index(&action)
+  end
+
+end

data/lib/ruport/db/mailer.rb

@@ -0,0 +1,42 @@
+# 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

@@ -0,0 +1,49 @@
+#!/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

@@ -0,0 +1,44 @@
+#!/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

@@ -0,0 +1,212 @@
+#!/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
+