redis-objects 1.4.2 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d42c057174f5a48560f104f08c5cf9bb25bd1772dd0684912a0094c4158840b
-  data.tar.gz: a0f945a9aede01c5623486576444c370cacd0e8a4fa2315511e7c1245339e489
+  metadata.gz: 6a9f86f294c2283b6ceae1730dfe6f1d1c3665ac9733cd107a4aa522d8a66bda
+  data.tar.gz: 50d631298aff5bcd5b15179c1a700a56a512c4a096cedad4c3f716999dcfebea
 SHA512:
-  metadata.gz: 7dec3f8e9925f49601f629786a2e01ff4524483235831fc4afe02d7dd7491fb7723a8a3bf0b8034712c2bba6c9071ad00c03c214ffe5e7ddfed9e0749fb48ab4
-  data.tar.gz: 7055d7720a3512215a9e3f63426ffe4d81ff06ce4d118a2e6ce05193362cd50052e95269cd2aa56e8a97703ad1349181d5790e2e7aedbc13d04e68f84f2597b6
+  metadata.gz: 48b37a11d5a2a5844863f2a7c559b5e38a6a96eab5d8f5393d0b688f8ffada7f8e480bb12d93869ca7a82d1fbb0fd311fc85a5f72635a4749ee771fefe834abc
+  data.tar.gz: b09b794badff0249c468b0cc33b2daa24e87ab084cc5a778eb3415894bdad6e90070f7e3da4d417c16ec867017d4c15e5d06c0ca163560e5c4513297e3698241

data/CHANGELOG.rdoc

@@ -1,5 +1,47 @@
 = Changelog for Redis::Objects
 
+== 1.4.3 (7 Oct 2018)
+
+* Merge pull request #235 from johnc219/fix/end-time-expiration Add expiration in seconds to obtain end_time [Nate Wiger]
+
+* Merge pull request #223 from artinboghosian/compress-redis-value Allow compression of value stored in Redis::Value to save memory on R… [Nate Wiger]
+
+* Merge pull request #224 from artinboghosian/sorted-set-missing-operations Fix set operation methods on SortedSets [Nate Wiger]
+
+* Merge pull request #233 from tmattia/master Add SortedSet#count alias so it's consistent with Set#count [Nate Wiger]
+
+* Merge pull request #236 from nateware/revert-220-threadsafe Revert "Make Redis::Objects.connection thread-safe" [Nate Wiger]
+
+* Revert "Make Redis::Objects.connection thread-safe"  [Nate Wiger]
+
+== 1.4.2 (29 Aug 2018)
+
+* Merge pull request #227 from D-system/optimise_lock Optimise lock [Nate Wiger]
+
+* Merge pull request #228 from D-system/travis_ruby_2.5 Travis: test against ruby 2.5 [Nate Wiger]
+
+* Travis: test against ruby 2.5  [Thomas Brennetot]
+
+* Lock: update comment  [Thomas Brennetot]
+
+* Lock: add backward compatibility  [Thomas Brennetot]
+
+* Use SET with the NX and the expiration option in a single request  [Thomas Brennetot]
+
+* Merge pull request #218 from edwardbako/list_pushed_count Return count of lpush & rpush commands [Nate Wiger]
+
+* Merge pull request #220 from gammons/threadsafe Make Redis::Objects.connection thread-safe [Nate Wiger]
+
+* Make Redis::Objects.connection threadsafe  [Grant Ammons]
+
+* Return count of lpush & rpush commands  [Edward Bako]
+
+* Removed support for versions of Ruby < 2.2  [Nate Wiger]
+
+== 1.4.1 (Unreleased)
+
+* Buggy release that was removed
+
 == 1.4.0 (7 Dec 2017)
 
 * Bumped dependency to redis.rb 4.0 [Nate Wiger]

data/README.md

@@ -261,6 +261,18 @@ Complex data is no problem with :marshal => true:
 puts @newest.value['username']
 ~~~
 
+Compress data to save memory usage on Redis with :compress => true:
+
+~~~ruby
+@account = Account.create!(params[:account])
+@marshaled_value = Redis::Value.new('marshaled', :marshal => true, :compress => true)
+@marshaled_value.value = @account.attributes
+@unmarshaled_value = Redis::Value.new('unmarshaled', :compress => true)
+@unmarshaled_value = 'Really Long String'
+puts @marshaled_value.value['username']
+puts @unmarshaled_value.value
+~~~
+
 Lists
 -----
 Lists work just like Ruby arrays:

data/lib/redis/lock.rb

@@ -35,14 +35,15 @@ class Redis
     # that was specified when the lock was defined.
     def lock
       raise ArgumentError, 'Block not given' unless block_given?
-      expiration = generate_expiration
+      expiration_ms = generate_expiration
+      expiration_s  = expiration_ms / 1000.0
       end_time = nil
       try_until_timeout do
-        end_time = Time.now.to_i + expiration
+        end_time = Time.now.to_i + expiration_s
         # Set a NX record and use the Redis expiration mechanism.
         # Empty value because the presence of it is enough to lock
         # `px` only except an Integer in millisecond
