redis-store 1.8.2 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6a10a3762b8378dd9efe3a4d1b41220691224b6f45fc6af2b06874fe1670cbf
-  data.tar.gz: f81892b9c196e999bde41136a0fbb667e8ff5ddec7c16842afe86847b2872f71
+  metadata.gz: 476790788b3d0462db696bc3773a72c18b3f57f04db394e238bc849b04f6b54a
+  data.tar.gz: 443eca0ff3f6acd16c696aadf4e8cb1c34edf213944d489d66fe6508a5ff2390
 SHA512:
-  metadata.gz: 8a63ad83287d6bc1249ce4980300745cf68243c61c274014b20f49bf0f395e3eb2b0b6e8899217fbf1d14792afc0f6ff54ca82844af1de5ab3a63fdf02fa2d27
-  data.tar.gz: 9d834c549cbf74c18d1f9042216f10016fcb6b2115f3784c03fdc19923bd189382ac1dd88cd658524fe9e9579f24afb0ef25e8d005ce718a1b0441345856e0f1
+  metadata.gz: 104215ff505c8dd84b0baac16c99a75e117b33dafbc0f654f6f87acbf0fba1b0a1c34ce3e63530566f65289ca725a98b1e0a640cfc878f33e27fb51857a243df
+  data.tar.gz: 49730d0bc9e9a1295aaa6b410cae27c58838f953a71fb6255c53e27dc4faa670b827effbe2d0f614d4d4dfbe5f91b333465c380db44475c466f261d534e2d91c

data/.travis.yml

@@ -9,15 +9,16 @@ before_install:
   > ./cc-test-reporter
 - chmod +x ./cc-test-reporter
 rvm:
-  - 2.1
-  - 2.2
   - 2.3
   - 2.4
   - 2.5
   - 2.6
+  - 2.7
   - ruby-head
   - jruby-head
 gemfile:
+- gemfiles/redis_4_0_x.gemfile
+- gemfiles/redis_4_1_x.gemfile
 - gemfiles/redis_4_x.gemfile
 before_script: "./cc-test-reporter before-build"
 after_script:
@@ -28,11 +29,6 @@ matrix:
   allow_failures:
   - rvm: jruby-head
   - rvm: ruby-head
-  exclude:
-  - rvm: 2.1
-    gemfile: gemfiles/redis_4_x.gemfile
-  - rvm: 2.2
-    gemfile: gemfiles/redis_4_x.gemfile
 deploy:
   provider: rubygems
   api_key:

data/Appraisals

@@ -1,6 +1,10 @@
 
