groupdate 4.2.0 → 5.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a10a3b53e404c803b6f78e42b3d4cb43088cf9884db7de2e7a8ffd10d91b786
-  data.tar.gz: 6b8123a4e90331d58d656f176684660eedeb7722b754d0325feaea87d897c9fd
+  metadata.gz: 448e7901aa2448bca591568110960048d18ac0f21faa5c3cae566fc4a6de30c4
+  data.tar.gz: ba242e41103ae9d2542ff0509de1f454f58142957f0da190482769a42a152887
 SHA512:
-  metadata.gz: eb01ba56326b819e783784dfe09b14ece4bda6ab53bcf2ea7b61a19b94f4d54eaa7ac7b6847cbec3c9e3056d7fac866a4eff83edf1d5b4a0b5a89d9a2ac82d9a
-  data.tar.gz: 57167fca94dd3b1f61003cb6e3af9164085daaa46da3ff51190d356b1332c3fcf9bac6e26a95cabc803cabd18c1c6d38644163a80ade6b762fea6316ab42a562
+  metadata.gz: 91b008f8ee0d9ad419ec042ee2f417b621fba09793b223705a2898fe21083a09527885ead3be2d3b8003427473d1f996938098c9bd7139bcb9bffdad2810734c
+  data.tar.gz: d4eb493bdf4b7f40eda2733003263bee49e62f9f69fb6239bec118d1768ce0630c21244e819147ca6b5b1556a9b5e125ed69748e2ee69d3c325f31a2740a6ec5

data/CHANGELOG.md

@@ -1,36 +1,69 @@
-## 4.2.0
+## 5.2.1 (2020-09-09)
+
+- Improved error message for invalid ranges
+- Fixed bug with date string ranges
+
+## 5.2.0 (2020-09-07)
+
+- Added warning for non-attribute argument
+- Added support for beginless and endless ranges in `range` option
+
+## 5.1.0 (2020-07-30)
+
+- Added `n` option to minute and second for custom durations
+
+## 5.0.0 (2020-02-18)
+
+- Added support for `week_start` for SQLite
+- Added support for full weekday names
+- Made `day_start` behavior consistent between Active Record and enumerable
+- Made `last` option extend to end of current period
+- Raise error when `day_start` and `week_start` passed to unsupported methods
+- The `day_start` option no longer applies to shorter periods
+- Fixed `inconsistent time zone info` errors around DST with MySQL and PostgreSQL
+- Improved performance of `format` option
+- Removed deprecated positional arguments for time zone and range
+- Dropped support for `mysql` gem (last release was 2013)
+
+## 4.3.0 (2019-12-26)
+
+- Fixed error with empty results in Ruby 2.7
+- Fixed deprecation warnings in Ruby 2.7
+- Deprecated positional arguments for time zone and range
+
+## 4.2.0 (2019-10-28)
 
 - Added `day_of_year`
 - Dropped support for Rails 4.2
 
-## 4.1.2
+## 4.1.2 (2019-05-26)
 
 - Fixed error with empty data and `current: false`
 - Fixed error in time zone check for Rails < 5.2
 - Prevent infinite loop with endless ranges
 
-## 4.1.1
+## 4.1.1 (2018-12-11)
 
 - Made column resolution consistent with `group`
 - Added support for `alias_attribute`
 
-## 4.1.0
+## 4.1.0 (2018-11-04)
 
 - Many performance improvements
 - Added check for consistent time zone info
 - Fixed error message for invalid queries with MySQL and SQLite
 - Fixed issue with enumerable methods ignoring nils
 
-## 4.0.2
+## 4.0.2 (2018-10-15)
 
 - Make `current` option work without `last`
 - Fixed default value for `maximum`, `minimum`, and `average` (periods with no results now return `nil` instead of `0`, pass `default_value: 0` for previous behavior)
 
-## 4.0.1
+## 4.0.1 (2018-05-03)
 
 - Fixed incorrect range with `last` option near time change
 
-## 4.0.0
+## 4.0.0 (2018-02-21)
 
 - Custom calculation methods are supported by default - `groupdate_calculation_methods` is no longer needed
 
@@ -42,37 +75,37 @@ Breaking changes
 - `week_start` now affects `day_of_week`
 - Removed support for `reverse_order` (was never supported in Rails 5)
 
-## 3.2.1
+## 3.2.1 (2018-02-21)
 
 - Added `minute_of_hour`
 - Added support for `unscoped`
 
-## 3.2.0
+## 3.2.0 (2017-01-30)
 
 - Added limited support for SQLite
 
-## 3.1.1
+## 3.1.1 (2016-10-25)
 
 - Fixed `current: false`
 - Fixed `last` with `group_by_quarter`
 - Raise `ArgumentError` when `last` option is not supported
 
-## 3.1.0
+## 3.1.0 (2016-10-22)
 
 - Better support for date columns with `time_zone: false`
 - Better date range handling for `range` option
 
-## 3.0.2
+## 3.0.2 (2016-08-09)
 
 - Fixed `group_by_period` with associations
 - Fixed `week_start` option for enumerables
 
-## 3.0.1
+## 3.0.1 (2016-07-13)
 
 - Added support for Redshift
 - Fix for infinite loop in certain cases for Rails 5
 
-## 3.0.0
+## 3.0.0 (2016-05-30)
 
 Breaking changes
 
@@ -80,16 +113,16 @@ Breaking changes
 - Array and hash methods no longer return the entire series by default. Use `series: true` for the previous behavior.
 - The `series: false` option now returns the correct types and order, and plays nicely with other options.
 
