redis-objects 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc70bd55cafac46d93b6dc5dcd24d2e116c00d1e
-  data.tar.gz: d98febd210c47c61f8511f023e09edf86d848f25
+  metadata.gz: 4c3ed8e9d16f4beddbb3e7192845ba17a8367bdb
+  data.tar.gz: 834245d36db41b311e29d9c2cdce0a7ab02a14e1
 SHA512:
-  metadata.gz: d854a41164664e2e4dafdf3c25e05ad6281ba305cb4c28fcccbff6777b4f2bcc9f773b96e0c7423552957395ab21aa7c0bef5175d70fe4aae7677c04c457c7d4
-  data.tar.gz: 090c58f4cbe376b4a37b0bd9c1b70894f036c8bc5b94a62c58e1047c0a175f8418659b260ca26daa3a3c21f6e2c9642694f1176f8c8bc390a6914eccd05e90bb
+  metadata.gz: 446c36a59eed213a54d2c73479096b1ffb1cb778cef1f40a1a42ce9bc7e773abe13251a78976b75b15387247f1f28cf8cb8708131608340b27e71e239aa4b191
+  data.tar.gz: 47626977f71544038bb1a9d3ef0261e126ca804a21c798c6efcca297d8d4b7d012f3ff9701f479d2339f2ceb4b4e5499553814b1d8bba4da0ce72aec030f6190

data/CHANGELOG.rdoc

@@ -1,8 +1,19 @@
 = Changelog for Redis::Objects
 
+== 1.2.0 (30 Apr 2015)
+
+
+* New expiration implementation to address edge cases and missing methods [Ross Kaffenberger]
+
+* Add support for expiration/expireat on HashKey#update [Ross Kaffenberger]
+
+* Make locks with 0 timeout possible  Jean Boussier]
+
+* Update hdel methods to support deleting multiple keys [Star]
+
 == 1.1.0 (21 Jan 2015)
 
-* Support connection_pool useage via a proxy object [Jared Jenkins]
+* Support connection_pool usage via a proxy object [Jared Jenkins]
 
 * Fix typo on :counter usage [Kevin Bongart]
 

data/lib/redis/base_object.rb

@@ -22,19 +22,8 @@ class Redis
       end
     end
 
-    class << self
-      def expiration_filter(*names)
-        names.each do |name|
-          # http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html
-          bind_method = instance_method(name)
-
-          define_method(name) do |*args, &block|
-            result = bind_method.bind(self).call(*args, &block)
-            set_expiration
-            result
-          end
-        end
-      end
+    def allow_expiration(&block)
+      block.call.tap { set_expiration }
     end
   end
 end

data/lib/redis/counter.rb

@@ -25,8 +25,10 @@ class Redis
     # with a parent and starting over (for example, restarting a game and
     # disconnecting all players).
     def reset(to=options[:start])
-      redis.set key, to.to_i
-      true  # hack for redis-rb regression
+      allow_expiration do
+        redis.set key, to.to_i
+        true  # hack for redis-rb regression
+      end
     end
 
     # Reset the counter to its starting value, and return previous value.
@@ -47,10 +49,12 @@ class Redis
     alias_method :get, :value
 
     def value=(val)
-      if val.nil?
-        delete
-      else
-        redis.set key, val
+      allow_expiration do
+        if val.nil?
+          delete
+        else
+          redis.set key, val
+        end
       end
     end
     alias_method :set, :value=
@@ -66,8 +70,10 @@ class Redis
     # counter will automatically be decremented to its previous value.  This
     # method is aliased as incr() for brevity.
     def increment(by=1, &block)
-      val = redis.incrby(key, by).to_i
-      block_given? ? rewindable_block(:decrement, by, val, &block) : val
+      allow_expiration do
+        val = redis.incrby(key, by).to_i
+        block_given? ? rewindable_block(:decrement, by, val, &block) : val
+      end
     end
     alias_method :incr, :increment
     alias_method :incrby, :increment
@@ -78,8 +84,10 @@ class Redis
     # counter will automatically be incremented to its previous value.  This
     # method is aliased as decr() for brevity.
     def decrement(by=1, &block)
-      val = redis.decrby(key, by).to_i
-      block_given? ? rewindable_block(:increment, by, val, &block) : val
+      allow_expiration do
+        val = redis.decrby(key, by).to_i
+        block_given? ? rewindable_block(:increment, by, val, &block) : val
+      end
     end
     alias_method :decr, :decrement
     alias_method :decrby, :decrement
