redis-namespace 1.4.1 → 1.5.0

data/lib/redis/namespace.rb

@@ -61,7 +61,7 @@ class Redis
       "bitcount"         => [ :first ],
       "bitop"            => [ :exclude_first ],
       "blpop"            => [ :exclude_last, :first ],
-      "brpop"            => [ :exclude_last ],
+      "brpop"            => [ :exclude_last, :first ],
       "brpoplpush"       => [ :exclude_last ],
       "config"           => [],
       "dbsize"           => [],
@@ -123,12 +123,16 @@ class Redis
       "mget"             => [ :all ],
       "monitor"          => [ :monitor ],
       "move"             => [ :first ],
+      "multi"            => [],
       "mset"             => [ :alternate ],
       "msetnx"           => [ :alternate ],
       "object"           => [ :exclude_first ],
       "persist"          => [ :first ],
       "pexpire"          => [ :first ],
       "pexpireat"        => [ :first ],
+      "pfadd"            => [ :first ],
+      "pfcount"          => [ :all ],
+      "pfmerge"          => [ :all ],
       "ping"             => [],
       "psetex"           => [ :first ],
       "psubscribe"       => [ :all ],
@@ -149,6 +153,7 @@ class Redis
       "scard"            => [ :first ],
       "scan"             => [ :scan_style, :second ],
       "scan_each"        => [ :scan_style, :all ],
+      "script"           => [],
       "sdiff"            => [ :all ],
       "sdiffstore"       => [ :all ],
       "select"           => [],
@@ -203,13 +208,6 @@ class Redis
     # Support 1.8.7 by providing a namespaced reference to Enumerable::Enumerator
     Enumerator = Enumerable::Enumerator unless defined?(::Enumerator)
 
-    # support previous versions of redis gem
-    ALIASES = case
-              when defined? Redis::Client::ALIASES  then Redis::Client::ALIASES
-              when defined? Redis::ALIASES          then Redis::ALIASES
-              else {}
-              end
-
     attr_writer :namespace
     attr_reader :redis
     attr_accessor :warning
@@ -217,34 +215,42 @@ class Redis
     def initialize(namespace, options = {})
       @namespace = namespace
       @redis = options[:redis] || Redis.current
-      @warning = options[:warning] || false
+      @warning = options.fetch(:warning, true)
+      @deprecations = !!options.fetch(:deprecations) do
+                        ENV['REDIS_NAMESPACE_DEPRECATIONS']
+                      end
+    end
+
+    def deprecations?
+      @deprecations
+    end
+
+    def client
+      @redis.client
     end
 
     # Ruby defines a now deprecated type method so we need to override it here
     # since it will never hit method_missing
     def type(key)
-      method_missing(:type, key)
+      call_with_namespace(:type, key)
     end
 
     alias_method :self_respond_to?, :respond_to?
 
+    # emulate Ruby 1.9+ and keep respond_to_missing? logic together.
     def respond_to?(command, include_private=false)
-      if self_respond_to?(command, include_private)
-        true
-      else
-        @redis.respond_to?(command, include_private)
-      end
+      super or respond_to_missing?(command, include_private)
     end
 
     def keys(query = nil)
-      query.nil? ? super("*") : super
+      call_with_namespace(:keys, query || '*')
     end
 
     def multi(&block)
       if block_given?
         namespaced_block(:multi, &block)
       else
-        method_missing(:multi)
+        call_with_namespace(:multi)
       end
     end
 
@@ -262,24 +268,49 @@ class Redis
     end
 
     def exec
-      method_missing(:exec)
+      call_with_namespace(:exec)
     end
 
     def eval(*args)
-      method_missing(:eval, *args)
+      call_with_namespace(:eval, *args)
     end
 
     def method_missing(command, *args, &block)
-      command_for_lookup = command.to_s.downcase
-      handling = COMMANDS[command_for_lookup] ||
-        COMMANDS[ALIASES[command_for_lookup]]
+      normalized_command = command.to_s.downcase
+
+      if COMMANDS.include?(normalized_command)
+        call_with_namespace(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.
+        # Passing it to @redis as is, where redis-namespace shows
+        # a warning message if @warning is set.
+        if @warning
+          call_site = caller.reject { |l| l.start_with?(__FILE__) }.first
+          warn("Passing '#{command}' command to redis as is (at #{call_site})")
+        end
+        @redis.send(command, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(command, include_all=false)
+      return true if COMMANDS.include?(command.to_s.downcase)
+
+      # blind passthrough is deprecated and will be removed in 2.0
+      if @redis.respond_to?(command, include_all) && !deprecations?
+        return true
+      end
+
+      defined?(super) && super
+    end
+
+    def call_with_namespace(command, *args, &block)
+      handling = COMMANDS[command.to_s.downcase]
 
-      # redis-namespace does not know how to handle this command.
-      # Passing it to @redis as is, where redis-namespace shows
-      # a warning message if @warning is set.
       if handling.nil?
-        warn("Passing '#{command}' command to redis as is.") if @warning
-        return @redis.send(command, *args, &block)
+        fail("Redis::Namespace does not know how to handle '#{command}'.")
       end
 
       (before, after) = handling
@@ -413,7 +444,7 @@ class Redis
       # Enumerator in 1.8.7 *requires* a single argument, so we need to use
       # its Generator class, which matches the block syntax of 1.9.x's
       # Enumerator class.
-      if defined?(::Enumerable::Enumerator)
+      if RUBY_VERSION.start_with?('1.8')
         require 'generator' unless defined?(Generator)
         Generator.new(&block).to_enum
       else

data/lib/redis/namespace/version.rb

@@ -2,6 +2,6 @@
 
 class Redis
   class Namespace
-    VERSION = '1.4.1'
+    VERSION = '1.5.0'
   end
 end

data/spec/deprecation_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'stringio'
+
+describe Redis::Namespace do
+  # Blind passthrough of unhandled commands will be removed
+  # in 2.0; the following tests ensure that we support them
+  # until that point, & that we can programatically disable
+  # them in the meantime.
+  context 'deprecated 1.x behaviour' do
+    let(:redis) { double(Redis) }
+    let(:namespaced) do
+      Redis::Namespace.new(:ns, options.merge(:redis => redis))
+    end
+
+    let(:options) { Hash.new }
+
+    subject { namespaced }
+
+    its(:deprecations?) { should be false }
+
+    context('with REDIS_NAMESPACE_DEPRECATIONS') do
+      around(:each) {|e| with_env('REDIS_NAMESPACE_DEPRECATIONS'=>'1', &e) }
+      its(:deprecations?) { should be true }
+    end
+
+    before(:each) do
+      allow(redis).to receive(:unhandled) do |*args| 
+        "unhandled(#{args.inspect})"
+      end
+    end
+
+    # This behaviour will hold true after the 2.x migration
+    context('with deprecations enabled') do
+      let(:options) { {:deprecations => true} }
+      its(:deprecations?) { should be true }
+
+      context('with an unhandled command') do
+        it { should_not respond_to :unhandled }
+
+        it('raises a NoMethodError') do
+          expect do
+            namespaced.unhandled('foo')
+          end.to raise_exception NoMethodError
+        end
+      end
+    end
+
+    # This behaviour will no longer be available after the 2.x migration
+    context('with deprecations disabled') do
+      let(:options) { {:deprecations => false} }
+      its(:deprecations?) { should be false }
+
+      context('with an an unhandled command') do
+        it { should respond_to :unhandled }
+
+        it 'blindly passes through' do
+          expect(redis).to receive(:unhandled)
+
+          capture_stderr do
+            response = namespaced.unhandled('foo')
+            expect(response).to eq 'unhandled(["foo"])'
+          end
+        end
+
+        it 'warns with helpful output' do
+          capture_stderr(stderr = StringIO.new) do
+            namespaced.unhandled('bar')
+          end
+          warning = stderr.tap(&:rewind).read
+
+          expect(warning).to_not be_empty
+          expect(warning).to include %q(Passing 'unhandled' command to redis as is)
+          expect(warning).to include __FILE__
+        end
+      end
+    end
+  end
+end

data/spec/redis_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe "redis" do
@@ -223,6 +225,36 @@ describe "redis" do
     @namespaced.zrevrange('union', 0, -1).should eq(%w( 4 2 3 1 ))
   end
 
+  it "should properly intersect two sorted sets without options" do
+    @namespaced.zadd('food', 1, 'orange')
+    @namespaced.zadd('food', 2, 'banana')
+    @namespaced.zadd('food', 3, 'eggplant')
+
+    @namespaced.zadd('color', 2, 'orange')
+    @namespaced.zadd('color', 3, 'yellow')
+    @namespaced.zadd('color', 4, 'eggplant')
+
+    @namespaced.zinterstore('inter', ['food', 'color'])
+
+    inter_values = @namespaced.zrevrange('inter', 0, -1, :with_scores => true)
+    inter_values.should =~ [['orange', 3.0], ['eggplant', 7.0]]
+  end
+
+  it "should properly intersect two sorted sets with options" do
+    @namespaced.zadd('food', 1, 'orange')
+    @namespaced.zadd('food', 2, 'banana')
+    @namespaced.zadd('food', 3, 'eggplant')
+
+    @namespaced.zadd('color', 2, 'orange')
+    @namespaced.zadd('color', 3, 'yellow')
+    @namespaced.zadd('color', 4, 'eggplant')
+
+    @namespaced.zinterstore('inter', ['food', 'color'], :aggregate => "min")
+
+    inter_values = @namespaced.zrevrange('inter', 0, -1, :with_scores => true)
+    inter_values.should =~ [['orange', 1.0], ['eggplant', 3.0]]
+  end
+
   it "should add namespace to sort" do
     @namespaced.sadd('foo', 1)
     @namespaced.sadd('foo', 2)
@@ -342,26 +374,54 @@ describe "redis" do
     @namespaced.respond_to?(:warning=).should == true
   end
 
-  it "should warn against unknown commands if :warning is true" do
-    @namespaced.warning = true
-    capture_stderr {
-      @namespaced.unknown('foo')
-    }.should == "Passing 'unknown' command to redis as is."
+  it "should raise an exception when an unknown command is passed" do
+    expect { @namespaced.unknown('foo') }.to raise_exception NoMethodError
   end
 
   # Redis 2.6 RC reports its version as 2.5.
   if @redis_version >= Gem::Version.new("2.5.0")
     describe "redis 2.6 commands" do
       it "should namespace bitcount" do
-        pending "awaiting implementaton of command in redis gem"
+        @redis.set('ns:foo', 'foobar')
+        expect(@namespaced.bitcount('foo')).to eq 26
+        expect(@namespaced.bitcount('foo', 0, 0)).to eq 4
+        expect(@namespaced.bitcount('foo', 1, 1)).to eq 6
+        expect(@namespaced.bitcount('foo', 3, 5)).to eq 10
       end
 
       it "should namespace bitop" do
-        pending "awaiting implementaton of command in redis gem"
+        try_encoding('UTF-8') do
+          @redis.set("ns:foo", "a")
+          @redis.set("ns:bar", "b")
+
+          @namespaced.bitop(:and, "foo&bar", "foo", "bar")
+          @namespaced.bitop(:or, "foo|bar", "foo", "bar")
+          @namespaced.bitop(:xor, "foo^bar", "foo", "bar")
+          @namespaced.bitop(:not, "~foo", "foo")
+
+          expect(@redis.get("ns:foo&bar")).to eq "\x60"
+          expect(@redis.get("ns:foo|bar")).to eq "\x63"
+          expect(@redis.get("ns:foo^bar")).to eq "\x03"
+          expect(@redis.get("ns:~foo")).to eq "\x9E"
+        end
       end
 
-      it "should namespace dump" do
-        pending "awaiting implementaton of command in redis gem"
+      it "should namespace dump and restore" do
+        @redis.set("ns:foo", "a")
+        v = @namespaced.dump("foo")
+        @redis.del("ns:foo")
+
+        expect(@namespaced.restore("foo", 1000, v)).to be_true
+        expect(@redis.get("ns:foo")).to eq 'a'
+        expect(@redis.ttl("ns:foo")).to satisfy {|v| (0..1).include?(v) }
+
+        @redis.rpush("ns:bar", %w(b c d))
+        w = @namespaced.dump("bar")
+        @redis.del("ns:bar")
+
+        expect(@namespaced.restore("bar", 1000, w)).to be_true
+        expect(@redis.lrange('ns:bar', 0, -1)).to eq %w(b c d)
+        expect(@redis.ttl("ns:foo")).to satisfy {|v| (0..1).include?(v) }
       end
 
       it "should namespace hincrbyfloat" do
@@ -407,10 +467,6 @@ describe "redis" do
         @namespaced.pttl('mykey').should >= 0
       end
 
-      it "should namespace restore" do
-        pending "awaiting implementaton of command in redis gem"
-      end
-
       it "should namespace eval keys passed in as array args" do
         @namespaced.
           eval("return {KEYS[1], KEYS[2]}", %w[k1 k2], %w[arg1 arg2]).
@@ -713,26 +769,25 @@ describe "redis" do
     end
   end
 
-  # Only test aliasing functionality for Redis clients that support aliases.
-  unless Redis::Namespace::ALIASES.empty?
-    it "should support command aliases (delete)" do
-      @namespaced.delete('foo')
-      @redis.should_not have_key('ns:foo')
+  if @redis_version >= Gem::Version.new("2.8.9")
+    it 'should namespace pfadd' do
+      5.times { |n| @namespaced.pfadd("pf", n) }
+      @redis.pfcount("ns:pf").should == 5
     end
 
-    it "should support command aliases (set_add)" do
-      @namespaced.set_add('bar', 'quux')
-      @namespaced.smembers('bar').should include('quux')
+    it 'should namespace pfcount' do
+      5.times { |n| @redis.pfadd("ns:pf", n) }
+      @namespaced.pfcount("pf").should == 5
     end
 
-    it "should support command aliases (push_head)" do
-      @namespaced.push_head('bar', 'quux')
-      @redis.llen('ns:bar').should eq(1)
-    end
+    it 'should namespace pfmerge' do
+      5.times do |n|
+        @redis.pfadd("ns:pfa", n)
+        @redis.pfadd("ns:pfb", n+5)
+      end
 
-    it "should support command aliases (zset_add)" do
-      @namespaced.zset_add('bar', 1, 'quux')
-      @redis.zcard('ns:bar').should eq(1)
+      @namespaced.pfmerge("pfc", "pfa", "pfb")
+      @redis.pfcount("ns:pfc").should == 10
     end
   end
 end

data/spec/spec_helper.rb

@@ -11,18 +11,63 @@ $TESTING=true
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'redis/namespace'
 
-def capture_stderr
-  require 'stringio'
-  begin
-    original, $stderr = $stderr, StringIO.new
+module Helper
+  def capture_stderr(io = nil)
+    require 'stringio'
+    io ||= StringIO.new
+    begin
+      original, $stderr = $stderr, io
+      yield
+    rescue Redis::CommandError
+      # ignore Redis::CommandError for test and
+      # return captured messages
+      $stderr.string.chomp
+    ensure
+      $stderr = original
+    end
+  end
+
+  def with_env(env = {})
+    backup_env = ENV.to_hash.dup
+    ENV.update(env)
+
     yield
-  rescue Redis::CommandError 
-    # ignore Redis::CommandError for test and
-    # return captured messages
-    $stderr.string.chomp
   ensure
-    $stderr = original
+    ENV.replace(backup_env)
   end
+
+  def silent
+    verbose, $VERBOSE = $VERBOSE, false
+
+    begin
+      yield
+    ensure
+      $VERBOSE = verbose
+    end
+  end
+
+  def with_external_encoding(encoding)
+    original_encoding = Encoding.default_external
+
+    begin
+      silent { Encoding.default_external = Encoding.find(encoding) }
+      yield
+    ensure
+      silent { Encoding.default_external = original_encoding }
+    end
+  end
+
+  def try_encoding(encoding, &block)
+    if defined?(Encoding)
+      with_external_encoding(encoding, &block)
+    else
+      yield
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include Helper
 end
 
 RSpec::Matchers.define :have_key do |expected|

metadata

@@ -1,115 +1,122 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: redis-namespace
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 1
-  - 4
-  - 1
-  version: 1.4.1
+version: !ruby/object:Gem::Version
+  version: 1.5.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Chris Wanstrath
 - Terence Lee
 - Steve Klabnik
+- Ryan Biesemeyer
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-12-04 00:00:00 +00:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-06-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: redis
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 0
-        - 4
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 3.0.4
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
   type: :development
-  version_requirements: *id003
-description: |
-  Adds a Redis::Namespace class which can be used to namespace calls
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: ! 'Adds a Redis::Namespace class which can be used to namespace calls
+
   to Redis. This is useful when using a single instance of Redis with
+
   multiple, different applications.
 
-email: 
+'
+email:
 - chris@ozmm.org
 - hone02@gmail.com
 - steve@steveklabnik.com
+- me@yaauie.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - README.md
 - Rakefile
 - LICENSE
 - lib/redis/namespace/version.rb
 - lib/redis/namespace.rb
 - lib/redis-namespace.rb
+- spec/deprecation_spec.rb
 - spec/redis_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/resque/redis-namespace
-licenses: []
-
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Namespaces Redis commands.
 test_files: []
-
+has_rdoc: false