redis-objects 1.5.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1645ef709707def1356b48d10f02ed09c7cffc5e83568dc3b2d14c030fdff3d7
-  data.tar.gz: f1ef896dfaa12b573631417eaae3039bf16fd0d07ea4019956aa002c24a057f5
+  metadata.gz: a34d5bd684e2dfb04c3216b84fc8c0d0ac4b8037919ba6f887bd1930e3eca727
+  data.tar.gz: e3b4c9df6c48b594850948dd437cec9acecb9a7622102f71d57a4f17068e7fd8
 SHA512:
-  metadata.gz: a9d492b56d5c712d5c33d19ac682fd45eb937ead9dba84d7123346a40aaf88020dd6be82c8697342a130470f8a23bf0d3cc701e6691cf15e685efc1aec64737a
-  data.tar.gz: c5033f81a4d8c9aba6798aca9bf49cf5613217b6ef388252df92fe099111b4a85c0709e96fc64fcfe2bb0cc54720a536f2b08ea6c49976d44604347d7049b978
+  metadata.gz: 99d33225c4326dec14e62b14e2c0735ac688b7c1d7a86f767d0141fe3a49782e2fc41e02c80cf8c16a79e0c570249e4e3f758e86d1c652688566b4392890abd8
+  data.tar.gz: d1c6831c0d327fa3f6b2e5e8b3ed45deacdc4373836565084ed16e7492219c7de73e5d79ccc61f0bf28863ad10ef185284c81799369a27fa1cd3f375e426b61c

data/.gitignore

@@ -9,3 +9,5 @@ spec/redis.pid
 dump.rdb
 Gemfile.lock
 redis-objects-*.gem
+coverage/
+.DS_Store

data/.travis.yml

@@ -5,7 +5,12 @@ before_install:
   - gem install bundler
 
 rvm:
-  - 2.3.3
-  - 2.4.0
-  - 2.5.1
-  - 2.6.4
+  - 2.3.8
+  - 2.4.10
+  - 2.5.9
+  - 2.6.7
+  - 2.7.3
+  - 3.0.1
+
+# For code coverage reports
+script: bundle exec rake

data/CHANGELOG.rdoc

@@ -1,5 +1,30 @@
 = Changelog for Redis::Objects
 
+== 1.7.0 (29 Apr 2022)
+
+* Bumped version to 1.7.0 to revert redis-rb version lock [Nate Wiger]
+
+== 1.6.0 (29 Apr 2022)
+
+* Upgrade version to 1.6.0 due to redis-rb changes to Redis.current [Nate Wiger]
+
+== 1.5.1 (10 Jul 2021)
+
+* Added double-splat for **options to account for Ruby 3.0  [Nate Wiger]
+
+* Fix ConnectionPoolProxy Ruby 3.0 compatibility Fix: https://github.com/nateware/redis-objects/pull/258 [Jean byroot Boussier]
+
+* Change Redis#exists to Redis#exists? * bump redis version to 4.2 [Alina Hryshchuk]
+
+* Local variable `dir` is not in use since 98226b95f35ef455f231692fdb679dfd61200a78 [Akira Matsuda]
+
+* Issue 249: when atomic decrbyfloat fails, increment back instead of decrementing again [Slava Samoliuk]
+
+* Update documentation to reflect ability to assign values directly [Artin Boghosian]
+
+* Allow directly assigning values of lists, hashes and sets [Artin Boghosian]
+
+
 == 1.5.0 (18 Sep 2019)
 
 * updated README on expireat  [Nate Wiger]

data/README.md

@@ -1,7 +1,8 @@
 Redis::Objects - Map Redis types directly to Ruby objects
 =========================================================
 
