redis-objects-periodical 0.6.0 → 0.8.0

data/docs/usage.md

@@ -0,0 +1,216 @@
+# Usage guide
+
+[README](../README.md) introduces installation and a minimal counter example.
+Configure the Redis connection through Redis::Objects before using these fields.
+
+## Declarations and object lifetime
+
+The examples below use these four fields. Each type's example illustrates a
+separate sequence of writes to initially empty period keys.
+
+```rb
+class Homepage
+  include Redis::Objects
+
+  daily_counter :pv, expireat: -> { Time.now + 2_678_400 } # about a month
+  daily_hash_key :browsing_history, expireat: -> { Time.now + 2_678_400 } # about a month
+  daily_set :dau, expireat: -> { Time.now + 2_678_400 } # about a month
+  daily_value :cache, expireat: -> { Time.now + 2_678_400 } # about a month
+
+  def id
+    1
+  end
+end
+
+homepage = Homepage.new
+```
+
+Each field accessor constructs a periodical object using the current time. Its
+Redis key and cached current time are fixed at construction. Call the accessor
+again after a period boundary to select the new key:
+
+```ruby
+counter = homepage.pv
+# After midnight, counter still addresses the day on which it was constructed.
+# homepage.pv creates a new object and selects the current day's key.
+```
+
+The `global: true` option also supports class-level fields, as in
+`daily_counter :pv, global: true`. Standard Redis::Objects operations remain
+available on each periodical object.
+
+## Periods and key formats
+
+Combine any prefix below with `counter`, `value`, `set`, or `hash_key`.
+The normal instance key has the prefix `model_name:id:field_name:`.
+
+| Period prefix | Key suffix | Argument for historical access |
+| --- | --- | --- |
+| `annual_` | `yyyy` | `Date` or `Time` |
+| `monthly_` | `yyyy-mm` | `Date` or `Time` |
+| `weekly_` | `yyyyWww` | `Date` or `Time` |
+| `daily_` | `yyyy-mm-dd` | `Date` or `Time` |
+| `hourly_` | `yyyy-mm-ddThh` | `Time` |
+| `minutely_` | `yyyy-mm-ddThh:mi` | `Time` |
+
+Weekly keys first normalize the requested date to Monday, then format that
+Monday using `%Y` and `%W`. They are not ISO week-year keys. For example,
+2021-12-31 and 2022-01-01 both use `2021W52`. The year in the key can therefore
+belong to December of the previous year. A configurable strategy remains an
+unresolved decision in [Issue #265](https://github.com/ryz310/redis-objects-periodical/issues/265);
+this guide describes the existing implementation.
+
+Annual periods are not recommended when Redis is the only copy of long-term
+history. Choose retention and expiration deliberately for every period.
+
+## Shared historical operations
+
+| Method | Behavior |
+| --- | --- |
+| `field[date_or_time]` or `slice` | Read one period's value |
+| `field[start, length]` | Read/combine `length` successive periods |
+| `field[start..finish]` | Pass an inclusive Range to the range reader |
+| `field.range(start, finish)` | Read/combine successive cursors while cursor is at most `finish` |
+| `field.delete_at(date_or_time)` | Delete one period's key |
+| `field.at(date_or_time)` | Return a standard Redis::Objects object for that fixed key |
+
+For the length form, zero returns an empty array (counter/value/set) or hash
+(hash_key), and a negative length returns `nil`. Examples use inclusive ranges;
+do not infer unsupported argument forms from the array-like method names.
+
+Range iteration starts at the supplied start date/time and advances one interval
+at a time; it does not first align the cursor to the calendar period boundary.
+The end comparison is inclusive for that cursor, so a partial final interval may
+not be visited. For example, a weekly range from Thursday 2021-04-01 to Monday
+2021-04-05 reads only the week of March 29: its next cursor is April 8. Use
+period-aligned endpoints when requesting complete calendar periods.
+
+Counter and value ranges return arrays in period order. Set ranges return a
+union; member order is not guaranteed. Hash ranges combine fields across periods:
+unsigned integer strings are summed as integers, unsigned decimal strings are
+summed as floats, and other repeated values are joined with commas. The numeric
+aggregate remains a string. Missing periods contribute `0`, `nil`, `[]`, or `{}`
+for counter, value, set, and hash respectively.
+
+## Expiration
+
+Use `expireat` as shown in the declarations to bound retention; its callable
+returns the expiration time. The specs also exercise the upstream `expiration`
+option with a duration in seconds. These options are provided through
+Redis::Objects. Changing periods creates different keys; it does not itself
+delete older period keys.
+
+## Periodical Counters
+
+```rb
+# 2021-04-01
+homepage.pv.increment(3)
+
+# 2021-04-02 (next day)
+homepage.pv.increment(2)
+
+# 2021-04-03 (next day)
+homepage.pv.increment(5)
+
+homepage.pv[Date.new(2021, 4, 1)] # => 3
+homepage.pv[Date.new(2021, 4, 1), 3] # => [3, 2, 5]
+homepage.pv[Date.new(2021, 4, 1)..Date.new(2021, 4, 2)] # => [3, 2]
+
+homepage.pv.delete_at(Date.new(2021, 4, 1))
+homepage.pv.range(Date.new(2021, 4, 1), Date.new(2021, 4, 3)) # => [0, 2, 5]
+homepage.pv.at(Date.new(2021, 4, 2)) # => #<Redis::Counter key="homepage:1:pv:2021-04-02">
+homepage.pv.at(Date.new(2021, 4, 2)).value # 2
+```
+
+## Periodical Values
+
+```rb
+# 2021-04-01
+homepage.cache.value = 'a'
+
+# 2021-04-02 (next day)
+homepage.cache.value = 'b'
+
+# 2021-04-03 (next day)
+homepage.cache.value = 'c'
+
+homepage.cache[Date.new(2021, 4, 1)] # => 'a'
+homepage.cache[Date.new(2021, 4, 1), 3] # => ['a', 'b', 'c']
+homepage.cache[Date.new(2021, 4, 1)..Date.new(2021, 4, 2)] # => ['a', 'b']
+
+homepage.cache.delete_at(Date.new(2021, 4, 1))
+homepage.cache.range(Date.new(2021, 4, 1), Date.new(2021, 4, 3)) # => [nil, 'b', 'c']
+homepage.cache.at(Date.new(2021, 4, 2)) # => #<Redis::Value key="homepage:1:cache:2021-04-02">
+homepage.cache.at(Date.new(2021, 4, 2)).value # 'b'
+```
+
+## Periodical Hashes
+
+```rb
+# 2021-04-01
+homepage.browsing_history.incr('item1')
+homepage.browsing_history.incr('item2')
+homepage.browsing_history.incr('item2')
+puts homepage.browsing_history.all # { 'item1' => '1', 'item2' => '2' }
+
+# 2021-04-02 (next day)
+puts homepage.browsing_history.all # {}
+
+homepage.browsing_history.bulk_set('item1' => 3, 'item3' => 5)
+puts homepage.browsing_history.all # { 'item1' => '3', 'item3' => '5' }
+
+# 2021-04-03 (next day)
+homepage.browsing_history.incr('item2')
+homepage.browsing_history.incr('item4')
+puts homepage.browsing_history.all # { 'item2' => '1', 'item4' => '1' }
+
+homepage.browsing_history[Date.new(2021, 4, 1)] # => { 'item1' => '1', 'item2' => '2' }
+homepage.browsing_history[Date.new(2021, 4, 1), 3] # => { 'item1' => '4', 'item2' => '3', 'item3' => '5', 'item4' => '1' }
+homepage.browsing_history[Date.new(2021, 4, 1)..Date.new(2021, 4, 2)] # => { 'item1' => '4', 'item2' => '2', 'item3' => '5' }
+
+homepage.browsing_history.delete_at(Date.new(2021, 4, 1))
+homepage.browsing_history.range(Date.new(2021, 4, 1), Date.new(2021, 4, 3)) # => { 'item1' => '3', 'item2' => '1', 'item3' => '5', 'item4' => '1' }
+homepage.browsing_history.at(Date.new(2021, 4, 2)) # => #<Redis::HashKey key="homepage:1:browsing_history:2021-04-02">
+homepage.browsing_history.at(Date.new(2021, 4, 2)).all # { 'item1' => '3', 'item3' => '5' }
+```
+
+## Periodical Sets
+
+```rb
+# 2021-04-01
+homepage.dau << 'user1'
+homepage.dau << 'user2'
+homepage.dau << 'user1' # dup ignored
+puts homepage.dau.members # ['user1', 'user2']
+puts homepage.dau.length # 2
+puts homepage.dau.count # alias of #length
+
+# 2021-04-02 (next day)
+puts homepage.dau.members # []
+
+homepage.dau.merge('user2', 'user3')
+puts homepage.dau.members # ['user2', 'user3']
+
+# 2021-04-03 (next day)
+homepage.dau.merge('user4')
+
+homepage.dau[Date.new(2021, 4, 1)] # => ['user1', 'user2']
+homepage.dau[Date.new(2021, 4, 1), 3] # => ['user1', 'user2', 'user3', 'user4']
+homepage.dau[Date.new(2021, 4, 1)..Date.new(2021, 4, 2)] # => ['user1', 'user2', 'user3']
+
+homepage.dau.delete_at(Date.new(2021, 4, 1))
+homepage.dau.range(Date.new(2021, 4, 1), Date.new(2021, 4, 3)) # => ['user2', 'user3', 'user4']
+homepage.dau.at(Date.new(2021, 4, 2)) # => #<Redis::Set key="homepage:1:dau:2021-04-02">
+homepage.dau.at(Date.new(2021, 4, 2)).members # ['user2', 'user3']
+```
+
+## Timezone
+
+Without ActiveSupport, new periodical objects use `Time.now` in the Ruby
+process timezone. If `Time.current` is available, they use it instead. With
+ActiveSupport, `Time.zone` selects the application zone; when unset, its process
+clock fallback applies. ActiveSupport is optional and is not a runtime dependency.
+
+The [contributor guide](../CONTRIBUTING.md#optional-activesupport-integration)
+describes the specific Ruby/ActiveSupport pair and boundary cases verified in CI;
+it does not establish compatibility with every Rails release or timezone.

data/docs/verification/2026-10-27-timezone.md

@@ -0,0 +1,25 @@
+# Timezone verification recorded on 2026-10-27
+
+This historical record was moved from README.md during documentation cleanup.
+Its source is [revision e4c8af4](https://github.com/ryz310/redis-objects-periodical/blob/e4c8af42a8b311dbab2d38ed0e6bb2c9613b677a/README.md#L402).
+The cleanup did not rerun the recorded experiment. Current procedures and the
+execution inventory guard are described in
+[Contributing](../../CONTRIBUTING.md#optional-activesupport-integration).
+
+On 2026-10-27, the JUnit artifact from the
+[successful CI run for commit 8ab4de1](https://github.com/ryz310/redis-objects-periodical/actions/runs/40409599457)
+confirmed both zone groups actually ran under Ruby 3.3 / ActiveSupport 8.1.4.
+A separate diagnostic changed `Time.use_zone(zone)` to `Time.use_zone(nil)` in
+an isolated temporary copy and ran it against disposable Redis:
+
+| Verification | Tokyo: executed / failed | Unset: executed / failed |
+| --- | --- | --- |
+| Actual CI JUnit report | 48 / 0 | 48 / 0 |
+| Temporary copy with the zone setting disabled | 48 / 36 | 48 / 0 |
+
+Both reports contained zero errors and zero skipped examples. The diagnostic
+failed on incorrect keys, for example expected annual suffix `2021` versus actual
+`2020`. Some periods share a key at one of the two boundary instants, so disabling
+the zone does not make every Tokyo example fail. This experiment confirms that
+the assertions detect ineffective timezone selection; it is a recorded one-off
+diagnostic, not an additional CI step.

data/gemfiles/active_support/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Optional Ruby 3.3 target; see CONTRIBUTING.md's ActiveSupport version selection policy.
+eval_gemfile '../../Gemfile'
+gem 'activesupport', '~> 8.1.4'

data/gemfiles/active_support/Gemfile.lock

@@ -0,0 +1,137 @@
+PATH
+  remote: ../..
+  specs:
+    redis-objects-periodical (0.8.0)
+      redis-objects (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (8.1.4)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    ast (2.4.3)
+    base64 (0.3.0)
+    bigdecimal (4.1.3)
+    byebug (13.0.0)
+      reline (>= 0.6.0)
+    coderay (1.1.3)
+    concurrent-ruby (1.3.8)
+    connection_pool (2.3.0)
+    diff-lcs (1.6.2)
+    drb (2.2.3)
+    i18n (1.14.8)
+      concurrent-ruby (~> 1.0)
+    io-console (0.9.4)
+    json (3.1.0)
+    language_server-protocol (3.17.0.6)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    method_source (1.0.0)
+    minitest (5.26.1)
+    parallel (1.28.0)
+    parser (3.3.13.0)
+      ast (~> 2.4.1)
+      racc
+    prism (1.9.0)
+    pry (0.16.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+      reline (>= 0.6.0)
+    pry-byebug (3.12.0)
+      byebug (~> 13.0)
+      pry (>= 0.13, < 0.17)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.4.2)
+    redis (5.0.6)
+      redis-client (>= 0.9.0)
+    redis-client (0.12.1)
+      connection_pool
+    redis-objects (1.7.0)
+      redis
+    regexp_parser (2.13.1)
+    reline (0.7.0)
+      io-console (~> 0.5)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    rspec_junit_formatter (0.8.0)
+      rspec-core (>= 3.13, < 4)
+    rubocop (1.92.1)
+      json (>= 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (>= 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.11.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.50.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-performance (1.27.0)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.89.0, < 2.0)
+      rubocop-ast (>= 1.47.1, < 2.0)
+    rubocop-rspec (3.10.2)
+      lint_roller (~> 1.1)
+      regexp_parser (>= 2.0)
+      rubocop (~> 1.86, >= 1.86.2)
+    ruby-progressbar (1.13.0)
+    securerandom (0.3.2)
+    simplecov (1.3.2)
+    timecop (0.9.11)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (3.3.0)
+      unicode-emoji (~> 4.3)
+    unicode-emoji (4.3.0)
+    uri (1.1.2)
+    yard (0.9.45)
+
+PLATFORMS
+  aarch64-linux
+  x86_64-darwin-19
+  x86_64-darwin-20
+  x86_64-linux
+
+DEPENDENCIES
+  activesupport (~> 8.1.4)
+  bundler (~> 4.0)
+  pry-byebug (~> 3.12)
+  rake (~> 13.4)
+  redis-objects-periodical!
+  rspec (~> 3.13)
+  rspec_junit_formatter
+  rubocop (~> 1.92)
+  rubocop-performance
+  rubocop-rspec
+  simplecov (= 1.3.2)
+  timecop
+  yard
+
+BUNDLED WITH
+  4.0.23

data/lib/redis/base_value_object.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Redis
+  module BaseValueObject
+    private
+
+    def get_redis_object(key)
+      Redis::Value.new(key)
+    end
+
+    def get_value_from_redis(key)
+      unmarshal(redis.get(key))
+    end
+
+    def get_values_from_redis(keys)
+      redis.mget(*keys).map { |v| unmarshal(v) }
+    end
+
+    def delete_from_redis(key)
+      redis.del(key)
+    end
+
+    def empty_value
+      []
+    end
+  end
+end

data/lib/redis/objects/periodical/version.rb

@@ -3,7 +3,7 @@
 class Redis
   module Objects
     module Periodical
-      VERSION = '0.6.0'
+      VERSION = '0.8.0'
     end
   end
 end

data/lib/redis/objects/periodical_counters.rb

@@ -36,5 +36,5 @@ Redis::PERIODICALS.each do |periodical| # rubocop:disable Metrics/BlockLength
       end
     end
   RUBY
-  Redis::Objects.const_set("#{periodical.capitalize}Counters", new_module)
+  Redis::Objects.const_set(:"#{periodical.capitalize}Counters", new_module)
 end

data/lib/redis/objects/periodical_hashes.rb

@@ -46,5 +46,5 @@ Redis::PERIODICALS.each do |periodical| # rubocop:disable Metrics/BlockLength
       end
     end
   RUBY
-  Redis::Objects.const_set("#{periodical.capitalize}Hashes", new_module)
+  Redis::Objects.const_set(:"#{periodical.capitalize}Hashes", new_module)
 end

data/lib/redis/objects/periodical_sets.rb

@@ -46,5 +46,5 @@ Redis::PERIODICALS.each do |periodical| # rubocop:disable Metrics/BlockLength
       end
     end
   RUBY
-  Redis::Objects.const_set("#{periodical.capitalize}Sets", new_module)
+  Redis::Objects.const_set(:"#{periodical.capitalize}Sets", new_module)
 end

data/lib/redis/objects/periodical_values.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'redis/periodical_value'
+
+Redis::PERIODICALS.each do |periodical| # rubocop:disable Metrics/BlockLength
+  new_module = Module.new
+  new_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def #{periodical}_value(name, options = {})
+        redis_objects[name.to_sym] = options.merge(:type => :value)
+
+        mod = Module.new do
+          define_method(name) do
+            Redis::#{periodical.capitalize}Value.new(
+              redis_field_key(name), redis_field_redis(name), redis_options(name)
+            )
+          end
+          define_method(:"#\{name}=") do |value|
+            public_send(name).value = value
+          end
+        end
+
+        if options[:global]
+          extend mod
+
+          # dispatch to class methods
+          define_method(name) do
+            self.class.public_send(name)
+          end
+          define_method(:"#\{name}=") do |value|
+            self.class.public_send(:"#\{name}=", value)
+          end
+        else
+          include mod
+        end
+      end
+    end
+  RUBY
+  Redis::Objects.const_set(:"#{periodical.capitalize}Values", new_module)
+end

data/lib/redis/periodical_counter.rb

@@ -11,5 +11,5 @@ Redis::PERIODICALS.each do |periodical|
     include Redis::BaseCounterObject
     include const_get("Redis::RecurringAtIntervals::#{periodical.capitalize}")
   end
-  Redis.const_set("#{periodical.capitalize}Counter", new_class)
+  Redis.const_set(:"#{periodical.capitalize}Counter", new_class)
 end

data/lib/redis/periodical_hash_key.rb

@@ -11,5 +11,5 @@ Redis::PERIODICALS.each do |periodical|
     include Redis::BaseHashKeyObject
     include const_get("Redis::RecurringAtIntervals::#{periodical.capitalize}")
   end
-  Redis.const_set("#{periodical.capitalize}HashKey", new_class)
+  Redis.const_set(:"#{periodical.capitalize}HashKey", new_class)
 end

data/lib/redis/periodical_set.rb

@@ -11,5 +11,5 @@ Redis::PERIODICALS.each do |periodical|
     include Redis::BaseSetObject
     include const_get("Redis::RecurringAtIntervals::#{periodical.capitalize}")
   end
-  Redis.const_set("#{periodical.capitalize}Set", new_class)
+  Redis.const_set(:"#{periodical.capitalize}Set", new_class)
 end

data/lib/redis/periodical_value.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/recurring_at_intervals"
+require "#{File.dirname(__FILE__)}/base_value_object"
+
+Redis::PERIODICALS.each do |periodical|
+  require "#{File.dirname(__FILE__)}/recurring_at_intervals/#{periodical}"
+
+  new_class = Class.new(Redis::Value) do
+    include Redis::RecurringAtIntervals
+    include Redis::BaseValueObject
+    include const_get("Redis::RecurringAtIntervals::#{periodical.capitalize}")
+  end
+  Redis.const_set(:"#{periodical.capitalize}Value", new_class)
+end

data/lib/redis/recurring_at_intervals/weekly.rb

@@ -6,7 +6,9 @@ class Redis
       private
 
       def redis_periodical_field_key(date_or_time)
-        date_key = date_or_time.strftime('%YW%W')
+        wday = date_or_time.wday
+        beginning_of_week_date = date_or_time.to_date - (wday.zero? ? 6 : wday - 1)
+        date_key = beginning_of_week_date.strftime('%YW%W')
         [original_key, date_key].flatten.join(':')
       end
 

data/lib/redis/recurring_at_intervals.rb

@@ -2,9 +2,9 @@
 
 class Redis
   module RecurringAtIntervals
-    def initialize(key, *args)
+    def initialize(key, *)
       @original_key = key
-      super(redis_periodical_field_key(current_time), *args)
+      super(redis_periodical_field_key(current_time), *)
     end
 
     attr_reader :original_key
@@ -16,7 +16,7 @@ class Redis
         case length <=> 0
         when 1  then range(date_or_time, next_key(date_or_time, length - 1))
         when 0  then empty_value
-        when -1 then nil  # Ruby does this (a bit weird)
+        when -1 then nil # Ruby does this (a bit weird)
         end
       else
         get_value_from_redis(redis_periodical_field_key(date_or_time))

data/lib/redis-objects-periodical.rb

@@ -9,6 +9,7 @@ class Redis
     autoload :"#{periodical.capitalize}Counter", 'redis/periodical_counter'
     autoload :"#{periodical.capitalize}HashKey", 'redis/periodical_hash_key'
     autoload :"#{periodical.capitalize}Set", 'redis/periodical_set'
+    autoload :"#{periodical.capitalize}Value", 'redis/periodical_value'
   end
 
   module Objects
@@ -16,6 +17,7 @@ class Redis
       autoload :"#{periodical.capitalize}Counters", 'redis/objects/periodical_counters'
       autoload :"#{periodical.capitalize}Hashes", 'redis/objects/periodical_hashes'
       autoload :"#{periodical.capitalize}Sets", 'redis/objects/periodical_sets'
+      autoload :"#{periodical.capitalize}Values", 'redis/objects/periodical_values'
     end
 
     class << self
@@ -29,6 +31,7 @@ class Redis
           klass.send :include, const_get("Redis::Objects::#{periodical.capitalize}Counters")
           klass.send :include, const_get("Redis::Objects::#{periodical.capitalize}Hashes")
           klass.send :include, const_get("Redis::Objects::#{periodical.capitalize}Sets")
+          klass.send :include, const_get("Redis::Objects::#{periodical.capitalize}Values")
         end
       end
     end

data/redis-objects-periodical.gemspec

@@ -27,9 +27,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = '>= 2.7.0'
+  spec.required_ruby_version = '>= 3.3.0'
 
-  spec.add_dependency 'redis-objects'
+  spec.add_dependency 'redis-objects', '~> 1.0'
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html