stockpile-redis 1.0 → 1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5265acd0adce155a74ad5e760a4220f2e67d21bd
-  data.tar.gz: a0255909976359af85261d59d10b9b7cf50fc256
+  metadata.gz: c921c5dea37bc0ab0c8f2b5ebb77bb3db14071a3
+  data.tar.gz: 75fa3e0437603717c027d83270d36f93eb814852
 SHA512:
-  metadata.gz: f4bcc22097af1e9ecda717d747a8462da5b7894ec795a27878a6f3bd44d6bd65eddba590b24f00064f20315f8f7be5bf6c44f5633f48824a620b431ab18a6880
-  data.tar.gz: 5878c2e4459ad15f96b65948d2b724c0bd7062dbe63d44db9b1329edb661558d7297f391c6540d328e3d130674ac860698fef53d46dc48f9534d87be90615c9b
+  metadata.gz: bc72992d8cf5eaf4d146d0f3ae643659ea6b1c14d97a24bdaae96fa17b6fc2d74234dab6d79b39b3549d7ad16abae044784a2eff8e67717ddd8ff5917105116a
+  data.tar.gz: 061fe3aabb239931475bd1ba656b5d48e0d187c1f40777861844c9afa7e98be17a1b040256204193dc718a0bdde69d1e2fe13ba9780e9ef962c8f2c4d83204ca

data/History.rdoc

@@ -1,3 +1,13 @@
+=== 1.1 / 2015-02-10
+
+* 2 minor enhancements
+
+  * Modified Stockpile::Redis to be implmented based on the new Stockpile::Base
+    class provided in stockpile 1.1.
+
+  * Implemented the +namespace+ option for client connections to add additional
+    namespace support to individual child connections.
+
 === 1.0 / 2015-01-21
 
 * 1 major enhancement

data/Manifest.txt

@@ -2,7 +2,6 @@
 .gemtest
 .minitest.rb
 .travis.yml
-.workenv
 Contributing.rdoc
 Gemfile
 History.rdoc

data/README.rdoc

@@ -13,11 +13,14 @@ stockpile-redis is a connection manager for Redis to be used with
 
 stockpile-redis supports both normal Redis connections (<tt>Redis.new</tt>),
 and Redis::Namespace connections (<tt>Redis::Namespace.new('namespace', redis:
-Redis.new</tt>).
+Redis.new)</tt>).
 
 stockpile-redis provides special-case handling for connections for Resque when
 the name of the client is +:resque+.
 
+Release 1.1 adds a minor enhancement to allow for namespaces for named clients
+using Stockpile::Redis#connection_for.
+
 == Synopsis
 
   require 'stockpile/redis'
@@ -39,6 +42,12 @@ the name of the client is +:resque+.
   narrow.connection_for(:resque) != narrow.connection # => true
   narrow.connection_for(:resque).redis == narrow.connection # => true
 
+  # Standard namespace handling.
+  narrow.connection_for(:other, namespace: 'other') !=
+    narrow.connection # => true
+  narrow.connection_for(:other, namespace: 'other').redis !=
+    narrow.connection # => true
+
   # Show a Stockpile with no adapter capabilities, but name the method
   # stockpile, not cache. This will still usefully manage connections.
   # The use of inject_redis! makes Stockpile::Redis the default connection
@@ -96,7 +105,7 @@ the name of the client is +:resque+.
 
 Put stockpile-redis in your Gemfile:
 
-  gem 'stockpile-redis', '~> 1.0'
+  gem 'stockpile-redis', '~> 1.1'
 
 Or manually install:
 

data/Rakefile

@@ -22,7 +22,7 @@ spec = Hoe.spec 'stockpile-redis' do
   self.need_tar = true
   self.require_ruby_version '>= 1.9.2'
 
-  self.extra_deps << ['stockpile', '~> 1.0']
+  self.extra_deps << ['stockpile', '~> 1.1']
   self.extra_deps << ['redis', '~> 3.0']
   self.extra_deps << ['redis-namespace', '~> 1.0']
   self.extra_dev_deps << ['fakeredis', '~> 0.5']

data/lib/stockpile/redis.rb

@@ -2,12 +2,12 @@
 
 require 'redis'
 require 'redis/namespace'
-require 'stockpile'
+require 'stockpile/base'
 
 class Stockpile
   # A connection manager for Redis.
-  class Redis
-    VERSION = '1.0' # :nodoc:
+  class Redis < Stockpile::Base
+    VERSION = '1.1' # :nodoc:
 
     # Create a new Redis connection manager with the provided options.
     #
@@ -24,13 +24,11 @@ class Stockpile
     #               <tt>options[:redis]</tt>, a namespace will be generated
     #               from one of the following: <tt>$REDIS_NAMESPACE</tt>,
     #               <tt>Rails.env</tt> (if in Rails), or <tt>$RACK_ENV</tt>.
-    # +narrow+::    Use a narrow connection width if true; if not provided,
-    #               uses the value of ::Stockpile.narrow? in this connection
-    #               manager.
     def initialize(options = {})
-      @redis_options = options.fetch(:redis, {})
-      @narrow        = !!options.fetch(:narrow, ::Stockpile.narrow?)
-      @namespace     = options.fetch(:namespace) {
+      super
+
+      @redis_options = (@options.delete(:redis) || {}).dup
+      @namespace     = @options.fetch(:namespace) {
         @redis_options.fetch(:namespace) {
           ENV['REDIS_NAMESPACE'] ||
           (defined?(::Rails) && ::Rails.env) ||
@@ -38,23 +36,11 @@ class Stockpile
         }
       }
 
-      if @redis_options.has_key?(:namespace)
-        @redis_options = @redis_options.reject { |k, _| k == :namespace }
-      end
-
-      @connection = nil
-      @clients    = {}
-    end
-
-    # The current primary connection to Redis.
-    attr_reader :connection
-
-    # Indicates if this connection manager is using a narrow connection
-    # width.
-    def narrow?
-      @narrow
+      @options.delete(:namespace)
+      @redis_options.delete(:namespace)
     end
 
+    ##
     # Connect to Redis, unless already connected. Additional client connections
     # can be specified in the parameters as a shorthand for calls to
     # #connection_for.
@@ -67,112 +53,136 @@ class Stockpile
     #
     #   # This means the same as above.
     #   manager.connect(:redis)
-    def connect(*client_names)
-      @connection ||= connect_for_any
-
-      clients_from(*client_names).each { |client_name|
-        connection_for(client_name)
-      }
-
-      connection
-    end
+    #
+    # === Clients
+    #
+    # +clients+ may be provided in one of several ways:
+    #
+    # * A Hash object, mapping client names to client options.
+    #
+    #     connect(redis: nil, rollout: { namespace: 'rollout' })
+    #     # Transforms into:
+    #     # connect(redis: {}, rollout: { namespace: 'rollout' })
+    #
+    # * An (implicit) array of client names, for connections with no options
+    #   provided.
+    #
+    #     connect(:redis, :resque, :rollout)
+    #     # Transforms into:
+    #     # connect(redis: {}, resque: {}, rollout: {})
+    #
+    # * An array of Hash objects, mapping client names to client options.
+    #
+    #     connect({ redis: nil },
+    #             { rollout: { namespace: 'rollout' } })
+    #     # Transforms into:
+    #     # connect(redis: {}, rollout: { namespace: 'rollout' })
+    #
+    # * A mix of client names and Hash objects:
+    #
+    #     connect(:redis, { rollout: { namespace: 'rollout' } })
+    #     # Transforms into:
+    #     # connect(redis: {}, rollout: { namespace: 'rollout' })
+    #
+    # ==== Client Options
+    #
+    # Stockpile::Redis supports one option, +namespace+. The use of this with a
+    # client automatically wraps the client in the provided +namespace+. The
+    # namespace will be within the global namespace for the Stockpile::Redis
+    # instance, if one has been set.
+    #
+    #   r = Stockpile::Redis.new(namespace: 'first')
+    #   rr = r.client_for(other: { namespace: 'second' })
+    #   rr.set 'found', true
+    #   r.set 'found', true
+    #   rr.keys # => [ 'found' ]
+    #   r.keys # => [ 'found', 'second:found' ]
+    #   r.connection.redis.keys # => [ 'first:found', 'first:second:found' ]
+    #
+    # :method: connect
 
-    # Perform a client connection to Redis for a specific +client_name+. The
-    # +client_name+ of +:all+ will always return +nil+.
+    ##
+    # Returns a Redis client connection for a particular client. If the
+    # connection manager is using a narrow connection width, this returns the
+    # same as #connection.
+    #
+    # The +client_name+ of +:all+ will always return +nil+.
     #
     # If the requested client does not yet exist, the connection will be
-    # created.
+    # created with the provided options.
     #
     # Because Resque depends on Redis::Namespace, #connection_for will perform
     # special Redis::Namespace handling for a connection with the name
     # +:resque+.
     #
-    # If #narrow? is true, the same Redis connection will be shared between all
-    # clients.
-    #
-    # If a connection has not yet been made, it will be made.
-    def connection_for(client_name)
-      connect unless connection
-      return nil if client_name == :all
-      @clients[client_name] ||= case client_name
-                                when :resque
-                                  connect_for_resque
-                                else
-                                  connect_for_any
-                                end
-    end
+    # :method: connection_for
 
+    ##
     # Reconnect to Redis for some or all clients. The primary connection will
     # always be reconnected; other clients will be reconnected based on the
     # +clients+ provided. Only clients actively managed by previous calls to
     # #connect or #connection_for will be reconnected.
     #
     # If #reconnect is called with the value +:all+, all currently managed
-    # clients will be reconnected.
+    # clients will be reconnected. If #narrow? is true, the primary connection
+    # will be reconnected.
     #
-    # If #narrow? is true, only the primary connection will be reconnected.
-    def reconnect(*client_names)
-      return unless connection
-
-      connection.client.reconnect
-
-      unless narrow?
-        clients_from(*client_names).each { |client_name|
-          redis = @clients[client_name]
-          redis.client.reconnect if redis
-        }
-      end
-
-      connection
-    end
+    # :method: reconnect
 
+    ##
     # Disconnect from Redis for some or all clients. The primary connection
     # will always be disconnected; other clients will be disconnected based on
     # the +clients+ provided. Only clients actively managed by previous calls
     # to #connect or #connection_for will be disconnected.
     #
     # If #disconnect is called with the value +:all+, all currently managed
-    # clients will be disconnected.
+    # clients will be disconnected. If #narrow? is true, the primary connection
+    # will be disconnected.
     #
-    # If #narrow? is true, only the primary connection will be disconnected.
-    def disconnect(*client_names)
-      return unless connection
-
-      unless narrow?
-        clients_from(*client_names).each { |client_name|
-          redis = @clients[client_name]
-          redis.quit if redis
-        }
-      end
-
-      connection.quit
-    end
+    # :method: disconnect
 
     private
-    def clients_from(*client_names)
-      if client_names.size == 1
-        if client_names.first == :all
-          @clients.keys
-        else
-          client_names
-        end
+    def client_connect(name = nil, options = {})
+      options = { namespace: options[:namespace] }
+
+      case name
+      when :resque
+        connect_for_resque(options)
       else
-        client_names
+        connect_for_any(options)
       end
     end
 
-    def connect_for_any
-      return connection if connection && narrow?
+    def client_reconnect(redis = connection())
+      redis.client.reconnect if redis
+    end
 
-      r = ::Redis.new(@redis_options)
-      if @namespace
-        r = ::Redis::Namespace.new(@namespace, redis: r)
+    def client_disconnect(redis = connection())
+      redis.quit if redis
+    end
+
+    def connect_for_any(options)
+      r = if connection && narrow?
+            connection
+          else
+            r = ::Redis.new(@redis_options.merge(options))
+
+            if @namespace
+              ::Redis::Namespace.new(@namespace, redis: r)
+            else
+              r
+            end
+          end
+
+      if options[:namespace]
+        r = ::Redis::Namespace.new(options[:namespace], redis: r)
       end
+
       r
     end
 
-    def connect_for_resque
-      r = connect_for_any
+    def connect_for_resque(options)
+      r = connect_for_any(options)
 
       if r.instance_of?(::Redis::Namespace) && r.namespace.to_s !~ /:resque\z/
         r = ::Redis::Namespace.new(:"#{r.namespace}:resque", redis: r.redis)

data/test/test_stockpile_redis.rb

@@ -105,13 +105,17 @@ describe Stockpile::Redis do
 
     describe "with a wide connection width" do
       before do
-        rcm_wide.connect(:redis, :rollout)
+        rcm_wide.connect(:redis, rollout: { namespace: 'rollout' })
       end
 
       it "connects multiple clients" do
         assert_clients [ :redis, :rollout ], rcm_wide
       end
 
+      it "creates a Redis::Namespace for rollout" do
+        assert_kind_of Redis::Namespace, rcm_wide.connection_for(:rollout)
+      end
+
       it "connects *different* clients" do
         refute_same rcm_wide.connection, rcm_wide.connection_for(:redis)
         refute_same rcm_wide.connection, rcm_wide.connection_for(:rollout)
@@ -121,17 +125,25 @@ describe Stockpile::Redis do
 
     describe "with a narrow connection width" do
       before do
-        rcm_narrow.connect(:redis, :rollout)
+        rcm_narrow.connect(:redis, rollout: { namespace: 'rollout' })
       end
 
       it "appears to connect multiple clients" do
         assert_clients [ :redis, :rollout ], rcm_narrow
       end
 
+      it "creates a Redis::Namespace for rollout" do
+        assert_kind_of Redis::Namespace, rcm_narrow.connection_for(:rollout)
+      end
+
       it "returns identical clients" do
         assert_same rcm_narrow.connection, rcm_narrow.connection_for(:redis)
-        assert_same rcm_narrow.connection, rcm_narrow.connection_for(:rollout)
-        assert_same rcm_narrow.connection_for(:redis), rcm_narrow.connection_for(:rollout)
+        refute_same rcm_narrow.connection, rcm_narrow.connection_for(:rollout)
+        assert_same rcm_narrow.connection,
+          rcm_narrow.connection_for(:rollout).redis
+        refute_same rcm_narrow.connection_for(:redis), rcm_narrow.connection_for(:rollout)
+        assert_same rcm_narrow.connection_for(:redis),
+          rcm_narrow.connection_for(:rollout).redis
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stockpile-redis
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: '1.1'
 platform: ruby
 authors:
 - Austin Ziegler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-21 00:00:00.000000000 Z
+date: 2015-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: stockpile
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -294,7 +294,6 @@ files:
 - ".gemtest"
 - ".minitest.rb"
 - ".travis.yml"
-- ".workenv"
 - Contributing.rdoc
 - Gemfile
 - History.rdoc
@@ -333,6 +332,4 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: stockpile-redis is a connection manager for Redis to be used with {Stockpile}[https://github.com/halostatue/stockpile].
-test_files:
-- test/test_stockpile_adapter_redis.rb
-- test/test_stockpile_redis.rb
+test_files: []

data/.workenv

@@ -1,5 +0,0 @@
-#! zsh
-
---workenv-tab --first
---workenv-tab --desc autotest autotest
---workenv-tab --desc documents "fswatch -o *.rdoc lib/**/*.rb| xargs -n1 -I{} rake docs"