-## 2.5.3
+## 2.5.3 (2016-04-28)
 
 - All tests green with `mysql` gem
 - Added support for decimal day start
 
-## 2.5.2
+## 2.5.2 (2016-02-16)
 
 - Added `dates` option to return dates for day, week, month, quarter, and year
 
-## 2.5.1
+## 2.5.1 (2016-02-03)
 
 - Added `group_by_quarter`
 - Added `default_value` option
@@ -97,13 +130,13 @@ Breaking changes
 - Raise `ArgumentError` if no field specified
 - Added support for ActiveRecord 5 beta
 
-## 2.5.0
+## 2.5.0 (2015-09-29)
 
 - Added `group_by_period` method
 - Added `current` option
 - Raise `ArgumentError` if no block given to enumerable
 
-## 2.4.0
+## 2.4.0 (2014-12-28)
 
 - Added localization
 - Added `carry_forward` option
@@ -111,77 +144,77 @@ Breaking changes
 - Fixed issue w/ Brasilia Summer Time
 - Fixed issues w/ ActiveRecord 4.2
 
-## 2.3.0
+## 2.3.0 (2014-08-31)
 
 - Raise error when ActiveRecord::Base.default_timezone is not `:utc`
 - Added `day_of_month`
 - Added `month_of_year`
 - Do not quote column name
 
-## 2.2.1
+## 2.2.1 (2014-06-23)
 
 - Fixed ActiveRecord 3 associations
 
-## 2.2.0
+## 2.2.0 (2014-06-22)
 
 - Added support for arrays and hashes
 
-## 2.1.1
+## 2.1.1 (2014-05-17)
 
 - Fixed format option with multiple groups
 - Better error message if time zone support is missing for MySQL
 
-## 2.1.0
+## 2.1.0 (2014-03-16)
 
 - Added last option
 - Added format option
 
-## 2.0.4
+## 2.0.4 (2014-03-12)
 
 - Added multiple groups
 - Added order
 - Subsequent methods no longer modify relation
 
-## 2.0.3
+## 2.0.3 (2014-03-11)
 
 - Implemented respond_to?
 
-## 2.0.2
+## 2.0.2 (2014-03-11)
 
 - where, joins, and includes no longer need to be before the group_by method
 
-## 2.0.1
+## 2.0.1 (2014-03-07)
 
 - Use time zone instead of UTC for results
 
-## 2.0.0
+## 2.0.0 (2014-03-07)
 
 - Returns entire series by default
 - Added day_start option
 - Better interface
 
-## 1.0.5
+## 1.0.5 (2014-03-06)
 
 - Added global time_zone option
 
-## 1.0.4
+## 1.0.4 (2013-07-20)
 
 - Added global week_start option
 - Fixed bug with NULL values and series
 
-## 1.0.3
+## 1.0.3 (2013-07-05)
 
 - Fixed deprecation warning when used with will_paginate
 - Fixed bug with DateTime series
 
-## 1.0.2
+## 1.0.2 (2013-06-10)
 
 - Added :start option for custom week start for group_by_week
 
-## 1.0.1
+## 1.0.1 (2013-06-03)
 
 - Fixed series for Rails < 3.2 and MySQL
 
-## 1.0.0
+## 1.0.0 (2013-05-15)
 
 - First major release

data/LICENSE.txt

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

data/README.md