@@ -87,15 +95,19 @@ class Redis
     # Increment a floating point counter atomically.
     # Redis uses separate API's to interact with integers vs floats.
     def incrbyfloat(by=1.0, &block)
-      val = redis.incrbyfloat(key, by).to_f
-      block_given? ? rewindable_block(:decrbyfloat, by, val, &block) : val
+      allow_expiration do
+        val = redis.incrbyfloat(key, by).to_f
+        block_given? ? rewindable_block(:decrbyfloat, by, val, &block) : val
+      end
     end
 
     # Decrement a floating point counter atomically.
     # Redis uses separate API's to interact with integers vs floats.
     def decrbyfloat(by=1.0, &block)
-      val = redis.incrbyfloat(key, -by).to_f
-      block_given? ? rewindable_block(:incrbyfloat, -by, val, &block) : val
+      allow_expiration do
+        val = redis.incrbyfloat(key, -by).to_f
+        block_given? ? rewindable_block(:incrbyfloat, -by, val, &block) : val
+      end
     end
 
     ##
@@ -113,10 +125,6 @@ class Redis
       EndOverload
     end
 
-    expiration_filter :increment, :incr, :incrby, :incrbyfloat, 
-                      :decrement, :decr, :decrby, :decrbyfloat,
-                      :value=, :set, :reset
-
     private
 
     # Implements atomic increment/decrement blocks

data/lib/redis/hash_key.rb

@@ -18,7 +18,9 @@ class Redis
 
     # Redis: HSET
     def store(field, value)
-      redis.hset(key, field, marshal(value, options[:marshal_keys][field]))
+      allow_expiration do
+        redis.hset(key, field, marshal(value, options[:marshal_keys][field]))
+      end
     end
     alias_method :[]=, :store
 
@@ -37,8 +39,8 @@ class Redis
     alias_method :key?, :has_key?
     alias_method :member?, :has_key?
 
-    # Delete field. Redis: HDEL
-    def delete(field)
+    # Delete fields. Redis: HDEL
+    def delete(*field)
       redis.hdel(key, field)
     end
 
@@ -106,17 +108,21 @@ class Redis
     # Set keys in bulk, takes a hash of field/values {'field1' => 'val1'}. Redis: HMSET
     def bulk_set(*args)
       raise ArgumentError, "Argument to bulk_set must be hash of key/value pairs" unless args.last.is_a?(::Hash)
-      redis.hmset(key, *args.last.inject([]){ |arr,kv|
-        arr + [kv[0], marshal(kv[1], options[:marshal_keys][kv[0]])]
-      })
+      allow_expiration do
+        redis.hmset(key, *args.last.inject([]){ |arr,kv|
+          arr + [kv[0], marshal(kv[1], options[:marshal_keys][kv[0]])]
+        })
+      end
     end
     alias_method :update, :bulk_set
 
     # Set keys in bulk if they do not exist. Takes a hash of field/values {'field1' => 'val1'}. Redis: HSETNX
     def fill(pairs={})
       raise ArgumentError, "Arugment to fill must be a hash of key/value pairs" unless pairs.is_a?(::Hash)
-      pairs.each do |field, value|
-        redis.hsetnx(key, field, marshal(value, options[:marshal_keys][field]))
+      allow_expiration do
+        pairs.each do |field, value|
+          redis.hsetnx(key, field, marshal(value, options[:marshal_keys][field]))
+        end
       end
     end
 
@@ -139,11 +145,13 @@ class Redis
 
     # Increment value by integer at field. Redis: HINCRBY
     def incrby(field, by=1)
-      ret = redis.hincrby(key, field, by)
-      unless ret.is_a? Array
-        ret.to_i
-      else
-        nil
+      allow_expiration do
+        ret = redis.hincrby(key, field, by)
+        unless ret.is_a? Array
+          ret.to_i
+        else
+          nil
+        end
       end
     end
     alias_method :incr, :incrby
@@ -156,11 +164,13 @@ class Redis
 
     # Increment value by float at field. Redis: HINCRBYFLOAT
     def incrbyfloat(field, by=1.0)
-      ret = redis.hincrbyfloat(key, field, by)
-      unless ret.is_a? Array
-        ret.to_f
-      else
-        nil
+      allow_expiration do
+        ret = redis.hincrbyfloat(key, field, by)
+        unless ret.is_a? Array
+          ret.to_f
+        else
+          nil
+        end
       end
     end
 
