stockpile 1.0 → 1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d12f955c01ed9d46dd13ec2fc357cbb086094146
-  data.tar.gz: 5612ead9571a141b3b68695727655c1e03d680e0
+  metadata.gz: 9285056e00c41c3c09036585e9a8b2d5b517b27b
+  data.tar.gz: 84202f9f191b3ee26b30ed7deadef9203b6e5b8c
 SHA512:
-  metadata.gz: a3734ac43b06cfe7fe5d3fdbdc60cbd9f7560dfdce10fdee63d1d8128291de176baa307b368ef39fc02fe9aa307fde5a552262f50455fb02ab4058ebd8c2a2a9
-  data.tar.gz: 99989e77edc96cc5f193b1c327cf42c4c573b43250f236ffe018cbf4f23240cbc5c327065ae063eec4e99e9b090b8a3c188cea37c07dac8138a25f71a34aa221
+  metadata.gz: d0af27d554f66cd6e22006fdcfa75af45dd83305c5061a7fdf7b222e4836525124a9e6ec941dd9a8d95e743c576bb027f089d52be9b1532e78be2c1def10f47b
+  data.tar.gz: c60a70effa8e3e76b0b764807308db584543dfe61df6d519f4dd7344003db56298bd0c69b52c2ffbdb20aacedbe91ece8f5bf3d11a8980f2d26bc463d4bd01df

data/.travis.yml

@@ -1,6 +1,7 @@
 ---
 language: ruby
 rvm:
+  - 2.2.0
   - 2.1.0
   - 2.0.0
   - 1.9.3
@@ -29,6 +30,6 @@ after_script:
 notifications:
   email:
     recipients:
-      - FIX@example.com
+      - halostatue@gmail.com
     on_success: change
     on_failure: always

data/History.rdoc

@@ -1,3 +1,22 @@
+=== 1.1 / 2015-02-10
+
+* 3 minor enhancements
+
+  * Created a base adapter, Stockpile::Base, that implements the core public
+    interface of a connection manager in a consistent way for argument parsing.
+
+  * Created a memory adapter as an example adapter. (This had previously been
+    a test adapter created in the test environment.)
+
+  * Documented changes to how clients can be specified for Stockpile.new,
+    Stockpile#connect, and Stockpile#connection_for.
+
+* 1 bugfix
+
+  * Fix {issue #2}[https://github.com/halostatue/stockpile/issues/2], where
+    the use of the cache adapter causes the Stockpile cache manager to
+    initialize too early.
+
 === 1.0 / 2015-01-21
 
 * 1 major enhancement

data/Manifest.txt

@@ -10,5 +10,8 @@ Manifest.txt
 README.rdoc
 Rakefile
 lib/stockpile.rb
+lib/stockpile/base.rb
+lib/stockpile/memory.rb
 test/minitest_config.rb
 test/test_stockpile.rb
+test/test_stockpile_base.rb

data/README.rdoc

@@ -14,6 +14,12 @@ implemented connection managers. So far, only Redis has been implemented
 Stockpile also provides an adapter so that its functionality can be accessed
 from within a module.
 
+Release 1.1 fixes an issue with early initialization of an injected Stockpile
+instance during adaptation
+({stockpile#2}[https://githbub.com/halostatue/stockpile/issues/2]). Several
+small improvements to Stockpile.new, Stockpile#connect, and
+Stockpile#connection_for have been documented.
+
 == Features
 
 * Stockpile manages key-value store connections. There are two variants:
@@ -35,7 +41,7 @@ your Gemfile.
 
 == Synopsis
 
-  wide = Stockpile.new # A Stockpile to Redis.
+  wide = Stockpile.new # A Stockpile instance.
   wide.connection.set('hello', 'world') # => 'OK'
   wide.connection.get('hello') # => 'world'
 
@@ -51,6 +57,12 @@ your Gemfile.
   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.
   module Cacher
@@ -132,10 +144,10 @@ be used in Rails. A link to it will be provided here when it is complete.
 == Install
 
 Stockpile is not intended to be installed by itself, as it does not implement a
-key-value store specific connection manager. Instead, install an
-store-specific gem which depends on Stockpile.
+key-value store specific connection manager. Instead, install a store-specific
+gem which depends on Stockpile.
 
-  gem 'stockpile-redis', '~> 1.0'
+  gem 'stockpile-redis', '~> 1.1'
 
 Or manually install:
 

data/Rakefile

@@ -2,6 +2,7 @@
 
 require 'rubygems'
 require 'hoe'
+require 'rake/clean'
 
 Hoe.plugin :doofus
 Hoe.plugin :gemspec2
@@ -46,6 +47,7 @@ namespace :test do
     ].join('; ')
     Rake::Task['test'].execute
   end
+  CLOBBER << 'coverage'
 end
 
 # vim: syntax=ruby

data/lib/stockpile.rb

@@ -2,8 +2,8 @@
 
 require 'forwardable'
 
-# Stockpile is a thin wrapper around connections to a fast key-value store used
-# for caching (currently only supporting Redis).
+# Stockpile is a thin wrapper around connections to a fast key-value store
+# used for caching (currently only supporting Redis).
 #
 # This provides a couple of layers of functionality:
 #
@@ -14,7 +14,7 @@ require 'forwardable'
 class Stockpile
   extend Forwardable
 
-  VERSION = "1.0" # :nodoc:
+  VERSION = "1.1" # :nodoc:
 
   @default_manager = nil
 
@@ -79,20 +79,34 @@ class Stockpile
       end
 
       name    = options.fetch(:method, :cache).to_sym
-      msc     = mod.singleton_class
-
+      mklass  = mod.singleton_class
       default = options.fetch(:default_manager, nil)
 
-      msc.send(:define_method, name) do |init_options = {}|
+      mklass.send(:define_method, name) do |init_options = {}|
         init_options = init_options.merge(default_manager: default)
         @__stockpile__ ||= ::Stockpile.new(init_options)
+        @__stockpile_triggers__ ||= []
+
+        triggers, @__stockpile_triggers__ = @__stockpile_triggers__, []
+        triggers.each(&:call)
+
+        @__stockpile__
       end
 
       if options.fetch(:adaptable, true)
         adapter = :"#{name}_adapter"
-        msc.send(:define_method, adapter) do |m, k = nil|
+        mklass.send(:define_method, adapter) do |m, k = nil|
           o = self
-          send(name).singleton_class.send(:include, m)
+
+          @__stockpile_triggers__ ||= []
+
+          trigger = -> { send(name).singleton_class.send(:include, m) }
+
+          if defined?(@__stockpile__) && @__stockpile__
+            trigger.call
+          else
+            @__stockpile_triggers__ << trigger
+          end
 
           if k
             mk = k.singleton_class
@@ -104,7 +118,7 @@ class Stockpile
           end
         end
 
-        msc.send(:define_method, :"#{adapter}!") do |m|
+        mklass.send(:define_method, :"#{adapter}!") do |m|
           send(adapter, m, m)
         end
       end
@@ -131,37 +145,46 @@ class Stockpile
   #             through any means.
   # +clients+:: Connections will be created for the provided list of clients.
   #             These connections must be assigned to their appropriate clients
-  #             after initialization. This may also be called +client+.
+  #             after initialization. This may also be called +client+. These
+  #             values may be provided as names (e.g., +:cache+), or as hashes
+  #             of client name to client options (e.g., <tt>{ cache: {
+  #             namespace: 'x' } }</tt>). See Stockpile#connect for more
+  #             details on this latter format.
   #
   # All other options will be passed to the connection provider.
   #
   # === Synopsis
   #
-  #  # Create and assign a connection to Redis.current, Resque, and Rollout.
-  #  # Under a narrow connection management width, all three will be the
-  #  # same client connection.
-  #  Stockpile.new(manager: Stockpile::Redis, clients: [ :redis, :resque ]) do |stockpile|
+  #   # Create and assign a connection to Redis.current, Resque, and Rollout.
+  #   # Under a narrow connection management width, all three will be the
+  #   # same client connection.
+  #   options = {
+  #     manager: Stockpile::Redis,
+  #     clients: [ :redis, :resque ]
+  #   }
+  #   Stockpile.new(options) do |stockpile|
   #    Redis.current = stockpile.connection_for(:redis)
   #    Resque.redis = stockpile.connection_for(:resque)
   #    # Clients will be created by name if necessary.
   #    $rollout = Rollout.new(stockpile.connection_for(:rollout))
   #  end
   def initialize(options = {})
-    manager = options.fetch(:manager) {
-      options[:default_manager] || self.class.default_manager
-    }
+    options = options.dup
+    manager = options.delete(:manager)
+    default = options.delete(:default_manager) || self.class.default_manager
 
-    unless manager
+    unless manager || default
       raise ArgumentError, "No connection manager provided or set as default."
     end
 
-    clients = (Array(options[:clients]) + Array(options[:client])).flatten.uniq
+    manager ||= default
+
+    clients = [
+      Array(options.delete(:clients)), Array(options.delete(:client))
+    ].flatten.uniq
 
-    options = { narrow: Stockpile.narrow? }.merge(options.reject { |k, _|
-      k == :manager || k == :clients || k == :client
-    })
+    @manager = manager.new({ narrow: Stockpile.narrow? }.merge(options))
 
-    @manager = manager.new(options)
     connect(*clients)
     yield self if block_given?
   end
@@ -183,19 +206,57 @@ class Stockpile
   #
   # If the connection is using a narrow connection width, the same connection
   # will be shared.
+  #
+  # === 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 cache providers will handle the parsing of options to ensure that
+  # only suitable options are passed along (most providers will ignore any
+  # options that change the target system).
   def_delegator :@manager, :connect
 
   ##
   # :method: connection_for
   # :call-seq:
   #   connection_for(client_name)
+  #   connection_for(client_name, options)
   #
   # Returns a 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.
+  # If the requested client does not yet exist, the connection will be created
+  # with the provided options.
   def_delegator :@manager, :connection_for
 
   ##

data/lib/stockpile/base.rb

@@ -0,0 +1,186 @@
+# coding: utf-8
+
+require 'stockpile'
+
+class Stockpile
+  # The base connection manager, providing some common functionality for
+  # connection managers.
+  #
+  # It is not necessary to implement a connection manager from Stockpile::Base,
+  # but it is recommended because it provides all of the core functionality
+  # required of all connection managers, and requires only four integration
+  # points:
+  #
+  # * +initialize+: The constructor for the client connection manager. This
+  #   should call +super+ at the beginning of its own implementation, and use
+  #   <tt>@options</tt> if further parsing or manipulation of provided options
+  #   is required.
+  # * +client_connect+: The actions necessary to connect clients.
+  # * +client_reconnect+: The actions necessary to reconnect clients.
+  # * +client_disconnect+: The actions necessary to disconnect clients.
+  class Base
+    # Create a new connection manager with the provided options.
+    #
+    # == Options
+    #
+    # +narrow+::    Use a narrow connection width if true; if not provided,
+    #               uses the value of ::Stockpile.narrow? in this connection
+    #               manager.
+    def initialize(options = {})
+      @options    = options.dup
+      @narrow     = !!@options.fetch(:narrow, ::Stockpile.narrow?)
+      @connection = nil
+      @clients    = {}
+
+      @options.delete(:narrow)
+    end
+
+    # The primary connection.
+    attr_reader :connection
+
+    # Indicates if this connection manager is using a narrow connection width.
+    def narrow?
+      @narrow
+    end
+
+    # Connect 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 connection will be used for all clients
+    # managed by this connection manager.
+    #
+    #   manager.connect
+    #   manager.connection_for(:bar)
+    #
+    #   # This means the same as above.
+    #   manager.connect(:bar)
+    def connect(*client_names)
+      @connection ||= client_connect
+
+      clients_from(*client_names).each { |client_name, options|
+        connection_for(client_name, options || {})
+      }
+
+      connection
+    end
+
+    # Perform a client connection for a specific +client_name+. A +client_name+
+    # of +:all+ will always return +nil+. If the requested client does not yet
+    # exist, the connection will be created.
+    def connection_for(client_name, options = {})
+      connect unless connection
+      return nil if client_name == :all
+
+      @clients[client_name] ||= client_connect(client_name, options)
+    end
+
+    # Reconnect 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, the primary connection will be reconnected, which
+    # reconnects all connections implicitly.
+    def reconnect(*client_names)
+      return unless connection
+
+      client_reconnect
+
+      unless narrow?
+        clients_from(*client_names).each { |client_name, _|
+          client_reconnect(@clients[client_name])
+        }
+      end
+
+      connection
+    end
+
+    # Disconnect 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, the primary connection will be disconnected,
+    # which disconnects all connections implicitly.
+    def disconnect(*client_names)
+      return unless connection
+
+      unless narrow?
+        clients_from(*client_names).each { |client_name, _|
+          client_disconnect(@clients[client_name])
+        }
+      end
+
+      client_disconnect
+    end
+
+    private
+    # Converts +client_names+ into a hash of client names to options.
+    #
+    # * 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' })
+    def clients_from(*client_names)
+      clients = if client_names.size == 1
+                  if client_names.first == :all
+                    @clients.keys
+                  else
+                    client_names
+                  end
+                else
+                  client_names
+                end
+      clients.map { |v|
+        case v
+        when Hash
+          v
+        else
+          { v => {} }
+        end
+      }.inject({}, :merge)
+    end
+
+    # Performs a client connect action. Must be implemented by a client.
+    def client_connect(name = nil, options = {})
+      raise NotImplementedError
+    end
+
+    # Performs a client reconnect action. Must be implemented by a client.
+    def client_reconnect(client = connect())
+      raise NotImplementedError
+    end
+
+    # Performs a client disconnect action. Must be implemented by a client.
+    def client_disconnect(client = connect())
+      raise NotImplementedError
+    end
+  end
+end

data/lib/stockpile/memory.rb

@@ -0,0 +1,170 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'stockpile/base'
+
+class Stockpile
+  # An in-memory connection manager, providing a complete example of how a
+  # Stockpile connection manager could be made.
+  class Memory < Stockpile::Base
+    class Data # :nodoc:
+      class << self
+        attr_reader :data
+
+        def reset
+          @data = {}
+        end
+      end
+
+      reset
+
+      attr_reader :options
+
+      def initialize(options = {})
+        @connected = false
+        @options   = options
+        connect
+      end
+
+      def connect
+        @connected = true
+      end
+      alias_method :reconnect, :connect
+
+      def disconnect
+        @connected = false
+      end
+
+      def connected?
+        !!@connected
+      end
+
+      def get(key)
+        check_valid!
+        self.class.data[key]
+      end
+
+      def set(key, value)
+        check_valid!
+        self.class.data[key] = value
+      end
+
+      def hget(key, field)
+        raise unless connected?
+        valid_hkey!(key)[field]
+      end
+
+      def hset(key, field, value)
+        raise unless connected?
+        valid_hkey!(key)[field] = value
+      end
+
+      private
+      def check_valid!
+        raise unless connected?
+      end
+
+      def valid_hkey!(key)
+        check_valid!
+        case h = self.class.data[key]
+        when nil
+          h = (self.class.data[key] = {})
+        when Hash
+          nil
+        else
+          raise
+        end
+        h
+      end
+    end
+
+    ##
+    # :singleton-method: new
+    # :call-seq:
+    #   new(options = {})
+    #
+    # Create a new Memory connection manager.
+
+    ##
+    # :attr_reader: connection
+    #
+    # The primary connection.
+
+    ##
+    # :method: narrow?
+    #
+    # Indicates if this connection manager is using a narrow connection width.
+
+    ##
+    # :method: connect
+    # :call-seq:
+    #   connect(*client_names)
+    #
+    # Connect 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 connection will be used for all clients
+    # managed by this connection manager.
+    #
+    #   manager.connect
+    #   manager.connection_for(:bar)
+    #
+    #   # This means the same as above.
+    #   manager.connect(:bar)
+
+    ##
+    # :method: connection_for
+    # :call-seq:
+    #   connection_for(client_name, options = {})
+    #
+    # Perform a client connection for a specific +client_name+. A +client_name+
+    # of +:all+ will always return +nil+. If the requested client does not yet
+    # exist, the connection will be created.
+
+    ##
+    # :method: reconnect
+    # :call-seq:
+    #   reconnect(*client_names)
+    #
+    # Reconnect 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, the primary connection will be reconnected, which
+    # reconnects all connections implicitly.
+
+    ##
+    # :method: disconnect
+    # :call-seq:
+    #   disconnect(*client_names)
+    #
+    # Disconnect 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, the primary connection will be disconnected,
+    # which disconnects all connections implicitly.
+
+    ##
+    private
+    def client_connect(name = nil, options = {})
+      return connection if connection && narrow?
+      Data.new(@options.merge(options))
+    end
+
+    def client_reconnect(client = connection())
+      client.reconnect if client
+    end
+
+    def client_disconnect(client = connection())
+      client.disconnect if client
+    end
+  end
+end

data/test/minitest_config.rb

@@ -7,138 +7,12 @@ require 'minitest/focus'
 require 'minitest/moar'
 require 'minitest/bisect'
 
-require 'stockpile'
-
-class StockpileTestManager
-  class Connection
-    class << self
-      attr_reader :data
-
-      def reset_data
-        @data = Hash.new { |h, k| h[k] = {} }
-      end
-    end
-
-    reset_data
-
-    def initialize
-      @connected = false
-      connect
-    end
-
-    def connect
-      @connected = true
-    end
-    alias_method :reconnect, :connect
-
-    def disconnect
-      @connected = false
-    end
-
-    def connected?
-      !!@connected
-    end
-
-    def get(key)
-      raise unless connected?
-      self.class.data[key]
-    end
-
-    def set(key, value)
-      raise unless connected?
-      self.class.data[key] = value
-    end
-
-    def hget(key, field)
-      raise unless connected?
-      self.class.data[key][field]
-    end
-
-    def hset(key, field, value)
-      raise unless connected?
-      self.class.data[key][field] = value
-    end
-  end
-
-  def initialize(options = {})
-    @narrow     = !!options.fetch(:narrow, ::Stockpile.narrow?)
-    @connection = nil
-    @clients    = {}
-  end
-
-  attr_reader :connection
-
-  def narrow?
-    @narrow
-  end
-
-  def connect(*client_names)
-    @connection ||= connect_for_any
-
-    clients_from(*client_names).each { |client_name|
-      connection_for(client_name)
-    }
-
-    connection
-  end
-
-  def connection_for(client_name)
-    connect unless connection
-    return nil if client_name == :all
-    @clients[client_name] ||= connect_for_any
-  end
-
-  def reconnect(*client_names)
-    return unless connection
-
-    connection.reconnect
-
-    unless narrow?
-      clients_from(*client_names).each { |client_name|
-        client = @clients[client_name]
-        client.reconnect if client
-      }
-    end
-
-    connection
-  end
-
-  def disconnect(*client_names)
-    return unless connection
-
-    unless narrow?
-      clients_from(*client_names).each { |client_name|
-        client = @clients[client_name]
-        client.disconnect if client
-      }
-    end
-
-    connection.disconnect
-  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?
-    Connection.new
-  end
-end
+require 'stockpile/memory'
 
 module Minitest::ENVStub
   def setup
     super
-    StockpileTestManager::Connection.reset_data
+    Stockpile::Memory::Data.reset
   end
 
   def stub_env env, options = {}, *block_args, &block

data/test/test_stockpile.rb

@@ -1,5 +1,4 @@
 require 'minitest_config'
-require 'stockpile'
 require 'time'
 
 describe Stockpile do
@@ -18,6 +17,7 @@ describe Stockpile do
   end
 
   describe ".inject!" do
+    let(:cls) { Class.new }
     let(:mod) { Module.new }
     let(:lrt) {
       Module.new do
@@ -29,10 +29,24 @@ describe Stockpile do
             Time.parse(value) if value
           end
         end
+
+        def job_ran(job, value = nil)
+          if value
+            connection.set(job, !!value)
+          else
+            !!connection.get(job)
+          end
+        end
       end
     }
 
-    describe "Stockpile.inject!(Mod):" do
+    it "throws an ArgumentError unless it's a class or module" do
+      assert_raises ArgumentError do
+        ::Stockpile.inject!(Object.new)
+      end
+    end
+
+    describe "Stockpile.inject!(Module):" do
       before { ::Stockpile.inject!(mod) }
 
       it "defines Mod.cache" do
@@ -84,7 +98,9 @@ describe Stockpile do
     end
 
     describe "Stockpile.inject!(Mod, method: :stockpile, adaptable: false)" do
-      before { ::Stockpile.inject!(mod, method: :stockpile, adaptable: false) }
+      before do
+        ::Stockpile.inject!(mod, method: :stockpile, adaptable: false)
+      end
 
       it "defines Mod.stockpile" do
         assert_respond_to mod, :stockpile
@@ -100,8 +116,29 @@ describe Stockpile do
       let(:now) { Time.now }
       let(:iso) { now.utc.iso8601 }
       before do
-        ::Stockpile.inject!(mod, adaptable: true,
-                            default_manager: StockpileTestManager)
+        ::Stockpile.inject!(mod, default_manager: Stockpile::Memory)
+      end
+
+      it "queues adaptation until Stockpile has been initialized" do
+        stub Stockpile, :new do
+          mod.cache_adapter(lrt)
+          refute_called Stockpile, :new
+          refute_nil mod.instance_variable_get(:@__stockpile_triggers__)
+          refute_empty mod.instance_variable_get(:@__stockpile_triggers__)
+        end
+
+        assert_equal({ namespace: 'n' },
+                     mod.cache(namespace: 'n').connection.options)
+        assert_respond_to mod.cache, :last_run_time
+        assert_respond_to mod.cache, :job_ran
+      end
+
+      it "adapts an initialized Stockpile immediately" do
+        mod.cache
+        mod.cache_adapter(lrt)
+        assert_respond_to mod.cache, :last_run_time
+        assert_respond_to mod.cache, :job_ran
+        assert_empty mod.instance_variable_get(:@__stockpile_triggers__)
       end
 
       it "adapts the cache with last_run_time" do
@@ -124,10 +161,49 @@ describe Stockpile do
         assert_equal iso, lrt.last_run_time('foo', now)
         assert_equal now.to_i, lrt.last_run_time('foo').to_i
       end
+
+      it "adapts the cache with job_ran" do
+        mod.cache_adapter(lrt)
+        refute mod.cache.job_ran('foo')
+        assert mod.cache.job_ran('foo', true)
+        assert mod.cache.job_ran('foo')
+      end
+
+      it "adapts the module with last_run_time" do
+        mod.cache_adapter(lrt, mod)
+        refute mod.job_ran('foo')
+        assert mod.job_ran('foo', true)
+        assert mod.job_ran('foo')
+      end
+
+      it "adapts the lrt module with last_run_time" do
+        mod.cache_adapter!(lrt)
+        refute lrt.job_ran('foo')
+        assert lrt.job_ran('foo', true)
+        assert lrt.job_ran('foo')
+      end
     end
-  end
 
-  # Testing #connection, #connect, #connection_for, #reconnect, and #disconnect
-  # are testing Forwardable. Those tests are to be done in the individual
-  # connectors.
+    describe "Stockpile.inject!(Class):" do
+      before { ::Stockpile.inject!(cls) }
+
+      it "defines cls.cache" do
+        assert_respond_to cls, :cache
+      end
+
+      it "defines cls.cache_adapter" do
+        assert_respond_to cls, :cache_adapter
+      end
+
+      it "defines cls.cache_adapter!" do
+        assert_respond_to cls, :cache_adapter!
+      end
+
+      it "Fails cache initialization" do
+        assert_raises ArgumentError do
+          cls.cache
+        end
+      end
+    end
+  end
 end

data/test/test_stockpile_base.rb

@@ -0,0 +1,245 @@
+require 'minitest_config'
+
+describe Stockpile::Base 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(:mem) {
+    stub_env({}) { Stockpile::Memory.new }
+  }
+  let(:mem_namespace) {
+    stub_env({}) { Stockpile::Memory.new(namespace: 'Z') }
+  }
+  let(:mem_wide) {
+    stub_env({}) { Stockpile::Memory.new(narrow: false) }
+  }
+  let(:mem_narrow) {
+    stub_env({}) { Stockpile::Memory.new(narrow: true) }
+  }
+
+  describe 'constructor' do
+    it "uses the default connection width by default" do
+      stub ::Stockpile, :narrow?, lambda { false } do
+        refute Stockpile::Base.new.narrow?,
+          "should be narrow, but is not"
+      end
+
+      stub ::Stockpile, :narrow?, lambda { true } do
+        assert Stockpile::Base.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 mem_narrow.narrow?
+      end
+
+      stub ::Stockpile, :narrow?, lambda { true } do
+        refute mem_wide.narrow?
+      end
+    end
+
+    it "passes settings through to the client" do
+      options = {
+        url: 'test://xyz/'
+      }
+      mem = ::Stockpile::Memory.new(options)
+      assert_equal 'test://xyz/', mem.connect.options[:url]
+    end
+
+    it "has no clients by default" do
+      assert_clients [], ::Stockpile::Memory.new
+    end
+  end
+
+  describe "#connect" do
+    it "raises NotImplementedError unless #client_connect is implemented" do
+      assert_raises NotImplementedError do
+        ::Stockpile::Base.new.connect
+      end
+    end
+
+    it "creates a connection to the client" do
+      assert_nil mem.connection
+      refute_nil mem.connect
+    end
+
+    it "creates a namespaced connection to the client" do
+      assert_nil mem_namespace.connection
+      refute_nil mem_namespace.connect
+    end
+
+    describe "with a wide connection width" do
+      before do
+        mem_wide.connect(:hoge, { quux: {} })
+      end
+
+      it "connects multiple clients" do
+        assert_clients [ :hoge, :quux ], mem_wide
+      end
+
+      it "connects *different* clients" do
+        refute_same mem_wide.connection, mem_wide.connection_for(:hoge)
+        refute_same mem_wide.connection, mem_wide.connection_for(:quux)
+        refute_same mem_wide.connection_for(:hoge), mem_wide.connection_for(:quux)
+      end
+    end
+
+    describe "with a narrow connection width" do
+      before do
+        mem_narrow.connect(:hoge, :quux)
+      end
+
+      it "appears to connect multiple clients" do
+        assert_clients [ :hoge, :quux ], mem_narrow
+      end
+
+      it "returns identical clients" do
+        assert_same mem_narrow.connection, mem_narrow.connection_for(:hoge)
+        assert_same mem_narrow.connection, mem_narrow.connection_for(:quux)
+        assert_same mem_narrow.connection_for(:hoge), mem_narrow.connection_for(:quux)
+      end
+    end
+  end
+
+  describe "#connection_for" do
+    it "raises NotImplementedError unless #client_connect is implemented" do
+      assert_raises NotImplementedError do
+        instance_stub ::Stockpile::Base, :connection, -> { true } do
+          ::Stockpile::Base.new.connection_for(:foo)
+        end
+      end
+    end
+
+    describe "with a wide connection width" do
+      it "connects the main client" do
+        mem_wide.connection_for(:global)
+        assert mem_wide.connection
+        refute_same mem_wide.connection, mem_wide.connection_for(:global)
+      end
+    end
+
+    describe "with a narrow connection width" do
+      it "connects the main client" do
+        mem_narrow.connection_for(:global)
+        assert mem_narrow.connection
+        assert_same mem_narrow.connection, mem_narrow.connection_for(:global)
+      end
+    end
+  end
+
+  let(:connection) { Stockpile::Memory::Data }
+
+  describe "#disconnect" do
+    it "raises NotImplementedError unless #client_disconnect is implemented" do
+      base = ::Stockpile::Base.new
+      assert_raises NotImplementedError do
+        instance_stub ::Stockpile::Base, :connect do
+          instance_stub ::Stockpile::Base, :connection, -> { true } do
+            base.disconnect
+          end
+        end
+      end
+    end
+
+    describe "with a wide connection width" do
+      let(:global) { mem_wide.connection }
+      let(:hoge) { mem_wide.connection_for(:hoge) }
+
+      before do
+        mem_wide.connect(:hoge)
+        assert hoge.connected? && global.connected?
+      end
+
+      it "disconnects the global client" do
+        mem_wide.disconnect
+        assert hoge.connected? && !global.connected?
+      end
+
+      it "disconnects the redis and global clients" do
+        mem_wide.disconnect(:hoge)
+        refute hoge.connected? || global.connected?
+      end
+    end
+
+    describe "with a narrow connection width" do
+      let(:global) { mem_narrow.connection }
+      let(:hoge) { mem_narrow.connection_for(:hoge) }
+
+      before do
+        mem_narrow.connect(:hoge)
+        assert hoge.connected? && global.connected?
+      end
+
+      it "#disconnect disconnects all clients" do
+        mem_narrow.disconnect
+        refute hoge.connected? || global.connected?
+      end
+
+      it "#disconnect(:hoge) disconnects all clients" do
+        mem_narrow.disconnect(:hoge)
+        refute hoge.connected? || global.connected?
+      end
+    end
+  end
+
+  describe "#reconnect" do
+    it "raises NotImplementedError unless #client_reconnect is implemented" do
+      base = ::Stockpile::Base.new
+      assert_raises NotImplementedError do
+        instance_stub ::Stockpile::Base, :connect do
+          instance_stub ::Stockpile::Base, :connection, -> { true } do
+            base.reconnect
+          end
+        end
+      end
+    end
+
+    describe "with a wide connection width" do
+      let(:global) { mem_wide.connection }
+      let(:hoge) { mem_wide.connection_for(:hoge) }
+
+      before do
+        mem_wide.connect(:hoge)
+        assert hoge.connected? && global.connected?
+        mem_wide.disconnect(:all)
+        refute hoge.connected? || global.connected?
+      end
+
+      it "reconnects the global client" do
+        mem_wide.reconnect
+        assert !hoge.connected? && global.connected?
+      end
+
+      it "reconnects the redis and global clients" do
+        mem_wide.reconnect(:hoge)
+        assert hoge.connected? && global.connected?
+      end
+    end
+
+    describe "with a narrow connection width" do
+      let(:global) { mem_narrow.connection }
+      let(:hoge) { mem_narrow.connection_for(:hoge) }
+
+      def force_connection
+        mem_narrow.connect(:hoge)
+        assert hoge.connected? && global.connected?
+        mem_wide.disconnect(:all)
+        refute hoge.connected? || global.connected?
+      end
+
+      it "#reconnect reconnects the all clients" do
+        mem_narrow.reconnect
+        assert hoge.connected? && global.connected?
+      end
+
+      it "#reconnect(:hoge:) reconnects all clients" do
+        mem_narrow.reconnect(:hoge)
+        assert hoge.connected? && global.connected?
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stockpile
 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: minitest
@@ -228,6 +228,12 @@ description: |-
 
   Stockpile also provides an adapter so that its functionality can be accessed
   from within a module.
+
+  Release 1.1 fixes an issue with early initialization of an injected Stockpile
+  instance during adaptation
+  ({stockpile#2}[https://githbub.com/halostatue/stockpile/issues/2]). Several
+  small improvements to Stockpile.new, Stockpile#connect, and
+  Stockpile#connection_for have been documented.
 email:
 - halostatue@gmail.com
 executables: []
@@ -251,8 +257,11 @@ files:
 - README.rdoc
 - Rakefile
 - lib/stockpile.rb
+- lib/stockpile/base.rb
+- lib/stockpile/memory.rb
 - test/minitest_config.rb
 - test/test_stockpile.rb
+- test/test_stockpile_base.rb
 homepage: https://github.com/halostatue/stockpile/
 licenses:
 - MIT
@@ -279,5 +288,4 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Stockpile is a simple key-value store connection manager framework
-test_files:
-- test/test_stockpile.rb
+test_files: []