micro-lite-rb 0.0.1

data/groupdate-6.8.0/lib/groupdate/adapters/base_adapter.rb

@@ -0,0 +1,46 @@
+module Groupdate
+  module Adapters
+    class BaseAdapter
+      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:, adapter_name: nil)
+        @relation = relation
+        @column = column
+        @period = period
+        @time_zone = time_zone
+        @time_range = time_range
+        @week_start = week_start
+        @day_start = day_start
+        @n_seconds = n_seconds
+        @adapter_name = adapter_name
+
+        if ActiveRecord.default_timezone == :local
+          raise Groupdate::Error, "ActiveRecord.default_timezone must be :utc to use Groupdate"
+        end
+      end
+
+      def generate
+        @relation.group(group_clause).where(*where_clause)
+      end
+
+      private
+
+      def where_clause
+        if @time_range.is_a?(Range)
+          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
+    end
+  end
+end

data/groupdate-6.8.0/lib/groupdate/adapters/mysql_adapter.rb

@@ -0,0 +1,63 @@
+module Groupdate
+  module Adapters
+    class MySQLAdapter < BaseAdapter
+      def group_clause
+        time_zone = @time_zone.tzinfo.name
+        day_start_column = "CONVERT_TZ(#{column}, '+00:00', ?) - INTERVAL ? second"
+
+        query =
+          case period
+          when :minute_of_hour
+            ["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(#{day_start_column})", time_zone, day_start]
+          when :day_of_year
+            ["DAYOFYEAR(#{day_start_column})", time_zone, day_start]
+          when :month_of_year
+            ["MONTH(#{day_start_column})", time_zone, day_start]
+          when :week
+            ["CAST(DATE_FORMAT(#{day_start_column} - INTERVAL ((? + DAYOFWEEK(#{day_start_column})) % 7) DAY, '%Y-%m-%d') AS DATE)", time_zone, day_start, 12 - week_start, time_zone, day_start]
+          when :quarter
+            ["CAST(CONCAT(YEAR(#{day_start_column}), '-', LPAD(1 + 3 * (QUARTER(#{day_start_column}) - 1), 2, '00'), '-01') AS DATE)", time_zone, day_start, time_zone, day_start]
+          when :day, :month, :year
+            format =
+              case period
+              when :day
+                "%Y-%m-%d"
+              when :month
+                "%Y-%m-01"
+              else # year
+                "%Y-01-01"
+              end
+
+            ["CAST(DATE_FORMAT(#{day_start_column}, ?) AS DATE)", time_zone, day_start, format]
+          when :custom
+            ["FROM_UNIXTIME((UNIX_TIMESTAMP(#{column}) DIV ?) * ?)", n_seconds, n_seconds]
+          else
+            format =
+              case period
+              when :second
+                "%Y-%m-%d %H:%i:%S"
+              when :minute
+                "%Y-%m-%d %H:%i:00"
+              else # hour
+                "%Y-%m-%d %H:00:00"
+              end
+
+            ["CONVERT_TZ(DATE_FORMAT(#{day_start_column}, ?) + INTERVAL ? second, ?, '+00:00')", time_zone, day_start, format, day_start, time_zone]
+          end
+
+        clean_group_clause(@relation.send(:sanitize_sql_array, query))
+      end
+
+      def clean_group_clause(clause)
+        # zero quoted in Active Record 7+
+        clause.gsub(/ (\-|\+) INTERVAL 0 second/, "").gsub(/ (\-|\+) INTERVAL '0' second/, "")
+      end
+    end
+  end
+end

data/groupdate-6.8.0/lib/groupdate/adapters/postgresql_adapter.rb

@@ -0,0 +1,46 @@
+module Groupdate
+  module Adapters
+    class PostgreSQLAdapter < BaseAdapter
+      def group_clause
+        time_zone = @time_zone.tzinfo.name
+        day_start_column = "#{column}::timestamptz AT TIME ZONE ? - INTERVAL ?"
+        day_start_interval = "#{day_start} second"
+
+        query =
+          case period
+          when :minute_of_hour
+            ["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 #{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 #{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 ?)::date", time_zone, day_start_interval, 13 - week_start, time_zone, day_start_interval, day_start_interval]
+          when :custom
+            if @adapter_name == "Redshift"
+              ["TIMESTAMP 'epoch' + (FLOOR(EXTRACT(EPOCH FROM #{column}::timestamp) / ?) * ?) * INTERVAL '1 second'", n_seconds, n_seconds]
+            else
+              ["TO_TIMESTAMP(FLOOR(EXTRACT(EPOCH FROM #{column}::timestamptz) / ?) * ?)", n_seconds, n_seconds]
+            end
+          when :day, :month, :quarter, :year
+            ["DATE_TRUNC(?, #{day_start_column})::date", period, time_zone, day_start_interval]
+          else
+            # day start is always 0 for seconds, minute, hour
+            ["DATE_TRUNC(?, #{day_start_column}) AT TIME ZONE ?", period, time_zone, day_start_interval, time_zone]
+          end
+
+        clean_group_clause(@relation.send(:sanitize_sql_array, query))
+      end
+
+      def clean_group_clause(clause)
+        clause.gsub(/ (\-|\+) INTERVAL '0 second'/, "")
+      end
+    end
+  end
+end