@@ -168,10 +178,5 @@ class Redis
     def decrbyfloat(field, by=1.0)
       incrbyfloat(field, -by)
     end
-
-    expiration_filter :[]=, :store, :bulk_set, :fill,
-                      :incrby, :incr, :incrbyfloat,
-                      :decrby, :decr, :decrbyfloat
   end
 end
-

data/lib/redis/list.rb

@@ -21,13 +21,17 @@ class Redis
 
     # Add a member before or after pivot in the list. Redis: LINSERT
     def insert(where,pivot,value)
-      redis.linsert(key,where,marshal(pivot),marshal(value))
+      allow_expiration do
+        redis.linsert(key,where,marshal(pivot),marshal(value))
+      end
     end
 
     # Add a member to the end of the list. Redis: RPUSH
     def push(*values)
-      redis.rpush(key, values.map{|v| marshal(v) })
-      redis.ltrim(key, -options[:maxlength], -1) if options[:maxlength]
+      allow_expiration do
+        redis.rpush(key, values.map{|v| marshal(v) })
+        redis.ltrim(key, -options[:maxlength], -1) if options[:maxlength]
+      end
     end
 
     # Remove a member from the end of the list. Redis: RPOP
@@ -49,8 +53,10 @@ class Redis
 
     # Add a member to the start of the list. Redis: LPUSH
     def unshift(*values)
-      redis.lpush(key, values.map{|v| marshal(v) })
-      redis.ltrim(key, 0, options[:maxlength] - 1) if options[:maxlength]
+      allow_expiration do
+        redis.lpush(key, values.map{|v| marshal(v) })
+        redis.ltrim(key, 0, options[:maxlength] - 1) if options[:maxlength]
+      end
     end
 
     # Remove a member from the start of the list. Redis: LPOP
@@ -85,7 +91,9 @@ class Redis
 
     # Same functionality as Ruby arrays.
     def []=(index, value)
-      redis.lset(key, index, marshal(value))
+      allow_expiration do
+        redis.lset(key, index, marshal(value))
+      end
     end
 
     # Delete the element(s) from the list that match name. If count is specified,
@@ -142,7 +150,5 @@ class Redis
     def to_s
       values.join(', ')
     end
-
-    expiration_filter :[]=, :push, :<<, :insert, :unshift
   end
 end

data/lib/redis/lock.rb

@@ -30,14 +30,11 @@ class Redis
     # (on any server) will spin waiting for the lock up to the :timeout
     # that was specified when the lock was defined.
     def lock(&block)
-      start = Time.now
-      gotit = false
       expiration = nil
-      while Time.now - start < @options[:timeout]
+      try_until_timeout do
         expiration = generate_expiration
         # Use the expiration as the value of the lock.
-        gotit = redis.setnx(key, expiration)
-        break if gotit
+        break if redis.setnx(key, expiration)
 
         # Lock is being held.  Now check to see if it's expired (if we're using
         # lock expiration).
@@ -53,16 +50,10 @@ class Redis
             # 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.
-            if old_expiration < Time.now.to_f
-              gotit = true
-              break
-            end
+            break if old_expiration < Time.now.to_f
           end
         end
-
-        sleep 0.1
       end
-      raise LockTimeout, "Timeout on lock #{key} exceeded #{@options[:timeout]} sec" unless gotit
       begin
         yield
       ensure
@@ -80,5 +71,20 @@ class Redis
     def generate_expiration
       @options[:expiration].nil? ? 1 : (Time.now + @options[:expiration].to_f + 1).to_f
     end
+
+    private
+
+    def try_until_timeout
+      if @options[:timeout] == 0
+        yield
+      else
+        start = Time.now
+        while Time.now - start < @options[:timeout]
+          yield
+          sleep 0.1
+        end
+      end
+      raise LockTimeout, "Timeout on lock #{key} exceeded #{@options[:timeout]} sec"
+    end
   end
 end

data/lib/redis/objects/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Objects
-    VERSION = "1.1.0"
+    VERSION = "1.2.0"
   end
 end

data/lib/redis/set.rb

@@ -21,7 +21,9 @@ class Redis
     # Add the specified value to the set only if it does not exist already.
     # Redis: SADD
     def add(value)
