redis-store 1.5.0 → 1.9.0

data/lib/redis/store/interface.rb

@@ -5,8 +5,16 @@ class Redis
         super(key)
       end
 
+      REDIS_SET_OPTIONS = %i(ex px nx xx keepttl).freeze
+      private_constant :REDIS_SET_OPTIONS
+
       def set(key, value, options = nil)
-        super(key, value, options || {})
+        if options && REDIS_SET_OPTIONS.any? { |k| options.key?(k) }
+          kwargs = REDIS_SET_OPTIONS.each_with_object({}) { |key, h| h[key] = options[key] if options.key?(key) }
+          super(key, value, **kwargs)
+        else
+          super(key, value)
+        end
       end
 
       def setnx(key, value, options = nil)

data/lib/redis/store/namespace.rb

@@ -3,28 +3,32 @@ class Redis
     module Namespace
       FLUSHDB_BATCH_SIZE = 1000
 
-      def set(key, val, options = nil)
-        namespace(key) { |k| super(k, val, options) }
+      def set(key, *args)
+        namespace(key) { |k| super(k, *args) }
       end
 
-      def setex(key, ttl, val, options = nil)
-        namespace(key) { |k| super(k, ttl, val, options) }
+      def setex(key, *args)
+        namespace(key) { |k| super(k, *args) }
       end
 
-      def setnx(key, val, options = nil)
-        namespace(key) { |k| super(k, val, options) }
+      def setnx(key, *args)
+        namespace(key) { |k| super(k, *args) }
       end
 
       def ttl(key, options = nil)
         namespace(key) { |k| super(k) }
       end
 
-      def get(key, options = nil)
-        namespace(key) { |k| super(k, options) }
+      def get(key, *args)
+        namespace(key) { |k| super(k, *args) }
       end
 
-      def exists(key)
-        namespace(key) { |k| super(k) }
+      def exists(*keys)
+        super(*keys.map { |key| interpolate(key) })
+      end
+
+      def exists?(*keys)
+        super(*keys.map { |key| interpolate(key) })
       end
 
       def incrby(key, increment)
@@ -36,15 +40,30 @@ class Redis
       end
 
       def keys(pattern = "*")
-        namespace(pattern) { |p| super(p).map{|key| strip_namespace(key) } }
+        namespace(pattern) { |p| super(p).map { |key| strip_namespace(key) } }
+      end
+
+      def scan(cursor, match: nil, **kwargs)
+        if match
+          namespace(match) do |pattern|
+            cursor, keys = super(cursor, match: pattern, **kwargs)
+            [ cursor, keys.map{ |key| strip_namespace(key) } ]
+          end
+        else
+          super(cursor, **kwargs)
+        end
       end
 
       def del(*keys)
-        super(*keys.map {|key| interpolate(key) }) if keys.any?
+        super(*keys.map { |key| interpolate(key) }) if keys.any?
+      end
+
+      def unlink(*keys)
+        super(*keys.map { |key| interpolate(key) }) if keys.any?
       end
 
       def watch(*keys)
-        super(*keys.map {|key| interpolate(key) }) if keys.any?
+        super(*keys.map { |key| interpolate(key) }) if keys.any?
       end
 
       def mget(*keys, &blk)
@@ -52,15 +71,95 @@ class Redis
         if keys.any?
           # Serialization gets extended before Namespace does, so we need to pass options further
           if singleton_class.ancestors.include? Serialization
-            super(*keys.map {|key| interpolate(key) }, options, &blk)
+            super(*keys.map { |key| interpolate(key) }, options, &blk)
           else
-            super(*keys.map {|key| interpolate(key) }, &blk)
+            super(*keys.map { |key| interpolate(key) }, &blk)
           end
         end
       end
 
       def expire(key, ttl)
-         namespace(key) { |k| super(k, ttl) }
+        namespace(key) { |k| super(k, ttl) }
+      end
+
+      def hdel(key, *fields)
+        namespace(key) { |k| super(k, *fields) }
+      end
+
+      def hget(key, field)
+        namespace(key) { |k| super(k, field) }
+      end
+
+      def hgetall(key)
+        namespace(key) { |k| super(k) }
+      end
+
+      def hexists(key, field)
+        namespace(key) { |k| super(k, field) }
+      end
+
+      def hincrby(key, field, increment)
+        namespace(key) { |k| super(k, field, increment) }
+      end
+
+      def hincrbyfloat(key, field, increment)
+        namespace(key) { |k| super(k, field, increment) }
+      end
+
+      def hkeys(key)
+        namespace(key) { |k| super(k) }
+      end
+
+      def hlen(key)
+        namespace(key) { |k| super(k) }
+      end
+
+      def hmget(key, *fields, &blk)
+        namespace(key) { |k| super(k, *fields, &blk) }
+      end
+
+      def hmset(key, *attrs)
+        namespace(key) { |k| super(k, *attrs) }
+      end
+
+      def hset(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def hsetnx(key, field, val)
+        namespace(key) { |k| super(k, field, val) }
+      end
+
+      def hvals(key)
+        namespace(key) { |k| super(k) }
+      end
+
+      def hscan(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def hscan_each(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def zincrby(key, increment, member)
+        namespace(key) { |k| super(k, increment, member) }
+      end
+
+      def zscore(key, member)
+        namespace(key) { |k| super(k, member) }
+      end
+
+      def zadd(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def zrem(key, member)
+        namespace(key) { |k| super(k, member) }
+      end
+
+      if respond_to?(:ruby2_keywords, true)
+        ruby2_keywords :set, :setex, :setnx, :hscan, :hscan_each
       end
 
       def to_s

data/lib/redis/store/redis_version.rb

@@ -11,4 +11,3 @@ class Redis
     end
   end
 end
-

data/lib/redis/store/ttl.rb

@@ -34,7 +34,7 @@ class Redis
         end
 
         def with_multi_or_pipelined(options, &block)
-          return pipelined(&block) if options[:avoid_multi_commands]
+          return pipelined(&block) if options.key?(:cluster) || options[:avoid_multi_commands]
           multi(&block)
         end
     end

data/lib/redis/store/version.rb

@@ -1,5 +1,5 @@
 class Redis
   class Store < self
-    VERSION = '1.5.0'
+    VERSION = '1.9.0'
   end
 end

data/redis-store.gemspec

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+
 $:.push File.expand_path('../lib', __FILE__)
 require 'redis/store/version'
 
@@ -8,21 +9,19 @@ Gem::Specification.new do |s|
   s.authors     = ['Luca Guidi']
   s.email       = ['me@lucaguidi.com']
   s.homepage    = 'http://redis-store.org/redis-store'
-  s.summary     = %q{Redis stores for Ruby frameworks}
-  s.description = %q{Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks.}
-
-  s.rubyforge_project = 'redis-store'
+  s.summary     = 'Redis stores for Ruby frameworks'
+  s.description = 'Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks.'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
   s.license       = 'MIT'
 
-  s.add_dependency 'redis', '>= 2.2', '< 5'
+  s.add_dependency 'redis', '>= 4', '< 5'
 
-  s.add_development_dependency 'rake',     '~> 10'
-  s.add_development_dependency 'bundler',  '~> 1.3'
+  s.add_development_dependency 'rake',     '>= 12.3.3'
+  s.add_development_dependency 'bundler'
   s.add_development_dependency 'mocha',    '~> 0.14.0'
   s.add_development_dependency 'minitest', '~> 5'
   s.add_development_dependency 'git',      '~> 1.2'
@@ -30,4 +29,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'pry',      '~> 0.10.4'
   s.add_development_dependency 'redis-store-testing'
   s.add_development_dependency 'appraisal', '~> 2.0'
+  s.add_development_dependency 'rubocop', '~> 0.54'
 end

data/test/redis/distributed_store_test.rb

@@ -3,8 +3,8 @@ require 'test_helper'
 describe "Redis::DistributedStore" do
   def setup
     @dmr = Redis::DistributedStore.new [
-      {:host => "localhost", :port => "6380", :db => 0},
-      {:host => "localhost", :port => "6381", :db => 0}
+      { :host => "localhost", :port => "6380", :db => 0 },
+      { :host => "localhost", :port => "6381", :db => 0 }
     ]
     @rabbit = OpenStruct.new :name => "bunny"
     @white_rabbit = OpenStruct.new :color => "white"
@@ -67,8 +67,8 @@ describe "Redis::DistributedStore" do
 
   it "passes through ring replica options" do
     dmr = Redis::DistributedStore.new [
-                                    {:host => "localhost", :port => "6380", :db => 0},
-                                    {:host => "localhost", :port => "6381", :db => 0}
+                                    { :host => "localhost", :port => "6380", :db => 0 },
+                                    { :host => "localhost", :port => "6381", :db => 0 }
                                 ], replicas: 1024
     dmr.ring.replicas.must_equal 1024
   end
@@ -76,8 +76,8 @@ describe "Redis::DistributedStore" do
   it "uses a custom ring object" do
     my_ring = Redis::HashRing.new
     dmr = Redis::DistributedStore.new [
-                                          {:host => "localhost", :port => "6380", :db => 0},
-                                          {:host => "localhost", :port => "6381", :db => 0}
+                                          { :host => "localhost", :port => "6380", :db => 0 },
+                                          { :host => "localhost", :port => "6381", :db => 0 }
                                       ], ring: my_ring
     dmr.ring.must_equal my_ring
     dmr.ring.nodes.length.must_equal 2
@@ -100,8 +100,8 @@ describe "Redis::DistributedStore" do
   describe "namespace" do
     it "uses namespaced key" do
       @dmr = Redis::DistributedStore.new [
-        {:host => "localhost", :port => "6380", :db => 0},
-        {:host => "localhost", :port => "6381", :db => 0}
+        { :host => "localhost", :port => "6380", :db => 0 },
+        { :host => "localhost", :port => "6381", :db => 0 }
       ], :namespace => "theplaylist"
 
       @dmr.expects(:node_for).with("theplaylist:rabbit").returns(@dmr.nodes.first)

data/test/redis/store/factory_test.rb

@@ -22,6 +22,11 @@ describe "Redis::Store::Factory" do
         store.to_s.must_equal("Redis Client connected to localhost:6380 against DB 0")
       end
 
+      it "uses specified scheme" do
+        store = Redis::Store::Factory.create :scheme => "rediss"
+        store.instance_variable_get(:@client).scheme.must_equal('rediss')
+      end
+
       it "uses specified path" do
         store = Redis::Store::Factory.create :path => "/var/run/redis.sock"
         store.to_s.must_equal("Redis Client connected to /var/run/redis.sock against DB 0")
@@ -69,6 +74,23 @@ describe "Redis::Store::Factory" do
         store.instance_variable_get(:@options)[:raw].must_equal(false)
       end
 
+      describe "defaults" do
+        it "defaults to localhost if no host specified" do
+          store = Redis::Store::Factory.create
+          store.instance_variable_get(:@client).host.must_equal('127.0.0.1')
+        end
+
+        it "defaults to 6379 if no port specified" do
+          store = Redis::Store::Factory.create
+          store.instance_variable_get(:@client).port.must_equal(6379)
+        end
+
+        it "defaults to redis:// if no scheme specified" do
+          store = Redis::Store::Factory.create
+          store.instance_variable_get(:@client).scheme.must_equal('redis')
+        end
+      end
+
       describe 'with stdout disabled' do
         before do
           @original_stderr = $stderr
@@ -98,11 +120,11 @@ describe "Redis::Store::Factory" do
 
       it "should instantiate a Redis::DistributedStore store" do
         store = Redis::Store::Factory.create(
-          {:host => "localhost", :port => 6379},
-          {:host => "localhost", :port => 6380}
+          { :host => "localhost", :port => 6379 },
+          { :host => "localhost", :port => 6380 }
         )
         store.must_be_kind_of(Redis::DistributedStore)
-        store.nodes.map {|node| node.to_s }.must_equal([
+        store.nodes.map { |node| node.to_s }.must_equal([
           "Redis Client connected to localhost:6379 against DB 0",
           "Redis Client connected to localhost:6380 against DB 0",
         ])
@@ -120,6 +142,16 @@ describe "Redis::Store::Factory" do
         store.to_s.must_equal("Redis Client connected to 127.0.0.1:6380 against DB 0")
       end
 
+      it "uses specified scheme" do
+        store = Redis::Store::Factory.create "rediss://127.0.0.1:6380"
+        store.instance_variable_get(:@client).scheme.must_equal('rediss')
+      end
+
+      it "correctly defaults to redis:// when relative scheme specified" do
+        store = Redis::Store::Factory.create "//127.0.0.1:6379"
+        store.instance_variable_get(:@client).scheme.must_equal('redis')
+      end
+
       it "uses specified path" do
         store = Redis::Store::Factory.create "unix:///var/run/redis.sock"
         store.to_s.must_equal("Redis Client connected to /var/run/redis.sock against DB 0")
@@ -174,50 +206,50 @@ describe "Redis::Store::Factory" do
       it "instantiates Redis::DistributedStore" do
         store = Redis::Store::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380"
         store.must_be_kind_of(Redis::DistributedStore)
-        store.nodes.map {|node| node.to_s }.must_equal([
+        store.nodes.map { |node| node.to_s }.must_equal([
           "Redis Client connected to 127.0.0.1:6379 against DB 0",
           "Redis Client connected to 127.0.0.1:6380 against DB 0",
         ])
       end
     end
 
-    describe 'when given host Hash and options Hash' do 
+    describe 'when given host Hash and options Hash' do
       it 'instantiates Redis::Store and merges options' do
         store = Redis::Store::Factory.create(
-          { :host => '127.0.0.1', :port => '6379' }, 
+          { :host => '127.0.0.1', :port => '6379' },
           { :namespace => 'theplaylist' }
         )
       end
 
-      it 'instantiates Redis::DistributedStore and merges options' do 
+      it 'instantiates Redis::DistributedStore and merges options' do
         store = Redis::Store::Factory.create(
-          { :host => '127.0.0.1', :port => '6379' }, 
-          { :host => '127.0.0.1', :port => '6380' }, 
+          { :host => '127.0.0.1', :port => '6379' },
+          { :host => '127.0.0.1', :port => '6380' },
           { :namespace => 'theplaylist' }
         )
-        store.nodes.map {|node| node.to_s }.must_equal([
+        store.nodes.map { |node| node.to_s }.must_equal([
           "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist",
           "Redis Client connected to 127.0.0.1:6380 against DB 0 with namespace theplaylist"
         ])
       end
     end
 
-    describe 'when given host String and options Hash' do 
-      it 'instantiates Redis::Store and merges options' do 
-        store = Redis::Store::Factory.create "redis://127.0.0.1", { :namespace => 'theplaylist' }
+    describe 'when given host String and options Hash' do
+      it 'instantiates Redis::Store and merges options' do
+        store = Redis::Store::Factory.create "redis://127.0.0.1", :namespace => 'theplaylist'
         store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
       end
 
-      it 'instantiates Redis::DistributedStore and merges options' do 
-        store = Redis::Store::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380", { :namespace => 'theplaylist' }
-        store.nodes.map {|node| node.to_s }.must_equal([
+      it 'instantiates Redis::DistributedStore and merges options' do
+        store = Redis::Store::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380", :namespace => 'theplaylist'
+        store.nodes.map { |node| node.to_s }.must_equal([
           "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist",
           "Redis Client connected to 127.0.0.1:6380 against DB 0 with namespace theplaylist",
         ])
       end
 
       it 'instantiates Redis::Store and sets namespace from String' do
-        store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0/theplaylist", { :expire_after => 5 }
+        store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0/theplaylist", :expire_after => 5
         store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
       end
     end

data/test/redis/store/interface_test.rb

@@ -10,18 +10,18 @@ describe Redis::Store::Interface do
   end
 
   it "should get an element" do
-    lambda { @r.get("key", :option => true) } #.wont_raise ArgumentError
+    lambda { @r.get("key", :option => true) } # .wont_raise ArgumentError
   end
 
   it "should set an element" do
-    lambda { @r.set("key", "value", :option => true) } #.wont_raise ArgumentError
+    lambda { @r.set("key", "value", :option => true) } # .wont_raise ArgumentError
   end
 
   it "should setnx an element" do
-    lambda { @r.setnx("key", "value", :option => true) } #.wont_raise ArgumentError
+    lambda { @r.setnx("key", "value", :option => true) } # .wont_raise ArgumentError
   end
 
   it "should setex an element" do
-    lambda { @r.setex("key", 1, "value", :option => true) } #.wont_raise ArgumentError
+    lambda { @r.setex("key", 1, "value", :option => true) } # .wont_raise ArgumentError
   end
 end