groupdate 4.0.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d6b498ed092c226ed3e7eeec42f68ff8a4b092c1
-  data.tar.gz: a43c5abd7af5dcc458825c8e151184fc30d98626
+SHA256:
+  metadata.gz: edfe1e903c4ce720f5dfe74be0088937aa52b69f82dd88732802f49764205314
+  data.tar.gz: 85a0642b059de80a94ee621c028f117296e1baa09d93232ed6e97680b9d5fb25
 SHA512:
-  metadata.gz: c6379307ca9ef9c5d3435490bb61cea9d8afd15abd9c106aabbf55bb2e4d3d20f2dcd5f2e5e8e12cf338cb48c113d81ea2265e7085bce643b88a0011bd73c7f4
-  data.tar.gz: a1c6d9161d0051153b313b5501d3043df99de23105748e336a3c2446edeb5acfb3708be638c95cb23811205840f2dd2799f571124f369dbfbe562df70259087d
+  metadata.gz: f2c7f1f9d5cd73b00b89005a17d62897494deb51164ccb75cbf5b6917ce389cd2847c410f271c75118c74b17677d6fabb1ef0c327063c5b7de527ad46604e66d
+  data.tar.gz: c0a4f216150c83fa1cca7e8f10775b619da2b654b4a85e6f148bead6fe8fe82b1fd45b1741f89b7873e7c9c1ca6494f528b6cfbf41b4dda723b37c88b9d22cc2

data/.travis.yml

@@ -1,10 +1,10 @@
 language: ruby
 rvm:
   - 2.4.2
-  - jruby-9.1.5.0
+  - jruby-9.1.9.0
 gemfile:
   - Gemfile
-  - test/gemfiles/activerecord52.gemfile
+  - test/gemfiles/activerecord51.gemfile
   - test/gemfiles/activerecord50.gemfile
   - test/gemfiles/activerecord42.gemfile
 sudo: false
@@ -20,9 +20,7 @@ notifications:
     on_failure: change
 matrix:
   allow_failures:
-    - rvm: 2.4.2
-      gemfile: test/gemfiles/activerecord52.gemfile
-    - rvm: jruby-9.1.5.0
-      gemfile: test/gemfiles/activerecord52.gemfile
-    - rvm: jruby-9.1.5.0
-      gemfile: test/gemfiles/activerecord42.gemfile
+    - rvm: jruby-9.1.9.0
+      gemfile: Gemfile
+    - rvm: jruby-9.1.9.0
+      gemfile: test/gemfiles/activerecord51.gemfile

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 4.0.1
+
+- Fixed incorrect range with `last` option near time change
+
 ## 4.0.0
 
 - Custom calculation methods are supported by default - `groupdate_calculation_methods` is no longer needed

data/CONTRIBUTING.md

@@ -21,7 +21,10 @@ Think you’ve discovered an issue?
 gem "groupdate", github: "ankane/groupdate"
 ```
 
-If the above steps don’t help, create an issue. Include the complete backtrace for exceptions.
+If the above steps don’t help, create an issue. Include:
+
+- Detailed steps to reproduce
+- Complete backtraces for exceptions
 
 ## Pull Requests
 

data/Gemfile

@@ -3,4 +3,10 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in groupdate.gemspec
 gemspec
 
-gem "activerecord", "5.1.4" # "~> 5.1.0"
+gem "activerecord", "~> 5.2.0"
+
+if defined?(JRUBY_VERSION)
+  gem "activerecord-jdbcpostgresql-adapter", git: "https://github.com/jruby/activerecord-jdbc-adapter.git"
+  gem "activerecord-jdbcmysql-adapter", git: "https://github.com/jruby/activerecord-jdbc-adapter.git"
+  gem "activerecord-jdbcsqlite3-adapter", git: "https://github.com/jruby/activerecord-jdbc-adapter.git"
+end

data/README.md

@@ -218,7 +218,7 @@ gem 'groupdate'
 
 #### For MySQL
 
-[Time zone support](http://dev.mysql.com/doc/refman/5.6/en/time-zone-support.html) must be installed on the server.
+[Time zone support](https://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html) must be installed on the server.
 
 ```sh
 mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -u root mysql
