adapter 0.5

data/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) 2011, Zynga Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+* Neither the name of Zynga Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,59 @@
+= Adapter
+
+A simple interface to anything.
+
+== Defining an Adapter
+
+An adapter requires 4 methods to work: read, write, delete and clear.
+
+    Adapter.define(:memory) do
+      def read(key)
+        decode(client[key_for(key)])
+      end
+
+      def write(key, value)
+        client[key_for(key)] = encode(value)
+      end
+
+      def delete(key)
+        client.delete(key_for(key))
+      end
+
+      def clear
+        client.clear
+      end
+    end
+
+Note: in order for things to be most flexible, always wrap key with key_for(key) which will ensure that pretty much anything can be a key. Also, by default encode and decode are included and they Marshal.dump and Marshal.load. Feel free to override these if you prefer JSON serialization or something else.
+
+Once you have defined an adapter, you can get a class of that adapter like this:
+
+    Adapter[:memory]
+
+This returns a dynamic class with your adapting methods included and an initialize method that takes a client. This means you can get an instance of the adapter by using new and passing the client (in this instance a boring hash):
+
+    adapter = Adapter[:memory].new({}) # sets {} to client
+    adapter.write('foo', 'bar')
+    adapter.read('foo') # 'bar'
+    adapter.delete('foo')
+    adapter.fetch('foo', 'bar') # returns bar and sets foo to bar
+
+get and [] are aliased to read. set and []= are aliased to write.
+
+Note: You can also optionally provide a lock method. See the memcached and redis adapters for more on locking.
+
+== Extending Adapters
+
+Adapters can be defined using a block, a module, or a module and a block. This allows very flexibly overriding specific things in an adapter to create a new adapter, without having to redo all of the work. See examples/overriding_serialization.rb for an example of this.
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so we don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine, but bump version in a commit by itself so we can ignore when we pull)
+* Send us a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 New Toy. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/lib/adapter.rb

@@ -0,0 +1,58 @@
+require 'adapter/asserts'
+require 'adapter/defaults'
+require 'adapter/exceptions'
+
+module Adapter
+  extend Asserts
+  include Defaults
+
+  def self.definitions
+    @definitions ||= {}
+  end
+
+  def self.define(name, mod=nil, &block)
+    definition_module = Module.new
+    definition_module.send(:include, Defaults)
+    definition_module.send(:include, mod) unless mod.nil?
+    definition_module.send(:include, Module.new(&block)) if block_given?
+    assert_valid_module(definition_module)
+    adapters.delete(name.to_sym)
+    definitions[name.to_sym] = definition_module
+  end
+
+  def self.adapters
+    @adapters ||= {}
+  end
+
+  def self.[](name)
+    assert_valid_adapter(name)
+    adapters[name.to_sym] ||= get_adapter_instance(name)
+  end
+
+  private
+    def self.get_adapter_instance(name)
+      Class.new do
+        attr_reader :client, :options
+
+        def initialize(client, options={})
+          @client = client
+          @options = options
+        end
+
+        include Adapter.definitions[name.to_sym]
+
+        alias get read
+        alias set write
+
+        alias []  read
+        alias []= write
+
+        def eql?(other)
+          self.class.eql?(other.class) && client == other.client
+        end
+        alias == eql?
+
+        class_eval "def name; :#{name} end"
+      end
+    end
+end

data/lib/adapter/asserts.rb

@@ -0,0 +1,21 @@
+module Adapter
+  module Asserts
+    RequiredMethods = [:read, :write, :delete, :clear]
+
+    def assert_valid_module(mod)
+      assert_methods_defined(mod)
+    end
+
+    def assert_valid_adapter(name)
+      raise Undefined.new(name) unless definitions.key?(name.to_sym)
+    end
+
+    def assert_methods_defined(mod)
+      missing_methods = []
+      RequiredMethods.each do |meth|
+        missing_methods << meth unless mod.method_defined?(meth)
+      end
+      raise IncompleteAPI.new(missing_methods) unless missing_methods.empty?
+    end
+  end
+end

data/lib/adapter/defaults.rb

@@ -0,0 +1,33 @@
+module Adapter
+  module Defaults
+    def fetch(key, value=nil, &block)
+      read(key) || begin
+        value = yield(key) if value.nil? && block_given?
+        write(key, value)
+        value
+      end
+    end
+
+    def key?(key)
+      !read(key).nil?
+    end
+
+    def key_for(key)
+      if key.is_a?(String)
+        key
+      elsif key.is_a?(Symbol)
+        key.to_s
+      else
+        Marshal.dump(key)
+      end
+    end
+
+    def encode(value)
+      Marshal.dump(value)
+    end
+
+    def decode(value)
+      value && Marshal.load(value)
+    end
+  end
+end

data/lib/adapter/exceptions.rb

@@ -0,0 +1,17 @@
+module Adapter
+  class Error < StandardError; end
+
+  class Undefined < Error; end
+
+  class IncompleteAPI < Error
+    def initialize(methods)
+      super("Missing methods needed to complete API (#{methods.join(', ')})")
+    end
+  end
+
+  class LockTimeout < Error
+    def initialize(key, timeout)
+      super("Timeout on lock #{key} exceeded #{timeout} sec")
+    end
+  end
+end

data/lib/adapter/memory.rb

@@ -0,0 +1,23 @@
+require 'adapter'
+
+module Adapter
+  module Memory
+    def read(key)
+      decode(client[key_for(key)])
+    end
+
+    def write(key, value)
+      client[key_for(key)] = encode(value)
+    end
+
+    def delete(key)
+      read(key).tap { client.delete(key_for(key)) }
+    end
+
+    def clear
+      client.clear
+    end
+  end
+end
+
+Adapter.define(:memory, Adapter::Memory)

data/lib/adapter/version.rb

@@ -0,0 +1,3 @@
+module Adapter
+  VERSION = '0.5'
+end

data/spec/adapter/defaults_spec.rb

@@ -0,0 +1,40 @@
+require 'helper'
+
+describe Adapter::Defaults do
+  let(:mod) do
+    Module.new.tap do |m|
+      m.extend(Adapter::Defaults)
+    end
+  end
+
+  describe "#key_for" do
+    it "returns value for string" do
+      mod.key_for('foo').should == 'foo'
+    end
+
+    it "returns string for symbol" do
+      mod.key_for(:foo).should == 'foo'
+    end
+
+    it "marshals anything not a string or symbol" do
+      mod.key_for({'testing' => 'this'}).should == %Q(\004\b{\006\"\ftesting\"\tthis)
+    end
+  end
+
+  describe "#encode" do
+    it "marshals value" do
+      mod.encode(nil).should == "\004\b0"
+      mod.encode({'testing' => 'this'}).should == %Q(\004\b{\006\"\ftesting\"\tthis)
+    end
+  end
+
+  describe "#decode" do
+    it "returns nil if nil" do
+      mod.decode(nil).should be_nil
+    end
+
+    it "returns marshal load if not nil" do
+      mod.decode(%Q(\004\b{\006\"\ftesting\"\tthis)).should == {'testing' => 'this'}
+    end
+  end
+end

data/spec/adapter/memory_spec.rb

@@ -0,0 +1,15 @@
+require 'helper'
+require 'adapter/memory'
+
+describe "Memory adapter" do
+  before do
+    @client = {}
+    @adapter = Adapter[:memory].new(@client)
+    @adapter.clear
+  end
+
+  let(:adapter) { @adapter }
+  let(:client)  { @client }
+
+  it_should_behave_like 'a marshaled adapter'
+end

data/spec/adapter_spec.rb

@@ -0,0 +1,302 @@
+require 'helper'
+
+describe Adapter do
+  describe ".definitions" do
+    it "defaults to empty hash" do
+      Adapter.instance_variable_set("@definitions", nil)
+      Adapter.definitions.should == {}
+    end
+  end
+
+  describe ".define" do
+    describe "with string name" do
+      it "symbolizes string adapter names" do
+        Adapter.define('memory', valid_module)
+        Adapter.definitions.keys.should include(:memory)
+      end
+    end
+
+    describe "with module" do
+      before do
+        @mod = valid_module
+        Adapter.define(:memory, mod)
+      end
+      let(:mod) { @mod }
+
+      it "adds adapter to definitions" do
+        Adapter.definitions.should have_key(:memory)
+        Adapter.definitions[:memory].should be_instance_of(Module)
+      end
+
+      it "includes the defaults" do
+        Class.new do
+          include Adapter.definitions[:memory]
+        end.tap do |klass|
+          klass.new.respond_to?(:fetch).should be_true
+          klass.new.respond_to?(:key_for, true).should be_true
+          klass.new.respond_to?(:encode, true).should be_true
+          klass.new.respond_to?(:decode, true).should be_true
+        end
+      end
+
+      [:read, :write, :delete, :clear].each do |method_name|
+        it "raises error if #{method_name} is not defined in module" do
+          mod.send(:undef_method, method_name)
+
+          lambda do
+            Adapter.define(:memory, mod)
+          end.should raise_error(Adapter::IncompleteAPI, "Missing methods needed to complete API (#{method_name})")
+        end
+      end
+    end
+
+    describe "with block" do
+      before do
+        Adapter.define(:memory) do
+          def read(key)
+            client[key]
+          end
+
+          def write(key, value)
+            client[key] = value
+          end
+
+          def delete(key)
+            client.delete(key)
+          end
+
+          def clear
+            client.clear
+          end
+        end
+      end
+
+      it "adds adapter to definitions" do
+        Adapter.definitions.should have_key(:memory)
+      end
+
+      it "modularizes the block" do
+        Adapter.definitions[:memory].should be_instance_of(Module)
+      end
+    end
+
+    describe "with module and block" do
+      before do
+        Adapter.define(:memory, valid_module) do
+          def clear
+            raise 'Not Implemented'
+          end
+        end
+      end
+
+      it "includes block after module" do
+        adapter = Adapter[:memory].new({})
+        adapter.write('foo', 'bar')
+        adapter.read('foo').should == 'bar'
+        lambda do
+          adapter.clear
+        end.should raise_error('Not Implemented')
+      end
+    end
+  end
+
+  describe "Overriding encode/decode" do
+    before do
+      Adapter.define(:memory_json, valid_module) do
+        def encode(value)
+          ActiveSupport::JSON.encode(value)
+        end
+
+        def decode(value)
+          ActiveSupport::JSON.decode(value)
+        end
+      end
+    end
+    let(:adapter) { Adapter[:memory_json].new({}) }
+
+    it "encodes correctly" do
+      hash = {'foo' => 'bar'}
+      adapter.write('foo', hash)
+      adapter.client['foo'].should == ActiveSupport::JSON.encode(hash)
+    end
+
+    it "decodes correctly" do
+      hash = {'foo' => 'bar'}
+      adapter.client['foo'] = ActiveSupport::JSON.encode(hash)
+      adapter.read('foo').should == hash
+    end
+  end
+
+  describe "Redefining an adapter" do
+    before do
+      Adapter.define(:memory, valid_module)
+      Adapter.define(:hash, valid_module)
+      @memoized_memory = Adapter[:memory]
+      @memoized_hash = Adapter[:hash]
+      Adapter.define(:memory, valid_module)
+    end
+
+    it "unmemoizes adapter by name" do
+      Adapter[:memory].should_not equal(@memoized_memory)
+    end
+
+    it "does not unmemoize other adapters" do
+      Adapter[:hash].should equal(@memoized_hash)
+    end
+  end
+
+  describe ".[]" do
+    before do
+      Adapter.define(:memory, valid_module)
+    end
+
+    it "returns adapter instance" do
+      adapter = Adapter[:memory].new({})
+      adapter.write('foo', 'bar')
+      adapter.read('foo').should == 'bar'
+      adapter.delete('foo')
+      adapter.read('foo').should be_nil
+      adapter.write('foo', 'bar')
+      adapter.clear
+      adapter.read('foo').should be_nil
+    end
+
+    it "raises error for undefined adapter" do
+      lambda do
+        Adapter[:non_existant]
+      end.should raise_error(Adapter::Undefined)
+    end
+
+    it "memoizes adapter by name" do
+      Adapter[:memory].should equal(Adapter[:memory])
+    end
+  end
+
+  describe "Adapter" do
+    before do
+      Adapter.define(:memory, valid_module)
+      @client = {}
+      @adapter = Adapter[:memory].new(@client)
+    end
+    let(:adapter) { @adapter }
+
+    describe "#initialize" do
+      it "works with options" do
+        Adapter.define(:memory, valid_module)
+        adapter = Adapter[:memory].new({}, :namespace => 'foo')
+        adapter.options[:namespace].should == 'foo'
+      end
+    end
+
+    describe "#name" do
+      it "returns adapter name" do
+        adapter.name.should be(:memory)
+      end
+    end
+
+    describe "#fetch" do
+      it "returns value if found" do
+        adapter.write('foo', 'bar')
+        adapter.fetch('foo', 'baz').should == 'bar'
+      end
+
+      it "returns value if not found" do
+        adapter.fetch('foo', 'baz').should == 'baz'
+      end
+
+      describe "with block" do
+        it "returns value if key found" do
+          adapter.write('foo', 'bar')
+          adapter.should_not_receive(:write)
+          adapter.fetch('foo') do
+            'baz'
+          end.should == 'bar'
+        end
+
+        it "returns result of block if key not found and writes result to key" do
+          adapter.fetch('foo') do
+            'baz'
+          end.should == 'baz'
+          adapter.fetch('foo').should == 'baz'
+        end
+
+        it "yields key to block" do
+          adapter.fetch('foo') do |key|
+            key
+          end.should == 'foo'
+        end
+      end
+    end
+
+    describe "#key?" do
+      it "returns true if key is set" do
+        adapter.write('foo', 'bar')
+        adapter.key?('foo').should be_true
+      end
+
+      it "returns false if key is not set" do
+        adapter.key?('foo').should be_false
+      end
+    end
+
+    describe "#[]" do
+      it "is aliased to read" do
+        adapter.write('foo', 'bar')
+        adapter['foo'].should == 'bar'
+      end
+    end
+
+    describe "#get" do
+      it "is aliased to read" do
+        adapter.write('foo', 'bar')
+        adapter.get('foo').should == 'bar'
+      end
+    end
+
+    describe "#[]=" do
+      it "is aliased to write" do
+        adapter.read('foo').should be_nil
+        adapter['foo'] = 'bar'
+        adapter.read('foo').should == 'bar'
+      end
+    end
+
+    describe "#[]=" do
+      it "is aliased to write" do
+        adapter.read('foo').should be_nil
+        adapter.set('foo', 'bar')
+        adapter.read('foo').should == 'bar'
+      end
+    end
+
+    describe "#eql?" do
+      it "returns true if same name and client" do
+        adapter.should eql(Adapter[:memory].new({}))
+      end
+
+      it "returns false if different name" do
+        Adapter.define(:hash, valid_module)
+        adapter.should_not eql(Adapter[:hash].new({}))
+      end
+
+      it "returns false if different client" do
+        adapter.should_not eql(Adapter[:memory].new(Object.new))
+      end
+    end
+
+    describe "#==" do
+      it "returns true if same name and client" do
+        adapter.should == Adapter[:memory].new({})
+      end
+
+      it "returns false if different name" do
+        Adapter.define(:hash, valid_module)
+        adapter.should_not == Adapter[:hash].new({})
+      end
+
+      it "returns false if different client" do
+        adapter.should_not == Adapter[:memory].new(Object.new)
+      end
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,28 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'rubygems'
+require 'bundler'
+
+Bundler.require(:default, :development)
+
+require 'pathname'
+require 'logger'
+
+root_path = Pathname(__FILE__).dirname.join('..').expand_path
+lib_path  = root_path.join('lib')
+log_path  = root_path.join('log')
+log_path.mkpath
+
+require 'support/an_adapter'
+require 'support/marshal_adapter'
+require 'support/json_adapter'
+require 'support/module_helpers'
+
+logger = Logger.new(log_path.join('test.log'))
+LogBuddy.init(:logger => logger)
+
+Rspec.configure do |c|
+  c.include(ModuleHelpers)
+end
+
+AdapterTestTypes = {"String" => ["key", "key2"]}

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--timeout
+20

data/spec/support/an_adapter.rb

@@ -0,0 +1,162 @@
+shared_examples_for "an adapter" do
+  it "can read the client" do
+    adapter.client.should == client
+  end
+
+  AdapterTestTypes.each do |type, (key, key2)|
+    it "reads from keys that are #{type}s like a Hash" do
+      handle_failed_connections do
+        adapter[key].should == nil
+      end
+    end
+
+    it "writes String values to keys that are #{type}s like a Hash" do
+      handle_failed_connections do
+        adapter[key] = "value"
+        adapter[key].should == "value"
+      end
+    end
+
+    it "guarantees that a different String value is retrieved from the #{type} key" do
+      handle_failed_connections do
+        value = "value"
+        adapter[key] = value
+        adapter[key].should_not be_equal(value)
+      end
+    end
+
+    it "guarantees that a different Object value is retrieved from the #{type} key" do
+      handle_failed_connections do
+        value = {:foo => :bar}
+        adapter[key] = value
+        adapter[key].should_not be_equal(:foo => :bar)
+      end
+    end
+
+    it "returns false from key? if a #{type} key is not available" do
+      handle_failed_connections do
+        adapter.key?(key).should be_false
+      end
+    end
+
+    it "returns true from key? if a #{type} key is available" do
+      handle_failed_connections do
+        adapter[key] = "value"
+        adapter.key?(key).should be_true
+      end
+    end
+
+    it "removes and return an element with a #{type} key from the backing store via delete if it exists" do
+      handle_failed_connections do
+        adapter[key] = "value"
+        adapter.delete(key).should == "value"
+        adapter.key?(key).should be_false
+      end
+    end
+
+    it "returns nil from delete if an element for a #{type} key does not exist" do
+      handle_failed_connections do
+        adapter.delete(key).should be_nil
+      end
+    end
+
+    it "removes all #{type} keys from the store with clear" do
+      handle_failed_connections do
+        adapter[key] = "value"
+        adapter[key2] = "value2"
+        adapter.clear
+        adapter.key?(key).should_not be_true
+        adapter.key?(key2).should_not be_true
+      end
+    end
+
+    it "fetches a #{type} key with a default value with fetch, if the key is not available" do
+      handle_failed_connections do
+        adapter.fetch(key, "value").should == "value"
+      end
+    end
+
+    it "fetches a #{type} key with a block with fetch, if the key is not available" do
+      handle_failed_connections do
+        adapter.fetch(key) { |k| "value" }.should == "value"
+      end
+    end
+
+    it "does not run the block if the #{type} key is available" do
+      handle_failed_connections do
+        adapter[key] = "value"
+        unaltered = "unaltered"
+        adapter.fetch(key) { unaltered = "altered" }
+        unaltered.should == "unaltered"
+      end
+    end
+
+    it "fetches a #{type} key with a default value with fetch, if the key is available" do
+      handle_failed_connections do
+        adapter[key] = "value2"
+        adapter.fetch(key, "value").should == "value2"
+      end
+    end
+
+    it "writes #{key} values with #write" do
+      handle_failed_connections do
+        adapter.write(key, "value")
+        adapter[key].should == "value"
+      end
+    end
+  end
+
+  it "refuses to #[] from keys that cannot be marshalled" do
+    handle_failed_connections do
+      lambda do
+        adapter[Struct.new(:foo).new(:bar)]
+      end.should raise_error(TypeError)
+    end
+  end
+
+  it "refuses to fetch from keys that cannot be marshalled" do
+    handle_failed_connections do
+      lambda do
+        adapter.fetch(Struct.new(:foo).new(:bar), true)
+      end.should raise_error(TypeError)
+    end
+  end
+
+  it "refuses to #[]= to keys that cannot be marshalled" do
+    handle_failed_connections do
+      lambda do
+        adapter[Struct.new(:foo).new(:bar)] = "value"
+      end.should raise_error(TypeError)
+    end
+  end
+
+  it "refuses to store to keys that cannot be marshalled" do
+    handle_failed_connections do
+      lambda do
+        adapter.write Struct.new(:foo).new(:bar), "value"
+      end.should raise_error(TypeError)
+    end
+  end
+
+  it "refuses to check for key? if the key cannot be marshalled" do
+    handle_failed_connections do
+      lambda do
+        adapter.key? Struct.new(:foo).new(:bar)
+      end.should raise_error(TypeError)
+    end
+  end
+
+  it "refuses to delete a key if the key cannot be marshalled" do
+    handle_failed_connections do
+      lambda do
+        adapter.delete Struct.new(:foo).new(:bar)
+      end.should raise_error(TypeError)
+    end
+  end
+
+  it "specifies that it is writable via frozen?" do
+    handle_failed_connections do
+      adapter.should_not be_frozen
+    end
+  end
+end

data/spec/support/json_adapter.rb

@@ -0,0 +1,10 @@
+shared_examples_for "a json adapter" do
+  it_should_behave_like 'an adapter'
+
+  AdapterTestTypes.each do |type, (key, key2)|
+    it "writes Object values to keys that are #{type}s like a Hash" do
+      adapter[key] = {:foo => :bar}
+      adapter[key].should == {'foo' => 'bar'}
+    end
+  end
+end

data/spec/support/marshal_adapter.rb

@@ -0,0 +1,12 @@
+shared_examples_for "a marshaled adapter" do
+  it_should_behave_like 'an adapter'
+
+  AdapterTestTypes.each do |type, (key, key2)|
+    it "writes Object values to keys that are #{type}s like a Hash" do
+      handle_failed_connections do
+        adapter[key] = {:foo => :bar}
+        adapter[key].should == {:foo => :bar}
+      end
+    end
+  end
+end

data/spec/support/module_helpers.rb

@@ -0,0 +1,29 @@
+module ModuleHelpers
+  def valid_module
+    Module.new do
+      def read(key)
+        decode(client[key_for(key)])
+      end
+
+      def write(key, value)
+        client[key_for(key)] = encode(value)
+      end
+
+      def delete(key)
+        client.delete(key_for(key))
+      end
+
+      def clear
+        client.clear
+      end
+    end
+  end
+
+  def handle_failed_connections
+    yield
+  rescue => e
+    puts e.inspect
+    puts e.message unless e.message.nil?
+    pending
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: adapter
+version: !ruby/object:Gem::Version 
+  hash: 1
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  version: "0.5"
+platform: ruby
+authors: 
+- John Nunemaker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-25 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+- nunemaker@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/adapter/asserts.rb
+- lib/adapter/defaults.rb
+- lib/adapter/exceptions.rb
+- lib/adapter/memory.rb
+- lib/adapter/version.rb
+- lib/adapter.rb
+- spec/adapter/defaults_spec.rb
+- spec/adapter/memory_spec.rb
+- spec/adapter_spec.rb
+- spec/helper.rb
+- spec/spec.opts
+- spec/support/an_adapter.rb
+- spec/support/json_adapter.rb
+- spec/support/marshal_adapter.rb
+- spec/support/module_helpers.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/newtoy/adapter
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A simple interface to anything
+test_files: []
+