redis-objects 1.7.0 → 2.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a34d5bd684e2dfb04c3216b84fc8c0d0ac4b8037919ba6f887bd1930e3eca727
-  data.tar.gz: e3b4c9df6c48b594850948dd437cec9acecb9a7622102f71d57a4f17068e7fd8
+  metadata.gz: 3962b1b4d04b8b94a6d130f2323fe1f93a74cce5546285b011ccbb85293afa5d
+  data.tar.gz: cfba25072de6ac2801100f2a11aa0588dc872e0826d88c070327c3be688a9260
 SHA512:
-  metadata.gz: 99d33225c4326dec14e62b14e2c0735ac688b7c1d7a86f767d0141fe3a49782e2fc41e02c80cf8c16a79e0c570249e4e3f758e86d1c652688566b4392890abd8
-  data.tar.gz: d1c6831c0d327fa3f6b2e5e8b3ed45deacdc4373836565084ed16e7492219c7de73e5d79ccc61f0bf28863ad10ef185284c81799369a27fa1cd3f375e426b61c
+  metadata.gz: 64a0743cbe2f89145510e00877f2954f6734bdd472c0b272ac165912dffb4ef9d03b395ee7c63bf6a5c06504f6340cf761e69cca0f9fdf5285895b3a544e38b3
+  data.tar.gz: eb7cc427ed879586363b84ed1b509052a23e5bf56d7ef8621d5b9fc6d8c4fea3ec20672a1569d018f45530ac131f9e68772213192c6c42baf50beaa7cec977a5

data/CHANGELOG.rdoc

@@ -1,5 +1,13 @@
 = Changelog for Redis::Objects
 
+== 2.0.0.beta (30 Mar 2023)
+
+* Updated internal calls to match `redis-rb`
+
+* INCOMPAT: `Redis.current` is no longer allowed due to changes in `redis-rb`
+
+* INCOMPAT: The order of items popped off a list by the rarely-used command `list.pop(n)` to specify multiple elements is now reversed to match redis.
+
 == 1.7.0 (29 Apr 2022)
 
 * Bumped version to 1.7.0 to revert redis-rb version lock [Nate Wiger]

data/README.md