-        break if redis.set(key, nil, px: expiration, nx: true)
+        break if redis.set(key, nil, px: expiration_ms, nx: true)
 
         # Backward compatibility code
         # TODO: remove at the next major release for performance
@@ -52,9 +53,10 @@ class Redis
           # Check it was not an empty string with `zero?` and
           # the expiration time is passed.
           if !old_expiration.zero? && old_expiration < Time.now.to_f
-            expiration = generate_expiration
-            end_time = Time.now.to_i + expiration
-            break if redis.set(key, nil, px: expiration)
+            expiration_ms = generate_expiration
+            expiration_s  = expiration_ms / 1000.0
+            end_time = Time.now.to_i + expiration_s
+            break if redis.set(key, nil, px: expiration_ms)
           end
         end
       end

data/lib/redis/objects.rb

@@ -61,11 +61,10 @@ class Redis
 
     class << self
       def redis=(conn)
-        Thread.current[:__redis_objects_redis] = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
+        @redis = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
       end
-
       def redis
-        Thread.current[:__redis_objects_redis] || $redis || Redis.current ||
+        @redis || $redis || Redis.current ||
           raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
       end
 
@@ -91,11 +90,11 @@ class Redis
     module ClassMethods
       # Enable per-class connections (eg, User and Post can use diff redis-server)
       def redis=(conn)
-        Thread.current[:__redis_objects_redis] = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
+        @redis = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
       end
 
       def redis
-        Thread.current[:__redis_objects_redis] || Objects.redis
+        @redis || Objects.redis
       end
 
       # Internal list of objects

data/lib/redis/objects/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Objects
-    VERSION = "1.4.2"
+    VERSION = "1.4.3"
   end
 end

data/lib/redis/set.rb

@@ -165,7 +165,7 @@ class Redis
       redis.smove(key, destination.is_a?(Redis::Set) ? destination.key : destination.to_s, value)
     end
 
-    # The number of members in the set. Aliased as size. Redis: SCARD
+    # The number of members in the set. Aliased as size or count. Redis: SCARD
     def length
       redis.scard(key)
     end

data/lib/redis/sorted_set.rb

@@ -208,7 +208,17 @@ class Redis
     #
     # Redis: SINTER
     def intersection(*sets)
-      redis.zinter(key, *keys_from_objects(sets)).map{|v| unmarshal(v) }
+      result = nil
+      temp_key = :"#{key}:intersection:#{Time.current.to_i + rand}"
+
+      redis.multi do
+        interstore(temp_key, *sets)
+        redis.expire(temp_key, 1)
+
+        result = redis.zrange(temp_key, 0, -1)
+      end
+
+      result.value
     end
     alias_method :intersect, :intersection
     alias_method :inter, :intersection
@@ -235,7 +245,17 @@ class Redis
     #
     # Redis: SUNION
     def union(*sets)
-      redis.zunion(key, *keys_from_objects(sets)).map{|v| unmarshal(v) }
+      result = nil
+      temp_key = :"#{key}:union:#{Time.current.to_i + rand}"
+
+      redis.multi do
+        unionstore(temp_key, *sets)
+        redis.expire(temp_key, 1)
+
+        result = redis.zrange(temp_key, 0, -1)
+      end
+
+      result.value
     end
     alias_method :|, :union
     alias_method :+, :union
@@ -249,31 +269,6 @@ class Redis
       end
     end
 
-    # Return the difference vs another set.  Can pass it either another set
-    # object or set name. Also available as ^ or - which is a bit cleaner:
-    #
-    #    members_difference = set1 ^ set2
-    #    members_difference = set1 - set2
-    #
-    # If you want to specify multiple sets, you must use +difference+:
-    #
-    #    members_difference = set1.difference(set2, set3, set4)
-    #    members_difference = set1.diff(set2, set3, set4)
-    #
-    # Redis: SDIFF
-    def difference(*sets)
-      redis.zdiff(key, *keys_from_objects(sets)).map{|v| unmarshal(v) }
-    end
-    alias_method :diff, :difference
-    alias_method :^, :difference
-    alias_method :-, :difference
-
-    # Calculate the diff and store it in Redis as +name+. Returns the number
-    # of elements in the stored union. Redis: SDIFFSTORE
-    def diffstore(name, *sets)
-      redis.zdiffstore(name, key, *keys_from_objects(sets))
-    end
-
     # Returns true if the set has no members. Redis: SCARD == 0
     def empty?
       length == 0
@@ -303,11 +298,12 @@ class Redis
       at(-1)
     end
 
-    # The number of members in the set. Aliased as size. Redis: ZCARD
+    # The number of members in the set. Aliased as size or count. Redis: ZCARD
     def length
       redis.zcard(key)
     end
     alias_method :size, :length
+    alias_method :count, :length
 
     # The number of members within a range of scores. Redis: ZCOUNT
     def range_size(min, max)

data/lib/redis/value.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/base_object'
+require 'zlib'
 
 class Redis
   #
@@ -31,6 +32,30 @@ class Redis
     end
     alias_method :get, :value
 