-      redis.sadd(key, marshal(value)) if value.nil? || !Array(value).empty?
+      allow_expiration do
+        redis.sadd(key, marshal(value)) if value.nil? || !Array(value).empty?
+      end
     end
 
     # Remove and return a random member.  Redis: SPOP
@@ -180,14 +182,11 @@ class Redis
       members.join(', ')
     end
 
-    expiration_filter :add
-
     private
 
     def keys_from_objects(sets)
       raise ArgumentError, "Must pass in one or more set names" if sets.empty?
       sets.collect{|set| set.is_a?(Redis::Set) ? set.key : set}
     end
-
   end
 end

data/lib/redis/sorted_set.rb

@@ -23,7 +23,9 @@ class Redis
     # arguments to this are flipped; the member comes first rather than
     # the score, since the member is the unique item (not the score).
     def add(member, score)
-      redis.zadd(key, score, marshal(member))
+      allow_expiration do
+        redis.zadd(key, score, marshal(member))
+      end
     end
 
     # Add a list of members and their corresponding value (or a hash mapping
@@ -31,8 +33,10 @@ class Redis
     # the member comes first rather than the score, since the member is the unique
     # item (not the score).
     def merge(values)
-      vals = values.map{|v,s| [s, marshal(v)] }
-      redis.zadd(key, vals)
+      allow_expiration do
+        vals = values.map{|v,s| [s, marshal(v)] }
+        redis.zadd(key, vals)
+      end
     end
     alias_method :add_all, :merge
 
@@ -155,7 +159,9 @@ class Redis
 
     # Delete the value from the set.  Redis: ZREM
     def delete(value)
-      redis.zrem(key, marshal(value))
+      allow_expiration do
+        redis.zrem(key, marshal(value))
+      end
     end
 
     # Delete element if it matches block
@@ -173,14 +179,18 @@ class Redis
     # Increment the rank of that member atomically and return the new value. This
     # method is aliased as incr() for brevity. Redis: ZINCRBY
     def increment(member, by=1)
-      redis.zincrby(key, by, marshal(member)).to_i
+      allow_expiration do
+        zincrby(member, by)
+      end
     end
     alias_method :incr, :increment
     alias_method :incrby, :increment
 
     # Convenience to calling increment() with a negative number.
     def decrement(member, by=1)
-      redis.zincrby(key, -by, marshal(member)).to_i
+      allow_expiration do
+        zincrby(member, -by)
+      end
     end
     alias_method :decr, :decrement
     alias_method :decrby, :decrement
@@ -206,8 +216,10 @@ class Redis
     # Calculate the intersection and store it in Redis as +name+. Returns the number
     # of elements in the stored intersection. Redis: SUNIONSTORE
     def interstore(name, *sets)
-      opts = sets.last.is_a?(Hash) ? sets.pop : {}
-      redis.zinterstore(key_from_object(name), keys_from_objects([self] + sets), opts)
+      allow_expiration do
+        opts = sets.last.is_a?(Hash) ? sets.pop : {}
+        redis.zinterstore(key_from_object(name), keys_from_objects([self] + sets), opts)
+      end
     end
 
     # Return the union with another set.  Can pass it either another set
@@ -230,8 +242,10 @@ class Redis
     # Calculate the union and store it in Redis as +name+. Returns the number
     # of elements in the stored union. Redis: SUNIONSTORE
     def unionstore(name, *sets)
-      opts = sets.last.is_a?(Hash) ? sets.pop : {}
-      redis.zunionstore(key_from_object(name), keys_from_objects([self] + sets), opts)
+      allow_expiration do
+        opts = sets.last.is_a?(Hash) ? sets.pop : {}
+        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
@@ -304,10 +318,6 @@ class Redis
       !redis.zscore(key, marshal(value)).nil?
     end
 
-    expiration_filter :[]=, :add, :merge, :delete,
-                      :increment, :incr, :incrby, :decrement, :decr, :decrby,
-                      :intersection, :interstore, :unionstore, :diffstore
-
     private
     def key_from_object(set)
       set.is_a?(Redis::SortedSet) ? set.key : set
@@ -317,5 +327,9 @@ class Redis
       raise ArgumentError, "Must pass in one or more set names" if sets.empty?
       sets.collect{|set| set.is_a?(Redis::SortedSet) || set.is_a?(Redis::Set) ? set.key : set}
     end
+
+    def zincrby(member, by)
+      redis.zincrby(key, by, marshal(member)).to_i
+    end
   end
 end

data/lib/redis/value.rb

@@ -15,10 +15,12 @@ class Redis
     end
 
     def value=(val)
-      if val.nil?
-        delete
-      else
-        redis.set key, marshal(val)
+      allow_expiration do
+        if val.nil?
+          delete
+        else
+          redis.set key, marshal(val)
+        end
       end
     end
     alias_method :set, :value=
@@ -40,7 +42,5 @@ class Redis
     def method_missing(*args)
       self.value.send *args
     end
-
-    expiration_filter :value=
   end
 end

data/spec/redis_objects_active_record_spec.rb

@@ -16,7 +16,7 @@ begin
       create_table :blogs do |t|
         t.string :name
         t.integer :posts_count, :default => 0
-        t.timestamps
+        t.timestamps null: true
       end
     end
 
@@ -37,7 +37,7 @@ begin
         t.string :description, :length => 200
         t.integer :total
         t.integer :blog_id
-        t.timestamps
+        t.timestamps null: true
       end
     end
 
@@ -58,11 +58,11 @@ begin
       create_table :comments do |t|
         t.string :body
         t.integer :post_id
-        t.timestamps
+        t.timestamps null: true
       end
     end
 
-    def self.down
+   def self.down
       drop_table :comments
     end
   end

data/spec/redis_objects_instance_spec.rb

@@ -18,7 +18,7 @@ describe Redis::Value do
     @value = Redis::Value.new('spec/value', :default => false, :marshal => true)
     @value.value.should == false
   end
-  
+
   it "should handle simple values" do
     @value.should == nil
     @value.value = 'Trevor Hoffman'
@@ -109,17 +109,21 @@ describe Redis::Value do
     @value.nil?.should == true
   end
 
-  it 'should set time to live in seconds when expiration option assigned' do
-    @value = Redis::Value.new('spec/value', :expiration => 10)
-    @value.value = 'monkey'
-    @value.ttl.should > 0
-    @value.ttl.should <= 10
-  end
+  describe "with expiration" do
+    [:value=, :set].each do |meth|
+      it "#{meth} should set time to live in seconds when expiration option assigned" do
+        @value = Redis::Value.new('spec/value', :expiration => 10)
+        @value.send(meth, 'monkey')
+        @value.ttl.should > 0
+        @value.ttl.should <= 10
+      end
 
-  it 'should set expiration when expireat option assigned' do
-    @value = Redis::Value.new('spec/value', :expireat => Time.now + 10.seconds)
-    @value.value = 'monkey'
-    @value.ttl.should > 0
+      it "#{meth} should set expiration when expireat option assigned" do
+        @value = Redis::Value.new('spec/value', :expireat => Time.now + 10.seconds)
+        @value.send(meth, 'monkey')
+        @value.ttl.should > 0
+      end
+    end
   end
 
   after do
@@ -127,7 +131,6 @@ describe Redis::Value do
   end
 end
 
-
 describe Redis::List do
   describe "as a bounded list" do
     before do
@@ -340,27 +343,59 @@ describe Redis::List do
   end
 
   describe 'with expiration' do
-    [:[]=, :push, :<<, :insert, :unshift].each do |meth|
-      describe meth do
-        it 'expiration: option' do
-          @list = Redis::List.new('spec/list_exp', :expiration => 10)
-          @list << 'val'
-          @list.ttl.should > 0
-          @list.ttl.should <= 10
-        end
-
-        it 'expireat: option' do
-          @list = Redis::List.new('spec/list_exp', :expireat => Time.now + 10.seconds)
-          @list << 'val'
-          @list.ttl.should > 0
-          @list.ttl.should <= 10
-        end
+    [:push, :<<, :unshift].each do |meth, args|
+      it "#{meth} expiration: option" do
+        @list = Redis::List.new('spec/list_exp', :expiration => 10)
+        @list.clear
+        @list.send(meth, 'val')
+        @list.ttl.should > 0
+        @list.ttl.should <= 10
       end
 
-      after do
+      it "#{meth} expireat: option" do
+        @list = Redis::List.new('spec/list_exp', :expireat => Time.now + 10.seconds)
         @list.clear
+        @list.send(meth, 'val')
+        @list.ttl.should > 0
+        @list.ttl.should <= 10
       end
     end
+
+    it "[]= expiration: option" do
+      @list = Redis::List.new('spec/list_exp', :expiration => 10)
+      @list.clear
+      @list.redis.rpush(@list.key, 'hello')
+      @list[0] = 'world'
+      @list.ttl.should > 0
+      @list.ttl.should <= 10
+    end
+
+    it "[]= expireat: option" do
+      @list = Redis::List.new('spec/list_exp', :expireat => Time.now + 10.seconds)
+      @list.clear
+      @list.redis.rpush(@list.key, 'hello')
+      @list[0] = 'world'
+      @list.ttl.should > 0
+      @list.ttl.should <= 10
+    end
+
+    it "insert expiration: option" do
+      @list = Redis::List.new('spec/list_exp', :expiration => 10)
+      @list.clear
+      @list.redis.rpush(@list.key, 'hello')
+      @list.insert 'BEFORE', 'hello', 'world'
+      @list.ttl.should > 0
+      @list.ttl.should <= 10
+    end
+
+    it "insert expireat: option" do
+      @list = Redis::List.new('spec/list_exp', :expireat => Time.now + 10.seconds)
+      @list.clear
+      @list.redis.rpush(@list.key, 'hello')
+      @list.insert 'BEFORE', 'hello', 'world'
+      @list.ttl.should > 0
+      @list.ttl.should <= 10
+    end
   end
 
 end
@@ -440,7 +475,7 @@ describe Redis::Counter do
       @counter.ttl.should <= 10
     end
 
-   [:increment, :incr, :incrby, :incrbyfloat, 
+   [:increment, :incr, :incrby, :incrbyfloat,
     :decrement, :decr, :decrby, :decrbyfloat, :reset].each do |meth|
       describe meth do
         it "expiration: option" do
@@ -574,7 +609,6 @@ describe Redis::Lock do
   end
 end
 
-
 describe Redis::HashKey do
   describe "With Marshal" do
     before do
@@ -794,28 +828,37 @@ describe Redis::HashKey do
     block.should == "oops: missing_key"
   end
 
-  #[:[]=, :store, :bulk_set, :fill,
   describe 'with expiration' do
-    [:incrby, :incr, :incrbyfloat, :decrby, :decr, :decrbyfloat].each do |meth|
-      describe meth do
-        it "expiration: option" do
-          @hash = Redis::HashKey.new('spec/hash_exp', :expiration => 10)
-          @hash.send(meth, 'somekey')
-          @hash.ttl.should > 0
-          @hash.ttl.should <= 10
-        end
-        it "expireat: option" do
-          @hash = Redis::HashKey.new('spec/hash_exp', :expireat => Time.now + 10.seconds)
-          @hash.send(meth, 'somekey')
-          @hash.ttl.should > 0
-          @hash.ttl.should <= 10
-        end
-        after do
-          @hash.clear
-        end
+    {
+      :incrby      => 'somekey',
+      :incr        => 'somekey',
+      :incrbyfloat => 'somekey',
+      :decrby      => 'somekey',
+      :decr        => 'somekey',
+      :decrbyfloat => 'somekey',
+      :store       => ['somekey', 'somevalue'],
+      :[]=         => ['somekey', 'somevalue'],
+      :bulk_set    => [{ 'somekey' => 'somevalue' }],
+      :update      => [{ 'somekey' => 'somevalue' }],
+      :fill        => [{ 'somekey' => 'somevalue' }]
+    }.each do |meth, args|
+      it "#{meth} expiration: option" do
+        @hash = Redis::HashKey.new('spec/hash_expiration', :expiration => 10)
+        @hash.clear
+        @hash.send(meth, *args)
+        @hash.ttl.should > 0
+        @hash.ttl.should <= 10
       end
-    end 
-  end 
+
+      it "#{meth} expireat: option" do
+        @hash = Redis::HashKey.new('spec/hash_expireat', :expireat => Time.now + 10.seconds)
+        @hash.clear
+        @hash.send(meth, *args)
+        @hash.ttl.should > 0
+        @hash.ttl.should <= 10
+      end
+    end
+  end
 
   after do
     @hash.clear
@@ -991,18 +1034,22 @@ describe Redis::Set do
     @set_1.redis.del SORT_STORE[:store]
   end
 
-  it 'should set time to live in seconds when expiration option assigned' do
-    @set = Redis::Set.new('spec/set', :expiration => 10)
-    @set << 'val'
-    @set.ttl.should > 0
-    @set.ttl.should <= 10
-  end
+  describe "with expiration" do
+    [:<<, :add].each do |meth|
+      it "should set time to live in seconds when expiration option assigned" do
+        @set = Redis::Set.new('spec/set', :expiration => 10)
+        @set.send(meth, 'val')
+        @set.ttl.should > 0
+        @set.ttl.should <= 10
+      end
 
-  it 'should set expiration when expireat option assigned' do
-    @set = Redis::Set.new('spec/set', :expireat => Time.now + 10.seconds)
-    @set << 'val'
-    @set.ttl.should > 0
-    @set.ttl.should <= 10
+      it "should set expiration when expireat option assigned" do
+        @set = Redis::Set.new('spec/set', :expireat => Time.now + 10.seconds)
+        @set.send(meth, 'val')
+        @set.ttl.should > 0
+        @set.ttl.should <= 10
+      end
+    end
   end
 
   after do
@@ -1257,25 +1304,79 @@ describe Redis::SortedSet do
 
   describe "with expiration" do
     [:[]=, :add, :increment, :incr, :incrby, :decrement, :decr, :decrby].each do |meth|
-      describe meth do
-        it "expiration: option" do
-          @hash = Redis::SortedSet.new('spec/zset_exp', :expiration => 10)
-          @hash.send(meth, 'somekey', 12)
-          @hash.ttl.should > 0
-          @hash.ttl.should <= 10
-        end
-        it "expireat: option" do
-          @hash = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10.seconds)
-          @hash.send(meth, 'somekey', 12)
-          @hash.ttl.should > 0
-          @hash.ttl.should <= 10
-        end
-        after do
-          @hash.clear
-        end
+      it "#{meth} expiration: option" do
+        @set = Redis::SortedSet.new('spec/zset_exp', :expiration => 10)
+        @set.clear
+        @set.send(meth, 'somekey', 12)
+        @set.ttl.should > 0
+        @set.ttl.should <= 10
+      end
+      it "#{meth} expireat: option" do
+        @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10.seconds)
+        @set.clear
+        @set.send(meth, 'somekey', 12)
+        @set.ttl.should > 0
+        @set.ttl.should <= 10
+      end
+    end
+
+    [:merge, :add_all].each do |meth|
+      it "#{meth} expiration: option" do
+        @set = Redis::SortedSet.new('spec/zset_exp', :expiration => 10)
+        @set.clear
+        @set.send(meth, 'somekey' => 12)
+        @set.ttl.should > 0
+        @set.ttl.should <= 10
+      end
+      it "#{meth} expireat: option" do
+        @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10.seconds)
+        @set.clear
+        @set.send(meth, 'somekey' => 12)
+        @set.ttl.should > 0
+        @set.ttl.should <= 10
+      end
+    end
+
+    [:unionstore, :interstore].each do |meth|
+      it "#{meth} expiration: option" do
+        @set = Redis::SortedSet.new('spec/zset_exp', :expiration => 10)
+        @set.clear
+        @set.redis.zadd(@set.key, 1, "1")
+        @set.send(meth, 'sets', Redis::SortedSet.new('other'))
+        @set.ttl.should > 0
+        @set.ttl.should <= 10
+      end
+
+      it "#{meth} expireat: option" do
+        @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10.seconds)
+        @set.clear
+        @set.redis.zadd(@set.key, 1, "1")
+        @set.send(meth, 'sets', Redis::SortedSet.new('other'))
+        @set.ttl.should > 0
+        @set.ttl.should <= 10
       end
     end
-  end 
+
+    it "delete expiration: option" do
+      @set = Redis::SortedSet.new('spec/zset_exp', :expiration => 10)
+      @set.clear
+      @set.redis.zadd(@set.key, 1, "1")
+      @set.redis.zadd(@set.key, 2, "2")
+      @set.delete("2")
+      @set.ttl.should > 0
+      @set.ttl.should <= 10
+    end
+
+    it "delete expireat: option" do
+      @set = Redis::SortedSet.new('spec/zset_exp', :expireat => Time.now + 10.seconds)
+      @set.clear
+      @set.redis.zadd(@set.key, 1, "1")
+      @set.redis.zadd(@set.key, 2, "2")
+      @set.delete("2")
+      @set.ttl.should > 0
+      @set.ttl.should <= 10
+    end
+  end
 
   after do
     @set.clear

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-objects
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Nate Wiger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2015-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis