ar_aggregate_by_interval 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0941adcd198c82ec6bdd4d87187e6403f6738f6a
+  data.tar.gz: eb241530407ea9d26228d8637bdcdcfe3d07c477
+SHA512:
+  metadata.gz: d29b854bc1a7265a68bfdee328618b7bef4cf550869536c10d065560a6ff6129bbd8b98d8f91fe4abcb254ac6942f11d84f953e807e5829c0c95577929d3f489
+  data.tar.gz: d5376e25140ee0d4d79d7b3614a4582ab8d80bca67a39850a648fd4e4e5e88049f81423cc6083935536baeca8777a07cfce10dc4354074d9be23cef748eb93b2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Guardfile

@@ -0,0 +1,77 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec feature)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), the you will want to move the Guardfile
+## to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jonathan Otto
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+# ArAggregateByInterval
+---
+Build arrays of counts, sums and averages from Ruby on Rails ActiveRecord models grouped by days, weeks or months. e.g.:
+```ruby
+# default 'group by' is 'created_at'
+Blog.count_weekly(1.month.ago).values
+=> [4, 2, 2, 0]
+```
+
+## Why?
+1. to simplify "group by" SQL queries when weeks or months are involved
+2. to fill in 0's for days/weeks/months where database has no data
+
+## Usage
+```ruby
+ActiveRecordModel.{sum,count,avg}_{daily,weekly,monthly}(arg_hash).{values,values_and_dates}
+```
+
+```ruby
+#values //(returns an array of numerics)
+=> [4, 2, 15, 0, 10]
+```
+```ruby
+#values_and_dates //(returns an array of hashes)
+=> [{date: DateObject, value: 0}, {date: DateObject, value: 5}]
+```
+## Examples
+#### Total blog posts created weekly
+```ruby
+Blog.count_weekly({
+  group_by_column: :created_at,
+  from: 6.months.ago,
+  to: Time.zone.now
+}).values
+```
+
+#### Total calories burned per week
+```ruby
+Exercise.sum_weekly({
+  group_by_column: :created_at,
+  aggregate_column: :calories,
+  from: 6.months.ago,
+  to: Time.zone.now
+}).values
+```
+
+#### Weekly revenue since beginning of year (with dates)
+```ruby
+Billing.sum_weekly({
+  group_by_column: :transacted_at,
+  aggregate_column: :cents, # necessary when using sum as opposed to count
+  from: Time.zone.now.beginning_of_year,
+  to: Time.zone.now
+}).values_and_dates
+```

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => :spec
+rescue LoadError
+end

data/ar_aggregate_counter.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ar_aggregate_by_interval/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'ar_aggregate_by_interval'
+  s.version     = ArAggregateByInterval::VERSION
+  s.authors     = ['Jonathan Otto']
+  s.email       = ['jonathan.otto@gmail.com']
+  s.homepage    = 'https://github.com/jotto/ar_aggregate_by_interval'
+  s.summary     = 'add [sum|count]_[daily|weekly|monthly] to your AR models for MySQL AND Postgres'
+  s.description = 'add [sum|count]_[daily|weekly|monthly] to your AR models for MySQL AND Postgres'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'bundler', '~> 1.5'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'database_cleaner', '~> 1.4'
+  s.add_development_dependency 'guard-rspec', '~> 4.5'
+  s.add_development_dependency 'sqlite3'
+  s.add_dependency 'activesupport', '~> 4.0'
+  s.add_dependency 'activerecord', '~> 4.0'
+  s.add_dependency 'classy_hash', '~> 0.1'
+  s.add_dependency 'date_iterator', '~> 1.0'
+
+end

data/lib/ar_aggregate_by_interval.rb

@@ -0,0 +1,39 @@
+require 'ar_aggregate_by_interval/query_runner'
+require 'ar_aggregate_by_interval/utils'
+
+# POSTGRES AND MYSQL COMPATIBLE
+# ActiveRecordModel.[sum|count]_[daily|weekly|monthly]
+# examples:
+
+module ArAggregateByInterval
+
+  def method_missing(method_name, *args)
+    supported_methods_rgx = /\A(count|sum|avg)_(daily|weekly|monthly)\z/
+
+    aggregate_function, interval = method_name.to_s.scan(supported_methods_rgx).flatten
+
+    return super unless aggregate_function && interval
+
+    hash_args = if args.size == 1 && args.first.is_a?(Hash)
+      args.first
+    elsif args.size > 1 && !args.any?{ |a| a.is_a?(Hash) }
+      Utils.args_to_hash(aggregate_function, interval, *args)
+    else
+      nil
+    end
+
+    return super unless hash_args
+
+    QueryRunner.new(self, {
+      aggregate_function: aggregate_function,
+      interval: interval
+    }.merge(hash_args))
+
+  end
+
+end
+
+# for queries on the class
+ActiveRecord::Base.send :extend, ArAggregateByInterval
+# for scoped queries
+ActiveRecord::Relation.send :include, ArAggregateByInterval

