ruport-util 0.10.0 → 0.12.0

data/Rakefile

@@ -10,7 +10,7 @@ require "rake/gempackagetask"
 
 require 'spec/rake/spectask'
 
-task :default => [:wraptest]
+task :default => [:test]
 
 desc "Run all tests"
 Spec::Rake::SpecTask.new('test') do |t|
@@ -33,7 +33,7 @@ end
 
 spec = Gem::Specification.new do |spec|
   spec.name = "ruport-util"
-  spec.version = "0.10.0"
+  spec.version = "0.12.0"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "A set of tools and helper libs for Ruby Reports"
   spec.files =  Dir.glob("{example,lib,test,bin}/**/**/*") +

data/lib/ruport/util.rb

@@ -1,6 +1,6 @@
 module Ruport
   module Util
-    VERSION = "0.10.0"
+    VERSION = "0.12.0"
 
     file = __FILE__
     file = File.readlink(file) if File.symlink?(file)
@@ -18,4 +18,6 @@ require "ruport/util/mailer"
 require "ruport/util/bench"
 require "ruport/util/generator"
 require "ruport/util/pdf/form"
-require "ruport/util/ods"
+require "ruport/util/ods" 
+require "ruport/util/query"
+require "ruport/util/xls"

data/lib/ruport/util/graph/gruff.rb

@@ -39,11 +39,11 @@ class Ruport::Formatter
   
   class PDF
     def draw_graph(graph, opts={})
-      x = opts[:x]
-      y = opts[:y]
-      width = opts[:width]
-      height = opts[:height]
-      g = graph.as(:jpg)
+      x = opts.delete(:x)
+      y = opts.delete(:y)
+      width = opts.delete(:width)
+      height = opts.delete(:height)
+      g = graph.as(:jpg, opts)
       info = ::PDF::Writer::Graphics::ImageInfo.new(g)
       
       # reduce the size of the image until it fits into the requested box

data/lib/ruport/util/invoice.rb

@@ -4,8 +4,6 @@ module Ruport
                
       required_option :customer_info,:company_info,:order_info,:comments
 
-      option :title
-      
       stage :invoice_headers,:invoice_body,:invoice_footer
       
       finalize :invoice

data/lib/ruport/util/query.rb