data/groupdate-6.8.0/lib/groupdate/adapters/sqlite_adapter.rb

@@ -0,0 +1,86 @@
+module Groupdate
+  module Adapters
+    class SQLiteAdapter < BaseAdapter
+      def group_clause
+        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
+                nil
+              else # year
+                "%Y-01-01"
+              end
+
+            ["strftime(?, #{column})", format]
+          end
+
+        if period != :custom && (@time_zone != SeriesBuilder.utc || day_start != 0 || period == :quarter)
+          setup_function
+          week_start = period == :week ? Groupdate::Magic::DAYS[self.week_start].to_s : nil
+          query = ["groupdate_internal(?, #{column}, ?, ?, ?)", period, @time_zone.tzinfo.name, day_start, week_start]
+        end
+
+        @relation.send(:sanitize_sql_array, query)
+      end
+
+      private
+
+      def setup_function
+        @relation.connection_pool.with_connection do |connection|
+          raw_connection = connection.raw_connection
+          return if raw_connection.instance_variable_defined?(:@groupdate_function)
+
+          utc = SeriesBuilder.utc
+          date_periods = %i[day week month quarter year]
+
+          # note: this function is part of the internal API and may change between releases
+          # TODO improve performance
+          raw_connection.create_function("groupdate_internal", 4) do |func, period, value, time_zone, day_start, week_start|
+            if value.nil?
+              func.result = nil
+            else
+              period = period.to_sym
+              # cast_result handles week_start for day_of_week
+              week_start = :sunday if period == :day_of_week
+              result = SeriesBuilder.round_time(utc.parse(value), period, ActiveSupport::TimeZone[time_zone], day_start.to_i, week_start&.to_sym)
+              if date_periods.include?(period)
+                result = result.strftime("%Y-%m-%d")
+              elsif result.is_a?(Time)
+                result = result.in_time_zone(utc).strftime("%Y-%m-%d %H:%M:%S")
+              end
+              func.result = result
+            end
+          end
+          raw_connection.instance_variable_set(:@groupdate_function, true)
+        end
+      end
+    end
+  end
+end

data/groupdate-6.8.0/lib/groupdate/enumerable.rb

@@ -0,0 +1,25 @@
+module Enumerable
+  Groupdate::PERIODS.each do |period|
+    define_method :"group_by_#{period}" do |*args, **options, &block|
+      if 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.group_by_period(period, *args, **options, &block) }
+      else
+        raise ArgumentError, "no block given"
+      end
+    end
+  end
+
+  def group_by_period(period, *args, **options, &block)
+    if block || !respond_to?(:scoping)
+      raise ArgumentError, "wrong number of arguments (given #{args.size + 1}, expected 1)" if args.any?
+
+      Groupdate::Magic.validate_period(period, options.delete(:permit))
+      send("group_by_#{period}", **options, &block)
+    else
+      scoping { klass.group_by_period(period, *args, **options, &block) }
+    end
+  end
+end

data/groupdate-6.8.0/lib/groupdate/magic.rb