@@ -32,9 +32,9 @@ For MySQL and SQLite, also follow [these instructions](#additional-instructions)
 ```ruby
 User.group_by_day(:created_at).count
 # {
-#   Sat, 28 May 2016 => 50,
-#   Sun, 29 May 2016 => 100,
-#   Mon, 30 May 2016 => 34
+#   Sat, 24 May 2020 => 50,
+#   Sun, 25 May 2020 => 100,
+#   Mon, 26 May 2020 => 34
 # }
 ```
 
@@ -53,13 +53,14 @@ You can group by:
 
 and
 
+- minute_of_hour
 - hour_of_day
 - day_of_week (Sunday = 0, Monday = 1, etc)
 - day_of_month
 - day_of_year
 - month_of_year
 
-Use it anywhere you can use `group`. Works with `count`, `sum`, `minimum`, `maximum`, and `average`. For `median`, check out [ActiveMedian](https://github.com/ankane/active_median).
+Use it anywhere you can use `group`. Works with `count`, `sum`, `minimum`, `maximum`, and `average`. For `median` and `percentile`, check out [ActiveMedian](https://github.com/ankane/active_median).
 
 ### Time Zones
 
@@ -74,9 +75,9 @@ or
 ```ruby
 User.group_by_week(:created_at, time_zone: "Pacific Time (US & Canada)").count
 # {
-#   Sun, 06 Mar 2016 => 70,
-#   Sun, 13 Mar 2016 => 54,
-#   Sun, 20 Mar 2016 => 80
+#   Sun, 08 Mar 2020 => 70,
+#   Sun, 15 Mar 2020 => 54,
+#   Sun, 22 Mar 2020 => 80
 # }
 ```
 
@@ -87,13 +88,13 @@ Time zone objects also work. To see a list of available time zones in Rails, run
 Weeks start on Sunday by default. Change this with:
 
 ```ruby
-Groupdate.week_start = :mon # first three letters of day
+Groupdate.week_start = :monday
 ```
 
 or
 
 ```ruby
-User.group_by_week(:created_at, week_start: :mon).count
+User.group_by_week(:created_at, week_start: :monday).count
 ```
 
 ### Day Start
@@ -147,8 +148,8 @@ To get keys in a different format, use:
 ```ruby
 User.group_by_month(:created_at, format: "%b %Y").count
 # {
-#   "Jan 2015" => 10
-#   "Feb 2015" => 12
+#   "Jan 2020" => 10
+#   "Feb 2020" => 12
 # }
 ```
 
@@ -193,6 +194,14 @@ User.group_by_period(params[:period], :created_at, permit: ["day", "week"]).coun
 
 Raises an `ArgumentError` for unpermitted periods.
 
+### Custom Duration
+
+To group by a specific number of minutes or seconds, use:
+
+```ruby
+User.group_by_minute(:created_at, n: 10).count # 10 minutes
+```
+
 ### Date Columns
 
 If grouping on date columns which don’t need time zone conversion, use:
@@ -226,23 +235,23 @@ Supports the same options as above
 users.group_by_day(time_zone: time_zone) { |u| u.created_at }
 ```
 
-Count
+Get the entire series with:
 
 ```ruby
-users.group_by_day { |u| u.created_at }.map { |k, v| [k, v.size] }.to_h
+users.group_by_day(series: true) { |u| u.created_at }
 ```
 
-Get the entire series with:
+Count
 
 ```ruby
-users.group_by_day(series: true) { |u| u.created_at }
+users.group_by_day { |u| u.created_at }.map { |k, v| [k, v.count] }.to_h
 ```
 
 ## Additional Instructions
 
 ### For MySQL
 
-[Time zone support](https://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html) must be installed on the server.
+[Time zone support](https://dev.mysql.com/doc/refman/8.0/en/time-zone-support.html) must be installed on the server.
 
 ```sh
 mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -u root mysql
@@ -263,7 +272,7 @@ It should return the time instead of `NULL`.
 Groupdate has limited support for SQLite.
 
 - No time zone support
-- No `day_start` or `week_start` options
+- No `day_start` option
 - No `group_by_quarter` method
 
 If your application’s time zone is set to something other than `Etc/UTC` (the default), create an initializer with:
@@ -274,36 +283,18 @@ 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
+### 5.0
 
-Groupdate 3.0 brings a number of improvements. Here are a few to be aware of:
+Groupdate 5.0 brings a number of improvements. Here are a few to be aware of:
 
-- `Date` objects are now returned for day, week, month, quarter, and year by default. Use `dates: false` for the previous behavior, or change this globally with `Groupdate.dates = false`.
-- Array and hash methods no longer return the entire series by default. Use `series: true` for the previous behavior.
-- The `series: false` option now returns the correct type and order, and plays nicely with other options.
-
-### 2.0
-
-Groupdate 2.0 brings a number of improvements. Here are two things to be aware of:
-
-- the entire series is returned by default
-- `ActiveSupport::TimeWithZone` keys are now returned for every database adapter - adapters previously returned `Time` or `String` keys
+- The `week_start` option is now supported for SQLite
+- The `day_start` option is now consistent between Active Record and enumerable
+- Deprecated positional arguments for time zone and range have been removed
 
 ## History
 
 View the [changelog](https://github.com/ankane/groupdate/blob/master/CHANGELOG.md)
 
-Groupdate follows [Semantic Versioning](https://semver.org/)
-
 ## Contributing
 
 Everyone is encouraged to help improve this project. Here are a few ways you can help:

data/lib/groupdate.rb

@@ -1,9 +1,12 @@
+# dependencies
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/time"
-require "groupdate/version"
+
+# modules
+require "groupdate/magic"
 require "groupdate/relation_builder"
 require "groupdate/series_builder"
-require "groupdate/magic"
+require "groupdate/version"
 
 module Groupdate
   class Error < RuntimeError; end
@@ -12,7 +15,7 @@ module Groupdate
   METHODS = PERIODS.map { |v| :"group_by_#{v}" } + [:group_by_period]
 
   mattr_accessor :week_start, :day_start, :time_zone, :dates
-  self.week_start = :sun
+  self.week_start = :sunday
   self.day_start = 0
   self.dates = true
 

data/lib/groupdate/enumerable.rb

@@ -1,31 +1,25 @@
 module Enumerable
   Groupdate::PERIODS.each do |period|
-    define_method :"group_by_#{period}" do |*args, &block|
+    define_method :"group_by_#{period}" do |*args, **options, &block|
       if block
-        Groupdate::Magic::Enumerable.group_by(self, period, args[0] || {}, &block)
+        raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0)" if args.any?
+        Groupdate::Magic::Enumerable.group_by(self, period, options, &block)
       elsif respond_to?(:scoping)
-        scoping { @klass.send(:"group_by_#{period}", *args, &block) }
+        scoping { @klass.group_by_period(period, *args, **options, &block) }
       else
         raise ArgumentError, "no block given"
       end
     end
   end
 
-  def group_by_period(*args, &block)
+  def group_by_period(period, *args, **options, &block)
     if block || !respond_to?(:scoping)
-      period = args[0]
-      options = args[1] || {}
+      raise ArgumentError, "wrong number of arguments (given #{args.size + 1}, expected 1)" if args.any?
 
-      options = options.dup
-      # to_sym is unsafe on user input, so convert to strings
-      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
-        raise ArgumentError, "Unpermitted period"
-      end
+      Groupdate::Magic.validate_period(period, options.delete(:permit))
+      send("group_by_#{period}", **options, &block)
     else
-      scoping { @klass.send(:group_by_period, *args, &block) }
+      scoping { @klass.group_by_period(period, *args, **options, &block) }
     end
   end
 end

data/lib/groupdate/magic.rb

@@ -2,18 +2,52 @@ require "i18n"
 
 module Groupdate
   class Magic
-    attr_accessor :period, :options, :group_index
+    DAYS = [:monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday]
+
+    attr_accessor :period, :options, :group_index, :n_seconds
 
     def initialize(period:, **options)
       @period = period
       @options = options
 
-      unknown_keywords = options.keys - [:day_start, :time_zone, :dates, :series, :week_start, :format, :locale, :range, :reverse]
+      validate_keywords
+      validate_arguments
+
+      if options[:n]
+        raise ArgumentError, "n must be a positive integer" if !options[:n].is_a?(Integer) || options[:n] < 1
+        @period = :custom
+        @n_seconds = options[:n].to_i
+        @n_seconds *= 60 if period == :minute
+      end
+    end
+
+    def validate_keywords
+      known_keywords = [:time_zone, :dates, :series, :format, :locale, :range, :reverse]
+
+      if %i[week day_of_week].include?(period)
+        known_keywords << :week_start
+      end
+
+      if %i[day week month quarter year day_of_week hour_of_day day_of_month day_of_year month_of_year].include?(period)
+        known_keywords << :day_start
+      else
+        # prevent Groupdate.day_start from applying
+        @day_start = 0
+      end
+
+      if %i[second minute].include?(period)
+        known_keywords << :n
+      end
+
+      unknown_keywords = options.keys - known_keywords
       raise ArgumentError, "unknown keywords: #{unknown_keywords.join(", ")}" if unknown_keywords.any?
+    end
 
-      raise Groupdate::Error, "Unrecognized time zone" unless time_zone
-      raise Groupdate::Error, "Unrecognized :week_start option" if period == :week && !week_start
-      raise Groupdate::Error, "Cannot use endless range for :range option" if options[:range].is_a?(Range) && !options[:range].end
+    def validate_arguments
+      # TODO better messages
+      raise ArgumentError, "Unrecognized time zone" unless time_zone
+      raise ArgumentError, "Unrecognized :week_start option" unless week_start
+      raise ArgumentError, ":day_start must be between 0 and 24" if (day_start / 3600) < 0 || (day_start / 3600) >= 24
     end
 
     def time_zone
@@ -25,7 +59,10 @@ module Groupdate
     end
 
     def week_start
-      @week_start ||= [:mon, :tue, :wed, :thu, :fri, :sat, :sun].index((options[:week_start] || options[:start] || Groupdate.week_start).to_sym)
+      @week_start ||= begin
+        v = (options[:week_start] || Groupdate.week_start).to_sym
+        DAYS.index(v) || [:mon, :tue, :wed, :thu, :fri, :sat, :sun].index(v)
+      end
     end
 
     def day_start
@@ -39,7 +76,8 @@ module Groupdate
           period: period,
           time_zone: time_zone,
           day_start: day_start,
-          week_start: week_start
+          week_start: week_start,
+          n_seconds: n_seconds
         )
     end
 
@@ -47,6 +85,11 @@ module Groupdate
       series_builder.time_range
     end
 
+    def self.validate_period(period, permit)
+      permitted_periods = ((permit || Groupdate::PERIODS).map(&:to_sym) & Groupdate::PERIODS).map(&:to_s)
+      raise ArgumentError, "Unpermitted period" unless permitted_periods.include?(period.to_s)
+    end
+
     class Enumerable < Magic
       def group_by(enum, &_block)
         group = enum.group_by do |v|
@@ -85,10 +128,10 @@ module Groupdate
       def cast_method
         @cast_method ||= begin
           case period
+          when :minute_of_hour, :hour_of_day, :day_of_month, :day_of_year, :month_of_year
+            lambda { |k| k.to_i }
           when :day_of_week
             lambda { |k| (k.to_i - 1 - week_start) % 7 }
-          when :hour_of_day, :day_of_month, :day_of_year, :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) }
@@ -142,7 +185,8 @@ module Groupdate
             time_zone: magic.time_zone,
             time_range: magic.time_range,
             week_start: magic.week_start,
-            day_start: magic.day_start
+            day_start: magic.day_start,
+            n_seconds: magic.n_seconds
           ).generate
 
         # add Groupdate info