@@ -0,0 +1,253 @@
+# Ruport : Extensible Reporting System                                
+#
+# query.rb provides a basic wrapper around RubyDBI for SQL interaction
+#
+# Original work began by Gregory Brown based on ideas from James Edward Gray II
+# in August, 2005.
+#
+# Copyright (C) 2005-2007, Gregory Brown
+# All Rights Reserved.   
+#
+# This is free software distributed under the same terms as Ruby 1.8
+# See LICENSE and COPYING for details.
+require "generator"
+
+module Ruport
+  
+  # === Overview
+  # 
+  # Query offers a way to interact with databases via RubyDBI. It supports
+  # returning result sets in either Ruport's Data::Table, or in their 
+  # raw form as DBI::Rows.
+  #
+  # Query allows you to treat your result sets as an Enumerable data structure
+  # that plays well with the rest of Ruport.
+  #
+  # If you are using ActiveRecord, you might prefer our acts_as_reportable
+  # extension.       
+  #
+  class Query 
+       
+    include Enumerable
+    
+    # Ruport::Query provides an interface for dealing with raw SQL queries.
+    # The SQL can be single or multistatement, but the resulting Data::Table 
+    # will consist only of the result of the last statement.
+    #
+    # Available options:
+    #
+    # <b><tt>:source</tt></b>::         A source specified in 
+    #                                   Ruport::Query.sources, defaults to 
+    #                                   <tt>:default</tt>.
+    # <b><tt>:dsn</tt></b>::            If specifed, the Query object will 
+    #                                   manually override Ruport::Query.
+    # <b><tt>:user</tt></b>::           If a DSN is specified, the user can 
+    #                                   be set with this option.
+    # <b><tt>:password</tt></b>::       If a DSN is specified, the password 
+    #                                   can be set with this option.
+    # <b><tt>:row_type</tt></b>::       When set to :raw, DBI::Rows will be 
+    #                                   returned instead of a Data::Table
+    #
+    # Examples:
+    #   
+    #   # uses Ruport::Query's default source
+    #   Ruport::Query.new("select * from fo")
+    #   
+    #   # uses the Ruport::Query's source labeled :my_source
+    #   Ruport::Query.new("select * from fo", :source => :my_source)
+    #
+    #   # uses a manually entered source
+    #   Ruport::Query.new("select * from fo", :dsn => "dbi:mysql:my_db",
+    #     :user => "greg", :password => "chunky_bacon" )
+    #
+    #   # uses a SQL file stored on disk
+    #   Ruport::Query.new("my_query.sql")
+    #
+    #   # explicitly use a file, even if it doesn't end in .sql
+    #   Ruport::Query.new(:file => "foo")
+    #
+    def initialize(sql, options={})   
+      if sql.kind_of?(Hash)  
+        options = { :source => :default }.merge(sql)   
+        sql = options[:file] || options[:string]
+      else 
+        options = { :source => :default, :string => sql }.merge(options)
+        options[:file] = sql if sql =~ /.sql$/    
+      end                                                 
+      origin = options[:file] ? :file : :string      
+      
+      @statements = SqlSplit.new(get_query(origin,sql))
+      @sql = @statements.join
+      
+      if options[:dsn]
+        Ruport::Query.add_source :temp, :dsn      => options[:dsn],
+                                        :user     => options[:user],
+                                     :password => options[:password]
+        options[:source] = :temp
+      end
+      
+      select_source(options[:source])
+      
+      @raw_data = options[:row_type].eql?(:raw)
+      @params = options[:params]
+    end
+     
+    # Returns an OpenStruct with the configuration options for the default
+    # database source.
+    #
+    def self.default_source
+      sources[:default]
+    end
+     
+    # Returns a hash of database sources, keyed by label.
+    def self.sources
+      @sources ||= {}
+    end
+    
+    # Allows you to add a labeled DBI source configuration. 
+    #
+    # Query objects will use the source labeled <tt>:default</tt>,
+    # unless another source is specified.
+    #
+    # Examples:
+    #
+    #   # a connection to a MySQL database foo with user root, pass chunkybacon
+    #   Query.add_source :default, :dsn => "dbi:mysql:foo", 
+    #                              :user => "root",
+    #                              :password => "chunkybacon"
+    #
+    #
+    #   # a second connection to a MySQL database bar
+    #   Query.add_source :test, :dsn => "dbi:mysql:bar",
+    #                           :user => "tester",
+    #                           :password => "blinky" 
+    #
+    # 
+    def self.add_source(name,options={})
+      sources[name] = OpenStruct.new(options)
+      check_source(sources[name],name)
+    end
+
+    attr_accessor :raw_data
+    
+    # The original SQL for the Query object
+    attr_reader :sql
+    
+    # This will set the <tt>dsn</tt>, <tt>username</tt>, and <tt>password</tt> 
+    # to one specified by a source in Ruport::Query.
+    #
+    def select_source(label)
+      @dsn      = Ruport::Query.sources[label].dsn
+      @user     = Ruport::Query.sources[label].user
+      @password = Ruport::Query.sources[label].password
+    end 
+    
+    # Yields result set by row.
+    def each(&action)
+      raise(LocalJumpError, "No block given!") unless action
+      fetch(&action)
+      self
+    end
+    
+    # Runs the SQL query and returns the result set 
+    def result; fetch; end
+    
+    # Runs the query without returning its results.
+    def execute; fetch; nil; end
+    
+    # Returns a Data::Table, even if in <tt>raw_data</tt> mode.
+    def to_table
+      data_flag, @raw_data = @raw_data, false
+      data = fetch; @raw_data = data_flag; return data
+    end
+
+    # Returns a csv dump of the query.
+    def to_csv
+      fetch.to_csv
+    end
+
+    # Returns a Generator object of the result set.
+    def generator
+      Generator.new(fetch)
+    end
+
+    private
+    
+    def query_data(query_text, params=@params)
+
+      require "dbi"
+      
+      data = @raw_data ? [] : Data::Table.new
+
+      DBI.connect(@dsn, @user, @password) do |dbh|
+        dbh.execute(query_text, *(params || [])) do |sth|
+          # Work-around for inconsistent DBD behavior w/ resultless queries
+          names = sth.column_names rescue []
+          if names.empty?
+            # Work-around for SQLite3 DBD bug
+            sth.cancel rescue nil
+            return nil
+          end
+          
+          data.column_names = names unless @raw_data
+
+          sth.each do |row|
+            row = row.to_a
+            row = Data::Record.new(row, :attributes => names) unless @raw_data
+            yield row if block_given?
+            data << row if !block_given?
+          end
+        end
+      end
+      data
+    end
+    
+    def get_query(type,query)
+      type.eql?(:file) ? load_file( query ) : query
+    end
+    
+    def fetch(&block)
+      data = nil
+      final = @statements.size - 1
+      @statements.each_with_index do |query_text, index|
+        data = query_data(query_text, &(index == final ? block : nil))
+      end
+      return data
+    end
+    
+    def load_file(query_file)
+      begin
+        File.read( query_file ).strip
+      rescue
+        raise LoadError, "Could not open #{query_file}"
+      end
+    end
+
+    def self.check_source(settings,label) # :nodoc:
+      raise ArgumentError unless settings.dsn
+    end
+    
+  end
+  
+  # Created by Francis Hwang, 2005.12.31
+  # Copyright (c) 2005, All Rights Reserved.
+  #++
+  class SqlSplit < Array  #:nodoc:
+    def initialize( sql )
+      super()
+      next_sql = ''
+      sql.each do |line|
+        unless line =~ /^--/ or line =~ %r{^/\*.*\*/;} or line =~ /^\s*$/
+          next_sql << line
+          if line =~ /;$/
+            next_sql.gsub!( /;\s$/, '' )
+            self << next_sql
+            next_sql = ''
+          end
+        end
+      end
+      self << next_sql if next_sql != ''
+    end
+  end
+  
+end

