redis-store 1.1.7 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c34d0f4a72ee0603e5b2ef2b95808baac398b667
-  data.tar.gz: e4805c9cd1bfd2cffc6504e36bddf00c80b0ce45
+  metadata.gz: fdc1ba61b75205e6f17d1bb790c3324d98335abb
+  data.tar.gz: 95cf5013e84b74ef20e9041c971cce5773411ec3
 SHA512:
-  metadata.gz: 85aa71788df20715c5878ee1b13c047c5904a2b57fb30f4d69e9235dd61692b8f01671ac112f789f9ea6730a8db3cc188226c036188691a563df0e48964a6f90
-  data.tar.gz: 9bebac3bac2a0ee4dc94db6f08325ce707a65ca289f36ad049769ed0cbc0ea6c6eba0f8ce8c0786560242f7b6ba683567743738c1d7897669b3909fffe854368
+  metadata.gz: 42f21ac1f963af2a5e96a145672ec97d670dc7bfe94dba63eeda69a1bd37567effb5f2d60a09d4f0871f9ded839318de092b88221189e955dd91191adb20c260
+  data.tar.gz: 488d11620f6f0c2a8ea615825056c199e0267386d374d9d91891c648fe1420739858c7f75cb3c1afafebabe22fa2ffdb99c7c77b33bd46def781a68709c6f15b

data/.travis.yml

@@ -6,8 +6,9 @@ rvm:
   - 2.0.0
   - 2.1
   - 2.2
+  - 2.3.0
   - ruby-head
-  - rbx-19mode
+  - rbx-2
   - jruby-19mode
   - jruby-head
 bundler_args: '--path vendor/bundle'

data/README.md

@@ -21,7 +21,7 @@ Download and install Redis from [the download page](http://redis.io//download) a
 ## Running tests
 
 ```ruby
-git clone git://github.com/jodosha/redis-store.git
+git clone git://github.com/redis-store/redis-store.git
 cd redis-store
 gem install bundler
 bundle exec rake

data/lib/redis/distributed_store.rb

@@ -46,6 +46,10 @@ class Redis
       end
     end
 
+    def setex(key, expiry, value, options = nil)
+      node_for(key).setex(key, expiry, value, options)
+    end
+
     private
       def _extend_namespace(options)
         @namespace = options[:namespace]

data/lib/redis/store/interface.rb

@@ -6,7 +6,7 @@ class Redis
       end
 
       def set(key, value, options = nil)
-        super(key, value)
+        super(key, value, options || {})
       end
 
       def setnx(key, value, options = nil)

data/lib/redis/store/marshalling.rb

@@ -2,15 +2,15 @@ class Redis
   class Store < self
     module Marshalling
       def set(key, value, options = nil)
-        _marshal(value, options) { |value| super encode(key), encode(value), options }
+        _marshal(value, options) { |v| super encode(key), encode(v), options }
       end
 
       def setnx(key, value, options = nil)
-        _marshal(value, options) { |value| super encode(key), encode(value), options }
+        _marshal(value, options) { |v| super encode(key), encode(v), options }
       end
 
       def setex(key, expiry, value, options = nil)
-        _marshal(value, options) { |value| super encode(key), expiry, encode(value), options }
+        _marshal(value, options) { |v| super encode(key), expiry, encode(v), options }
       end
 
       def get(key, options = nil)

data/lib/redis/store/namespace.rb

@@ -1,44 +1,46 @@
 class Redis
   class Store < self
     module Namespace
+      FLUSHDB_BATCH_SIZE = 1000
+
       def set(key, val, options = nil)
-        namespace(key) { |key| super(key, val, options) }
+        namespace(key) { |k| super(k, val, options) }
       end
 
       def setex(key, ttl, val, options = nil)
-        namespace(key) { |key| super(key, ttl, val, options) }
+        namespace(key) { |k| super(k, ttl, val, options) }
       end
 
       def setnx(key, val, options = nil)
-        namespace(key) { |key| super(key, val, options) }
+        namespace(key) { |k| super(k, val, options) }
       end
 
       def ttl(key, options = nil)
-        namespace(key) { |key| super(key) }
+        namespace(key) { |k| super(k) }
       end
 
       def get(key, options = nil)
-        namespace(key) { |key| super(key, options) }
+        namespace(key) { |k| super(k, options) }
       end
 
       def exists(key)
-        namespace(key) { |key| super(key) }
+        namespace(key) { |k| super(k) }
       end
 
       def incrby(key, increment)
-        namespace(key) { |key| super(key, increment) }
+        namespace(key) { |k| super(k, increment) }
       end
 
       def decrby(key, increment)
-        namespace(key) { |key| super(key, increment) }
+        namespace(key) { |k| super(k, increment) }
       end
 
       def keys(pattern = "*")
-        namespace(pattern) { |pattern| super(pattern).map{|key| strip_namespace(key) } }
+        namespace(pattern) { |p| super(p).map{|key| strip_namespace(key) } }
       end
 
       def del(*keys)
-        super *keys.map {|key| interpolate(key) } if keys.any?
+        super(*keys.map {|key| interpolate(key) }) if keys.any?
       end
 
       def mget(*keys)
@@ -46,27 +48,35 @@ class Redis
         if keys.any?
           # Marshalling gets extended before Namespace does, so we need to pass options further
           if singleton_class.ancestors.include? Marshalling
-            super *keys.map {|key| interpolate(key) }, options
+            super(*keys.map {|key| interpolate(key) }, options)
           else
-            super *keys.map {|key| interpolate(key) }
+            super(*keys.map {|key| interpolate(key) })
           end
         end
       end
-      
+
       def expire(key, ttl)
-         namespace(key) { |key| super(key, ttl) }
-      end
-      
-      def ttl(key)
-         namespace(key) { |key| super(key) }
+         namespace(key) { |k| super(k, ttl) }
       end
 
       def to_s
-        "#{super} with namespace #{namespace_str}"
+        if namespace_str
+          "#{super} with namespace #{namespace_str}"
+        else
+          super
+        end
       end
 
       def flushdb
-        del *keys
+        keys.each_slice(FLUSHDB_BATCH_SIZE) { |key_slice| del(*key_slice) }
+      end
+
+      def with_namespace(ns)
+        old_ns = @namespace
+        @namespace = ns
+        yield self
+      ensure
+        @namespace = old_ns
       end
 
       private
@@ -79,10 +89,12 @@ class Redis
         end
 
         def interpolate(key)
+          return key unless namespace_str
           key.match(namespace_regexp) ? key : "#{namespace_str}:#{key}"
         end
 
         def strip_namespace(key)
+          return key unless namespace_str
           key.gsub namespace_regexp, ""
         end
 

data/lib/redis/store/ttl.rb

@@ -5,7 +5,7 @@ class Redis
         if ttl = expires_in(options)
           setex(key, ttl.to_i, value, :raw => true)
         else
-          super(key, value)
+          super(key, value, options)
         end
       end
 

data/lib/redis/store/version.rb

@@ -1,5 +1,5 @@
 class Redis
   class Store < self
-    VERSION = '1.1.7'
+    VERSION = '1.2.0'
   end
 end

data/lib/redis/store.rb

@@ -29,7 +29,7 @@ class Redis
 
       def _extend_namespace(options)
         @namespace = options[:namespace]
-        extend Namespace if @namespace
+        extend Namespace
       end
   end
 end

data/test/redis/store/marshalling_test.rb

@@ -67,6 +67,24 @@ describe "Redis::Marshalling" do
     @store.get("rabbit2").must_be_nil
   end
 
+  it "marshals setex (over a distributed store)" do
+    @store = Redis::DistributedStore.new [
+      {:host => "localhost", :port => "6380", :db => 0},
+      {:host => "localhost", :port => "6381", :db => 0}
+    ]
+    @store.setex "rabbit", 50, @white_rabbit
+    @store.get("rabbit").must_equal(@white_rabbit)
+  end
+
+  it "doesn't marshal setex if raw option is true (over a distributed store)" do
+    @store = Redis::DistributedStore.new [
+      {:host => "localhost", :port => "6380", :db => 0},
+      {:host => "localhost", :port => "6381", :db => 0}
+    ]
+    @store.setex "rabbit", 50, @white_rabbit, :raw => true
+    @store.get("rabbit", :raw => true).must_equal(%(#<OpenStruct color="white">))
+  end
+
   it "doesn't unmarshal on multi get" do
     @store.set "rabbit2", @white_rabbit
     rabbit, rabbit2 = @store.mget "rabbit", "rabbit2"

data/test/redis/store/namespace_test.rb

@@ -7,7 +7,8 @@ describe "Redis::Store::Namespace" do
     @client = @store.instance_variable_get(:@client)
     @rabbit = "bunny"
     @default_store = Redis::Store.new
-    @other_store = Redis::Store.new :namespace => 'other'
+    @other_namespace = 'other'
+    @other_store = Redis::Store.new :namespace => @other_namespace
   end
 
   def teardown
@@ -41,6 +42,18 @@ describe "Redis::Store::Namespace" do
     @default_store.get('abc').must_equal('cba')
   end
 
+  it 'should allow to change namespace on the fly' do
+    @default_store.set 'abc', 'cba'
+    @other_store.set 'foo', 'bar'
+
+    @default_store.keys.sort.must_equal ['abc', 'other:foo']
+
+    @default_store.with_namespace(@other_namespace) do
+      @default_store.keys.must_equal ['foo']
+      @default_store.get('foo').must_equal('bar')
+    end
+  end
+
   it "should not try to delete missing namespaced keys" do
     empty_store = Redis::Store.new :namespace => 'empty'
     empty_store.flushdb

data/test/redis/store/ttl_test.rb

@@ -66,7 +66,7 @@ describe MockTtlStore do
     describe 'without options' do
       it 'must call super with key and value' do
         redis.set(key, mock_value)
-        redis.has_set?(key, mock_value).must_equal true
+        redis.has_set?(key, mock_value, nil).must_equal true
       end
     end
 
@@ -76,6 +76,14 @@ describe MockTtlStore do
         redis.has_setex?(key, options[:expire_after], mock_value, :raw => true).must_equal true
       end
     end
+
+    describe 'with nx and ex option' do
+      it 'must call super with key and value and options' do
+        set_options = {nx: true, ex: 3600}
+        redis.set(key, mock_value, set_options)
+        redis.has_set?(key, mock_value, set_options).must_equal true
+      end
+    end
   end
 
   describe '#setnx' do

data/test/redis/store/version_test.rb

@@ -2,6 +2,6 @@ require 'test_helper'
 
 describe Redis::Store::VERSION do
   it 'returns current version' do
-    Redis::Store::VERSION.must_equal '1.1.6'
+    Redis::Store::VERSION.must_equal '1.1.7'
   end
 end

data/test/redis/store_test.rb

@@ -30,6 +30,28 @@ describe Redis::Store do
         @store.set('key', 'value', options)
       end
     end
+
+    describe 'with ex and nx' do
+      let(:key) { 'key' }
+      let(:mock_value) { 'value' }
+      let(:options) { { nx: true, ex: 3600 } }
+
+      it 'must pass on options' do
+        Marshal.expects(:dump).times(4)
+
+        # without options no ex or nx will be set
+        @store.del(key)
+        @store.set(key, mock_value, {}).must_equal 'OK'
+        @store.set(key, mock_value, {}).must_equal 'OK'
+        @store.ttl(key).must_equal -1
+
+        # with ex and nx options, the key can only be set once and a ttl will be set
+        @store.del(key)
+        @store.set(key, mock_value, options).must_equal true
+        @store.set(key, mock_value, options).must_equal false
+        @store.ttl(key).must_equal 3600
+      end
+    end
   end
 
   describe '#setnx' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-store
 version: !ruby/object:Gem::Version
-  version: 1.1.7
+  version: 1.2.0
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-28 00:00:00.000000000 Z
+date: 2016-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -164,7 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: redis-store
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Redis stores for Ruby frameworks