ruport 1.2.3 → 1.4.0

data/lib/ruport/query/sql_split.rb

@@ -1,33 +0,0 @@
-#--
-# sqlsplit.rb : A tool to properly split SQL input
-#
-# This is Free Software.  You may freely redistribute or modify under the terms
-# of the GNU General Public License or the Ruby License.  See LICENSE and
-# COPYING for details.
-#
-# Created by Francis Hwang, 2005.12.31
-# Copyright (c) 2005, All Rights Reserved.
-#++
-module Ruport
-  class Query
-    # This class properly splits up multi-statement SQL input for use with
-    # Ruby/DBI
-    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
-end

data/lib/ruport/query.rb

@@ -1,232 +0,0 @@
-# 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"
-require "ruport/query/sql_split"
-
-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
-end

data/test/acts_as_reportable_test.rb

@@ -1,272 +0,0 @@
-#!/usr/bin/env ruby -w
-require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
-
-begin
-  require "mocha"
-  require "stubba"      
-  Ruport.quiet { require "active_record" } 
-rescue LoadError
-  nil
-end
-
-if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
-
-  require "ruport/acts_as_reportable"   
-
-  class Team < ActiveRecord::Base
-    acts_as_reportable :except => 'id', :include => :players
-    has_many :players
-  end
-
-  class Player < ActiveRecord::Base
-    acts_as_reportable
-    belongs_to :team
-    belongs_to :personal_trainer
-  
-    def stats
-      "#{name} stats"
-    end
-  end
-  
-  module SomeModule
-    class PersonalTrainer < ActiveRecord::Base
-      acts_as_reportable
-      has_one :team
-      has_many :players
-    end
-  end
-  
-  module ModelStubsSetup
-    Column = ActiveRecord::ConnectionAdapters::Column
-    PersonalTrainer = SomeModule::PersonalTrainer
-    
-    def setup
-      setup_column_stubs
-
-      @trainers = []
-      @trainers << PersonalTrainer.new(:name => "Trainer 1")
-      @trainers << PersonalTrainer.new(:name => "Trainer 2")
-      @teams = []
-      @teams << Team.new( :name   => "Testers",
-                          :league => "My League")
-      @teams << Team.new( :name   => "Others",
-                          :league => "Other League")
-      @players = []
-      @players << Player.new( :team_id  => 1,
-                              :name     => "Player 1",
-                              :personal_trainer_id  => 1)
-      @players << Player.new( :team_id  => 1,
-                              :name     => "Player 2",
-                              :personal_trainer_id  => 2)
-    
-      setup_find_stubs
-    end
-    
-    private
-    
-    def setup_column_stubs
-      PersonalTrainer.stubs(:columns).returns([
-        Column.new("id", nil, "integer", false),
-        Column.new("name", nil, "string", false)])
-      Team.stubs(:columns).returns([Column.new("id", nil, "integer", false),
-        Column.new("name", nil, "string", false),
-        Column.new("league", nil, "string", true)])
-      Player.stubs(:columns).returns([Column.new("id", nil, "integer", false),
-        Column.new("team_id", nil, "integer", true),
-        Column.new("name", nil, "string", false),
-        Column.new("personal_trainer_id", nil, "integer", true)])
-    end
-  
-    def setup_find_stubs
-      PersonalTrainer.stubs(:find).returns(@trainers)
-      @trainers[0].stubs(:players).returns([@players[0]])
-      @trainers[1].stubs(:players).returns([@players[1]])
-      Team.stubs(:find).returns(@teams)
-      @teams[0].stubs(:players).returns(@players)
-      @teams[1].stubs(:players).returns([])
-      Player.stubs(:find).returns(@players)
-      Player.stubs(:find_by_sql).returns(@players)
-      @players[0].stubs(:team).returns(@teams[0])
-      @players[1].stubs(:team).returns(@teams[0])
-      @players[0].stubs(:personal_trainer).returns(@trainers[0])
-      @players[1].stubs(:personal_trainer).returns(@trainers[1])
-    end
-  end
-
-
-  class TestActsAsReportableClassMethods < Test::Unit::TestCase
-    
-    def test_aar_options_set
-      assert_equal({:except => 'id', :include => :players}, Team.aar_options)
-    end
-  end
-
-  class TestActsAsReportableSingletonMethods < Test::Unit::TestCase
-    include ModelStubsSetup
-    
-    def test_basic_report_table
-      actual = Player.report_table
-      expected = [[1, "Player 1", 1],
-        [1, "Player 2", 2]].to_table(%w[team_id name personal_trainer_id])
-      assert_equal expected, actual
-    end
-    
-    def test_report_table_by_sql
-      actual = Player.report_table_by_sql("SELECT * FROM players")
-      expected = [[1, "Player 1", 1],
-        [1, "Player 2", 2]].to_table(%w[team_id name personal_trainer_id])
-      assert_equal expected, actual
-    end
-    
-    def test_only_option
-      actual = Player.report_table(:all, :only => 'name')
-      expected = [["Player 1"],["Player 2"]].to_table(%w[name])
-      assert_equal expected, actual
-    end
-    
-    def test_only_option_preserves_column_sort_order
-      column_order = %w[name personal_trainer_id team_id]
-      actual = Player.report_table(:all, :only => column_order)
-      expected = [["Player 1", 1, 1],
-        ["Player 2", 2, 1]].to_table(column_order)
-      assert_equal expected, actual
-    end
-      
-    def test_except_option
-      actual = Player.report_table(:all, :except => 'personal_trainer_id')
-      expected = [[1, "Player 1"],[1, "Player 2"]].to_table(%w[team_id name])
-      assert_equal expected, actual
-    end
-      
-    def test_methods_option
-      actual = Player.report_table(:all, :only => 'name', :methods => :stats)
-      expected = [["Player 1", "Player 1 stats"],
-                  ["Player 2", "Player 2 stats"]].to_table(%w[name stats])
-      assert_equal expected, actual
-    end
-      
-    def test_include_option
-      actual = Player.report_table(:all, :only => 'name',
-        :include => :personal_trainer)
-      expected = [["Player 1", "Trainer 1"],
-        ["Player 2", "Trainer 2"]].to_table(%w[name personal_trainer.name])
-      assert_equal expected, actual
-    end
-    
-    def test_column_sorting_works_with_include_option
-      actual = Player.report_table(:all,
-        :only     => %w[name personal_trainer.name],
-        :include  => { :personal_trainer => { :only => %w[name] } })
-      expected = [["Player 1", "Trainer 1"],
-        ["Player 2", "Trainer 2"]].to_table(%w[name personal_trainer.name])
-      assert_equal expected, actual
-      
-      actual = Player.report_table(:all,
-        :only     => %w[personal_trainer.name name],
-        :include  => { :personal_trainer => { :only => %w[name] } })
-      expected = [["Trainer 1", "Player 1"],
-        ["Trainer 2", "Player 2"]].to_table(%w[personal_trainer.name name])
-      assert_equal expected, actual
-    end
-      
-    def test_include_has_options
-      actual = Team.report_table(:all, :only => 'name',
-        :include => { :players => { :only => 'name' } })
-      expected = [["Testers", "Player 1"],
-        ["Testers", "Player 2"],
-        ["Others", nil]].to_table(%w[name players.name])
-      assert_equal expected, actual
-    end
-    
-    class CustomRecord < Ruport::Data::Record; end
-
-    def test_record_class_option
-      actual = Player.report_table(:all, :record_class => CustomRecord)
-      actual.each { |r| assert_equal CustomRecord, r.class }
-
-      actual = Player.report_table_by_sql("SELECT * FROM players",
-                 :record_class => CustomRecord)
-      actual.each { |r| assert_equal CustomRecord, r.class }
-    end
-
-    def test_get_include_for_find
-      assert_equal :players, Team.send(:get_include_for_find, nil)
-      assert_equal nil, Player.send(:get_include_for_find, nil)
-      assert_equal :team, Player.send(:get_include_for_find, :team)
-      expected = {:team => {}}
-      assert_equal expected,
-        Player.send(:get_include_for_find, {:team => {:except => 'id'}})
-      expected = {:team => {:a => {}, :b => {}},
-        :c => {:d => {:e => {}, :f => {}}},
-        :g => {}}
-      assert_equal expected,
-        Player.send(:get_include_for_find, {:team => {:include => [:a,:b]},
-        :c => {:include => {:d => {:include => [:e,:f]}}}, :g => {}})
-    end  
-  end
-    
-  class TestActsAsReportableInstanceMethods < Test::Unit::TestCase
-    include ModelStubsSetup
-    
-    def test_reportable_data
-      actual = @players[0].reportable_data
-      expected = [{ 'team_id' => 1,
-                    'name' => "Player 1",
-                    'personal_trainer_id' => 1 }]
-      assert_equal expected, actual
-    
-      actual = @teams[0].reportable_data(:include =>
-        { :players => { :only => 'name' } })
-      expected = [{ 'name' => "Testers",
-                    'league' => "My League",
-                    'players.name' => "Player 1" },
-                    { 'name' => "Testers",
-                    'league' => "My League",
-                    'players.name' => "Player 2" }]
-      assert_equal expected, actual
-    end
-    
-    def test_add_includes
-      actual = @players[0].send(:add_includes,
-        [{ 'name' => "Player 1" }], :personal_trainer)
-      expected = [{ 'name' => "Player 1",
-                    'personal_trainer.name' => "Trainer 1" }]
-      assert_equal expected, actual
-    end
-    
-    def test_has_report_options
-      assert @teams[0].send(:has_report_options?, { :only => 'name' })
-      assert @teams[0].send(:has_report_options?, { :except => 'name' })
-      assert @teams[0].send(:has_report_options?, { :methods => 'name' })
-      assert @teams[0].send(:has_report_options?, { :include => 'name' })
-      assert !@teams[0].send(:has_report_options?, { :foo => 'name' })
-    end
-      
-    def test_get_attributes_with_options
-      actual = @players[0].send(:get_attributes_with_options)
-      expected = { 'team_id' => 1,
-                   'name' => "Player 1",
-                   'personal_trainer_id' => 1 }
-      assert_equal expected, actual
-    
-      actual = @players[0].send(:get_attributes_with_options,
-        { :only => 'name' })
-      expected = { 'name' => "Player 1" }
-      assert_equal expected, actual
-    
-      actual = @players[0].send(:get_attributes_with_options,
-        { :except => 'personal_trainer_id' })
-      expected = { 'team_id' => 1,
-                   'name' => "Player 1" }
-      assert_equal expected, actual
-    
-      actual = @players[0].send(:get_attributes_with_options,
-        { :only => 'name', :qualify_attribute_names => :players })
-      expected = { 'players.name' => "Player 1" }
-      assert_equal expected, actual
-    end
-  end
-
-else
-  $stderr.puts "Warning: Mocha and/or ActiveRecord not found -- skipping AAR tests"
-end