-[![Build Status](https://travis-ci.org/nateware/redis-objects.png)](https://travis-ci.org/nateware/redis-objects)
+[![Build Status](https://app.travis-ci.com/nateware/redis-objects.svg?branch=master)](https://travis-ci.com/github/nateware/redis-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)
 
 This is **not** an ORM. People that are wrapping ORM’s around Redis are missing the point.
@@ -144,6 +145,7 @@ Familiar Ruby array operations Just Work (TM):
 @team.on_base.shift
 @team.on_base.length  # 1
 @team.on_base.delete('player2')
+@team.on_base = ['player1', 'player2']  # ['player1', 'player2']
 ~~~
 
 Sets work too:
@@ -157,6 +159,15 @@ Sets work too:
   puts player
 end
 player = @team.outfielders.detect{|of| of == 'outfielder2'}
+@team.outfielders = ['outfielder1', 'outfielder3']  # ['outfielder1', 'outfielder3']
+~~~
+
+Hashes work too:
+
+~~~ruby
+@team.pitchers_faced['player1'] = 'pitcher2'
+@team.pitchers_faced['player2'] = 'pitcher1'
+@team.pitchers_faced = { 'player1' => 'pitcher2', 'player2' => 'pitcher1' }
 ~~~
 
 And you can do unions and intersections between objects (kinda cool):

data/lib/redis/counter.rb

@@ -102,7 +102,7 @@ class Redis
     def decrbyfloat(by=1.0, &block)
       allow_expiration do
         val = redis.incrbyfloat(key, -by).to_f
-        block_given? ? rewindable_block(:incrbyfloat, -by, val, &block) : val
+        block_given? ? rewindable_block(:incrbyfloat, by, val, &block) : val
       end
     end
 
@@ -112,7 +112,7 @@ class Redis
     alias_method :to_i, :value
 
     def nil?
-      !redis.exists(key)
+      !redis.exists?(key)
     end
 
     ##

data/lib/redis/enumerable_object.rb

@@ -16,7 +16,7 @@ class Redis
     def sort(options={})
       return super() if block_given?
       options[:order] = "asc alpha" if options.keys.count == 0  # compat with Ruby
-      val = redis.sort(key, options)
+      val = redis.sort(key, **options)
       val.is_a?(Array) ? val.map{|v| unmarshal(v)} : val
     end
 

data/lib/redis/hash_key.rb

@@ -123,24 +123,20 @@ class Redis
       hsh
     end
 
-    # Get values in bulk, takes an array of keys as arguments.
+    # Get values in bulk, takes an array of fields as arguments.
     # Values are returned in a collection in the same order than their keys in *keys Redis: HMGET
-    def bulk_values(*keys)
-      get_keys = *keys.flatten
-      return [] if get_keys.empty?
-      res = redis.hmget(key, get_keys)
-      get_keys.inject([]){|collection, k| collection << unmarshal(res.shift, options[:marshal_keys][k])}
+    def bulk_values(*fields)
+      get_fields = *fields.flatten
+      return [] if get_fields.empty?
+      res = redis.hmget(key, get_fields)
+      get_fields.collect{|k| unmarshal(res.shift, options[:marshal_keys][k])}
     end
 
     # Increment value by integer at field. Redis: HINCRBY
     def incrby(field, by=1)
       allow_expiration do
         ret = redis.hincrby(key, field, by)
-        unless ret.is_a? Array
-          ret.to_i
-        else
-          nil
-        end
+        ret.to_i
       end
     end
     alias_method :incr, :incrby
@@ -155,11 +151,7 @@ class Redis
     def incrbyfloat(field, by=1.0)
       allow_expiration do
         ret = redis.hincrbyfloat(key, field, by)
-        unless ret.is_a? Array
-          ret.to_f
-        else
-          nil
-        end
+        ret.to_f
       end
     end
 

data/lib/redis/helpers/core_commands.rb

@@ -2,10 +2,14 @@ class Redis
   module Helpers
     # These are core commands that all types share (rename, etc)
     module CoreCommands
-      def exists?
+      def exists
         redis.exists key
       end
 
+      def exists?
+        redis.exists? key
+      end
+
       # Delete key. Redis: DEL
       def delete
         redis.del key

data/lib/redis/objects/connection_pool_proxy.rb

@@ -9,6 +9,7 @@ class Redis
       def method_missing(name, *args, &block)
         @pool.with { |x| x.send(name, *args, &block) }
       end
+      ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
 
       def respond_to_missing?(name, include_all = false)
         @pool.with { |x| x.respond_to?(name, include_all) }

data/lib/redis/objects/hashes.rb

@@ -26,6 +26,15 @@ class Redis
                   )
                 )
             end
+
+            define_method(:"#{name}=") do |values|
+              hash_key = public_send(name)
+
+              redis.pipelined do
+                hash_key.clear
+                hash_key.bulk_set(values)
+              end
+            end
           end
 
           if options[:global]

data/lib/redis/objects/lists.rb

@@ -26,6 +26,15 @@ class Redis
                   )
                 )
             end
