ruport 0.2.0 → 0.2.2

data/CHANGELOG

@@ -1,3 +1,29 @@
+The current version of Ruby Reports is 0.2.2
+
+changes since Ruport 0.2.0:
+
+- Report becomes Engine
+- MockDB becomes FakeDB
+- MockReport becomes MockEngine
+
+- Modules are added so now,
+
+   Ruport::Report::Engine,
+   Ruport::Report::DataSet is the full name of these classes.
+
+- 'require ruportlib' runs include Ruport,
+   so you can type Report::Engine.new instead of Ruport::Report::Engine.new
+
+- The assert that was supposed to be an assert_equal that
+  David Black caught was fixed.
+
+- Examples are updated and now on the RubyForge FRS in many formats.
+  (With .DS_Store and other garbage files removed! ;) )
+
+- Formatting of code was cleaned up and improved.
+
+- Generates a test.rb that does not use deprecated functions now.
+
 changes since Ruport 0.1.0:
 
 CLEANUP / ORGANIZATION:

data/README

@@ -7,7 +7,7 @@ of databases via DBI.  It also provides helper methods and utilities to generate
 It happens to be alpha software, so if it offends your mother, burns out the innards of your computer, or threatens you in any other way, you may want to wait until further releases to play around with it.
 
 There is a set of examples and a brief walkthrough for this application
-available at http://ruport.rubyforge.org/examples.zip which I strongly
+available at http://ruport.rubyforge.org/example.zip which I strongly
 recommend going through
 
 Otherwise, here is a brief set of installation and setup instructions which will

data/Rakefile

@@ -14,7 +14,7 @@ end
 
 spec = Gem::Specification.new do |spec|
 	spec.name = "ruport"
-	spec.version = "0.2.0"
+	spec.version = "0.2.2"
 	spec.platform = Gem::Platform::RUBY
 	spec.summary = "A generalized Ruby report generation and templating engine."
 

data/TODO

@@ -1,5 +1,11 @@
 TODO:
 
+Bugfixes:
+ - Fix potential failure in Ruport::Report::DataSet#eql?
+ - Is there an OS X packaging problem with the gems?
+ - Fix the manual that is in the example package so it it reads FakeDB instead
+   of MockDB
+ 
 Improvement:
 
 - Mail system
@@ -104,9 +110,8 @@ Other:
 
 	Ruport needs to be modified to support as many databases as possibly
 	internally.  The system was written using MySQL on Gentoo Linux
-	and Mac OS X.3 / OS X.4, Windows 2000 / XP 
-  
-  and Microsoft SQL Server on Windows 2000 (via ODBC),
+	and Mac OS X.3 / OS X.4, Windows 2000 / XP and Microsoft SQL Server
+  on Windows 2000 (via ODBC),
 	
   so the support for these platforms are best.  An effort will be given to
 	make Ruport less hostile in other environments.

data/bin/ruport

@@ -61,11 +61,11 @@ if ARGV[0].eql?("generate")
        
   File.open("#{ARGV[1]}/config/ruport.yaml", "w") { |f| f.puts(conf) }
   File.open("#{ARGV[1]}/templates/test.rb", "w") { |f|
-    f.puts 'select "database()" do |r| puts r end'
+    f.puts('query ("show tables;") do |data| @report << data.to_csv end ')
   }
   exit
 elsif ARGV[0].eql?("-v")
-  puts "Ruport Version 0.2.0 \nA ruby report generation system by Gregory " +
+  puts "Ruport Version 0.2.2 \nA ruby report generation system by Gregory " +
   "Brown.\nThis application is Free Software under the GPL/Ruby License. " +
   "\nAll praise and/or criticism can be directed to "+
   "gregory.t.brown@gmail.com"
@@ -79,17 +79,17 @@ config = YAML.load(File.open("config/ruport.yaml"))
 mailer = nil
 
 if config.has_key?(:mail_host)
-  mailer = Mailer.new( config[:mail_host],    config[:mail_address],
+  mailer = Report::Mailer.new( config[:mail_host],    config[:mail_address],
                        config[:mail_account], config[:mail_password],
                        25, config[:mail_authentication] )
 end
 
-report  = Report.new( 
+report  = Report::Engine.new( 
            "#{config[:driver]}:#{config[:database]}",
            config[:db_user], config[:db_password], mailer )
 
 if config[:driver].eql?("ruport")
-  report = MockReport.new( "#{config[:driver]}:#{config[:database]}",
+  report = Report::FakeEngine.new( "#{config[:driver]}:#{config[:database]}",
            config[:db_user], config[:db_password], mailer )
 end
 

data/lib/ruport/report/data_row.rb

@@ -0,0 +1,67 @@
+#!/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
+
+module Ruport
+  module Report
+    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
+  end
+end

data/lib/ruport/report/data_set.rb

@@ -0,0 +1,104 @@
+#!/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
+module Ruport
+  module Report
+    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
+  end
+end

data/lib/ruport/report/engine.rb

@@ -0,0 +1,214 @@
+#!/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 )
+        @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.
+      #
+      # 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
+    end
+  end
+end
+