redis-objects 2.0.0.beta → 2.0.0.beta2

data/lib/redis/objects/version.rb

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

data/lib/redis/objects.rb

@@ -66,6 +66,19 @@ class 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,11 +114,6 @@ class Redis
         @redis_objects ||= {}
       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
@@ -114,10 +122,10 @@ class Redis
 
       def redis_prefix(klass = self) #:nodoc:
         @redis_prefix ||=
-          if redis_legacy_naming
+          if Objects.redis_legacy_naming?
+            redis_legacy_naming_warning_message(klass)
             redis_legacy_prefix(klass)
           else
-            redis_legacy_naming_warning_message(klass)
             redis_modern_prefix(klass)
           end
 
@@ -140,45 +148,68 @@ class Redis
           downcase
       end
 
-        # Temporary warning to help with migrating key names
+      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
-        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!
+        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
-        end
       end
 
-      def migrate_redis_legacy_keys
-        cursor = 0
+      # 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
-        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})"
+        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 "[redis-objects] Migrating keys from #{legacy} prefix to #{redis_prefix}"
+
+        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}:*")
+          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 ':'
-            base_class, id, name = key.split(':')
+            # 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=id, context=self)
+            new_key = redis_field_key(name, id)
 
             # Rename the key
-            warn "[redis-objects] Rename '#{key}', '#{new_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
@@ -186,6 +217,10 @@ EOW
         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)
@@ -207,18 +242,24 @@ EOW
         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/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

data/spec/redis_objects_model_spec.rb

@@ -6,6 +6,7 @@ Redis::Objects.redis = REDIS_HANDLE
 
 class Roster
   include Redis::Objects
+
   counter :available_slots, :start => 10
   counter :pitchers, :limit => :max_pitchers
   counter :basic
@@ -35,7 +36,7 @@ class Roster
   def self.jimmyhat; 350; end
   value :weird_key, :key => 'players:weird_key:#{jimmyhat}', :global => true
 
-  #callable as key
+  # callable as key
   counter :daily, :global => true, :key => Proc.new { |roster| "#{roster.name}:#{Time.now.strftime('%Y-%m-%dT%H')}:daily" }
 
   # set default expiration
@@ -61,16 +62,31 @@ class Roster
 end
 
 class VanillaRoster < Roster
-  # No explicit Redis::Objects
+  # inherits Redis::Objects
+  # No explicit RedisAccessors (but they are inherited)
 end
 
 class CustomRoster < Roster
-  include Redis::Objects
+  # inherits Redis::Objects
 
   counter :basic # Override
   counter :special # New
 end
 
+class UidRoster < Roster
+  # inherits Redis::Objects
+
+  attr_accessor :uid
+  def initialize(uid=123) @uid = uid end
+end
+
+class CustomIdFieldRoster < UidRoster
+  # inherits Redis::Objects
+  redis_id_field :uid
+
+  counter :basic
+end
+
 class MethodRoster
   def increment(attribute, by=1)
     42
@@ -87,18 +103,24 @@ class CustomMethodRoster < MethodRoster
   counter :basic
 end
 
-class UidRoster < Roster
-  attr_accessor :uid
-  def initialize(uid=123) @uid = uid end
-end
 
-class CustomIdFieldRoster < UidRoster
-  redis_id_field :uid
-  include Redis::Objects
-  counter :basic
-end
+# TODO: @redis_objects is un-initialized in subclasses. It only picks up accessors declared within the subclass itself.
+#       but all the accessors continue to work as expected.
+=begin
+puts "Roster.redis_objects.length: #{Roster.redis_objects.length} (expected: 35)" # got 35
+VanillaRoster.total_players_online.increment(5)
+VanillaRoster.global_player_leaderboard.add('nate', 22)
+puts "VanillaRoster.redis_objects.length: #{VanillaRoster.redis_objects.length} (expected: 35)" # got 0
+puts "VanillaRoster: total_players_online: #{VanillaRoster.total_players_online} global_player_leaderboard: #{VanillaRoster.global_player_leaderboard}" # got 5 & nate
+puts "CustomRoster.redis_objects.length: #{CustomRoster.redis_objects.length} (expected: 36)" # got 2
+puts "UidRoster.redis_objects.length: #{UidRoster.redis_objects.length} (expected: 35)" # got 0
+puts "CustomIdFieldRoster.redis_objects.length: #{CustomIdFieldRoster.redis_objects.length} (expected: 35)" # got 1
+#puts "MethodRoster.redis_objects.length: #{MethodRoster.redis_objects.length}"
+puts "CustomMethodRoster.redis_objects.length: #{CustomMethodRoster.redis_objects.length} (expected: 1)" # got 1
+=end
 
 describe Redis::Objects do
+  # Before each
   before do
     @roster  = Roster.new
     @roster2 = Roster.new