data/lib/groupdate/query_methods.rb

@@ -1,25 +1,18 @@
 module Groupdate
   module QueryMethods
     Groupdate::PERIODS.each do |period|
-      define_method :"group_by_#{period}" do |field, time_zone = nil, range = nil, **options|
+      define_method :"group_by_#{period}" do |field, **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
+      Groupdate::Magic.validate_period(period, permit)
+      send("group_by_#{period}", field, **options)
     end
   end
 end

data/lib/groupdate/relation_builder.rb

@@ -1,8 +1,11 @@
 module Groupdate
   class RelationBuilder
-    attr_reader :period, :column, :day_start, :week_start
+    attr_reader :period, :column, :day_start, :week_start, :n_seconds
+
+    def initialize(relation, column:, period:, time_zone:, time_range:, week_start:, day_start:, n_seconds:)
+      # very important
+      validate_column(column)
 
-    def initialize(relation, column:, period:, time_zone:, time_range:, week_start:, day_start:)
       @relation = relation
       @column = resolve_column(relation, column)
       @period = period
@@ -10,6 +13,7 @@ module Groupdate
       @time_range = time_range
       @week_start = week_start
       @day_start = day_start
+      @n_seconds = n_seconds
 
       if relation.default_timezone == :local
         raise Groupdate::Error, "ActiveRecord::Base.default_timezone must be :utc to use Groupdate"
