derencius-acts_as_reportable 1.1.1

data/Rakefile

@@ -0,0 +1,63 @@
+require "rake/rdoctask"
+require "rake/testtask"
+require "rake/gempackagetask"
+
+AAR_VERSION = "1.1.1"
+
+begin
+  require "rubygems"
+rescue LoadError
+  nil
+end
+
+task :default => [:test]
+
+Rake::TestTask.new do |test|
+  test.libs << "test"
+  test.test_files = Dir[ "test/*_test.rb" ]
+  test.verbose = true
+end
+
+spec = Gem::Specification.new do |spec|
+  spec.name = "acts_as_reportable"
+  spec.version = AAR_VERSION
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = "ActiveRecord support for Ruby Reports"
+  spec.files =  Dir.glob("{lib,test}/**/**/*") +
+                      ["Rakefile"]
+  spec.require_path = "lib"
+  
+  spec.test_files = Dir[ "test/*_test.rb" ]
+  spec.has_rdoc = true
+  #spec.extra_rdoc_files = %w{README LICENSE AUTHORS}
+  spec.rdoc_options << '--title' << 'Ruport Documentation'
+  spec.add_dependency('ruport', '>= 1.6.0')
+  spec.author = "Michael Milner"
+  spec.email = "mikem836@gmail.com"
+  spec.rubyforge_project = "ruport"
+  spec.homepage = "http://rubyreports.org"
+  spec.description = <<END_DESC
+  acts_as_reportable provides ActiveRecord support for Ruby Reports
+END_DESC
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_files.include( "lib/" )
+  rdoc.main     = "README"
+  rdoc.rdoc_dir = "doc/html"
+  rdoc.title    = "acts_as_reportable Documentation"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.test_files = Dir[ "test/*_test.rb" ]
+  end
+rescue LoadError
+  nil
+end

data/lib/ruport/acts_as_reportable.rb