+
+            define_method(:"#{name}=") do |values|
+              list = public_send(name)
+
+              redis.pipelined do
+                list.clear
+                list.push(*values)
+              end
+            end
           end
 
           if options[:global]

data/lib/redis/objects/sets.rb

@@ -26,6 +26,15 @@ class Redis
                   )
                 )
             end
+
+            define_method(:"#{name}=") do |values|
+              set = public_send(name)
+
+              redis.pipelined do
+                set.clear
+                set.merge(*values)
+              end
+            end
           end
 
           if options[:global]

data/lib/redis/objects/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Objects
-    VERSION = "1.5.0"
+    VERSION = "1.7.0"
   end
 end

data/lib/redis/objects.rb

@@ -46,8 +46,6 @@ class Redis
   #
   #
   module Objects
-    dir = File.expand_path(__FILE__.sub(/\.rb$/,''))
-
     autoload :Counters,   'redis/objects/counters'
     autoload :Lists,      'redis/objects/lists'
     autoload :Locks,      'redis/objects/locks'

data/lib/redis/sorted_set.rb

@@ -117,7 +117,7 @@ class Redis
                 options[:offset] || options[:limit] || options[:count]
       args[:with_scores] = true if options[:withscores] || options[:with_scores]
 
-      redis.zrangebyscore(key, min, max, args).map{|v| unmarshal(v) }
+      redis.zrangebyscore(key, min, max, **args).map{|v| unmarshal(v) }
     end
 
     # Returns all the elements in the sorted set at key with a score between max and min
@@ -133,7 +133,7 @@ class Redis
                 options[:offset] || options[:limit] || options[:count]
       args[:with_scores] = true if options[:withscores] || options[:with_scores]
 
-      redis.zrevrangebyscore(key, max, min, args).map{|v| unmarshal(v) }
+      redis.zrevrangebyscore(key, max, min, **args).map{|v| unmarshal(v) }
     end
 
     # Remove all elements in the sorted set at key with rank between start and end. Start and end are
@@ -222,7 +222,7 @@ class Redis
     def interstore(name, *sets)
       allow_expiration do
         opts = sets.last.is_a?(Hash) ? sets.pop : {}
-        redis.zinterstore(key_from_object(name), keys_from_objects([self] + sets), opts)
+        redis.zinterstore(key_from_object(name), keys_from_objects([self] + sets), **opts)
       end
     end
 
@@ -258,7 +258,7 @@ class Redis
     def unionstore(name, *sets)
       allow_expiration do
         opts = sets.last.is_a?(Hash) ? sets.pop : {}
-        redis.zunionstore(key_from_object(name), keys_from_objects([self] + sets), opts)
+        redis.zunionstore(key_from_object(name), keys_from_objects([self] + sets), **opts)
       end
     end
 

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", "~> 4.0"
+  spec.add_dependency "redis"
 
   # Ignore gemspec warnings on these.  Trying to fix them to versions breaks TravisCI
   spec.add_development_dependency "bundler"
@@ -29,6 +29,10 @@ Gem::Specification.new do |spec|
 
   # Compatibility testing
   spec.add_development_dependency "redis-namespace"
+  spec.add_development_dependency "activesupport"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
+
+  # Code coverage
+  spec.add_development_dependency "simplecov-cobertura"
 end

data/spec/redis_autoload_objects_spec.rb

@@ -4,7 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 # tests whether autoload functionality works correctly; had issues previously
 
 require 'redis/objects'
-# $redis used automatically
+Redis::Objects.redis = REDIS_HANDLE
 
 describe 'Redis::Objects' do
   it "should autoload everything" do

data/spec/redis_objects_conn_spec.rb

@@ -5,6 +5,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/objects'
 require 'connection_pool'
+Redis::Objects.redis = REDIS_HANDLE
 
 BAD_REDIS = "totally bad bogus redis handle"
 
