ar_aggregate_by_interval 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4beebc54e103e64f0d2ea5b3dc8947a033b4a217
-  data.tar.gz: d3f4008258eba648f009f37006d16b44d31475b6
+  metadata.gz: d67fb1f746590e8801a28802ab2fd1aba5175f11
+  data.tar.gz: c5618c06679af82e4d078ed02ddc150040cad40f
 SHA512:
-  metadata.gz: 5812bb1f2cbd9e838940e9e119db08126f244166d760796370b100e6913245b8665d3d4d3c6e4ca7a2f9fb5d7b8b37d1a7390dd1e345fde36d8a27b901f915d1
-  data.tar.gz: ccbb37c325b454a1fe4759a4f392fa8657054095fc13e2a3bd2eddc4b0307d351617b1243a4d07139efc8e4068334da1cea25a97c7ae208bcf7243f4a4f2d43e
+  metadata.gz: ccdd2612b245ebac746c3e5bb3756a8a021488de55325b5a378fe868ed08c5f1f1987bfd67612257c281d9d5f13cd8997de764fe9c1f00d9f3572037ab0945d0
+  data.tar.gz: 9ccfddcab1829beec3c274ca62bea99f886ef6e9750a3a729d9353cd45e1ca30c588af7212e70fe3bd371ed82098c3b1154e2af7606743f1c1230eb5c73cd3f4

data/CHANGELOG.md

@@ -3,6 +3,12 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 This file adheres to [Keep a changelog](http://keepachangelog.com/).
 
+## [1.1.4] - 2015-03-08 (maintenance)
+### Changed
+- Moved functionality from constructors to methods
+- Build hash from `select_rows` instead of AR objects (performance, simplicity)
+- Driver of functionality now in method_missing (decoupling)
+
 ## [1.1.3] - 2015-03-02
 ### Fixed
 - Fix Postgres queries due to AR injecting order clause

data/lib/ar_aggregate_by_interval.rb

@@ -30,11 +30,24 @@ module ArAggregateByInterval
       hash_args[col] = hash_args[col].intern if hash_args[col]
     end
 
-    QueryRunner.new(self, {
+    # build query object
+    query_runner = QueryRunner.new(self, {
       aggregate_function: aggregate_function,
       interval: interval
     }.merge(hash_args))
 
+    # actually run SQL and return a hash of dates => vals
+    date_values_hash = query_runner.run_query
+
+    # takes hash and fills in missing dates
+    # this QueryResult object has 2 attributes: values_and_dates, values
+    QueryResult.new({
+      date_values_hash: date_values_hash,
+      from: query_runner.from,
+      to: query_runner.to,
+      interval: query_runner.interval
+    })
+
   end
 
 end

data/lib/ar_aggregate_by_interval/query_result.rb

@@ -9,10 +9,10 @@ module ArAggregateByInterval
   class QueryResult
 
     VALID_HASH_ARGS = {
-      ar_result: -> (v) { v.respond_to?(:to_a) },
+      date_values_hash: [Hash],
 
-      # hash with 1 key where the key is a date column and value is the column being aggegated
-      ar_result_select_col_mapping: -> (v) { v.is_a?(Hash) && v.size == 1 },
+      # # hash with 1 key where the key is a date column and value is the column being aggegated
+      # ar_result_select_col_mapping: -> (v) { v.is_a?(Hash) && v.size == 1 },
 
       from: [Date, DateTime, Time, ActiveSupport::TimeWithZone],
       to: [Date, DateTime, Time, ActiveSupport::TimeWithZone],
@@ -20,17 +20,18 @@ module ArAggregateByInterval
       interval: -> (v) { Utils.ruby_strftime_map.keys.include?(v) }
     }
 
-    def initialize(args)
-      validate_args!(args)
+    def initialize(hash_args)
+      ClassyHash.validate(hash_args, VALID_HASH_ARGS)
 
-      @dates_values_hash = Utils.ar_to_hash(args[:ar_result], args[:ar_result_select_col_mapping])
-      @date_iterator_method = Utils::DATE_ITERATOR_METHOD_MAP[args[:interval]]
+      # @dates_values_hash = Utils.ar_to_hash(args[:ar_result], args[:ar_result_select_col_mapping])
+      @dates_values_hash = hash_args[:date_values_hash]
+      @date_iterator_method = Utils::DATE_ITERATOR_METHOD_MAP[hash_args[:interval]]
 
       # strformat to match the format out of the database
-      @strftime_format = Utils.ruby_strftime_map[args[:interval]]
+      @strftime_format = Utils.ruby_strftime_map[hash_args[:interval]]
 
-      @from = args[:from]
-      @to = args[:to]
+      @from = hash_args[:from]
+      @to = hash_args[:to]
     end
 
     def values_and_dates
@@ -42,16 +43,20 @@ module ArAggregateByInterval
       end
     end
 
+    def values
+      @values ||= values_and_dates.collect { |hash| hash[:value] }
+    end
+
     private
 
-    def validate_args!(hash_args)
-      ClassyHash.validate(hash_args, VALID_HASH_ARGS)
-      first_res = hash_args[:ar_result].first
-      keys = hash_args[:ar_result_select_col_mapping].to_a.flatten
-      if first_res && keys.any? { |key| !first_res.respond_to?(key) }
-        raise RuntimeError.new("the collection passed does not respond to all attribs: #{keys}")
-      end
-    end
+    # def validate_args!(hash_args)
+    #   ClassyHash.validate(hash_args, VALID_HASH_ARGS)
+    #   first_res = hash_args[:ar_result].first
+    #   keys = hash_args[:ar_result_select_col_mapping].to_a.flatten
+    #   if first_res && keys.any? { |key| !first_res.respond_to?(key) }
+    #     raise RuntimeError.new("the collection passed does not respond to all attribs: #{keys}")
+    #   end
+    # end
 
     def array_of_dates
       @array_of_dates ||= @from.to_date.send(@date_iterator_method, @to.to_date).map do |date|

data/lib/ar_aggregate_by_interval/query_runner.rb

@@ -19,41 +19,58 @@ module ArAggregateByInterval
       aggregate_column: [:optional, Symbol, NilClass] # required when using sum (as opposed to count)
     }
 
-    attr_reader :values, :values_and_dates
+    attr_reader :values, :values_and_dates, :from, :to, :interval
 
     def initialize(ar_model, hash_args)
 
       validate_args!(hash_args)
 
-      from = normalize_from(hash_args[:from], hash_args[:interval])
-      to = normalize_to(hash_args[:to] || Time.zone.try(:now) || Time.now, hash_args[:interval])
+      @ar_model = ar_model
 
-      db_vendor_select_for_date_function =
+      @from = normalize_from(hash_args[:from], hash_args[:interval])
+      @to = normalize_to(hash_args[:to] || Time.zone.try(:now) || Time.now, hash_args[:interval])
+
+      @db_vendor_select =
         Utils.select_for_grouping_column(hash_args[:group_by_column])[hash_args[:interval]]
 
-      ar_result = ar_model.
-        select("#{hash_args[:aggregate_function]}(#{hash_args[:aggregate_column] || '*'}) as totalchunked__").
-        select("#{db_vendor_select_for_date_function} as datechunk__").
-        group('datechunk__').
-        where(["#{hash_args[:group_by_column]} >= ? and #{hash_args[:group_by_column]} <= ?", from, to]).
-        order(nil)
-
-      # fill the gaps of the sql results
-      agg_int = QueryResult.new({
-        ar_result: ar_result,
-        ar_result_select_col_mapping: {'datechunk__' => 'totalchunked__'},
-        from: from,
-        to: to,
-        interval: hash_args[:interval]
-      })
-
-      @values_and_dates = agg_int.values_and_dates
-      @values = @values_and_dates.collect { |hash| hash[:value] }
+      @aggregate_function = hash_args[:aggregate_function]
+      @aggregate_column = hash_args[:aggregate_column]
+      @group_by_column = hash_args[:group_by_column]
+
+      @interval = hash_args[:interval]
+    end
+
+    def run_query
+      # actually run query
+      array_of_pairs = ActiveRecord::Base.connection.select_rows(to_sql)
+
+      # workaround ActiveRecord's automatic casting to Date objects
+      # (ideally we could return raw values straight from ActiveRecord to avoid this expensive N)
+      array_of_pairs.collect! do |date_val_pair|
+        date_val_pair.collect(&:to_s)
+      end
 
+      # convert the array of key/values to a hash
+      Hash[array_of_pairs]
     end
 
     private
 
+    def to_sql
+      # first col is date, second col is actual value
+      query = @ar_model.
+        select("#{@db_vendor_select} as datechunk__").
+        select("#{@aggregate_function}(#{@aggregate_column || '*'}) as totalchunked__").
+        where(["#{@group_by_column} >= ? and #{@group_by_column} <= ?", @from, @to]).
+        group('datechunk__')
+
+      # workaround Postgres adapter's insistence of adding an order clause
+      query = query.order(nil)
+
+      # an string of the query to run
+      query.to_sql
+    end
+
     def validate_args!(hash_args)
       ClassyHash.validate(hash_args, VALID_HASH_ARGS)
       if hash_args[:aggregate_function] != 'count' && hash_args[:aggregate_column].blank?

data/lib/ar_aggregate_by_interval/version.rb

@@ -1,3 +1,3 @@
 module ArAggregateByInterval
-  VERSION = '1.1.3'
+  VERSION = '1.1.4'
 end

data/spec/lib/ar_aggregate_by_interval/utils_spec.rb

@@ -5,47 +5,41 @@ module ArAggregateByInterval
 
   describe Utils do
 
-    context 'converting ar to hash' do
+    describe 'interval_inflector' do
 
-      subject do
-        described_class.ar_to_hash(ar_objs, mapping)
+      shared_examples 'working inflector' do |int, beg_end, expected|
+        it "works for #{beg_end}_#{int}" do
+          expect(described_class.interval_inflector(int, beg_end)).to eq expected
+        end
       end
 
-      context 'normal values' do
-        let(:ar_objs) do
-          [
-            OpenStruct.new({
-              date_chunk__: '2014-01-01',
-              value: 5
-            })
-          ]
-        end
+      include_examples 'working inflector', 'daily', 'beginning', 'beginning_of_day'
+      include_examples 'working inflector', 'daily', 'end', 'end_of_day'
 
-        let(:mapping) { { 'date_chunk__' => 'value' } }
+      include_examples 'working inflector', 'weekly', 'beginning', 'beginning_of_week'
+      include_examples 'working inflector', 'weekly', 'end', 'end_of_week'
 
-        it 'works' do
-          expect(subject).to eq({ '2014-01-01' => 5 })
-        end
-      end
+      include_examples 'working inflector', 'monthly', 'beginning', 'beginning_of_month'
+      include_examples 'working inflector', 'monthly', 'end', 'end_of_month'
 
-      context 'arbitrary values' do
-        let(:ar_objs) do
-          [
-            OpenStruct.new({
-              id: OpenStruct.new({}),
-              something: 1
-            })
-          ]
-        end
-        let(:mapping) { { 'id' => 'something' } }
+    end
+
+    describe 'to_f_or_i_or_s' do
 
-        it 'does not cast or change any objects' do
-          expect(subject.keys.first).to be_a(OpenStruct)
-          expect(subject.values.first).to be_a(Integer)
+      shared_examples 'working Numeric converter' do |arg1, expected_class|
+        it "works for #{arg1.class.name} to #{expected_class.name}" do
+          expect(described_class.to_f_or_i_or_s(arg1)).to be_instance_of(expected_class)
         end
       end
 
+      include_examples 'working Numeric converter', '1.1', Float
+      include_examples 'working Numeric converter', 1.1, Float
+      include_examples 'working Numeric converter', '1.0', Fixnum
+      include_examples 'working Numeric converter', 1.0, Fixnum
+      include_examples 'working Numeric converter', 1, Fixnum
+
     end
+
   end
 
-end
+end

data/spec/lib/ar_aggregate_by_interval_spec.rb

@@ -5,25 +5,27 @@ describe ArAggregateByInterval do
   before(:all) do |example|
     @from = DateTime.parse '2013-08-05'
     @to = @from
-    blog = Blog.create arbitrary_number: 10, created_at: @from
-    blog.page_views.create date: @from
+    blog1 = Blog.create arbitrary_number: 10, created_at: @from
+    blog2 = Blog.create arbitrary_number: 20, created_at: @from
+    blog1.page_views.create date: @from
+    blog1.page_views.create date: @from
   end
 
   shared_examples_for 'count .values_and_dates' do
     it 'returns value and date with expected values' do
-      expect(subject.values_and_dates).to eq([date: @from.beginning_of_week.to_date, value: 1])
+      expect(subject.values_and_dates).to eq([date: @from.beginning_of_week.to_date, value: 2])
     end
   end
 
   shared_examples_for 'sum .values_and_dates' do
     it 'returns value and date with expected values' do
-      expect(subject.values_and_dates).to eq([date: @from.beginning_of_week.to_date, value: 10])
+      expect(subject.values_and_dates).to eq([date: @from.beginning_of_week.to_date, value: 30])
     end
   end
 
   shared_examples_for 'avg .values_and_dates' do
     it 'returns value and date with expected values' do
-      expect(subject.values_and_dates).to eq([date: @from.beginning_of_week.to_date, value: 10])
+      expect(subject.values_and_dates).to eq([date: @from.beginning_of_week.to_date, value: 15])
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_aggregate_by_interval
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - Jonathan Otto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-03 00:00:00.000000000 Z
+date: 2015-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -161,7 +161,6 @@ files:
 - lib/ar_aggregate_by_interval/version.rb
 - spec/ar_bootstrap/init.rb
 - spec/ar_bootstrap/schema.rb
-- spec/lib/ar_aggregate_by_interval/query_runner_spec.rb
 - spec/lib/ar_aggregate_by_interval/utils_spec.rb
 - spec/lib/ar_aggregate_by_interval_spec.rb
 - spec/spec_helper.rb
@@ -191,7 +190,6 @@ summary: add [sum|count]_[daily|weekly|monthly] to your AR models for MySQL AND
 test_files:
 - spec/ar_bootstrap/init.rb
 - spec/ar_bootstrap/schema.rb
-- spec/lib/ar_aggregate_by_interval/query_runner_spec.rb
 - spec/lib/ar_aggregate_by_interval/utils_spec.rb
 - spec/lib/ar_aggregate_by_interval_spec.rb
 - spec/spec_helper.rb

data/spec/lib/ar_aggregate_by_interval/query_runner_spec.rb

@@ -1,66 +0,0 @@
-require 'ar_aggregate_by_interval/query_runner'
-
-module ArAggregateByInterval
-  describe QueryRunner do
-
-    subject do
-      described_class.new(Blog, {
-        aggregate_function: aggregate_function,
-        aggregate_column: (aggregate_column rescue nil),
-        interval: interval,
-        group_by_column: :created_at,
-        from: from,
-        to: to
-      })
-    end
-
-    context 'one week duration' do
-
-      # monday
-      let(:from) { DateTime.parse '2013-08-05' }
-      # sunday
-      let(:to) { DateTime.parse '2013-08-11' }
-
-      before do |example|
-        Blog.create [
-          {arbitrary_number: 10, created_at: from},
-          {arbitrary_number: 20, created_at: from}
-        ]
-      end
-
-      context 'avg daily' do
-        let(:interval) { 'daily' }
-        let(:aggregate_function) { 'avg' }
-        let(:aggregate_column) { :arbitrary_number }
-
-        describe '.values' do
-          it 'returns an array of size 7' do
-            expect(subject.values.size).to eq 7
-          end
-          it 'returns actual averages' do
-            expect(subject.values).to eq([15, 0, 0, 0, 0, 0, 0])
-          end
-        end
-      end
-
-      context 'count weekly' do
-        let(:interval) { 'weekly' }
-        let(:aggregate_function) { 'count' }
-
-        describe '.values' do
-          it 'returns exactly 1 element array with 1' do
-            expect(subject.values).to eq([2])
-          end
-        end
-
-        describe '.value_and_dates' do
-          it 'returns value and date with expected values' do
-            expect(subject.values_and_dates).to eq([date: from.beginning_of_week.to_date, value: 2])
-          end
-        end
-      end
-
-    end
-  end
-
-end