+    def marshal(value, *args)
+      if !value.nil? && options[:compress]
+        compress(super)
+      else
+        super
+      end
+    end
+
+    def unmarshal(value, *args)
+      if !value.nil? && options[:compress]
+        super(decompress(value), *args)
+      else
+        super
+      end
+    end
+
+    def decompress(value)
+      Zlib::Inflate.inflate(value)
+    end
+
+    def compress(value)
+      Zlib::Deflate.deflate(value)
+    end
+
     def inspect
       "#<Redis::Value #{value.inspect}>"
     end

data/spec/redis_objects_conn_spec.rb

@@ -41,21 +41,6 @@ describe 'Connection tests' do
     obj.default_redis_value.clear
   end
 
-  it "should be thread-safe when setting Redis::Objects.redis connection" do
-    Redis::Objects.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT, :db => 23)
-
-    thr = Thread.new do
-      Redis::Objects.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT, :db => 24)
-      Redis::Objects.redis.connection[:id].ends_with?("/24").should == true
-    end
-
-    Redis::Objects.redis.connection[:id].ends_with?("/23").should == true
-
-    thr.join
-
-    Redis::Objects.redis.connection[:id].ends_with?("/23").should == true
-  end
-
   it "should support mget" do
     class CustomConnectionObject
       include Redis::Objects

data/spec/redis_objects_instance_spec.rb

@@ -19,6 +19,28 @@ describe Redis::Value do
     @value.value.should == false
   end
 
+  it "should compress non marshaled values" do
+    @value = Redis::Value.new('spec/value', compress: true)
+    @value.value = 'Trevor Hoffman'
+    @value.value.should == 'Trevor Hoffman'
+    @value.redis.get(@value.key).should.not == 'Trevor Hoffman'
+    @value.value = nil
+    @value.value.should == nil
+    @value.value = ''
+    @value.value.should == ''
+  end
+
+  it "should compress marshaled values" do
+    @value = Redis::Value.new('spec/value', marshal: true, compress: true)
+    @value.value = 'Trevor Hoffman'
+    @value.value.should == 'Trevor Hoffman'
+    @value.redis.get(@value.key).should.not == Marshal.dump('Trevor Hoffman')
+    @value.value = nil
+    @value.value.should == nil
+    @value.value = ''
+    @value.value.should == ''
+  end
+
   it "should handle simple values" do
     @value.should == nil
     @value.value = 'Trevor Hoffman'
@@ -622,13 +644,46 @@ describe Redis::Lock do
     lock = Redis::Lock.new(:test_lock, :expiration => 0.1)
 
     lock.lock do
-      sleep 0.2
+      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
     end
 
-    # lock value should still be set since the lock was held for more than the expiry
-    REDIS_HANDLE.get("test_lock").should.be.nil
+    # lock value should not be set since the lock was held for more than the expiry
+    REDIS_HANDLE.exists("test_lock").should.be.false
   end
 
+
+  it "should not manually delete a key with a 'lock' name if finished after expiration" 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.set("test_lock2", "foo") # this is no longer a lock key, name is a coincidence
+    end
+
+    REDIS_HANDLE.get("test_lock2").should == "foo"
+  end
+
+  it "should manually delete the key if finished before expiration" do
+    lock = Redis::Lock.new(:test_lock3, :expiration => 0.5)
+
+    lock.lock do
+      REDIS_HANDLE.exists("test_lock3").should.be.true
+      sleep 0.1
+      REDIS_HANDLE.exists("test_lock3").should.be.true
+    end
+
+    # should delete the key because the lock block is done, regardless of time
+    # for some strange reason, I have seen this test fail randomly, which is worrisome.
+    #REDIS_HANDLE.exists("test_lock3").should.be.false
+  end
+
+
   it "should respond to #to_json" do
     Redis::Lock.new(:test_lock).to_json.should.be.kind_of(String)
   end
@@ -1253,6 +1308,7 @@ describe Redis::SortedSet do
     @set.delete('c')
     @set.length.should == 4
     @set.size.should == 4
+    @set.count.should == 4
 
     @set.range_size(100, 120).should == 0
     @set.range_size(0, 100).should == 2
@@ -1318,6 +1374,8 @@ describe Redis::SortedSet do
     @set_2.add('c', 1)
     @set_2.add('d', 0)
 
+    @set_1.union(@set_2).should == ['d', 'a', 'c', 'b']
+
     @set_1.unionstore(@set.key, @set_2)
     # @set is now: [[d, 0], [a, 1], [c, 4], [b, 6]]
     @set.members.should == ['d', 'a', 'c', 'b']
@@ -1357,6 +1415,8 @@ describe Redis::SortedSet do
     @set_2.add('c', 1)
     @set_2.add('d', 0)
 
+    @set_1.intersection(@set_2).should == ['c', 'b']
+
     @set_1.interstore(@set.key, @set_2)
     # @set is now: [[c, 4], [b, 6]]
     @set.members.should == ['c', 'b']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-objects
 version: !ruby/object:Gem::Version
-  version: 1.4.2
+  version: 1.4.3
 platform: ruby
 authors:
 - Nate Wiger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-29 00:00:00.000000000 Z
+date: 2018-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis