moneta 0.7.0 → 0.7.1

data/lib/moneta/stack.rb

@@ -2,7 +2,7 @@ module Moneta
   # Combines multiple stores. Reads return the result from the first store,
   # writes go to all stores.
   #
-  # @example Add stack to chain
+  # @example Add `Moneta::Stack` to proxy stack
   #   Moneta.build do
   #     use(:Stack) do
   #       add { adapter :Redis }

data/lib/moneta/transformer.rb

@@ -2,7 +2,7 @@ module Moneta
   # Transforms keys and values (Marshal, YAML, JSON, Base64, MD5, ...).
   # You can bypass the transformer (e.g. serialization) by using the `:raw` option.
   #
-  # @example Add transformer to chain
+  # @example Add `Moneta::Transformer` to proxy stack
   #   Moneta.build do
   #     transformer :key => [:marshal, :escape], :value => [:marshal]
   #     adapter :File, :dir => 'data'
@@ -25,14 +25,13 @@ module Moneta
       #
       # @param [Moneta store] adapter The underlying store
       # @param [Hash] options
-      #
-      # Options:
-      # * :key - List of key transformers in the order in which they should be applied
-      # * :value - List of value transformers in the order in which they should be applied
-      # * :prefix - Prefix string for key namespacing (Used by the :prefix key transformer)
-      # * :secret - HMAC secret to verify values (Used by the :hmac value transformer)
-      # * :maxlen - Maximum key length (Used by the :truncate key transformer)
-      # * :quiet - Disable error message
+      # @return [Transformer] new Moneta transformer
+      # @option options [Array] :key List of key transformers in the order in which they should be applied
+      # @option options [Array] :value List of value transformers in the order in which they should be applied
+      # @option options [String] :prefix Prefix string for key namespacing (Used by the :prefix key transformer)
+      # @option options [String] :secret HMAC secret to verify values (Used by the :hmac value transformer)
+      # @option options [Integer] :maxlen Maximum key length (Used by the :truncate key transformer)
+      # @option options [Boolean] :quiet Disable error message
       def new(adapter, options = {})
         keys = [options[:key]].flatten.compact
         values = [options[:value]].flatten.compact
@@ -46,8 +45,11 @@ module Moneta
       private
 
       def compile(options, keys, values)
-        raise ArgumentError, 'Invalid key transformer chain' if KEY_TRANSFORMER !~ keys.map(&:inspect).join
-        raise ArgumentError, 'Invalid value transformer chain' if VALUE_TRANSFORMER !~ values.map(&:inspect).join
+        @key_validator ||= compile_validator(KEY_TRANSFORMER)
+        @value_validator ||= compile_validator(VALUE_TRANSFORMER)
+
+        raise ArgumentError, 'Invalid key transformer chain' if @key_validator !~ keys.map(&:inspect).join
+        raise ArgumentError, 'Invalid value transformer chain' if @value_validator !~ values.map(&:inspect).join
 
         key = compile_transformer(keys, 'key')
 
@@ -140,9 +142,9 @@ module Moneta
           require t[3] if t[3]
           code = t[i]
           if t[0] == :serialize && var == 'key'
-            "(tmp = #{value}; String === tmp ? tmp : #{code.gsub('value', 'tmp')})"
+            "(tmp = #{value}; String === tmp ? tmp : #{code % 'tmp'})"
           else
-            code.gsub('value', value)
+            code % value
           end
         end
       end

data/lib/moneta/transformer/config.rb

@@ -2,41 +2,43 @@ module Moneta
   class Transformer
     # Available key/value transformers
     TRANSFORMER = {
-      # Name    => [ Type,       Load,                               Dump,                                Library         ],
-      :bencode  => [ :serialize, '::BEncode.load(value)',             '::BEncode.dump(value)',             'bencode'       ],
-      :bert     => [ :serialize, '::BERT.decode(value)',              '::BERT.encode(value)',              'bert'          ],
-      :bson     => [ :serialize, "::BSON.deserialize(value)['v']",    "::BSON.serialize('v'=>value).to_s", 'bson'          ],
-      :json     => [ :serialize, '::MultiJson.load(value).first',     '::MultiJson.dump([value])',         'multi_json'    ],
-      :marshal  => [ :serialize, '::Marshal.load(value)',             '::Marshal.dump(value)'                              ],
-      :msgpack  => [ :serialize, '::MessagePack.unpack(value)',       '::MessagePack.pack(value)',         'msgpack'       ],
-      :ox       => [ :serialize, '::Ox.parse_obj(value)',             '::Ox.dump(value)',                  'ox'            ],
-      :tnet     => [ :serialize, '::TNetstring.parse(value).first',   '::TNetstring.dump(value)',          'tnetstring'    ],
-      :yaml     => [ :serialize, '::YAML.load(value)',                '::YAML.dump(value)',                'yaml'          ],
-      :bzip2    => [ :compress,  '::Bzip2.uncompress(value)',         '::Bzip2.compress(value)',           'bzip2'         ],
-      :lzma     => [ :compress,  '::LZMA.decompress(value)',          '::LZMA.compress(value)',            'lzma'          ],
-      :lzo      => [ :compress,  '::LZO.decompress(value)',           '::LZO.compress(value)',             'lzoruby'       ],
-      :snappy   => [ :compress,  '::Snappy.inflate(value)',           '::Snappy.deflate(value)',           'snappy'        ],
-      :quicklz  => [ :compress,  '::QuickLZ.decompress(value)',       '::QuickLZ.compress(value)',         'qlzruby'       ],
-      :zlib     => [ :compress,  '::Zlib::Inflate.inflate(value)',    '::Zlib::Deflate.deflate(value)',    'zlib'          ],
-      :base64   => [ :encode,    "value.unpack('m').first",           "[value].pack('m').strip"                            ],
-      :uuencode => [ :encode,    "value.unpack('u').first",           "[value].pack('u').strip"                            ],
-      :escape   => [ :encode,    'Helper.unescape(value)',            'Helper.escape(value)'                               ],
-      :hmac     => [ :hmac,      'Helper.hmacverify(value, @secret)', 'Helper.hmacsign(value, @secret)',   'openssl'       ],
-      :truncate => [ :truncate,  nil,                                 'Helper.truncate(value, @maxlen)',   'digest/md5'    ],
-      :md5      => [ :digest,    nil,                                 '::Digest::MD5.hexdigest(value)',    'digest/md5'    ],
-      :rmd160   => [ :digest,    nil,                                 '::Digest::RMD160.hexdigest(value)', 'digest/rmd160' ],
-      :sha1     => [ :digest,    nil,                                 '::Digest::SHA1.hexdigest(value)',   'digest/sha1'   ],
-      :sha256   => [ :digest,    nil,                                 '::Digest::SHA256.hexdigest(value)', 'digest/sha2'   ],
-      :sha384   => [ :digest,    nil,                                 '::Digest::SHA384.hexdigest(value)', 'digest/sha2'   ],
-      :sha512   => [ :digest,    nil,                                 '::Digest::SHA512.hexdigest(value)', 'digest/sha2'   ],
-      :prefix   => [ :prefix,    nil,                                 '(options[:prefix]||@prefix)+value'                  ],
-      :spread   => [ :spread,    nil,                                 'Helper.spread(value)'                               ],
+      # Name    => [ Type,       Load,                             Dump,                             Library         ],
+      :bencode  => [ :serialize, '::BEncode.load(%s)',             '::BEncode.dump(%s)',             'bencode'       ],
+      :bert     => [ :serialize, '::BERT.decode(%s)',              '::BERT.encode(%s)',              'bert'          ],
+      :bson     => [ :serialize, "::BSON.deserialize(%s)['v']",    "::BSON.serialize('v'=>%s).to_s", 'bson'          ],
+      :json     => [ :serialize, '::MultiJson.load(%s).first',     '::MultiJson.dump([%s])',         'multi_json'    ],
+      :marshal  => [ :serialize, '::Marshal.load(%s)',             '::Marshal.dump(%s)'                              ],
+      :msgpack  => [ :serialize, '::MessagePack.unpack(%s)',       '::MessagePack.pack(%s)',         'msgpack'       ],
+      :ox       => [ :serialize, '::Ox.parse_obj(%s)',             '::Ox.dump(%s)',                  'ox'            ],
+      :tnet     => [ :serialize, '::TNetstring.parse(%s).first',   '::TNetstring.dump(%s)',          'tnetstring'    ],
+      :yaml     => [ :serialize, '::YAML.load(%s)',                '::YAML.dump(%s)',                'yaml'          ],
+      :bzip2    => [ :compress,  '::Bzip2.uncompress(%s)',         '::Bzip2.compress(%s)',           'bzip2'         ],
+      :lzma     => [ :compress,  '::LZMA.decompress(%s)',          '::LZMA.compress(%s)',            'lzma'          ],
+      :lzo      => [ :compress,  '::LZO.decompress(%s)',           '::LZO.compress(%s)',             'lzoruby'       ],
+      :snappy   => [ :compress,  '::Snappy.inflate(%s)',           '::Snappy.deflate(%s)',           'snappy'        ],
+      :quicklz  => [ :compress,  '::QuickLZ.decompress(%s)',       '::QuickLZ.compress(%s)',         'qlzruby'       ],
+      :zlib     => [ :compress,  '::Zlib::Inflate.inflate(%s)',    '::Zlib::Deflate.deflate(%s)',    'zlib'          ],
+      :uuencode => [ :encode,    "%s.unpack('u').first",           "[%s].pack('u').strip"                            ],
+      :base64   => RUBY_VERSION > '1.9' ?
+                   [ :encode,    "%s.unpack('m0').first",          "[%s].pack('m0')"                                 ] :
+                   [ :encode,    "%s.unpack('m').first",           "[%s].pack('m').gsub(\"\n\", '')"                 ],
+      :escape   => [ :encode,    'Helper.unescape(%s)',            'Helper.escape(%s)'                               ],
+      :hmac     => [ :hmac,      'Helper.hmacverify(%s, @secret)', 'Helper.hmacsign(%s, @secret)',   'openssl'       ],
+      :truncate => [ :truncate,  nil,                              'Helper.truncate(%s, @maxlen)',   'digest/md5'    ],
+      :md5      => [ :digest,    nil,                              '::Digest::MD5.hexdigest(%s)',    'digest/md5'    ],
+      :rmd160   => [ :digest,    nil,                              '::Digest::RMD160.hexdigest(%s)', 'digest/rmd160' ],
+      :sha1     => [ :digest,    nil,                              '::Digest::SHA1.hexdigest(%s)',   'digest/sha1'   ],
+      :sha256   => [ :digest,    nil,                              '::Digest::SHA256.hexdigest(%s)', 'digest/sha2'   ],
+      :sha384   => [ :digest,    nil,                              '::Digest::SHA384.hexdigest(%s)', 'digest/sha2'   ],
+      :sha512   => [ :digest,    nil,                              '::Digest::SHA512.hexdigest(%s)', 'digest/sha2'   ],
+      :prefix   => [ :prefix,    nil,                              '(options[:prefix]||@prefix)+%s'                  ],
+      :spread   => [ :spread,    nil,                              'Helper.spread(%s)'                               ],
     }
 
     # Allowed value transformers (Read it like a regular expression!)
-    VALUE_TRANSFORMER = compile_validator('serialize? compress? hmac? encode?')
+    VALUE_TRANSFORMER = 'serialize? compress? hmac? encode?'
 
     # Allowed key transformers (Read it like a regular expression!)
-    KEY_TRANSFORMER = compile_validator('serialize? prefix? ((encode? truncate?) | (digest spread?))?')
+    KEY_TRANSFORMER = 'serialize? prefix? ((encode? truncate?) | (digest spread?))?'
   end
 end

data/lib/moneta/version.rb

@@ -1,5 +1,5 @@
 module Moneta
   # Moneta version number
   # @api public
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
 end

data/lib/rack/cache/moneta.rb

@@ -5,8 +5,10 @@ require 'rack/cache/entitystore'
 
 module Rack
   module Cache
+    # @api public
     Moneta = {}
 
+    # @api private
     module MonetaResolver
       include Rack::Utils
 
@@ -29,6 +31,7 @@ module Rack
     end
 
     class MetaStore
+      # @api public
       class Moneta < MetaStore
         extend MonetaResolver
 
@@ -50,10 +53,12 @@ module Rack
         end
       end
 
+      # @api public
       MONETA = Moneta
     end
 
     class EntityStore
+      # @api public
       class Moneta < EntityStore
         extend MonetaResolver
 
@@ -87,6 +92,7 @@ module Rack
         end
       end
 
+      # @api public
       MONETA = Moneta
     end
   end

data/lib/rack/moneta_cookies.rb

@@ -33,6 +33,7 @@ module Rack
   #     [200, {}, []]
   #   end
   #
+  # @api public
   class MonetaCookies
     def initialize(app, options = {}, &block)
       @app, @pool = app, []

data/lib/rack/session/moneta.rb

@@ -4,6 +4,7 @@ require 'thread'
 
 module Rack
   module Session
+    # @api public
     class Moneta < Abstract::ID
       attr_reader :mutex, :pool
 

data/moneta.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.name             = 'moneta'
   s.version          = Moneta::VERSION
   s.date             = Date.today.to_s
-  s.authors          = ['Daniel Mendler', 'Yehuda Katz' 'Hannes Georg']
+  s.authors          = ['Daniel Mendler', 'Yehuda Katz', 'Hannes Georg']
   s.email            = %w{mail@daniel-mendler.de wycats@gmail.com hannes.georg@googlemail.com}
   s.description      = 'A unified interface to key/value stores'
   s.extra_rdoc_files = %w{README.md SPEC.md LICENSE}

data/spec/generate.rb