@@ -27,24 +31,28 @@ module Groupdate
       adapter_name = @relation.connection.adapter_name
       query =
         case adapter_name
-        when "MySQL", "Mysql2", "Mysql2Spatial", 'Mysql2Rgeo'
+        when "Mysql2", "Mysql2Spatial", "Mysql2Rgeo"
+          day_start_column = "CONVERT_TZ(#{column}, '+00:00', ?) - INTERVAL ? second"
+
           case period
-          when :day_of_week
-            ["DAYOFWEEK(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?)) - 1", time_zone]
-          when :day_of_year
-            ["DAYOFYEAR(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?))", 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]
+            ["MINUTE(#{day_start_column})", time_zone, day_start]
+          when :hour_of_day
+            ["HOUR(#{day_start_column})", time_zone, day_start]
+          when :day_of_week
+            ["DAYOFWEEK(#{day_start_column}) - 1", time_zone, day_start]
           when :day_of_month
-            ["DAYOFMONTH(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?))", time_zone]
+            ["DAYOFMONTH(#{day_start_column})", time_zone, day_start]
+          when :day_of_year
+            ["DAYOFYEAR(#{day_start_column})", time_zone, day_start]
           when :month_of_year
-            ["MONTH(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?))", time_zone]
+            ["MONTH(#{day_start_column})", time_zone, day_start]
           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]
+            ["CONVERT_TZ(DATE_FORMAT(#{day_start_column} - INTERVAL ((? + DAYOFWEEK(#{day_start_column})) % 7) DAY, '%Y-%m-%d 00:00:00') + INTERVAL ? second, ?, '+00:00')", time_zone, day_start, 12 - week_start, time_zone, day_start, day_start, 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]
+            ["CONVERT_TZ(DATE_FORMAT(DATE(CONCAT(YEAR(#{day_start_column}), '-', LPAD(1 + 3 * (QUARTER(#{day_start_column}) - 1), 2, '00'), '-01')), '%Y-%m-%d %H:%i:%S') + INTERVAL ? second, ?, '+00:00')", time_zone, day_start, time_zone, day_start, day_start, time_zone]
+          when :custom
+            ["FROM_UNIXTIME((UNIX_TIMESTAMP(#{column}) DIV ?) * ?)", n_seconds, n_seconds]
           else
             format =
               case period
@@ -62,49 +70,60 @@ module Groupdate
                 "%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]
+            ["CONVERT_TZ(DATE_FORMAT(#{day_start_column}, ?) + INTERVAL ? second, ?, '+00:00')", time_zone, day_start, format, day_start, time_zone]
           end
         when "PostgreSQL", "PostGIS"
+          day_start_column = "#{column}::timestamptz AT TIME ZONE ? - INTERVAL ?"
+          day_start_interval = "#{day_start} second"
+
           case period
-          when :day_of_week
-            ["EXTRACT(DOW from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :day_of_year
-            ["EXTRACT(DOY 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]
+            ["EXTRACT(MINUTE FROM #{day_start_column})::integer", time_zone, day_start_interval]
+          when :hour_of_day
+            ["EXTRACT(HOUR FROM #{day_start_column})::integer", time_zone, day_start_interval]
+          when :day_of_week
+            ["EXTRACT(DOW FROM #{day_start_column})::integer", time_zone, day_start_interval]
           when :day_of_month
-            ["EXTRACT(DAY from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
+            ["EXTRACT(DAY FROM #{day_start_column})::integer", time_zone, day_start_interval]
+          when :day_of_year
+            ["EXTRACT(DOY FROM #{day_start_column})::integer", time_zone, day_start_interval]
           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]
+            ["EXTRACT(MONTH FROM #{day_start_column})::integer", time_zone, day_start_interval]
+          when :week
+            ["(DATE_TRUNC('day', #{day_start_column} - INTERVAL '1 day' * ((? + EXTRACT(DOW FROM #{day_start_column})::integer) % 7)) + INTERVAL ?) AT TIME ZONE ?", time_zone, day_start_interval, 13 - week_start, time_zone, day_start_interval, day_start_interval, time_zone]
+          when :custom
+            ["TO_TIMESTAMP(FLOOR(EXTRACT(EPOCH FROM #{column}::timestamptz) / ?) * ?)", n_seconds, n_seconds]
           else
-            ["(DATE_TRUNC('#{period}', (#{column}::timestamptz - INTERVAL '#{day_start} second') AT TIME ZONE ?) + INTERVAL '#{day_start} second') AT TIME ZONE ?", time_zone, time_zone]
+            if day_start == 0
+              # prettier
+              ["DATE_TRUNC(?, #{day_start_column}) AT TIME ZONE ?", period, time_zone, day_start_interval, time_zone]
+            else
+              ["(DATE_TRUNC(?, #{day_start_column}) + INTERVAL ?) AT TIME ZONE ?", period, time_zone, day_start_interval, day_start_interval, time_zone]
+            end
           end
         when "SQLite"
           raise Groupdate::Error, "Time zones not supported for SQLite" unless @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')"]
+            ["strftime('%Y-%m-%d 00:00:00 UTC', #{column}, '-6 days', ?)", "weekday #{(week_start + 1) % 7}"]
+          elsif period == :custom
+            ["datetime((strftime('%s', #{column}) / ?) * ?, 'unixepoch')", n_seconds, n_seconds]
           else
             format =
               case period
-              when :hour_of_day
-                "%H"
               when :minute_of_hour
                 "%M"
+              when :hour_of_day
+                "%H"
               when :day_of_week
                 "%w"
               when :day_of_month
                 "%d"
-              when :month_of_year
-                "%m"
               when :day_of_year
                 "%j"
+              when :month_of_year
+                "%m"
               when :second
                 "%Y-%m-%d %H:%M:%S UTC"
               when :minute
@@ -121,39 +140,40 @@ module Groupdate
                 "%Y-01-01 00:00:00 UTC"
               end
 
-            ["strftime('#{format.gsub(/%/, '%%')}', #{column})"]
+            ["strftime(?, #{column})", format]
           end
         when "Redshift"
+          day_start_column = "CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL ?"
+          day_start_interval = "#{day_start} second"
+
           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]
+            ["EXTRACT(MINUTE from #{day_start_column})::integer", time_zone, day_start_interval]
+          when :hour_of_day
+            ["EXTRACT(HOUR from #{day_start_column})::integer", time_zone, day_start_interval]
+          when :day_of_week
+            ["EXTRACT(DOW from #{day_start_column})::integer", time_zone, day_start_interval]
           when :day_of_month
-            ["EXTRACT(DAY from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
+            ["EXTRACT(DAY from #{day_start_column})::integer", time_zone, day_start_interval]
           when :day_of_year
-            ["EXTRACT(DOY from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
+            ["EXTRACT(DOY from #{day_start_column})::integer", time_zone, day_start_interval]
           when :month_of_year
-            ["EXTRACT(MONTH from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
+            ["EXTRACT(MONTH from #{day_start_column})::integer", time_zone, day_start_interval]
           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]
+            week_start_interval = "#{week_start} day"
+            ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC('week', #{day_start_column} - INTERVAL ?) + INTERVAL ? + INTERVAL ?)::timestamp", time_zone, time_zone, day_start_interval, week_start_interval, week_start_interval, day_start_interval]
+          when :custom
+            raise Groupdate::Error, "Not implemented yet"
           else
-            ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC(?, CONVERT_TIMEZONE(?, #{column}) - INTERVAL '#{day_start} second'))::timestamp + INTERVAL '#{day_start} second'", time_zone, period, time_zone]
+            ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC(?, #{day_start_column}) + INTERVAL ?)::timestamp", time_zone, period, time_zone, day_start_interval, day_start_interval]
           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
-
       clause = @relation.send(:sanitize_sql_array, query)
 
       # cleaner queries in logs
@@ -166,22 +186,35 @@ module Groupdate
     end
 
     def clean_group_clause_mysql(clause)
-      clause = clause.gsub("DATE_SUB(#{column}, INTERVAL 0 second)", "#{column}")
-      if clause.start_with?("DATE_ADD(") && clause.end_with?(", INTERVAL 0 second)")
-        clause = clause[9..-21]
-      end
-      clause
+      clause.gsub(/ (\-|\+) INTERVAL 0 second/, "")
     end
 
     def where_clause
       if @time_range.is_a?(Range)
-        op = @time_range.exclude_end? ? "<" : "<="
-        ["#{column} >= ? AND #{column} #{op} ?", @time_range.first, @time_range.last]
+        if @time_range.end
+          op = @time_range.exclude_end? ? "<" : "<="
+          if @time_range.begin
+            ["#{column} >= ? AND #{column} #{op} ?", @time_range.begin, @time_range.end]
+          else
+            ["#{column} #{op} ?", @time_range.end]
+          end
+        else
+          ["#{column} >= ?", @time_range.begin]
+        end
       else
         ["#{column} IS NOT NULL"]
       end
     end
 
+    # basic version of Active Record disallow_raw_sql!
+    # symbol = column (safe), Arel node = SQL (safe), other = untrusted
+    def validate_column(column)
+      # matches table.column and column
+      unless column.is_a?(Symbol) || column.is_a?(Arel::Nodes::SqlLiteral) || /\A\w+(\.\w+)?\z/i.match(column.to_s)
+        warn "[groupdate] Non-attribute argument: #{column}. Use Arel.sql() for known-safe values. This will raise an error in Groupdate 6"
+      end
+    end
+
     # resolves eagerly
     # need to convert both where_clause (easy)
     # and group_clause (not easy) if want to avoid this

data/lib/groupdate/series_builder.rb

@@ -1,29 +1,64 @@
 module Groupdate
   class SeriesBuilder
-    attr_reader :period, :time_zone, :day_start, :week_start, :options
+    attr_reader :period, :time_zone, :day_start, :week_start, :n_seconds, :options
 
     CHECK_PERIODS = [:day, :week, :month, :quarter, :year]
 
-    def initialize(period:, time_zone:, day_start:, week_start:, **options)
+    def initialize(period:, time_zone:, day_start:, week_start:, n_seconds:, **options)
       @period = period
       @time_zone = time_zone
       @week_start = week_start
       @day_start = day_start
+      @n_seconds = n_seconds
       @options = options
-      @round_time = {}
+      @week_start_key = Groupdate::Magic::DAYS[@week_start] if @week_start
     end
 
     def generate(data, default_value:, series_default: true, multiple_groups: false, group_index: nil)
       series = generate_series(data, multiple_groups, group_index)
       series = handle_multiple(data, series, multiple_groups, group_index)
 
+      verified_data = {}
+      series.each do |k|
+        verified_data[k] = data.delete(k)
+      end
+
+      # this is a fun one
+      # PostgreSQL and Ruby both return the 2nd hour when converting/parsing a backward DST change
+      # Other databases and Active Support return the 1st hour (as expected)
+      # Active Support good: ActiveSupport::TimeZone["America/Los_Angeles"].parse("2013-11-03 01:00:00")
+      # MySQL good: SELECT CONVERT_TZ('2013-11-03 01:00:00', 'America/Los_Angeles', 'Etc/UTC');
+      # Ruby not good: Time.parse("2013-11-03 01:00:00")
+      # PostgreSQL not good: SELECT '2013-11-03 01:00:00'::timestamp AT TIME ZONE 'America/Los_Angeles';
+      # we need to account for this here
+      if series_default && CHECK_PERIODS.include?(period)
+        data.each do |k, v|
+          key = multiple_groups ? k[group_index] : k
+          # TODO only do this for PostgreSQL
+          # this may mask some inconsistent time zone errors
+          # but not sure there's a better approach
+          if key.hour == (key - 1.hour).hour && series.include?(key - 1.hour)
+            key -= 1.hour
+            if multiple_groups
+              k[group_index]  = key
+            else
+              k = key
+            end
+            verified_data[k] = v
+          elsif key != round_time(key)
+            # only need to show what database returned since it will cast in Ruby time zone
+            raise Groupdate::Error, "Database and Ruby have inconsistent time zone info. Database returned #{key}"
+          end
+        end
+      end
+
       unless entire_series?(series_default)
-        series = series.select { |k| data[k] }
+        series = series.select { |k| verified_data[k] }
       end
 
       value = 0
       result = Hash[series.map do |k|
-        value = data.delete(k) || (@options[:carry_forward] && value) || default_value
+        value = verified_data[k] || (@options[:carry_forward] && value) || default_value
         key =
           if multiple_groups
             k[0...group_index] + [key_format.call(k[group_index])] + k[(group_index + 1)..-1]
@@ -34,20 +69,21 @@ module Groupdate
         [key, value]
       end]
 
-      # only check for database
-      # only checks remaining keys to avoid expensive calls to round_time
-      if series_default && CHECK_PERIODS.include?(period)
-        check_consistent_time_zone_info(data, multiple_groups, group_index)
-      end
-
       result
     end
 
     def round_time(time)
+      if period == :custom
+        return time_zone.at((time.to_time.to_i / n_seconds) * n_seconds)
+      end
+
       time = time.to_time.in_time_zone(time_zone)
 
-      # only if day_start != 0 for performance
-      time -= day_start.seconds if day_start != 0
+      if day_start != 0
+        # apply day_start to a time object that's not affected by DST
+        time = change_zone.call(time, utc)
+        time -= day_start.seconds
+      end
 
       time =
         case period
@@ -60,9 +96,7 @@ module Groupdate
         when :day
           time.beginning_of_day
         when :week
-          # same logic as MySQL group
-          weekday = (time.wday - 1) % 7
-          (time - ((7 - week_start + weekday) % 7).days).midnight
+          time.beginning_of_week(@week_start_key)
         when :month
           time.beginning_of_month
         when :quarter
@@ -74,7 +108,7 @@ module Groupdate
         when :minute_of_hour
           time.min
         when :day_of_week
-          (time.wday - 1 - week_start) % 7
+          time.days_to_week_start(@week_start_key)
         when :day_of_month
           time.day
         when :month_of_year
@@ -85,24 +119,62 @@ module Groupdate
           raise Groupdate::Error, "Invalid period"
         end
 
-      # only if day_start != 0 for performance
-      time += day_start.seconds if day_start != 0 && time.is_a?(Time)
+      if day_start != 0 && time.is_a?(Time)
+        time += day_start.seconds
+        time = change_zone.call(time, time_zone)
+      end
 
       time
     end
 
+    def change_zone
+      @change_zone ||= begin
+        if ActiveSupport::VERSION::STRING >= "5.2"
+          ->(time, zone) { time.change(zone: zone) }
+        else
+          # TODO make more efficient
+          ->(time, zone) { zone.parse(time.strftime("%Y-%m-%d %H:%M:%S")) }
+        end
+      end
+    end
+
     def time_range
       @time_range ||= begin
         time_range = options[:range]
-        if time_range.is_a?(Range) && time_range.first.is_a?(Date)
-          # convert range of dates to range of times
-          # use parsing instead of in_time_zone due to Rails < 4
-          last = time_zone.parse(time_range.last.to_s)
-          last += 1.day unless time_range.exclude_end?
-          time_range = Range.new(time_zone.parse(time_range.first.to_s), last, true)
+
+        if time_range.is_a?(Range)
+          # check types
+          [time_range.begin, time_range.end].each do |v|
+            case v
+            when nil, Date, Time
+              # good
+            when String
+              # TODO raise error in Groupdate 6
+              warn "[groupdate] Range bounds should be Date or Time, not #{v.class.name}. This will raise an error in Groupdate 6"
+              break
+            else
+              raise ArgumentError, "Range bounds should be Date or Time, not #{v.class.name}"
+            end
+          end
+
+          start = time_range.begin
+          start = start.in_time_zone(time_zone) if start
+
+          exclude_end = time_range.exclude_end?
+
+          finish = time_range.end
+          finish = finish.in_time_zone(time_zone) if finish
+          if time_range.end.is_a?(Date) && !exclude_end
+            finish += 1.day
+            exclude_end = true
+          end
+
+          time_range = Range.new(start, finish, exclude_end)
         elsif !time_range && options[:last]
           if period == :quarter
             step = 3.months
+          elsif period == :custom
+            step = n_seconds
           elsif 1.respond_to?(period)
             step = 1.send(period)
           else
@@ -119,7 +191,8 @@ module Groupdate
               if options[:current] == false
                 round_time(start_at - step)...round_time(now)
               else
-                round_time(start_at)..now
+                # extend to end of current period
+                round_time(start_at)...(round_time(now) + step)
               end
           end
         end
@@ -150,7 +223,7 @@ module Groupdate
       else
         time_range = self.time_range
         time_range =
-          if time_range.is_a?(Range)
+          if time_range.is_a?(Range) && time_range.begin && time_range.end
             time_range
           else
             # use first and last values
@@ -161,26 +234,41 @@ module Groupdate
                 data.keys.sort
               end
 
-            tr = sorted_keys.first..sorted_keys.last
-            if options[:current] == false && sorted_keys.any? && round_time(now) >= tr.last
-              tr = tr.first...round_time(now)
+            if time_range.is_a?(Range)
+              if sorted_keys.any?
+                if time_range.begin
+                  time_range.begin..sorted_keys.last
+                else
+                  Range.new(sorted_keys.first, time_range.end, time_range.exclude_end?)
+                end
+              else
+                nil..nil
+              end
+            else
+              tr = sorted_keys.first..sorted_keys.last
+              if options[:current] == false && sorted_keys.any? && round_time(now) >= tr.last
+                tr = tr.first...round_time(now)
+              end
+              tr
             end
-            tr
           end
 
-        if time_range.first
-          series = [round_time(time_range.first)]
+        if time_range.begin
+          series = [round_time(time_range.begin)]
 
           if period == :quarter
             step = 3.months
+          elsif period == :custom
+            step = n_seconds
           else
             step = 1.send(period)
           end
 
           last_step = series.last
+          day_start_hour = day_start / 3600
           loop do
             next_step = last_step + step
-            next_step = round_time(next_step) if next_step.hour != day_start # add condition to speed up
+            next_step = round_time(next_step) if next_step.hour != day_start_hour # add condition to speed up
             break unless time_range.cover?(next_step)
 
             if next_step == last_step
@@ -199,34 +287,36 @@ module Groupdate
     end
 
     def key_format
-      locale = options[:locale] || I18n.locale
-      use_dates = options.key?(:dates) ? options[:dates] : Groupdate.dates
+      @key_format ||= begin
+        locale = options[:locale] || I18n.locale
+        use_dates = options.key?(:dates) ? options[:dates] : Groupdate.dates
 
-      if options[:format]
-        if options[:format].respond_to?(:call)
-          options[:format]
-        else
-          sunday = time_zone.parse("2014-03-02 00:00:00")
-          lambda do |key|
-            case period
-            when :hour_of_day
-              key = sunday + key.hours + day_start.seconds
-            when :minute_of_hour
-              key = sunday + key.minutes + day_start.seconds
-            when :day_of_week
-              key = sunday + key.days + (week_start + 1).days
-            when :day_of_month
-              key = Date.new(2014, 1, key).to_time
-            when :month_of_year
-              key = Date.new(2014, key, 1).to_time
+        if options[:format]
+          if options[:format].respond_to?(:call)
+            options[:format]
+          else
+            sunday = time_zone.parse("2014-03-02 00:00:00")
+            lambda do |key|
+              case period
+              when :hour_of_day
+                key = sunday + key.hours + day_start.seconds
+              when :minute_of_hour
+                key = sunday + key.minutes + day_start.seconds
+              when :day_of_week
+                key = sunday + key.days + (week_start + 1).days
+              when :day_of_month
+                key = Date.new(2014, 1, key).to_time
+              when :month_of_year
+                key = Date.new(2014, key, 1).to_time
+              end
+              I18n.localize(key, format: options[:format], locale: locale)
             end
-            I18n.localize(key, format: options[:format], locale: locale)
           end
+        elsif [:day, :week, :month, :quarter, :year].include?(period) && use_dates
+          lambda { |k| k.to_date }
+        else
+          lambda { |k| k }
         end
-      elsif [:day, :week, :month, :quarter, :year].include?(period) && use_dates
-        lambda { |k| k.to_date }
-      else
-        lambda { |k| k }
       end
     end
 
@@ -246,23 +336,12 @@ module Groupdate
       end
     end
 
-    def check_consistent_time_zone_info(data, multiple_groups, group_index)
-      keys = data.keys
-      if multiple_groups
-        keys.map! { |k| k[group_index] }
-        keys.uniq!
-      end
-
-      keys.each do |key|
-        if key != round_time(key)
-          # only need to show what database returned since it will cast in Ruby time zone
-          raise Groupdate::Error, "Database and Ruby have inconsistent time zone info. Database returned #{key}"
-        end
-      end
-    end
-
     def entire_series?(series_default)
       options.key?(:series) ? options[:series] : series_default
     end
+
+    def utc
+      @utc ||= ActiveSupport::TimeZone["Etc/UTC"]
+    end
   end
 end

data/lib/groupdate/version.rb

@@ -1,3 +1,3 @@
 module Groupdate
-  VERSION = "4.2.0"
+  VERSION = "5.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: groupdate
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 5.2.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-28 00:00:00.000000000 Z
+date: 2020-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -160,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: The simplest way to group temporal data