@@ -5,6 +5,56 @@ Redis::Objects - Map Redis types directly to Ruby objects
 [![Code Coverage](https://codecov.io/gh/nateware/redis-objects/branch/master/graph/badge.svg)](https://codecov.io/gh/nateware/redis-objects)
 [![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=MJF7JU5M7F8VL)
 
+Important 2.0 changes
+=====================
+Redis::Objects 2.0 introduces several important backwards incompatible changes.
+Currently 2.0 can be installed with `gem install redis-objects --pre` or by listing it
+explicitly in your Gemfile:
+~~~ruby
+# Gemfile
+gem 'redis-objects', '>= 2.0.0.beta'
+~~~
+You're encouraged to try it out in test code (not production) to ensure it works for you.
+Official release is expected later in 2023.
+
+Key Naming Changes
+------------------
+The internal key naming scheme has changed for `Nested::Class::Namespaces` to fix a longstanding bug.
+**This means your existing data in Redis will not be accessible until you call `migrate_redis_legacy_keys`.**
+
+To fix this (only needed once), create a script like this:
+
+~~~ruby
+class YouClassNameHere < ActiveRecord::Base
+  include Redis::Objects
+  # ... your relevant definitions here ...
+end
+
+YourClassName.migrate_redis_legacy_keys
+~~~
+
+Then, you need to find a time when you can temporarily pause writes to your redis server
+so that you can run that script. It uses `redis.scan` internally so it should be able to
+handle a high number of keys. For large data sets, it could take a while.
+
+For more details on the issue and fix refer to [#213](https://github.com/nateware/redis-objects/issues/231).
+
+Renaming of `lock` Method
+-------------------------
+The `lock` method that collided with `ActiveRecord::Base` has been renamed `redis_lock`.
+This means your classes need to be updated to call `redis_lock` instead:
+
+~~~ruby
+class YouClassNameHere < ActiveRecord::Base
+  include Redis::Objects
+  redis_lock :mylock  # formerly just "lock"
+end 
+~~~
+
+For more details on the issue and fix refer to [#196](https://github.com/nateware/redis-objects/issues/196).
+
+Overview
+--------
 This is **not** an ORM. People that are wrapping ORM’s around Redis are missing the point.
 
 The killer feature of Redis is that it allows you to perform _atomic_ operations
@@ -119,7 +169,7 @@ Here's an example that integrates several data types with an ActiveRecord model:
 class Team < ActiveRecord::Base
   include Redis::Objects
 
-  lock :trade_players, :expiration => 15  # sec
+  redis_lock :trade_players, :expiration => 15  # sec
   value :at_bat
   counter :hits
   counter :runs
@@ -524,7 +574,7 @@ Locks work similarly. On completion or exception the lock is released:
 
 ~~~ruby
 class Team < ActiveRecord::Base
-  lock :reorder # declare a lock
+  redis_lock :reorder # declare a lock
 end
 
 @team.reorder_lock.lock do
@@ -548,7 +598,7 @@ lock time.
 
 ~~~ruby
 class Team < ActiveRecord::Base
-  lock :reorder, :expiration => 15.minutes
+  redis_lock :reorder, :expiration => 15.minutes
 end
 ~~~
 
@@ -596,5 +646,5 @@ end
 
 Author
 =======
-Copyright (c) 2009-2019 [Nate Wiger](http://nateware.com).  All Rights Reserved.
+Copyright (c) 2009-2022 [Nate Wiger](http://nateware.com).  All Rights Reserved.
 Released under the [Artistic License](http://www.opensource.org/licenses/artistic-license-2.0.php).

data/lib/redis/list.rb

@@ -31,11 +31,7 @@ class Redis
     # Remove a member from the end of the list. Redis: RPOP
     def pop(n=nil)
       if n
-        result, = redis.multi do
-          redis.lrange(key, -n, -1)
-          redis.ltrim(key, 0, -n - 1)
-        end
-        unmarshal result
+        unmarshal redis.rpop(key, n)
       else
         unmarshal redis.rpop(key)
       end
@@ -65,11 +61,7 @@ class Redis
     # Remove a member from the start of the list. Redis: LPOP
     def shift(n=nil)
       if n
-        result, = redis.multi do
-          redis.lrange(key, 0, n - 1)
-          redis.ltrim(key, n, -1)
-        end
-        unmarshal result
+        unmarshal redis.lpop(key, n)
       else
         unmarshal redis.lpop(key)
       end

data/lib/redis/objects/locks.rb

@@ -14,7 +14,7 @@ class Redis
       module ClassMethods
         # Define a new lock.  It will function like a model attribute,
         # so it can be used alongside ActiveRecord/DataMapper, etc.
-        def lock(name, options={})
+        def redis_lock(name, options={})
           options[:timeout] ||= 5  # seconds
           lock_name = "#{name}_lock"
           redis_objects[lock_name.to_sym] = options.merge(:type => :lock)

data/lib/redis/objects/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Objects
-    VERSION = "1.7.0"
+    VERSION = "2.0.0.beta"
   end
 end

data/lib/redis/objects.rb

@@ -62,7 +62,7 @@ class Redis
         @redis = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
       end
       def redis
-        @redis || $redis || Redis.current ||
+        @redis || $redis ||
           raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
       end
 
@@ -101,16 +101,93 @@ class Redis
         @redis_objects ||= {}
       end
 
-      # Set the Redis redis_prefix to use. Defaults to model_name
-      def redis_prefix=(redis_prefix) @redis_prefix = redis_prefix end
+      # Toggles whether to use the legacy redis key naming scheme, which causes
+      # naming conflicts in certain cases.
+      attr_accessor :redis_legacy_naming
+      attr_accessor :redis_silence_warnings
+
+      # Set the Redis redis_prefix to use. Defaults to class_name.
+      def redis_prefix=(redis_prefix)
+        @silence_warnings_as_redis_prefix_was_set_manually = true
+        @redis_prefix = redis_prefix
+      end
+
       def redis_prefix(klass = self) #:nodoc:
-        @redis_prefix ||= klass.name.to_s.
-          sub(%r{(.*::)}, '').
-          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        @redis_prefix ||=
+          if redis_legacy_naming
+            redis_legacy_prefix(klass)
+          else
+            redis_legacy_naming_warning_message(klass)
+            redis_modern_prefix(klass)
+          end
+
+        @redis_prefix
+      end
+
+      def redis_modern_prefix(klass = self) #:nodoc:
+        klass.name.to_s.
+          gsub(/::/, '__').                     # Nested::Class => Nested__Class
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2'). # ClassName => Class_Name
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').     # className => class_Name
+          downcase
+      end
+
+      def redis_legacy_prefix(klass = self) #:nodoc:
+        klass.name.to_s.
+          sub(%r{(.*::)}, '').                  # Nested::Class => Class (problematic)
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2'). # ClassName => Class_Name
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').     # className => class_Name
           downcase
       end
 
+        # Temporary warning to help with migrating key names
+      def redis_legacy_naming_warning_message(klass)
+        # warn @silence_warnings_as_redis_prefix_was_set_manually.inspect
+        unless redis_legacy_naming || redis_silence_warnings || @silence_warnings_as_redis_prefix_was_set_manually
+          modern = redis_modern_prefix(klass)
+          legacy = redis_legacy_prefix(klass)
+          if modern != legacy
+            warn <<EOW
+[redis-objects] WARNING: In redis-objects 2.0.0, key naming will change to fix longstanding bugs.
+[redis-objects] Your class #{klass.name.to_s} will be affected by this change!
+[redis-objects] Current key prefix: #{legacy.inspect}
+[redis-objects] Future  key prefix: #{modern.inspect}
+[redis-objects] Read more at https://github.com/nateware/redis-objects/issues/231
+EOW
+          end
+        end
+      end
+
+      def migrate_redis_legacy_keys
+        cursor = 0
+        legacy = redis_legacy_prefix
+        total_keys = 0
+        if legacy == redis_prefix
+          raise "Failed to migrate keys for #{self.name.to_s} as legacy and new redis_prefix are the same (#{redis_prefix})"
+        end
+        warn "[redis-objects] Migrating keys from #{legacy} prefix to #{redis_prefix}"
+
+        loop do
+          cursor, keys = redis.scan(cursor, :match => "#{legacy}:*")
+          total_keys += keys.length
+          keys.each do |key|
+            # Split key name apart on ':'
+            base_class, id, name = key.split(':')
+
+            # Figure out the new name
+            new_key = redis_field_key(name, id=id, context=self)
+
+            # Rename the key
+            warn "[redis-objects] Rename '#{key}', '#{new_key}'"
+            ok = redis.rename(key, new_key)
+            warn "[redis-objects] Warning: Rename '#{key}', '#{new_key}' failed: #{ok}" if ok != 'OK'
+          end
+          break if cursor == "0"
+        end
+
+        warn "[redis-objects] Migrated #{total_keys} total number of redis keys"
+      end
+
       def redis_options(name)
         klass = first_ancestor_with(name)
         return klass.redis_objects[name.to_sym] || {}

data/lib/redis/set.rb

@@ -15,7 +15,8 @@ class Redis
     # Redis: SADD
     def add(value)
       allow_expiration do
-        redis.sadd(key, marshal(value)) if value.nil? || !Array(value).empty?
+        value = '' if value.nil?
+        redis.sadd(key, marshal(value)) if !Array(value).empty? # allow empty adds
       end
     end
 

data/lib/redis/sorted_set.rb

@@ -211,7 +211,7 @@ class Redis
         result = redis.zrange(temp_key, 0, -1)
       end
 
-      result.value
+      result
     end
     alias_method :intersect, :intersection
     alias_method :inter, :intersection
@@ -248,7 +248,7 @@ class Redis
         result = redis.zrange(temp_key, 0, -1)
       end
 
-      result.value
+      result
     end
     alias_method :|, :union
     alias_method :+, :union

data/redis-objects.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Only fix this one version or else tests break
-  spec.add_dependency "redis"
+  spec.add_dependency "redis", '~> 5.0'
 
   # Ignore gemspec warnings on these.  Trying to fix them to versions breaks TravisCI
   spec.add_development_dependency "bundler"

data/spec/redis_legacy_key_naming_spec.rb

@@ -0,0 +1,419 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'redis/objects'
+Redis::Objects.redis = REDIS_HANDLE
+
+require 'securerandom'
+
+require "stringio"
+
+def capture_stderr
+  # The output stream must be an IO-like object. In this case we capture it in
+  # an in-memory IO object so we can return the string value. You can assign any
+  # IO object here.
+  previous_stderr, $stderr = $stderr, StringIO.new
+  yield
+  $stderr.string
+ensure
+  # Restore the previous value of stderr (typically equal to STDERR).
+  $stderr = previous_stderr
+end
+
+describe 'Legacy redis key prefix naming compatibility' do
+  it 'verifies single level classes work the same' do
+    class SingleLevelOne
+      include Redis::Objects
+
+      def id
+        1
+      end
+    end
+
+    obj = SingleLevelOne.new
+    obj.class.redis_prefix.should == 'single_level_one'
+  end
+
+  it 'verifies single level classes obey the legacy naming flag' do
+    class SingleLevelTwo
+      include Redis::Objects
+      self.redis_legacy_naming = true
+
+      def id
+        1
+      end
+    end
+
+    obj = SingleLevelTwo.new
+    obj.class.redis_prefix.should == 'single_level_two'
+  end
+
+  it 'verifies nested classes do NOT work the same' do
+    module Nested
+      class NamingOne
+        include Redis::Objects
+        self.redis_silence_warnings = true
+  
+        def id
+          1
+        end
+      end
+    end
+
+    obj = Nested::NamingOne.new
+    obj.class.redis_prefix.should == 'nested__naming_one'
+  end
+
+  it 'verifies the legacy naming flag is respected' do
+    module Nested
+      class NamingTwo
+        include Redis::Objects
+        self.redis_legacy_naming = true
+        self.redis_silence_warnings = true
+  
+        def id
+          1
+        end
+      end
+    end
+
+    Nested::NamingTwo.redis_legacy_naming.should == true
+    obj = Nested::NamingTwo.new
+    obj.class.redis_prefix.should == 'naming_two'
+  end
+
+  it 'verifies that multiple levels respect __ vs _' do
+    module NestedLevel
+      module Further
+        class NamingThree
+          include Redis::Objects
+          self.redis_silence_warnings = true
+    
+          def id
+            1
+          end
+        end
+      end
+    end
+
+    obj = NestedLevel::Further::NamingThree.new
+    obj.class.redis_prefix.should == 'nested_level__further__naming_three'
+  end
+
+  it 'verifies that multiple levels respect the legacy naming' do
+    module NestedLevel
+      module Further
+        class NamingFour
+          include Redis::Objects
+          self.redis_legacy_naming = true
+    
+          def id
+            1
+          end
+
+          redis_handle = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT, :db => 31)
+          value :redis_value, :redis => redis_handle
+        end
+      end
+    end
+
+    NestedLevel::Further::NamingFour.redis_legacy_naming.should == true
+    obj = NestedLevel::Further::NamingFour.new
+    obj.class.redis_prefix.should == 'naming_four'
+    val = SecureRandom.hex(10)
+    obj.redis_value = val
+    obj.redis_value.should == val
+    obj.redis_value.key.should == 'naming_four:1:redis_value'
+  end
+
+  it 'verifies that multiple levels do not conflict 1' do
+    module NestedLevel
+      module Further
+        class NamingFive
+          include Redis::Objects
+          self.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
+          self.redis_silence_warnings = true
+    
+          def id
+            1
+          end
+
+          value :redis_value
+        end
+      end
+    end
+
+    obj = NestedLevel::Further::NamingFive.new
+    obj.class.redis_prefix.should == 'nested_level__further__naming_five'
+    val = SecureRandom.hex(10)
+    obj.redis_value = val
+    obj.redis_value.should == val
+    obj.redis_value.key.should == 'nested_level__further__naming_five:1:redis_value'
+    obj.redis_value.redis.should == obj.redis
+    obj.redis.get('nested_level__further__naming_five:1:redis_value').should == val
+  end
+
+  it 'verifies that multiple levels do not conflict 2' do
+    module Nested
+      module LevelFurtherNaming
+        class Five
+          include Redis::Objects
+          self.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
+          self.redis_silence_warnings = true
+    
+          def id
+            1
+          end
+
+          value :redis_value
+        end
+      end
+    end
+
+    obj = Nested::LevelFurtherNaming::Five.new
+    obj.class.redis_prefix.should == 'nested__level_further_naming__five'
+    val = SecureRandom.hex(10)
+    obj.redis_value = val
+    obj.redis_value.should == val
+    obj.redis_value.key.should == 'nested__level_further_naming__five:1:redis_value'
+    obj.redis.get('nested__level_further_naming__five:1:redis_value').should == val
+  end
+
+  it 'verifies that multiple levels do not conflict 3' do
+    module Nested
+      module LevelFurther
+        class NamingFive
+          include Redis::Objects
+          self.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
+          self.redis_silence_warnings = true
+    
+          def id
+            1
+          end
+
+          value :redis_value
+        end
+      end
+    end
+
+    obj = Nested::LevelFurther::NamingFive.new
+    obj.class.redis_prefix.should == 'nested__level_further__naming_five'
+    val = SecureRandom.hex(10)
+    obj.redis_value = val
+    obj.redis_value.should == val
+    obj.redis_value.key.should == 'nested__level_further__naming_five:1:redis_value'
+    obj.redis.get('nested__level_further__naming_five:1:redis_value').should == val
+  end
+
+  it 'handles dynamically created classes correctly' do
+    module Nested
+      class LevelSix
+        include Redis::Objects
+        self.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
+        self.redis_silence_warnings = true
+
+        def id
+          1
+        end
+
+        value :redis_value
+      end
+    end
+
+    obj = Nested::LevelSix.new
+    obj.class.redis_prefix.should == 'nested__level_six'
+    val = SecureRandom.hex(10)
+    obj.redis_value = val
+    obj.redis_value.should == val
+    obj.redis_value.key.should == 'nested__level_six:1:redis_value'
+    obj.redis.get('nested__level_six:1:redis_value').should == val
+
+    DynamicClass = Class.new(Nested::LevelSix)
+    DynamicClass.value :redis_value2
+    obj2 = DynamicClass.new
+    DynamicClass.redis_prefix.should == 'dynamic_class'
+    obj2.redis_value.should.be.kind_of(Redis::Value)
+    obj2.redis_value2.should.be.kind_of(Redis::Value)
+    obj2.redis_value.key.should == 'dynamic_class:1:redis_value'
+    obj2.redis_value2.key.should == 'dynamic_class:1:redis_value2'
+
+  end
+
+  it 'handles dynamically created classes correctly in legacy mode' do
+    module Nested
+      class LevelSeven
+        include Redis::Objects
+        self.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
+        self.redis_legacy_naming = true
+
+        def id
+          1
+        end
+
+        value :redis_value
+      end
+    end
+
+    obj = Nested::LevelSeven.new
+    obj.class.redis_prefix.should == 'level_seven'
+    val = SecureRandom.hex(10)
+    obj.redis_value = val
+    obj.redis_value.should == val
+    obj.redis_value.key.should == 'level_seven:1:redis_value'
+    obj.redis.get('level_seven:1:redis_value').should == val
+
+    DynamicClass2 = Class.new(Nested::LevelSeven)
+    DynamicClass2.value :redis_value2
+    obj2 = DynamicClass2.new
+    DynamicClass2.redis_prefix.should == 'dynamic_class2'
+    obj2.redis_value.should.be.kind_of(Redis::Value)
+    obj2.redis_value2.should.be.kind_of(Redis::Value)
+    obj2.redis_value.key.should == 'dynamic_class2:1:redis_value'
+    obj2.redis_value2.key.should == 'dynamic_class2:1:redis_value2'
+  end
+
+  it 'prints a warning message if the key name changes' do
+    module Nested
+      class LevelNine
+        include Redis::Objects
+        self.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
+
+        def id
+          1
+        end
+
+        value :redis_value
+      end
+    end
+
+    captured_output = capture_stderr do
+      # Does not output anything directly.
+      obj = Nested::LevelNine.new
+      val = SecureRandom.hex(10)
+      obj.redis_value = val
+      obj.redis_value.should == val
+    end
+
+    captured_output.should =~ /Warning:/i
+  end
+
+  it 'supports a method to migrate legacy key names' do
+    module Nested
+      class Legacy
+        include Redis::Objects
+        self.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
+        self.redis_legacy_naming = true
+
+        # override this for testing - need two classes as if we imagine an old and new one
+        # also use the legacy flat prefix that ignores the nested class name
+        self.redis_prefix = 'modern'
+
+        def initialize(id)
+          @id = id
+        end
+        def id
+          @id
+        end
+
+        value :redis_value
+        counter :redis_counter
+        hash_key :redis_hash
+        list :redis_list
+        set :redis_set
+        sorted_set :redis_sorted_set
+
+        # global class counters
+        value :global_value, :global => true
+        counter :global_counter, :global => true
+        hash_key :global_hash_key, :global => true
+        list :global_list, :global => true
+        set :global_set, :global => true
+        sorted_set :global_sorted_set, :global => true
+      
+        #callable as key
+        value :global_proc_value, :global => true, :key => Proc.new { |roster| "#{roster.name}:#{Time.now.strftime('%Y-%m-%dT%H')}:daily" }
+      end
+    end
+
+    module Nested
+      class Modern
+        include Redis::Objects
+        self.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
+
+        def initialize(id)
+          @id = id
+        end
+        def id
+          @id
+        end
+
+        value :redis_value
+        counter :redis_counter
+        hash_key :redis_hash
+        list :redis_list
+        set :redis_set
+        sorted_set :redis_sorted_set
+
+        # global class counters
+        value :global_value, :global => true
+        counter :global_counter, :global => true
+        hash_key :global_hash_key, :global => true
+        list :global_list, :global => true
+        set :global_set, :global => true
+        sorted_set :global_sorted_set, :global => true
+      
+        #callable as key
+        value :global_proc_value, :global => true, :key => Proc.new { |roster| "#{roster.name}:#{Time.now.strftime('%Y-%m-%dT%H')}:daily" }
+      end
+    end
+
+    # Iterate over them
+    Nested::Modern.redis_objects.length.should == 13
+    Nested::Modern.redis_objects.length.should == Nested::Legacy.redis_objects.length.should
+    Nested::Legacy.redis_prefix.should == 'modern'
+    Nested::Modern.redis_prefix.should == 'nested__modern'
+
+    # Create a whole bunch of keys using the legacy names
+    30.times do |i|
+      # warn i.inspect
+      obj = Nested::Legacy.new(i)
+      obj.redis_value = i
+      obj.redis_value.to_i.should == i
+      obj.redis_counter.increment
+      obj.redis_hash[:key] = i
+      obj.redis_list << i
+      obj.redis_set << i
+      obj.redis_sorted_set[i] = i
+    end
+
+    obj = Nested::Legacy.new(99)
+    obj.global_value = 42
+    obj.global_counter.increment
+    obj.global_counter.increment
+    obj.global_counter.increment
+    obj.global_hash_key[:key] = 'value'
+    obj.global_set << 'a' << 'b'
+    obj.global_sorted_set[:key] = 2.2
+
+    Nested::Modern.migrate_redis_legacy_keys
+
+    # Try to access the keys through modern names now
+    30.times do |i|
+      # warn i.inspect
+      obj = Nested::Modern.new(i)
+      obj.redis_value.to_i.should == i
+      obj.redis_counter.to_i.should == 1
+      obj.redis_hash[:key].to_i.should == i
+      obj.redis_list[0].to_i.should == i
+      obj.redis_set.include?(i).should == true
+      obj.redis_sorted_set[i].should == i
+    end
+
+    obj = Nested::Modern.new(99)
+    obj.global_value.to_i.should == 42
+    obj.global_counter.to_i.should == 3
+    obj.global_hash_key[:key].should == 'value'
+    obj.global_set.should.include?('a').should == true
+    obj.global_set.should.include?('b').should == true
+    obj.global_sorted_set[:key].should == 2.2
+  end
+end

data/spec/redis_objects_conn_spec.rb

@@ -34,8 +34,8 @@ describe 'Connection tests' do
     obj.redis_value.value.should == nil
 
     obj.default_redis_value.clear
-    obj.redis_value.value = 'foo'
-    obj.redis_value.value.should == 'foo'
+    obj.redis_value.value = 'bar'
+    obj.redis_value.value.should == 'bar'
     obj.default_redis_value.value.should == nil
 
     obj.redis_value.clear
@@ -96,14 +96,9 @@ describe 'Connection tests' do
   end
 
   it "should support local handles with a vanilla redis connection" do
-    # Redis.current = nil  # reset from other tests
     Redis::Objects.redis = nil
     @redis_handle = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
-
-    # Redis.current is lazily auto-populated to touch 6379
-    # This why we choose the weird 9212 port to avoid
-    # Redis.current.inspect.should == Redis.new.inspect
-    Redis::Objects.redis.inspect.should == Redis.new.inspect
+    raises_exception{ Redis::Objects.redis.inspect } # NotConnected
 
     v = Redis::Value.new('conn/value', @redis_handle)
     v.clear
@@ -141,14 +136,9 @@ describe 'Connection tests' do
   end
 
   it "should support local handles with a connection_pool" do
-    # Redis.current = nil  # reset from other tests
     Redis::Objects.redis = nil
     @redis_handle = ConnectionPool.new { Redis.new(:host => REDIS_HOST, :port => REDIS_PORT) }
-
-    # Redis.current is lazily auto-populated to touch 6379
-    # This why we choose the weird 9212 port to avoid
-    # Redis.current.inspect.should == Redis.new.inspect
-    Redis::Objects.redis.inspect.should == Redis.new.inspect
+    raises_exception{ Redis::Objects.redis.inspect } # NotConnected
 
     v = Redis::Value.new('conn/value', @redis_handle)
     v.clear

data/spec/redis_objects_instance_spec.rb

@@ -148,7 +148,7 @@ describe Redis::Value do
       end
 
       it "#{meth} should set expiration when expireat option assigned" do
-        @value = Redis::Value.new('spec/value', :expireat => Time.now + 10.seconds)
+        @value = Redis::Value.new('spec/value', :expireat => Time.now + 10)
         @value.send(meth, 'monkey')
         @value.ttl.should > 0
       end
@@ -286,18 +286,28 @@ describe Redis::List do
       @list.get.should == ['a','c','f','j','h','i','a']
     end
 
-    it "should support popping & shifting multiple values" do
+    it "should support popping and shifting multiple values" do
       @list.should.be.empty
 
-      @list << 'a' << 'b' << 'c'
-      @list.shift(2).should == ['a', 'b']
-      @list.shift(2).should == ['c']
-      @list.shift(2).should == []
+      @list << 'a' << 'b' << 'c' << 'd'
+      @list.should == ['a', 'b', 'c', 'd']
+      @list.shift
+      @list.should == ['b', 'c', 'd']
+      @list.shift(2).should == ['b', 'c']
+      @list.should == ['d']
+      @list.shift(2).should == ['d']
+      @list.shift(2).should == nil
 
-      @list << 'a' << 'b' << 'c'
-      @list.pop(2).should == ['b', 'c']
-      @list.pop(2).should == ['a']
-      @list.pop(2).should == []
+      @list << 'e' << 'f' << 'g'
+
+      # Old behavior
+      # @list.pop(2).should == ['f', 'g']
+
+      # New behavior
+      @list.pop(2).should == ['g', 'f']
+
+      @list.pop(2).should == ['e']
+      @list.pop(2).should == nil
     end
 
     it "should handle rpoplpush" do
@@ -412,7 +422,7 @@ describe Redis::List do
       end
 
       it "#{meth} expireat: option" do
-        @list = Redis::List.new('spec/list_exp', :expireat => Time.now + 10.seconds)
+        @list = Redis::List.new('spec/list_exp', :expireat => Time.now + 10)
         @list.clear
         @list.send(meth, 'val')
         @list.ttl.should > 0
@@ -430,7 +440,7 @@ describe Redis::List do
     end
 
     it "[]= expireat: option" do
-      @list = Redis::List.new('spec/list_exp', :expireat => Time.now + 10.seconds)
+      @list = Redis::List.new('spec/list_exp', :expireat => Time.now + 10)
       @list.clear
       @list.redis.rpush(@list.key, 'hello')
       @list[0] = 'world'
@@ -448,7 +458,7 @@ describe Redis::List do
     end
 
     it "insert expireat: option" do
-      @list = Redis::List.new('spec/list_exp', :expireat => Time.now + 10.seconds)
+      @list = Redis::List.new('spec/list_exp', :expireat => Time.now + 10)
       @list.clear
       @list.redis.rpush(@list.key, 'hello')
       @list.insert 'BEFORE', 'hello', 'world'
@@ -586,7 +596,7 @@ describe Redis::Counter do
           @counter.ttl.should <= 10
         end
         it "expireat: option" do
-          @counter = Redis::Counter.new('spec/counter_exp', :expireat => Time.now + 10.seconds)
+          @counter = Redis::Counter.new('spec/counter_exp', :expireat => Time.now + 10)
           @counter.send(meth)
           @counter.ttl.should > 0
           @counter.ttl.should <= 10
@@ -600,14 +610,14 @@ describe Redis::Counter do
    [:set, :value=].each do |meth|
       describe meth do
         it "expiration: option" do
-          @counter = Redis::Counter.new('spec/counter_exp', :expireat => Time.now + 10.seconds)
+          @counter = Redis::Counter.new('spec/counter_exp', :expireat => Time.now + 10)
           @counter.send(meth, 99)
           @counter.should == 99
           @counter.ttl.should > 0
           @counter.ttl.should <= 10
         end
         it "expireat: option" do
-          @counter = Redis::Counter.new('spec/counter_exp', :expireat => Time.now + 10.seconds)
+          @counter = Redis::Counter.new('spec/counter_exp', :expireat => Time.now + 10)
           @counter.send(meth, 99)
           @counter.should == 99
           @counter.ttl.should > 0
@@ -805,22 +815,25 @@ end
 describe Redis::HashKey do
   describe "With Marshal" do
     before do
-      @hash = Redis::HashKey.new('test_hash', {:marshal_keys=>{'created_at'=>true}})
+      @hash = Redis::HashKey.new('test_hash', {:marshal_keys=>{'created_at' => true}})
       @hash.clear
     end
 
     it "should marshal specified keys" do
-      @hash['created_at'] = Time.now
+      time = Time.now
+      @hash['created_at'] = time
+      @hash['created_at'].should == time
       @hash['created_at'].class.should == Time
     end
 
     it "should not marshal unless required" do
-      @hash['updated_at'] = Time.now
+      @hash['updated_at'] = 10
+      @hash['updated_at'].should == "10"
       @hash['updated_at'].class.should == String
     end
 
     it "should marshall appropriate key with bulk set and get" do
-      @hash.bulk_set({'created_at'=>Time.now, 'updated_at'=>Time.now})
+      @hash.bulk_set({'created_at' => Time.now, 'updated_at' => 11})
 
       @hash['created_at'].class.should == Time
       @hash['updated_at'].class.should == String
@@ -849,7 +862,7 @@ describe Redis::HashKey do
     # no marshaling
     @hash.options[:marshal] = false
     v = {:json => 'data'}
-    @hash['abc'] = v
+    @hash['abc'] = v.to_s
     @hash['abc'].should == v.to_s
 
     @hash.options[:marshal] = true
@@ -1075,7 +1088,7 @@ describe Redis::HashKey do
       end
 
       it "#{meth} expireat: option" do
-        @hash = Redis::HashKey.new('spec/hash_expireat', :expireat => Time.now + 10.seconds)
+        @hash = Redis::HashKey.new('spec/hash_expireat', :expireat => Time.now + 10)
         @hash.clear
         @hash.send(meth, *args)
         @hash.ttl.should > 0
@@ -1294,7 +1307,7 @@ describe Redis::Set do
       end
 
       it "should set expiration when expireat option assigned" do
-        @set = Redis::Set.new('spec/set', :expireat => Time.now + 10.seconds)
+        @set = Redis::Set.new('spec/set', :expireat => Time.now + 10)
         @set.send(meth, 'val')
         @set.ttl.should > 0
         @set.ttl.should <= 10
@@ -1558,7 +1571,7 @@ describe Redis::SortedSet do
   end
 
   it 'should set expiration when expireat option assigned' do
-    @set = Redis::SortedSet.new('spec/zset', :expireat => Time.now + 10.seconds)
+    @set = Redis::SortedSet.new('spec/zset', :expireat => Time.now + 10)
     @set['val'] = 1
     @set.ttl.should > 0
     @set.ttl.should <= 10
@@ -1590,7 +1603,7 @@ describe Redis::SortedSet do
         @set.ttl.should <= 10
       end
       it "#{meth} expireat: option" do
-        @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10.seconds)
+        @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10)
         @set.clear
         @set.send(meth, 'somekey', 12)
         @set.ttl.should > 0
@@ -1607,7 +1620,7 @@ describe Redis::SortedSet do
         @set.ttl.should <= 10
       end
       it "#{meth} expireat: option" do
-        @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10.seconds)
+        @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10)
         @set.clear
         @set.send(meth, 'somekey' => 12)
         @set.ttl.should > 0
@@ -1626,7 +1639,7 @@ describe Redis::SortedSet do
       end
 
       it "#{meth} expireat: option" do
-        @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10.seconds)
+        @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10)
         @set.clear
         @set.redis.zadd(@set.key, 1, "1")
         @set.send(meth, 'sets', Redis::SortedSet.new('other'))
@@ -1646,7 +1659,7 @@ describe Redis::SortedSet do
     end
 
     it "delete expireat: option" do
-      @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10.seconds)
+      @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10)
       @set.clear
       @set.redis.zadd(@set.key, 1, "1")
       @set.redis.zadd(@set.key, 2, "2")

data/spec/redis_objects_model_spec.rb

@@ -10,18 +10,18 @@ class Roster
   counter :pitchers, :limit => :max_pitchers
   counter :basic
   hash_key :contact_information, :marshal_keys=>{'updated_at'=>true}
-  lock :resort, :timeout => 2
+  redis_lock :resort, :timeout => 2
   value :starting_pitcher, :marshal => true
   list :player_stats, :marshal => true
   set :outfielders, :marshal => true
   sorted_set :rank
-  lock :per_field
+  redis_lock :per_field
 
   # global class counters
   counter :total_players_online, :global => true
   set :all_players_online, :global => true
   value :last_player, :global => true
-  lock :nasty_global_mutex, :global => true  # remember it appends "_lock"
+  redis_lock :nasty_global_mutex, :global => true  # remember it appends "_lock"
   sorted_set :global_player_leaderboard, :global => true
   hash_key :global_player_online_status, :global => true
 
@@ -966,9 +966,13 @@ describe Redis::Objects do
   end
 
   it "should pick up class methods from superclass automatically" do
+    Roster.redis_prefix.should == 'roster'
     CounterRoster = Class.new(Roster)
+    CounterRoster.redis_prefix.should == 'counter_roster'
     CounterRoster.counter :extended_counter
     extended_roster = CounterRoster.new