@@ -95,13 +96,13 @@ describe 'Connection tests' do
   end
 
   it "should support local handles with a vanilla redis connection" do
-    Redis.current = nil  # reset from other tests
+    # 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.current.inspect.should == Redis.new.inspect
     Redis::Objects.redis.inspect.should == Redis.new.inspect
 
     v = Redis::Value.new('conn/value', @redis_handle)
@@ -140,13 +141,13 @@ describe 'Connection tests' do
   end
 
   it "should support local handles with a connection_pool" do
-    Redis.current = nil  # reset from other tests
+    # 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.current.inspect.should == Redis.new.inspect
     Redis::Objects.redis.inspect.should == Redis.new.inspect
 
     v = Redis::Value.new('conn/value', @redis_handle)
@@ -184,24 +185,19 @@ describe 'Connection tests' do
     c.decr(1)
   end
 
-  it "should support Redis.current" do
-    Redis.current = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
-
-    Redis::Value.new('conn/value').should == 'yay'
-    Redis::HashKey.new('conn/hash').keys.should == ['k']
-    Redis::List.new('conn/list').sort.should  == ['3', '4', '5']
-    Redis::Set.new('conn/set').sort.should    == ['5', '6', '7']
-    Redis::SortedSet.new('conn/zset').should  == ['d', 'b', 'a', 'c']
-    Redis::Counter.new('conn/counter').should == 2
+  it "should properly support fallback handle variables" do
+    # Redis.current is lazily auto-populated to touch 6379
+    # This why we choose the weird 9212 port to avoid
+    old_redis = $redis
+    $redis = BAD_REDIS
+    Redis::Objects.redis.should == BAD_REDIS
+    $redis = old_redis
   end
 
   it "should support Redis::Objects.redis= with a connection_pool" do
+    # reset redis
     @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 = BAD_REDIS
-    Redis::Objects.redis.should == BAD_REDIS
+    Redis::Objects.redis = @redis_handle
 
     # This set of tests sucks, it fucks up the per-data-type handles
     # because Redis.current is then set to a BS value, and the lazy
@@ -229,13 +225,8 @@ describe 'Connection tests' do
 
   it "should support Redis::Objects.redis= with a vanilla redis connection" do
     # reset redis
-    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 = BAD_REDIS
-    Redis::Objects.redis.should == BAD_REDIS
+    Redis::Objects.redis = @redis_handle
 
     # This set of tests sucks, it fucks up the per-data-type handles
     # because Redis.current is then set to a BS value, and the lazy
@@ -260,7 +251,7 @@ describe 'Connection tests' do
     Redis::Counter.new('conn/counter').should == 2
 
     # Fix for future tests
-    Redis.current = @redis_handle
+    # Redis.current = @redis_handle
   end
 
   it "should support pipelined changes" do

data/spec/redis_objects_custom_serializer.rb

@@ -2,6 +2,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/objects'
+Redis::Objects.redis = REDIS_HANDLE
 
 class CustomSerializer
   class << self

data/spec/redis_objects_instance_spec.rb

@@ -2,6 +2,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/objects'
+Redis::Objects.redis = REDIS_HANDLE
 
 describe Redis::Value do
   before do
@@ -19,6 +20,21 @@ describe Redis::Value do
     @value.value.should == false
   end
 
+  it "should handle simple values" do
+    @value.should == nil
+    @value.value = 'Trevor Hoffman'
+    @value.should == 'Trevor Hoffman'
+    @value.get.should == 'Trevor Hoffman'
+    @value.exists?.should == true
+    @value.exists.should == 1
+    @value.del.should == 1
+    @value.should.be.nil
+    @value.exists?.should == false
+    @value.exists.should == 0
+    @value.value = 42
+    @value.value.should == '42'
+  end
+
   it "should compress non marshaled values" do
     @value = Redis::Value.new('spec/value', compress: true)
     @value.value = 'Trevor Hoffman'
@@ -39,17 +55,8 @@ describe Redis::Value do
     @value.value.should == nil
     @value.value = ''
     @value.value.should == ''
-  end
-
-  it "should handle simple values" do
-    @value.should == nil
-    @value.value = 'Trevor Hoffman'
-    @value.should == 'Trevor Hoffman'
-    @value.get.should == 'Trevor Hoffman'
-    @value.del.should == 1
-    @value.should.be.nil
-    @value.value = 42
-    @value.value.should == '42'
+    @value.delete
+    @value.value.should.be.nil
   end
 
   it "should handle complex marshaled values" do
@@ -88,7 +95,7 @@ describe Redis::Value do
     marshalled_string = Marshal.dump({json: 'marshal'})
     @value = Redis::Value.new('spec/marshal', :default => marshalled_string, :marshal => true)
     @value.value.should == marshalled_string
-    @value.clear
+    @value.delete
   end
 
   it "should support renaming values" do
@@ -499,23 +506,56 @@ describe Redis::Counter do
     @counter.incrbyfloat 2.0e2
     @counter.to_f.should == 5214.31
     @counter.clear
+    @counter.should.be.nil
   end
 
   it "should support an atomic block" do
     @counter = Redis::Counter.new("spec/block_counter")
     @counter.should == 0
     @counter.increment(1)
-    # The block is never executed.
-    @updated =
-      @counter.increment(1) do |updated|
-        if updated == 2
-          'yep'
-        else
-          raise("test failed")
-        end
-      end
+
+    # successfully increments
+    @updated = @counter.increment(1) { |updated| updated == 2 ? 'yep' : nil }
+    @updated.should == 'yep'
+    @counter.should == 2
+
+    # fails to increment
+    @updated = @counter.increment(1) { |updated| updated == 2 ? 'yep' : nil }
+    @updated.should == nil
+    @counter.should == 2
+
+    # successfully increments by float
+    @updated = @counter.incrbyfloat(1.5) { |updated| updated == 3.5 ? 'yep' : nil }
+    @updated.should == 'yep'
+    @counter.should == 3.5
+
+    # fails to increment by float
+    @updated = @counter.incrbyfloat(2.5) { |updated| updated == 5 ? 'yep' : nil }
+    @updated.should == nil
+    @counter.should == 3.5
+
+    # fails to decrement by float
+    @updated = @counter.decrbyfloat(0.5) { |updated| updated == 5 ? 'yep' : nil }
+    @updated.should == nil
+    @counter.should == 3.5
+
+    # successfully decrements by float
+    @updated = @counter.decrbyfloat(0.5) { |updated| updated == 3 ? 'yep' : nil }
+    @updated.should == 'yep'
+    @counter.should == 3
+
+    # fails to decrement
+    @updated = @counter.decrement(1) { |updated| updated == 3 ? 'yep' : nil }
+    @updated.should == nil
+    @counter.should == 3
+
+    # successfully decrements
+    @updated = @counter.decrement(1) { |updated| updated == 2 ? 'yep' : nil }
     @updated.should == 'yep'
     @counter.should == 2
+
+    @counter.value = nil
+    @counter.should == 0
   end
 
   it "should support #to_json" do
@@ -615,7 +655,7 @@ describe Redis::Lock do
     REDIS_HANDLE.get("test_lock").should.be.nil
   end
 
-  it "should not let non-expired locks be gettable" do
+  it "should not let blocks execute if they timeout" do
     expiry = 15
     lock = Redis::Lock.new(:test_lock, :expiration => expiry, :timeout => 0.1)
 
@@ -640,19 +680,68 @@ describe Redis::Lock do
     REDIS_HANDLE.get("test_lock").should.not.be.nil
   end
 
+  it "should handle a timeout of 0" do
+    expiry = 15
+    lock = Redis::Lock.new(:test_lock, :timeout => 0)
+
+    # create a fake lock
+    REDIS_HANDLE.set("test_lock", (Time.now + expiry).to_f)
+
+    gotit = false
+    error = nil
+    begin
+      lock.lock do
+        gotit = true
+      end
+    rescue => error
+    end
+
+    error.should.be.kind_of(Redis::Lock::LockTimeout)
+
+    # should not have the lock
+    gotit.should.not.be.true
+
+    # lock value should still be set
+    REDIS_HANDLE.get("test_lock").should.not.be.nil
+  end
+
+  it "should properly keep the lock across threads" do
+    lock = Redis::Lock.new(:test_lock0)
+
+    t1 = Thread.new do
+      lock.lock do
+        lock.exists?.should.be.true if RUNNING_LOCALLY
+        REDIS_HANDLE.exists?("test_lock0").should.be.true if RUNNING_LOCALLY
+        sleep 1.0  # hang onto the lock across other thread
+      end
+    end
+
+    t2 = Thread.new do
+      # check for the lock from another thread
+      lock.exists?.should.be.true if RUNNING_LOCALLY
+      REDIS_HANDLE.exists?("test_lock0").should.be.true if RUNNING_LOCALLY
+    end
+
+    t1.join
+    t2.join
+
+    # lock value should not be set since the lock was held for more than the expiry
+    lock.exists?.should.be.false
+    REDIS_HANDLE.exists?("test_lock0").should.be.false
+  end
+
   it "Redis should remove the key if lock is held past expiration" do
-    lock = Redis::Lock.new(:test_lock, :expiration => 0.1)
+    lock = Redis::Lock.new(:test_lock1, :expiration => 0.1)
 
     lock.lock do
-      REDIS_HANDLE.exists("test_lock").should.be.true
-      sleep 0.3
-      # technically undefined behavior because we don't have a BG thread
-      # running and deleting lock keys - that is only triggered on block exit
-      #REDIS_HANDLE.exists("test_lock").should.be.false
+      lock.exists?.should.be.true
+      REDIS_HANDLE.exists?("test_lock1").should.be.true
+      sleep 1.0  # hang onto the lock > expiry
     end
 
     # lock value should not be set since the lock was held for more than the expiry
-    REDIS_HANDLE.exists("test_lock").should.be.false
+    lock.exists?.should.be.false
+    REDIS_HANDLE.exists?("test_lock1").should.be.false
   end
 
 
@@ -660,9 +749,9 @@ describe Redis::Lock do
     lock = Redis::Lock.new(:test_lock2, :expiration => 0.1)
 
     lock.lock do
-      REDIS_HANDLE.exists("test_lock2").should.be.true
-      sleep 0.3 # expired, key is deleted
-      REDIS_HANDLE.exists("test_lock2").should.be.false
+      REDIS_HANDLE.exists?("test_lock2").should.be.true
+      sleep 1.0 # expired, key is deleted
+      REDIS_HANDLE.exists?("test_lock2").should.be.false
       REDIS_HANDLE.set("test_lock2", "foo") # this is no longer a lock key, name is a coincidence
     end
 
@@ -670,17 +759,17 @@ describe Redis::Lock do
   end
 
   it "should manually delete the key if finished before expiration" do
-    lock = Redis::Lock.new(:test_lock3, :expiration => 0.5)
+    lock = Redis::Lock.new(:test_lock3, :expiration => 10.0)
 
     lock.lock do
-      REDIS_HANDLE.exists("test_lock3").should.be.true
+      REDIS_HANDLE.exists?("test_lock3").should.be.true
       sleep 0.1
-      REDIS_HANDLE.exists("test_lock3").should.be.true
+      REDIS_HANDLE.exists?("test_lock3").should.be.true
     end
 
-    # should delete the key because the lock block is done, regardless of time
+    # should delete the key because the lock block is done, regardless of expiry
     # for some strange reason, I have seen this test fail randomly, which is worrisome.
-    #REDIS_HANDLE.exists("test_lock3").should.be.false
+    REDIS_HANDLE.exists?("test_lock3").should.be.false
   end
 
 
@@ -900,6 +989,13 @@ describe Redis::HashKey do
     hsh['foo'].should == 'bar'
   end
 
+  it "should return multiple items via bulk_values" do
+    @hash['taco'] = 42
+    @hash['burrito'] = 99
+    res = @hash.bulk_values('taco', 'burrito')
+    res.should == ['42', '99']  # hashes don't convert
+  end
+
   it "should increment field" do
     @hash.incr('counter')
     @hash.incr('counter')
@@ -1007,7 +1103,9 @@ describe Redis::Set do
 
   it "should handle sets of simple values" do
     @set.should.be.empty
-    @set << 'a' << 'a' << 'a'
+    @set << 'a'
+    @set.randmember.should == 'a'
+    @set << 'a' << 'a'
     @set.should == ['a']
     @set.to_s.should == 'a'
     @set.get.should == ['a']
@@ -1048,11 +1146,13 @@ describe Redis::Set do
     coll = @set.select{|st| st == 'c'}
     coll.should == ['c']
     @set.sort.should == ['a','b','c']
+    @set.randmember.should.not == 'd'
     @set.delete_if{|m| m == 'c'}
     @set.sort.should == ['a','b']
 
     @set << nil
     @set.include?("").should.be.true
+    @set.sort.should == ['','a','b']
   end
 
   it "should handle empty array adds" do
@@ -1168,6 +1268,12 @@ describe Redis::Set do
     @set_1.value.should == ['a']
   end
 
+  it "should support moving between sets" do
+    @set_1 << 'X' << 'Y' << 'Z'
+    @set_1.move('X', @set_2)
+    @set_2.should == ['X']
+  end
+
   it "should respond to #to_json" do
     @set_1 << 'a'
     JSON.parse(@set_1.to_json)['value'].should == ['a']
@@ -1267,6 +1373,9 @@ describe Redis::SortedSet do
     @set.to_s.should == 'a, b'
     @set.should == ['a','b']
     @set.members.should == ['a','b']
+    @set.member?('a').should == true
+    @set.member?('b').should == true
+    @set.member?('c').should == false
     @set['d'] = 0
 
     @set.rangebyscore(0, 4).should == ['d','a']
@@ -1316,6 +1425,10 @@ describe Redis::SortedSet do
 
     @set.delete_if{|m| m == 'b'}
     @set.size.should == 3
+
+    # this is destructive so must come last
+    res = @set.remrangebyrank(0, 2)
+    res.should == 3
   end
 
   it "should handle inserting multiple values at once" do

data/spec/redis_objects_model_spec.rb

@@ -2,6 +2,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/objects'
+Redis::Objects.redis = REDIS_HANDLE
 
 class Roster
   include Redis::Objects
@@ -14,11 +15,15 @@ class Roster
   list :player_stats, :marshal => true
   set :outfielders, :marshal => true
   sorted_set :rank
+  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"
+  sorted_set :global_player_leaderboard, :global => true
+  hash_key :global_player_online_status, :global => true
 
   # custom keys
   counter :player_totals, :key => 'players/#{username}/total'
@@ -162,6 +167,14 @@ describe Redis::Objects do
     @roster.redis.get(k).should == '1'
   end
 
+  it "should be able to directly assign value of hash" do
+    @roster.contact_information['John_Name'] = 'John Doe'
+    @roster.contact_information = { 'John_Phone' => '12345678', 'John_Address' => '321 LANE' }
+    @roster.contact_information['John_Phone'].should == '12345678'
+    @roster.contact_information['John_Address'].should == '321 LANE'
+    @roster.contact_information['John_Name'].should.be.nil
+  end
+
   it "should be able to get/set contact info" do
     @roster.contact_information['John_Phone'] = '123415352'
     @roster.contact_information['John_Address'] = '123 LANE'
@@ -202,6 +215,21 @@ describe Redis::Objects do
      end
   end
 
+  it "should handle obtaining / clearing locks" do
+    # class-level calls for Admin reasons
+    # this is a really weird API and I wonder if anyone actually uses it
+    id = 88
+    roster = Roster.new(id)
+    roster.per_field_lock.exists?.should == false
+    Roster.obtain_lock(:per_field, id) do
+      roster.per_field_lock.exists?.should == true
+    end
+    roster.per_field_lock.exists?.should == false
+
+    Roster.clear_lock(:per_field, id)
+    roster.per_field_lock.exists?.should == false
+  end
+
   it "should support increment/decrement of counters" do
     @roster.available_slots.key.should == 'roster:1:available_slots'
     @roster.available_slots.should == 10
@@ -265,6 +293,26 @@ describe Redis::Objects do
     Roster.get_counter(:total_players_online).should == 111
   end
 
+  it "should support class-level manipulation of global objects" do
+    Roster.nasty_global_mutex_lock.exists?.should == false
+    Roster.nasty_global_mutex_lock do
+      Roster.nasty_global_mutex_lock.exists?.should == true
+    end
+    Roster.nasty_global_mutex_lock.exists?.should == false
+
+    Roster.global_player_leaderboard.exists?.should == false
+    Roster.global_player_leaderboard.add('nate', 22)
+    Roster.global_player_leaderboard.add('jim', 11)
+    Roster.global_player_leaderboard.rank('nate').should == 1 # 0-based
+
+    Roster.global_player_online_status.exists?.should == false
+    Roster.global_player_online_status['nate'] = 'online'
+    Roster.global_player_online_status['jeff'] = 'offline'
+    Roster.global_player_online_status['nate'].should == 'online'
+    Roster.global_player_online_status['jeff'].should == 'offline'
+    Roster.global_player_online_status['bobby'].should.be.nil
+  end
+
   it "should take an atomic block for increment/decrement" do
     a = false
     @roster.available_slots.should == 10
@@ -423,6 +471,13 @@ describe Redis::Objects do
     end
     error.should.be.kind_of(NoMethodError)
 
+    error = nil
+    begin
+      Roster.increment_counter(:available_slots, nil)
+    rescue => error
+    end
+    error.should.be.kind_of(Redis::Objects::MissingID)
+
     error = nil
     begin
       Roster.obtain_lock(:badness, 2){}
@@ -485,6 +540,12 @@ describe Redis::Objects do
     @roster.starting_pitcher.should.be.nil
   end
 
+  it "should be able to directly assign value of list" do
+    @roster.player_stats << 'c'
+    @roster.player_stats = ['a', 'b']
+    @roster.player_stats.get.should == ['a', 'b']
+  end
+
   it "should handle lists of simple values" do
     @roster.player_stats.should.be.empty
     @roster.player_stats << 'a'
@@ -559,6 +620,14 @@ describe Redis::Objects do
     @roster.player_stats.get.should == ['a','c','f','j','h','i','a']
   end
 
+  it "should be able to directly assign values of set" do
+    @roster.outfielders << 'c'
+    @roster.outfielders = ['a', 'b']
+    @roster.outfielders.member?('a').should.be.true
+    @roster.outfielders.member?('b').should.be.true
+    @roster.outfielders.member?('c').should.be.false
+  end
+
   it "should handle sets of simple values" do
     @roster.outfielders.should.be.empty
     @roster.outfielders << 'a' << 'a' << 'a'
@@ -1020,4 +1089,10 @@ describe Redis::Objects do
     @roster.redis_instance_keys.include?('roster:1:player_stats').should == true
     @roster.redis_instance_keys.include?('players:all_stats').should == false
   end
+
+  it "should handle per-class connection handles" do
+    redis = Roster.redis
+    Roster.redis = redis
+    Roster.redis.should == redis
+  end
 end

data/spec/spec_helper.rb

@@ -9,6 +9,21 @@ if $0 =~ /\brspec$/
   raise "\n===\nThese tests are in bacon, not rspec.  Try: bacon #{ARGV * ' '}\n===\n"
 end
 
+# For the incompatible change from redis.rb
+Redis.exists_returns_integer =  true
+
+# Avoid phantom remote test failures
+RUNNING_LOCALLY = !ENV['TRAVIS']
+
+# Code coverage reports
+require 'simplecov'
+SimpleCov.start
+
+require 'simplecov-cobertura'
+SimpleCov.formatter = SimpleCov::Formatter::CoberturaFormatter
+
+#require "active_support/xml_mini"
+require "active_support"
 require "active_support/testing/time_helpers"
 include ActiveSupport::Testing::TimeHelpers
 
@@ -69,8 +84,6 @@ end
 
 # Grab a global handle
 REDIS_HANDLE = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
-#$redis = REDIS_HANDLE
-Redis.current = REDIS_HANDLE
 
 SORT_ORDER = {:order => 'desc alpha'}
 SORT_LIMIT = {:limit => [2, 2]}

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: redis-objects
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Nate Wiger
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-09-18 00:00:00.000000000 Z
+date: 2022-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-cobertura
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Map Redis types directly to Ruby objects. Works with any class or ORM.
 email:
 - nwiger@gmail.com
@@ -171,7 +199,7 @@ homepage: http://github.com/nateware/redis-objects
 licenses:
 - Artistic-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -186,8 +214,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Map Redis types directly to Ruby objects
 test_files: