groupdate 3.2.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f98770b6255920a055b3d7ab6c9bf36227580077
-  data.tar.gz: 4d7d1eb90c872e35ba89ad0eead165841f1e0506
+  metadata.gz: d6b498ed092c226ed3e7eeec42f68ff8a4b092c1
+  data.tar.gz: a43c5abd7af5dcc458825c8e151184fc30d98626
 SHA512:
-  metadata.gz: 4aca35fb45ab76e77535404eb6123efc25bcdf4b2414b7255f8dd62e87e4b1d567eaf367807f93ac9ce18f5a571d752ea4d3dc2c47cc141413ebd49eeb656b31
-  data.tar.gz: 3f4ade3ccaab2acc62a413ca93ff618b1d89c2daa0c4d341b895b76db055dd6c0b208826c12696eb4c3f83900afcea69560f6c9bdf8d34c15e3c781264785e1b
+  metadata.gz: c6379307ca9ef9c5d3435490bb61cea9d8afd15abd9c106aabbf55bb2e4d3d20f2dcd5f2e5e8e12cf338cb48c113d81ea2265e7085bce643b88a0011bd73c7f4
+  data.tar.gz: a1c6d9161d0051153b313b5501d3043df99de23105748e336a3c2446edeb5acfb3708be638c95cb23811205840f2dd2799f571124f369dbfbe562df70259087d

data/.travis.yml

@@ -8,14 +8,12 @@ gemfile:
   - test/gemfiles/activerecord50.gemfile
   - test/gemfiles/activerecord42.gemfile
 sudo: false
-script: RUBYOPT=W0 bundle exec rake test
+script: bundle exec rake test
 before_install:
   - gem install bundler
   - mysql -e 'create database groupdate_test;'
   - mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -u root mysql
   - psql -c 'create database groupdate_test;' -U postgres
-env:
-  - TRAVIS=t
 notifications:
   email:
     on_success: never

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 4.0.0
+
+- Custom calculation methods are supported by default - `groupdate_calculation_methods` is no longer needed
+
+Breaking changes
+
+- Dropped support for Rails < 4.2
+- Invalid options now throw an `ArgumentError`
+- `group_by` methods return an `ActiveRecord::Relation` instead of a `Groupdate::Series`
+- `week_start` now affects `day_of_week`
+- Removed support for `reverse_order` (was never supported in Rails 5)
+
 ## 3.2.1
 
 - Added `minute_of_hour`

data/CONTRIBUTING.md

@@ -60,6 +60,9 @@ git clone https://github.com/ankane/groupdate.git
 cd groupdate
 bundle install
 bundle exec rake test
+
+# run a single test file
+ruby test/postgresql_test.rb
 ```
 
 ---

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Andrew Kane
+Copyright (c) 2013-2018 Andrew Kane
 
 MIT License
 

data/README.md

@@ -208,37 +208,6 @@ Count
 Hash[ users.group_by_day { |u| u.created_at }.map { |k, v| [k, v.size] } ]
 ```
 
-## Custom Calculation Methods
-
-Groupdate knows all of the calculations defined by `ActiveRecord` like `count`,
-`sum`, or `average`. However you may have your own class level calculation
-methods that you need to tell Groupdate about. All you have to do is define the
-class method `groupdate_calculation_methods` returning an array of the method
-names as symbols.
-
-```ruby
-class User < ApplicationRecord
-  def self.groupdate_calculation_methods
-    [:total_sign_ins]
-  end
-
-  def self.total_sign_ins
-    all.sum(:sign_ins)
-  end
-end
-```
-
-Then you can use your custom calculation method:
-
-```ruby
-User.group_by_week(:created_at).total_sign_ins
-```
-
-Note that even if your method uses one of the calculations from `ActiveRecord`,
-you'll still need to add it to the `groupdate_calculation_methods` array to have
-it return the Hash of dates to values. Otherwise it will return a
-`Groupdate::Series` object.
-
 ## Installation
 
 Add this line to your application’s Gemfile:
@@ -281,6 +250,15 @@ Groupdate.time_zone = false
 
 ## Upgrading
 
+### 4.0
+
+Groupdate 4.0 brings a number of improvements.  Here are a few to be aware of:
+
+- `group_by` methods return an `ActiveRecord::Relation` instead of a `Groupdate::Series`
+- Invalid options now throw an `ArgumentError`
+- `week_start` now affects `day_of_week`
+- Custom calculation methods are supported by default
+
 ### 3.0
 
 Groupdate 3.0 brings a number of improvements.  Here are a few to be aware of:

data/Rakefile

@@ -7,18 +7,3 @@ Rake::TestTask.new do |t|
   t.test_files = FileList["test/**/*_test.rb"].exclude(/redshift/)
   t.warning = false
 end
-
-namespace :test do
-  Rake::TestTask.new(:postgresql) do |t|
-    t.libs << "test"
-    t.pattern = "test/postgresql_test.rb"
-  end
-  Rake::TestTask.new(:mysql) do |t|
-    t.libs << "test"
-    t.pattern = "test/mysql_test.rb"
-  end
-  Rake::TestTask.new(:redshift) do |t|
-    t.libs << "test"
-    t.pattern = "test/redshift_test.rb"
-  end
-end

data/groupdate.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport", ">= 3"
+  spec.add_dependency "activesupport", ">= 4.2"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/lib/groupdate.rb

@@ -7,8 +7,6 @@ module Groupdate
   class Error < RuntimeError; end
 
   PERIODS = [:second, :minute, :hour, :day, :week, :month, :quarter, :year, :day_of_week, :hour_of_day, :minute_of_hour, :day_of_month, :month_of_year]
-  # backwards compatibility for anyone who happened to use it
-  FIELDS = PERIODS
   METHODS = PERIODS.map { |v| :"group_by_#{v}" } + [:group_by_period]
 
   mattr_accessor :week_start, :day_start, :time_zone, :dates

data/lib/groupdate/active_record.rb

@@ -1,53 +1,6 @@
 require "active_record"
-require "groupdate/order_hack"
-require "groupdate/scopes"
-require "groupdate/calculations"
-require "groupdate/series"
+require "groupdate/query_methods"
+require "groupdate/relation"
 
-ActiveRecord::Base.send(:extend, Groupdate::Scopes)
-
-module ActiveRecord
-  class Relation
-    if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 2
-
-      def method_missing_with_hack(method, *args, &block)
-        if Groupdate::METHODS.include?(method)
-          scoping { @klass.send(method, *args, &block) }
-        else
-          method_missing_without_hack(method, *args, &block)
-        end
-      end
-      alias_method_chain :method_missing, :hack
-
-    end
-  end
-end
-
-module ActiveRecord
-  module Associations
-    class CollectionProxy
-      if ActiveRecord::VERSION::MAJOR == 3
-        delegate(*Groupdate::METHODS, to: :scoped)
-      end
-    end
-  end
-end
-
-# hack for issue before Rails 5
-# https://github.com/rails/rails/issues/7121
-module ActiveRecord
-  module Calculations
-    private
-
-    if ActiveRecord::VERSION::MAJOR < 5
-      def column_alias_for_with_hack(*keys)
-        if keys.first.is_a?(Groupdate::OrderHack)
-          keys.first.field
-        else
-          column_alias_for_without_hack(*keys)
-        end
-      end
-      alias_method_chain :column_alias_for, :hack
-    end
-  end
-end
+ActiveRecord::Base.extend(Groupdate::QueryMethods)
+ActiveRecord::Relation.include(Groupdate::Relation)

data/lib/groupdate/enumerable.rb

@@ -2,7 +2,7 @@ module Enumerable
   Groupdate::PERIODS.each do |period|
     define_method :"group_by_#{period}" do |*args, &block|
       if block
-        Groupdate::Magic.new(period, args[0] || {}).group_by(self, &block)
+        Groupdate::Magic::Enumerable.group_by(self, period, args[0] || {}, &block)
       elsif respond_to?(:scoping)
         scoping { @klass.send(:"group_by_#{period}", *args, &block) }
       else
@@ -16,8 +16,9 @@ module Enumerable
       period = args[0]
       options = args[1] || {}
 
+      options = options.dup
       # to_sym is unsafe on user input, so convert to strings
-      permitted_periods = ((options[:permit] || Groupdate::PERIODS).map(&:to_sym) & Groupdate::PERIODS).map(&:to_s)
+      permitted_periods = ((options.delete(:permit) || Groupdate::PERIODS).map(&:to_sym) & Groupdate::PERIODS).map(&:to_s)
       if permitted_periods.include?(period.to_s)
         send("group_by_#{period}", options, &block)
       else

data/lib/groupdate/magic.rb

@@ -4,205 +4,17 @@ module Groupdate
   class Magic
     attr_accessor :period, :options
 
-    def initialize(period, options)
+    def initialize(period:, **options)
       @period = period
       @options = options
 
-      raise Groupdate::Error, "Unrecognized time zone" unless time_zone
+      unknown_keywords = options.keys - [:day_start, :time_zone, :dates, :series, :week_start, :format, :locale, :range, :reverse]
+      raise ArgumentError, "unknown keywords: #{unknown_keywords.join(", ")}" if unknown_keywords.any?
 
+      raise Groupdate::Error, "Unrecognized time zone" unless time_zone
       raise Groupdate::Error, "Unrecognized :week_start option" if period == :week && !week_start
     end
 
-    def group_by(enum, &_block)
-      group = enum.group_by { |v| v = yield(v); v ? round_time(v) : nil }
-      series(group, [], false, false, false)
-    end
-
-    def relation(column, relation)
-      if relation.default_timezone == :local
-        raise Groupdate::Error, "ActiveRecord::Base.default_timezone must be :utc to use Groupdate"
-      end
-
-      time_zone = self.time_zone.tzinfo.name
-
-      adapter_name = relation.connection.adapter_name
-      query =
-        case adapter_name
-        when "MySQL", "Mysql2", "Mysql2Spatial", 'Mysql2Rgeo'
-          case period
-          when :day_of_week # Sunday = 0, Monday = 1, etc
-            # use CONCAT for consistent return type (String)
-            ["DAYOFWEEK(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?)) - 1", time_zone]
-          when :hour_of_day
-            ["(EXTRACT(HOUR from CONVERT_TZ(#{column}, '+00:00', ?)) + 24 - #{day_start / 3600}) % 24", time_zone]
-          when :minute_of_hour
-            ["(EXTRACT(MINUTE from CONVERT_TZ(#{column}, '+00:00', ?)))", time_zone]
-          when :day_of_month
-            ["DAYOFMONTH(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?))", time_zone]
-          when :month_of_year
-            ["MONTH(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?))", time_zone]
-          when :week
-            ["CONVERT_TZ(DATE_FORMAT(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL ((#{7 - week_start} + WEEKDAY(CONVERT_TZ(#{column}, '+00:00', ?) - INTERVAL #{day_start} second)) % 7) DAY) - INTERVAL #{day_start} second, '+00:00', ?), '%Y-%m-%d 00:00:00') + INTERVAL #{day_start} second, ?, '+00:00')", time_zone, time_zone, time_zone]
-          when :quarter
-            ["DATE_ADD(CONVERT_TZ(DATE_FORMAT(DATE(CONCAT(EXTRACT(YEAR FROM CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?)), '-', LPAD(1 + 3 * (QUARTER(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?)) - 1), 2, '00'), '-01')), '%Y-%m-%d %H:%i:%S'), ?, '+00:00'), INTERVAL #{day_start} second)", time_zone, time_zone, time_zone]
-          else
-            format =
-              case period
-              when :second
-                "%Y-%m-%d %H:%i:%S"
-              when :minute
-                "%Y-%m-%d %H:%i:00"
-              when :hour
-                "%Y-%m-%d %H:00:00"
-              when :day
-                "%Y-%m-%d 00:00:00"
-              when :month
-                "%Y-%m-01 00:00:00"
-              else # year
-                "%Y-01-01 00:00:00"
-              end
-
-            ["DATE_ADD(CONVERT_TZ(DATE_FORMAT(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?), '#{format}'), ?, '+00:00'), INTERVAL #{day_start} second)", time_zone, time_zone]
-          end
-        when "PostgreSQL", "PostGIS"
-          case period
-          when :day_of_week
-            ["EXTRACT(DOW from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :hour_of_day
-            ["EXTRACT(HOUR from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :minute_of_hour
-            ["EXTRACT(MINUTE from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :day_of_month
-            ["EXTRACT(DAY from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :month_of_year
-            ["EXTRACT(MONTH from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :week # start on Sunday, not PostgreSQL default Monday
-            ["(DATE_TRUNC('#{period}', (#{column}::timestamptz - INTERVAL '#{week_start} day' - INTERVAL '#{day_start} second') AT TIME ZONE ?) + INTERVAL '#{week_start} day' + INTERVAL '#{day_start} second') AT TIME ZONE ?", time_zone, time_zone]
-          else
-            ["(DATE_TRUNC('#{period}', (#{column}::timestamptz - INTERVAL '#{day_start} second') AT TIME ZONE ?) + INTERVAL '#{day_start} second') AT TIME ZONE ?", time_zone, time_zone]
-          end
-        when "SQLite"
-          raise Groupdate::Error, "Time zones not supported for SQLite" unless self.time_zone.utc_offset.zero?
-          raise Groupdate::Error, "day_start not supported for SQLite" unless day_start.zero?
-          raise Groupdate::Error, "week_start not supported for SQLite" unless week_start == 6
-
-          if period == :week
-            ["strftime('%%Y-%%m-%%d 00:00:00 UTC', #{column}, '-6 days', 'weekday 0')"]
-          else
-            format =
-              case period
-              when :hour_of_day
-                "%H"
-              when :minute_of_hour
-                "%M"
-              when :day_of_week
-                "%w"
-              when :day_of_month
-                "%d"
-              when :month_of_year
-                "%m"
-              when :second
-                "%Y-%m-%d %H:%M:%S UTC"
-              when :minute
-                "%Y-%m-%d %H:%M:00 UTC"
-              when :hour
-                "%Y-%m-%d %H:00:00 UTC"
-              when :day
-                "%Y-%m-%d 00:00:00 UTC"
-              when :month
-                "%Y-%m-01 00:00:00 UTC"
-              when :quarter
-                raise Groupdate::Error, "Quarter not supported for SQLite"
-              else # year
-                "%Y-01-01 00:00:00 UTC"
-              end
-
-            ["strftime('#{format.gsub(/%/, '%%')}', #{column})"]
-          end
-        when "Redshift"
-          case period
-          when :day_of_week # Sunday = 0, Monday = 1, etc.
-            ["EXTRACT(DOW from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :hour_of_day
-            ["EXTRACT(HOUR from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :minute_of_hour
-            ["EXTRACT(MINUTE from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :day_of_month
-            ["EXTRACT(DAY from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :month_of_year
-            ["EXTRACT(MONTH from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :week # start on Sunday, not Redshift default Monday
-            # Redshift does not return timezone information; it
-            # always says it is in UTC time, so we must convert
-            # back to UTC to play properly with the rest of Groupdate.
-            #
-            ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC(?, CONVERT_TIMEZONE(?, #{column}) - INTERVAL '#{week_start} day' - INTERVAL '#{day_start} second'))::timestamp + INTERVAL '#{week_start} day' + INTERVAL '#{day_start} second'", time_zone, period, time_zone]
-          else
-            ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC(?, CONVERT_TIMEZONE(?, #{column}) - INTERVAL '#{day_start} second'))::timestamp + INTERVAL '#{day_start} second'", time_zone, period, time_zone]
-          end
-        else
-          raise Groupdate::Error, "Connection adapter not supported: #{adapter_name}"
-        end
-
-      if adapter_name == "MySQL" && period == :week
-        query[0] = "CAST(#{query[0]} AS DATETIME)"
-      end
-
-      group = relation.group(Groupdate::OrderHack.new(relation.send(:sanitize_sql_array, query), period, time_zone))
-      relation =
-        if time_range.is_a?(Range)
-          # doesn't matter whether we include the end of a ... range - it will be excluded later
-          group.where("#{column} >= ? AND #{column} <= ?", time_range.first, time_range.last)
-        else
-          group.where("#{column} IS NOT NULL")
-        end
-
-      # TODO do not change object state
-      @group_index = group.group_values.size - 1
-
-      Groupdate::Series.new(self, relation)
-    end
-
-    def perform(relation, method, *args, &block)
-      # undo reverse since we do not want this to appear in the query
-      reverse = relation.send(:reverse_order_value)
-      relation = relation.except(:reverse_order) if reverse
-      order = relation.order_values.first
-      if order.is_a?(String)
-        parts = order.split(" ")
-        reverse_order = (parts.size == 2 && (parts[0].to_sym == period || (activerecord42? && parts[0] == "#{relation.quoted_table_name}.#{relation.quoted_primary_key}")) && parts[1].to_s.downcase == "desc")
-        if reverse_order
-          reverse = !reverse
-          relation = relation.reorder(relation.order_values[1..-1])
-        end
-      end
-
-      multiple_groups = relation.group_values.size > 1
-
-      cast_method =
-        case period
-        when :day_of_week, :hour_of_day, :day_of_month, :month_of_year, :minute_of_hour
-          lambda { |k| k.to_i }
-        else
-          utc = ActiveSupport::TimeZone["UTC"]
-          lambda { |k| (k.is_a?(String) || !k.respond_to?(:to_time) ? utc.parse(k.to_s) : k.to_time).in_time_zone(time_zone) }
-        end
-
-      result = relation.send(method, *args, &block)
-      if result.is_a?(Hash)
-        missing_time_zone_support = multiple_groups ? (result.keys.first && result.keys.first[@group_index].nil?) : result.key?(nil)
-        if missing_time_zone_support
-          raise Groupdate::Error, "Be sure to install time zone support - https://github.com/ankane/groupdate#for-mysql"
-        end
-        result = Hash[result.map { |k, v| [multiple_groups ? k[0...@group_index] + [cast_method.call(k[@group_index])] + k[(@group_index + 1)..-1] : cast_method.call(k), v] }]
-
-        series(result, (options.key?(:default_value) ? options[:default_value] : 0), multiple_groups, reverse)
-      else
-        # for ActiveRecord::Calculations methods that don't call calculate, like pluck
-        result
-      end
-    end
-
     protected
 
     def time_zone
@@ -343,7 +155,7 @@ module Groupdate
               when :minute_of_hour
                 key = sunday + key.minutes + day_start.seconds
               when :day_of_week
-                key = sunday + key.days
+                key = sunday + key.days + (week_start + 1).days
               when :day_of_month
                 key = Date.new(2014, 1, key).to_time
               when :month_of_year
@@ -398,7 +210,7 @@ module Groupdate
         when :minute_of_hour
           time.min
         when :day_of_week
-          time.wday
+          (time.wday - 1 - week_start) % 7
         when :day_of_month
           time.day
         when :month_of_year
@@ -410,8 +222,219 @@ module Groupdate
       time.is_a?(Time) ? time + day_start.seconds : time
     end
 
-    def activerecord42?
-      ActiveRecord::VERSION::STRING.starts_with?("4.2.")
+    class Enumerable < Magic
+      def group_by(enum, &_block)
+        group = enum.group_by { |v| v = yield(v); v ? round_time(v) : nil }
+        series(group, [], false, false, false)
+      end
+
+      def self.group_by(enum, period, options, &block)
+        Groupdate::Magic::Enumerable.new(period: period, **options).group_by(enum, &block)
+      end
+    end
+
+    class Relation < Magic
+      def initialize(**options)
+        super(**options.reject { |k, _| [:default_value, :carry_forward, :last, :current].include?(k) })
+        @options = options
+      end
+
+      def relation(column, relation)
+        if relation.default_timezone == :local
+          raise Groupdate::Error, "ActiveRecord::Base.default_timezone must be :utc to use Groupdate"
+        end
+
+        time_zone = self.time_zone.tzinfo.name
+
+        adapter_name = relation.connection.adapter_name
+        query =
+          case adapter_name
+          when "MySQL", "Mysql2", "Mysql2Spatial", 'Mysql2Rgeo'
+            case period
+            when :day_of_week
+              ["DAYOFWEEK(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?)) - 1", time_zone]
+            when :hour_of_day
+              ["(EXTRACT(HOUR from CONVERT_TZ(#{column}, '+00:00', ?)) + 24 - #{day_start / 3600}) % 24", time_zone]
+            when :minute_of_hour
+              ["(EXTRACT(MINUTE from CONVERT_TZ(#{column}, '+00:00', ?)))", time_zone]
+            when :day_of_month
+              ["DAYOFMONTH(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?))", time_zone]
+            when :month_of_year
+              ["MONTH(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?))", time_zone]
+            when :week
+              ["CONVERT_TZ(DATE_FORMAT(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL ((#{7 - week_start} + WEEKDAY(CONVERT_TZ(#{column}, '+00:00', ?) - INTERVAL #{day_start} second)) % 7) DAY) - INTERVAL #{day_start} second, '+00:00', ?), '%Y-%m-%d 00:00:00') + INTERVAL #{day_start} second, ?, '+00:00')", time_zone, time_zone, time_zone]
+            when :quarter
+              ["DATE_ADD(CONVERT_TZ(DATE_FORMAT(DATE(CONCAT(EXTRACT(YEAR FROM CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?)), '-', LPAD(1 + 3 * (QUARTER(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?)) - 1), 2, '00'), '-01')), '%Y-%m-%d %H:%i:%S'), ?, '+00:00'), INTERVAL #{day_start} second)", time_zone, time_zone, time_zone]
+            else
+              format =
+                case period
+                when :second
+                  "%Y-%m-%d %H:%i:%S"
+                when :minute
+                  "%Y-%m-%d %H:%i:00"
+                when :hour
+                  "%Y-%m-%d %H:00:00"
+                when :day
+                  "%Y-%m-%d 00:00:00"
+                when :month
+                  "%Y-%m-01 00:00:00"
+                else # year
+                  "%Y-01-01 00:00:00"
+                end
+
+              ["DATE_ADD(CONVERT_TZ(DATE_FORMAT(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?), '#{format}'), ?, '+00:00'), INTERVAL #{day_start} second)", time_zone, time_zone]
+            end
+          when "PostgreSQL", "PostGIS"
+            case period
+            when :day_of_week
+              ["EXTRACT(DOW from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
+            when :hour_of_day
+              ["EXTRACT(HOUR from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
+            when :minute_of_hour
+              ["EXTRACT(MINUTE from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
+            when :day_of_month
+              ["EXTRACT(DAY from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
+            when :month_of_year
+              ["EXTRACT(MONTH from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
+            when :week # start on Sunday, not PostgreSQL default Monday
+              ["(DATE_TRUNC('#{period}', (#{column}::timestamptz - INTERVAL '#{week_start} day' - INTERVAL '#{day_start} second') AT TIME ZONE ?) + INTERVAL '#{week_start} day' + INTERVAL '#{day_start} second') AT TIME ZONE ?", time_zone, time_zone]
+            else
+              ["(DATE_TRUNC('#{period}', (#{column}::timestamptz - INTERVAL '#{day_start} second') AT TIME ZONE ?) + INTERVAL '#{day_start} second') AT TIME ZONE ?", time_zone, time_zone]
+            end
+          when "SQLite"
+            raise Groupdate::Error, "Time zones not supported for SQLite" unless self.time_zone.utc_offset.zero?
+            raise Groupdate::Error, "day_start not supported for SQLite" unless day_start.zero?
+            raise Groupdate::Error, "week_start not supported for SQLite" unless week_start == 6
+
+            if period == :week
+              ["strftime('%%Y-%%m-%%d 00:00:00 UTC', #{column}, '-6 days', 'weekday 0')"]
+            else
+              format =
+                case period
+                when :hour_of_day
+                  "%H"
+                when :minute_of_hour
+                  "%M"
+                when :day_of_week
+                  "%w"
+                when :day_of_month
+                  "%d"
+                when :month_of_year
+                  "%m"
+                when :second
+                  "%Y-%m-%d %H:%M:%S UTC"
+                when :minute
+                  "%Y-%m-%d %H:%M:00 UTC"
+                when :hour
+                  "%Y-%m-%d %H:00:00 UTC"
+                when :day
+                  "%Y-%m-%d 00:00:00 UTC"
+                when :month
+                  "%Y-%m-01 00:00:00 UTC"
+                when :quarter
+                  raise Groupdate::Error, "Quarter not supported for SQLite"
+                else # year
+                  "%Y-01-01 00:00:00 UTC"
+                end
+
+              ["strftime('#{format.gsub(/%/, '%%')}', #{column})"]
+            end
+          when "Redshift"
+            case period
+            when :day_of_week
+              ["EXTRACT(DOW from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
+            when :hour_of_day
+              ["EXTRACT(HOUR from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
+            when :minute_of_hour
+              ["EXTRACT(MINUTE from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
+            when :day_of_month
+              ["EXTRACT(DAY from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
+            when :month_of_year
+              ["EXTRACT(MONTH from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
+            when :week # start on Sunday, not Redshift default Monday
+              # Redshift does not return timezone information; it
+              # always says it is in UTC time, so we must convert
+              # back to UTC to play properly with the rest of Groupdate.
+              #
+              ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC(?, CONVERT_TIMEZONE(?, #{column}) - INTERVAL '#{week_start} day' - INTERVAL '#{day_start} second'))::timestamp + INTERVAL '#{week_start} day' + INTERVAL '#{day_start} second'", time_zone, period, time_zone]
+            else
+              ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC(?, CONVERT_TIMEZONE(?, #{column}) - INTERVAL '#{day_start} second'))::timestamp + INTERVAL '#{day_start} second'", time_zone, period, time_zone]
+            end
+          else
+            raise Groupdate::Error, "Connection adapter not supported: #{adapter_name}"
+          end
+
+        if adapter_name == "MySQL" && period == :week
+          query[0] = "CAST(#{query[0]} AS DATETIME)"
+        end
+
+        group_str = relation.send(:sanitize_sql_array, query)
+
+        # cleaner queries in logs
+        # Postgres
+        group_str = group_str.gsub(/ (\-|\+) INTERVAL '0 second'/, "")
+        # MySQL
+        group_str = group_str.gsub("DATE_SUB(#{column}, INTERVAL 0 second)", "#{column}")
+        if group_str.start_with?("DATE_ADD(") && group_str.end_with?(", INTERVAL 0 second)")
+          group_str = group_str[9..-21]
+        end
+
+        group = relation.group(group_str)
+        relation =
+          if time_range.is_a?(Range)
+            # doesn't matter whether we include the end of a ... range - it will be excluded later
+            group.where("#{column} >= ? AND #{column} <= ?", time_range.first, time_range.last)
+          else
+            group.where("#{column} IS NOT NULL")
+          end
+
+        # TODO do not change object state
+        @group_index = group.group_values.size - 1
+
+        relation
+      end
+
+      def perform(relation, result)
+        multiple_groups = relation.group_values.size > 1
+
+        cast_method =
+          case period
+          when :day_of_week
+            lambda { |k| (k.to_i - 1 - week_start) % 7 }
+          when :hour_of_day, :day_of_month, :month_of_year, :minute_of_hour
+            lambda { |k| k.to_i }
+          else
+            utc = ActiveSupport::TimeZone["UTC"]
+            lambda { |k| (k.is_a?(String) || !k.respond_to?(:to_time) ? utc.parse(k.to_s) : k.to_time).in_time_zone(time_zone) }
+          end
+
+        missing_time_zone_support = multiple_groups ? (result.keys.first && result.keys.first[@group_index].nil?) : result.key?(nil)
+        if missing_time_zone_support
+          raise Groupdate::Error, "Be sure to install time zone support - https://github.com/ankane/groupdate#for-mysql"
+        end
+        result = Hash[result.map { |k, v| [multiple_groups ? k[0...@group_index] + [cast_method.call(k[@group_index])] + k[(@group_index + 1)..-1] : cast_method.call(k), v] }]
+
+        series(result, (options.key?(:default_value) ? options[:default_value] : 0), multiple_groups, @reverse)
+      end
+
+      def self.generate_relation(relation, field:, **options)
+        magic = Groupdate::Magic::Relation.new(**options)
+
+        # generate ActiveRecord relation
+        relation = magic.relation(field, relation)
+
+        # add Groupdate info
+        (relation.groupdate_values ||= []) << magic
+
+        relation
+      end
+
+      def self.process_result(relation, result)
+        relation.groupdate_values.reverse.each do |gv|
+          result = gv.perform(relation, result)
+        end
+        result
+      end
     end
   end
 end

data/lib/groupdate/query_methods.rb

@@ -0,0 +1,25 @@
+module Groupdate
+  module QueryMethods
+    Groupdate::PERIODS.each do |period|
+      define_method :"group_by_#{period}" do |field, time_zone = nil, range = nil, **options|
+        Groupdate::Magic::Relation.generate_relation(self,
+          period: period,
+          field: field,
+          time_zone: time_zone,
+          range: range,
+          **options
+        )
+      end
+    end
+
+    def group_by_period(period, field, permit: nil, **options)
+      # to_sym is unsafe on user input, so convert to strings
+      permitted_periods = ((permit || Groupdate::PERIODS).map(&:to_sym) & Groupdate::PERIODS).map(&:to_s)
+      if permitted_periods.include?(period.to_s)
+        send("group_by_#{period}", field, **options)
+      else
+        raise ArgumentError, "Unpermitted period"
+      end
+    end
+  end
+end

data/lib/groupdate/relation.rb

@@ -0,0 +1,19 @@
+require "active_support/concern"
+
+module Groupdate
+  module Relation
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :groupdate_values
+    end
+
+    def calculate(*args, &block)
+      if groupdate_values
+        Groupdate::Magic::Relation.process_result(self, super)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/groupdate/version.rb

@@ -1,3 +1,3 @@
 module Groupdate
-  VERSION = "3.2.1"
+  VERSION = "4.0.0"
 end

data/test/gemfiles/redshift.gemfile

@@ -3,5 +3,5 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in groupdate.gemspec
 gemspec path: "../../"
 
-gem "activerecord", "~> 4.2.0"
-gem "activerecord4-redshift-adapter", "~> 0.2.0"
+gem "activerecord", "~> 5.1.0"
+gem "activerecord5-redshift-adapter"

data/test/sqlite_test.rb

@@ -17,11 +17,6 @@ class TestSqlite < Minitest::Test
     skip
   end
 
-  def test_zeros_datetime
-    skip if ENV["TRAVIS"]
-    super
-  end
-
   def call_method(method, field, options)
     if method == :quarter || options[:time_zone] || options[:day_start] || options[:week_start] || Groupdate.week_start != :sun || (Time.zone && options[:time_zone] != false)
       error = assert_raises(Groupdate::Error) { super }

data/test/test_helper.rb

@@ -10,7 +10,7 @@ Minitest::Test = Minitest::Unit::TestCase unless defined?(Minitest::Test)
 ENV["TZ"] = "UTC"
 
 # for debugging
-# ActiveRecord::Base.logger = Logger.new(STDOUT)
+ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT) if ENV["VERBOSE"]
 
 # rails does this in activerecord/lib/active_record/railtie.rb
 ActiveRecord::Base.default_timezone = :utc
@@ -19,17 +19,9 @@ ActiveRecord::Base.time_zone_aware_attributes = true
 class User < ActiveRecord::Base
   has_many :posts
 
-  def self.groupdate_calculation_methods
-    [:custom_count, :undefined_calculation]
-  end
-
   def self.custom_count
     count
   end
-
-  def self.unlisted_calculation
-    count
-  end
 end
 
 class Post < ActiveRecord::Base
@@ -86,24 +78,6 @@ module TestDatabase
     assert_equal expected, User.where("id = 0").group_by_day(:created_at, range: Date.parse("2013-05-01")..Date.parse("2013-05-01 23:59:59 UTC")).count
   end
 
-  def test_order_hour_of_day
-    assert_equal 23, User.group_by_hour_of_day(:created_at).order("hour_of_day desc").count.keys.first
-  end
-
-  def test_order_hour_of_day_case
-    assert_equal 23, User.group_by_hour_of_day(:created_at).order("hour_of_day DESC").count.keys.first
-  end
-
-  def test_order_hour_of_day_reverse
-    skip if ActiveRecord::VERSION::MAJOR == 5
-    assert_equal 23, User.group_by_hour_of_day(:created_at).reverse_order.count.keys.first
-  end
-
-  def test_order_hour_of_day_order_reverse
-    skip if ActiveRecord::VERSION::MAJOR == 5
-    assert_equal 0, User.group_by_hour_of_day(:created_at).order("hour_of_day desc").reverse_order.count.keys.first
-  end
-
   def test_table_name
     # This test is to ensure there's not an error when using the table
     # name as part of the column name.
@@ -403,10 +377,6 @@ module TestDatabase
     assert_equal expected, User.group_by_day(:created_at).custom_count
   end
 
-  def test_using_unlisted_calculation_method_returns_new_series_instance
-    assert_instance_of Groupdate::Series, User.group_by_day(:created_at).unlisted_calculation
-  end
-
   def test_using_listed_but_undefined_custom_calculation_method_raises_error
     assert_raises(NoMethodError) do
       User.group_by_day(:created_at).undefined_calculation
@@ -426,6 +396,12 @@ module TestDatabase
     assert_equal [0], User.group_by_hour_of_day(:created_at).pluck(0)
   end
 
+  # test relation
+
+  def test_relation
+    assert User.group_by_day(:created_at).is_a?(ActiveRecord::Relation)
+  end
+
   private
 
   def call_method(method, field, options)
@@ -799,6 +775,24 @@ module TestGroupdate
     assert_result :day_of_week, 3, "2013-01-02 10:00:00", true, day_start: 2
   end
 
+  # day of week week start monday
+
+  def test_day_of_week_end_of_day_week_start_mon
+    assert_result :day_of_week, 1, "2013-01-01 23:59:59", false, week_start: :mon
+  end
+
+  def test_day_of_week_start_of_day_week_start_mon
+    assert_result :day_of_week, 2, "2013-01-02 00:00:00", false, week_start: :mon
+  end
+
+  def test_day_of_week_end_of_week_with_time_zone_week_start_mon
+    assert_result :day_of_week, 1, "2013-01-02 07:59:59", true, week_start: :mon
+  end
+
+  def test_day_of_week_start_of_week_with_time_zone_week_start_mon
+    assert_result :day_of_week, 2, "2013-01-02 08:00:00", true, week_start: :mon
+  end
+
   # day of month
 
   def test_day_of_month_end_of_day
@@ -1101,6 +1095,10 @@ module TestGroupdate
     assert_format :day_of_week, "Sat", "%a", week_start: :mon
   end
 
+  def test_format_day_of_week_week_start
+    assert_equal "Mon", call_method(:day_of_week, :created_at, week_start: :mon, format: "%a", series: true).keys.first
+  end
+
   def test_format_day_of_month
     create_user "2014-03-01"
     assert_format :day_of_month, " 1", "%e"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: groupdate
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 4.0.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -141,18 +141,12 @@ files:
 - groupdate.gemspec
 - lib/groupdate.rb
 - lib/groupdate/active_record.rb
-- lib/groupdate/calculations.rb
 - lib/groupdate/enumerable.rb
 - lib/groupdate/magic.rb
-- lib/groupdate/order_hack.rb
-- lib/groupdate/scopes.rb
-- lib/groupdate/series.rb
+- lib/groupdate/query_methods.rb
+- lib/groupdate/relation.rb
 - lib/groupdate/version.rb
 - test/enumerable_test.rb
-- test/gemfiles/activerecord31.gemfile
-- test/gemfiles/activerecord32.gemfile
-- test/gemfiles/activerecord40.gemfile
-- test/gemfiles/activerecord41.gemfile
 - test/gemfiles/activerecord42.gemfile
 - test/gemfiles/activerecord50.gemfile
 - test/gemfiles/activerecord52.gemfile
@@ -188,10 +182,6 @@ specification_version: 4
 summary: The simplest way to group temporal data
 test_files:
 - test/enumerable_test.rb
-- test/gemfiles/activerecord31.gemfile
-- test/gemfiles/activerecord32.gemfile
-- test/gemfiles/activerecord40.gemfile
-- test/gemfiles/activerecord41.gemfile
 - test/gemfiles/activerecord42.gemfile
 - test/gemfiles/activerecord50.gemfile
 - test/gemfiles/activerecord52.gemfile

data/lib/groupdate/calculations.rb

@@ -1,26 +0,0 @@
-module Groupdate
-  class Calculations
-    attr_reader :relation
-
-    def initialize(relation)
-      @relation = relation
-    end
-
-    def include?(method)
-      # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/relation/calculations.rb
-      ActiveRecord::Calculations.method_defined?(method) || custom_calculations.include?(method)
-    end
-
-    def custom_calculations
-      return [] if !model.respond_to?(:groupdate_calculation_methods)
-      model.groupdate_calculation_methods
-    end
-
-    private
-
-    def model
-      return if !relation.respond_to?(:klass)
-      relation.klass
-    end
-  end
-end

data/lib/groupdate/order_hack.rb

@@ -1,11 +0,0 @@
-module Groupdate
-  class OrderHack < String
-    attr_reader :field, :time_zone
-
-    def initialize(str, field, time_zone)
-      super(str)
-      @field = field.to_s
-      @time_zone = time_zone
-    end
-  end
-end

data/lib/groupdate/scopes.rb

@@ -1,24 +0,0 @@
-module Groupdate
-  module Scopes
-    Groupdate::PERIODS.each do |period|
-      define_method :"group_by_#{period}" do |field, *args|
-        args = args.dup
-        options = args[-1].is_a?(Hash) ? args.pop : {}
-        options[:time_zone] ||= args[0] unless args[0].nil?
-        options[:range] ||= args[1] unless args[1].nil?
-
-        Groupdate::Magic.new(period, options).relation(field, self)
-      end
-    end
-
-    def group_by_period(period, field, options = {})
-      # to_sym is unsafe on user input, so convert to strings
-      permitted_periods = ((options[:permit] || Groupdate::PERIODS).map(&:to_sym) & Groupdate::PERIODS).map(&:to_s)
-      if permitted_periods.include?(period.to_s)
-        send("group_by_#{period}", field, options)
-      else
-        raise ArgumentError, "Unpermitted period"
-      end
-    end
-  end
-end

data/lib/groupdate/series.rb

@@ -1,34 +0,0 @@
-module Groupdate
-  class Series
-    attr_accessor :magic, :relation
-
-    def initialize(magic, relation)
-      @magic = magic
-      @relation = relation
-      @calculations = Groupdate::Calculations.new(relation)
-    end
-
-    # clone to prevent modifying original variables
-    def method_missing(method, *args, &block)
-      if @calculations.include?(method)
-        magic.perform(relation, method, *args, &block)
-      elsif relation.respond_to?(method, true)
-        Groupdate::Series.new(magic, relation.send(method, *args, &block))
-      else
-        super
-      end
-    end
-
-    def respond_to?(method, include_all = false)
-      @calculations.include?(method) || relation.respond_to?(method) || super
-    end
-
-    def reverse_order_value
-      nil
-    end
-
-    def unscoped
-      @relation.unscoped
-    end
-  end
-end

data/test/gemfiles/activerecord31.gemfile

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in groupdate.gemspec
-gemspec path: "../../"
-
-gem "activerecord", "~> 3.1.0"

data/test/gemfiles/activerecord32.gemfile

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in groupdate.gemspec
-gemspec path: "../../"
-
-gem "activerecord", "~> 3.2.0"

data/test/gemfiles/activerecord40.gemfile

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in groupdate.gemspec
-gemspec path: "../../"
-
-gem "activerecord", "~> 4.0.0"

data/test/gemfiles/activerecord41.gemfile

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in groupdate.gemspec
-gemspec path: "../../"
-
-gem "activerecord", "~> 4.1.0"