ruport 0.1.0 → 0.2.0

data/lib/ruport/db/sql.rb

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

data/lib/ruport/format/chart.rb

@@ -0,0 +1 @@
+# Do me!

data/lib/ruportlib.rb

@@ -0,0 +1,7 @@
+require "ruport/db/report"
+require "ruport/db/mailer"
+require "ruport/db/sql"
+require "ruport/db/mock_db"
+require "ruport/db/mock_report"
+require "ruport/db/data_set"
+require "ruport/db/data_row"

data/test/tc_data_row.rb

@@ -0,0 +1,53 @@
+#!/usr/local/bin/ruby -w
+
+require "test/unit"
+require "ruportlib"
+
+class TestDataRow < Test::Unit::TestCase
+  def setup
+    @rows = DataSet.new
+    @rows.fields = %w[ foo bar ]
+    @rows << [ 1 , 2 ]
+    @rows << [ 3 , 4 ]
+    @rows << [ 5 , 6 ]
+    @rows << { "foo" => 7, "bar" => 8 }
+  end
+
+  def test_first?
+    assert(@rows[0].first?)
+    @rows[1..-1].each do |row|
+      assert(!row.first?)
+    end
+  end
+
+  def test_middle?
+    assert(!@rows[0].middle?)
+    assert(!@rows[-1].middle?)
+    @rows[1..-2].each do |row|
+      assert(row.middle?)
+    end
+  end
+
+  def test_last?
+    @rows[0..-2].each do |row|
+      assert(!row.last?)
+    end
+    assert(@rows[-1].last?)
+  end
+
+  def test_oddity
+    @rows[0..-1].each_with_index do |row,index|
+	  if (index % 2 == 0)
+        assert(row.even?)
+      else
+        assert(row.odd?)
+      end
+    end
+  end
+
+  def test_to_s
+    assert_equal("[1,2]",@rows[0].to_s)
+  end
+
+end
+    

data/test/tc_data_set.rb

@@ -0,0 +1,67 @@
+#!/usr/local/bin/ruby -w
+
+require "test/unit"
+require "ruportlib"
+
+class TestDataSet < Test::Unit::TestCase
+  def setup
+    @data = DataSet.new
+    @data.fields = %w[ col1 col2 col3 ]
+    @data.default = ""
+    @data << %w[ a b c ]
+    @data << { "col1" => "d", "col3" => "e"}
+  end
+  
+  def test_fields 
+    assert_equal(%w[ col1 col2 col3 ], @data.fields )
+  end
+
+  def test_default
+    @data.default = "x"
+    @data << { }
+    assert_equal(  ['x','x','x'],
+                    @data[2].to_a )
+  end
+      
+  def test_brackets
+    row0 = { "col1" => "a", "col2" => "b", "col3" => "c" }
+    row1 = { "col1" => "d", "col2" => "", "col3" => "e" }
+    row0.each do |key,value|
+      assert_equal( value, @data[0][key] )
+    end
+    row1.each do |key,value|
+      assert_equal( value, @data[1][key] )
+    end       
+  end
+
+  def test_eql?
+    data2 = DataSet.new
+    data2.fields = %w[ col1 col2 col3 ]
+    data2.default = ""
+    data2 << %w[ a b c ]
+    data2 << { "col1" => "d", "col3" => "e" }
+
+    #FIXME: This looks like some shady discrete math assignment
+    assert(@data.eql?(data2) && data2.eql?(@data)) 
+    data2 << [2, 3, 4]
+    assert(!( @data.eql?(data2) || data2.eql?(@data) ))
+    @data << [2, 3, 4]
+    assert(@data.eql?(data2) && data2.eql?(@data))
+    @data << [8, 9, 10]
+    assert(!( @data.eql?(data2) || data2.eql?(@data) ))
+    data2 << [8, 9, 10]
+    assert(@data.eql?(data2) && data2.eql?(@data)) 
+  end
+
+  def test_load
+     loaded_data = DataSet.load("test/data.csv")
+     assert(@data.eql?(loaded_data))
+  end
+
+  def test_to_csv
+    loaded_data = DataSet.load("test/data.csv" )
+    csv = loaded_data.to_csv
+    assert_equal("col1,col2,col3\na,b,c\nd,\"\",e\n",csv)
+  end
+
+end

data/test/tc_report.rb

