redis-objects 1.7.0 → 2.0.0

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"
   end
 end

data/lib/redis/objects.rb

@@ -62,10 +62,23 @@ 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
 
+      # Toggles whether to use the legacy redis key naming scheme, which causes
+      # naming conflicts in certain cases.
+      # (attr_accessor with a default value)
+      attr_writer :prefix_style
+      def prefix_style
+        # NOTE: In a future release the default will change to :modern
+        @prefix_style ||= :legacy
+      end
+
+      def redis_legacy_naming?
+        prefix_style == :legacy
+      end
+
       def included(klass)
         # Core (this file)
         klass.instance_variable_set(:@redis, nil)
@@ -101,16 +114,115 @@ 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
+      # 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 Objects.redis_legacy_naming?
+            redis_legacy_naming_warning_message(klass)
+            redis_legacy_prefix(klass)
+          else
+            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
 
+      attr_accessor :redis_silence_warnings
+
+      # 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
+        return if redis_silence_warnings || @silence_warnings_as_redis_prefix_was_set_manually
+
+        modern = redis_modern_prefix(klass)
+        legacy = redis_legacy_prefix(klass)
+        return if modern == legacy
+
+        warn <<EOW
+
+[redis-objects] WARNING: redis-objects 2.0.0, revises key naming to fix a longstanding bug.
+[redis-objects] Your class #{klass.name} should be updated to resolve this bug!
+[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
+
+      # To be run once per Redis::Objects enhanced model
+      def migrate_redis_legacy_keys(scan_count=10, verbose=false)
+        unless Objects.redis_legacy_naming?
+          raise "Redis::Objects is already configured to use modern key prefixes."
+        end
+
+        legacy = redis_legacy_prefix
+        modern = redis_modern_prefix
+        if modern == legacy
+          warn "[redis-objects] #{self.name}.#{__method__} NOOP. Legacy and modern redis_prefix are the same (#{modern})"
+          return
+        end
+
+        warn "\n[redis-objects] Migrating keys from '#{legacy}' prefix to '#{modern}'"
+
+        cursor = 0
+        total_keys = 0
+
+        # Temporarily update the prefix to modern while we update these keys.
+        # NOTE: we cannot simply adjust the prefix_style, because the prefix is cached by @redis_prefix
+        self.redis_prefix = modern
+
+        loop do
+          cursor, keys = redis.scan(cursor, :match => "#{legacy}:*", :count => scan_count)
+          # REM: scan returns keys in a randomized order
+          keys.sort!
+          #puts "got #{keys.length} keys"
+          total_keys += keys.length
+          keys.each do |key|
+            # Split key name apart on ':'
+            # REM: global keys will have an empty id
+            #      klass::object_accessor_name
+            _base_class, id, name = key.split(':')
+
+            # Figure out the new name
+            new_key = redis_field_key(name, id)
+
+            # Rename the key
+            if verbose
+              warn "[redis-objects] Rename '#{key}', '#{new_key}'"
+            end
+            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"
+
+      ensure
+        # Change the prefix back (just in case)
+        self.redis_prefix = legacy
+      end
+
       def redis_options(name)
         klass = first_ancestor_with(name)
         return klass.redis_objects[name.to_sym] || {}
@@ -130,18 +242,24 @@ class Redis
         klass = first_ancestor_with(name)
         # READ THIS: This can never ever ever ever change or upgrades will corrupt all data
         # I don't think people were using Proc as keys before (that would create a weird key). Should be ok
+        
+        # If a custom key was set for this accessor
         if key = klass.redis_objects[name.to_sym][:key]
+          # If that custom key was callable (E.G. a proc)
           if key.respond_to?(:call)
             key = key.call context
           else
             context.instance_eval "%(#{key})"
           end
+
         else
+          # If its not a global key, and ID is nil, then throw an error
           if id.nil? and !klass.redis_objects[name.to_sym][:global]
             raise NilObjectId,
               "[#{klass.redis_objects[name.to_sym]}] Attempt to address redis-object " +
               ":#{name} on class #{klass.name} with nil id (unsaved record?) [object_id=#{object_id}]"
           end
+          # Otherwise return the constructed key
           "#{redis_prefix(klass)}:#{id}:#{name}"
         end
       end

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

@@ -0,0 +1,427 @@
+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 'Redis key prefix naming compatibility' do
+
+  describe 'verifies single level classes' do # context
+
+    it 'work the same (modern)' do
+      Redis::Objects.prefix_style = :modern
+
+      class SingleLevelOne
+        include Redis::Objects
+
+        def id
+          1
+        end
+      end
+
+      obj = SingleLevelOne.new
+      obj.class.redis_prefix.should == 'single_level_one'
+    end
+
+    it 'work the same (legacy)' do
+      Redis::Objects.prefix_style = :legacy
+
+      class SingleLevelTwo
+        include Redis::Objects
+
+        def id
+          1
+        end
+      end
+
+      obj = SingleLevelTwo.new
+      obj.class.redis_prefix.should == 'single_level_two'
+    end
+
+  end # context
+
+  describe 'verifies nested classes' do # context
+
+    it 'do NOT work the same (modern)' do
+      Redis::Objects.prefix_style = :modern
+
+      module Nested
+        class NamingOne
+          include Redis::Objects
+
+          def id
+            1
+          end
+        end
+      end
+
+      obj = Nested::NamingOne.new
+      obj.class.redis_prefix.should == 'nested__naming_one'
+    end
+
+    it 'do NOT work the same (legacy)' do
+      Redis::Objects.prefix_style = :legacy
+
+      module Nested
+        class NamingTwo
+          include Redis::Objects
+          self.redis_silence_warnings = true
+
+          def id
+            1
+          end
+        end
+      end
+
+      obj = Nested::NamingTwo.new
+      obj.class.redis_prefix.should == 'naming_two'
+    end
+
+  end # context
+
+  describe 'verifies that multiple levels' do # context
+
+    it 'respect __ vs _' do
+      Redis::Objects.prefix_style = :modern
+
+      module NestedLevel
+        module Further
+          class NamingThree
+            include Redis::Objects
+
+            def id
+              1
+            end
+          end
+        end
+      end
+
+      obj = NestedLevel::Further::NamingThree.new
+      obj.class.redis_prefix.should == 'nested_level__further__naming_three'
+    end
+
+    it 'respect legacy naming' do
+      Redis::Objects.prefix_style = :legacy
+
+      module NestedLevel
+        module Further
+          class NamingFour
+            include Redis::Objects
+            self.redis_silence_warnings = 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
+
+      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 'do not conflict 1' do
+      Redis::Objects.prefix_style = :modern
+
+      module NestedLevel
+        module Further
+          class NamingFive
+            include Redis::Objects
+
+            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 'do not conflict 2' do
+      Redis::Objects.prefix_style = :modern
+
+      module Nested
+        module LevelFurtherNaming
+          class Five
+            include Redis::Objects
+
+            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 'do not conflict 3' do
+      Redis::Objects.prefix_style = :modern
+
+      module Nested
+        module LevelFurther
+          class NamingFive
+            include Redis::Objects
+
+            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
+
+  end # context
+
+  describe 'handles dynamically created classes correctly' do # context
+
+    it 'in modern mode' do
+      Redis::Objects.prefix_style = :modern
+
+      module Nested
+        class LevelSix
+          include Redis::Objects
+
+          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 'in legacy mode' do
+      Redis::Objects.prefix_style = :legacy
+
+      module Nested
+        class LevelSeven
+          include Redis::Objects
+          self.redis_silence_warnings = 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
+
+  end # context
+
+  # ---- other tests ----
+
+  it 'prints a warning message if the key name changes' do
+    Redis::Objects.prefix_style = :legacy
+
+    module Nested
+      class LevelNine
+        include Redis::Objects
+
+        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
+      def self.make_class
+        # TODO notes
+        klass = Class.new do
+          def initialize(id)
+            @id = id
+          end
+          def id
+            @id
+          end
+
+          include Redis::Objects
+
+          self.redis_silence_warnings = true
+
+          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
+
+          # use a callable as the key
+          value :global_proc_value, :global => true, :key => Proc.new { |roster| "#{roster.name}:#{Time.now.strftime('%Y-%m-%dT%H')}:daily" }
+        end
+      end
+    end
+
+    # First define the class using legacy prefix
+    Redis::Objects.prefix_style = :legacy
+    Nested::UpgradeTest = Nested.make_class
+
+    # Sanity checks
+    Nested::UpgradeTest.redis_objects.length.should == 13
+    Nested::UpgradeTest.redis_prefix.should == 'upgrade_test'
+
+    # Create a whole bunch of keys using the legacy prefixed keys
+
+    30.times do |i|
+      # warn i.inspect
+      obj = Nested::UpgradeTest.new(i)
+      obj.redis_value = 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::UpgradeTest.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
+
+    # Run the upgrade
+    Nested::UpgradeTest.migrate_redis_legacy_keys(1000)
+
+    # Re-Create the class using modern prefix
+    Nested.send(:remove_const, :UpgradeTest)
+    Redis::Objects.prefix_style = :modern
+    Nested::UpgradeTest = Nested.make_class
+
+    # Sanity checks
+    Nested::UpgradeTest.redis_objects.length.should == 13
+    Nested::UpgradeTest.redis_prefix.should == 'nested__upgrade_test'
+
+    # Try to access the keys through modern prefixed keys now
+    30.times do |i|
+      # warn i.inspect
+      obj = Nested::UpgradeTest.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::UpgradeTest.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.include?('a').should == true
+    obj.global_set.include?('b').should == true
+    obj.global_sorted_set[:key].should == 2.2
+  end
+
+end

data/spec/redis_objects_active_record_spec.rb

@@ -44,7 +44,7 @@ begin
     def self.up
       create_table :posts do |t|
         t.string :title
-        t.string :description, :length => 200
+        t.string :description, :limit => 200
         t.integer :total
         t.integer :blog_id
         t.timestamps null: true