stockpile-redis 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5265acd0adce155a74ad5e760a4220f2e67d21bd
+  data.tar.gz: a0255909976359af85261d59d10b9b7cf50fc256
+SHA512:
+  metadata.gz: f4bcc22097af1e9ecda717d747a8462da5b7894ec795a27878a6f3bd44d6bd65eddba590b24f00064f20315f8f7be5bf6c44f5633f48824a620b431ab18a6880
+  data.tar.gz: 5878c2e4459ad15f96b65948d2b724c0bd7062dbe63d44db9b1329edb661558d7297f391c6540d328e3d130674ac860698fef53d46dc48f9534d87be90615c9b

data/.autotest

@@ -0,0 +1,27 @@
+# -*- ruby -*-
+
+require "autotest/restart"
+
+Autotest.add_hook :initialize do |at|
+  # .minitest.rb ensures that the gem version of minitest is used.
+  at.testlib = ".minitest.rb"
+  # at.testlib = "minitest/unit"
+  #
+  # at.extra_files << "../some/external/dependency.rb"
+  #
+  # at.libs << ":../some/external"
+  #
+  # at.add_exception "vendor"
+  #
+  # at.add_mapping(/dependency.rb/) do |f, _|
+  #   at.files_matching(/test_.*rb$/)
+  # end
+  #
+  # %w(TestA TestB).each do |klass|
+  #   at.extra_class_map[klass] = "test/test_misc.rb"
+  # end
+end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/.gemtest

@@ -0,0 +1 @@
+

data/.minitest.rb

@@ -0,0 +1,2 @@
+gem "minitest"
+require "minitest/autorun"

data/.travis.yml

@@ -0,0 +1,37 @@
+---
+language: ruby
+rvm:
+  - "2.2"
+  - "2.1"
+  - 2.0.0
+  - 1.9.3
+  - ruby-head
+  - jruby-19mode
+  - jruby-head
+  - rbx-2
+matrix:
+  allow_failures:
+    - rvm: rbx-2
+    - rvm: jruby-head
+    - rvm: ruby-head
+gemfile:
+  - Gemfile
+before_script:
+  - |
+    case "${TRAVIS_RUBY_VERSION}" in
+      rbx*)
+        gem install psych
+        ;;
+    esac
+  - rake travis:before -t
+script: rake travis
+after_script:
+  - rake travis:after -t
+notifications:
+  email:
+    recipients:
+      - halostatue@gmail.com
+    on_success: change
+    on_failure: always
+sudo:
+  false

data/.workenv

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

data/Contributing.rdoc

@@ -0,0 +1,64 @@
+== Contributing
+
+I value any contribution to stockpile-redis you can provide: a bug report, a
+feature request, or code contributions.
+
+As stockpile-redis is a complex codebase, there are a few guidelines:
+
+* Changes *will* *not* be accepted without tests. The test suite is written
+  with {Minitest}[https://github.com/seattlerb/minitest].
+* Match my coding style.
+* Use a thoughtfully-named topic branch that contains your change. Rebase your
+  commits into logical chunks as necessary.
+* Use {quality commit messages}[http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html].
+* Do not change the version number; when your patch is accepted and a release
+  is made, the version will be updated at that point.
+* Submit a GitHub pull request with your changes.
+* New behaviours require new or updated documentation.
+
+=== Test Dependencies
+
+stockpile-redis uses Ryan Davis’s {Hoe}[https://github.com/seattlerb/hoe]
+to manage the release process, and it adds a number of rake tasks. You will
+mostly be interested in:
+
+    $ rake
+
+which runs the tests the same way that:
+
+    $ rake test
+    $ rake travis
+
+will do.
+
+To assist with the installation of the development dependencies for
+stockpile-redis, I have provided the simplest possible Gemfile pointing to
+the (generated) +stockpile-redis.gemspec+ file. This will permit you to do:
+
+    $ bundle install
+
+to get the development dependencies. If you aleady have +hoe+ installed, you
+can accomplish the same thing with:
+
+    $ rake newb
+
+This task will install any missing dependencies, run the tests/specs, and
+generate the RDoc.
+
+=== Workflow
+
+Here's the most direct way to get your work merged into the project:
+
+* Fork the project.
+* Clone down your fork (<tt>git clone git://github.com/halostatue/stockpile-redis.git</tt>).
+* Create a topic branch to contain your change (<tt>git checkout -b my\_awesome\_feature</tt>).
+* Hack away, add tests. Not necessarily in that order.
+* Make sure everything still passes by running +rake+.
+* If necessary, rebase your commits into logical chunks, without errors.
+* Push the branch up (<tt>git push origin my\_awesome\_feature</tt>).
+* Create a pull request against halostatue/stockpile-redis and describe
+  what your change does and the why you think it should be merged.
+
+=== Contributors
+
+* Austin Ziegler created stockpile-redis.

data/Gemfile

@@ -0,0 +1,9 @@
+# -*- ruby -*-
+
+# NOTE: This file is present to keep Travis CI happy. Edits to it will not
+# be accepted.
+
+source "https://rubygems.org/"
+gemspec
+
+# vim: syntax=ruby

data/History.rdoc

@@ -0,0 +1,5 @@
+=== 1.0 / 2015-01-21
+
+* 1 major enhancement
+
+  * Birthday!

data/Licence.rdoc

@@ -0,0 +1,27 @@
+== Licence
+
+This software is available under an MIT-style licence.
+
+* Copyright 2015 Austin Ziegler
+
+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 names of its contributors may not be used to endorse or promote
+  products derived from this software without specific prior written
+  permission.
+
+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.

data/Manifest.txt

@@ -0,0 +1,17 @@
+.autotest
+.gemtest
+.minitest.rb
+.travis.yml
+.workenv
+Contributing.rdoc
+Gemfile
+History.rdoc
+Licence.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+lib/stockpile-redis.rb
+lib/stockpile/redis.rb
+test/minitest_config.rb
+test/test_stockpile_adapter_redis.rb
+test/test_stockpile_redis.rb

data/README.rdoc

@@ -0,0 +1,118 @@
+= stockpile-redis
+
+code :: https://github.com/halostatue/stockpile-redis/
+bugs :: https://github.com/halostatue/stockpile-redis/issues
+continuous integration :: {<img src="https://travis-ci.org/halostatue/stockpile-redis.png" />}[https://travis-ci.org/halostatue/stockpile-redis]
+
+== Description
+
+stockpile-redis is a connection manager for Redis to be used with
+{Stockpile}[https://github.com/halostatue/stockpile].
+
+== Features
+
+stockpile-redis supports both normal Redis connections (<tt>Redis.new</tt>),
+and Redis::Namespace connections (<tt>Redis::Namespace.new('namespace', redis:
+Redis.new</tt>).
+
+stockpile-redis provides special-case handling for connections for Resque when
+the name of the client is +:resque+.
+
+== Synopsis
+
+  require 'stockpile/redis'
+
+  wide = Stockpile.new(manager: Stockpile::Redis) # A Stockpile to Redis.
+  wide.connection.set('hello', 'world') # => 'OK'
+  wide.connection.get('hello') # => 'world'
+
+  # Connections are independent from one another.
+  wide.connection_for(:other) != wide.connection # => true
+
+  # A 'narrow' Stockpile to Redis.
+  narrow = Stockpile.new(manager: Stockpile::Redis, narrow: true)
+  # Or set ENV['STOCKPILE_CONNECTION_WIDTH'] = 'narrow' and call Stockpile.new
+  # normally.
+  narrow.connection_for(:other) == narrow.connection # => true
+
+  # Special Redis::Namespace handling for Resque clients.
+  narrow.connection_for(:resque) != narrow.connection # => true
+  narrow.connection_for(:resque).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
+  # manager for the Cacher module Stockpile.
+  module Cacher
+    Stockpile.inject_redis!(self, method: :stockpile, adaptable: false)
+  end
+  Cacher.respond_to?(:stockpile) # => true
+  Cacher.respond_to?(:stockpile_adapter) # => false
+  Cacher.stockpile.connection.set('hello', 'world') # => 'OK'
+  Cacher.stockpile.connection.get('hello') # => 'world'
+
+  # Now a Stockpile with adapter capabilities.
+  module Jobber
+    module LastRunTime
+      def last_run_time(key, value = nil)
+        if value
+          connection.hset(__method__, key, value.utc.iso8601)
+        else
+          value = connection.hget(__method__, key)
+          Time.parse(value) if value
+        end
+      end
+    end
+
+    Stockpile.inject_redis!(self)
+  end
+  Jobber.respond_to?(:cache) # => true
+  Jobber.respond_to?(:cache_adapter) # => true
+
+  # Four ways:
+  # 1. Adapt Jobber.cache to recognize #last_run_time.
+  Jobber.cache_adapter(Jobber::LastRunTime)
+  Jobber.cache.last_run_time('hello', t = Time.now) # => true
+  Jobber.cache.last_run_time('hello') # => approximately t
+
+  # 2. Adapt Jobber.cache and another module to recognize #last_run_time.
+  module Foo; end
+  Jobber.cache_adapter(Jobber::LastRunTime, Foo)
+  Foo.last_run_time('hello', t = Time.now) # => true
+  Foo.last_run_time('hello') # => approximately t
+
+  # 3. Adapt Jobber.cache and Jobber to recognize #last_run_time.
+  Jobber.cache_adapter(Jobber::LastRunTime, Jobber)
+  Jobber.last_run_time('hello', t = Time.now) # => true
+  Jobber.last_run_time('hello') # => approximately t
+
+  # 4. Adapt Jobber.cache and Jobber::LastRunTime to recognize #last_run_time.
+  Jobber.cache_adapter!(Jobber::LastRunTime)
+  # or Jobber.cache_adapter(Jobber::LastRunTime, Jobber::LastRunTime)
+  Jobber::LastRunTime.last_run_time('hello', t = Time.now) # => true
+  Jobber::LastRunTime.last_run_time('hello') # => approximately t
+
+== Install
+
+Put stockpile-redis in your Gemfile:
+
+  gem 'stockpile-redis', '~> 1.0'
+
+Or manually install:
+
+  % gem install stockpile-redis
+
+and require Stockpile in your code:
+
+  require 'stockpile/redis'
+
+== stockpile-redis Semantic Versioning
+
+stockpile-redis uses a {Semantic Versioning}[http://semver.org/] scheme with
+one change:
+
+* When PATCH is zero (+0+), it will be omitted from version references.
+
+:include: Contributing.rdoc
+
+:include: Licence.rdoc

data/Rakefile

@@ -0,0 +1,56 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :doofus
+Hoe.plugin :gemspec2
+Hoe.plugin :git
+Hoe.plugin :minitest
+Hoe.plugin :travis
+Hoe.plugin :email unless ENV['CI'] or ENV['TRAVIS']
+
+spec = Hoe.spec 'stockpile-redis' do
+  developer('Austin Ziegler', 'halostatue@gmail.com')
+
+  self.history_file = 'History.rdoc'
+  self.readme_file = 'README.rdoc'
+  self.extra_rdoc_files = FileList["*.rdoc"].to_a
+
+  license "MIT"
+
+  self.need_tar = true
+  self.require_ruby_version '>= 1.9.2'
+
+  self.extra_deps << ['stockpile', '~> 1.0']
+  self.extra_deps << ['redis', '~> 3.0']
+  self.extra_deps << ['redis-namespace', '~> 1.0']
+  self.extra_dev_deps << ['fakeredis', '~> 0.5']
+  self.extra_dev_deps << ['hoe-doofus', '~> 1.0']
+  self.extra_dev_deps << ['hoe-gemspec2', '~> 1.1']
+  self.extra_dev_deps << ['hoe-git', '~> 1.5']
+  self.extra_dev_deps << ['hoe-travis', '~> 1.2']
+  self.extra_dev_deps << ['minitest', '~> 5.4']
+  self.extra_dev_deps << ['minitest-around', '~> 0.3']
+  self.extra_dev_deps << ['minitest-autotest', '~> 1.0']
+  self.extra_dev_deps << ['minitest-bisect', '~> 1.2']
+  self.extra_dev_deps << ['minitest-focus', '~> 1.1']
+  self.extra_dev_deps << ['minitest-moar', '~> 0.0']
+  self.extra_dev_deps << ['minitest-pretty_diff', '~> 0.1']
+  self.extra_dev_deps << ['rake', '>= 10.0']
+  self.extra_dev_deps << ['redis-namespace', '~> 1.5']
+  self.extra_dev_deps << ['simplecov', '~> 0.7']
+end
+
+namespace :test do
+  task :coverage do
+    spec.test_prelude = [
+      'require "simplecov"',
+      'SimpleCov.start("test_frameworks") { command_name "Minitest" }',
+      'gem "minitest"'
+    ].join('; ')
+    Rake::Task['test'].execute
+  end
+end
+
+# vim: syntax=ruby

data/lib/stockpile-redis.rb

@@ -0,0 +1 @@
+require 'stockpile/redis'

data/lib/stockpile/redis.rb

@@ -0,0 +1,195 @@
+# coding: utf-8
+
+require 'redis'
+require 'redis/namespace'
+require 'stockpile'
+
+class Stockpile
+  # A connection manager for Redis.
+  class Redis
+    VERSION = '1.0' # :nodoc:
+
+    # Create a new Redis connection manager with the provided options.
+    #
+    # == Options
+    #
+    # +redis+::     Provides the Redis connection options.
+    # +namespace+:: Provides the Redis namespace to use, but only if
+    #               redis-namespace is in use (detected with the existence of
+    #               Redis::Namespace).
+    #
+    #               The namespace can also be provided as a key in the +redis+
+    #               options if it is missing from the main options. If there is
+    #               no namespace key present in either +options+ or
+    #               <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) {
+        @redis_options.fetch(:namespace) {
+          ENV['REDIS_NAMESPACE'] ||
+          (defined?(::Rails) && ::Rails.env) ||
+          ENV['RACK_ENV']
+        }
+      }
+
+      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
+    end
+
+    # Connect to Redis, unless already connected. Additional client connections
+    # can be specified in the parameters as a shorthand for calls to
+    # #connection_for.
+    #
+    # If #narrow? is true, the same Redis connection will be used for all
+    # clients managed by this connection manager.
+    #
+    #   manager.connect
+    #   manager.connection_for(:redis)
+    #
+    #   # 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
+
+    # Perform a client connection to Redis for a specific +client_name+. The
+    # +client_name+ of +:all+ will always return +nil+.
+    #
+    # If the requested client does not yet exist, the connection will be
+    # created.
+    #
+    # 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
+
+    # 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.
+    #
+    # 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
+
+    # 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.
+    #
+    # 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
+
+    private
+    def clients_from(*client_names)
+      if client_names.size == 1
+        if client_names.first == :all
+          @clients.keys
+        else
+          client_names
+        end
+      else
+        client_names
+      end
+    end
+
+    def connect_for_any
+      return connection if connection && narrow?
+
+      r = ::Redis.new(@redis_options)
+      if @namespace
+        r = ::Redis::Namespace.new(@namespace, redis: r)
+      end
+      r
+    end
+
+    def connect_for_resque
+      r = connect_for_any
+
+      if r.instance_of?(::Redis::Namespace) && r.namespace.to_s !~ /:resque\z/
+        r = ::Redis::Namespace.new(:"#{r.namespace}:resque", redis: r.redis)
+      elsif r.instance_of?(::Redis)
+        r = ::Redis::Namespace.new("resque", redis: r)
+      end
+
+      r
+    end
+  end
+
+  # Enables module or class +mod+ to contain a Stockpile instance that defaults
+  # the created +cache+ method to using Stockpile::Redis as the key-value store
+  # connection manager.
+  #
+  # See <tt>Stockpile.inject!</tt>.
+  def self.inject_redis!(mod, options = {})
+    inject!(mod, options.merge(default_manager: Stockpile::Redis))
+  end
+end

data/test/minitest_config.rb

@@ -0,0 +1,41 @@
+# -*- ruby encoding: utf-8 -*-
+
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/pretty_diff'
+require 'minitest/focus'
+require 'minitest/moar'
+require 'minitest/bisect'
+
+require 'fakeredis'
+
+module Minitest::FakeRedis
+  def setup
+    super
+    Redis::Connection::Memory.reset_all_databases
+  end
+
+  Minitest::Test.send(:include, self)
+end
+
+module Minitest::ENVStub
+  def stub_env env, options = {}, *block_args, &block
+    mock = lambda { |key|
+      env.fetch(key) { |k|
+        if options[:passthrough]
+          ENV.send(:"__minitest_stub__[]", k)
+        else
+          nil
+        end
+      }
+    }
+
+    if defined? Minitest::Moar::Stubbing
+      stub ENV, :[], mock, *block_args, &block
+    else
+      ENV.stub :[], mock, *block_args, &block
+    end
+  end
+
+  Minitest::Test.send(:include, self)
+end

data/test/test_stockpile_adapter_redis.rb

@@ -0,0 +1,47 @@
+require 'minitest_config'
+require 'stockpile/redis'
+require 'time'
+
+describe Stockpile do
+  describe ".inject!" do
+    let(:mod) { Module.new }
+    let(:lrt) {
+      Module.new do
+        def last_run_time(key, value = nil)
+          if value
+            connection.hset(__method__, key, value.utc.iso8601)
+          else
+            value = connection.hget(__method__, key)
+            Time.parse(value) if value
+          end
+        end
+      end
+    }
+
+    describe "Mod.cache_adapter" do
+      let(:now) { Time.now }
+      before { ::Stockpile.inject_redis!(mod, adaptable: true) }
+
+      it "adapts the cache with last_run_time" do
+        mod.cache_adapter(lrt)
+        assert_nil mod.cache.last_run_time('foo')
+        assert_equal true, mod.cache.last_run_time('foo', now)
+        assert_equal now.to_i, mod.cache.last_run_time('foo').to_i
+      end
+
+      it "adapts the module with last_run_time" do
+        mod.cache_adapter(lrt, mod)
+        assert_nil mod.last_run_time('foo')
+        assert_equal true, mod.last_run_time('foo', now)
+        assert_equal now.to_i, mod.last_run_time('foo').to_i
+      end
+
+      it "adapts the lrt module with last_run_time" do
+        mod.cache_adapter!(lrt)
+        assert_nil lrt.last_run_time('foo')
+        assert_equal true, lrt.last_run_time('foo', now)
+        assert_equal now.to_i, lrt.last_run_time('foo').to_i
+      end
+    end
+  end
+end

data/test/test_stockpile_redis.rb

@@ -0,0 +1,281 @@
+require 'minitest_config'
+require 'stockpile/redis'
+
+describe Stockpile::Redis do
+  def assert_clients expected_clients, connector
+    actual_clients = connector.instance_variable_get(:@clients).keys
+    assert_equal actual_clients.sort, expected_clients.sort
+  end
+
+  let(:rcm) { stub_env({}) { Stockpile::Redis.new } }
+  let(:rcm_namespace) { stub_env({}) { Stockpile::Redis.new(namespace: 'Z') } }
+  let(:rcm_wide) { stub_env({}) { Stockpile::Redis.new(narrow: false) } }
+  let(:rcm_narrow) { stub_env({}) { Stockpile::Redis.new(narrow: true) } }
+
+  describe 'constructor' do
+    it "uses the default connection width by default" do
+      stub ::Stockpile, :narrow?, lambda { false } do
+        refute Stockpile::Redis.new.narrow?,
+          "should be narrow, but is not"
+      end
+
+      stub ::Stockpile, :narrow?, lambda { true } do
+        assert Stockpile::Redis.new.narrow?,
+          "is not narrow, but should be"
+      end
+    end
+
+    it "can be told which connection width to use explicitly" do
+      stub ::Stockpile, :narrow?, lambda { false } do
+        assert rcm_narrow.narrow?
+      end
+
+      stub ::Stockpile, :narrow?, lambda { true } do
+        refute rcm_wide.narrow?
+      end
+    end
+
+    it "passes settings through to Redis" do
+      options = {
+        redis: {
+          url: 'redis://xyz/'
+        }
+      }
+      rcm = ::Stockpile::Redis.new(options)
+      assert_equal 'xyz', rcm.connect.client.options[:host]
+    end
+
+    it "has no clients by default" do
+      assert_clients [], ::Stockpile::Redis.new
+    end
+
+    describe "namespace support" do
+      def assert_namespace(client)
+        assert_equal 'stockpile', client.instance_variable_get(:@namespace)
+      end
+
+      it "will set namespace from ENV['REDIS_NAMESPACE']" do
+        stub_env({ 'REDIS_NAMESPACE' => 'stockpile' }) do
+          assert_namespace ::Stockpile::Redis.new
+        end
+      end
+
+      it "will set namespace from Rails.env" do
+        begin
+          ::Rails = Class.new do
+            def self.env
+              'stockpile'
+            end
+          end
+
+          stub_env({}) do
+            assert_namespace ::Stockpile::Redis.new
+          end
+        ensure
+          Object.send(:remove_const, :Rails)
+        end
+      end
+
+      it "will set namespace from ENV['RACK_ENV']" do
+        stub_env({ 'RACK_ENV' => 'stockpile' }) do
+          assert_namespace ::Stockpile::Redis.new
+        end
+      end
+
+      it "will set namespace from parameters" do
+        stub_env({ 'RACK_ENV' => 'test' }) do
+          assert_namespace ::Stockpile::Redis.new(namespace: 'stockpile')
+        end
+      end
+    end
+  end
+
+  describe "#connect" do
+    it "creates a connection to Redis" do
+      assert_nil rcm.connection
+      refute_nil rcm.connect
+      assert_kind_of ::Redis, rcm.connection
+    end
+
+    it "creates a namespaced connection to Redis" do
+      assert_nil rcm_namespace.connection
+      refute_nil rcm_namespace.connect
+      assert_kind_of ::Redis::Namespace, rcm_namespace.connection
+    end
+
+    describe "with a wide connection width" do
+      before do
+        rcm_wide.connect(:redis, :rollout)
+      end
+
+      it "connects multiple clients" do
+        assert_clients [ :redis, :rollout ], rcm_wide
+      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)
+        refute_same rcm_wide.connection_for(:redis), rcm_wide.connection_for(:rollout)
+      end
+    end
+
+    describe "with a narrow connection width" do
+      before do
+        rcm_narrow.connect(:redis, :rollout)
+      end
+
+      it "appears to connect multiple clients" do
+        assert_clients [ :redis, :rollout ], rcm_narrow
+      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)
+      end
+    end
+  end
+
+  describe "#connection_for" do
+    describe "with a wide connection width" do
+      it "connects the main client" do
+        rcm_wide.connection_for(:global)
+        assert rcm_wide.connection
+        refute_same rcm_wide.connection, rcm_wide.connection_for(:global)
+      end
+
+      it "wraps a :resque client in Redis::Namespace" do
+        assert_kind_of Redis::Namespace, rcm_wide.connection_for(:resque)
+        assert_equal "resque", rcm_wide.connection_for(:resque).namespace
+      end
+    end
+
+    describe "with a narrow connection width" do
+      it "connects the main client" do
+        rcm_narrow.connection_for(:global)
+        assert rcm_narrow.connection
+        assert_same rcm_narrow.connection, rcm_narrow.connection_for(:global)
+      end
+
+      it "wraps a :resque client in Redis::Namespace" do
+        assert_kind_of Redis::Namespace, rcm_narrow.connection_for(:resque)
+      end
+    end
+  end
+
+  # #disconnect cannot be tested with FakeRedis because the FakeRedis
+  # #connected? method always returns true.
+  describe "#disconnect" do
+    describe "with a wide connection width" do
+      let(:global) { rcm_wide.connection }
+      let(:redis) { rcm_wide.connection_for(:redis) }
+
+      def force_connection
+        rcm_wide.connect(:redis)
+        global.client.connect
+        redis.client.connect
+      end
+
+      it "disconnects the global client" do
+        instance_stub Redis, :quit do
+          force_connection
+          rcm_wide.disconnect
+        end
+        assert_instance_called Redis, :quit, 1
+      end
+
+      it "disconnects the redis and global clients" do
+        instance_stub Redis, :quit do
+          force_connection
+          rcm_wide.disconnect(:redis)
+        end
+        assert_instance_called Redis, :quit, 2
+      end
+    end
+
+    describe "with a narrow connection width" do
+      let(:global) { rcm_narrow.connection }
+      let(:redis) { rcm_narrow.connection_for(:redis) }
+
+      def force_connection
+        rcm_narrow.connect(:redis)
+        global.client.connect
+        redis.client.connect
+      end
+
+      it "disconnects the global client" do
+        instance_stub Redis, :quit do
+          force_connection
+          rcm_narrow.disconnect
+        end
+        assert_instance_called Redis, :quit, 1
+      end
+
+      it "disconnects the redis and global clients" do
+        instance_stub Redis, :quit do
+          force_connection
+          rcm_narrow.disconnect(:redis)
+        end
+        assert_instance_called Redis, :quit, 1
+      end
+    end
+  end
+
+  # #reconnect cannot be tested with FakeRedis because the FakeRedis
+  # #connected? method always returns true.
+  describe "#reconnect" do
+    describe "with a wide connection width" do
+      let(:global) { rcm_wide.connection }
+      let(:redis) { rcm_wide.connection_for(:redis) }
+
+      def force_connection
+        rcm_wide.connect(:redis)
+        global.client.connect
+        redis.client.connect
+      end
+
+      it "reconnects the global client" do
+        instance_stub Redis::Client, :reconnect do
+          force_connection
+          rcm_wide.reconnect
+        end
+        assert_instance_called Redis::Client, :reconnect, 1
+      end
+
+      it "reconnects the redis and global clients" do
+        instance_stub Redis::Client, :reconnect do
+          force_connection
+          rcm_wide.reconnect(:redis)
+        end
+        assert_instance_called Redis::Client, :reconnect, 2
+      end
+    end
+
+    describe "with a narrow connection width" do
+      let(:global) { rcm_narrow.connection }
+      let(:redis) { rcm_narrow.connection_for(:redis) }
+
+      def force_connection
+        rcm_narrow.connect(:redis)
+        global.client.connect
+        redis.client.connect
+      end
+
+      it "reconnects the global client" do
+        instance_stub Redis::Client, :reconnect do
+          force_connection
+          rcm_narrow.reconnect
+        end
+        assert_instance_called Redis::Client, :reconnect, 1
+      end
+
+      it "reconnects the redis and global clients" do
+        instance_stub Redis::Client, :reconnect do
+          force_connection
+          rcm_narrow.reconnect(:redis)
+        end
+        assert_instance_called Redis::Client, :reconnect, 1
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,338 @@
+--- !ruby/object:Gem::Specification
+name: stockpile-redis
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Austin Ziegler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: stockpile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: hoe-doofus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: hoe-gemspec2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: hoe-git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: hoe-travis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: minitest-around
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: minitest-autotest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-bisect
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: minitest-moar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-pretty_diff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: |-
+  stockpile-redis is a connection manager for Redis to be used with
+  {Stockpile}[https://github.com/halostatue/stockpile].
+email:
+- halostatue@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- Contributing.rdoc
+- History.rdoc
+- Licence.rdoc
+- Manifest.txt
+- README.rdoc
+files:
+- ".autotest"
+- ".gemtest"
+- ".minitest.rb"
+- ".travis.yml"
+- ".workenv"
+- Contributing.rdoc
+- Gemfile
+- History.rdoc
+- Licence.rdoc
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/stockpile-redis.rb
+- lib/stockpile/redis.rb
+- test/minitest_config.rb
+- test/test_stockpile_adapter_redis.rb
+- test/test_stockpile_redis.rb
+homepage: https://github.com/halostatue/stockpile-redis/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+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