@@ -0,0 +1,104 @@
+#tc_ruport.rb
+#
+#  Created by Gregory Thomas Brown on 2005-08-09
+#  Copyright 2005 (Gregory Brown) All rights reserved.
+
+require "test/unit"
+require "lib/ruportlib"
+class TestRuport < Test::Unit::TestCase
+  
+def setup
+    @report = MockReport.new( "DBI:mysql:ruport:localhost", "test", "123") 
+    @report.query_table = "ruport_queries"
+
+    @report.fake_db = MockDB.new([ "DBI:mysql","ruport",
+                                   "localhost",  "test", "123"])
+
+    @report.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" } ]
+          
+     @report.fake_db[ "SELECT query FROM #{@report.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, @report.load_file("test/test.sql"));
+    
+    #absolute path
+    assert_equal(contents, 
+                 @report.load_file(File.expand_path("test/test.sql")))
+  end
+  
+  def test_sql_generation
+    sql = @report.fetch do
+      from :ruport_test
+    end
+    assert_equal("SELECT * FROM ruport_test;", sql)
+    sql = @report.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" }
+    @report.load_yaml "test/test.yaml"
+    config_hash.each do |key, value|
+      assert_equal(value,@report.config[key])
+    end
+  end
+
+def test_sql 
+  row_i = 0
+    @report.select("* FROM ruport_test") do |row|
+      assert_equal(@data[row_i]["a"],  row["a"].to_s)
+      assert_equal(@data[row_i]["b"],  row["b"].to_s)
+      assert_equal(@data[row_i]["c"],  row["c"].to_s)
+      assert_equal(@data[row_i]["d"],  row["d"].to_s)
+      row_i += 1
+    end
+  end
+
+  def test_sql_file
+    row_i = 0
+    @report.select("test/test.sql",:file) do |row|
+      assert_equal(@data[row_i]["a"],  row["a"].to_s)
+      assert_equal(@data[row_i]["b"],  row["b"].to_s)
+      assert_equal(@data[row_i]["c"],  row["c"].to_s)
+      assert_equal(@data[row_i]["d"],  row["d"].to_s)
+      row_i += 1
+    end
+  end
+
+  def test_sql_stored
+    row_i = 0
+    @report.select("sql_stored_test",:db) do |row|
+      assert_equal(@data[row_i]["a"],  row["a"].to_s)
+      assert_equal(@data[row_i]["b"],  row["b"].to_s)
+      assert_equal(@data[row_i]["c"],  row["c"].to_s)
+      assert_equal(@data[row_i]["d"],  row["d"].to_s)
+      row_i += 1
+    end
+  end
+
+  def test_query
+    @report.query("SELECT * FROM ruport_test") do |result|
+      assert(@data,result)
+    end
+  end
+  
+end  

data/test/ts_all.rb

@@ -0,0 +1,4 @@
+require "test/unit"
+require "test/tc_report"
+require "test/tc_data_set"
+require "test/tc_data_row"

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: ruport
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2005-08-28
+  version: 0.2.0
+date: 2005-11-08
 summary: A generalized Ruby report generation and templating engine.
 require_paths: 
   - lib
@@ -27,16 +27,25 @@ platform: ruby
 authors: 
   - Gregory Brown
 files: 
-  - bin/ruport.rb
-  - lib/mailer.rb
-  - lib/query.rb
-  - lib/sql.rb
-  - tests/tc_ruport.rb
+  - lib/ruportlib.rb
+  - lib/ruport/db/data_row.rb
+  - lib/ruport/db/data_set.rb
+  - lib/ruport/db/mailer.rb
+  - lib/ruport/db/mock_db.rb
+  - lib/ruport/db/mock_report.rb
+  - lib/ruport/db/report.rb
+  - lib/ruport/db/sql.rb
+  - lib/ruport/format/chart.rb
+  - test/tc_data_row.rb
+  - test/tc_data_set.rb
+  - test/tc_report.rb
+  - test/ts_all.rb
   - Rakefile
-  - setup.rb
   - README
   - LICENSE
   - TODO
+  - AUTHORS
+  - CHANGELOG
 test_files: []
 rdoc_options: 
   - "--title"
@@ -47,19 +56,10 @@ extra_rdoc_files:
   - README
   - LICENSE
   - TODO
+  - AUTHORS
+  - CHANGELOG
 executables: 
   - ruport
-  - ruport.rb
 extensions: []
 requirements: []
-dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: parseinput
-    version_requirement: 
-    version_requirements: !ruby/object:Gem::Version::Requirement 
-      requirements: 
-        - 
-          - ">="
-          - !ruby/object:Gem::Version 
-            version: 0.0.1
-      version: 
+dependencies: []

data/bin/ruport.rb

@@ -1,4 +0,0 @@
-# THIS IS A NASTY HACK TO GET RUPORT TO WORK IN CMD.EXE
-# BETTER SOLUTION IS A MUST.
-
-eval(File.read("C:/ruby/bin/ruport"))

data/lib/mailer.rb

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