micro-lite-rb 0.0.1

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

@@ -0,0 +1,309 @@
+module Groupdate
+  class SeriesBuilder
+    attr_reader :period, :time_zone, :day_start, :week_start, :n_seconds, :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
+      @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| verified_data[k] }
+      end
+
+      value = 0
+      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]
+          else
+            key_format.call(k)
+          end
+
+        [key, value]
+      end
+
+      result
+    end
+
+    def round_time(time)
+      if period == :custom
+        return time_zone.at((time.to_time.to_i / n_seconds) * n_seconds)
+      end
+
+      # TODO avoid calling to_time on dates
+      self.class.round_time(time.to_time, period, time_zone, day_start, @week_start_key)
+    end
+
+    def self.round_time(time, period, time_zone, day_start, week_start_key)
+      time = time.in_time_zone(time_zone)
+
+      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
+        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
+          time.beginning_of_week(week_start_key)
+        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.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
+
+      if day_start != 0 && time.is_a?(Time)
+        time += day_start.seconds
+        time = time.change(zone: time_zone)
+      end
+
+      time
+    end
+
+    def time_range
+      @time_range ||= begin
+        time_range = options[:range]
+
+        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) && !time_range.end.is_a?(DateTime) && !exclude_end
+            finish += 1.day
+            exclude_end = true
+          end
+
+          if options[:expand_range]
+            start = round_time(start) if start
+            if finish && !(finish == round_time(finish) && exclude_end)
+              finish = round_time(finish) + step
+              exclude_end = true
+            end
+          end
+
+          time_range = Range.new(start, finish, exclude_end)
+        elsif !time_range && options[:last]
+          step = step()
+          raise ArgumentError, "Cannot use last option with #{period}" unless step
+
+          # 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
+              # extend to end of current period
+              round_time(start_at)...(round_time(now) + step)
+            end
+        end
+        time_range
+      end
+    end
+
+    private
+
+    def now
+      @now ||= time_zone.now
+    end
+
+    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 :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) && time_range.begin && time_range.end
+            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
+
+            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
+          end
+
+        if time_range.begin
+          series = [round_time(time_range.begin)]
+
+          step = step()
+
+          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_hour # add condition to speed up
+            break unless 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
+      @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
+              end
+              I18n.localize(key, format: options[:format], locale: locale)
+            end
+          end
+        elsif [:day, :week, :month, :quarter, :year].include?(period)
+          lambda { |k| k.to_date }
+        else
+          lambda { |k| k }
+        end
+      end
+    end
+
+    def step
+      if period == :quarter
+        3.months
+      elsif period == :custom
+        n_seconds
+      elsif 1.respond_to?(period)
+        1.send(period)
+      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
+
+    def self.utc
+      @utc ||= ActiveSupport::TimeZone["Etc/UTC"]
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+module Groupdate
+  VERSION = "6.8.0"
+end

data/groupdate-6.8.0/lib/groupdate.rb

@@ -0,0 +1,54 @@
+# dependencies
+require "active_support"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/time"
+
+# modules
+require_relative "groupdate/magic"
+require_relative "groupdate/series_builder"
+require_relative "groupdate/version"
+
+# adapters
+require_relative "groupdate/adapters/base_adapter"
+require_relative "groupdate/adapters/mysql_adapter"
+require_relative "groupdate/adapters/postgresql_adapter"
+require_relative "groupdate/adapters/sqlite_adapter"
+
+module Groupdate
+  class Error < RuntimeError; end
+
+  PERIODS = [:second, :minute, :hour, :day, :week, :month, :quarter, :year, :day_of_week, :hour_of_day, :minute_of_hour, :day_of_month, :day_of_year, :month_of_year]
+  METHODS = PERIODS.map { |v| :"group_by_#{v}" } + [:group_by_period]
+
+  mattr_accessor :week_start, :day_start, :time_zone
+  self.week_start = :sunday
+  self.day_start = 0
+
+  # api for gems like ActiveMedian
+  def self.process_result(relation, result, **options)
+    if relation.groupdate_values
+      result = Groupdate::Magic::Relation.process_result(relation, result, **options)
+    end
+    result
+  end
+
+  def self.adapters
+    @adapters ||= {}
+  end
+
+  def self.register_adapter(name, adapter)
+    Array(name).each do |n|
+      adapters[n] = adapter
+    end
+  end
+end
+
+Groupdate.register_adapter ["Mysql2", "Mysql2Spatial", "Mysql2Rgeo", "Trilogy"], Groupdate::Adapters::MySQLAdapter
+Groupdate.register_adapter ["PostgreSQL", "PostGIS", "Redshift"], Groupdate::Adapters::PostgreSQLAdapter
+Groupdate.register_adapter "SQLite", Groupdate::Adapters::SQLiteAdapter
+
+require_relative "groupdate/enumerable"
+
+ActiveSupport.on_load(:active_record) do
+  require_relative "groupdate/active_record"
+end

data/micro-lite-rb.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = "micro-lite-rb"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on groupdate"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+  s.metadata    = { "source_code_uri" => "https://github.com/Andrey78/micro-lite-rb" }
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: micro-lite-rb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey78
+bindir: bin
+cert_chain: []
+date: 2026-07-06 00:00:00.000000000 Z
+dependencies: []
+description: University research based on groupdate
+email:
+- cakoc614@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- groupdate-6.8.0/CHANGELOG.md
+- groupdate-6.8.0/CONTRIBUTING.md
+- groupdate-6.8.0/LICENSE.txt
+- groupdate-6.8.0/README.md
+- groupdate-6.8.0/lib/groupdate.rb
+- groupdate-6.8.0/lib/groupdate/active_record.rb
+- groupdate-6.8.0/lib/groupdate/adapters/base_adapter.rb
+- groupdate-6.8.0/lib/groupdate/adapters/mysql_adapter.rb
+- groupdate-6.8.0/lib/groupdate/adapters/postgresql_adapter.rb
+- groupdate-6.8.0/lib/groupdate/adapters/sqlite_adapter.rb
+- groupdate-6.8.0/lib/groupdate/enumerable.rb
+- groupdate-6.8.0/lib/groupdate/magic.rb
+- groupdate-6.8.0/lib/groupdate/query_methods.rb
+- groupdate-6.8.0/lib/groupdate/relation.rb
+- groupdate-6.8.0/lib/groupdate/series_builder.rb
+- groupdate-6.8.0/lib/groupdate/version.rb
+- micro-lite-rb.gemspec
+homepage: https://rubygems.org/profiles/Andrey78
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Andrey78/micro-lite-rb
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Research test
+test_files: []