data/lib/ar_aggregate_by_interval/query_result.rb

@@ -0,0 +1,55 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'classy_hash'
+require 'date_iterator'
+require 'ar_aggregate_by_interval/utils'
+
+module ArAggregateByInterval
+
+  class QueryResult
+
+    VALID_HASH_ARGS = {
+      ar_result: -> (v) { v.class.name == 'ActiveRecord::Relation' },
+
+      # 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],
+
+      interval: -> (v) { Utils.ruby_strftime_map.keys.include?(v) }
+    }
+
+    def initialize(args)
+      ClassyHash.validate(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]]
+
+      # strformat to match the format out of the database
+      @strftime_format = Utils.ruby_strftime_map[args[:interval]]
+
+      @from = args[:from]
+      @to = args[:to]
+    end
+
+    def values_and_dates
+      @values_and_dates ||= array_of_dates.collect do |date, formatted_date|
+        {
+          date: date,
+          value: Utils.to_f_or_i_or_s(@dates_values_hash[formatted_date] || 0)
+        }
+      end
+    end
+
+    private
+
+    def array_of_dates
+      @array_of_dates ||= @from.to_date.send(@date_iterator_method, @to.to_date).map do |date|
+        [date, date.strftime(@strftime_format)]
+      end
+    end
+
+  end
+
+end

data/lib/ar_aggregate_by_interval/query_runner.rb

@@ -0,0 +1,79 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'classy_hash'
+require 'ar_aggregate_by_interval/utils'
+require 'ar_aggregate_by_interval/query_result'
+
+module ArAggregateByInterval
+
+  class QueryRunner
+
+    VALID_HASH_ARGS = {
+      aggregate_function: [String], # sum, count
+      interval: [String], # daily, weekly, monthly
+      group_by_column: [String], # i.e.: created_at
+
+      from: [Date, DateTime, Time, ActiveSupport::TimeWithZone],
+      to: [:optional, Date, DateTime, Time, ActiveSupport::TimeWithZone],
+
+      aggregate_column: [:optional, String, NilClass] # required when using sum (as opposed to count)
+    }
+
+    attr_reader :values, :values_and_dates
+
+    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])
+
+      db_vendor_select_for_date_function =
+        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])
+
+      # 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] }
+
+    end
+
+    private
+
+    def validate_args!(hash_args)
+      ClassyHash.validate(hash_args, VALID_HASH_ARGS)
+      if hash_args[:aggregate_function] != 'count' && hash_args[:aggregate_column].blank?
+        raise RuntimeError.new('must pass the :aggregate_column arg')
+      end
+    end
+
+    # adjust "to" to end of day, week or month (if less than now)
+    def normalize_to(to, interval)
+      adjusted_to = to.send(Utils.interval_inflector(interval, 'end'))
+      if adjusted_to < (Time.zone.try(:now) || Time.now)
+        adjusted_to
+      else
+        to
+      end
+    end
+
+    # adjust "from" to beginning of day, week or month
+    def normalize_from(from, interval)
+      from.send(Utils.interval_inflector(interval, 'beginning'))
+    end
+
+  end
+end

data/lib/ar_aggregate_by_interval/utils.rb

@@ -0,0 +1,108 @@
+module ArAggregateByInterval
+  module Utils
+
+    extend self
+
+    DATE_ITERATOR_METHOD_MAP = {
+      'monthly' => 'each_month_until',
+      'weekly' => 'each_week_until',
+      'daily' => 'each_day_until'
+    }
+
+    # support legacy arguments (as opposed to direct hash)
+    # can do:
+    # ArModel.count_weekly(:group_by_col, :from, :to, :return_dates_bool)
+    # ArModel.count_weekly(:from, :to, :return_dates_bool) # defaults to :created_at
+    # or
+    # ArModel.sum_weekly(:group_by_col, :aggregate_col, :from, :to, :return_dates_bool)
+    def args_to_hash(sum_or_count, daily_weekly_monthly, *args)
+      group_by_column, aggregate_column, from, to, return_dates = args
+
+      group_by_column ||= 'created_at'
+      return_dates ||= false
+
+      if sum_or_count == 'count'
+        if aggregate_column.present? && (aggregate_column.is_a?(Date) || aggregate_column.is_a?(Time))
+          return_dates = to
+          to = from
+          from = aggregate_column
+          aggregate_column = nil
+        end
+      elsif sum_or_count != 'count' && aggregate_column.nil? || !(aggregate_column.is_a?(String) || aggregate_column.is_a?(Symbol))
+        raise "aggregate_column cant be nil with #{sum_or_count}"
+      end
+
+      return {
+        group_by_column: group_by_column,
+        from: from,
+        to: to,
+        aggregate_column: aggregate_column
+      }.delete_if { |k, v| v.nil? }
+    end
+
+    def ar_to_hash(ar_result, mapping)
+      ar_result.to_a.inject({}) do |memo, ar_obj|
+        mapping.each { |key, val| memo.merge!(ar_obj.send(key) => ar_obj.send(val)) }
+        memo
+      end
+    end
+
+    def ruby_strftime_map
+      @ruby_strftime_map ||= {
+        'monthly' => '%Y-%m',
+        # sqlite doesn't support ISO weeks
+        'weekly' => Utils.db_vendor.match(/sqlite/i) ? '%Y-%U' : '%G-%V',
+        'daily' => '%F'
+      }
+    end
+
+    def select_for_grouping_column(grouping_col)
+      case db_vendor
+      when /mysql/i
+        {
+          'monthly' => "date_format(#{grouping_col}, '%Y-%m')",
+          'weekly' => "date_format(#{grouping_col}, '%x-%v')",
+          'daily' => "date(#{grouping_col})"
+        }
+      when /postgres/i
+        {
+          'monthly' => "to_char(#{grouping_col}, 'YYYY-MM')",
+          'weekly' => "to_char(#{grouping_col}, 'IYYY-IW')",
+          'daily' => "date(#{grouping_col})"
+        }
+      when /sqlite/i
+        {
+          'monthly' => "strftime('%Y-%m', #{grouping_col})",
+          'weekly' => "strftime('%Y-%W', #{grouping_col})", # sqlite doesn't support ISO weeks
+          'daily' => "date(#{grouping_col})"
+        }
+      else
+        raise "unknown database vendor #{db_vendor}"
+      end
+    end
+
+    def db_vendor
+      @db_vendor ||=
+        ActiveRecord::Base.connection_config.try(:symbolize_keys).try(:[], :adapter) ||
+        ENV['DATABASE_URL']
+    end
+
+    # converts args like: [weekly, beginning] to beginning_of_week
+    def interval_inflector(interval, beg_or_end)
+      raise "beginning or end, not #{beg_or_end}" unless beg_or_end.match(/\A(beginning|end)\z/)
+
+      time_interval = {
+        'monthly' => 'month',
+        'weekly' => 'week',
+        'daily' => 'day'
+      }[interval] || raise("unknown interval #{interval}")
+
+      "#{beg_or_end}_of_#{time_interval}"
+    end
+
+    def to_f_or_i_or_s(v)
+      ((float = Float(v)) && (float % 1.0 == 0) ? float.to_i : float) rescue v
+    end
+
+  end
+end

data/lib/ar_aggregate_by_interval/version.rb

@@ -0,0 +1,3 @@
+module ArAggregateByInterval
+  VERSION = '1.1.0'
+end

data/spec/lib/ar_aggregate_by_interval/query_runner_spec.rb

@@ -0,0 +1,71 @@
+require 'ar_aggregate_by_interval/query_runner'
+require 'active_record'
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+load File.join(File.dirname(__FILE__), '../../schema.rb')
+
+class Blog < ActiveRecord::Base; end
+
+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

data/spec/lib/ar_aggregate_by_interval/utils_spec.rb

@@ -0,0 +1,51 @@
+require 'ar_aggregate_by_interval/utils'
+require 'ostruct'
+
+module ArAggregateByInterval
+
+  describe Utils do
+
+    context 'converting ar to hash' do
+
+      subject do
+        described_class.ar_to_hash(ar_objs, mapping)
+      end
+
+      context 'normal values' do
+        let(:ar_objs) do
+          [
+            OpenStruct.new({
+              date_chunk__: '2014-01-01',
+              value: 5
+            })
+          ]
+        end
+
+        let(:mapping) { { 'date_chunk__' => 'value' } }
+
+        it 'works' do
+          expect(subject).to eq({ '2014-01-01' => 5 })
+        end
+      end
+
+      context 'arbitrary values' do
+        let(:ar_objs) do
+          [
+            OpenStruct.new({
+              id: OpenStruct.new({}),
+              something: 1
+            })
+          ]
+        end
+        let(:mapping) { { 'id' => 'something' } }
+
+        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)
+        end
+      end
+
+    end
+  end
+
+end

data/spec/lib/ar_aggregate_by_interval_spec.rb

@@ -0,0 +1,125 @@
+require 'active_record'
+require 'ar_aggregate_by_interval'
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+load File.join(File.dirname(__FILE__), '../schema.rb')
+
+class Blog < ActiveRecord::Base; end
+
+describe ArAggregateByInterval do
+
+  before(:all) do |example|
+    @from = DateTime.parse '2013-08-05'
+    @to = @from
+    Blog.create arbitrary_number: 10, created_at: @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])
+    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])
+    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])
+    end
+  end
+
+  context 'scoped' do
+    subject do
+      Blog.where('id > 0').count_weekly('created_at', @from, @from)
+    end
+    it_behaves_like 'count .values_and_dates'
+  end
+
+  context 'hash args' do
+
+    context 'for count' do
+      subject do
+        Blog.count_weekly({
+          group_by_column: 'created_at',
+          from: @from,
+          to: @to
+        })
+      end
+      it_behaves_like 'count .values_and_dates'
+    end
+
+    context 'for sum' do
+      subject do
+        Blog.sum_weekly({
+          group_by_column: 'created_at',
+          aggregate_column: 'arbitrary_number',
+          from: @from,
+          to: @to
+        })
+      end
+      it_behaves_like 'sum .values_and_dates'
+    end
+
+    context 'for avg' do
+      subject do
+        Blog.avg_weekly({
+          group_by_column: 'created_at',
+          aggregate_column: 'arbitrary_number',
+          from: @from,
+          to: @to
+        })
+      end
+      it_behaves_like 'avg .values_and_dates'
+    end
+
+  end
+
+  context 'normal args' do
+    context 'for count' do
+      subject do
+        Blog.count_weekly('created_at', @from, @from)
+      end
+      it_behaves_like 'count .values_and_dates'
+    end
+    context 'for sum' do
+      subject do
+        Blog.sum_weekly('created_at', 'arbitrary_number', @from, @from)
+      end
+      it_behaves_like 'sum .values_and_dates'
+    end
+    context 'for avg' do
+      subject do
+        Blog.avg_weekly('created_at', 'arbitrary_number', @from, @from)
+      end
+      it_behaves_like 'avg .values_and_dates'
+    end
+  end
+
+  context 'bad args' do
+    context 'for count' do
+      subject do
+        Blog.count_weekly('created_at', {}, {})
+      end
+      it 'raise NoMethodError' do
+        expect do
+          subject
+        end.to raise_error(NoMethodError)
+      end
+    end
+
+    context 'for sum' do
+      subject do
+        Blog.sum_weekly('created_at', @from, @from)
+      end
+      it 'raise NoMethodError' do
+        expect do
+          subject
+        end.to raise_error(RuntimeError, /aggregate_column/)
+      end
+    end
+  end
+
+end

data/spec/schema.rb

@@ -0,0 +1,11 @@
+
+# ActiveRecord::Base.logger = Logger.new($stdout)
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :blogs, :force => true do |t|
+    t.integer :arbitrary_number
+    t.timestamps null: false
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,103 @@
+require 'database_cleaner'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    # DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: ar_aggregate_by_interval
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Jonathan Otto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: classy_hash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: date_iterator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: add [sum|count]_[daily|weekly|monthly] to your AR models for MySQL AND
+  Postgres
+email:
+- jonathan.otto@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ar_aggregate_counter.gemspec
+- lib/ar_aggregate_by_interval.rb
+- lib/ar_aggregate_by_interval/query_result.rb
+- lib/ar_aggregate_by_interval/query_runner.rb
+- lib/ar_aggregate_by_interval/utils.rb
+- lib/ar_aggregate_by_interval/version.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/schema.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jotto/ar_aggregate_by_interval
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: add [sum|count]_[daily|weekly|monthly] to your AR models for MySQL AND Postgres
+test_files:
+- 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/schema.rb
+- spec/spec_helper.rb