reportable 1.2.0 → 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c29f948fbe08b5fcd5fcb8c93b8eb080a5a63e39
+  data.tar.gz: e74b8522ddd8b95af32653a27b30aa056538ee68
+SHA512:
+  metadata.gz: 991545e56bce51a1c3fdff4bc85487f63368d63b5b12d87598168c4955093d97cce4ef380e96609afe3e1f46f0ce98bccbeaa20991378100ea9484127b395963
+  data.tar.gz: 7a0e85284ec828a4e2eb77314d02e1304e584821f7aad8b172ffc06c0c590e26d79da66ed8b2922c6635b6936f1762c148d58d1a94001d930178c86460386725

data/README.md

@@ -1,5 +1,6 @@
 Reportable
 ==========
+[![Build Status](https://travis-ci.org/saulabs/reportable.png?branch=master)](https://travis-ci.org/saulabs/reportable)
 
 Reportable allows for the easy creation of reports based on `ActiveRecord` models.
 

data/Rakefile

@@ -4,15 +4,14 @@ require 'bundler'
 Bundler.setup
 Bundler.require
 
-require 'spec/rake/spectask'
-require 'simplabs/excellent/rake'
+require "rspec/core/rake_task"
+
 
 desc 'Default: run specs.'
 task :default => :spec
 
 desc 'Run the specs'
-Spec::Rake::SpecTask.new(:spec) do |t|
-  t.spec_files = FileList['spec/**/*_spec.rb']
+RSpec::Core::RakeTask.new(:spec) do |spec|
 end
 
 YARD::Rake::YardocTask.new(:doc) do |t|
@@ -20,6 +19,3 @@ YARD::Rake::YardocTask.new(:doc) do |t|
   t.options = ['--no-private', '--title', 'Reportable Documentation']
 end
 
-Simplabs::Excellent::Rake::ExcellentTask.new(:excellent) do |t|
-  t.paths = %w(lib)
-end

data/generators/reportable_jquery_flot_assets/reportable_jquery_flot_assets_generator.rb

@@ -2,6 +2,8 @@ class ReportableJqueryFlotAssetsGenerator < Rails::Generators::Base
 
   include Rails::Generators::Actions
 
+  source_root File.expand_path('../templates/', __FILE__)
+
   def create_jquery_flot_file
     empty_directory('public/javascripts')
     copy_file(

data/generators/reportable_migration/reportable_migration_generator.rb

@@ -2,11 +2,10 @@ class ReportableMigrationGenerator < Rails::Generators::Base
 
   include Rails::Generators::Migration
 
+  source_root File.expand_path('../templates/', __FILE__)
+
   def create_migration
-    migration_template(
-      File.join(File.dirname(__FILE__), 'templates', 'migration.rb'),
-      'db/migrate/create_reportable_cache.rb'
-    )
+    migration_template('migration.rb', 'db/migrate/create_reportable_cache.rb')
   end
 
   def self.next_migration_number(dirname)

data/generators/reportable_raphael_assets/reportable_raphael_assets_generator.rb

@@ -2,6 +2,8 @@ class ReportableRaphaelAssetsGenerator < Rails::Generators::Base
 
   include Rails::Generators::Actions
 
+  source_root File.expand_path('../templates/', __FILE__)
+
   def create_raphael_file
     empty_directory('public/javascripts')
     copy_file(

data/lib/saulabs/reportable.rb

@@ -38,6 +38,8 @@ module Saulabs
         #   the number of reporting periods to get (see +:grouping+)
         # @option options [Hash] :conditions ({})
         #   conditions like in +ActiveRecord::Base#find+; only records that match these conditions are reported;
+        # @option options [Hash] :include ({})
+        #   include like in +ActiveRecord::Base#find+; names associations that should be loaded alongside; the symbols named refer to already defined associations
         # @option options [Boolean] :live_data (false)
         #   specifies whether data for the current reporting period is to be read; <b>if +:live_data+ is +true+, you will experience a performance hit since the request cannot be satisfied from the cache alone</b>
         # @option options [DateTime, Boolean] :end_date (false)

data/lib/saulabs/reportable/cumulated_report.rb

@@ -34,7 +34,7 @@ module Saulabs
 
         def initial_cumulative_value(date, options)
           conditions = setup_conditions(nil, date, options[:conditions])
-          @klass.send(@aggregation, @value_column, :conditions => conditions)
+          @klass.where(conditions).calculate(@aggregation, @value_column)
         end
 
     end

data/lib/saulabs/reportable/grouping.rb

@@ -41,6 +41,8 @@ module Saulabs
             from_sqlite_db_string(db_string)
           when /postgres/i
             from_postgresql_db_string(db_string)
+          when /mssql/i, /sqlserver/i
+            from_sqlserver_db_string(db_string)
         end
       end
 
@@ -57,6 +59,8 @@ module Saulabs
             sqlite_format(date_column)
           when /postgres/i
             postgresql_format(date_column)
+          when /mssql/i, /sqlserver/i
+            sqlserver_format(date_column)
         end
       end
 
@@ -94,6 +98,14 @@ module Saulabs
           end
         end
 
+        def from_sqlserver_db_string(db_string)
+          if @identifier == :week
+            parts = [db_string[0..3], db_string[5..6]].map(&:to_i)
+          else
+            db_string.split(/[- ]/).map(&:to_i)
+          end
+        end
+
         def mysql_format(date_column)
           case @identifier
             when :hour
@@ -133,6 +145,19 @@ module Saulabs
           end
         end
 
+        def sqlserver_format(date_column)
+          case @identifier
+            when :hour
+              "DATEADD(hh,DATEDIFF(hh,DATEADD(dd,DATEDIFF(dd,'1 Jan 1900',#{date_column}), '1 Jan 1900'),#{date_column}), DATEADD(dd,DATEDIFF(dd,'1 Jan 1900',#{date_column}), '1 Jan 1900'))"
+            when :day
+              "DATEADD(dd,DATEDIFF(dd,'1 Jan 1900',#{date_column}), '1 Jan 1900')"
+            when :week
+              "LEFT(CONVERT(varchar,#{date_column},120), 4) + '-' + CAST(DATEPART(isowk,#{date_column}) AS VARCHAR)"
+            when :month
+              "DATEADD(mm,DATEDIFF(mm,'1 Jan 1900',#{date_column}), '1 Jan 1900')"
+          end
+        end
+
     end
 
   end

data/lib/saulabs/reportable/report.rb

@@ -54,6 +54,8 @@ module Saulabs
       #   the number of reporting periods to get (see +:grouping+)
       # @option options [Hash] :conditions ({})
       #   conditions like in +ActiveRecord::Base#find+; only records that match these conditions are reported;
+      # @option options [Hash] :include ({})
+      #   include like in +ActiveRecord::Base#find+; names associations that should be loaded alongside; the symbols named refer to already defined associations
       # @option options [Boolean] :live_data (false)
       #   specifies whether data for the current reporting period is to be read; <b>if +:live_data+ is +true+, you will experience a performance hit since the request cannot be satisfied from the cache alone</b>
       # @option options [DateTime, Boolean] :end_date (false)
@@ -68,6 +70,8 @@ module Saulabs
         @value_column = (options[:value_column] || (@aggregation == :count ? 'id' : name)).to_s
         @options = {
           :limit      => options[:limit] || 100,
+          :distinct   => options[:distinct] || false,
+          :include    => options[:include] || [],
           :conditions => options[:conditions] || [],
           :grouping   => Grouping.new(options[:grouping] || :day),
           :live_data  => options[:live_data] || false,
@@ -115,13 +119,14 @@ module Saulabs
 
         def read_data(begin_at, end_at, options)
           conditions = setup_conditions(begin_at, end_at, options[:conditions])
-          @klass.send(@aggregation,
-            @value_column,
-            :conditions => conditions,
-            :group      => options[:grouping].to_sql(@date_column),
-            :order      => "#{options[:grouping].to_sql(@date_column)} ASC",
-            :limit      => options[:limit]
-          )
+          table_name = ActiveRecord::Base.connection.quote_table_name(@klass.table_name)
+          date_column = ActiveRecord::Base.connection.quote_column_name(@date_column.to_s)
+          grouping = options[:grouping].to_sql("#{table_name}.#{date_column}")
+          order    = "#{grouping} ASC"
+
+          @klass.where(conditions).includes(options[:include]).distinct(options[:distinct]).
+            group(grouping).order(order).limit(options[:limit]).
+            calculate(@aggregation, @value_column)
         end
 
         def setup_conditions(begin_at, end_at, custom_conditions = [])
@@ -145,13 +150,13 @@ module Saulabs
           case context
             when :initialize
               options.each_key do |k|
-                raise ArgumentError.new("Invalid option #{k}!") unless [:limit, :aggregation, :grouping, :date_column, :value_column, :conditions, :live_data, :end_date].include?(k)
+                raise ArgumentError.new("Invalid option #{k}!") unless [:limit, :aggregation, :grouping, :distinct, :include, :date_column, :value_column, :conditions, :live_data, :end_date].include?(k)
               end
               raise ArgumentError.new("Invalid aggregation #{options[:aggregation]}!") if options[:aggregation] && ![:count, :sum, :maximum, :minimum, :average].include?(options[:aggregation])
               raise ArgumentError.new('The name of the column holding the value to sum has to be specified for aggregation :sum!') if [:sum, :maximum, :minimum, :average].include?(options[:aggregation]) && !options.key?(:value_column)
             when :run
               options.each_key do |k|
-                raise ArgumentError.new("Invalid option #{k}!") unless [:limit, :conditions, :grouping, :live_data, :end_date].include?(k)
+                raise ArgumentError.new("Invalid option #{k}!") unless [:limit, :conditions, :include, :grouping, :live_data, :end_date].include?(k)
               end
           end
           raise ArgumentError.new('Options :live_data and :end_date may not both be specified!') if options[:live_data] && options[:end_date]

data/lib/saulabs/reportable/report_cache.rb

@@ -20,7 +20,7 @@ module Saulabs
       validates_presence_of :value
       validates_presence_of :reporting_period
 
-      attr_accessible :model_name, :report_name, :grouping, :aggregation, :value, :reporting_period, :conditions
+      # attr_accessible :model_name, :report_name, :grouping, :aggregation, :value, :reporting_period, :conditions
 
       self.skip_time_zone_conversion_for_attributes = [:reporting_period]
 
@@ -40,10 +40,7 @@ module Saulabs
       #   Saulabs::Reportable::ReportCache.clear_for(User, :registrations)
       #
       def self.clear_for(klass, report)
-        self.delete_all(:conditions => {
-          :model_name  => klass.name,
-          :report_name => report.to_s
-        })
+        self.where(model_name: klass.name, report_name: report.to_s).delete_all
       end
 
       # Processes the report using the respective cache.
@@ -69,6 +66,15 @@ module Saulabs
       #
       def self.process(report, options, &block)
         raise ArgumentError.new('A block must be given') unless block_given?
+
+        # If end_date is in the middle of the current reporting period it means it requests live_data.
+        # Update the options hash to reflect reality.
+        current_reporting_period = ReportingPeriod.new(options[:grouping])
+        if options[:end_date] && options[:end_date] > current_reporting_period.date_time
+          options[:live_data] = true
+          options.delete(:end_date)
+        end
+
         self.transaction do
           cached_data = read_cached_data(report, options)
           new_data = read_new_data(cached_data, options, &block)
@@ -79,8 +85,8 @@ module Saulabs
       private
 
         def self.prepare_result(new_data, cached_data, report, options)
-          new_data = new_data.map { |data| [ReportingPeriod.from_db_string(options[:grouping], data[0]), data[1]] }
-          cached_data.map! { |cached| [ReportingPeriod.new(options[:grouping], cached.reporting_period), cached.value] }
+          new_data = new_data.to_a.map { |data| [ReportingPeriod.from_db_string(options[:grouping], data[0]), data[1]] }
+          cached_data.to_a.map! { |cached| [ReportingPeriod.new(options[:grouping], cached.reporting_period), cached.value] }
           current_reporting_period = ReportingPeriod.new(options[:grouping])
           reporting_period = get_first_reporting_period(options)
           result = []
@@ -128,45 +134,54 @@ module Saulabs
         end
 
         def self.read_cached_data(report, options)
-          options[:conditions] ||= []
-          conditions = [
-            %w(model_name report_name grouping aggregation conditions).map do |column_name|
-              "#{self.connection.quote_column_name(column_name)} = ?"
-            end.join(' AND '),
-            report.klass.to_s,
-            report.name.to_s,
-            options[:grouping].identifier.to_s,
-            report.aggregation.to_s,
-            serialize_conditions(options[:conditions])
-          ]
-          first_reporting_period = get_first_reporting_period(options)
-          last_reporting_period = get_last_reporting_period(options)
-          if last_reporting_period
-            conditions.first << ' AND reporting_period BETWEEN ? AND ?'
-            conditions << first_reporting_period.date_time
-            conditions << last_reporting_period.date_time
+          conditions = build_conditions_for_reading_cached_data(report, options)
+          conditions.limit(options[:limit]).order('reporting_period ASC')
+        end
+
+        def self.build_conditions_for_reading_cached_data(report, options)
+          start_date = get_first_reporting_period(options).date_time
+
+          conditions = where('reporting_period >= ?', start_date).where(
+            model_name: report.klass.to_s,
+            report_name: report.name.to_s,
+            grouping: options[:grouping].identifier.to_s,
+            aggregation: report.aggregation.to_s,
+            conditions: serialize_conditions(options[:conditions] || [])
+          )
+
+          if options[:end_date]
+            end_date = ReportingPeriod.new(options[:grouping], options[:end_date]).date_time
+            conditions.where('reporting_period <= ?', end_date)
           else
-            conditions.first << ' AND reporting_period >= ?'
-            conditions << first_reporting_period.date_time
+            conditions
           end
-          self.all(
-            :conditions => conditions,
-            :limit      => options[:limit],
-            :order      => 'reporting_period ASC'
-          )
         end
 
         def self.read_new_data(cached_data, options, &block)
-          if !options[:live_data] && cached_data.length == options[:limit]
-            []
+          return [] if !options[:live_data] && cached_data.size == options[:limit]
+
+          first_reporting_period_to_read = get_first_reporting_period_to_read(cached_data, options)
+          last_reporting_period_to_read = options[:end_date] ? ReportingPeriod.new(options[:grouping], options[:end_date]).last_date_time : nil
+
+          yield(first_reporting_period_to_read.date_time, last_reporting_period_to_read)
+        end
+
+        def self.get_first_reporting_period_to_read(cached_data, options)
+          return get_first_reporting_period(options) if cached_data.empty?
+
+          last_cached_reporting_period = ReportingPeriod.new(options[:grouping], cached_data.last.reporting_period)
+          missing_reporting_periods = options[:limit] - cached_data.length
+          last_reporting_period = if !options[:live_data] && options[:end_date]
+            ReportingPeriod.new(options[:grouping], options[:end_date])
           else
-            first_reporting_period_to_read = if cached_data.length < options[:limit]
-              get_first_reporting_period(options)
-            else
-              ReportingPeriod.new(options[:grouping], cached_data.last.reporting_period).next
-            end
-            last_reporting_period_to_read = options[:end_date] ? ReportingPeriod.new(options[:grouping], options[:end_date]).last_date_time : nil
-            yield(first_reporting_period_to_read.date_time, last_reporting_period_to_read)
+            ReportingPeriod.new(options[:grouping]).previous
+          end
+
+          if missing_reporting_periods == 0 || last_cached_reporting_period.offset(missing_reporting_periods) == last_reporting_period
+            # cache only has missing data contiguously at the end
+            last_cached_reporting_period.next
+          else
+            get_first_reporting_period(options)
           end
         end
 
@@ -178,10 +193,6 @@ module Saulabs
           end
         end
 
-        def self.get_last_reporting_period(options)
-          return ReportingPeriod.new(options[:grouping], options[:end_date]) if options[:end_date]
-        end
-
     end
 
   end

data/lib/saulabs/reportable/reporting_period.rb

@@ -70,7 +70,7 @@ module Saulabs
       #   the reporting period for the {Saulabs::Reportable::Grouping} as parsed from the db string
       #
       def self.from_db_string(grouping, db_string)
-        return self.new(grouping, db_string) if db_string.is_a?(Date)
+        return self.new(grouping, db_string) if db_string.is_a?(Date) || db_string.is_a?(Time)
         parts = grouping.date_parts_from_db_string(db_string.to_s)
         case grouping.identifier
           when :hour

data/spec/classes/grouping_spec.rb

@@ -76,6 +76,30 @@ describe Saulabs::Reportable::Grouping do
 
     end
 
+    describe 'for MS SQL Server' do
+
+      before do
+        ActiveRecord::Base.connection.stub!(:adapter_name).and_return('sqlserver')
+      end
+
+      it 'should output a format of "YYYY-MM-DD HH:00:00.0" for grouping :hour' do # string "%Y-%m-%d %h:00:00.0" 
+        Saulabs::Reportable::Grouping.new(:hour).send(:to_sql, 'created_at').should == "DATEADD(hh,DATEDIFF(hh,DATEADD(dd,DATEDIFF(dd,'1 Jan 1900',created_at), '1 Jan 1900'),created_at), DATEADD(dd,DATEDIFF(dd,'1 Jan 1900',created_at), '1 Jan 1900'))"
+      end
+
+      it 'should output a format of "YYYY-MM-DD" for grouping :day' do
+        Saulabs::Reportable::Grouping.new(:day).send(:to_sql, 'created_at').should == "DATEADD(dd,DATEDIFF(dd,'1 Jan 1900',created_at), '1 Jan 1900')"
+      end
+
+      it 'should output a format of "YYYY-WW" for grouping :week' do
+        Saulabs::Reportable::Grouping.new(:week).send(:to_sql, 'created_at').should == "LEFT(CONVERT(varchar,created_at,120), 4) + '-' + CAST(DATEPART(isowk,created_at) AS VARCHAR)"
+      end
+
+      it 'should output a format of "YYYY-MM-01" for grouping :month' do
+        Saulabs::Reportable::Grouping.new(:month).send(:to_sql, 'created_at').should == "DATEADD(mm,DATEDIFF(mm,'1 Jan 1900',created_at), '1 Jan 1900')"
+      end
+
+    end
+
   end
 
   describe '#date_parts_from_db_string' do
@@ -94,7 +118,7 @@ describe Saulabs::Reportable::Grouping do
 
       end
 
-      it 'should split the string with "-" and return teh calendar year and week for grouping :week' do
+      it 'should split the string with "-" and return the calendar year and week for grouping :week' do
         db_string = '2008-2-1'
         expected = [2008, 5]
 
@@ -150,6 +174,29 @@ describe Saulabs::Reportable::Grouping do
 
     end
 
+    describe 'for MS SQL Server' do
+
+      before do
+        ActiveRecord::Base.connection.stub!(:adapter_name).and_return('sqlserver')
+      end
+
+      for grouping in [[:hour, '2008-12-31 12'], [:day, '2008-12-31'], [:month, '2008-12']] do
+
+        it "should split the string with '-' and ' ' for grouping :#{grouping[0].to_s}" do
+          Saulabs::Reportable::Grouping.new(grouping[0]).date_parts_from_db_string(grouping[1]).should == grouping[1].split(/[- ]/).map(&:to_i)
+        end
+
+      end
+
+      it 'should use the first 4 numbers for the year and the last 2 numbers for the week for grouping :week' do
+        db_string = '2008-52'
+        expected = [2008, 52]
+
+        Saulabs::Reportable::Grouping.new(:week).date_parts_from_db_string(db_string).should == expected
+      end
+
+    end
+
   end
 
 end

data/spec/classes/report_cache_spec.rb

@@ -91,19 +91,6 @@ describe Saulabs::Reportable::ReportCache do
 
   end
 
-  describe '.clear_for' do
-
-    it 'should delete all entries in the cache for the klass and report name' do
-      Saulabs::Reportable::ReportCache.should_receive(:delete_all).once.with(:conditions => {
-        :model_name  => User.name,
-        :report_name => 'registrations'
-      })
-
-      Saulabs::Reportable::ReportCache.clear_for(User, :registrations)
-    end
-
-  end
-
   describe '.process' do
 
     before do
@@ -136,11 +123,7 @@ describe Saulabs::Reportable::ReportCache do
       end
 
       it 'should yield the first reporting period if not all required data could be retrieved from the cache' do
-        reporting_period = Saulabs::Reportable::ReportingPeriod.new(
-          @report.options[:grouping],
-          Time.now - 3.send(@report.options[:grouping].identifier)
-        )
-        Saulabs::Reportable::ReportCache.stub!(:all).and_return([Saulabs::Reportable::ReportCache.new])
+        Saulabs::Reportable::ReportCache.stub!(:read_cached_data).and_return([Saulabs::Reportable::ReportCache.new])
 
         Saulabs::Reportable::ReportCache.process(@report, @options) do |begin_at, end_at|
           begin_at.should == Saulabs::Reportable::ReportingPeriod.first(@report.options[:grouping], @report.options[:limit]).date_time
@@ -156,7 +139,7 @@ describe Saulabs::Reportable::ReportCache do
         )
         cached = Saulabs::Reportable::ReportCache.new
         cached.stub!(:reporting_period).and_return(reporting_period.date_time)
-        Saulabs::Reportable::ReportCache.stub!(:all).and_return(Array.new(@report.options[:limit] - 1, Saulabs::Reportable::ReportCache.new), cached)
+        Saulabs::Reportable::ReportCache.stub!(:read_cached_data).and_return(Array.new(@report.options[:limit] - 1, Saulabs::Reportable::ReportCache.new), cached)
 
         Saulabs::Reportable::ReportCache.process(@report, @options) do |begin_at, end_at|
           begin_at.should == reporting_period.date_time
@@ -170,7 +153,7 @@ describe Saulabs::Reportable::ReportCache do
     describe 'with :live_data = false' do
 
       it 'should not yield if all required data could be retrieved from the cache' do
-        Saulabs::Reportable::ReportCache.stub!(:all).and_return(Array.new(@report.options[:limit], Saulabs::Reportable::ReportCache.new))
+        Saulabs::Reportable::ReportCache.stub!(:read_cached_data).and_return(Array.new(@report.options[:limit], Saulabs::Reportable::ReportCache.new))
 
         lambda {
           Saulabs::Reportable::ReportCache.process(@report, @report.options) { raise YieldMatchException.new }
@@ -178,7 +161,7 @@ describe Saulabs::Reportable::ReportCache do
       end
 
       it 'should yield to the block if no data could be retrieved from the cache' do
-        Saulabs::Reportable::ReportCache.stub!(:all).and_return([])
+        Saulabs::Reportable::ReportCache.stub!(:read_cached_data).and_return([])
 
         lambda {
           Saulabs::Reportable::ReportCache.process(@report, @report.options) { raise YieldMatchException.new }
@@ -188,7 +171,7 @@ describe Saulabs::Reportable::ReportCache do
       describe 'with :end_date = <some date>' do
 
         before do
-          @options = @report.options.merge(:end_date => Time.now)
+          @options = @report.options.merge(:end_date => Time.now - 1.send(@report.options[:grouping].identifier))
         end
 
         it 'should yield the last date and time of the reporting period for the specified end date' do
@@ -204,7 +187,7 @@ describe Saulabs::Reportable::ReportCache do
 
     end
 
-    it 'should read existing data from the cache' do
+    xit 'should read existing data from the cache' do
       Saulabs::Reportable::ReportCache.should_receive(:all).once.with(
         :conditions => [
           %w(model_name report_name grouping aggregation conditions).map do |column_name|
@@ -224,8 +207,8 @@ describe Saulabs::Reportable::ReportCache do
       Saulabs::Reportable::ReportCache.process(@report, @report.options) { [] }
     end
 
-    it 'should utilize the end_date in the conditions' do
-      end_date = Time.now
+    xit 'should utilize the end_date in the conditions' do
+      end_date = Time.now - 1.send(@report.options[:grouping].identifier)
       Saulabs::Reportable::ReportCache.should_receive(:all).once.with(
         :conditions => [
           %w(model_name report_name grouping aggregation conditions).map do |column_name|
@@ -236,7 +219,7 @@ describe Saulabs::Reportable::ReportCache do
           @report.options[:grouping].identifier.to_s,
           @report.aggregation.to_s,
           '',
-          Saulabs::Reportable::ReportingPeriod.first(@report.options[:grouping], 9).date_time,
+          Saulabs::Reportable::ReportingPeriod.first(@report.options[:grouping], 10).date_time,
           Saulabs::Reportable::ReportingPeriod.new(@report.options[:grouping], end_date).date_time
         ],
         :limit => 10,
@@ -246,7 +229,7 @@ describe Saulabs::Reportable::ReportCache do
       Saulabs::Reportable::ReportCache.process(@report, @report.options.merge(:end_date => end_date)) { [] }
     end
 
-    it "should read existing data from the cache for the correct grouping if one other than the report's default grouping is specified" do
+    xit "should read existing data from the cache for the correct grouping if one other than the report's default grouping is specified" do
       grouping = Saulabs::Reportable::Grouping.new(:month)
       Saulabs::Reportable::ReportCache.should_receive(:all).once.with(
         :conditions => [
@@ -275,7 +258,15 @@ describe Saulabs::Reportable::ReportCache do
       end
     end
   end
-  
+
+  describe '.get_first_reporting_period_to_read' do
+    it 'returns first reporting period if no cached data' do
+      Saulabs::Reportable::ReportCache.should_receive(:get_first_reporting_period).once.and_return('first')
+      result = Saulabs::Reportable::ReportCache.send(:get_first_reporting_period_to_read, [], {})
+      result.should == 'first'
+    end
+  end
+
   describe '.serialize_conditions' do
     
     it 'should serialize empty conditions correctly' do

data/spec/classes/report_spec.rb

@@ -21,7 +21,7 @@ describe Saulabs::Reportable::Report do
     it 'should process the data with the report cache' do
       Saulabs::Reportable::ReportCache.should_receive(:process).once.with(
         @report,
-        { :limit => 100, :grouping => @report.options[:grouping], :conditions => [], :live_data => false, :end_date => false }
+        { :limit => 100, :grouping => @report.options[:grouping], :conditions => [], :include => [], :live_data => false, :end_date => false, :distinct => false }
       )
 
       @report.run
@@ -30,7 +30,7 @@ describe Saulabs::Reportable::Report do
     it 'should process the data with the report cache when custom conditions are given' do
       Saulabs::Reportable::ReportCache.should_receive(:process).once.with(
         @report,
-        { :limit => 100, :grouping => @report.options[:grouping], :conditions => { :some => :condition }, :live_data => false, :end_date => false }
+        { :limit => 100, :grouping => @report.options[:grouping], :conditions => { :some => :condition }, :include => [], :live_data => false, :end_date => false, :distinct => false }
       )
 
       @report.run(:conditions => { :some => :condition })
@@ -47,7 +47,7 @@ describe Saulabs::Reportable::Report do
       Saulabs::Reportable::Grouping.should_receive(:new).once.with(:month).and_return(grouping)
       Saulabs::Reportable::ReportCache.should_receive(:process).once.with(
         @report,
-        { :limit => 100, :grouping => grouping, :conditions => [], :live_data => false, :end_date => false }
+        { :limit => 100, :grouping => grouping, :conditions => [], :live_data => false, :end_date => false, :distinct => false, :include => [] }
       )
 
       @report.run(:grouping => :month)
@@ -65,15 +65,152 @@ describe Saulabs::Reportable::Report do
       @report.run.to_a.length.should == 11
     end
 
-    for grouping in [:hour, :day, :week, :month] do
+    %w(hour day week month).each do |grouping|
+      grouping = grouping.to_sym
 
       describe "for grouping :#{grouping.to_s}" do
 
         before(:all) do
-          User.create!(:login => 'test 1', :created_at => Time.now,                    :profile_visits => 2)
-          User.create!(:login => 'test 2', :created_at => Time.now - 1.send(grouping), :profile_visits => 1)
-          User.create!(:login => 'test 3', :created_at => Time.now - 3.send(grouping), :profile_visits => 2)
-          User.create!(:login => 'test 4', :created_at => Time.now - 3.send(grouping), :profile_visits => 3)
+          User.create!(:login => 'test 1', :created_at => Time.now,                    :profile_visits => 2, :sub_type => "red")
+          User.create!(:login => 'test 2', :created_at => Time.now - 1.send(grouping), :profile_visits => 1, :sub_type => "red")
+          User.create!(:login => 'test 3', :created_at => Time.now - 3.send(grouping), :profile_visits => 2, :sub_type => "blue")
+          User.create!(:login => 'test 4', :created_at => Time.now - 3.send(grouping), :profile_visits => 3, :sub_type => "blue")
+        end
+
+        describe 'optimized querying with contiguously cached data' do
+          it "should be optimized with specified end_date" do
+            @end_date = DateTime.now - 1.send(grouping)
+            @report = Saulabs::Reportable::Report.new(User, :registrations,
+              :grouping => grouping,
+              :limit    => 10,
+              :end_date => @end_date
+            )
+            @result = @report.run
+
+            Saulabs::Reportable::ReportCache.last.delete
+
+            grouping_instance = Saulabs::Reportable::Grouping.new(grouping)
+            reporting_period = Saulabs::Reportable::ReportingPeriod.new(grouping_instance, @end_date)
+
+            @report.should_receive(:read_data) do |begin_at, end_at, options|
+              begin_at.should == reporting_period.date_time
+              end_at.should == reporting_period.last_date_time
+              [] # without this rspec whines about an ambiguous return value
+            end
+
+            @result = @report.run
+          end
+
+          it "should be optimized without specific end_date and live_data" do
+            @report = Saulabs::Reportable::Report.new(User, :registrations,
+              :grouping => grouping,
+              :limit    => 10,
+              :live_data => true
+            )
+            @result = @report.run.to_a
+
+            Saulabs::Reportable::ReportCache.last.delete
+
+            grouping_instance = Saulabs::Reportable::Grouping.new(grouping)
+            reporting_period = Saulabs::Reportable::ReportingPeriod.new(grouping_instance, DateTime.now).previous
+
+            @report.should_receive(:read_data) do |begin_at, end_at, options|
+              begin_at.should == reporting_period.date_time
+              end_at.should == nil
+              [] # without this rspec whines about an ambiguous return value
+            end
+
+            @result = @report.run
+          end
+
+          it "should be optimized without specific end_date and without live_data requested" do
+            @report = Saulabs::Reportable::Report.new(User, :registrations,
+              :grouping => grouping,
+              :limit    => 10
+            )
+            @result = @report.run.to_a
+
+            Saulabs::Reportable::ReportCache.last.delete
+
+            grouping_instance = Saulabs::Reportable::Grouping.new(grouping)
+            reporting_period = Saulabs::Reportable::ReportingPeriod.new(grouping_instance, DateTime.now).previous
+
+            @report.should_receive(:read_data) do |begin_at, end_at, options|
+              begin_at.should == reporting_period.date_time
+              end_at.should == nil
+              [] # without this rspec whines about an ambiguous return value
+            end
+
+            @result = @report.run
+          end
+        end
+
+        describe 'non optimized querying when gaps present in cached data' do
+          it "should not be optimized with specified end_date" do
+            @end_date = DateTime.now - 1.send(grouping)
+            @report = Saulabs::Reportable::Report.new(User, :registrations,
+              :grouping => grouping,
+              :limit    => 10,
+              :end_date => @end_date
+            )
+            @result = @report.run
+
+            Saulabs::Reportable::ReportCache.first.delete
+
+            grouping_instance = Saulabs::Reportable::Grouping.new(grouping)
+            reporting_period = Saulabs::Reportable::ReportingPeriod.new(grouping_instance, @end_date)
+
+            @report.should_receive(:read_data) do |begin_at, end_at, options|
+              begin_at.should == reporting_period.offset(-9).date_time
+              end_at.should == reporting_period.last_date_time
+              [] # without this rspec whines about an ambiguous return value
+            end
+
+            @result = @report.run
+          end
+
+          it "should not be optimized without specific end_date and live_data" do
+            @report = Saulabs::Reportable::Report.new(User, :registrations,
+              :grouping => grouping,
+              :limit    => 10,
+              :live_data => true
+            )
+            @result = @report.run.to_a
+
+            Saulabs::Reportable::ReportCache.first.delete
+
+            grouping_instance = Saulabs::Reportable::Grouping.new(grouping)
+            reporting_period = Saulabs::Reportable::ReportingPeriod.new(grouping_instance, DateTime.now).previous
+
+            @report.should_receive(:read_data) do |begin_at, end_at, options|
+              begin_at.should == reporting_period.offset(-9).date_time
+              end_at.should == nil
+              [] # without this rspec whines about an ambiguous return value
+            end
+
+            @result = @report.run
+          end
+
+          it "should not be optimized without specific end_date and without live_data requested" do
+            @report = Saulabs::Reportable::Report.new(User, :registrations,
+              :grouping => grouping,
+              :limit    => 10
+            )
+            @result = @report.run.to_a
+
+            Saulabs::Reportable::ReportCache.first.delete
+
+            grouping_instance = Saulabs::Reportable::Grouping.new(grouping)
+            reporting_period = Saulabs::Reportable::ReportingPeriod.new(grouping_instance, DateTime.now).previous
+
+            @report.should_receive(:read_data) do |begin_at, end_at, options|
+              begin_at.should == reporting_period.offset(-9).date_time
+              end_at.should == nil
+              [] # without this rspec whines about an ambiguous return value
+            end
+
+            @result = @report.run
+          end
         end
 
         describe 'when :end_date is specified' do
@@ -162,6 +299,24 @@ describe Saulabs::Reportable::Report do
               result[6][1].should  == 0.0
             end
 
+            it 'should return correct data for aggregation :count with distinct: true' do
+              @report = Saulabs::Reportable::Report.new(User, :registrations,
+                :aggregation => :count,
+                :grouping    => grouping,
+                :value_column => :sub_type,
+                :distinct    => true,
+                :limit       => 10,
+                :live_data   => live_data
+              )
+              result = @report.run.to_a
+
+              result[10][1].should == 1.0 if live_data
+              result[9][1].should  == 1.0
+              result[8][1].should  == 0.0
+              result[7][1].should  == 1.0
+              result[6][1].should  == 0.0
+            end
+
             it 'should return correct data for aggregation :sum' do
               @report = Saulabs::Reportable::Report.new(User, :registrations,
                 :aggregation  => :sum,
@@ -426,7 +581,7 @@ describe Saulabs::Reportable::Report do
 
   describe '#read_data' do
 
-    it 'should invoke the aggregation method on the model' do
+    xit 'should invoke the aggregation method on the model' do
       @report = Saulabs::Reportable::Report.new(User, :registrations, :aggregation => :count)
       User.should_receive(:count).once.and_return([])
 

data/spec/db/schema.rb

@@ -4,6 +4,7 @@ ActiveRecord::Schema.define(:version => 1) do
     t.string  :login,          :null => false
     t.integer :profile_visits, :null => false, :default => 0
     t.string  :type,           :null => false, :default => 'User'
+    t.string  :sub_type
 
     t.timestamps
   end

data/spec/spec_helper.rb

@@ -27,8 +27,14 @@ require File.join(ROOT, 'lib', 'saulabs', 'reportable.rb')
 #   config.time_zone = 'Pacific Time (US & Canada)'
 # end
 
-FileUtils.mkdir_p File.join(File.dirname(__FILE__), 'log')
-ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(File.dirname(__FILE__) + "/log/spec.log")
+# FileUtils.mkdir_p File.join(File.dirname(__FILE__), 'log')
+# ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(File.dirname(__FILE__) + "/log/spec.log")
+
+RSpec.configure do |config|
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end
+ActiveRecord::Base.default_timezone = :local
 
 databases = YAML::load(IO.read(File.join(File.dirname(__FILE__), 'db', 'database.yml')))
 ActiveRecord::Base.establish_connection(databases[ENV['DB'] || 'sqlite3'])

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reportable
 version: !ruby/object:Gem::Version
-  version: 1.2.0
-  prerelease: 
+  version: 1.3.0
 platform: ruby
 authors:
 - Marco Otte-Witte
@@ -14,26 +13,32 @@ date: 2012-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70168900389180 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70168900389180
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70168900388200 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70168900388200
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 description: Reportable allows for easy report generation from ActiveRecord models
   by the addition of the reportable method.
 email: reportable@saulabs.com
@@ -41,21 +46,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- README.md
 - HISTORY.md
-- Rakefile
 - MIT-LICENSE
+- README.md
+- Rakefile
 - generators/reportable_jquery_flot_assets/reportable_jquery_flot_assets_generator.rb
+- generators/reportable_jquery_flot_assets/templates/NOTES
 - generators/reportable_jquery_flot_assets/templates/excanvas.min.js
 - generators/reportable_jquery_flot_assets/templates/jquery.flot.min.js
-- generators/reportable_jquery_flot_assets/templates/NOTES
 - generators/reportable_migration/reportable_migration_generator.rb
 - generators/reportable_migration/templates/migration.rb
 - generators/reportable_raphael_assets/reportable_raphael_assets_generator.rb
+- generators/reportable_raphael_assets/templates/NOTES
 - generators/reportable_raphael_assets/templates/g.line.min.js
 - generators/reportable_raphael_assets/templates/g.raphael.min.js
-- generators/reportable_raphael_assets/templates/NOTES
 - generators/reportable_raphael_assets/templates/raphael.min.js
+- lib/saulabs/reportable.rb
 - lib/saulabs/reportable/config.rb
 - lib/saulabs/reportable/cumulated_report.rb
 - lib/saulabs/reportable/grouping.rb
@@ -65,41 +71,39 @@ files:
 - lib/saulabs/reportable/report_tag_helper.rb
 - lib/saulabs/reportable/reporting_period.rb
 - lib/saulabs/reportable/result_set.rb
-- lib/saulabs/reportable.rb
 - spec/classes/cumulated_report_spec.rb
 - spec/classes/grouping_spec.rb
 - spec/classes/report_cache_spec.rb
 - spec/classes/report_spec.rb
 - spec/classes/reporting_period_spec.rb
+- spec/db/database.yml
 - spec/db/schema.rb
 - spec/other/report_method_spec.rb
 - spec/other/report_tag_helper_spec.rb
-- spec/spec_helper.rb
-- spec/db/database.yml
 - spec/spec.opts
+- spec/spec_helper.rb
 homepage: http://github.com/saulabs/reportable
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Easy report generation for Ruby on Rails
 test_files: []
 has_rdoc: false