@@ -0,0 +1,385 @@
+# Ruport : Extensible Reporting System                                
+#
+# acts_as_reportable.rb provides ActiveRecord integration for Ruport.
+#     
+# Originally created by Dudley Flanders, 2006
+# Revised and updated by Michael Milner, 2007     
+# Copyright (C) 2006-2007 Dudley Flanders / Michael Milner, All Rights Reserved.  
+#
+# This is free software distributed under the same terms as Ruby 1.8
+# See LICENSE and COPYING for details.   
+#
+require "ruport"
+Ruport.quiet { require "active_record" }
+
+module Ruport
+  
+  # === Overview
+  # 
+  # This module is designed to allow an ActiveRecord model to be converted to
+  # Ruport's data structures.  If ActiveRecord is available when Ruport is
+  # loaded, this module will be automatically mixed into ActiveRecord::Base.
+  #
+  # Add the acts_as_reportable call to the model class that you want to
+  # integrate with Ruport:
+  #
+  #   class Book < ActiveRecord::Base
+  #     acts_as_reportable
+  #     belongs_to :author
+  #   end
+  #
+  # Then you can use the <tt>report_table</tt> method to get data from the
+  # model using ActiveRecord.
+  #
+  #   Book.report_table(:all, :include => :author)
+  #
+  module Reportable
+    
+    def self.included(base) #:nodoc:
+      base.extend ClassMethods  
+    end
+    
+    # === Overview
+    # 
+    # This module contains class methods that will automatically be available
+    # to ActiveRecord models.
+    #
+    module ClassMethods 
+      
+      # In the ActiveRecord model you wish to integrate with Ruport, add the 
+      # following line just below the class definition:
+      #
+      #   acts_as_reportable
+      #
+      # Available options:
+      #
+      # <b><tt>:only</tt></b>::     an attribute name or array of attribute
+      #                             names to include in the results, other
+      #                             attributes will be excuded.
+      # <b><tt>:except</tt></b>::   an attribute name or array of attribute
+      #                             names to exclude from the results.
+      # <b><tt>:methods</tt></b>::  a method name or array of method names
+      #                             whose result(s) will be included in the
+      #                             table.
+      # <b><tt>:include</tt></b>::  an associated model or array of associated
+      #                             models to include in the results.
+      #
+      # Example:
+      # 
+      #   class Book < ActiveRecord::Base
+      #     acts_as_reportable, :only => 'title', :include => :author
+      #   end
+      #
+      def acts_as_reportable(options = {})
+        cattr_accessor :aar_options, :aar_columns
+
+        self.aar_options = options
+
+        include Ruport::Reportable::InstanceMethods
+        extend Ruport::Reportable::SingletonMethods
+      end
+    end
+    
+    # === Overview
+    # 
+    # This module contains methods that will be made available as singleton
+    # class methods to any ActiveRecord model that calls
+    # <tt>acts_as_reportable</tt>.
+    #
+    module SingletonMethods
+      
+      # Creates a Ruport::Data::Table from an ActiveRecord find. Takes 
+      # parameters just like a regular find.
+      #
+      # Additional options include:
+      #
+      # <b><tt>:only</tt></b>::     An attribute name or array of attribute
+      #                             names to include in the results, other
+      #                             attributes will be excuded.
+      # <b><tt>:except</tt></b>::   An attribute name or array of attribute
+      #                             names to exclude from the results.
+      # <b><tt>:methods</tt></b>::  A method name or array of method names
+      #                             whose result(s) will be included in the
+      #                             table.
+      # <b><tt>:include</tt></b>::  An associated model or array of associated
+      #                             models to include in the results.
+      # <b><tt>:filters</tt></b>::  A proc or array of procs that set up
+      #                             conditions to filter the data being added
+      #                             to the table.
+      # <b><tt>:transforms</tt></b>::  A proc or array of procs that perform
+      #                                transformations on the data being added
+      #                                to the table.
+      # <b><tt>:record_class</tt></b>::  Specify the class of the table's
+      #                                  records.
+      # <b><tt>:eager_loading</tt></b>::  Set to false if you don't want to
+      #                                   eager load included associations.
+      #
+      # The :only, :except, :methods, and :include options may also be passed
+      # to the :include option in order to specify the output for any
+      # associated models. In this case, the :include option must be a hash,
+      # where the keys are the names of the associations and the values
+      # are hashes of options.
+      #
+      # Any options passed to report_table will disable the options set by
+      # the acts_as_reportable class method.
+      #
+      # Example:
+      # 
+      #   class Book < ActiveRecord::Base
+      #     belongs_to :author
+      #     acts_as_reportable
+      #   end
+      #
+      #   Book.report_table(:all, :only => ['title'],
+      #     :include => { :author => { :only => 'name' } }).as(:html)
+      #
+      # Returns:
+      #
+      # an html version of the table with two columns, title from 
+      # the book, and name from the associated author.
+      #
+      # Example:
+      # 
+      #   Book.report_table(:all, :include => :author).as(:html)
+      #
+      # Returns:
+      #
+      # an html version of the table with all columns from books and authors.
+      #
+      # Note: column names for attributes of included models will be qualified
+      # with the name of the association. 
+      #
+      def report_table(number = :all, options = {})
+        only = options.delete(:only)
+        except = options.delete(:except)
+        methods = options.delete(:methods)
+        includes = options.delete(:include)
+        filters = options.delete(:filters) 
+        transforms = options.delete(:transforms)
+        record_class = options.delete(:record_class) || Ruport::Data::Record
+        self.aar_columns = []
+
+        unless options.delete(:eager_loading) == false
+          options[:include] = get_include_for_find(includes)
+        end
+        
+        data = [find(number, options)].flatten
+        data = data.map {|r| r.reportable_data(:include => includes,
+                               :only => only,
+                               :except => except,
+                               :methods => methods) }.flatten   
+
+        table = Ruport::Data::Table.new(:data => data,
+                                        :column_names => aar_columns,
+                                        :record_class => record_class,
+                                        :filters => filters,
+                                        :transforms => transforms )
+      end
+      
+      # Creates a Ruport::Data::Table from an ActiveRecord find_by_sql.
+      #
+      # Additional options include:
+      #
+      # <b><tt>:filters</tt></b>::  A proc or array of procs that set up
+      #                             conditions to filter the data being added
+      #                             to the table.
+      # <b><tt>:transforms</tt></b>::  A proc or array of procs that perform
+      #                                transformations on the data being added
+      #                                to the table.
+      # <b><tt>:record_class</tt></b>::  Specify the class of the table's
+      #                                  records.
+      #
+      # Example:
+      # 
+      #   class Book < ActiveRecord::Base
+      #     belongs_to :author
+      #     acts_as_reportable
+      #   end
+      #
+      #   Book.report_table_by_sql("SELECT * FROM books")
+      #
+      def report_table_by_sql(sql, options = {})
+        record_class = options.delete(:record_class) || Ruport::Data::Record
+        filters = options.delete(:filters) 
+        transforms = options.delete(:transforms)
+        self.aar_columns = []
+
+        data = find_by_sql(sql)
+        data = data.map {|r| r.reportable_data }.flatten
+
+        table = Ruport::Data::Table.new(:data => data,
+                                        :column_names => aar_columns,
+                                        :record_class => record_class,
+                                        :filters => filters,
+                                        :transforms => transforms)
+      end
+
+      private
+      
+      def get_include_for_find(report_option)
+        includes = report_option.blank? ? aar_options[:include] : report_option
+        if includes.is_a?(Hash)
+          result = {}
+          includes.each do |k,v|
+            if v.empty? || !v[:include]
+              result.merge!(k => {})
+            else
+              result.merge!(k => get_include_for_find(v[:include]))
+            end
+          end
+          result
+        elsif includes.is_a?(Array)
+          result = {}
+          includes.each {|i| result.merge!(i => {}) }
+          result
+        else
+          includes
+        end
+      end
+    end
+    
+    # === Overview
+    # 
+    # This module contains methods that will be made available as instance
+    # methods to any ActiveRecord model that calls <tt>acts_as_reportable</tt>.
+    #
+    module InstanceMethods
+      
+      # Grabs all of the object's attributes and the attributes of the
+      # associated objects and returns them as an array of record hashes.
+      # 
+      # Associated object attributes are stored in the record with
+      # "association.attribute" keys.
+      # 
+      # Passing :only as an option will only get those attributes.
+      # Passing :except as an option will exclude those attributes.
+      # Must pass :include as an option to access associations.  Options
+      # may be passed to the included associations by providing the :include
+      # option as a hash.
+      # Passing :methods as an option will include any methods on the object.
+      #
+      # Example:
+      # 
+      #   class Book < ActiveRecord::Base
+      #     belongs_to :author
+      #     acts_as_reportable
+      #   end
+      # 
+      #   abook.reportable_data(:only => ['title'], :include => [:author])
+      #
+      # Returns:
+      #
+      #   [{'title' => 'book title',
+      #     'author.id' => 'author id',
+      #     'author.name' => 'author name' }]
+      #  
+      # NOTE: title will only be returned if the value exists in the table.
+      # If the books table does not have a title column, it will not be
+      # returned.
+      #
+      # Example:
+      #
+      #   abook.reportable_data(:only => ['title'],
+      #     :include => { :author => { :only => ['name'] } })
+      #
+      # Returns:
+      #
+      #   [{'title' => 'book title',
+      #     'author.name' => 'author name' }]
+      #
+      def reportable_data(options = {})
+        options = options.merge(self.class.aar_options) unless
+          has_report_options?(options)
+        
+        data_records = [get_attributes_with_options(options)]
+        Array(options[:methods]).each do |method|
+          if options[:qualify_attribute_names]
+            m = "#{options[:qualify_attribute_names]}.#{method}"
+          else
+            m = "#{method}"
+          end
+          data_records.first[m] = send(method)
+        end
+        
+        # Reorder columns to match options[:only]
+        if Array === options[:only]
+          cols = options[:only].map {|c| c.to_s }
+          self.class.aar_columns = cols
+        end
+                            
+        self.class.aar_columns |= data_records.first.keys  
+        
+        data_records =
+          add_includes(data_records, options[:include]) if options[:include] 
+          
+        data_records
+      end
+      
+      private
+
+      # Add data for all included associations
+      #
+      def add_includes(data_records, includes)
+        include_has_options = includes.is_a?(Hash)
+        associations = include_has_options ? includes.keys : Array(includes)
+        
+        associations.each do |association|
+          existing_records = data_records.dup
+          data_records = []
+          
+          if include_has_options
+            assoc_options = includes[association].merge({
+              :qualify_attribute_names => association })
+          else
+            assoc_options = { :qualify_attribute_names => association }
+          end
+          
+          association_objects = [send(association)].flatten.compact
+          
+          existing_records.each do |existing_record|
+            if association_objects.empty?
+              data_records << existing_record
+            else
+              association_objects.each do |obj|
+                association_records = obj.reportable_data(assoc_options)
+                association_records.each do |assoc_record|
+                  data_records << existing_record.merge(assoc_record)
+                end
+                self.class.aar_columns |= data_records.last.keys
+              end
+            end
+          end
+        end
+        data_records
+      end
+      
+      # Check if the options hash has any report options
+      # (:only, :except, :methods, or :include).
+      #
+      def has_report_options?(options)
+        options[:only] || options[:except] || options[:methods] ||
+          options[:include]
+      end
+
+      # Get the object's attributes using the supplied options.
+      # 
+      # Use the :only or :except options to limit the attributes returned.
+      #
+      # Use the :qualify_attribute_names option to append the association
+      # name to the attribute name as association.attribute
+      #
+      def get_attributes_with_options(options = {})
+        attrs = attributes
+        attrs.delete_if {|key, value| [*options[:except]].collect{|o| o.to_s}.include?( key.to_s) } if options[:except]
+        attrs.delete_if {|key, value| ![*options[:only]].collect{|o| o.to_s}.include?( key.to_s) } if options[:only]
+        
+        attrs = attrs.inject({}) {|h,(k,v)|
+                  h["#{options[:qualify_attribute_names]}.#{k}"] = v; h
+                } if options[:qualify_attribute_names]
+        attrs
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Ruport::Reportable