@@ -1,26 +1,111 @@
-ADAPTER_SPECS = [:null_stringkey_stringvalue, :store_stringkey_stringvalue, :returndifferent_stringkey_stringvalue, :not_increment]
-SIMPLE_SPECS = [:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :not_increment]
-EXPIRES_SPECS = [:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :expires_stringkey_stringvalue, :transform_value_with_expires, :not_increment]
-NATIVE_EXPIRES_SPECS = SIMPLE_SPECS + [:expires_stringkey_stringvalue]
-TRANSFORMER_SPECS = [:null, :store, :returndifferent, :transform_value]
-ADAPTER_EXPIRES_SPECS = ADAPTER_SPECS + [:expires_stringkey_stringvalue]
-
-EXPIRES_INCR_SPECS = EXPIRES_SPECS.reject {|s| s == :not_increment } + [:increment]
-NATIVE_EXPIRES_INCR_SPECS = NATIVE_EXPIRES_SPECS.reject {|s| s == :not_increment } + [:increment]
-SIMPLE_INCR_SPECS = SIMPLE_SPECS.reject {|s| s == :not_increment } + [:increment]
-ADAPTER_INCR_SPECS = ADAPTER_SPECS.reject {|s| s == :not_increment } + [:increment]
-ADAPTER_EXPIRES_INCR_SPECS = ADAPTER_EXPIRES_SPECS.reject {|s| s == :not_increment } + [:increment]
-PSTORE_SPECS = ADAPTER_INCR_SPECS + [:null_stringkey_objectvalue,
-                                     :store_stringkey_objectvalue,
-                                     :returndifferent_stringkey_objectvalue]
+class Specs
+  attr_reader :key, :value, :specs
+
+  def initialize(specs, key = nil, value = nil)
+    @specs = specs
+    @key = key     || %w(Object String Hash Boolean Nil Integer)
+    @value = value || %w(Object String Hash Boolean Nil Integer)
+  end
+
+  def stringkeys_only
+    Specs.new(specs, %w(String), value)
+  end
+
+  def stringvalues_only
+    Specs.new(specs, key, %w(String))
+  end
+
+  def simplekeys_only
+    Specs.new(specs, %w(String Hash Integer), value)
+  end
+
+  def simplevalues_only
+    Specs.new(specs, key, %w(String Hash Integer))
+  end
+
+  def without_increment
+    a = specs.dup
+    a.delete(:increment)
+    a << :not_increment
+    Specs.new(a, key, value)
+  end
+
+  def without_persist
+    a = specs.dup
+    a.delete(:persist)
+    a << :not_persist
+    Specs.new(a, key, value)
+  end
+
+  def with_expires
+    a = specs.dup
+    if a.include?(:transform_value)
+      a.delete(:transform_value)
+      a << :transform_value_with_expires
+    end
+    a << :expires
+    Specs.new(a, key, value)
+  end
+
+  def with_native_expires
+    a = specs.dup
+    a << :expires
+    Specs.new(a, key, value)
+  end
+
+  def without_marshallable
+    a = specs.dup
+    a.delete(:marshallable_value)
+    a.delete(:marshallable_key)
+    Specs.new(a, key, value)
+  end
+
+  def without_transform
+    a = specs.dup
+    a.delete(:marshallable_value)
+    a.delete(:marshallable_key)
+    a.delete(:transform_value)
+    Specs.new(a, key, value)
+  end
+
+  def without_returndifferent
+    a = specs.dup
+    a.delete(:returndifferent)
+    Specs.new(a, key, value)
+  end
+
+  def without_marshallable_key
+    a = specs.dup
+    a.delete(:marshallable_key)
+    Specs.new(a, key, value)
+  end
+
+  def without_marshallable_value
+    a = specs.dup
+    a.delete(:marshallable_value)
+    Specs.new(a, key, value)
+  end
+
+  def without_store
+    a = specs.dup
+    a.delete(:store)
+    a.delete(:transform_value)
+    a.delete(:marshallable_value)
+    Specs.new(a, key, value)
+  end
+end
+
+ADAPTER_SPECS = Specs.new([:null, :store, :returndifferent, :increment, :persist], %w(String), %w(String))
+STANDARD_SPECS = Specs.new([:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :persist])
+TRANSFORMER_SPECS = Specs.new([:null, :store, :returndifferent, :transform_value, :increment])
 
 header = "# Generated by #{__FILE__}\n"
 
 TESTS = {
   'simple_client_tcp' => {
-    :preamble => "$tcp_server ||= Moneta::Server.new(Moneta::Adapters::Memory.new)\n",
+    :preamble => "start_server(Moneta::Adapters::Memory.new)\n",
     :store => :Client,
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS,
     :tests => %{
 it 'should support multiple clients' do
   client = Moneta.new(:Client)
@@ -39,214 +124,209 @@ end
 }
   },
   'simple_client_unix' => {
-    :preamble => "$unix_server ||= Moneta::Server.new(Moneta::Adapters::Memory.new, :file => File.join(make_tempdir, 'simple_client_unix'))\nafter(:all) { $unix_server.stop; $unix_server = nil }\n",
+    :preamble => "start_server(Moneta::Adapters::Memory.new, :file => File.join(make_tempdir, 'simple_client_unix'))\n",
     :store => :Client,
     :options => ":file => File.join(make_tempdir, 'simple_client_unix')",
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_memory' => {
     :store => :Memory,
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS.without_persist
   },
   'simple_memory_with_expires' => {
     :store => :Memory,
     :options => ':expires => true',
-    :specs => EXPIRES_SPECS,
-    :specs => EXPIRES_INCR_SPECS
+    :specs => STANDARD_SPECS.with_expires.without_persist
   },
   'simple_memory_with_compress' => {
     :store => :Memory,
     :options => ':compress => true',
     :load_value => 'Marshal.load(::Zlib::Inflate.inflate(value))',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS.without_persist
   },
   'simple_memory_with_prefix' => {
     :store => :Memory,
     :options => ':prefix => "moneta"',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS.without_persist
   },
   'simple_memory_with_json_serializer' => {
     :store => :Memory,
     :options => ':serializer => :json',
     :load_value => '::MultiJson.load(value).first',
-    :key => %w(Hash String),
-    :value => %w(Hash String),
-    :specs => [:null, :store, :returndifferent, :transform_value, :increment],
+    :specs => STANDARD_SPECS.without_marshallable.simplekeys_only.simplevalues_only.without_persist
   },
   'simple_memory_with_json_key_serializer' => {
     :store => :Memory,
     :options => ':key_serializer => :json',
-    :key => %w(Hash String),
-    :specs => [:null, :store, :returndifferent, :increment],
+    :specs => STANDARD_SPECS.without_marshallable_key.simplekeys_only.without_persist,
   },
   'simple_memory_with_json_value_serializer' => {
     :store => :Memory,
     :options => ':value_serializer => :json',
-    :value => %w(Hash String),
-    :specs => [:null, :store, :returndifferent, :marshallable_key, :transform_value, :increment],
+    :specs => STANDARD_SPECS.without_marshallable_value.simplevalues_only.without_persist,
     :load_value => '::MultiJson.load(value).first'
   },
   'simple_memory_with_snappy_compress' => {
     :store => :Memory,
     :options => ':compress => :snappy',
     :load_value => 'Marshal.load(::Snappy.inflate(value))',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS.without_persist
   },
   'simple_lruhash' => {
     :store => :LRUHash,
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS.without_persist
   },
   'simple_lruhash_with_expires' => {
     :store => :LRUHash,
     :options => ':expires => true',
-    :specs => EXPIRES_INCR_SPECS,
+    :specs => STANDARD_SPECS.with_expires.without_persist,
   },
   'simple_file' => {
     :store => :File,
     :options => ':dir => File.join(make_tempdir, "simple_file")',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_file_with_expires' => {
     :store => :File,
     :options => ':dir => File.join(make_tempdir, "simple_file_with_expires"), :expires => true',
-    :specs => EXPIRES_INCR_SPECS
+    :specs => STANDARD_SPECS.with_expires
   },
   'simple_hashfile' => {
     :store => :HashFile,
     :options => ':dir => File.join(make_tempdir, "simple_hashfile")',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_hashfile_with_expires' => {
     :store => :HashFile,
     :options => ':dir => File.join(make_tempdir, "simple_hashfile_with_expires"), :expires => true',
-    :specs => EXPIRES_INCR_SPECS
+    :specs => STANDARD_SPECS.with_expires
   },
   'simple_cassandra' => {
     :store => :Cassandra,
     :options => ':keyspace => "simple_cassandra"',
-    :specs => NATIVE_EXPIRES_SPECS,
+    :specs => STANDARD_SPECS.without_increment.with_native_expires,
   },
   'simple_hbase' => {
     :store => :HBase,
     :options => ':table => "simple_hbase"',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_hbase_with_expires' => {
     :store => :HBase,
     :options => ':table => "simple_hbase", :expires => true',
-    :specs => EXPIRES_INCR_SPECS,
+    :specs => STANDARD_SPECS.with_expires,
   },
   'simple_dbm' => {
     :store => :DBM,
     :options => ':file => File.join(make_tempdir, "simple_dbm")',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_dbm_with_expires' => {
     :store => :DBM,
     :options => ':file => File.join(make_tempdir, "simple_dbm_with_expires"), :expires => true',
-    :specs => EXPIRES_INCR_SPECS
+    :specs => STANDARD_SPECS.with_expires
   },
   'simple_gdbm' => {
     :store => :GDBM,
     :options => ':file => File.join(make_tempdir, "simple_gdbm")',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_gdbm_with_expires' => {
     :store => :GDBM,
     :options => ':file => File.join(make_tempdir, "simple_gdbm_with_expires"), :expires => true',
-    :specs => EXPIRES_INCR_SPECS
+    :specs => STANDARD_SPECS.with_expires
   },
   'simple_sdbm' => {
     :store => :SDBM,
     :options => ':file => File.join(make_tempdir, "simple_sdbm")',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_sdbm_with_expires' => {
     :store => :SDBM,
     :options => ':file => File.join(make_tempdir, "simple_sdbm_with_expires"), :expires => true',
-    :specs => EXPIRES_INCR_SPECS
+    :specs => STANDARD_SPECS.with_expires
   },
   'simple_leveldb' => {
     :store => :LevelDB,
     :options => ':dir => File.join(make_tempdir, "simple_leveldb")',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_leveldb_with_expires' => {
     :store => :LevelDB,
     :options => ':dir => File.join(make_tempdir, "simple_leveldb_with_expires"), :expires => true',
-    :specs => EXPIRES_INCR_SPECS
+    :specs => STANDARD_SPECS.with_expires
   },
   'simple_pstore' => {
     :store => :PStore,
     :options => ':file => File.join(make_tempdir, "simple_pstore")',
     :load_value => 'value',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_pstore_with_expires' => {
     :store => :PStore,
     :options => ':file => File.join(make_tempdir, "simple_pstore_with_expires"), :expires => true',
     :load_value => 'value',
-    :specs => EXPIRES_INCR_SPECS
+    :specs => STANDARD_SPECS.with_expires
   },
   'simple_yaml' => {
     :store => :YAML,
     :options => ':file => File.join(make_tempdir, "simple_yaml")',
-    :specs => [:null, :store, :returndifferent, :marshallable_key, :increment, :transform_value],
+    :specs => STANDARD_SPECS.without_marshallable_value,
     :load_value => 'value'
   },
   'simple_yaml_with_expires' => {
     :store => :YAML,
     :options => ':file => File.join(make_tempdir, "simple_yaml_with_expires"), :expires => true',
-    :specs => [:null, :store, :returndifferent, :marshallable_key, :expires_stringkey_stringvalue, :increment, :transform_value_with_expires],
+    :specs => STANDARD_SPECS.without_marshallable_value.with_expires,
     :load_value => 'value'
   },
   'simple_localmemcache' => {
     :store => :LocalMemCache,
     :options => ':file => File.join(make_tempdir, "simple_localmemcache")',
-    :specs => SIMPLE_SPECS
+    :specs => STANDARD_SPECS.without_increment
   },
   'simple_localmemcache_with_expires' => {
     :store => :LocalMemCache,
     :options => ':file => File.join(make_tempdir, "simple_localmemcache_with_expires"), :expires => true',
-    :specs => EXPIRES_SPECS
+    :specs => STANDARD_SPECS.without_increment.with_expires
   },
   'simple_tokyocabinet' => {
     :store => :TokyoCabinet,
     :options => ':file => File.join(make_tempdir, "simple_tokyocabinet")',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_tokyocabinet_with_expires' => {
     :store => :TokyoCabinet,
     :options => ':file => File.join(make_tempdir, "simple_tokyocabinet_with_expires"), :expires => true',
-    :specs => EXPIRES_INCR_SPECS
+    :specs => STANDARD_SPECS.with_expires
   },
   'simple_sqlite' => {
     :store => :Sqlite,
     :options => ':file => File.join(make_tempdir, "simple_sqlite")',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_sqlite_with_expires' => {
     :store => :Sqlite,
     :options => ':file => File.join(make_tempdir, "simple_sqlite_with_expires"), :expires => true',
-    :specs => EXPIRES_INCR_SPECS
+    :specs => STANDARD_SPECS.with_expires
   },
   'simple_redis' => {
     :store => :Redis,
-    :specs => NATIVE_EXPIRES_INCR_SPECS,
+    :specs => STANDARD_SPECS.with_native_expires,
   },
   'simple_memcached' => {
     :store => :Memcached,
-    :specs => NATIVE_EXPIRES_INCR_SPECS,
+    :specs => STANDARD_SPECS.with_native_expires,
     :options => ':namespace => "simple_memcached"'
   },
   'simple_memcached_dalli' => {
     :store => :MemcachedDalli,
-    :specs => NATIVE_EXPIRES_INCR_SPECS,
+    :specs => STANDARD_SPECS.with_native_expires,
     :options => ':namespace => "simple_memcached_dalli"'
   },
   'simple_memcached_native' => {
     :store => :MemcachedNative,
-    :specs => NATIVE_EXPIRES_INCR_SPECS,
+    :specs => STANDARD_SPECS.with_native_expires,
     :options => ':namespace => "simple_memcached_native"'
   },
   'simple_riak' => {
@@ -254,60 +334,60 @@ end
     :options => ":bucket => 'simple_riak'",
     # We don't want Riak warnings in tests
     :preamble => "require 'riak'\n\nRiak.disable_list_keys_warnings = true\n\n",
-    :specs => SIMPLE_SPECS
+    :specs => STANDARD_SPECS.without_increment
   },
   'simple_riak_with_expires' => {
     :store => :Riak,
     :options => ":bucket => 'simple_riak_with_expires', :expires => true",
     # We don't want Riak warnings in tests
     :preamble => "require 'riak'\n\nRiak.disable_list_keys_warnings = true\n\n",
-    :specs => EXPIRES_SPECS
+    :specs => STANDARD_SPECS.without_increment.with_expires
   },
   'simple_couch' => {
     :store => :Couch,
     :options => ":db => 'simple_couch'",
     :load_value => '::Marshal.load(value.unpack(\'m\').first)',
-    :specs => SIMPLE_SPECS
+    :specs => STANDARD_SPECS.without_increment
   },
   'simple_couch_with_expires' => {
     :store => :Couch,
     :options => ":db => 'simple_couch_with_expires', :expires => true",
-    :specs => EXPIRES_SPECS,
+    :specs => STANDARD_SPECS.without_increment.with_expires,
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'simple_mongo' => {
     :store => :Mongo,
     :options => ":db => 'simple_mongo'",
-    :specs => SIMPLE_SPECS
+    :specs => STANDARD_SPECS.without_increment
   },
   'simple_mongo_with_expires' => {
     :store => :Mongo,
     :options => ":db => 'simple_mongo_with_expires', :expires => true",
-    :specs => EXPIRES_SPECS
+    :specs => STANDARD_SPECS.without_increment.with_expires
   },
   'simple_null' => {
     :store => :Null,
-    :specs => [:null, :marshallable_key, :returndifferent]
+    :specs => STANDARD_SPECS.without_increment.without_store.without_persist
   },
   'null_adapter' => {
     :build => 'Moneta::Adapters::Null.new',
-    :specs => [:null]
+    :specs => Specs.new([:null, :not_increment, :not_persist])
   },
   'simple_sequel' => {
     :store => :Sequel,
     :options => ':db => (defined?(JRUBY_VERSION) ? "jdbc:sqlite:" : "sqlite:") + File.join(make_tempdir, "simple_sequel")',
     :load_value => '::Marshal.load(value.unpack(\'m\').first)',
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS
   },
   'simple_sequel_with_expires' => {
     :store => :Sequel,
     :options => ':db => (defined?(JRUBY_VERSION) ? "jdbc:sqlite:" : "sqlite:") + File.join(make_tempdir, "simple_sequel_with_expires"), :expires => true',
-    :specs => EXPIRES_INCR_SPECS,
+    :specs => STANDARD_SPECS.with_expires,
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'simple_datamapper' => {
     :store => :DataMapper,
-    :specs => SIMPLE_SPECS,
+    :specs => STANDARD_SPECS.without_increment,
     :options => ':setup => "sqlite3://#{make_tempdir}/simple_datamapper"',
     # DataMapper needs default repository to be setup
     :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
@@ -318,12 +398,12 @@ end
     :options => ':setup => "sqlite3://#{make_tempdir}/simple_datamapper_with_expires", :expires => true',
     # DataMapper needs default repository to be setup
     :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
-    :specs => EXPIRES_SPECS,
+    :specs => STANDARD_SPECS.without_increment.with_expires,
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'simple_datamapper_with_repository' => {
     :store => :DataMapper,
-    :specs => SIMPLE_SPECS,
+    :specs => STANDARD_SPECS.without_increment,
     :options => ':repository => :repo, :setup => "sqlite3://#{make_tempdir}/simple_datamapper_with_repository"',
     # DataMapper needs default repository to be setup
     :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
@@ -331,19 +411,19 @@ end
   },
   'simple_activerecord' => {
     :store => :ActiveRecord,
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS,
     :options => ":connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'simple_activerecord') }",
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'simple_activerecord_with_expires' => {
     :store => :ActiveRecord,
     :options => ":connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'simple_activerecord_with_expires') }, :expires => true",
-    :specs => EXPIRES_INCR_SPECS,
+    :specs => STANDARD_SPECS.with_expires,
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'simple_fog' => {
     :store                  => :Fog,
-    :specs                  => SIMPLE_SPECS,
+    :specs                  => STANDARD_SPECS.without_increment,
     :options => ":aws_access_key_id => 'fake_access_key_id',
     :aws_secret_access_key  => 'fake_secret_access_key',
     :provider               => 'AWS',
@@ -360,14 +440,14 @@ end
     :expires                => true",
     # Put Fog into testing mode
     :preamble               => "require 'fog'\nFog.mock!\n",
-    :specs => EXPIRES_SPECS
+    :specs => STANDARD_SPECS.without_increment.with_expires
   },
   'expires_memory' => {
     :build => %{Moneta.build do
   use :Expires
   adapter :Memory
 end},
-    :specs => [:null, :store, :expires, :increment],
+    :specs => STANDARD_SPECS.without_transform.with_expires.without_persist,
     :tests => %{
 it 'should support default expiration time' do
   store = Moneta.new(:Memory, :expires => 2)
@@ -387,7 +467,7 @@ end}
   use :Transformer, :key => [:marshal, :escape], :value => :marshal
   adapter :File, :dir => File.join(make_tempdir, "expires-file")
 end},
-    :specs => [:null, :store, :expires, :returndifferent, :marshallable_key, :increment],
+    :specs => STANDARD_SPECS.with_expires.stringvalues_only,
     :tests => %{
 it 'should delete expired value in underlying file storage' do
   store.store('foo', 'bar', :expires => 2)
@@ -407,7 +487,7 @@ end
   use :Proxy
   adapter :Redis
 end},
-    :specs => ADAPTER_EXPIRES_INCR_SPECS
+    :specs => ADAPTER_SPECS.with_expires
   },
   'proxy_expires_memory' => {
     :build => %{Moneta.build do
@@ -416,7 +496,7 @@ end},
   use :Proxy
   adapter :Memory
 end},
-    :specs => [:null, :store, :expires]
+    :specs => STANDARD_SPECS.without_transform.with_expires.without_returndifferent.without_persist
   },
   'cache_file_memory' => {
     :build => %{Moneta.build do
@@ -425,7 +505,7 @@ end},
     cache { adapter :Memory }
   end
 end},
-    :specs => ADAPTER_INCR_SPECS,
+    :specs => ADAPTER_SPECS,
     :tests => %{
 it 'should store loaded values in cache' do
   store.backend['foo'] = 'bar'
@@ -446,15 +526,15 @@ end
     cache(Moneta::Adapters::Null.new)
   end
 end},
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS.without_persist
   },
   'shared' => {
     :build => %{Moneta.build do
-  use(:Shared) do
+  use(:Shared, :port => 9001) do
     adapter :Memory
   end
 end},
-    :specs => ADAPTER_INCR_SPECS,
+    :specs => ADAPTER_SPECS.without_persist,
     :tests => %{
 it 'should share values' do
   store['shared_key'] = 'shared_value'
@@ -474,7 +554,7 @@ end
     add { adapter :Memory }
   end
 end},
-    :specs => ADAPTER_SPECS
+    :specs => ADAPTER_SPECS.without_increment
   },
   'stack_memory_file' => {
     :build => %{Moneta.build do
@@ -485,22 +565,21 @@ end},
     add { adapter :File, :dir => File.join(make_tempdir, "stack-file2") }
   end
 end},
-    :specs => [:null_stringkey_stringvalue, :store_stringkey_stringvalue, :not_increment]
+    :specs => STANDARD_SPECS.without_increment.without_transform.stringkeys_only.stringvalues_only
   },
   'lock' => {
     :build => %{Moneta.build do
   use :Lock
   adapter :Memory
 end},
-    :specs => [:null, :store, :increment]
+    :specs => STANDARD_SPECS.without_transform.without_returndifferent.without_persist
   },
   'transformer_zlib' => {
     :build => %{Moneta.build do
   use :Transformer, :value => :zlib
   adapter :Memory
 end},
-    :value => %w(String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.stringvalues_only,
     :load_value => '::Zlib::Inflate.inflate(value)'
   },
   'transformer_bzip2' => {
@@ -508,8 +587,7 @@ end},
   use :Transformer, :value => :bzip2
   adapter :Memory
 end},
-    :value => %w(String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.stringvalues_only,
     :load_value => '::Bzip2.uncompress(value)'
   },
   'transformer_lzo' => {
@@ -517,8 +595,7 @@ end},
   use :Transformer, :value => :lzo
   adapter :Memory
 end},
-    :value => %w(String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.stringvalues_only,
     :load_value => '::LZO.decompress(value)'
   },
   'transformer_lzma' => {
@@ -526,8 +603,7 @@ end},
   use :Transformer, :value => :lzma
   adapter :Memory
 end},
