redis-objects 1.3.1 → 1.5.1

data/lib/redis/lock.rb

@@ -11,7 +11,6 @@ class Redis
   class Lock < BaseObject
     class LockTimeout < StandardError; end #:nodoc:
 
-    attr_reader :key, :options
     def initialize(key, *args)
       super(key, *args)
       @options[:timeout] ||= 5
@@ -19,13 +18,6 @@ class Redis
       redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
     end
 
-    # Clear the lock.  Should only be needed if there's a server crash
-    # or some other event that gets locks in a stuck state.
-    def clear
-      redis.del(key)
-    end
-    alias_method :delete, :clear
-
     def value
       nil
     end
@@ -33,28 +25,30 @@ class Redis
     # Get the lock and execute the code block. Any other code that needs the lock
     # (on any server) will spin waiting for the lock up to the :timeout
     # that was specified when the lock was defined.
-    def lock(&block)
-      expiration = nil
+    def lock
+      raise ArgumentError, 'Block not given' unless block_given?
+      expiration_ms = generate_expiration
+      expiration_s  = expiration_ms / 1000.0
+      end_time = nil
       try_until_timeout do
-        expiration = generate_expiration
-        # Use the expiration as the value of the lock.
-        break if redis.setnx(key, 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_ms, nx: true)
 
-        # Lock is being held.  Now check to see if it's expired (if we're using
-        # lock expiration).
-        # See "Handling Deadlocks" section on http://redis.io/commands/setnx
-        if !@options[:expiration].nil?
+        # Backward compatibility code
+        # TODO: remove at the next major release for performance
+        unless @options[:expiration].nil?
           old_expiration = redis.get(key).to_f
 
-          if old_expiration < Time.now.to_f
-            # If it's expired, use GETSET to update it.
-            expiration = generate_expiration
-            old_expiration = redis.getset(key, expiration).to_f
-
-            # Since GETSET returns the old value of the lock, if the old expiration
-            # is still in the past, we know no one else has expired the locked
-            # and we now have it.
-            break if old_expiration < Time.now.to_f
+          # 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_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
@@ -66,14 +60,15 @@ class Redis
         # it's not safe for us to remove it.  Check how much time has passed since we
         # wrote the lock key and only delete it if it hasn't expired (or we're not using
         # lock expiration)
-        if @options[:expiration].nil? || expiration > Time.now.to_f
+        if @options[:expiration].nil? || end_time > Time.now.to_f
           redis.del(key)
         end
       end
     end
 
+    # Return expiration in milliseconds
     def generate_expiration
-      @options[:expiration].nil? ? 1 : (Time.now + @options[:expiration].to_f + 1).to_f
+      ((@options[:expiration].nil? ? 1 : @options[:expiration].to_f) * 1000).to_i
     end
 
     private

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'
@@ -173,8 +171,15 @@ class Redis
       def redis()         self.class.redis end
       def redis_objects() self.class.redis_objects end
 
-      def delete!
-        redis.del(redis_objects.keys.map { |k| send(k) }.reject(&:nil?).map { |obj| obj.key })
+      def redis_delete_objects
+        redis.del(redis_instance_keys)
+      end
+
+      def redis_instance_keys
+        redis_objects
+          .reject { |_, value| value[:global] }
+          .keys
+          .collect { |name| redis_field_key(name) }
       end
 
       def redis_options(name) #:nodoc:

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.3.1"
+    VERSION = "1.5.1"
   end
 end

data/lib/redis/set.rb

@@ -1,17 +1,10 @@
-require File.dirname(__FILE__) + '/base_object'
+require File.dirname(__FILE__) + '/enumerable_object'
 
 class Redis
   #
   # Class representing a set.
   #
-  class Set < BaseObject
-    require 'enumerator'
-    include Enumerable
-    require 'redis/helpers/core_commands'
-    include Redis::Helpers::CoreCommands
-
-    attr_reader :key, :options
-
+  class Set < EnumerableObject
     # Works like add.  Can chain together: list << 'a' << 'b'
     def <<(value)
       add(value)
@@ -27,8 +20,8 @@ class Redis
     end
 
     # Remove and return a random member.  Redis: SPOP
-    def pop
-      unmarshal redis.spop(key)
+    def pop(count = nil)
+      unmarshal redis.spop(key, count)
     end
 
     # return a random member.  Redis: SRANDMEMBER