data/lib/ruport/util/xls.rb

@@ -0,0 +1,301 @@
+require 'cgi'
+require 'tmpdir'
+require 'zip/zip'
+
+module Ruport
+  # This class provides Excel output for Ruport's Table renderers.
+  # It can export to format :
+  #  * Excel 2003 (use spreadsheet/excel gems)
+  #  * Excel 2003 XML
+  #  * Excel 2007 OpenXML
+  # 
+  # === Rendering Options
+  #     * worksheet_name : Name of the Worksheet
+  #     * Renders
+  #       * xls => Excel 2003 (If spreadsheet/excel no exist use xml format instead)
+  #       * xlsx => Excel 2007 OpenXML
+  #       * xlsxml => Excel 2003 XML
+  #
+  class Formatter::XLS < Formatter
+    renders :xls, :for => [ Renderer::Row, Renderer::Table]
+
+    def initialize
+      Ruport.quiet {
+        require 'spreadsheet/excel'
+      }
+    end
+
+
+    def prepare_table
+      @xls_row = 0
+      @tempfile = Tempfile.new('output.xls')
+      @workbook = Spreadsheet::Excel.new(@tempfile.path)
+      @worksheet = @workbook.add_worksheet(options.worksheet_name || 'Ruport')
+      @header_style = options.header_style || @workbook.add_format(:bold => 1, :size => 12)
+    end
+
+    def build_table_header
+      if options.show_table_headers
+        table_row { build_cells(data.column_names, @header_style) }
+      end
+    end
+
+    def build_table_body
+      data.each do |r|
+          table_row { build_cells(r) }
+      end
+    end
+
+    def build_row
+      table_row{ build_cells(data.to_a) }
+    end
+    
+    def table_row
+      yield
+      @xls_row += 1
+    end
+
+    def build_cells(values, style = nil)
+      col = 0
+      values.each do |value|
+        if style
+          @worksheet.write(@xls_row, col, value, style)
+        else
+          @worksheet.write(@xls_row, col, value)
+        end
+        col += 1
+      end
+    end
+
+    def finalize_table
+      @workbook.close
+      options.io =
+        if options.tempfile
+          @tempfile
+        else
+          File.read(@tempfile.path)
+        end
+    end
+  end  
+  
+  # Excel 2007 OpenXML
+  class Formatter::XLSX < Formatter
+    BLANK_XLSX = File.join(Ruport::Util::BASEDIR, 'example', 'data', 'blank.xlsx')
+    renders :xlsx, :for => [ Renderer::Row, Renderer::Table]
+
+    def initialize
+    end
+    
+ 
+   
+    def prepare_table
+      @xls_row = 0
+      output << %{<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xml:space="preserve" xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+ <sheetPr codeName="#{options.worksheet_name || 'Ruport'}"/>
+
+ <sheetViews>
+  <sheetView tabSelected="1" workbookViewId="0">
+   <selection/>
+  </sheetView>
+ </sheetViews>
+ <sheetFormatPr defaultRowHeight="12.75"/>
+<cols>
+      }
+      data.column_names.size.times {
+        output << %{ <col min="1" max="1" width="10" customWidth="true"/>}
+      }
+      output << %{</cols><sheetData>}
+      @strings = []
+    end
+
+    def build_table_header
+      if options.show_table_headers
+        table_row { build_cells(data.column_names, 'Heading') }
+      end
+    end
+
+    def build_table_body
+      data.each do |r|
+          table_row { build_cells(r) }
+      end
+    end
+
+    def build_row
+      table_row{ build_cells(data.to_a) }
+    end
+
+    def table_row
+      output << %{        <row r="#{@xls_row + 1}">\n}
+      yield
+      output << %{        </row>\n}
+      @xls_row += 1
+    end
+
+    def get_cell_name(row, col)
+      name = ((col % 26) + 65).chr + row.to_s
+      name = ((col / 26) + 65).chr + name if (col / 26 != 0)
+      name
+    end
+
+    def build_cells(values, style = '')
+      col = 0
+      values.each do |value|
+        value = CGI.escapeHTML(value.to_s)
+        id = @strings.length
+        @strings.push(value)
+        output << %{<c r="#{get_cell_name(@xls_row + 1, col)}" t="s">
+    <v>#{id}</v>
+   </c>}
+        col += 1
+      end     
+    end
+
+    def build_strings_file
+      out = ''
+      out << %{<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" uniqueCount="#{@strings.length}">\n}
+      @strings.each {|val|
+        out << %{  <si><t>#{val}</t></si>\n} 
+      }
+      out << %{</sst>\n}
+      out
+    end
+    
+    def finalize_table
+      output << %{</sheetData>
+ <sheetProtection sheet="false" objects="false" scenarios="false" formatCells="false" formatColumns="false" formatRows="false" insertColumns="false" insertRows="false" insertHyperlinks="false" deleteColumns="false" deleteRows="false" selectLockedCells="false" sort="false" autoFilter="false" pivotTables="false" selectUnlockedCells="false"/>
+ <printOptions gridLines="false" gridLinesSet="true"/>
+ <pageMargins left="0.7" right="0.7" top="0.75" bottom="0.75" header="0.3" footer="0.3"/>
+
+ <pageSetup paperSize="1" orientation="default"/>
+ <headerFooter differentOddEven="false" differentFirst="false" scaleWithDoc="true" alignWithMargins="true">
+  <oddHeader></oddHeader>
+  <oddFooter></oddFooter>
+  <evenHeader></evenHeader>
+  <evenFooter></evenFooter>
+  <firstHeader></firstHeader>
+  <firstFooter></firstFooter>
+ </headerFooter>
+
+</worksheet>}
+
+      @tempfile = Tempfile.new('output.xlsx')
+
+      File.open(BLANK_XLSX) { |bo| 
+        @tempfile.print(bo.read(1024)) until bo.eof? 
+      }
+      @tempfile.close
+      zip = Zip::ZipFile.open(@tempfile.path)
+      zip.get_output_stream('xl/worksheets/sheet1.xml') do |cxml|
+        cxml.write(output)
+      end
+      zip.get_output_stream('xl/sharedStrings.xml') do |cxml|
+        cxml.write(build_strings_file)
+      end
+      workbook = %{<?xml version="1.0" encoding="UTF-8" standalone="yes"?><workbook xml:space="preserve"  xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+<fileVersion appName="xl" lastEdited="4" lowestEdited="4" rupBuild="4505"/>
+<workbookPr codeName="ThisWorkbook"/>
+	<bookViews>
+<workbookView activeTab="0" autoFilterDateGrouping="1" firstSheet="0" minimized="0" showHorizontalScroll="1" showSheetTabs="1" showVerticalScroll="1" tabRatio="600" visibility="visible"/>
+</bookViews>
+	<sheets>
+<sheet name="#{options.worksheet_name || 'Ruport'}" sheetId="1" r:id="rId4"/>
+</sheets>
+<definedNames/>
+<calcPr calcId="124519" calcMode="auto" fullCalcOnLoad="1"/>
+</workbook>}
+      zip.get_output_stream('xl/workbook.xml') do |cxml|
+        cxml.write(workbook)
+      end
+      zip.close
+      options.io =
+        if options.tempfile
+          @tempfile
+        else
+          File.read(@tempfile.path)
+        end
+    end
+  end
+  
+  # Excel 2003 XML
+  class Formatter::XLSXML < Formatter
+    renders :xlsxml, :for => [ Renderer::Row, Renderer::Table]
+   
+    def prepare_table
+     output << %{<?xml version="1.0" encoding="UTF-8"?><?mso-application progid="Excel.Sheet"?>
+    <Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"
+          xmlns:o="urn:schemas-microsoft-com:office:office"
+          xmlns:x="urn:schemas-microsoft-com:office:excel"
+          xmlns:html="http://www.w3.org/TR/REC-html40"
+          xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">
+      <Styles>
+        <Style ss:ID="Default" ss:Name="Default"/>
+
+        <Style ss:ID="Heading" ss:Name="Heading">#{options.header_style || '
+          <Alignment ss:Horizontal="Center"/>
+          <Font ss:Bold="1" ss:Italic="1" ss:Size="12"/>'}
+        </Style>
+        <Style ss:ID="co1"/>
+        <Style ss:ID="ta1"/>
+      </Styles>
+      <ss:Worksheet ss:Name="#{options.worksheet_name || 'Ruport'}">
+	<Table ss:StyleID="ta1">
+      }
+      data.column_names.size.times {
+        output << %{<Column ss:AutoFitWidth="1"/>}
+      }
+    end
+
+    def build_table_header
+      if options.show_table_headers
+        table_row { build_cells(data.column_names, 'Heading') }
+      end
+    end
+
+    def build_table_body
+      data.each do |r|
+          table_row { build_cells(r) }
+      end
+    end
+
+    def build_row
+      table_row{ build_cells(data.to_a) }
+    end
+    
+    def table_row
+      output << %{        <Row>\n}
+      yield
+      output << %{        </Row>\n}
+    end
+
+    def build_cells(values, style = '')
+      values.each do |value|
+        value = CGI.escapeHTML(value.to_s)
+        if style.length > 0
+          output << %{          <Cell>\n}
+        else
+          output << %{          <Cell ss:StyleID="#{style}">\n}
+        end
+        output << %{              <Data ss:Type="String">#{value}</Data>\n}
+        output << %{            </Cell>\n}
+      end
+    end
+
+    def finalize_table
+      output << %{      </Table>
+    </ss:Worksheet>
+</Workbook>}
+
+      @tempfile = Tempfile.new('output.xls')
+      @tempfile.print(output)
+      @tempfile.close();
+      options.io =
+        if options.tempfile
+          @tempfile
+        else
+          File.read(@tempfile.path)
+        end
+    end
+
+  end
+end

data/test/helper.rb

@@ -1,7 +1,14 @@
 begin
   require "rubygems"
+  gem "ruport", "=1.2.3" 
 rescue LoadError
   nil
+end   
+
+class Array
+  def to_table(columns)
+    Table(columns) { |t| each { |r| t << r }}   
+  end
 end
 
 require "spec"

data/test/test_format_xls.rb

@@ -0,0 +1,35 @@
+require 'test/helper'
+require 'rexml/document'
+testcase_requires 'hpricot'  
+testcase_requires 'spreadsheet/excel'
+
+describe 'XLS Formatter' do
+  before :all do
+    @csv = "first col,second col,third col\n" +
+           "first row,cell 1,cell 2\n"        +
+           "second row,cell 3,cell 4\n"       +
+           "third row,special >,special <\n"  +
+           "fourth row,,after empty\n"        +
+           "\n"                               +
+           "seventh row,nothing,more\n"
+    @table = Table(:string => @csv)
+    @xlsxml = Hpricot(@table.to_xlsxml())
+    @xls = @table.to_xls()
+    @xlsx = @table.to_xlsx(:tempfile => true)
+    zip = Zip::ZipFile.open(@xlsx.path)
+      @xlsx_content = Hpricot(zip.read('xl/worksheets/sheet1.xml'))
+    zip.close
+    @xlsx_rows = @xlsx_content.search('//row')
+  end
+
+  it 'should have content' do
+    @xlsxml.should_not be_nil
+    @xls.should_not be_nil
+    @xlsx.should_not be_nil
+  end
+
+  it 'should have all rows' do
+    #@xlsxml.search('//row').should have(7).rows
+    @xlsx_rows.should have(7).rows
+  end
+end

data/test/test_query.rb

@@ -0,0 +1,250 @@
+#!/usr/bin/env ruby -w 
+require 'test/helper'    
+testcase_requires 'dbi'
+
+$VERBOSE = nil
+   
+describe "A Query" do
+
+   before :each do
+     @sources = {
+       :default => {
+         :dsn => 'ruport:test',  :user => 'greg',   :password => 'apple' },
+       :alternative => {
+         :dsn => "ruport:test2", :user => "sandal", :password => "harmonix" },
+     }
+     Ruport::Query.add_source :default,     @sources[:default]
+     Ruport::Query.add_source :alternative, @sources[:alternative]
+ 
+     @columns = %w(a b c)
+     @data = [ [[1,2,3],[4,5,6],[7,8,9]],
+               [[9,8,7],[6,5,4],[3,2,1]],
+               [[7,8,9],[4,5,6],[1,2,3]], ]
+     @datasets = @data.dup
+ 
+     @sql = [ "select * from foo", "create table foo ..." ]
+     @sql << @sql.values_at(0, 0).join(";\n")
+     @sql << @sql.values_at(1, 0).join(";\n")
+     @query = {
+      :plain      => Ruport::Query.new(@sql[0]),
+      :sourced    => Ruport::Query.new(@sql[0], :source        => :alternative),
+      :paramed    => Ruport::Query.new(@sql[0], :params        => [ 42 ]),
+      :raw        => Ruport::Query.new(@sql[0], :row_type      => :raw),
+      :resultless => Ruport::Query.new(@sql[1]),
+      :multi      => Ruport::Query.new(@sql[2]),
+      :mixed      => Ruport::Query.new(@sql[3]),
+     }
+   end
+
+   if Object.const_defined? :DBI
+ 
+     it "should have a nil result on execute" do
+       query = @query[:plain]
+       setup_mock_dbi(1)
+ 
+       query.execute.should == nil
+     end
+   
+     it "should allow execute to work with sources" do
+        query = @query[:sourced]
+        setup_mock_dbi(1, :source => :alternative)
+      
+        query.execute.should == nil
+      end
+   
+      it "should allow excute to accept parameters" do
+        query = @query[:paramed]
+        setup_mock_dbi(1, :params => [ 42 ])
+
+        query.execute.should == nil   
+      end  
+   
+      it "should return nil for empty results" do
+        query = @query[:resultless]
+        setup_mock_dbi(1, :resultless => true, :sql => @sql[1])
+
+        query.result.should be_nil  
+      end      
+   
+      it "should return last query result for multiple statements" do
+        query = @query[:multi]
+        setup_mock_dbi(2)
+      
+        get_raw(query.result).should == @data[1] 
+      end
+   
+      it "should allow raw mode" do
+        query = @query[:raw]
+        setup_mock_dbi(1)
+        
+        query.result.should == @data[0]
+      end  
+   
+      it "should allow reading from file with .sql extension" do
+       File.should_receive(:read).
+         with("query_test.sql").
+         and_return("select * from foo\n")
+       
+       query = Ruport::Query.new "query_test.sql"
+       query.sql.should == "select * from foo" 
+     end      
+                 
+      it "should allow reading from file with explicit :file argument" do
+        File.should_receive(:read).
+        with("query_test").
+        and_return("select * from foo\n")  
+      
+        query = Ruport::Query.new(:file => "query_test")
+        query.sql.should == "select * from foo" 
+        
+        query = Ruport::Query.new(:string => "query_test")
+        query.sql.should == "query_test"       
+      end
+   
+      it "should raise a LoadError if the file is not found" do
+        File.should_receive(:read).
+          with("query_test.sql").
+          and_raise(Errno::ENOENT)
+      
+        lambda { query = Ruport::Query.new "query_test.sql" }.
+          should raise_error(LoadError)
+      end
+   
+      it "should support an each() iterator" do
+        query = @query[:plain]
+        setup_mock_dbi(2)
+      
+        result = []; query.each { |r| result << r.to_a }
+        result.should == @data[0]
+                     
+        result = []; query.each { |r| result << r.to_a }
+        result.should == @data[1]
+      end  
+
+      it "should iterate the last data set if multiple queries" do
+        query = @query[:multi]
+        setup_mock_dbi(2)
+      
+        result = []; query.each { |r| result << r.to_a }
+        result.should == @data[1]
+      end
+   
+      it "should raise a LocalJumpError if a block is not given" do
+        lambda { @query[:plain].each }.should raise_error(LocalJumpError)
+      end
+   
+      it "should allow selecting sources" do
+        query = @query[:plain]
+        query.select_source :alternative
+        get_query_source(query).should == @sources[:alternative]
+      
+        query.select_source :default
+        get_query_source(query).should == @sources[:default] 
+      end
+ 
+      it "should initialize a temporary source" do
+        query = Ruport::Query.new "<unused>", @sources[:alternative]
+        get_query_source(query).should == @sources[:alternative]
+      end
+ 
+      it "should initialize multiple temporary source" do
+        query1 = Ruport::Query.new "<unused>", @sources[:default]
+        query2 = Ruport::Query.new "<unused>", @sources[:alternative]
+      
+        get_query_source(query1).should == @sources[:default]
+        get_query_source(query2).should == @sources[:alternative] 
+      end  
+ 
+      it "should allow conversion to table" do
+        query = @query[:raw]
+        setup_mock_dbi(3, :returns => [@data[0]])
+      
+        query.result.should == @data[0]
+        query.to_table.should == @data[0].to_table(@columns)
+        query.result.should == @data[0]
+      end
+   
+      it "should support conversion to csv" do
+        query = @query[:plain]
+        setup_mock_dbi(1)
+        
+        csv = @data[0].to_table(@columns).as(:csv)
+        query.to_csv.should == csv
+      end
+     
+      it "should raise error when DSN is missing" do
+        lambda {
+          Ruport::Query.add_source :foo, :user => "root", :password => "fff"
+        }.should raise_error(ArgumentError)
+      end
+
+
+      it "should be able to set new defaults" do
+        Ruport::Query.add_source :default, :dsn      => "dbi:mysql:test",
+                                           :user     => "root",
+                                           :password => ""
+        Ruport::Query.default_source.dsn.should == "dbi:mysql:test"
+        Ruport::Query.default_source.user.should == "root" 
+        Ruport::Query.default_source.password.should == "" 
+      end
+
+      it "should allow setting multiple sources" do
+        Ruport::Query.add_source :foo, :dsn => "dbi:mysql:test"
+        Ruport::Query.add_source :bar, :dsn => "dbi:mysql:test2"
+        Ruport::Query.sources[:foo].dsn.should == "dbi:mysql:test"  
+        Ruport::Query.sources[:bar].dsn.should == "dbi:mysql:test2" 
+      end
+
+    end
+     
+   private
+   def setup_mock_dbi(count, options={})  
+     sql = options[:sql] || @sql[0]
+     source = options[:source] || :default
+     resultless = options[:resultless]
+     params = options[:params] || []
+     
+     @dbh = mock("database_handle")
+     @sth = mock("statement_handle")
+     def @dbh.execute(*a, &b); execute__(*a, &b); ensure; sth__.finish if b; end
+     def @sth.each; data__.each { |x| yield(x.dup) }; end
+     def @sth.fetch_all; data__; end
+     
+     DBI.should_receive(:connect).exactly(count).times.
+       with(*@sources[source].values_at(:dsn, :user, :password)).
+       and_yield(@dbh)
+     c = @dbh.should_receive(:execute__).exactly(count).times.with(sql, *params)
+     c.and_yield(@sth)
+     c.and_return(@sth)
+     @dbh.stub!(:sth__).and_return(@sth)
+     @sth.should_receive(:finish).with().exactly(count).times
+     unless resultless
+       @sth.stub!(:fetchable?).and_return(true) 
+       @sth.stub!(:column_names).and_return(@columns) 
+       if options[:returns]        
+         if Array == options[:returns]       
+            @sth.should_receive(:data__).any_number_of_times.and_return(*options[:returns])  
+         else        
+           @sth.should_receive(:data__).any_number_of_times.and_return(*Array(options[:returns])) 
+         end
+       else
+         @sth.should_receive(:data__).any_number_of_times.and_return(*@datasets)
+       end
+     else
+       @sth.stub!(:fetchable?).and_return(false)
+       @sth.stub!(:column_names).and_return([])
+       @sth.stub!(:cancel)
+       @sth.should_receive(:data__).exactly(0).times
+     end                
+   end
+   
+   def get_query_source(query)
+     [ :dsn, :user, :password ].inject({}) do |memo, var|
+       memo.update var => query.instance_variable_get("@#{var}")
+     end
+   end
+ 
+   def get_raw(table)
+     table.map { |row| row.to_a }
+   end
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
+rubygems_version: 0.9.2
 specification_version: 1
 name: ruport-util
 version: !ruby/object:Gem::Version 
-  version: 0.10.0
-date: 2007-11-24 00:00:00 -05:00
+  version: 0.12.0
+date: 2007-12-25 00:00:00 -05:00
 summary: A set of tools and helper libs for Ruby Reports
 require_paths: 
 - lib
@@ -30,64 +30,71 @@ authors:
 - Gregory Brown
 files: 
 - example/data
+- example/data/amline_settings.xml
+- example/data/blank.xlsx
+- example/data/amline_graph.xml
+- example/data/blank.ods
+- example/invoice_report.rb
 - example/draw_graph.rb
 - example/form.rb
-- example/graph_report.rb
 - example/gruff_report.rb
-- example/invoice_report.rb
-- example/mailer.rb
-- example/managed_report.rb
 - example/ods.rb
-- example/data/amline_graph.xml
-- example/data/amline_settings.xml
-- example/data/blank.ods
-- lib/open_flash_chart.rb
+- example/managed_report.rb
+- example/mailer.rb
+- example/graph_report.rb
 - lib/ruport
 - lib/ruport/util
-- lib/ruport/util.rb
-- lib/ruport/util/bench.rb
-- lib/ruport/util/generator.rb
 - lib/ruport/util/graph
-- lib/ruport/util/graph.rb
-- lib/ruport/util/invoice.rb
-- lib/ruport/util/mailer.rb
-- lib/ruport/util/ods.rb
-- lib/ruport/util/pdf
-- lib/ruport/util/report.rb
-- lib/ruport/util/report_manager.rb
+- lib/ruport/util/graph/scruffy.rb
 - lib/ruport/util/graph/amline.rb
-- lib/ruport/util/graph/gruff.rb
 - lib/ruport/util/graph/o_f_c.rb
-- lib/ruport/util/graph/scruffy.rb
+- lib/ruport/util/graph/gruff.rb
+- lib/ruport/util/pdf
 - lib/ruport/util/pdf/form.rb
+- lib/ruport/util/generator.rb
+- lib/ruport/util/bench.rb
+- lib/ruport/util/graph.rb
+- lib/ruport/util/ods.rb
+- lib/ruport/util/query.rb
+- lib/ruport/util/report_manager.rb
+- lib/ruport/util/xls.rb
+- lib/ruport/util/mailer.rb
+- lib/ruport/util/report.rb
+- lib/ruport/util/invoice.rb
+- lib/ruport/util.rb
+- lib/open_flash_chart.rb
 - test/helper
-- test/helper.rb
-- test/samples
-- test/test_format_ods.rb
-- test/test_graph_ofc.rb
-- test/test_graph_renderer.rb
-- test/test_hpricot_traverser.rb
-- test/test_invoice.rb
-- test/test_mailer.rb
-- test/test_report.rb
-- test/test_report_manager.rb
 - test/helper/layout.rb
 - test/helper/wrap.rb
+- test/samples
 - test/samples/data.csv
 - test/samples/foo.rtxt
+- test/test_report_manager.rb
+- test/test_format_xls.rb
+- test/helper.rb
+- test/test_query.rb
+- test/test_hpricot_traverser.rb
+- test/test_graph_renderer.rb
+- test/test_graph_ofc.rb
+- test/test_mailer.rb
+- test/test_report.rb
+- test/test_invoice.rb
+- test/test_format_ods.rb
 - bin/csv2ods
 - bin/rope
 - Rakefile
 - INSTALL
 test_files: 
-- test/test_format_ods.rb
-- test/test_graph_ofc.rb
-- test/test_graph_renderer.rb
+- test/test_report_manager.rb
+- test/test_format_xls.rb
+- test/test_query.rb
 - test/test_hpricot_traverser.rb
-- test/test_invoice.rb
+- test/test_graph_renderer.rb
+- test/test_graph_ofc.rb
 - test/test_mailer.rb
 - test/test_report.rb
-- test/test_report_manager.rb
+- test/test_invoice.rb
+- test/test_format_ods.rb
 rdoc_options: 
 - --title
 - ruport-util Documentation