redis-namespace 1.6.0 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: '08244a1c35f2f0164e72385ebd64aae7c57354b6'
-  data.tar.gz: dd76131303f0cbb576780146d9c5e3a759302e57
+SHA256:
+  metadata.gz: e003f4015162bfd465e79dd90e54b44ae46f0ec269118e10c08215d639166296
+  data.tar.gz: 16078b51e1bdab24977aa2b6fb7d0cd4761a7c41c340fcdacfb96dd32216c061
 SHA512:
-  metadata.gz: 4ca1e49aaf2c9e213a0859d1a0bda67f988ddf3a5af08bbf08388a8582298659d6a6869b7d8ee035501d8abf35779be20164dff5b849110f75f173cafb3444e5
-  data.tar.gz: ca1151681a327f2206370a12f63729ee4f9a0891830274fc0e219353137f09216757421cfb4d4d29c18f73ca2f6e2b7bcf8ff4a0dc55a88324cd0aa7957f2993
+  metadata.gz: fb965b575fe3ec2f2f45b99a71839f569f647681939b16576c053ab3e25bf85db1db030941bbe6eaeecc624eeeaf8c0497c58c53c4231440896e9e116bc189e3
+  data.tar.gz: 07b2b2e20c4a152b3e3a4cfbf6abad773f335e098067a9b213e29dd80cfc4519f3d27c43febe6cf8261ffe95e73184e23a1b9ff557007eb7a8308e43a398bbb1

data/LICENSE

@@ -1,20 +1,21 @@
+MIT License
+
 Copyright (c) 2009 Chris Wanstrath
 
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -3,13 +3,13 @@ redis-namespace
 
 Redis::Namespace provides an interface to a namespaced subset of your [redis][] keyspace (e.g., keys with a common beginning), and requires the [redis-rb][] gem.
 
-~~~ irb
+```ruby
 require 'redis-namespace'
 # => true
 
 redis_connection = Redis.new
 # => #<Redis client v3.1.0 for redis://127.0.0.1:6379/0>
-namespaced_redis = Redis::Namespace.new(:ns, :redis => redis_connection)
+namespaced_redis = Redis::Namespace.new(:ns, redis: redis_connection)
 # => #<Redis::Namespace v1.5.0 with client v3.1.0 for redis://127.0.0.1:6379/0/ns>
 
 namespaced_redis.set('foo', 'bar') # redis_connection.set('ns:foo', 'bar')
@@ -20,6 +20,8 @@ namespaced_redis.set('foo', 'bar') # redis_connection.set('ns:foo', 'bar')
 
 namespaced_redis.get('foo')
 # => "bar"
+redis_connection.get('foo')
+# => nil
 redis_connection.get('ns:foo')
 # => "bar"
 
@@ -29,7 +31,14 @@ namespaced_redis.get('foo')
 # => nil
 redis_connection.get('ns:foo')
 # => nil
-~~~
+```
+
+Redis::Namespace also supports `Proc` as a namespace and will take the result string as namespace at runtime.
+
+```ruby
+redis_connection = Redis.new
+namespaced_redis = Redis::Namespace.new(Proc.new { Tenant.current_tenant }, redis: redis_connection)
+```
 
 Installation
 ============
@@ -42,20 +51,18 @@ From the command line:
 
 Or in your Gemfile:
 
-~~~ ruby
+```ruby
 gem 'redis-namespace'
-~~~
+```
 
 Caveats
 =======
 
-`Redis::Namespace` provides a namespaced interface to `Redis` by keeping an internal registry of the method signatures in `Redis` provided by the redis-rb gem;
-we keep track of which arguments need the namespace added, and which return values need the namespace removed.
+`Redis::Namespace` provides a namespaced interface to `Redis` by keeping an internal registry of the method signatures in `Redis` provided by the [redis-rb][] gem; we keep track of which arguments need the namespace added, and which return values need the namespace removed.
 
 Blind Passthrough
 -----------------
-If your version of this gem doesn't know about a particular command, it can't namespace it.
-Historically, this has meant that Redis::Namespace blindly passes unknown commands on to the underlying redis connection without modification which can lead to surprising effects.
+If your version of this gem doesn't know about a particular command, it can't namespace it. Historically, this has meant that Redis::Namespace blindly passes unknown commands on to the underlying redis connection without modification which can lead to surprising effects.
 
 As of v1.5.0, blind passthrough has been deprecated, and the functionality will be removed entirely in 2.0.
 
@@ -63,26 +70,23 @@ If you come across a command that is not yet supported, please open an issue on
 
 Administrative Commands
 -----------------------
-The effects of some redis commands cannot be limited to a particular namespace (e.g., `FLUSHALL`, which literally truncates all databases in your redis server, regardless of keyspace).
-Historically, this has meant that Redis::Namespace intentionally passes administrative commands on to the underlying redis connection without modification, which can lead to surprising effects.
+The effects of some redis commands cannot be limited to a particular namespace (e.g., `FLUSHALL`, which literally truncates all databases in your redis server, regardless of keyspace). Historically, this has meant that Redis::Namespace intentionally passes administrative commands on to the underlying redis connection without modification, which can lead to surprising effects.
 
-As of v1.6.0, the direct use of administrative commands has been deprecated, and the functionality will be removed entirely in 2.0;
-while such commands are often useful for testing or administration, their meaning is inherently hidden when placed behind an interface that implies it will namespace everything.
+As of v1.6.0, the direct use of administrative commands has been deprecated, and the functionality will be removed entirely in 2.0; while such commands are often useful for testing or administration, their meaning is inherently hidden when placed behind an interface that implies it will namespace everything.
 
-The prefered way to send an administrative command is on the redis connection
-itself, which is publicly exposed as `Redis::Namespace#redis`:
+The prefered way to send an administrative command is on the redis connection itself, which is publicly exposed as `Redis::Namespace#redis`:
 
-~~~ ruby
+```ruby
 namespaced.redis.flushall()
 # => "OK"
-~~~
+```
 
 2.x Planned Breaking Changes
 ============================
 
 As mentioned above, 2.0 will remove blind passthrough and the administrative command passthrough.
 By default in 1.5+, deprecation warnings are present and enabled;
-they can be silenced by initializing `Redis::Namespace` with `warnings: false` or by setting the `REDIS_NAMESPACE_QUIET` environment variable.
+they can be silenced by initializing `Redis::Namespace` with `warning: false` or by setting the `REDIS_NAMESPACE_QUIET` environment variable.
 
 Early opt-in
 ------------

data/lib/redis/namespace/version.rb

@@ -2,6 +2,6 @@
 
 class Redis
   class Namespace
-    VERSION = '1.6.0'
+    VERSION = '1.11.0'
   end
 end

data/lib/redis/namespace.rb

@@ -57,20 +57,26 @@ class Redis
       "append"           => [ :first ],
       "bitcount"         => [ :first ],
       "bitop"            => [ :exclude_first ],
+      "bitpos"           => [ :first ],
       "blpop"            => [ :exclude_last, :first ],
       "brpop"            => [ :exclude_last, :first ],
       "brpoplpush"       => [ :exclude_last ],
+      "bzpopmin"         => [ :first ],
+      "bzpopmax"         => [ :first ],
       "debug"            => [ :exclude_first ],
       "decr"             => [ :first ],
       "decrby"           => [ :first ],
       "del"              => [ :all   ],
       "dump"             => [ :first ],
-      "exists"           => [ :first ],
+      "exists"           => [ :all ],
+      "exists?"          => [ :all ],
       "expire"           => [ :first ],
       "expireat"         => [ :first ],
+      "expiretime"       => [ :first ],
       "eval"             => [ :eval_style ],
       "evalsha"          => [ :eval_style ],
       "get"              => [ :first ],
+      "getex"            => [ :first ],
       "getbit"           => [ :first ],
       "getrange"         => [ :first ],
       "getset"           => [ :first ],
@@ -117,6 +123,7 @@ class Redis
       "persist"          => [ :first ],
       "pexpire"          => [ :first ],
       "pexpireat"        => [ :first ],
+      "pexpiretime"      => [ :first ],
       "pfadd"            => [ :first ],
       "pfcount"          => [ :all ],
       "pfmerge"          => [ :all ],
@@ -133,6 +140,7 @@ class Redis
       "rpush"            => [ :first ],
       "rpushx"           => [ :first ],
       "sadd"             => [ :first ],
+      "sadd?"            => [ :first ],
       "scard"            => [ :first ],
       "scan"             => [ :scan_style, :second ],
       "scan_each"        => [ :scan_style, :all ],
@@ -147,11 +155,13 @@ class Redis
       "sinterstore"      => [ :all ],
       "sismember"        => [ :first ],
       "smembers"         => [ :first ],
+      "smismember"       => [ :first ],
       "smove"            => [ :exclude_last ],
       "sort"             => [ :sort  ],
       "spop"             => [ :first ],
       "srandmember"      => [ :first ],
       "srem"             => [ :first ],
+      "srem?"            => [ :first ],
       "sscan"            => [ :first ],
       "sscan_each"       => [ :first ],
       "strlen"           => [ :first ],
@@ -160,27 +170,31 @@ class Redis
       "sunionstore"      => [ :all ],
       "ttl"              => [ :first ],
       "type"             => [ :first ],
+      "unlink"           => [ :all   ],
       "unsubscribe"      => [ :all ],
       "zadd"             => [ :first ],
       "zcard"            => [ :first ],
       "zcount"           => [ :first ],
       "zincrby"          => [ :first ],
       "zinterstore"      => [ :exclude_options ],
+      "zpopmin"          => [ :first ],
+      "zpopmax"          => [ :first ],
       "zrange"           => [ :first ],
       "zrangebyscore"    => [ :first ],
+      "zrangebylex"      => [ :first ],
       "zrank"            => [ :first ],
       "zrem"             => [ :first ],
       "zremrangebyrank"  => [ :first ],
       "zremrangebyscore" => [ :first ],
+      "zremrangebylex"   => [ :first ],
       "zrevrange"        => [ :first ],
       "zrevrangebyscore" => [ :first ],
+      "zrevrangebylex"   => [ :first ],
       "zrevrank"         => [ :first ],
       "zscan"            => [ :first ],
       "zscan_each"       => [ :first ],
       "zscore"           => [ :first ],
-      "zunionstore"      => [ :exclude_options ],
-      "[]"               => [ :first ],
-      "[]="              => [ :first ]
+      "zunionstore"      => [ :exclude_options ]
     }
     TRANSACTION_COMMANDS = {
       "discard"          => [],
@@ -192,6 +206,7 @@ class Redis
     HELPER_COMMANDS = {
       "auth"             => [],
       "disconnect!"      => [],
+      "close"            => [],
       "echo"             => [],
       "ping"             => [],
       "time"             => [],
@@ -228,13 +243,23 @@ class Redis
     # Support 1.8.7 by providing a namespaced reference to Enumerable::Enumerator
     Enumerator = Enumerable::Enumerator unless defined?(::Enumerator)
 
+    # This is used by the Redis gem to determine whether or not to display that deprecation message.
+    @sadd_returns_boolean = true
+
+    # This is used by the Redis gem to determine whether or not to display that deprecation message.
+    @srem_returns_boolean = true
+
+    class << self
+      attr_accessor :sadd_returns_boolean, :srem_returns_boolean
+    end
+
     attr_writer :namespace
     attr_reader :redis
     attr_accessor :warning
 
     def initialize(namespace, options = {})
       @namespace = namespace
-      @redis = options[:redis] || Redis.current
+      @redis = options[:redis] || Redis.new
       @warning = !!options.fetch(:warning) do
                    !ENV['REDIS_NAMESPACE_QUIET']
                  end
@@ -253,8 +278,8 @@ class Redis
     end
 
     def client
-      warn("The client method is deprecated as of redis-rb 4.0.0, please use the new _client" +
-            "method instead. Support for the old method will be removed in redis-namespace 2.0.") if @has_new_client_method
+      warn("The client method is deprecated as of redis-rb 4.0.0, please use the new _client " +
+            "method instead. Support for the old method will be removed in redis-namespace 2.0.") if @has_new_client_method && deprecations?
       _client
     end
 
@@ -272,7 +297,9 @@ class Redis
 
     # emulate Ruby 1.9+ and keep respond_to_missing? logic together.
     def respond_to?(command, include_private=false)
-      super or respond_to_missing?(command, include_private)
+      return !deprecations? if DEPRECATED_COMMANDS.include?(command.to_s.downcase)
+
+      respond_to_missing?(command, include_private) or super
     end
 
     def keys(query = nil)
@@ -297,7 +324,15 @@ class Redis
                                    :redis => @redis)
       end
 
-      @namespace
+      @namespace.respond_to?(:call) ? @namespace.call : @namespace
+    end
+
+    def full_namespace
+      redis.is_a?(Namespace) ? "#{redis.full_namespace}:#{namespace}" : namespace.to_s
+    end
+
+    def connection
+      @redis.connection.tap { |info| info[:namespace] = namespace }
     end
 
     def exec
@@ -307,16 +342,40 @@ class Redis
     def eval(*args)
       call_with_namespace(:eval, *args)
     end
+    ruby2_keywords(:eval) if respond_to?(:ruby2_keywords, true)
+
+    # This operation can run for a very long time if the namespace contains lots of keys!
+    # It should be used in tests, or when the namespace is small enough
+    # and you are sure you know what you are doing.
+    def clear
+      if warning?
+        warn("This operation can run for a very long time if the namespace contains lots of keys! " +
+             "It should be used in tests, or when the namespace is small enough " +
+             "and you are sure you know what you are doing.")
+      end
 
-    def method_missing(command, *args, &block)
-      normalized_command = command.to_s.downcase
+      batch_size = 1000
+
+      if supports_scan?
+        cursor = "0"
+        begin
+          cursor, keys = scan(cursor, count: batch_size)
+          del(*keys) unless keys.empty?
+        end until cursor == "0"
+      else
+        all_keys = keys("*")
+        all_keys.each_slice(batch_size) do |keys|
+          del(*keys)
+        end
+      end
+    end
+
+    ADMINISTRATIVE_COMMANDS.keys.each do |command|
+      define_method(command) do |*args, &block|
+        raise NoMethodError if deprecations?
 
-      if ADMINISTRATIVE_COMMANDS.include?(normalized_command)
-        # administrative commands usage is deprecated and will be removed in 2.0
-        # redis-namespace cannot safely apply a namespace to their effects.
-        return super if deprecations?
         if warning?
-          warn("Passing '#{normalized_command}' command to redis as is; " +
+          warn("Passing '#{command}' command to redis as is; " +
                "administrative commands cannot be effectively namespaced " +
                "and should be called on the redis connection directly; " +
                "passthrough has been deprecated and will be removed in " +
@@ -324,8 +383,25 @@ class Redis
                )
         end
         call_with_namespace(command, *args, &block)
-      elsif COMMANDS.include?(normalized_command)
+      end
+      ruby2_keywords(command) if respond_to?(:ruby2_keywords, true)
+    end
+
+    COMMANDS.keys.each do |command|
+      next if ADMINISTRATIVE_COMMANDS.include?(command)
+      next if method_defined?(command)
+
+      define_method(command) do |*args, &block|
         call_with_namespace(command, *args, &block)
+      end
+      ruby2_keywords(command) if respond_to?(:ruby2_keywords, true)
+    end
+
+    def method_missing(command, *args, &block)
+      normalized_command = command.to_s.downcase
+
+      if COMMANDS.include?(normalized_command)
+        send(normalized_command, *args, &block)
       elsif @redis.respond_to?(normalized_command) && !deprecations?
         # blind passthrough is deprecated and will be removed in 2.0
         # redis-namespace does not know how to handle this command.
@@ -336,23 +412,23 @@ class Redis
                "passthrough has been deprecated and will be removed in " +
                "redis-namespace 2.0 (at #{call_site})")
         end
-        @redis.send(command, *args, &block)
+
+        wrapped_send(@redis, command, args, &block)
       else
         super
       end
     end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
     def inspect
       "<#{self.class.name} v#{VERSION} with client v#{Redis::VERSION} "\
-      "for #{@redis.id}/#{@namespace}>"
+      "for #{@redis.id}/#{full_namespace}>"
     end
 
     def respond_to_missing?(command, include_all=false)
       normalized_command = command.to_s.downcase
 
       case
-      when DEPRECATED_COMMANDS.include?(normalized_command)
-        !deprecations?
       when COMMANDS.include?(normalized_command)
         true
       when !deprecations? && redis.respond_to?(command, include_all)
@@ -378,6 +454,7 @@ class Redis
       case before
       when :first
         args[0] = add_namespace(args[0]) if args[0]
+        args[-1] = ruby2_keywords_hash(args[-1]) if args[-1].is_a?(Hash)
       when :all
         args = add_namespace(args)
       when :exclude_first
@@ -390,13 +467,14 @@ class Redis
         args.push(last) if last
       when :exclude_options
         if args.last.is_a?(Hash)
-          last = args.pop
+          last = ruby2_keywords_hash(args.pop)
           args = add_namespace(args)
           args.push(last)
         else
           args = add_namespace(args)
         end
       when :alternate
+        args = args.flatten
         args.each_with_index { |a, i| args[i] = add_namespace(a) if i.even? }
       when :sort
         args[0] = add_namespace(args[0]) if args[0]
@@ -410,6 +488,7 @@ class Redis
           args[1][:get].each_index do |i|
             args[1][:get][i] = add_namespace(args[1][:get][i]) unless args[1][:get][i] == "#"
           end
+          args[1] = ruby2_keywords_hash(args[1])
         end
       when :eval_style
         # redis.eval() and evalsha() can either take the form:
@@ -430,7 +509,7 @@ class Redis
       when :scan_style
         options = (args.last.kind_of?(Hash) ? args.pop : {})
         options[:match] = add_namespace(options.fetch(:match, '*'))
-        args << options
+        args << ruby2_keywords_hash(options)
 
         if block
           original_block = block
@@ -439,7 +518,7 @@ class Redis
       end
 
       # Dispatch the command to Redis and store the result.
-      result = @redis.send(command, *args, &block)
+      result = wrapped_send(@redis, command, args, &block)
 
       # Don't try to remove namespace from a Redis::Future, you can't.
       return result if result.is_a?(Redis::Future)
@@ -456,9 +535,36 @@ class Redis
 
       result
     end
+    ruby2_keywords(:call_with_namespace) if respond_to?(:ruby2_keywords, true)
+
+  protected
+
+    def redis=(redis)
+      @redis = redis
+    end
 
   private
 
+    if Hash.respond_to?(:ruby2_keywords_hash)
+      def ruby2_keywords_hash(kwargs)
+        Hash.ruby2_keywords_hash(kwargs)
+      end
+    else
+      def ruby2_keywords_hash(kwargs)
+        kwargs
+      end
+    end
+
+    def wrapped_send(redis_client, command, args = [], &block)
+      if redis_client.class.name == "ConnectionPool"
+        redis_client.with do |pool_connection|
+          pool_connection.send(command, *args, &block)
+        end
+      else
+        redis_client.send(command, *args, &block)
+      end
+    end
+
     # Avoid modifying the caller's (pass-by-reference) arguments.
     def clone_args(arg)
       if arg.is_a?(Array)
@@ -475,18 +581,16 @@ class Redis
     end
 
     def namespaced_block(command, &block)
-      redis.send(command) do |r|
-        begin
-          original, @redis = @redis, r
-          yield self
-        ensure
-          @redis = original
-        end
+      if block.arity == 0
+        wrapped_send(redis, command, &block)
+      else
+        outer_block = proc { |r| copy = dup; copy.redis = r; yield copy }
+        wrapped_send(redis, command, &outer_block)
       end
     end
 
     def add_namespace(key)
-      return key unless key && @namespace
+      return key unless key && namespace
 
       case key
       when Array
@@ -495,12 +599,12 @@ class Redis
         key.keys.each {|k| key[add_namespace(k)] = key.delete(k)}
         key
       else
-        "#{@namespace}:#{key}"
+        "#{namespace}:#{key}"
       end
     end
 
     def rem_namespace(key)
-      return key unless key && @namespace
+      return key unless key && namespace
 
       case key
       when Array
@@ -512,7 +616,7 @@ class Redis
           key.each { |k| yielder.yield rem_namespace(k) }
         end
       else
-        key.to_s.sub(/\A#{@namespace}:/, '')
+        key.to_s.sub(/\A#{namespace}:/, '')
       end
     end
 
@@ -527,5 +631,10 @@ class Redis
         Enumerator.new(&block)
       end
     end
+
+    def supports_scan?
+      redis_version = @redis.info["redis_version"]
+      Gem::Version.new(redis_version) >= Gem::Version.new("2.8.0")
+    end
   end
 end

data/spec/deprecation_spec.rb

@@ -31,7 +31,7 @@ describe Redis::Namespace do
     end
 
     before(:each) do
-      allow(redis).to receive(:unhandled) do |*args| 
+      allow(redis).to receive(:unhandled) do |*args|
         "unhandled(#{args.inspect})"
       end
       allow(redis).to receive(:flushdb).and_return("OK")
@@ -43,7 +43,7 @@ describe Redis::Namespace do
       its(:deprecations?) { should be true }
 
       context('with an unhandled command') do
-        it { should_not respond_to :unhandled }
+        it { is_expected.not_to respond_to :unhandled }
 
         it('raises a NoMethodError') do
           expect do
@@ -53,7 +53,7 @@ describe Redis::Namespace do
       end
 
       context('with an administrative command') do
-        it { should_not respond_to :flushdb }
+        it { is_expected.not_to respond_to :flushdb }
 
         it('raises a NoMethodError') do
           expect do
@@ -69,7 +69,7 @@ describe Redis::Namespace do
       its(:deprecations?) { should be false }
 
       context('with an an unhandled command') do
-        it { should respond_to :unhandled }
+        it { is_expected.to respond_to :unhandled }
 
         it 'blindly passes through' do
           expect(redis).to receive(:unhandled)
@@ -106,7 +106,7 @@ describe Redis::Namespace do
       end
 
       context('with an administrative command') do
-        it { should respond_to :flushdb }
+        it { is_expected.to respond_to :flushdb }
         it 'processes the command' do
           expect(redis).to receive(:flushdb)
           capture_stderr { namespaced.flushdb }