-    :value => %w(String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.stringvalues_only,
     :load_value => '::LZMA.decompress(value)'
   },
   'transformer_snappy' => {
@@ -535,8 +611,7 @@ end},
   use :Transformer, :value => :snappy
   adapter :Memory
 end},
-    :value => %w(String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.stringvalues_only,
     :load_value => '::Snappy.inflate(value)'
   },
   'transformer_quicklz' => {
@@ -544,8 +619,7 @@ end},
   use :Transformer, :value => :quicklz
   adapter :Memory
 end},
-    :value => %w(String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.stringvalues_only,
     :load_value => '::QuickLZ.decompress(value)'
   },
   'transformer_json' => {
@@ -553,9 +627,7 @@ end},
   use :Transformer, :key => :json, :value => :json
   adapter :Memory
 end},
-    :key => %w(Hash String),
-    :value => %w(Hash String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
     :load_value => '::MultiJson.load(value).first'
   },
   'transformer_bert' => {
@@ -563,9 +635,7 @@ end},
   use :Transformer, :key => :bert, :value => :bert
   adapter :Memory
 end},
-    :key => %w(Hash String),
-    :value => %w(Hash String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
     :load_value => '::BERT.decode(value)'
   },
   'transformer_bencode' => {
@@ -573,9 +643,7 @@ end},
   use :Transformer, :key => :bencode, :value => :bencode
   adapter :Memory
 end},
-    :key => %w(Hash String),
-    :value => %w(Hash String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
     :load_value => '::BEncode.load(value)'
   },
   'transformer_bson' => {
@@ -583,9 +651,7 @@ end},
   use :Transformer, :key => :bson, :value => :bson
   adapter :Memory
 end},
-    :key => %w(Hash String),
-    :value => %w(Hash String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
     :load_value => "::BSON.deserialize(value)['v']"
   },
   'transformer_ox' => {
@@ -601,9 +667,7 @@ end},
  use :Transformer, :key => :tnet, :value => :tnet
  adapter :Memory
 end},
-    :key => %w(Hash String),
-    :value => %w(Hash String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
     :load_value => '::TNetstring.parse(value).first'
   },
   'transformer_msgpack' => {
@@ -611,9 +675,7 @@ end},
   use :Transformer, :key => :msgpack, :value => :msgpack
   adapter :Memory
 end},
-    :key => %w(Hash String),
-    :value => %w(Hash String),
-    :specs => TRANSFORMER_SPECS,
+    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
     :load_value => '::MessagePack.unpack(value)'
   },
   'transformer_yaml' => {
@@ -629,7 +691,7 @@ end},
   use :Transformer, :key => :marshal, :value => [:marshal, :hmac], :secret => 'secret'
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
     :load_value => '::Marshal.load(::Moneta::Transformer::Helper.hmacverify(value, \'secret\'))'
   },
   'transformer_marshal_base64' => {
@@ -637,7 +699,7 @@ end},
   use :Transformer, :key => [:marshal, :base64], :value => [:marshal, :base64]
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'transformer_marshal_prefix' => {
@@ -645,14 +707,14 @@ end},
   use :Transformer, :key => [:marshal, :prefix], :value => :marshal, :prefix => 'moneta'
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS.without_persist
   },
   'transformer_marshal_uuencode' => {
     :build => %{Moneta.build do
   use :Transformer, :key => [:marshal, :uuencode], :value => [:marshal, :uuencode]
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
     :load_value => '::Marshal.load(value.unpack(\'u\').first)'
   },
   'transformer_marshal_escape' => {
@@ -660,67 +722,67 @@ end},
   use :Transformer, :key => [:marshal, :escape], :value => :marshal
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS
+    :specs => STANDARD_SPECS.without_persist
   },
   'transformer_marshal_md5' => {
     :build => %{Moneta.build do
   use :Transformer, :key => [:marshal, :md5], :value => :marshal
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
   },
   'transformer_marshal_sha1' => {
     :build => %{Moneta.build do
   use :Transformer, :key => [:marshal, :sha1], :value => :marshal
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
   },
   'transformer_marshal_sha256' => {
     :build => %{Moneta.build do
   use :Transformer, :key => [:marshal, :sha256], :value => :marshal
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
   },
   'transformer_marshal_sha384' => {
     :build => %{Moneta.build do
   use :Transformer, :key => [:marshal, :sha384], :value => :marshal
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
   },
   'transformer_marshal_sha512' => {
     :build => %{Moneta.build do
   use :Transformer, :key => [:marshal, :sha512], :value => :marshal
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
   },
   'transformer_marshal_rmd160' => {
     :build => %{Moneta.build do
   use :Transformer, :key => [:marshal, :rmd160], :value => :marshal
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
   },
   'transformer_marshal_md5_spread' => {
     :build => %{Moneta.build do
   use :Transformer, :key => [:marshal, :md5, :spread], :value => :marshal
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
   },
   'transformer_marshal_truncate' => {
     :build => %{Moneta.build do
   use :Transformer, :key => [:marshal, :truncate], :value => :marshal, :maxlen => 64
   adapter :Memory
 end},
-    :specs => SIMPLE_INCR_SPECS,
+    :specs => STANDARD_SPECS.without_persist,
   },
   'adapter_activerecord' => {
     :build => "Moneta::Adapters::ActiveRecord.new(:connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'adapter_activerecord') })",
-    :specs => ADAPTER_INCR_SPECS,
+    :specs => ADAPTER_SPECS,
     :tests => %{
 it 'updates an existing key/value' do
   store['foo/bar'] = '1'
@@ -738,13 +800,13 @@ end
 }
   },
   'adapter_client' => {
-    :preamble => "$tcp_server ||= Moneta::Server.new(Moneta::Adapters::Memory.new)\n",
+    :preamble => "start_server(Moneta::Adapters::Memory.new)\n",
     :build => "Moneta::Adapters::Client.new",
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_cassandra' => {
     :build => "Moneta::Adapters::Cassandra.new(:keyspace => 'adapter_cassandra')",
-    :specs => ADAPTER_EXPIRES_SPECS,
+    :specs => ADAPTER_SPECS.without_increment.with_expires,
     :tests => %{
 it 'should support default expiration time' do
   store = Moneta::Adapters::Cassandra.new(:expires => 2, :keyspace => 'adapter_cassandra')
@@ -760,21 +822,21 @@ end}
   },
   'adapter_hbase' => {
     :build => "Moneta::Adapters::HBase.new(:table => 'adapter_hbase')",
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_cookie' => {
     :build => 'Moneta::Adapters::Cookie.new',
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS.without_persist
   },
   'adapter_couch' => {
     :build => "Moneta::Adapters::Couch.new(:db => 'adapter_couch')",
-    :specs => ADAPTER_SPECS
+    :specs => ADAPTER_SPECS.without_increment
   },
   'adapter_datamapper' => {
     :build => 'Moneta::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/adapter_datamapper")',
     # DataMapper needs default repository to be setup
     :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
-    :specs => ADAPTER_SPECS,
+    :specs => ADAPTER_SPECS.without_increment,
     :tests => %q{
 it 'does not cross contaminate when storing' do
   first = Moneta::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/datamapper-first")
@@ -808,11 +870,11 @@ end
   },
   'adapter_dbm' => {
     :build => 'Moneta::Adapters::DBM.new(:file => File.join(make_tempdir, "adapter_dbm"))',
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_file' => {
     :build => 'Moneta::Adapters::File.new(:dir => File.join(make_tempdir, "adapter_file"))',
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_fog' => {
     :build => "Moneta::Adapters::Fog.new(:aws_access_key_id => 'fake_access_key_id',
@@ -821,19 +883,19 @@ end
     :dir                    => 'moneta')",
     # Put Fog into testing mode
     :preamble               => "require 'fog'\nFog.mock!\n",
-    :specs => ADAPTER_SPECS
+    :specs => ADAPTER_SPECS.without_increment
   },
   'adapter_gdbm' => {
     :build => 'Moneta::Adapters::GDBM.new(:file => File.join(make_tempdir, "adapter_gdbm"))',
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_localmemcache' => {
     :build => 'Moneta::Adapters::LocalMemCache.new(:file => File.join(make_tempdir, "adapter_localmemcache"))',
-    :specs => ADAPTER_SPECS
+    :specs => ADAPTER_SPECS.without_increment
   },
   'adapter_memcached_dalli' => {
     :build => 'Moneta::Adapters::MemcachedDalli.new(:namespace => "adapter_memcached_dalli")',
-    :specs => ADAPTER_EXPIRES_INCR_SPECS,
+    :specs => ADAPTER_SPECS.with_expires,
     :tests => %{
 it 'should support default expiration time' do
   store = Moneta::Adapters::MemcachedDalli.new(:expires => 2, :namespace => "adapter_memcached_dalli")
@@ -849,7 +911,7 @@ end}
   },
   'adapter_memcached_native' => {
     :build => 'Moneta::Adapters::MemcachedNative.new(:namespace => "adapter_memcached_native")',
-    :specs => ADAPTER_EXPIRES_INCR_SPECS,
+    :specs => ADAPTER_SPECS.with_expires,
     :tests => %{
 it 'should support default expiration time' do
   store = Moneta::Adapters::MemcachedNative.new(:expires => 2, :namespace => "adapter_memcached_native")
@@ -866,7 +928,7 @@ end
   },
   'adapter_memcached' => {
     :build => 'Moneta::Adapters::Memcached.new(:namespace => "adapter_memcached")',
-    :specs => ADAPTER_EXPIRES_INCR_SPECS,
+    :specs => ADAPTER_SPECS.with_expires,
     :tests => %{
 it 'should support default expiration time' do
   store = Moneta::Adapters::Memcached.new(:expires => 2, :namespace => "adapter_memcached")
@@ -882,11 +944,11 @@ end}
   },
   'adapter_memory' => {
     :build => 'Moneta::Adapters::Memory.new',
-    :specs => [:null, :store, :increment]
+    :specs => STANDARD_SPECS.without_transform.without_returndifferent.without_persist
   },
   'adapter_lruhash' => {
     :build => 'Moneta::Adapters::LRUHash.new',
-    :specs => ADAPTER_INCR_SPECS,
+    :specs => ADAPTER_SPECS.without_persist,
     :tests => %{
 it 'should delete oldest' do
   store = Moneta::Adapters::LRUHash.new(:max_size => 10)
@@ -904,15 +966,15 @@ end}
   },
   'adapter_mongo' => {
     :build => 'Moneta::Adapters::Mongo.new(:db => "adapter_mongo")',
-    :specs => ADAPTER_SPECS
+    :specs => ADAPTER_SPECS.without_increment
   },
   'adapter_pstore' => {
     :build => 'Moneta::Adapters::PStore.new(:file => File.join(make_tempdir, "adapter_pstore"))',
-    :specs => PSTORE_SPECS
+    :specs => STANDARD_SPECS.without_transform
   },
   'adapter_redis' => {
     :build => 'Moneta::Adapters::Redis.new',
-    :specs => ADAPTER_EXPIRES_INCR_SPECS,
+    :specs => ADAPTER_SPECS.with_expires,
     :tests => %{
 it 'should support default expiration time' do
   store = Moneta::Adapters::Redis.new(:expires => 2)
@@ -929,41 +991,41 @@ end}
   'adapter_riak' => {
     :build => 'Moneta::Adapters::Riak.new',
     :options => ":bucket => 'adapter_riak'",
-    :specs => ADAPTER_SPECS,
+    :specs => ADAPTER_SPECS.without_increment,
     # We don't want Riak warnings in tests
     :preamble => "require 'riak'\n\nRiak.disable_list_keys_warnings = true\n\n"
   },
   'adapter_sdbm' => {
     :build => 'Moneta::Adapters::SDBM.new(:file => File.join(make_tempdir, "adapter_sdbm"))',
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_leveldb' => {
     :build => 'Moneta::Adapters::LevelDB.new(:dir => File.join(make_tempdir, "adapter_leveldb"))',
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_sequel' => {
     :build => 'Moneta::Adapters::Sequel.new(:db => (defined?(JRUBY_VERSION) ? "jdbc:sqlite:" : "sqlite:") + File.join(make_tempdir, "adapter_sequel"))',
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_sqlite' => {
     :build => 'Moneta::Adapters::Sqlite.new(:file => File.join(make_tempdir, "adapter_sqlite"))',
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_tokyocabinet_bdb' => {
     :build => 'Moneta::Adapters::TokyoCabinet.new(:file => File.join(make_tempdir, "adapter_tokyocabinet_bdb"), :type => :bdb)',
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_tokyocabinet_hdb' => {
     :build => 'Moneta::Adapters::TokyoCabinet.new(:file => File.join(make_tempdir, "adapter_tokyocabinet_hdb"), :type => :hdb)',
-    :specs => ADAPTER_INCR_SPECS
+    :specs => ADAPTER_SPECS
   },
   'adapter_yaml' => {
     :build => 'Moneta::Adapters::YAML.new(:file => File.join(make_tempdir, "adapter_yaml"))',
-    :specs => PSTORE_SPECS
+    :specs => STANDARD_SPECS.simplevalues_only.simplekeys_only.without_transform
   },
   'optionmerger' => {
     :store => :Memory,
-    :specs => [],
+    :specs => Specs.new([]),
     :tests => %{
 it '#with should return OptionMerger' do
   options = {:optionname => :optionvalue}
@@ -1048,13 +1110,18 @@ end}
 SPECS = {}
 
 KEYS = {
+  'Nil' => [0, 'nil'],
+  'Integer' => [-10, 42],
+  'Boolean' => [true, false],
   'String' => ['strkey1', 'strkey2'].map(&:inspect),
   'Object' => ['Value.new(:objkey1)', 'Value.new(:objkey2)'],
   'Hash' => [{'hashkey1' => 'hashkey2'}, {'hashkey3' => 'hashkey4'}].map(&:inspect)
 }
 
 VALUES = {
-  'Boolean' => [true, false],
+  'Nil' => [0, 'nil'],
+  'Integer' => [41, -12],
+  'Boolean' => [false, true],
   'String' => ['strval1', 'strval2'].map(&:inspect),
   'Hash' => [{'hashval1' => ['array1', 1]}, {'hashval3' => ['array2', {'hashval4' => 42}]}].map(&:inspect),
   'Object' => ['Value.new(:objval1)', 'Value.new(:objval2)'],
@@ -1066,19 +1133,27 @@ KEYS.each do |key_type, (key1,key2)|
     code = %{it "reads from keys that are #{key_type}s like a Hash" do
   store[#{key1}].should == nil
   store.load(#{key1}).should == nil
+
+  store[#{key2}].should == nil
+  store.load(#{key2}).should == nil
 end
 
 it "guarantees that the same #{val_type} value is returned when setting a #{key_type} key" do
   value = #{val1}
   (store[#{key1}] = value).should equal(value)
+
+  value = #{val2}
+  (store[#{key2}] = value).should equal(value)
 end
 
 it "returns false from key? if a #{key_type} key is not available" do
   store.key?(#{key1}).should == false
+  store.key?(#{key2}).should == false
 end
 
 it "returns nil from delete if an element for a #{key_type} key does not exist" do
   store.delete(#{key1}).should == nil
+  store.delete(#{key2}).should == nil
 end
 
 it "removes all #{key_type} keys from the store with clear" do
@@ -1091,6 +1166,7 @@ end
 
 it "fetches a #{key_type} key with a default value with fetch, if the key is not available" do
   store.fetch(#{key1}, #{val1}).should == #{val1}
+  store.fetch(#{key2}, #{val2}).should == #{val2}
 end
 
 it "fetches a #{key_type} key with a block with fetch, if the key is not available" do
@@ -1100,6 +1176,13 @@ it "fetches a #{key_type} key with a block with fetch, if the key is not availab
     k.should equal(key)
     value
   end.should equal(value)
+
+  key = #{key2}
+  value = #{val2}
+  store.fetch(key) do |k|
+    k.should equal(key)
+    value
+  end.should equal(value)
 end
 
 it 'should accept options' do
@@ -1117,6 +1200,10 @@ end}
   store[#{key1}] = #{val1}
   store[#{key1}].should == #{val1}
   store.load(#{key1}).should == #{val1}
+
+  store[#{key2}] = #{val2}
+  store[#{key2}].should == #{val2}
+  store.load(#{key2}).should == #{val2}
 end
 
 it "returns true from key? if a #{key_type} key is available" do
@@ -1131,6 +1218,11 @@ it "stores #{val_type} values with #{key_type} keys with #store" do
   store.store(#{key1}, value).should equal(value)
   store[#{key1}].should == #{val1}
   store.load(#{key1}).should == #{val1}
+
+  value = #{val2}
+  store.store(#{key2}, value).should equal(value)
+  store[#{key2}].should == #{val2}
+  store.load(#{key2}).should == #{val2}
 end
 
 it "stores #{key_type} after clear" do
@@ -1146,6 +1238,10 @@ it "removes and returns a #{val_type} element with a #{key_type} key from the ba
   store[#{key1}] = #{val1}
   store.delete(#{key1}).should == #{val1}
   store.key?(#{key1}).should == false
+
+  store[#{key2}] = #{val2}
+  store.delete(#{key2}).should == #{val2}
+  store.key?(#{key2}).should == false
 end
 
 it "overwrites existing #{val_type} values with #{key_type}" do
@@ -1155,166 +1251,235 @@ it "overwrites existing #{val_type} values with #{key_type}" do
   store[#{key1}].should == #{val2}
 end
 
-it "does not run the block if the #{key_type} key is available" do
-  store[#{key1}] = #{val1}
-  unaltered = "unaltered"
-  store.fetch(#{key1}) { unaltered = "altered" }
-  unaltered.should == "unaltered"
-end
-
 it "fetches a #{key_type} key with a default value with fetch, if the key is available" do
   store[#{key1}] = #{val1}
   store.fetch(#{key1}, #{val2}).should == #{val1}
 end}
+
+    if val_type != 'Nil'
+      code << %{
+it "does not run the block if the #{key_type} key is available" do
+  store[#{key1}] = #{val1}
+  unaltered = 'unaltered'
+  store.fetch(#{key1}) { unaltered = 'altered' }
+  unaltered.should == 'unaltered'
+
+  store[#{key2}] = #{val2}
+  unaltered = 'unaltered'
+  store.fetch(#{key2}) { unaltered = 'altered' }
+  unaltered.should == 'unaltered'
+end}
+    end
+
     SPECS["store_#{key_type.downcase}key_#{val_type.downcase}value"] = code
 
     code = %{it "guarantees that a different #{val_type} value is retrieved from the #{key_type} key" do
   value = #{val1}
   store[#{key1}] = #{val1}
   store[#{key1}].should_not be_equal(#{val1})
+
+  value = #{val2}
+  store[#{key2}] = #{val2}
+  store[#{key2}].should_not be_equal(#{val2})
 end}
-    if val_type != 'Boolean'
+    if val_type != 'Boolean' && val_type != 'Nil' && val_type != 'Integer'
       SPECS["returndifferent_#{key_type.downcase}key_#{val_type.downcase}value"] = code
     end
 
-    code = %{it 'should support expires on store and #[]' do
-  store.store(#{key1}, #{val1}, :expires => 2)
+    code = %{it "persists #{val_type} values with #{key_type} keys" do
+  store[#{key1}] = #{val1}
+  store[#{key2}] = #{val2}
+  store.close
+  @store = nil
+
   store[#{key1}].should == #{val1}
+  store[#{key2}].should == #{val2}
+end}
+    SPECS["persist_#{key_type.downcase}key_#{val_type.downcase}value"] = code
+  end
+end
+
+SPECS['not_persist'] = %{it "does not persist values" do
+  store['key'] = 'val'
+  store.close
+  @store = nil
+
+  store['key'].should be_nil
+end}
+
+SPECS['expires'] = %{it 'should support expires on store and #[]' do
+  store.store('key1', 'val1', :expires => 2)
+  store['key1'].should == 'val1'
   sleep 1
-  store[#{key1}].should == #{val1}
+  store['key1'].should == 'val1'
   sleep 2
-  store[#{key1}].should == nil
+  store['key1'].should == nil
 end
 
 it 'should support expires on store and load' do
-  store.store(#{key1}, #{val1}, :expires => 2)
-  store.load(#{key1}).should == #{val1}
+  store.store('key1', 'val1', :expires => 2)
+  store.load('key1').should == 'val1'
   sleep 1
-  store.load(#{key1}).should == #{val1}
+  store.load('key1').should == 'val1'
   sleep 2
-  store.load(#{key1}).should == nil
+  store.load('key1').should == nil
 end
 
 it 'should support expires on store and key?' do
-  store.store(#{key1}, #{val1}, :expires => 2)
-  store.key?(#{key1}).should == true
+  store.store('key1', 'val1', :expires => 2)
+  store.key?('key1').should == true
   sleep 1
-  store.key?(#{key1}).should == true
+  store.key?('key1').should == true
   sleep 2
-  store.key?(#{key1}).should == false
+  store.key?('key1').should == false
 end
 
 it 'should support updating the expiration time in load' do
-  store.store(#{key2}, #{val2}, :expires => 2)
-  store[#{key2}].should == #{val2}
+  store.store('key2', 'val2', :expires => 2)
+  store['key2'].should == 'val2'
   sleep 1
-  store.load(#{key2}, :expires => 3).should == #{val2}
-  store[#{key2}].should == #{val2}
+  store.load('key2', :expires => 3).should == 'val2'
+  store['key2'].should == 'val2'
   sleep 1
-  store[#{key2}].should == #{val2}
+  store['key2'].should == 'val2'
   sleep 3
-  store[#{key2}].should == nil
+  store['key2'].should == nil
 end
 
 it 'should support updating the expiration time in key?' do
-  store.store(#{key2}, #{val2}, :expires => 2)
-  store[#{key2}].should == #{val2}
+  store.store('key2', 'val2', :expires => 2)
+  store['key2'].should == 'val2'
   sleep 1
-  store.key?(#{key2}, :expires => 3).should be_true
-  store[#{key2}].should == #{val2}
+  store.key?('key2', :expires => 3).should be_true
+  store['key2'].should == 'val2'
   sleep 1
-  store[#{key2}].should == #{val2}
+  store['key2'].should == 'val2'
   sleep 3
-  store[#{key2}].should == nil
+  store['key2'].should == nil
 end
 
 it 'should support updating the expiration time in fetch' do
-  store.store(#{key1}, #{val1}, :expires => 2)
-  store[#{key1}].should == #{val1}
+  store.store('key1', 'val1', :expires => 2)
+  store['key1'].should == 'val1'
   sleep 1
-  store.fetch(#{key1}, nil, :expires => 3).should == #{val1}
-  store[#{key1}].should == #{val1}
+  store.fetch('key1', nil, :expires => 3).should == 'val1'
+  store['key1'].should == 'val1'
   sleep 1
-  store[#{key1}].should == #{val1}
+  store['key1'].should == 'val1'
   sleep 3
-  store[#{key1}].should == nil
+  store['key1'].should == nil
 end
 
 it 'should respect expires in delete' do
-  store.store(#{key2}, #{val2}, :expires => 2)
-  store[#{key2}].should == #{val2}
+  store.store('key2', 'val2', :expires => 2)
+  store['key2'].should == 'val2'
   sleep 1
-  store[#{key2}].should == #{val2}
+  store['key2'].should == 'val2'
   sleep 2
-  store.delete(#{key2}).should == nil
+  store.delete('key2').should == nil
 end
 
 it 'should support the #expires syntactic sugar' do
   store['longlive_key'] = 'longlive_value'
-  store.expires(2).store(#{key2}, #{val2})
-  store[#{key2}].should == #{val2}
+  store.expires(2).store('key2', 'val2')
+  store['key2'].should == 'val2'
   sleep 1
-  store[#{key2}].should == #{val2}
+  store['key2'].should == 'val2'
   sleep 2
-  store.delete(#{key2}).should == nil
+  store.delete('key2').should == nil
   store['longlive_key'].should == 'longlive_value'
 end}
-    SPECS["expires_#{key_type.downcase}key_#{val_type.downcase}value"] = code
 
-  end
+SPECS['not_increment'] = %{it 'should not support #increment' do
+  expect do
+    store.increment('inckey')
+  end.to raise_error(NotImplementedError)
 end
 
-SPECS['not_increment'] = %{it 'should not support increment' do
+it 'should not support #decrement' do
   expect do
     store.increment('inckey')
   end.to raise_error(NotImplementedError)
 end}
 
-SPECS['increment'] = %{it 'should initialize in increment with 1' do
+SPECS['increment'] = %{it 'should initialize in #increment with 1' do
   store.key?('inckey').should be_false
   store.increment('inckey').should == 1
   store.key?('inckey').should be_true
   store.raw['inckey'].should == '1'
   store.raw.load('inckey').should == '1'
   store.load('inckey', :raw => true).should == '1'
-  store['inckey'].should == '1'
+
+  # WARNING: Undefined behaviour!
+  result = safe_load_value(store.raw['inckey'])
+  store['inckey'].should == result
 
   store.delete('inckey', :raw => true).should == '1'
   store.key?('inckey').should be_false
 end
 
-it 'should initialize in increment with higher value' do
+it 'should initialize in #increment with higher value' do
   store.increment('inckey', 42).should == 42
   store.key?('inckey').should be_true
   store.raw['inckey'].should == '42'
-  store['inckey'].should == '42'
+
+  # WARNING: Undefined behaviour!
+  result = safe_load_value(store.raw['inckey'])
+  store['inckey'].should == result
+
   store.delete('inckey', :raw => true).should == '42'
 end
 
-it 'should initialize in increment with 0' do
+it 'should initialize in #increment with 0' do
   store.increment('inckey', 0).should == 0
   store.key?('inckey').should be_true
   store.raw['inckey'].should == '0'
-  store['inckey'].should == '0'
+
+  # WARNING: Undefined behaviour!
+  result = safe_load_value(store.raw['inckey'])
+  store['inckey'].should == result
+
   store.delete('inckey', :raw => true).should == '0'
 end
 
+it 'should support deleting integer value' do
+  store.increment('inckey').should == 1
+
+  # WARNING: Undefined behaviour!
+  result = safe_load_value(store.raw['inckey'])
+  store.delete('inckey').should == result
+
+  store.key?('inckey').should be_false
+end
+
+it 'should initialize in #decrement with 0' do
+  store.decrement('inckey', 0).should == 0
+  store.raw['inckey'].should == '0'
+end
+
+it 'should initialize in #decrement with negative value' do
+  store.decrement('inckey', -42).should == 42
+  store.raw['inckey'].should == '42'
+end
+
 it 'should support incrementing existing value by value' do
   store.increment('inckey').should == 1
   store.increment('inckey', 42).should == 43
   store.raw['inckey'].should == '43'
 end
 
-it 'should support incrementing existing value by 0' do
+it 'should support decrementing existing value by value' do
   store.increment('inckey').should == 1
-  store.increment('inckey', 0).should == 1
-  store.raw['inckey'].should == '1'
+  store.decrement('inckey').should == 0
+  store.increment('inckey', 42).should == 42
+  store.decrement('inckey', 2).should == 40
+  store.raw['inckey'].should == '40'
 end
 
-it 'should support deleting integer value' do
+it 'should support incrementing existing value by 0' do
   store.increment('inckey').should == 1
-  store.delete('inckey').should == '1'
-  store.key?('inckey').should be_false
+  store.increment('inckey', 0).should == 1
+  store.raw['inckey'].should == '1'
 end
 
 it 'should support decrementing existing value' do
@@ -1331,11 +1496,18 @@ it 'interpret raw value as integer' do
   store.raw['inckey'].should == '43'
 end
 
-it 'should raise error on non integer value' do
+it 'should raise error in #increment on non integer value' do
   store['strkey'] = 'value'
   expect do
     store.increment('strkey')
   end.to raise_error
+end
+
+it 'should raise error in #decrement on non integer value' do
+  store['strkey'] = 'value'
+  expect do
+    store.decrement('strkey')
+  end.to raise_error
 end}
 
 SPECS['marshallable_key']  = %{it 'refuses to #[] from keys that cannot be marshalled' do
@@ -1446,16 +1618,15 @@ File.open(File.join(File.dirname(__FILE__), 'monetaspecs.rb'), 'w') {|out| out <
 TESTS.each do |name, options|
   build = options.delete(:build)
   store = options.delete(:store)
-  key = [options.delete(:key) || %w(Object String Hash)].flatten
-  value = [options.delete(:value) || %w(Object String Hash Boolean)].flatten
 
   load_value = options.delete(:load_value) || 'Marshal.load(value)'
 
   specs_code = []
-  options.delete(:specs).each do |s|
+  specs = options.delete(:specs)
+  specs.specs.sort.each do |s|
     specs_code << "  it_should_behave_like '#{s}'" if SPECS[s.to_s]
-    key.each do |k|
-      value.each do |v|
+    specs.key.each do |k|
+      specs.value.each do |v|
         x = "#{s}_#{k.downcase}key_#{v.downcase}value"
         specs_code << "  it_should_behave_like '#{x}'" if SPECS[x]
       end