-appraise "redis_3_x" do
-  gem "redis", "~> 3.0"
+appraise "redis_4_0_x" do
+  gem "redis", "~> 4.0.0"
+end
+
+appraise "redis_4_1_x" do
+  gem "redis", "~> 4.1.0"
 end
 
 appraise "redis_4_x" do

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 1.9.0
+
+Breaking Changes
+
+* As a factor of updates for Redis v4.2.x, support for Ruby 2.1 and 2.2
+  has been dropped. These Ruby versions are end-of-life anyway.
+
+Fixed
+
+* [Compatibility with Redis client v4.2.x](https://github.com/redis-store/redis-store/pull/333)
+
+Added
+
+* [Support for edge Ruby's keyword arguments](https://github.com/redis-store/redis-store/pull/334)
+
+## 1.8.2
+
+Breaking Changes
+
+* None
+
+Added
+
+* [Add namespace to zincrby and zscore](https://github.com/redis-store/redis-store/pull/323)
+* [Add namespace to zadd and zrem](https://github.com/redis-store/redis-store/pull/326)
+
+Fixed
+
+* None
+
 ## 1.8.1
 
 Breaking Changes

data/gemfiles/{redis_3_x.gemfile → redis_4_0_x.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "redis", "~> 3.0"
+gem "redis", "~> 4.0.0"
 
 gemspec path: "../"

data/gemfiles/redis_4_1_x.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "redis", "~> 4.1.0"
+
+gemspec path: "../"

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)
@@ -39,14 +43,14 @@ class Redis
         namespace(pattern) { |p| super(p).map { |key| strip_namespace(key) } }
       end
 
-      def scan(cursor, options = {})
-        if options[:match]
-          namespace(options[:match]) do |pattern|
-            cursor, keys = super(cursor, options.merge(match: pattern))
-            [ cursor, keys.map{|key| strip_namespace(key) } ]
+      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, options)
+          super(cursor, **kwargs)
         end
       end
 
@@ -74,34 +78,70 @@ class Redis
         end
       end
 
+      def expire(key, 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 hsetnx(key, field, val)
-        namespace(key) { |k| super(k, field, val) }
+      def hexists(key, field)
+        namespace(key) { |k| super(k, field) }
       end
 
-      def hset(key, field, val)
-        namespace(key) { |k| super(k, field, val) }
+      def hincrby(key, field, increment)
+        namespace(key) { |k| super(k, field, increment) }
       end
 
-      def expire(key, ttl)
-        namespace(key) { |k| super(k, ttl) }
+      def hincrbyfloat(key, field, increment)
+        namespace(key) { |k| super(k, field, increment) }
       end
 
-      def hscan(key, cursor, options = {})
-        namespace(key) { |k| super(k, cursor, options) }
+      def hkeys(key)
+        namespace(key) { |k| super(k) }
       end
 
-      def hdel(key, *fields)
-        namespace(key) { |k| super(k, fields) }
+      def hlen(key)
+        namespace(key) { |k| super(k) }
       end
 
-      def hlen(key)
+      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
@@ -110,14 +150,18 @@ class Redis
         namespace(key) { |k| super(k, member) }
       end
 
-      def zadd(key, increment, member)
-        namespace(key) { |k| super(k, increment, member) }
+      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
         if namespace_str
           "#{super} with namespace #{namespace_str}"

data/lib/redis/store/version.rb

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

data/redis-store.gemspec

@@ -12,8 +12,6 @@ Gem::Specification.new do |s|
   s.summary     = 'Redis stores for Ruby frameworks'
   s.description = 'Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks.'
 
-  s.rubyforge_project = 'redis-store'
-
   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) }
@@ -22,7 +20,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'redis', '>= 4', '< 5'
 
-  s.add_development_dependency 'rake',     '~> 10'
+  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'

data/test/redis/store/namespace_test.rb

@@ -194,14 +194,54 @@ describe "Redis::Store::Namespace" do
       end
     end
 
+    it "should namespace hdel" do
+      client.expects(:call).with([:hdel, "#{@namespace}:rabbit", "key1", "key2"]).once
+      store.hdel("rabbit", "key1", "key2")
+    end
+
+    it "should namespace hget" do
+      client.expects(:call).with([:hget, "#{@namespace}:rabbit", "key"]).once
+      store.hget("rabbit", "key")
+    end
+
     it "should namespace hgetall" do
       client.expects(:call).with([:hgetall, "#{@namespace}:rabbit"]).once
       store.hgetall("rabbit")
     end
 
-    it "should namespace hsetnx" do
-      client.expects(:call).with([:hsetnx, "#{@namespace}:rabbit", "key", @rabbit])
-      store.hsetnx("rabbit", "key", @rabbit)
+    it "should namespace hexists" do
+      client.expects(:call).with([:hexists, "#{@namespace}:rabbit", "key"]).once
+      results = store.hexists("rabbit", "key")
+    end
+
+    it "should namespace hincrby" do
+      client.expects(:call).with([:hincrby, "#{@namespace}:rabbit", "key", 1]).once
+      store.hincrby("rabbit", "key", 1)
+    end
+
+    it "should namespace hincrbyfloat" do
+      client.expects(:call).with([:hincrby, "#{@namespace}:rabbit", "key", 1.5]).once
+      store.hincrby("rabbit", "key", 1.5)
+    end
+
+    it "should namespace hkeys" do
+      client.expects(:call).with([:hkeys, "#{@namespace}:rabbit"])
+      store.hkeys("rabbit")
+    end
+
+    it "should namespace hlen" do
+      client.expects(:call).with([:hlen, "#{@namespace}:rabbit"])
+      store.hlen("rabbit")
+    end
+
+    it "should namespace hmget" do
+      client.expects(:call).with([:hmget, "#{@namespace}:rabbit", "key1", "key2"])
+      store.hmget("rabbit", "key1", "key2")
+    end
+
+    it "should namespace hmset" do
+      client.expects(:call).with([:hmset, "#{@namespace}:rabbit", "key", @rabbit])
+      store.hmset("rabbit", "key", @rabbit)
     end
 
     it "should namespace hset" do
@@ -209,27 +249,44 @@ describe "Redis::Store::Namespace" do
       store.hset("rabbit", "key", @rabbit)
     end
 
+    it "should namespace hsetnx" do
+      client.expects(:call).with([:hsetnx, "#{@namespace}:rabbit", "key", @rabbit])
+      store.hsetnx("rabbit", "key", @rabbit)
+    end
+
+    it "should namespace hvals" do
+      client.expects(:call).with([:hvals, "#{@namespace}:rabbit"])
+      store.hvals("rabbit")
+    end
+
     it "should namespace hscan" do
       client.expects(:call).with([:hscan, "#{@namespace}:rabbit", 0])
       store.hscan("rabbit", 0)
     end
 
-    it "should namespace hdel" do
-      client.expects(:call).with([:hdel, "#{@namespace}:rabbit", %w(field)])
-      store.hdel("rabbit", "field")
+    it "should namespace hscan_each with block" do
+      client.call([:hset, "#{@namespace}:rabbit", "key1", @rabbit])
+      client.expects(:call).with([:hscan, "#{@namespace}:rabbit", 0]).returns(["0", ["key1"]])
+      results = []
+      store.hscan_each("rabbit") do |key|
+        results << key
+      end
+      results.must_equal(["key1"])
     end
 
-    it "should namespace hlen" do
-      client.expects(:call).with([:hlen, "#{@namespace}:rabbit"])
-      store.hlen("rabbit")
+    it "should namespace hscan_each without block" do
+      client.call([:hset, "#{@namespace}:rabbit", "key1", @rabbit])
+      client.expects(:call).with([:hscan, "#{@namespace}:rabbit", 0]).returns(["0", ["key1"]])
+      results = store.hscan_each("rabbit").to_a
+      results.must_equal(["key1"])
     end
 
-    it "should namespace zincrby" do 
+    it "should namespace zincrby" do
       client.expects(:call).with([:zincrby, "#{@namespace}:rabbit", 1.0, "member"])
       store.zincrby("rabbit", 1.0, "member")
     end
 
-    it "should namespace zscore" do 
+    it "should namespace zscore" do
       client.expects(:call).with([:zscore, "#{@namespace}:rabbit", "member"])
       store.zscore("rabbit", "member")
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-store
 version: !ruby/object:Gem::Version
-  version: 1.8.2
+  version: 1.9.0
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-24 00:00:00.000000000 Z
+date: 2020-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -34,16 +34,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -190,7 +190,8 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- gemfiles/redis_3_x.gemfile
+- gemfiles/redis_4_0_x.gemfile
+- gemfiles/redis_4_1_x.gemfile
 - gemfiles/redis_4_x.gemfile
 - lib/redis-store.rb
 - lib/redis/distributed_store.rb
@@ -232,7 +233,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Redis stores for Ruby frameworks