@@ -0,0 +1,269 @@
+require "i18n"
+
+module Groupdate
+  class Magic
+    DAYS = [:monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday]
+
+    attr_accessor :period, :options, :group_index, :n_seconds
+
+    def initialize(period:, **options)
+      @period = period
+      @options = options
+
+      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, :expand_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
+
+    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
+      @time_zone ||= begin
+        time_zone = "Etc/UTC" if options[:time_zone] == false
+        time_zone ||= options[:time_zone] || Groupdate.time_zone || (Groupdate.time_zone == false && "Etc/UTC") || Time.zone || "Etc/UTC"
+        time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone[time_zone]
+      end
+    end
+
+    def week_start
+      @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,
+          n_seconds: n_seconds
+        )
+    end
+
+    def time_range
+      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|
+          v = yield(v)
+          raise ArgumentError, "Not a time" unless v.respond_to?(:to_time)
+          series_builder.round_time(v)
+        end
+        series_builder.generate(group, default_value: [], series_default: false)
+      end
+
+      def self.group_by(enum, period, options, &block)
+        Groupdate::Magic::Enumerable.new(period: period, **options).group_by(enum, &block)
+      end
+    end
+
+    class Relation < Magic
+      def initialize(**options)
+        super(**options.reject { |k, _| [:default_value, :carry_forward, :last, :current].include?(k) })
+        @options = options
+      end
+
+      def perform(relation, result, default_value:)
+        if defined?(ActiveRecord::Promise) && result.is_a?(ActiveRecord::Promise)
+          return result.then { |r| perform(relation, r, default_value: default_value) }
+        end
+
+        multiple_groups = relation.group_values.size > 1
+
+        check_nils(result, multiple_groups, relation)
+        result = cast_result(result, multiple_groups)
+
+        series_builder.generate(
+          result,
+          default_value: options.key?(:default_value) ? options[:default_value] : default_value,
+          multiple_groups: multiple_groups,
+          group_index: group_index
+        )
+      end
+
+      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 :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) }
+          end
+        end
+      end
+
+      def cast_result(result, multiple_groups)
+        new_result = {}
+        result.each do |k, v|
+          if multiple_groups
+            k[group_index] = cast_method.call(k[group_index])
+          else
+            k = cast_method.call(k)
+          end
+          new_result[k] = v
+        end
+        new_result
+      end
+
+      def time_zone_support?(relation)
+        relation.connection_pool.with_connection do |connection|
+          if connection.adapter_name.match?(/mysql|trilogy/i)
+            sql = relation.send(:sanitize_sql_array, ["SELECT CONVERT_TZ(NOW(), '+00:00', ?)", time_zone.tzinfo.name])
+            !connection.select_all(sql).to_a.first.values.first.nil?
+          else
+            true
+          end
+        end
+      end
+
+      def check_nils(result, multiple_groups, relation)
+        has_nils = multiple_groups ? (result.keys.first && result.keys.first[group_index].nil?) : result.key?(nil)
+        if has_nils
+          if time_zone_support?(relation)
+            raise Groupdate::Error, "Invalid query - be sure to use a date or time column"
+          else
+            raise Groupdate::Error, "Database missing time zone support for #{time_zone.tzinfo.name} - see https://github.com/ankane/groupdate#for-mysql"
+          end
+        end
+      end
+
+      def self.generate_relation(relation, field:, **options)
+        magic = Groupdate::Magic::Relation.new(**options)
+
+        adapter_name = relation.connection_pool.with_connection { |c| c.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 =
+          adapter.new(
+            relation,
+            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,
+            n_seconds: magic.n_seconds,
+            adapter_name: adapter_name
+          ).generate
+
+        # add Groupdate info
+        magic.group_index = relation.group_values.size - 1
+        (relation.groupdate_values ||= []) << magic
+
+        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_pool.with_connection { |c| c.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|
+          result = gv.perform(relation, result, default_value: options[:default_value])
+        end
+        result
+      end
+    end
+  end
+end

data/groupdate-6.8.0/lib/groupdate/query_methods.rb

@@ -0,0 +1,18 @@
+module Groupdate
+  module QueryMethods
+    Groupdate::PERIODS.each do |period|
+      define_method :"group_by_#{period}" do |field, **options|
+        Groupdate::Magic::Relation.generate_relation(self,
+          period: period,
+          field: field,
+          **options
+        )
+      end
+    end
+
+    def group_by_period(period, field, permit: nil, **options)
+      Groupdate::Magic.validate_period(period, permit)
+      send("group_by_#{period}", field, **options)
+    end
+  end
+end

data/groupdate-6.8.0/lib/groupdate/relation.rb

@@ -0,0 +1,19 @@
+require "active_support/concern"
+
+module Groupdate
+  module Relation
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :groupdate_values
+    end
+
+    def calculate(*args, &block)
+      # prevent calculate from being called twice
+      return super if has_include?(args[1])
+
+      default_value = [:count, :sum].include?(args[0]) ? 0 : nil
+      Groupdate.process_result(self, super, default_value: default_value)
+    end
+  end
+end