@@ -74,12 +67,6 @@ class Redis
       res
     end
 
-    # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
-    # so you can also use familiar methods like +collect+, +detect+, and so forth.
-    def each(&block)
-      members.each(&block)
-    end
-
     # Return the intersection with another set.  Can pass it either another set
     # object or set name.  Also available as & which is a bit cleaner:
     #
@@ -165,7 +152,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
@@ -185,10 +172,6 @@ class Redis
       members.join(', ')
     end
 
-    def as_json(*)
-      to_hash
-    end
-
     private
 
     def keys_from_objects(sets)

data/lib/redis/sorted_set.rb

@@ -1,17 +1,10 @@
-require File.dirname(__FILE__) + '/base_object'
+require File.dirname(__FILE__) + '/enumerable_object'
 
 class Redis
   #
   # Class representing a sorted set.
   #
-  class SortedSet < BaseObject
-    # require 'enumerator'
-    # include Enumerable
-    require 'redis/helpers/core_commands'
-    include Redis::Helpers::CoreCommands
-
-    attr_reader :key, :options
-
+  class SortedSet < EnumerableObject
     # How to add values using a sorted set.  The key is the member, eg,
     # "Peter", and the value is the score, eg, 163.  So:
     #    num_posts['Peter'] = 163
@@ -124,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
@@ -140,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
@@ -208,7 +201,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
@@ -219,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
 
@@ -235,7 +238,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
@@ -245,35 +258,10 @@ 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
 
-    # 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 +291,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,15 +1,11 @@
 require File.dirname(__FILE__) + '/base_object'
+require 'zlib'
 
 class Redis
   #
   # Class representing a simple value.  You can use standard Ruby operations on it.
   #
   class Value < BaseObject
-    require 'redis/helpers/core_commands'
-    include Redis::Helpers::CoreCommands
-
-    attr_reader :key, :options
-
     def value=(val)
       allow_expiration do
         if val.nil?
@@ -31,6 +27,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_custom_serializer.rb

@@ -0,0 +1,198 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'redis/objects'
+
+class CustomSerializer
+  class << self
+    attr_accessor :dump_called, :load_called, :dump_args, :load_args
+  end
+
+  def self.dump(value, *args, **kargs)
+    @dump_called = true
+    @dump_args = [args, kargs]
+    Marshal.dump(value)
+  end
+
+  def self.load(value, *args, **kargs)
+    @load_called = true
+    @load_args = [args, kargs]
+    Marshal.load(value)
+  end
+
+  def self.reset!
+    @dump_called = nil
+    @load_called = nil
+  end
+end
+
+describe 'with custom serialization' do
+  before do
+    CustomSerializer.reset!
+  end
+
+  describe Redis::Value do
+    before do
+      @value = Redis::Value.new(
+        'spec/value_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @value.clear
+    end
+
+    it 'uses custom serializer' do
+      @value.value = { json: 'data' }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @value.value.should == { json: 'data' }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @value.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @value.value = 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @value.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @value.value = 1
+      @value.value.should == 1
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::List do
+    before do
+      @list = Redis::List.new(
+        'spec/list_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @list.clear
+    end
+
+    it 'uses custom serializer' do
+      @list << { json: 'data' }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @list.should == [{ json: 'data' }]
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @list.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @list << 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @list.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @list << 1
+      @list.values.should == [1]
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::HashKey do
+    before do
+      @hash = Redis::HashKey.new(
+        'spec/hash_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @hash.clear
+    end
+
+    it 'uses custom serializer' do
+      @hash['a'] = 1
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @hash.value.should == { 'a' => 1 }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @hash.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @hash['a'] = 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @hash.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @hash['a'] = 1
+      @hash.value.should == { 'a' => 1 }
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::Set do
+    before do
+      @set = Redis::Set.new(
+        'spec/set_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @set.clear
+    end
+
+    it 'uses custom serializer' do
+      @set << 'a'
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @set.members.should == ['a']
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @set.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @set << 'a'
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @set.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @set << 'a'
+      @set.members.should == ['a']
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::SortedSet do
+    before do
+      @set = Redis::SortedSet.new(
+        'spec/zset_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @set.clear
+    end
+
+    it 'uses custom serializer' do
+      @set['a'] = 1
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @set.members.should == ['a']
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @set.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @set['a'] = 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @set.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @set['a'] = 1
+      @set.members.should == ['a']
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+end