@@ -278,7 +278,7 @@ Groupdate 2.0 brings a number of improvements.  Here are two things to be aware
 
 View the [changelog](https://github.com/ankane/groupdate/blob/master/CHANGELOG.md)
 
-Groupdate follows [Semantic Versioning](http://semver.org/)
+Groupdate follows [Semantic Versioning](https://semver.org/)
 
 ## Contributing
 

data/groupdate.gemspec

@@ -17,6 +17,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = ">= 2.2.0"
+
   spec.add_dependency "activesupport", ">= 4.2"
 
   spec.add_development_dependency "bundler"
@@ -30,7 +32,7 @@ Gem::Specification.new do |spec|
     spec.add_development_dependency "activerecord-jdbcsqlite3-adapter"
   else
     spec.add_development_dependency "pg", "< 1"
-    spec.add_development_dependency "mysql2"
+    spec.add_development_dependency "mysql2", "< 0.5"
     spec.add_development_dependency "sqlite3"
   end
 end

data/lib/groupdate.rb

@@ -1,6 +1,8 @@
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/time"
 require "groupdate/version"
+require "groupdate/relation_builder"
+require "groupdate/series_builder"
 require "groupdate/magic"
 
 module Groupdate

data/lib/groupdate/magic.rb

@@ -2,7 +2,7 @@ require "i18n"
 
 module Groupdate
   class Magic
-    attr_accessor :period, :options
+    attr_accessor :period, :options, :group_index
 
     def initialize(period:, **options)
       @period = period
@@ -15,8 +15,6 @@ module Groupdate
       raise Groupdate::Error, "Unrecognized :week_start option" if period == :week && !week_start
     end
 
-    protected
-
     def time_zone
       @time_zone ||= begin
         time_zone = "Etc/UTC" if options[:time_zone] == false
@@ -33,199 +31,25 @@ module Groupdate
       @day_start ||= ((options[:day_start] || Groupdate.day_start).to_f * 3600).round
     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)
-        elsif !time_range && options[:last]
-          if period == :quarter
-            step = 3.months
-          elsif 1.respond_to?(period)
-            step = 1.send(period)
-          else
-            raise ArgumentError, "Cannot use last option with #{period}"
-          end
-          if step
-            now = Time.now
-            # loop instead of multiply to change start_at - see #151
-            start_at = now
-            (options[:last].to_i - 1).times do
-              start_at -= step
-            end
-
-            time_range =
-              if options[:current] == false
-                round_time(start_at - step)...round_time(now)
-              else
-                round_time(start_at)..now
-              end
-          end
-        end
-        time_range
-      end
+    def series_builder
+      @series_builder ||=
+        SeriesBuilder.new(
+          **options,
+          period: period,
+          time_zone: time_zone,
+          day_start: day_start,
+          week_start: week_start
+        )
     end
 
-    def series(count, default_value, multiple_groups = false, reverse = false, series_default = true)
-      reverse = !reverse if options[:reverse]
-
-      series =
-        case period
-        when :day_of_week
-          0..6
-        when :hour_of_day
-          0..23
-        when :minute_of_hour
-          0..59
-        when :day_of_month
-          1..31
-        when :month_of_year
-          1..12
-        else
-          time_range = self.time_range
-          time_range =
-            if time_range.is_a?(Range)
-              time_range
-            else
-              # use first and last values
-              sorted_keys =
-                if multiple_groups
-                  count.keys.map { |k| k[@group_index] }.sort
-                else
-                  count.keys.sort
-                end
-              sorted_keys.first..sorted_keys.last
-            end
-
-          if time_range.first
-            series = [round_time(time_range.first)]
-
-            if period == :quarter
-              step = 3.months
-            else
-              step = 1.send(period)
-            end
-
-            last_step = series.last
-            while (next_step = round_time(last_step + step)) && time_range.cover?(next_step)
-              if next_step == last_step
-                last_step += step
-                next
-              end
-              series << next_step
-              last_step = next_step
-            end
-
-            series
-          else
-            []
-          end
-        end
-
-      series =
-        if multiple_groups
-          keys = count.keys.map { |k| k[0...@group_index] + k[(@group_index + 1)..-1] }.uniq
-          series = series.to_a.reverse if reverse
-          keys.flat_map do |k|
-            series.map { |s| k[0...@group_index] + [s] + k[@group_index..-1] }
-          end
-        else
-          series
-        end
-
-      # reversed above if multiple groups
-      series = series.to_a.reverse if !multiple_groups && reverse
-
-      locale = options[:locale] || I18n.locale
-      use_dates = options.key?(:dates) ? options[:dates] : Groupdate.dates
-      key_format =
-        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
-          end
-        elsif [:day, :week, :month, :quarter, :year].include?(period) && use_dates
-          lambda { |k| k.to_date }
-        else
-          lambda { |k| k }
-        end
-
-      use_series = options.key?(:series) ? options[:series] : series_default
-      if use_series == false
-        series = series.select { |k| count[k] }
-      end
-
-      value = 0
-      Hash[series.map do |k|
-        value = count[k] || (@options[:carry_forward] && value) || default_value
-        [multiple_groups ? k[0...@group_index] + [key_format.call(k[@group_index])] + k[(@group_index + 1)..-1] : key_format.call(k), value]
-      end]
-    end
-
-    def round_time(time)
-      time = time.to_time.in_time_zone(time_zone) - day_start.seconds
-
-      time =
-        case period
-        when :second
-          time.change(usec: 0)
-        when :minute
-          time.change(sec: 0)
-        when :hour
-          time.change(min: 0)
-        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
-        when :month
-          time.beginning_of_month
-        when :quarter
-          time.beginning_of_quarter
-        when :year
-          time.beginning_of_year
-        when :hour_of_day
-          time.hour
-        when :minute_of_hour
-          time.min
-        when :day_of_week
-          (time.wday - 1 - week_start) % 7
-        when :day_of_month
-          time.day
-        when :month_of_year
-          time.month
-        else
-          raise Groupdate::Error, "Invalid period"
-        end
-
-      time.is_a?(Time) ? time + day_start.seconds : time
+    def time_range
+      series_builder.time_range
     end
 
     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)
+        group = enum.group_by { |v| v = yield(v); v ? series_builder.round_time(v) : nil }
+        series_builder.generate(group, default_value: [], series_default: false)
       end
 
       def self.group_by(enum, period, options, &block)
@@ -239,191 +63,60 @@ module Groupdate
         @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
+      def perform(relation, result)
+        multiple_groups = relation.group_values.size > 1
 
-        if adapter_name == "MySQL" && period == :week
-          query[0] = "CAST(#{query[0]} AS DATETIME)"
-        end
+        check_time_zone_support(result, multiple_groups)
+        result = cast_result(result, multiple_groups)
 
-        group_str = relation.send(:sanitize_sql_array, query)
+        series_builder.generate(
+          result,
+          default_value: options.key?(:default_value) ? options[:default_value] : 0,
+          multiple_groups: multiple_groups,
+          group_index: group_index
+        )
+      end
 
-        # 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]
+      def 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
-
-        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
+      def cast_result(result, multiple_groups)
+        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] }]
+      end
 
-        missing_time_zone_support = multiple_groups ? (result.keys.first && result.keys.first[@group_index].nil?) : result.key?(nil)
+      def check_time_zone_support(result, multiple_groups)
+        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)
+        relation =
+          RelationBuilder.new(
+            relation,
+            column: field,
+            period: magic.period,
+            time_zone: magic.time_zone,
+            time_range: magic.time_range,
+            week_start: magic.week_start,
+            day_start: magic.day_start
+          ).generate
 
         # add Groupdate info
+        magic.group_index = relation.group_values.size - 1
         (relation.groupdate_values ||= []) << magic
 
         relation

data/lib/groupdate/relation_builder.rb

@@ -0,0 +1,177 @@
+module Groupdate
+  class RelationBuilder
+    attr_reader :period, :column, :day_start, :week_start
+
+    def initialize(relation, column:, period:, time_zone:, time_range:, week_start:, day_start:)
+      @relation = relation
+      @column = column
+      @period = period
+      @time_zone = time_zone
+      @time_range = time_range
+      @week_start = week_start
+      @day_start = day_start
+
+      if relation.default_timezone == :local
+        raise Groupdate::Error, "ActiveRecord::Base.default_timezone must be :utc to use Groupdate"
+      end
+    end
+
+    def generate
+      @relation.group(group_clause).where(*where_clause)
+    end
+
+    private
+
+    def group_clause
+      time_zone = @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 @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
+
+      clause = @relation.send(:sanitize_sql_array, query)
+
+      # cleaner queries in logs
+      clause = clean_group_clause_postgresql(clause)
+      clean_group_clause_mysql(clause)
+    end
+
+    def clean_group_clause_postgresql(clause)
+      clause.gsub(/ (\-|\+) INTERVAL '0 second'/, "")
+    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
+    end
+
+    def where_clause
+      if @time_range.is_a?(Range)
+        # doesn't matter whether we include the end of a ... range - it will be excluded later
+        ["#{column} >= ? AND #{column} <= ?", @time_range.first, @time_range.last]
+      else
+        ["#{column} IS NOT NULL"]
+      end
+    end
+  end
+end

data/lib/groupdate/series_builder.rb

@@ -0,0 +1,220 @@
+module Groupdate
+  class SeriesBuilder
+    attr_reader :period, :time_zone, :day_start, :week_start, :options
+
+    def initialize(period:, time_zone:, day_start:, week_start:, **options)
+      @period = period
+      @time_zone = time_zone
+      @week_start = week_start
+      @day_start = day_start
+      @options = options
+    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)
+
+      unless entire_series?(series_default)
+        series = series.select { |k| data[k] }
+      end
+
+      value = 0
+      Hash[series.map do |k|
+        value = 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]
+          else
+            key_format.call(k)
+          end
+
+        [key, value]
+      end]
+    end
+
+    def round_time(time)
+      time = time.to_time.in_time_zone(time_zone) - day_start.seconds
+
+      time =
+        case period
+        when :second
+          time.change(usec: 0)
+        when :minute
+          time.change(sec: 0)
+        when :hour
+          time.change(min: 0)
+        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
+        when :month
+          time.beginning_of_month
+        when :quarter
+          time.beginning_of_quarter
+        when :year
+          time.beginning_of_year
+        when :hour_of_day
+          time.hour
+        when :minute_of_hour
+          time.min
+        when :day_of_week
+          (time.wday - 1 - week_start) % 7
+        when :day_of_month
+          time.day
+        when :month_of_year
+          time.month
+        else
+          raise Groupdate::Error, "Invalid period"
+        end
+
+      time.is_a?(Time) ? time + day_start.seconds : time
+    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)
+        elsif !time_range && options[:last]
+          if period == :quarter
+            step = 3.months
+          elsif 1.respond_to?(period)
+            step = 1.send(period)
+          else
+            raise ArgumentError, "Cannot use last option with #{period}"
+          end
+          if step
+            now = time_zone.now
+            # loop instead of multiply to change start_at - see #151
+            start_at = now
+            (options[:last].to_i - 1).times do
+              start_at -= step
+            end
+
+            time_range =
+              if options[:current] == false
+                round_time(start_at - step)...round_time(now)
+              else
+                round_time(start_at)..now
+              end
+          end
+        end
+        time_range
+      end
+    end
+
+    private
+
+    def generate_series(data, multiple_groups, group_index)
+      case period
+      when :day_of_week
+        0..6
+      when :hour_of_day
+        0..23
+      when :minute_of_hour
+        0..59
+      when :day_of_month
+        1..31
+      when :month_of_year
+        1..12
+      else
+        time_range = self.time_range
+        time_range =
+          if time_range.is_a?(Range)
+            time_range
+          else
+            # use first and last values
+            sorted_keys =
+              if multiple_groups
+                data.keys.map { |k| k[group_index] }.sort
+              else
+                data.keys.sort
+              end
+            sorted_keys.first..sorted_keys.last
+          end
+
+        if time_range.first
+          series = [round_time(time_range.first)]
+
+          if period == :quarter
+            step = 3.months
+          else
+            step = 1.send(period)
+          end
+
+          last_step = series.last
+          while (next_step = round_time(last_step + step)) && time_range.cover?(next_step)
+            if next_step == last_step
+              last_step += step
+              next
+            end
+            series << next_step
+            last_step = next_step
+          end
+
+          series
+        else
+          []
+        end
+      end
+    end
+
+    def key_format
+      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
+            end
+            I18n.localize(key, format: options[:format], locale: locale)
+          end
+        end
+      elsif [:day, :week, :month, :quarter, :year].include?(period) && use_dates
+        lambda { |k| k.to_date }
+      else
+        lambda { |k| k }
+      end
+    end
+
+    def handle_multiple(data, series, multiple_groups, group_index)
+      reverse = options[:reverse]
+
+      if multiple_groups
+        keys = data.keys.map { |k| k[0...group_index] + k[(group_index + 1)..-1] }.uniq
+        series = series.to_a.reverse if reverse
+        keys.flat_map do |k|
+          series.map { |s| k[0...group_index] + [s] + k[group_index..-1] }
+        end
+      elsif reverse
+        series.to_a.reverse
+      else
+        series
+      end
+    end
+
+    def entire_series?(series_default)
+      options.key?(:series) ? options[:series] : series_default
+    end
+  end
+end

data/lib/groupdate/version.rb

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

data/test/gemfiles/activerecord42.gemfile

@@ -4,3 +4,9 @@ source 'https://rubygems.org'
 gemspec path: "../../"
 
 gem "activerecord", "~> 4.2.0"
+
+if defined?(JRUBY_VERSION)
+  gem "activerecord-jdbcpostgresql-adapter", "~> 1.3.24"
+  gem "activerecord-jdbcmysql-adapter", "~> 1.3.24"
+  gem "activerecord-jdbcsqlite3-adapter", "~> 1.3.24"
+end

data/test/gemfiles/activerecord50.gemfile

@@ -4,3 +4,9 @@ source 'https://rubygems.org'
 gemspec path: "../../"
 
 gem "activerecord", "~> 5.0.0"
+
+if defined?(JRUBY_VERSION)
+  gem "activerecord-jdbcpostgresql-adapter", "~> 50.0"
+  gem "activerecord-jdbcmysql-adapter", "~> 50.0"
+  gem "activerecord-jdbcsqlite3-adapter", "~> 50.0"
+end

data/test/gemfiles/activerecord51.gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in groupdate.gemspec
+gemspec path: "../../"
+
+gem "activerecord", "~> 5.1.0"
+
+if defined?(JRUBY_VERSION)
+  gem "activerecord-jdbcpostgresql-adapter" # no 51.0 yet
+  gem "activerecord-jdbcmysql-adapter", "~> 51.0"
+  gem "activerecord-jdbcsqlite3-adapter", "~> 51.0"
+end

data/test/test_helper.rb

@@ -201,7 +201,7 @@ module TestDatabase
 
   def test_last_date
     Time.zone = pt
-    today = Date.today
+    today = Time.zone.now.to_date
     create_user today.to_s
     this_month = pt.parse(today.to_s).beginning_of_month
     last_month = this_month - 1.month

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: groupdate
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.0.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-22 00:00:00.000000000 Z
+date: 2018-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -98,16 +98,16 @@ dependencies:
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -129,12 +129,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/ISSUE_TEMPLATE.md"
 - ".gitignore"
 - ".travis.yml"
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
-- ISSUE_TEMPLATE.md
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -145,11 +145,13 @@ files:
 - lib/groupdate/magic.rb
 - lib/groupdate/query_methods.rb
 - lib/groupdate/relation.rb
+- lib/groupdate/relation_builder.rb
+- lib/groupdate/series_builder.rb
 - lib/groupdate/version.rb
 - test/enumerable_test.rb
 - test/gemfiles/activerecord42.gemfile
 - test/gemfiles/activerecord50.gemfile
-- test/gemfiles/activerecord52.gemfile
+- test/gemfiles/activerecord51.gemfile
 - test/gemfiles/redshift.gemfile
 - test/mysql_test.rb
 - test/postgresql_test.rb
@@ -168,7 +170,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -176,7 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: The simplest way to group temporal data
@@ -184,7 +186,7 @@ test_files:
 - test/enumerable_test.rb
 - test/gemfiles/activerecord42.gemfile
 - test/gemfiles/activerecord50.gemfile
-- test/gemfiles/activerecord52.gemfile
+- test/gemfiles/activerecord51.gemfile
 - test/gemfiles/redshift.gemfile
 - test/mysql_test.rb
 - test/postgresql_test.rb

data/test/gemfiles/activerecord52.gemfile

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