data/test/acts_as_reportable_test.rb

@@ -0,0 +1,286 @@
+class Array
+  def to_table(columns)
+    Table(columns) { |t| each { |r| t << r } }    
+  end
+end
+    
+
+#!/usr/bin/env ruby -w
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
+
+begin
+  require "mocha"
+  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_only_option_allows_symbols
+      column_order = [: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(%w[name personal_trainer_id team_id])
+      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

data/test/helpers.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+begin; require "rubygems"; rescue LoadError; nil; end
+require "ruport"
+require "spec-unit"
+
+class Test::Unit::TestCase
+  include SpecUnit
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: derencius-acts_as_reportable
+version: !ruby/object:Gem::Version 
+  version: 1.1.1
+platform: ruby
+authors: 
+- Michael Milner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.6.0
+    version: 
+description: acts_as_reportable provides ActiveRecord support for Ruby Reports
+email: mikem836@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ruport
+- lib/ruport/acts_as_reportable.rb
+- test/acts_as_reportable_test.rb
+- test/helpers.rb
+- Rakefile
+has_rdoc: true
+homepage: http://rubyreports.org
+post_install_message: 
+rdoc_options: 
+- --title
+- Ruport Documentation
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruport
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ActiveRecord support for Ruby Reports
+test_files: 
+- test/acts_as_reportable_test.rb