groupdate 4.1.2 → 6.0.1

data/lib/groupdate/adapters/sqlite_adapter.rb

@@ -0,0 +1,51 @@
+module Groupdate
+  module Adapters
+    class SQLiteAdapter < BaseAdapter
+      def group_clause
+        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?
+
+        query =
+          if period == :week
+            ["strftime('%Y-%m-%d', #{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 :minute_of_hour
+                "%M"
+              when :hour_of_day
+                "%H"
+              when :day_of_week
+                "%w"
+              when :day_of_month
+                "%d"
+              when :day_of_year
+                "%j"
+              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"
+              when :month
+                "%Y-%m-01"
+              when :quarter
+                raise Groupdate::Error, "Quarter not supported for SQLite"
+              else # year
+                "%Y-01-01"
+              end
+
+            ["strftime(?, #{column})", format]
+          end
+
+        @relation.send(:sanitize_sql_array, query)
+      end
+    end
+  end
+end

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, :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,21 +59,38 @@ 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
       @day_start ||= ((options[:day_start] || Groupdate.day_start).to_f * 3600).round
     end
 
+    def range
+      @range ||= begin
+        time_range = options[:range]
+
+        if time_range.is_a?(Range) && time_range.begin.nil? && time_range.end.nil?
+          nil
+        else
+          time_range
+        end
+      end
+    end
+
     def series_builder
       @series_builder ||=
         SeriesBuilder.new(
           **options,
           period: period,
           time_zone: time_zone,
+          range: range,
           day_start: day_start,
-          week_start: week_start
+          week_start: week_start,
+          n_seconds: n_seconds
         )
     end
 
@@ -47,6 +98,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 +141,20 @@ 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, :month_of_year, :minute_of_hour
-            lambda { |k| k.to_i }
+          when :day, :week, :month, :quarter, :year
+            # TODO keep as date
+            if day_start != 0
+              day_start_hour = day_start / 3600
+              day_start_min = (day_start % 3600) / 60
+              day_start_sec = (day_start % 3600) % 60
+              lambda { |k| k.in_time_zone(time_zone).change(hour: day_start_hour, min: day_start_min, sec: day_start_sec) }
+            else
+              lambda { |k| k.in_time_zone(time_zone) }
+            end
           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) }
@@ -133,16 +199,25 @@ module Groupdate
       def self.generate_relation(relation, field:, **options)
         magic = Groupdate::Magic::Relation.new(**options)
 
+        adapter_name = relation.connection.adapter_name
+        adapter = Groupdate.adapters[adapter_name]
+        raise Groupdate::Error, "Connection adapter not supported: #{adapter_name}" unless adapter
+
+        # very important
+        column = validate_column(field)
+        column = resolve_column(relation, column)
+
         # generate ActiveRecord relation
         relation =
-          RelationBuilder.new(
+          adapter.new(
             relation,
-            column: field,
+            column: column,
             period: magic.period,
             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
@@ -152,6 +227,30 @@ module Groupdate
         relation
       end
 
+      class << self
+        # basic version of Active Record disallow_raw_sql!
+        # symbol = column (safe), Arel node = SQL (safe), other = untrusted
+        # matches table.column and column
+        def validate_column(column)
+          unless column.is_a?(Symbol) || column.is_a?(Arel::Nodes::SqlLiteral)
+            column = column.to_s
+            unless /\A\w+(\.\w+)?\z/i.match(column)
+              raise ActiveRecord::UnknownAttributeReference, "Query method called with non-attribute argument(s): #{column.inspect}. Use Arel.sql() for known-safe values."
+            end
+          end
+          column
+        end
+
+        # resolves eagerly
+        # need to convert both where_clause (easy)
+        # and group_clause (not easy) if want to avoid this
+        def resolve_column(relation, column)
+          node = relation.send(:relation).send(:arel_columns, [column]).first
+          node = Arel::Nodes::SqlLiteral.new(node) if node.is_a?(String)
+          relation.connection.visitor.accept(node, Arel::Collectors::SQLString.new).value
+        end
+      end
+
       # allow any options to keep flexible for future
       def self.process_result(relation, result, **options)
         relation.groupdate_values.reverse.each do |gv|

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.rb

@@ -9,6 +9,9 @@ module Groupdate
     end
 
     def calculate(*args, &block)
+      # prevent calculate from being called twice
+      return super if ActiveRecord::VERSION::STRING.to_f >= 6.1 && has_include?(args[1])
+
       default_value = [:count, :sum].include?(args[0]) ? 0 : nil
       Groupdate.process_result(self, super, default_value: default_value)
     end

data/lib/groupdate/series_builder.rb

@@ -1,29 +1,33 @@
 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
+
       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
+      result = series.to_h do |k|
+        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]
@@ -32,22 +36,23 @@ module Groupdate
           end
 
         [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 = time.change(zone: utc)
+        time -= day_start.seconds
+      end
 
       time =
         case period
@@ -60,9 +65,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,17 +77,21 @@ 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
           time.month
+        when :day_of_year
+          time.yday
         else
           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 = time.change(zone: time_zone)
+      end
 
       time
     end
@@ -92,15 +99,36 @@ module Groupdate
     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
+            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
@@ -117,7 +145,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
@@ -141,12 +170,14 @@ module Groupdate
         0..59
       when :day_of_month
         1..31
+      when :day_of_year
+        1..366
       when :month_of_year
         1..12
       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
@@ -157,26 +188,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
@@ -195,34 +241,35 @@ 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
 
-      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)
+          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
 
@@ -242,23 +289,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.1.2"
+  VERSION = "6.0.1"
 end