+    Roster.redis_prefix.should == 'roster'
+    extended_roster.class.redis_prefix.should == 'counter_roster'
     extended_roster.basic.should.be.kind_of(Redis::Counter)
     extended_roster.extended_counter.should.be.kind_of(Redis::Counter)
     @roster.respond_to?(:extended_counter).should == false
@@ -981,7 +985,7 @@ describe Redis::Objects do
     @roster.respond_to?(:extended_hash_key).should == false
 
     LockRoster = Class.new(Roster)
-    LockRoster.lock :extended
+    LockRoster.redis_lock :extended
     extended_roster = LockRoster.new
     extended_roster.resort_lock.should.be.kind_of(Redis::Lock)
     extended_roster.extended_lock.should.be.kind_of(Redis::Lock)

data/spec/spec_helper.rb

@@ -10,7 +10,7 @@ if $0 =~ /\brspec$/
 end
 
 # For the incompatible change from redis.rb
-Redis.exists_returns_integer =  true
+# Redis.exists_returns_integer =  true
 
 # Avoid phantom remote test failures
 RUNNING_LOCALLY = !ENV['TRAVIS']
@@ -61,7 +61,7 @@ def kill_redis
   Process.kill "TERM", pid
   Process.kill "KILL", pid
   File.unlink pidfile
-  File.unlink rdbfile if File.exists? rdbfile
+  File.unlink rdbfile if File.exist? rdbfile
 end
 
 # Start redis-server except under JRuby

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: redis-objects
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 2.0.0.beta
 platform: ruby
 authors:
 - Nate Wiger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-22 00:00:00.000000000 Z
+date: 2023-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -188,6 +188,7 @@ files:
 - lib/redis/value.rb
 - redis-objects.gemspec
 - spec/redis_autoload_objects_spec.rb
+- spec/redis_legacy_key_naming_spec.rb
 - spec/redis_namespace_compat_spec.rb
 - spec/redis_objects_active_record_spec.rb
 - spec/redis_objects_conn_spec.rb
@@ -210,16 +211,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Map Redis types directly to Ruby objects
 test_files:
 - spec/redis_autoload_objects_spec.rb
+- spec/redis_legacy_key_naming_spec.rb
 - spec/redis_namespace_compat_spec.rb
 - spec/redis_objects_active_record_spec.rb
 - spec/redis_objects_conn_spec.rb