moneta 0.7.20 → 0.8.0

data/lib/moneta/transformer/config.rb

@@ -2,47 +2,45 @@ module Moneta
   class Transformer
     # Available key/value transformers
     TRANSFORMER = {
-      # 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)',         '::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'            ],
-      :php      => [ :serialize, '::PHP.unserialize(%s)',        '::PHP.serialize(%s)',           'php_serialize' ],
-      :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'         ],
-      :lz4      => [ :compress,  '::LZ4.uncompress(%s)',         '::LZ4.compress(%s)',              'lz4-ruby'      ],
-      :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'          ],
-      :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)'                                ],
-      :hex      => [ :encode,    "[%s].pack('H*')",              "%s.unpack('H*').first"                            ],
-      :qp       => [ :encode,    "%s.unpack('M').first",         "[%s].pack('M')"                                   ],
-      :uuencode => [ :encode,    "%s.unpack('u').first",         "[%s].pack('u')"                                   ],
-      :hmac     => [ :hmac,      'Helper.hmacverify(%s, options[:secret] || @secret)',
+      # 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)',         '::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'            ],
+      php:      [ :serialize, '::PHP.unserialize(%s)',        '::PHP.serialize(%s)',           'php_serialize' ],
+      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'         ],
+      lz4:      [ :compress,  '::LZ4.uncompress(%s)',         '::LZ4.compress(%s)',              'lz4-ruby'      ],
+      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'          ],
+      base64:   [ :encode,    "%s.unpack('m0').first",        "[%s].pack('m0')"                                  ],
+      escape:   [ :encode,    'Helper.unescape(%s)',          'Helper.escape(%s)'                                ],
+      hex:      [ :encode,    "[%s].pack('H*')",              "%s.unpack('H*').first"                            ],
+      qp:       [ :encode,    "%s.unpack('M').first",         "[%s].pack('M')"                                   ],
+      uuencode: [ :encode,    "%s.unpack('u').first",         "[%s].pack('u')"                                   ],
+      hmac:     [ :hmac,      'Helper.hmacverify(%s, options[:secret] || @secret)',
                                  'Helper.hmacsign(%s, options[:secret] || @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'   ],
-      :city32   => [ :digest,    nil,                            '::CityHash.hash32(%s).to_s(16)',  'cityhash'      ],
-      :city64   => [ :digest,    nil,                            '::CityHash.hash64(%s).to_s(16)',  'cityhash'      ],
-      :city128  => [ :digest,    nil,                            '::CityHash.hash128(%s).to_s(16)', 'cityhash'      ],
-      :prefix   => [ :prefix,    nil,                            '(options[:prefix] || @prefix)+%s'                 ],
-      :spread   => [ :spread,    nil,                            'Helper.spread(%s)'                                ],
-      :to_s     => [ :string,    nil,                            '%s.to_s'                                          ],
-      :inspect  => [ :string,    nil,                            '%s.inspect'                                       ],
+      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'   ],
+      city32:   [ :digest,    nil,                            '::CityHash.hash32(%s).to_s(16)',  'cityhash'      ],
+      city64:   [ :digest,    nil,                            '::CityHash.hash64(%s).to_s(16)',  'cityhash'      ],
+      city128:  [ :digest,    nil,                            '::CityHash.hash128(%s).to_s(16)', 'cityhash'      ],
+      prefix:   [ :prefix,    nil,                            '(options[:prefix] || @prefix)+%s'                 ],
+      spread:   [ :spread,    nil,                            'Helper.spread(%s)'                                ],
+      to_s:     [ :string,    nil,                            '%s.to_s'                                          ],
+      inspect:  [ :string,    nil,                            '%s.inspect'                                       ],
     }
 
     # Allowed value transformers (Read it like a regular expression!)

data/lib/moneta/version.rb

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

data/lib/rack/cache/moneta.rb

@@ -82,7 +82,7 @@ module Rack
         def write(body, ttl = 0)
           buf = StringIO.new
           key, size = slurp(body) { |part| buf.write(part) }
-          @cache.store(key, buf.string, ttl == 0 ? {} : {:expires => ttl})
+          @cache.store(key, buf.string, ttl == 0 ? {} : {expires: ttl})
           [key, size]
         end
 

data/lib/rack/moneta_cookies.rb

@@ -14,12 +14,12 @@ module Rack
   #
   # @example config.ru
   #   # Give it some options
-  #   use Rack::MonetaCookies, :domain => 'example.com', :path => '/path'
+  #   use Rack::MonetaCookies, domain: 'example.com', path: '/path'
   #
   # @example config.ru
   #   # Pass it a block like the one passed to Moneta.build
   #   use Rack::MonetaCookies do
-  #     use :Transformer, :key => :prefix, :prefix => 'moneta.'
+  #     use :Transformer, key: :prefix, prefix: 'moneta.'
   #     adapter :Cookie
   #   end
   #

data/lib/rack/moneta_rest.rb

@@ -11,7 +11,7 @@ module Rack
   # @example config.ru
   #   # Pass it a block like the one passed to Moneta.build
   #   run Rack::MonetaRest.new do
-  #     use :Transformer, :value => :zlib
+  #     use :Transformer, value: :zlib
   #     adapter :Memory
   #   end
   #

data/lib/rack/moneta_store.rb

@@ -2,11 +2,11 @@ require 'moneta'
 
 module Rack
   # A Rack middleware that inserts a Moneta store in the environment
-  # and supports per-request caching via the the option `:cache => true`.
+  # and supports per-request caching via the the option `cache: true`.
   #
   # @example config.ru
   #   # Add Rack::MonetaStore somewhere in your rack stack
-  #   use Rack::MonetaStore, :Memory, :cache => true
+  #   use Rack::MonetaStore, :Memory, cache: true
   #
   #   run lambda { |env|
   #     env['rack.moneta_store'] # is a Moneta store with per-request caching
@@ -15,7 +15,7 @@ module Rack
   # @example config.ru
   #   # Pass it a block like the one passed to Moneta.build
   #   use Rack::MonetaStore do
-  #     use :Transformer, :value => :zlib
+  #     use :Transformer, value: :zlib
   #     adapter :Cookie
   #   end
   #
@@ -38,7 +38,7 @@ module Rack
     end
 
     def call(env)
-      env['rack.moneta_store'] = @cache ? ::Moneta::Cache.new(:cache => ::Moneta::Adapters::Memory.new, :adapter => @store) : @store
+      env['rack.moneta_store'] = @cache ? ::Moneta::Cache.new(cache: ::Moneta::Adapters::Memory.new, adapter: @store) : @store
       @app.call(env)
     end
   end

data/lib/rack/session/moneta.rb

@@ -4,6 +4,18 @@ require 'thread'
 
 module Rack
   module Session
+    # Rack::Session::Moneta stores sessions in a Moneta store.
+    #
+    # Example:
+    #
+    # use Rack::Session::Moneta, key: 'rack.session',
+    # domain: 'foo.com',
+    # path: '/',
+    # expire_after: 2592000,
+    # store: Moneta.new(...)
+    #
+    # You can use all options supported by `Rack::Session::Abstract::ID`.
+    #
     # @api public
     class Moneta < Abstract::ID
       attr_reader :mutex, :pool
@@ -15,7 +27,7 @@ module Rack
           @pool = ::Moneta.build(&block)
         else
           raise ArgumentError, 'Block or option :store is required' unless @pool = options[:store]
-          @pool = ::Moneta.new(@pool, :expires => true) if Symbol === @pool
+          @pool = ::Moneta.new(@pool, expires: true) if Symbol === @pool
         end
         @pool = ::Moneta::WeakCreate.new(@pool) unless @pool.supports?(:create)
         @mutex = ::Mutex.new
@@ -43,7 +55,7 @@ module Rack
       def set_session(env, session_id, new_session, options)
         with_lock(env) do
           @pool.store(session_id, new_session,
-                      options[:expire_after] ? { :expires => options[:expire_after] } : {})
+                      options[:expire_after] ? { expires: options[:expire_after] } : {})
           session_id
         end
       end

data/moneta.gemspec

@@ -17,4 +17,5 @@ Gem::Specification.new do |s|
   s.licenses         = %w(MIT)
   s.require_paths    = %w(lib)
   s.summary          = %{A unified interface to key/value stores, including Redis, Memcached, TokyoCabinet, ActiveRecord and many more}
+  s.required_ruby_version = '>= 1.9'
 end

data/script/benchmarks

@@ -31,103 +31,104 @@ class MonetaBenchmarks
 
   STORES = {
     # SDBM accepts only very short key/value pairs (1k for both)
-    # :SDBM => { :file => "#{DIR}/sdbm" },
+    # SDBM: { file: "#{DIR}/sdbm" },
     # YAML is too slow
-    # :YAML => { :file => "#{DIR}/yaml" },
-    :ActiveRecord => { :table => 'activerecord', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :username => 'root', :database => 'moneta' } },
-    :Cassandra => {},
-    :Client => {},
-    :Couch => {},
-    :DBM => { :file => "#{DIR}/dbm" },
-    :DataMapper => { :setup => 'mysql://root:@localhost/moneta', :table => 'datamapper' },
-    :Daybreak => { :file => "#{DIR}/daybreak" },
-    :File => { :dir => "#{DIR}/file" },
-    :GDBM => { :file => "#{DIR}/gdbm" },
-    :HBase => {},
-    :HashFile => { :dir => "#{DIR}/hashfile" },
-    :KyotoCabinet => { :file => "#{DIR}/kyotocabinet.kch" },
-    :LRUHash => {},
-    :LevelDB => { :dir => "#{DIR}/leveldb" },
-    :LocalMemCache => { :file => "#{DIR}/lmc" },
-    :LMDB => { :dir => "#{DIR}/lmdb" },
-    :MemcachedDalli => {},
-    :MemcachedNative => {},
-    :Memory => {},
-    :Mongo => {},
-    :PStore => { :file => "#{DIR}/pstore" },
-    :Redis => {},
-    :RestClient => { :url => 'http://localhost:8808/' },
-    :Riak => {},
-    :Sequel => { :table => 'sequel',
-      :db => (defined?(JRUBY_VERSION) ?
+    # YAML: { file: "#{DIR}/yaml" },
+    ActiveRecord: { table: 'activerecord', connection: { adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), username: 'root', database: 'moneta' } },
+    Cassandra: {},
+    Client: {},
+    Couch: {},
+    DBM: { file: "#{DIR}/dbm" },
+    DataMapper: { setup: 'mysql://root:@localhost/moneta', table: 'datamapper' },
+    Daybreak: { file: "#{DIR}/daybreak" },
+    File: { dir: "#{DIR}/file" },
+    GDBM: { file: "#{DIR}/gdbm" },
+    HBase: {},
+    HashFile: { dir: "#{DIR}/hashfile" },
+    KyotoCabinet: { file: "#{DIR}/kyotocabinet.kch" },
+    LRUHash: {},
+    LevelDB: { dir: "#{DIR}/leveldb" },
+    LocalMemCache: { file: "#{DIR}/lmc" },
+    LMDB: { dir: "#{DIR}/lmdb" },
+    MemcachedDalli: {},
+    MemcachedNative: {},
+    Memory: {},
+    MongoMoped: {},
+    MongoOfficial: {},
+    PStore: { file: "#{DIR}/pstore" },
+    Redis: {},
+    RestClient: { url: 'http://localhost:8808/' },
+    Riak: {},
+    Sequel: { table: 'sequel',
+      db: (defined?(JRUBY_VERSION) ?
               'jdbc:mysql://localhost/moneta?user=root' :
               'mysql2://root:@localhost/moneta') },
-    :Sqlite => { :file => ':memory:' },
-    :TDB => { :file => "#{DIR}/tdb" },
-    :TokyoCabinet => { :file => "#{DIR}/tokyocabinet" },
-    :TokyoTyrant => {},
+    Sqlite: { file: ':memory:' },
+    TDB: { file: "#{DIR}/tdb" },
+    TokyoCabinet: { file: "#{DIR}/tokyocabinet" },
+    TokyoTyrant: {},
   }
 
   CONFIGS = {
-    :uniform_small => {
-      :runs => 3,
-      :keys => 1000,
-      :min_key_len => 1,
-      :max_key_len => 32,
-      :key_dist => :uniform,
-      :min_val_len => 0,
-      :max_val_len => 256,
-      :val_dist => :uniform
+    uniform_small: {
+      runs: 3,
+      keys: 1000,
+      min_key_len: 1,
+      max_key_len: 32,
+      key_dist: :uniform,
+      min_val_len: 0,
+      max_val_len: 256,
+      val_dist: :uniform
     },
-    :uniform_medium => {
-      :runs => 3,
-      :keys => 1000,
-      :min_key_len => 3,
-      :max_key_len => 128,
-      :key_dist => :uniform,
-      :min_val_len => 0,
-      :max_val_len => 1024,
-      :val_dist => :uniform
+    uniform_medium: {
+      runs: 3,
+      keys: 1000,
+      min_key_len: 3,
+      max_key_len: 128,
+      key_dist: :uniform,
+      min_val_len: 0,
+      max_val_len: 1024,
+      val_dist: :uniform
     },
-    :uniform_large => {
-      :runs => 3,
-      :keys => 100,
-      :min_key_len => 3,
-      :max_key_len => 128,
-      :key_dist => :uniform,
-      :min_val_len => 0,
-      :max_val_len => 10240,
-      :val_dist => :uniform
+    uniform_large: {
+      runs: 3,
+      keys: 100,
+      min_key_len: 3,
+      max_key_len: 128,
+      key_dist: :uniform,
+      min_val_len: 0,
+      max_val_len: 10240,
+      val_dist: :uniform
     },
-    :normal_small => {
-      :runs => 3,
-      :keys => 1000,
-      :min_key_len => 1,
-      :max_key_len => 32,
-      :key_dist => :normal,
-      :min_val_len => 0,
-      :max_val_len => 256,
-      :val_dist => :normal
+    normal_small: {
+      runs: 3,
+      keys: 1000,
+      min_key_len: 1,
+      max_key_len: 32,
+      key_dist: :normal,
+      min_val_len: 0,
+      max_val_len: 256,
+      val_dist: :normal
     },
-    :normal_medium => {
-      :runs => 3,
-      :keys => 1000,
-      :min_key_len => 3,
-      :max_key_len => 128,
-      :key_dist => :normal,
-      :min_val_len => 0,
-      :max_val_len => 1024,
-      :val_dist => :normal
+    normal_medium: {
+      runs: 3,
+      keys: 1000,
+      min_key_len: 3,
+      max_key_len: 128,
+      key_dist: :normal,
+      min_val_len: 0,
+      max_val_len: 1024,
+      val_dist: :normal
     },
-    :normal_large => {
-      :runs => 3,
-      :keys => 100,
-      :min_key_len => 3,
-      :max_key_len => 128,
-      :key_dist => :normal,
-      :min_val_len => 0,
-      :max_val_len => 10240,
-      :val_dist => :normal
+    normal_large: {
+      runs: 3,
+      keys: 100,
+      min_key_len: 3,
+      max_key_len: 128,
+      key_dist: :normal,
+      min_val_len: 0,
+      max_val_len: 10240,
+      val_dist: :normal
     },
   }
 
@@ -206,13 +207,13 @@ class MonetaBenchmarks
           def log(level, data); end
         end
 
-        Rack::Server.start(:app => Rack::Builder.app do
+        Rack::Server.start(app: Rack::Builder.app do
                              use Rack::Lint
-                             run Rack::MonetaRest.new(:store => :Memory)
+                             run Rack::MonetaRest.new(store: :Memory)
                            end,
-                           :environment => :none,
-                           :server => :webrick,
-                           :Port => 8808)
+                           environment: :none,
+                           server: :webrick,
+                           Port: 8808)
       rescue Exception => ex
         puts "\e[31mFailed to start Rack server - #{ex.message}\e[0m"
       end
@@ -227,7 +228,7 @@ class MonetaBenchmarks
         if name == :DataMapper
           begin
             require 'dm-core'
-            DataMapper.setup(:default, :adapter => :in_memory)
+            DataMapper.setup(:default, adapter: :in_memory)
           rescue LoadError => ex
             puts "\e[31mFailed to load DataMapper - #{ex.message}\e[0m"
           end
@@ -298,10 +299,10 @@ class MonetaBenchmarks
     store = Moneta.new(name, options.dup)
 
     @stats[name] = {
-      :write => [],
-      :read => [],
-      :sum => [],
-      :error => []
+      write: [],
+      read: [],
+      sum: [],
+      error: []
     }
 
     %w(Rehearse Measure).each do |type|

data/script/generate-specs

@@ -19,43 +19,43 @@ class Specs
   end
 
   def new(options)
-    Specs.new({:specs => specs, :key => key, :value => value}.merge(options))
+    Specs.new({specs: specs, key: key, value: value}.merge(options))
   end
 
   def without_path
-    new(:key => key - %w(path))
+    new(key: key - %w(path))
   end
 
   def stringvalues_only
-    new(:value => %w(string))
+    new(value: %w(string))
   end
 
   def simplekeys_only
-    new(:key => %w(string hash integer))
+    new(key: %w(string hash integer))
   end
 
   def simplevalues_only
-    new(:value => %w(string hash integer))
+    new(value: %w(string hash integer))
   end
 
   def without_increment
-    new(:specs => specs - [:increment, :concurrent_increment] + [:not_increment])
+    new(specs: specs - [:increment, :concurrent_increment] + [:not_increment])
   end
 
   def without_large
-    new(:specs => specs - [:store_large])
+    new(specs: specs - [:store_large])
   end
 
   def without_concurrent
-    new(:specs => specs - [:concurrent_increment, :concurrent_create])
+    new(specs: specs - [:concurrent_increment, :concurrent_create])
   end
 
   def without_persist
-    new(:specs => specs - [:persist, :multiprocess, :concurrent_increment, :concurrent_create] + [:not_persist])
+    new(specs: specs - [:persist, :multiprocess, :concurrent_increment, :concurrent_create] + [:not_persist])
   end
 
   def without_multiprocess
-    new(:specs => specs - [:multiprocess, :concurrent_increment, :concurrent_create])
+    new(specs: specs - [:multiprocess, :concurrent_increment, :concurrent_create])
   end
 
   def with_expires
@@ -66,60 +66,60 @@ class Specs
     end
     a << :create_expires if a.include?(:create)
     a << :expires
-    new(:specs => a)
+    new(specs: a)
   end
 
   def with_native_expires
     a = specs.dup
     a << :create_expires if a.include?(:create)
-    new(:specs => a + [:expires])
+    new(specs: a + [:expires])
   end
 
   def without_marshallable
-    new(:specs => specs - [:marshallable_value, :marshallable_key])
+    new(specs: specs - [:marshallable_value, :marshallable_key])
   end
 
   def without_transform
-    new(:specs => specs - [:marshallable_value, :marshallable_key, :transform_value])
+    new(specs: specs - [:marshallable_value, :marshallable_key, :transform_value])
   end
 
   def returnsame
-    new(:specs => specs - [:returndifferent] + [:returnsame])
+    new(specs: specs - [:returndifferent] + [:returnsame])
   end
 
   def without_marshallable_key
-    new(:specs => specs - [:marshallable_key])
+    new(specs: specs - [:marshallable_key])
   end
 
   def without_marshallable_value
-    new(:specs => specs - [:marshallable_value])
+    new(specs: specs - [:marshallable_value])
   end
 
   def without_store
-    new(:specs => specs - [:store, :store_large, :transform_value, :marshallable_value])
+    new(specs: specs - [:store, :store_large, :transform_value, :marshallable_value])
   end
 
   def with_default_expires
-    new(:specs => specs + [:default_expires])
+    new(specs: specs + [:default_expires])
   end
 
   def without_create
-    new(:specs => specs - [:create, :concurrent_create, :create_expires] + [:not_create])
+    new(specs: specs - [:create, :concurrent_create, :create_expires] + [:not_create])
   end
 end
 
-ADAPTER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :increment, :concurrent_increment, :concurrent_create, :persist, :multiprocess, :create, :features, :store_large], :key => %w(string path), :value => %w(string path))
-STANDARD_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :concurrent_increment, :concurrent_create, :persist, :multiprocess, :create, :features, :store_large])
-TRANSFORMER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :transform_value, :increment, :create, :features, :store_large])
+ADAPTER_SPECS = Specs.new(specs: [:null, :store, :returndifferent, :increment, :concurrent_increment, :concurrent_create, :persist, :multiprocess, :create, :features, :store_large], key: %w(string path), value: %w(string path))
+STANDARD_SPECS = Specs.new(specs: [:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :concurrent_increment, :concurrent_create, :persist, :multiprocess, :create, :features, :store_large])
+TRANSFORMER_SPECS = Specs.new(specs: [:null, :store, :returndifferent, :transform_value, :increment, :create, :features, :store_large])
 
 header = "# coding: binary\n# Generated by #{File.basename(__FILE__)}\n"
 
 TESTS = {
   'standard_client_tcp' => {
-    :preamble => "start_server(Moneta::Adapters::Memory.new)\n",
-    :store => :Client,
-    :specs => STANDARD_SPECS,
-    :tests => %{
+    preamble: "start_server(Moneta::Adapters::Memory.new)\n",
+    store: :Client,
+    specs: STANDARD_SPECS,
+    tests: %{
 it 'supports multiple clients' do
   client = Moneta.new(:Client)
   client['shared_key'] = 'shared_val'
@@ -137,424 +137,434 @@ end
 }
   },
   'standard_client_unix' => {
-    :preamble => "start_server(Moneta::Adapters::Memory.new, :socket => File.join(make_tempdir, 'standard_client_unix'))\n",
-    :store => :Client,
-    :options => ":socket => File.join(make_tempdir, 'standard_client_unix')",
-    :specs => STANDARD_SPECS
+    preamble: "start_server(Moneta::Adapters::Memory.new, socket: File.join(make_tempdir, 'standard_client_unix'))\n",
+    store: :Client,
+    options: "socket: File.join(make_tempdir, 'standard_client_unix')",
+    specs: STANDARD_SPECS
   },
   'standard_restclient' => {
-    :preamble => "start_restserver\n",
-    :store => :RestClient,
-    :options => ":url => 'http://localhost:8808/moneta/'",
-    :specs => STANDARD_SPECS.without_increment.without_create
+    preamble: "start_restserver\n",
+    store: :RestClient,
+    options: "url: 'http://localhost:8808/moneta/'",
+    specs: STANDARD_SPECS.without_increment.without_create
   },
   'standard_memory' => {
-    :store => :Memory,
-    :specs => STANDARD_SPECS.without_persist
+    store: :Memory,
+    specs: STANDARD_SPECS.without_persist
   },
   'standard_memory_with_expires' => {
-    :store => :Memory,
-    :options => ':expires => true',
-    :specs => STANDARD_SPECS.with_expires.without_persist
+    store: :Memory,
+    options: 'expires: true',
+    specs: STANDARD_SPECS.with_expires.without_persist
   },
   'standard_memory_with_compress' => {
-    :store => :Memory,
-    :options => ':compress => true',
-    :load_value => 'Marshal.load(::Zlib::Inflate.inflate(value))',
-    :specs => STANDARD_SPECS.without_persist
+    store: :Memory,
+    options: 'compress: true',
+    load_value: 'Marshal.load(::Zlib::Inflate.inflate(value))',
+    specs: STANDARD_SPECS.without_persist
   },
   'standard_memory_with_prefix' => {
-    :store => :Memory,
-    :options => ':prefix => "moneta"',
-    :specs => STANDARD_SPECS.without_persist
+    store: :Memory,
+    options: 'prefix: "moneta"',
+    specs: STANDARD_SPECS.without_persist
   },
   'standard_memory_with_json_serializer' => {
-    :store => :Memory,
-    :options => ':serializer => :json',
-    :load_value => '::MultiJson.load(value)',
-    :specs => STANDARD_SPECS.without_marshallable.simplekeys_only.simplevalues_only.without_persist
+    store: :Memory,
+    options: 'serializer: :json',
+    load_value: '::MultiJson.load(value)',
+    specs: STANDARD_SPECS.without_marshallable.simplekeys_only.simplevalues_only.without_persist
   },
   'standard_memory_with_json_key_serializer' => {
-    :store => :Memory,
-    :options => ':key_serializer => :json',
-    :specs => STANDARD_SPECS.without_marshallable_key.simplekeys_only.without_persist,
+    store: :Memory,
+    options: 'key_serializer: :json',
+    specs: STANDARD_SPECS.without_marshallable_key.simplekeys_only.without_persist,
   },
   'standard_memory_with_json_value_serializer' => {
-    :store => :Memory,
-    :options => ':value_serializer => :json',
-    :specs => STANDARD_SPECS.without_marshallable_value.simplevalues_only.without_persist,
-    :load_value => '::MultiJson.load(value)'
+    store: :Memory,
+    options: 'value_serializer: :json',
+    specs: STANDARD_SPECS.without_marshallable_value.simplevalues_only.without_persist,
+    load_value: '::MultiJson.load(value)'
   },
   'standard_memory_with_snappy_compress' => {
-    :store => :Memory,
-    :options => ':compress => :snappy',
-    :load_value => 'Marshal.load(::Snappy.inflate(value))',
-    :specs => STANDARD_SPECS.without_persist
+    store: :Memory,
+    options: 'compress: :snappy',
+    load_value: 'Marshal.load(::Snappy.inflate(value))',
+    specs: STANDARD_SPECS.without_persist
   },
   'standard_lruhash' => {
-    :store => :LRUHash,
-    :specs => STANDARD_SPECS.without_persist
+    store: :LRUHash,
+    specs: STANDARD_SPECS.without_persist
   },
   'standard_lruhash_with_expires' => {
-    :store => :LRUHash,
-    :options => ':expires => true',
-    :specs => STANDARD_SPECS.with_expires.without_persist,
+    store: :LRUHash,
+    options: 'expires: true',
+    specs: STANDARD_SPECS.with_expires.without_persist,
   },
   'standard_file' => {
-    :store => :File,
-    :options => ':dir => File.join(make_tempdir, "simple_file")',
-    :specs => STANDARD_SPECS
+    store: :File,
+    options: 'dir: File.join(make_tempdir, "simple_file")',
+    specs: STANDARD_SPECS
   },
   'standard_file_with_expires' => {
-    :store => :File,
-    :options => ':dir => File.join(make_tempdir, "simple_file_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.with_expires
+    store: :File,
+    options: 'dir: File.join(make_tempdir, "simple_file_with_expires"), expires: true',
+    specs: STANDARD_SPECS.with_expires
   },
   'standard_hashfile' => {
-    :store => :HashFile,
-    :options => ':dir => File.join(make_tempdir, "simple_hashfile")',
-    :specs => STANDARD_SPECS
+    store: :HashFile,
+    options: 'dir: File.join(make_tempdir, "simple_hashfile")',
+    specs: STANDARD_SPECS
   },
   'standard_hashfile_with_expires' => {
-    :store => :HashFile,
-    :options => ':dir => File.join(make_tempdir, "simple_hashfile_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.with_expires
+    store: :HashFile,
+    options: 'dir: File.join(make_tempdir, "simple_hashfile_with_expires"), expires: true',
+    specs: STANDARD_SPECS.with_expires
   },
   'standard_cassandra' => {
-    :store => :Cassandra,
-    :options => ':keyspace => "simple_cassandra"',
-    :specs => STANDARD_SPECS.without_increment.without_create.with_native_expires,
+    store: :Cassandra,
+    options: 'keyspace: "simple_cassandra"',
+    specs: STANDARD_SPECS.without_increment.without_create.with_native_expires,
   },
   'standard_hbase' => {
-    :store => :HBase,
-    :options => ':table => "simple_hbase"',
-    :specs => STANDARD_SPECS.without_create
+    store: :HBase,
+    options: 'table: "simple_hbase"',
+    specs: STANDARD_SPECS.without_create
   },
   'standard_hbase_with_expires' => {
-    :store => :HBase,
-    :options => ':table => "simple_hbase", :expires => true',
-    :specs => STANDARD_SPECS.with_expires,
+    store: :HBase,
+    options: 'table: "simple_hbase", expires: true',
+    specs: STANDARD_SPECS.with_expires,
   },
   'standard_dbm' => {
-    :store => :DBM,
-    :options => ':file => File.join(make_tempdir, "simple_dbm")',
-    :specs => STANDARD_SPECS.without_multiprocess
+    store: :DBM,
+    options: 'file: File.join(make_tempdir, "simple_dbm")',
+    specs: STANDARD_SPECS.without_multiprocess
   },
   'standard_dbm_with_expires' => {
-    :store => :DBM,
-    :options => ':file => File.join(make_tempdir, "simple_dbm_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_multiprocess.with_expires
+    store: :DBM,
+    options: 'file: File.join(make_tempdir, "simple_dbm_with_expires"), expires: true',
+    specs: STANDARD_SPECS.without_multiprocess.with_expires
   },
   'standard_tdb' => {
-    :store => :TDB,
-    :options => ':file => File.join(make_tempdir, "simple_tdb")',
-    :specs => STANDARD_SPECS.without_multiprocess
+    store: :TDB,
+    options: 'file: File.join(make_tempdir, "simple_tdb")',
+    specs: STANDARD_SPECS.without_multiprocess
   },
   'standard_tdb_with_expires' => {
-    :store => :TDB,
-    :options => ':file => File.join(make_tempdir, "simple_tdb_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_multiprocess.with_expires
+    store: :TDB,
+    options: 'file: File.join(make_tempdir, "simple_tdb_with_expires"), expires: true',
+    specs: STANDARD_SPECS.without_multiprocess.with_expires
   },
   'standard_daybreak' => {
-    :store => :Daybreak,
-    :options => ':file => File.join(make_tempdir, "simple_daybreak")',
-    :specs => STANDARD_SPECS.without_multiprocess
+    store: :Daybreak,
+    options: 'file: File.join(make_tempdir, "simple_daybreak")',
+    specs: STANDARD_SPECS.without_multiprocess
   },
   'standard_daybreak_with_expires' => {
-    :store => :Daybreak,
-    :options => ':file => File.join(make_tempdir, "simple_daybreak_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_multiprocess.with_expires
+    store: :Daybreak,
+    options: 'file: File.join(make_tempdir, "simple_daybreak_with_expires"), expires: true',
+    specs: STANDARD_SPECS.without_multiprocess.with_expires
   },
   'standard_gdbm' => {
-    :store => :GDBM,
-    :options => ':file => File.join(make_tempdir, "simple_gdbm")',
-    :specs => STANDARD_SPECS.without_multiprocess
+    store: :GDBM,
+    options: 'file: File.join(make_tempdir, "simple_gdbm")',
+    specs: STANDARD_SPECS.without_multiprocess
   },
   'standard_gdbm_with_expires' => {
-    :store => :GDBM,
-    :options => ':file => File.join(make_tempdir, "simple_gdbm_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_multiprocess.with_expires
+    store: :GDBM,
+    options: 'file: File.join(make_tempdir, "simple_gdbm_with_expires"), expires: true',
+    specs: STANDARD_SPECS.without_multiprocess.with_expires
   },
   'standard_sdbm' => {
-    :store => :SDBM,
-    :options => ':file => File.join(make_tempdir, "simple_sdbm")',
-    :specs => STANDARD_SPECS.without_multiprocess.without_large
+    store: :SDBM,
+    options: 'file: File.join(make_tempdir, "simple_sdbm")',
+    specs: STANDARD_SPECS.without_multiprocess.without_large
   },
   'standard_sdbm_with_expires' => {
-    :store => :SDBM,
-    :options => ':file => File.join(make_tempdir, "simple_sdbm_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_multiprocess.with_expires.without_large
+    store: :SDBM,
+    options: 'file: File.join(make_tempdir, "simple_sdbm_with_expires"), expires: true',
+    specs: STANDARD_SPECS.without_multiprocess.with_expires.without_large
   },
   'standard_leveldb' => {
-    :store => :LevelDB,
-    :options => ':dir => File.join(make_tempdir, "simple_leveldb")',
-    :specs => STANDARD_SPECS.without_multiprocess
+    store: :LevelDB,
+    options: 'dir: File.join(make_tempdir, "simple_leveldb")',
+    specs: STANDARD_SPECS.without_multiprocess
   },
   'standard_leveldb_with_expires' => {
-    :store => :LevelDB,
-    :options => ':dir => File.join(make_tempdir, "simple_leveldb_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_multiprocess.with_expires
+    store: :LevelDB,
+    options: 'dir: File.join(make_tempdir, "simple_leveldb_with_expires"), expires: true',
+    specs: STANDARD_SPECS.without_multiprocess.with_expires
   },
   'standard_lmdb' => {
-    :store => :LMDB,
-    :options => ':dir => File.join(make_tempdir, "simple_lmdb")',
-    :specs => STANDARD_SPECS.without_concurrent
+    store: :LMDB,
+    options: 'dir: File.join(make_tempdir, "simple_lmdb")',
+    specs: STANDARD_SPECS.without_concurrent
   },
   'standard_lmdb_with_expires' => {
-    :store => :LMDB,
-    :options => ':dir => File.join(make_tempdir, "simple_lmdb_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_concurrent.with_expires
+    store: :LMDB,
+    options: 'dir: File.join(make_tempdir, "simple_lmdb_with_expires"), expires: true',
+    specs: STANDARD_SPECS.without_concurrent.with_expires
   },
   'standard_pstore' => {
-    :store => :PStore,
-    :options => ':file => File.join(make_tempdir, "simple_pstore")',
-    :load_value => 'value',
-    :specs => STANDARD_SPECS
+    store: :PStore,
+    options: 'file: File.join(make_tempdir, "simple_pstore")',
+    load_value: 'value',
+    specs: STANDARD_SPECS
   },
   'standard_pstore_with_expires' => {
-    :store => :PStore,
-    :options => ':file => File.join(make_tempdir, "simple_pstore_with_expires"), :expires => true',
-    :load_value => 'value',
-    :specs => STANDARD_SPECS.with_expires
+    store: :PStore,
+    options: 'file: File.join(make_tempdir, "simple_pstore_with_expires"), expires: true',
+    load_value: 'value',
+    specs: STANDARD_SPECS.with_expires
   },
   'standard_yaml' => {
-    :store => :YAML,
-    :options => ':file => File.join(make_tempdir, "simple_yaml")',
-    :specs => STANDARD_SPECS.without_marshallable_value.without_concurrent,
-    :load_value => 'value'
+    store: :YAML,
+    options: 'file: File.join(make_tempdir, "simple_yaml")',
+    specs: STANDARD_SPECS.without_marshallable_value.without_concurrent,
+    load_value: 'value'
   },
   'standard_yaml_with_expires' => {
-    :store => :YAML,
-    :options => ':file => File.join(make_tempdir, "simple_yaml_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_marshallable_value.with_expires.without_concurrent,
-    :load_value => 'value'
+    store: :YAML,
+    options: 'file: File.join(make_tempdir, "simple_yaml_with_expires"), expires: true',
+    specs: STANDARD_SPECS.without_marshallable_value.with_expires.without_concurrent,
+    load_value: 'value'
   },
   'standard_localmemcache' => {
-    :store => :LocalMemCache,
-    :options => ':file => File.join(make_tempdir, "simple_localmemcache")',
-    :specs => STANDARD_SPECS.without_increment.without_create
+    store: :LocalMemCache,
+    options: 'file: File.join(make_tempdir, "simple_localmemcache")',
+    specs: STANDARD_SPECS.without_increment.without_create
   },
   'standard_localmemcache_with_expires' => {
-    :store => :LocalMemCache,
-    :options => ':file => File.join(make_tempdir, "simple_localmemcache_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_increment.without_create.with_expires
+    store: :LocalMemCache,
+    options: 'file: File.join(make_tempdir, "simple_localmemcache_with_expires"), expires: true',
+    specs: STANDARD_SPECS.without_increment.without_create.with_expires
   },
   'standard_tokyocabinet' => {
-    :store => :TokyoCabinet,
-    :options => ':file => File.join(make_tempdir, "simple_tokyocabinet")',
-    :specs => STANDARD_SPECS.without_multiprocess
+    store: :TokyoCabinet,
+    options: 'file: File.join(make_tempdir, "simple_tokyocabinet")',
+    specs: STANDARD_SPECS.without_multiprocess
   },
   'standard_tokyocabinet_with_expires' => {
-    :store => :TokyoCabinet,
-    :options => ':file => File.join(make_tempdir, "simple_tokyocabinet_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.without_multiprocess.with_expires
+    store: :TokyoCabinet,
+    options: 'file: File.join(make_tempdir, "simple_tokyocabinet_with_expires"), expires: true',
+    specs: STANDARD_SPECS.without_multiprocess.with_expires
   },
   'standard_tokyotyrant' => {
-    :store => :TokyoTyrant,
-    :specs => STANDARD_SPECS
+    store: :TokyoTyrant,
+    specs: STANDARD_SPECS
   },
   'standard_tokyotyrant_with_expires' => {
-    :store => :TokyoTyrant,
-    :options => ':expires => true',
-    :specs => STANDARD_SPECS.with_expires
+    store: :TokyoTyrant,
+    options: 'expires: true',
+    specs: STANDARD_SPECS.with_expires
   },
   'standard_kyotocabinet' => {
-    :store => :KyotoCabinet,
-    :options => ':file => File.join(make_tempdir, "simple_kyotocabinet.kch")',
-    :specs => STANDARD_SPECS.without_multiprocess
+    store: :KyotoCabinet,
+    options: 'file: File.join(make_tempdir, "simple_kyotocabinet.kch")',
+    specs: STANDARD_SPECS.without_multiprocess
   },
   'standard_kyotocabinet_with_expires' => {
-    :store => :KyotoCabinet,
-    :options => ':file => File.join(make_tempdir, "simple_kyotocabinet_with_expires.kch"), :expires => true',
-    :specs => STANDARD_SPECS.without_multiprocess.with_expires
+    store: :KyotoCabinet,
+    options: 'file: File.join(make_tempdir, "simple_kyotocabinet_with_expires.kch"), expires: true',
+    specs: STANDARD_SPECS.without_multiprocess.with_expires
   },
   'standard_sqlite' => {
-    :store => :Sqlite,
-    :options => ':file => File.join(make_tempdir, "simple_sqlite")',
-    :specs => STANDARD_SPECS.without_concurrent
+    store: :Sqlite,
+    options: 'file: File.join(make_tempdir, "simple_sqlite")',
+    specs: STANDARD_SPECS.without_concurrent
   },
   'standard_sqlite_with_expires' => {
-    :store => :Sqlite,
-    :options => ':file => File.join(make_tempdir, "simple_sqlite_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.with_expires.without_concurrent
+    store: :Sqlite,
+    options: 'file: File.join(make_tempdir, "simple_sqlite_with_expires"), expires: true',
+    specs: STANDARD_SPECS.with_expires.without_concurrent
   },
   'standard_redis' => {
-    :store => :Redis,
-    :specs => STANDARD_SPECS.with_native_expires,
+    store: :Redis,
+    specs: STANDARD_SPECS.with_native_expires,
   },
   'standard_memcached' => {
-    :store => :Memcached,
-    :specs => STANDARD_SPECS.with_native_expires,
-    :options => ':namespace => "simple_memcached"'
+    store: :Memcached,
+    specs: STANDARD_SPECS.with_native_expires,
+    options: 'namespace: "simple_memcached"'
   },
   'standard_memcached_dalli' => {
-    :store => :MemcachedDalli,
-    :specs => STANDARD_SPECS.with_native_expires,
-    :options => ':namespace => "simple_memcached_dalli"'
+    store: :MemcachedDalli,
+    specs: STANDARD_SPECS.with_native_expires,
+    options: 'namespace: "simple_memcached_dalli"'
   },
   'standard_memcached_native' => {
-    :store => :MemcachedNative,
-    :specs => STANDARD_SPECS.with_native_expires,
-    :options => ':namespace => "simple_memcached_native"'
+    store: :MemcachedNative,
+    specs: STANDARD_SPECS.with_native_expires,
+    options: 'namespace: "simple_memcached_native"'
   },
   'standard_riak' => {
-    :store => :Riak,
-    :options => ":bucket => 'standard_riak'",
+    store: :Riak,
+    options: "bucket: 'standard_riak'",
     # We don't want Riak warnings in tests
-    :preamble => "require 'riak'\n\nRiak.disable_list_keys_warnings = true\n\n",
-    :specs => STANDARD_SPECS.without_increment.without_create
+    preamble: "require 'riak'\n\nRiak.disable_list_keys_warnings = true\n\n",
+    specs: STANDARD_SPECS.without_increment.without_create
   },
   'standard_riak_with_expires' => {
-    :store => :Riak,
-    :options => ":bucket => 'standard_riak_with_expires', :expires => true",
+    store: :Riak,
+    options: "bucket: 'standard_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 => STANDARD_SPECS.without_increment.with_expires.without_create
+    preamble: "require 'riak'\n\nRiak.disable_list_keys_warnings = true\n\n",
+    specs: STANDARD_SPECS.without_increment.with_expires.without_create
   },
   'standard_couch' => {
-    :store => :Couch,
-    :options => ":db => 'standard_couch'",
-    :load_value => '::Marshal.load(value.unpack(\'m\').first)',
-    :specs => STANDARD_SPECS.without_increment
+    store: :Couch,
+    options: "db: 'standard_couch'",
+    load_value: '::Marshal.load(value.unpack(\'m\').first)',
+    specs: STANDARD_SPECS.without_increment
   },
   'standard_couch_with_expires' => {
-    :store => :Couch,
-    :options => ":db => 'standard_couch_with_expires', :expires => true",
-    :specs => STANDARD_SPECS.without_increment.with_expires,
-    :load_value => '::Marshal.load(value.unpack(\'m\').first)'
+    store: :Couch,
+    options: "db: 'standard_couch_with_expires', expires: true",
+    specs: STANDARD_SPECS.without_increment.with_expires,
+    load_value: '::Marshal.load(value.unpack(\'m\').first)'
   },
   'standard_mongo' => {
-    :store => :Mongo,
-    :options => ":db => 'standard_mongo'",
-    :specs => STANDARD_SPECS.with_native_expires
+    store: :Mongo,
+    options: "db: 'standard_mongo'",
+    specs: STANDARD_SPECS.with_native_expires
+  },
+  'standard_mongo_moped' => {
+    store: :MongoMoped,
+    options: "db: 'standard_mongo_moped'",
+    specs: STANDARD_SPECS.with_native_expires
+  },
+  'standard_mongo_official' => {
+    store: :MongoOfficial,
+    options: "db: 'standard_mongo_official'",
+    specs: STANDARD_SPECS.with_native_expires
   },
   'standard_null' => {
-    :store => :Null,
-    :specs => STANDARD_SPECS.without_increment.without_create.without_store.without_persist
+    store: :Null,
+    specs: STANDARD_SPECS.without_increment.without_create.without_store.without_persist
   },
   'null_adapter' => {
-    :build => 'Moneta::Adapters::Null.new',
-    :specs => Specs.new(:specs => [:null, :not_increment, :not_create, :not_persist])
+    build: 'Moneta::Adapters::Null.new',
+    specs: Specs.new(specs: [:null, :not_increment, :not_create, :not_persist])
   },
   'standard_sequel' => {
-    :store => :Sequel,
-    :options => ':db => (defined?(JRUBY_VERSION) ? "jdbc:mysql://localhost/moneta?user=root" : "mysql2://root:@localhost/moneta"), :table => "simple_sequel"',
-    :load_value => '::Marshal.load(value)',
-    :specs => STANDARD_SPECS
+    store: :Sequel,
+    options: 'db: (defined?(JRUBY_VERSION) ? "jdbc:mysql://localhost/moneta?user=root" : "mysql2://root:@localhost/moneta"), table: "simple_sequel"',
+    load_value: '::Marshal.load(value)',
+    specs: STANDARD_SPECS
   },
   'standard_sequel_with_expires' => {
-    :store => :Sequel,
-    :options => ':db => (defined?(JRUBY_VERSION) ? "jdbc:mysql://localhost/moneta?user=root" : "mysql2://root:@localhost/moneta"), :table => "simple_sequel_with_expires", :expires => true',
-    :specs => STANDARD_SPECS.with_expires,
-    :load_value => '::Marshal.load(value)'
+    store: :Sequel,
+    options: 'db: (defined?(JRUBY_VERSION) ? "jdbc:mysql://localhost/moneta?user=root" : "mysql2://root:@localhost/moneta"), table: "simple_sequel_with_expires", expires: true',
+    specs: STANDARD_SPECS.with_expires,
+    load_value: '::Marshal.load(value)'
   },
   'standard_datamapper' => {
-    :store => :DataMapper,
-    :specs => STANDARD_SPECS.without_increment,
-    :options => ':setup => "mysql://root:@localhost/moneta", :table => "simple_datamapper"',
+    store: :DataMapper,
+    specs: STANDARD_SPECS.without_increment,
+    options: 'setup: "mysql://root:@localhost/moneta", table: "simple_datamapper"',
     # DataMapper needs default repository to be setup
-    :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
-    :load_value => '::Marshal.load(value.unpack(\'m\').first)'
+    preamble: "require 'dm-core'\nDataMapper.setup(:default, adapter: :in_memory)\n",
+    load_value: '::Marshal.load(value.unpack(\'m\').first)'
   },
   'standard_datamapper_with_expires' => {
-    :store => :DataMapper,
-    :options => ':setup => "mysql://root:@localhost/moneta", :table => "simple_datamapper_with_expires", :expires => true',
+    store: :DataMapper,
+    options: 'setup: "mysql://root:@localhost/moneta", table: "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 => STANDARD_SPECS.without_increment.with_expires,
-    :load_value => '::Marshal.load(value.unpack(\'m\').first)'
+    preamble: "require 'dm-core'\nDataMapper.setup(:default, adapter: :in_memory)\n",
+    specs: STANDARD_SPECS.without_increment.with_expires,
+    load_value: '::Marshal.load(value.unpack(\'m\').first)'
   },
   'standard_datamapper_with_repository' => {
-    :store => :DataMapper,
-    :specs => STANDARD_SPECS.without_increment,
-    :options => ':repository => :repo, :setup => "mysql://root:@localhost/moneta", :table => "simple_datamapper_with_repository"',
+    store: :DataMapper,
+    specs: STANDARD_SPECS.without_increment,
+    options: 'repository: :repo, setup: "mysql://root:@localhost/moneta", table: "simple_datamapper_with_repository"',
     # DataMapper needs default repository to be setup
-    :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
-    :load_value => '::Marshal.load(value.unpack(\'m\').first)'
+    preamble: "require 'dm-core'\nDataMapper.setup(:default, adapter: :in_memory)\n",
+    load_value: '::Marshal.load(value.unpack(\'m\').first)'
   },
   'standard_activerecord' => {
-    :store => :ActiveRecord,
-    :specs => STANDARD_SPECS,
-    :options => ":table => 'standard_activerecord', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta', :username => 'root' }",
-    :load_value => '::Marshal.load(value.unpack(\'m\').first)'
+    store: :ActiveRecord,
+    specs: STANDARD_SPECS,
+    options: "table: 'standard_activerecord', connection: { adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), database: 'moneta', username: 'root' }",
+    load_value: '::Marshal.load(value.unpack(\'m\').first)'
   },
   'standard_activerecord_with_expires' => {
-    :store => :ActiveRecord,
-    :options => ":table => 'standard_activerecord_with_expires', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta', :username => 'root' }, :expires => true",
-    :specs => STANDARD_SPECS.with_expires,
-    :load_value => '::Marshal.load(value.unpack(\'m\').first)'
+    store: :ActiveRecord,
+    options: "table: 'standard_activerecord_with_expires', connection: { adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), database: 'moneta', username: 'root' }, expires: true",
+    specs: STANDARD_SPECS.with_expires,
+    load_value: '::Marshal.load(value.unpack(\'m\').first)'
   },
   'standard_fog' => {
-    :store                  => :Fog,
-    :specs                  => STANDARD_SPECS.without_increment.without_create,
-    :options => ":aws_access_key_id => 'fake_access_key_id',
-    :aws_secret_access_key  => 'fake_secret_access_key',
-    :provider               => 'AWS',
-    :dir                    => 'standard_fog'",
+    store:                  :Fog,
+    specs:                  STANDARD_SPECS.without_increment.without_create,
+    options: "aws_access_key_id: 'fake_access_key_id',
+    aws_secret_access_key:  'fake_secret_access_key',
+    provider:               'AWS',
+    dir:                    'standard_fog'",
     # Put Fog into testing mode
-    :preamble               => "require 'fog'\nFog.mock!\n"
+    preamble:               "require 'fog'\nFog.mock!\n"
   },
   'standard_fog_with_expires' => {
-    :store                  => :Fog,
-    :options => ":aws_access_key_id => 'fake_access_key_id',
-    :aws_secret_access_key  => 'fake_secret_access_key',
-    :provider               => 'AWS',
-    :dir                    => 'standard_fog_with_expires',
-    :expires                => true",
+    store:                  :Fog,
+    options: "aws_access_key_id: 'fake_access_key_id',
+    aws_secret_access_key:  'fake_secret_access_key',
+    provider:               'AWS',
+    dir:                    'standard_fog_with_expires',
+    expires:                true",
     # Put Fog into testing mode
-    :preamble               => "require 'fog'\nFog.mock!\n",
-    :specs => STANDARD_SPECS.without_increment.without_create.with_expires
+    preamble:               "require 'fog'\nFog.mock!\n",
+    specs: STANDARD_SPECS.without_increment.without_create.with_expires
   },
   'weak_create' => {
     # Put Fog into testing mode
-    :preamble               => "require 'fog'\nFog.mock!\n",
-    :build => %{Moneta.build do
+    preamble:               "require 'fog'\nFog.mock!\n",
+    build: %{Moneta.build do
   use :WeakCreate
   adapter :Fog,
-    :aws_access_key_id => 'fake_access_key_id',
-    :aws_secret_access_key  => 'fake_secret_access_key',
-    :provider               => 'AWS',
-    :dir                    => 'weak_create'
+    aws_access_key_id: 'fake_access_key_id',
+    aws_secret_access_key:  'fake_secret_access_key',
+    provider:               'AWS',
+    dir:                    'weak_create'
 end},
-    :specs => ADAPTER_SPECS.without_increment.without_concurrent.returnsame
+    specs: ADAPTER_SPECS.without_increment.without_concurrent.returnsame
   },
   'weak_increment' => {
     # Put Fog into testing mode
-    :preamble               => "require 'fog'\nFog.mock!\n",
-    :build => %{Moneta.build do
+    preamble:               "require 'fog'\nFog.mock!\n",
+    build: %{Moneta.build do
   use :WeakIncrement
   adapter :Fog,
-    :aws_access_key_id => 'fake_access_key_id',
-    :aws_secret_access_key  => 'fake_secret_access_key',
-    :provider               => 'AWS',
-    :dir                    => 'weak_increment'
+    aws_access_key_id: 'fake_access_key_id',
+    aws_secret_access_key:  'fake_secret_access_key',
+    provider:               'AWS',
+    dir:                    'weak_increment'
 end},
-    :specs => ADAPTER_SPECS.without_create.without_concurrent.returnsame
+    specs: ADAPTER_SPECS.without_create.without_concurrent.returnsame
   },
   'expires_memory' => {
-    :build => %{Moneta.build do
+    build: %{Moneta.build do
   use :Expires
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_transform.with_expires.without_persist.returnsame
+    specs: STANDARD_SPECS.without_transform.with_expires.without_persist.returnsame
   },
   'expires_memory_with_default_expires' => {
-    :build => %{Moneta.build do
-  use :Expires, :expires => 1
+    build: %{Moneta.build do
+  use :Expires, expires: 1
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_transform.with_expires.with_default_expires.without_persist.returnsame
+    specs: STANDARD_SPECS.without_transform.with_expires.with_default_expires.without_persist.returnsame
   },
   'expires_file' => {
-    :build => %{Moneta.build do
+    build: %{Moneta.build do
   use :Expires
-  use :Transformer, :key => [:marshal, :escape], :value => :marshal
-  adapter :File, :dir => File.join(make_tempdir, "expires-file")
+  use :Transformer, key: [:marshal, :escape], value: :marshal
+  adapter :File, dir: File.join(make_tempdir, "expires-file")
 end},
-    :specs => STANDARD_SPECS.with_expires.stringvalues_only,
-    :tests => %{
+    specs: STANDARD_SPECS.with_expires.stringvalues_only,
+    tests: %{
 it 'deletes expired value in underlying file storage' do
-  store.store('foo', 'bar', :expires => 2)
+  store.store('foo', 'bar', expires: 2)
   store['foo'].should == 'bar'
   sleep 1
   store['foo'].should == 'bar'
@@ -566,31 +576,31 @@ end
 }
   },
   'proxy_redis' => {
-    :build => %{Moneta.build do
+    build: %{Moneta.build do
   use :Proxy
   use :Proxy
   adapter :Redis
 end},
-    :specs => ADAPTER_SPECS.with_expires
+    specs: ADAPTER_SPECS.with_expires
   },
   'proxy_expires_memory' => {
-    :build => %{Moneta.build do
+    build: %{Moneta.build do
   use :Proxy
   use :Expires
   use :Proxy
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_transform.with_expires.returnsame.without_persist
+    specs: STANDARD_SPECS.without_transform.with_expires.returnsame.without_persist
   },
   'cache_file_memory' => {
-    :build => %{Moneta.build do
+    build: %{Moneta.build do
   use(:Cache) do
-    adapter { adapter :File, :dir => File.join(make_tempdir, "cache_file_memory") }
+    adapter { adapter :File, dir: File.join(make_tempdir, "cache_file_memory") }
     cache { adapter :Memory }
   end
 end},
-    :specs => ADAPTER_SPECS.returnsame,
-    :tests => %{
+    specs: ADAPTER_SPECS.returnsame,
+    tests: %{
 it 'stores loaded values in cache' do
   store.adapter['foo'] = 'bar'
   store.cache['foo'].should be_nil
@@ -604,22 +614,22 @@ end
 }
   },
   'cache_memory_null' => {
-    :build => %{Moneta.build do
+    build: %{Moneta.build do
   use(:Cache) do
     adapter(Moneta::Adapters::Memory.new)
     cache(Moneta::Adapters::Null.new)
   end
 end},
-    :specs => ADAPTER_SPECS.without_persist.returnsame
+    specs: ADAPTER_SPECS.without_persist.returnsame
   },
   'shared_tcp' => {
-    :build => %{Moneta.build do
-  use(:Shared, :port => 9001) do
-    adapter :PStore, :file => File.join(make_tempdir, 'shared_tcp')
+    build: %{Moneta.build do
+  use(:Shared, port: 9001) do
+    adapter :PStore, file: File.join(make_tempdir, 'shared_tcp')
   end
 end},
-    :specs => ADAPTER_SPECS,
-    :tests => %{
+    specs: ADAPTER_SPECS,
+    tests: %{
 it 'shares values' do
   store['shared_key'] = 'shared_value'
   second = new_store
@@ -630,13 +640,13 @@ end
 }
   },
   'shared_unix' => {
-    :build => %{Moneta.build do
-  use(:Shared, :socket => File.join(make_tempdir, 'shared_unix.socket')) do
-    adapter :PStore, :file => File.join(make_tempdir, 'shared_unix')
+    build: %{Moneta.build do
+  use(:Shared, socket: File.join(make_tempdir, 'shared_unix.socket')) do
+    adapter :PStore, file: File.join(make_tempdir, 'shared_unix')
   end
 end},
-    :specs => ADAPTER_SPECS,
-    :tests => %{
+    specs: ADAPTER_SPECS,
+    tests: %{
 it 'shares values' do
   store['shared_key'] = 'shared_value'
   second = new_store
@@ -647,165 +657,165 @@ end
 }
   },
   'stack_file_memory' => {
-    :build => %{Moneta.build do
+    build: %{Moneta.build do
   use(:Stack) do
     add(Moneta.new(:Null))
     add(Moneta::Adapters::Null.new)
-    add { adapter :File, :dir => File.join(make_tempdir, "stack_file_memory") }
+    add { adapter :File, dir: File.join(make_tempdir, "stack_file_memory") }
     add { adapter :Memory }
   end
 end},
-    :specs => ADAPTER_SPECS.without_increment.without_create
+    specs: ADAPTER_SPECS.without_increment.without_create
   },
   'stack_memory_file' => {
-    :build => %{Moneta.build do
+    build: %{Moneta.build do
   use(:Stack) do
     add { adapter :Memory }
-    add { adapter :File, :dir => File.join(make_tempdir, "stack_memory_file") }
+    add { adapter :File, dir: File.join(make_tempdir, "stack_memory_file") }
   end
 end},
-    :specs => ADAPTER_SPECS.returnsame
+    specs: ADAPTER_SPECS.returnsame
   },
   'lock' => {
-    :build => %{Moneta.build do
+    build: %{Moneta.build do
   use :Lock
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_transform.returnsame.without_persist
+    specs: STANDARD_SPECS.without_transform.returnsame.without_persist
   },
   'pool' => {
-    :build => %{Moneta.build do
+    build: %{Moneta.build do
   use :Pool do
-    adapter :File, :dir => File.join(make_tempdir, "pool")
+    adapter :File, dir: File.join(make_tempdir, "pool")
   end
 end},
-    :specs => ADAPTER_SPECS
+    specs: ADAPTER_SPECS
   },
   'transformer_zlib' => {
-    :build => %{Moneta.build do
-  use :Transformer, :value => :zlib
+    build: %{Moneta.build do
+  use :Transformer, value: :zlib
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.stringvalues_only,
-    :load_value => '::Zlib::Inflate.inflate(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.stringvalues_only,
+    load_value: '::Zlib::Inflate.inflate(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::ZlibValue.should_not be_nil
 end}
   },
   'transformer_bzip2' => {
-    :build => %{Moneta.build do
-  use :Transformer, :value => :bzip2
+    build: %{Moneta.build do
+  use :Transformer, value: :bzip2
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.stringvalues_only,
-    :load_value => '::Bzip2.uncompress(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.stringvalues_only,
+    load_value: '::Bzip2.uncompress(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::Bzip2Value.should_not be_nil
 end}
   },
   'transformer_lzo' => {
-    :build => %{Moneta.build do
-  use :Transformer, :value => :lzo
+    build: %{Moneta.build do
+  use :Transformer, value: :lzo
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.stringvalues_only,
-    :load_value => '::LZO.decompress(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.stringvalues_only,
+    load_value: '::LZO.decompress(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::LzoValue.should_not be_nil
 end}
   },
   'transformer_lz4' => {
-    :build => %{Moneta.build do
-  use :Transformer, :value => :lz4
+    build: %{Moneta.build do
+  use :Transformer, value: :lz4
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.stringvalues_only,
-    :load_value => '::LZ4.uncompress(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.stringvalues_only,
+    load_value: '::LZ4.uncompress(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::Lz4Value.should_not be_nil
 end}
   },
   'transformer_lzma' => {
-    :build => %{Moneta.build do
-  use :Transformer, :value => :lzma
+    build: %{Moneta.build do
+  use :Transformer, value: :lzma
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.stringvalues_only,
-    :load_value => '::LZMA.decompress(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.stringvalues_only,
+    load_value: '::LZMA.decompress(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::LzmaValue.should_not be_nil
 end}
   },
   'transformer_snappy' => {
-    :build => %{Moneta.build do
-  use :Transformer, :value => :snappy
+    build: %{Moneta.build do
+  use :Transformer, value: :snappy
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.stringvalues_only,
-    :load_value => '::Snappy.inflate(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.stringvalues_only,
+    load_value: '::Snappy.inflate(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::SnappyValue.should_not be_nil
 end}
   },
   'transformer_quicklz' => {
-    :build => %{Moneta.build do
-  use :Transformer, :value => :quicklz
+    build: %{Moneta.build do
+  use :Transformer, value: :quicklz
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.stringvalues_only,
-    :load_value => '::QuickLZ.decompress(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.stringvalues_only,
+    load_value: '::QuickLZ.decompress(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::QuicklzValue.should_not be_nil
 end}
   },
   'transformer_json' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :json, :value => :json
+    build: %{Moneta.build do
+  use :Transformer, key: :json, value: :json
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
-    :load_value => '::MultiJson.load(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
+    load_value: '::MultiJson.load(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::JsonKeyJsonValue.should_not be_nil
 end}
   },
   'transformer_bert' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :bert, :value => :bert
+    build: %{Moneta.build do
+  use :Transformer, key: :bert, value: :bert
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
-    :load_value => '::BERT.decode(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
+    load_value: '::BERT.decode(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::BertKeyBertValue.should_not be_nil
 end}
   },
   'transformer_bencode' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :bencode, :value => :bencode
+    build: %{Moneta.build do
+  use :Transformer, key: :bencode, value: :bencode
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
-    :load_value => '::BEncode.load(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
+    load_value: '::BEncode.load(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::BencodeKeyBencodeValue.should_not be_nil
@@ -813,408 +823,408 @@ end}
 
   },
   'transformer_bson' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :bson, :value => :bson
+    build: %{Moneta.build do
+  use :Transformer, key: :bson, value: :bson
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
-    :load_value => "::BSON.deserialize(value)['v']",
-    :tests => %{
+    specs: TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
+    load_value: "::BSON.deserialize(value)['v']",
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::BsonKeyBsonValue.should_not be_nil
 end}
   },
   'transformer_ox' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :ox, :value => :ox
+    build: %{Moneta.build do
+  use :Transformer, key: :ox, value: :ox
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS,
-    :load_value => '::Ox.parse_obj(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS,
+    load_value: '::Ox.parse_obj(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::OxKeyOxValue.should_not be_nil
 end}
   },
   'transformer_php' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :php, :value => :php
+    build: %{Moneta.build do
+  use :Transformer, key: :php, value: :php
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
-    :load_value => '::PHP.unserialize(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
+    load_value: '::PHP.unserialize(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::PhpKeyPhpValue.should_not be_nil
 end}
   },
   'transformer_tnet' => {
-    :build => %{Moneta.build do
- use :Transformer, :key => :tnet, :value => :tnet
+    build: %{Moneta.build do
+ use :Transformer, key: :tnet, value: :tnet
  adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
-    :load_value => '::TNetstring.parse(value).first',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
+    load_value: '::TNetstring.parse(value).first',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::TnetKeyTnetValue.should_not be_nil
 end}
   },
   'transformer_msgpack' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :msgpack, :value => :msgpack
+    build: %{Moneta.build do
+  use :Transformer, key: :msgpack, value: :msgpack
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
-    :load_value => '::MessagePack.unpack(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
+    load_value: '::MessagePack.unpack(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MsgpackKeyMsgpackValue.should_not be_nil
 end}
   },
   'transformer_marshal' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :marshal, :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: :marshal, value: :marshal
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS,
-    :load_value => '::Marshal.load(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS,
+    load_value: '::Marshal.load(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalKeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_key_marshal' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: :marshal
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.returnsame,
-    :load_value => 'value',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.returnsame,
+    load_value: 'value',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalKey.should_not be_nil
 end}
   },
   'transformer_key_to_s' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :to_s
+    build: %{Moneta.build do
+  use :Transformer, key: :to_s
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.returnsame.simplekeys_only,
-    :load_value => 'value',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.returnsame.simplekeys_only,
+    load_value: 'value',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::To_sKey.should_not be_nil
 end}
   },
   'transformer_key_inspect' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :inspect
+    build: %{Moneta.build do
+  use :Transformer, key: :inspect
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.returnsame.simplekeys_only,
-    :load_value => 'value',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.returnsame.simplekeys_only,
+    load_value: 'value',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::InspectKey.should_not be_nil
 end}
   },
   'transformer_value_marshal' => {
-    :build => %{Moneta.build do
-  use :Transformer, :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, value: :marshal
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS,
-    :load_value => '::Marshal.load(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS,
+    load_value: '::Marshal.load(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalValue.should_not be_nil
 end}
   },
   'transformer_yaml' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :yaml, :value => :yaml
+    build: %{Moneta.build do
+  use :Transformer, key: :yaml, value: :yaml
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS,
-    :load_value => '::YAML.load(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS,
+    load_value: '::YAML.load(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::YamlKeyYamlValue.should_not be_nil
 end}
   },
   'transformer_key_yaml' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :yaml
+    build: %{Moneta.build do
+  use :Transformer, key: :yaml
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS.returnsame,
-    :load_value => 'value',
-    :tests => %{
+    specs: TRANSFORMER_SPECS.returnsame,
+    load_value: 'value',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::YamlKey.should_not be_nil
 end}
   },
   'transformer_value_yaml' => {
-    :build => %{Moneta.build do
-  use :Transformer, :value => :yaml
+    build: %{Moneta.build do
+  use :Transformer, value: :yaml
   adapter :Memory
 end},
-    :specs => TRANSFORMER_SPECS,
-    :load_value => '::YAML.load(value)',
-    :tests => %{
+    specs: TRANSFORMER_SPECS,
+    load_value: '::YAML.load(value)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::YamlValue.should_not be_nil
 end}
   },
   'transformer_marshal_hmac' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => :marshal, :value => [:marshal, :hmac], :secret => 'secret'
+    build: %{Moneta.build do
+  use :Transformer, key: :marshal, value: [:marshal, :hmac], secret: 'secret'
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :load_value => '::Marshal.load(::Moneta::Transformer::Helper.hmacverify(value, \'secret\'))',
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    load_value: '::Marshal.load(::Moneta::Transformer::Helper.hmacverify(value, \'secret\'))',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalKeyMarshalHmacValue.should_not be_nil
 end}
   },
   'transformer_marshal_base64' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :base64], :value => [:marshal, :base64]
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :base64], value: [:marshal, :base64]
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :load_value => '::Marshal.load(value.unpack(\'m\').first)',
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    load_value: '::Marshal.load(value.unpack(\'m\').first)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalBase64KeyMarshalBase64Value.should_not be_nil
 end}
   },
   'transformer_marshal_hex' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :hex], :value => [:marshal, :hex]
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :hex], value: [:marshal, :hex]
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :load_value => '::Marshal.load([value].pack(\'H*\'))',
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    load_value: '::Marshal.load([value].pack(\'H*\'))',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalHexKeyMarshalHexValue.should_not be_nil
 end}
   },
   'transformer_marshal_prefix' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :prefix], :value => :marshal, :prefix => 'moneta'
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :prefix], value: :marshal, prefix: 'moneta'
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalPrefixKeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_uuencode' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :uuencode], :value => [:marshal, :uuencode]
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :uuencode], value: [:marshal, :uuencode]
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :load_value => '::Marshal.load(value.unpack(\'u\').first)',
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    load_value: '::Marshal.load(value.unpack(\'u\').first)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalUuencodeKeyMarshalUuencodeValue.should_not be_nil
 end}
   },
   'transformer_marshal_qp' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :qp], :value => [:marshal, :qp]
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :qp], value: [:marshal, :qp]
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :load_value => '::Marshal.load(value.unpack(\'M\').first)',
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    load_value: '::Marshal.load(value.unpack(\'M\').first)',
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalQpKeyMarshalQpValue.should_not be_nil
 end}
   },
   'transformer_marshal_escape' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :escape], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :escape], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalEscapeKeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_md5' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :md5], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :md5], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalMd5KeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_sha1' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :sha1], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :sha1], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalSha1KeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_sha256' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :sha256], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :sha256], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalSha256KeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_sha384' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :sha384], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :sha384], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalSha384KeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_sha512' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :sha512], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :sha512], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalSha512KeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_rmd160' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :rmd160], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :rmd160], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalRmd160KeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_md5_spread' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :md5, :spread], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :md5, :spread], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalMd5SpreadKeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_city32' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :city32], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :city32], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalCity32KeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_city64' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :city64], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :city64], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalCity64KeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_city128' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :city128], :value => :marshal
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :city128], value: :marshal
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalCity128KeyMarshalValue.should_not be_nil
 end}
   },
   'transformer_marshal_truncate' => {
-    :build => %{Moneta.build do
-  use :Transformer, :key => [:marshal, :truncate], :value => :marshal, :maxlen => 64
+    build: %{Moneta.build do
+  use :Transformer, key: [:marshal, :truncate], value: :marshal, maxlen: 64
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_persist,
-    :tests => %{
+    specs: STANDARD_SPECS.without_persist,
+    tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
   Moneta::Transformer::MarshalTruncateKeyMarshalValue.should_not be_nil
 end}
   },
   'adapter_activerecord' => {
-    :build => "Moneta::Adapters::ActiveRecord.new(:table => 'adapter_activerecord', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta', :username => 'root' })",
-    :specs => ADAPTER_SPECS,
-    :tests => %{
+    build: "Moneta::Adapters::ActiveRecord.new(table: 'adapter_activerecord', connection: { adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), database: 'moneta', username: 'root' })",
+    specs: ADAPTER_SPECS,
+    tests: %{
 it 'updates an existing key/value' do
   store['foo/bar'] = '1'
   store['foo/bar'] = '2'
-  store.table.where(:k => 'foo/bar').count.should == 1
+  store.table.where(k: 'foo/bar').count.should == 1
 end
 
 it 'supports different tables same database' do
-  store1 = Moneta::Adapters::ActiveRecord.new(:table => 'adapter_activerecord1', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta', :username => 'root' })
-  store2 = Moneta::Adapters::ActiveRecord.new(:table => 'adapter_activerecord2', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta', :username => 'root' })
+  store1 = Moneta::Adapters::ActiveRecord.new(table: 'adapter_activerecord1', connection: { adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), database: 'moneta', username: 'root' })
+  store2 = Moneta::Adapters::ActiveRecord.new(table: 'adapter_activerecord2', connection: { adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), database: 'moneta', username: 'root' })
 
   store1['key'] = 'value1'
   store2['key'] = 'value2'
@@ -1226,8 +1236,8 @@ it 'supports different tables same database' do
 end
 
 it 'supports different databases same table' do
-  store1 = Moneta::Adapters::ActiveRecord.new(:table => 'adapter_activerecord', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta_activerecord1', :username => 'root' })
-  store2 = Moneta::Adapters::ActiveRecord.new(:table => 'adapter_activerecord', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta_activerecord2', :username => 'root' })
+  store1 = Moneta::Adapters::ActiveRecord.new(table: 'adapter_activerecord', connection: { adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), database: 'moneta_activerecord1', username: 'root' })
+  store2 = Moneta::Adapters::ActiveRecord.new(table: 'adapter_activerecord', connection: { adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), database: 'moneta_activerecord2', username: 'root' })
 
   store1['key'] = 'value1'
   store2['key'] = 'value2'
@@ -1239,51 +1249,51 @@ it 'supports different databases same table' do
 end}
   },
   'adapter_activerecord_exisiting_connection' => {
-    :preamble => "require 'active_record'\nActiveRecord::Base.establish_connection :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta', :username => 'root'\n",
-    :build => "Moneta::Adapters::ActiveRecord.new(:table => 'adapter_activerecord_existing_connection')",
-    :specs => ADAPTER_SPECS
+    preamble: "require 'active_record'\nActiveRecord::Base.establish_connection adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), database: 'moneta', username: 'root'\n",
+    build: "Moneta::Adapters::ActiveRecord.new(table: 'adapter_activerecord_existing_connection')",
+    specs: ADAPTER_SPECS
   },
   'adapter_client' => {
-    :preamble => "start_server(Moneta::Adapters::Memory.new)\n",
-    :build => "Moneta::Adapters::Client.new",
-    :specs => ADAPTER_SPECS
+    preamble: "start_server(Moneta::Adapters::Memory.new)\n",
+    build: "Moneta::Adapters::Client.new",
+    specs: ADAPTER_SPECS
   },
   'adapter_restclient' => {
-    :preamble => "start_restserver\n",
-    :build => "Moneta::Adapters::RestClient.new(:url => 'http://localhost:8808/moneta/')",
-    :specs => ADAPTER_SPECS.without_increment.without_create
+    preamble: "start_restserver\n",
+    build: "Moneta::Adapters::RestClient.new(url: 'http://localhost:8808/moneta/')",
+    specs: ADAPTER_SPECS.without_increment.without_create
   },
   'adapter_cassandra' => {
-    :build => "Moneta::Adapters::Cassandra.new(:keyspace => 'adapter_cassandra')",
-    :specs => ADAPTER_SPECS.without_increment.without_create.with_native_expires
+    build: "Moneta::Adapters::Cassandra.new(keyspace: 'adapter_cassandra')",
+    specs: ADAPTER_SPECS.without_increment.without_create.with_native_expires
   },
   'adapter_cassandra_with_default_expires' => {
-    :build => %{Moneta::Adapters::Cassandra.new(:keyspace => 'adapter_cassandra_with_default_expires', :expires => 1)},
-    :specs => ADAPTER_SPECS.without_increment.without_create.with_native_expires.with_default_expires
+    build: %{Moneta::Adapters::Cassandra.new(keyspace: 'adapter_cassandra_with_default_expires', expires: 1)},
+    specs: ADAPTER_SPECS.without_increment.without_create.with_native_expires.with_default_expires
   },
   'adapter_hbase' => {
-    :build => "Moneta::Adapters::HBase.new(:table => 'adapter_hbase')",
-    :specs => ADAPTER_SPECS.without_create
+    build: "Moneta::Adapters::HBase.new(table: 'adapter_hbase')",
+    specs: ADAPTER_SPECS.without_create
   },
   'adapter_cookie' => {
-    :build => 'Moneta::Adapters::Cookie.new',
-    :specs => ADAPTER_SPECS.without_persist.returnsame
+    build: 'Moneta::Adapters::Cookie.new',
+    specs: ADAPTER_SPECS.without_persist.returnsame
   },
   'adapter_couch' => {
-    :build => "Moneta::Adapters::Couch.new(:db => 'adapter_couch')",
-    :specs => ADAPTER_SPECS.without_increment.simplevalues_only.without_path
+    build: "Moneta::Adapters::Couch.new(db: 'adapter_couch')",
+    specs: ADAPTER_SPECS.without_increment.simplevalues_only.without_path
   },
   'adapter_datamapper' => {
-    :build => 'Moneta::Adapters::DataMapper.new(:setup => "mysql://root:@localhost/moneta", :table => "adapter_datamapper")',
+    build: 'Moneta::Adapters::DataMapper.new(setup: "mysql://root:@localhost/moneta", table: "adapter_datamapper")',
     # DataMapper needs default repository to be setup
-    :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
-    :specs => ADAPTER_SPECS.without_increment,
-    :tests => %q{
+    preamble: "require 'dm-core'\nDataMapper.setup(:default, adapter: :in_memory)\n",
+    specs: ADAPTER_SPECS.without_increment,
+    tests: %q{
 it 'does not cross contaminate when storing' do
-  first = Moneta::Adapters::DataMapper.new(:setup => "mysql://root:@localhost/moneta", :table => "datamapper_first")
+  first = Moneta::Adapters::DataMapper.new(setup: "mysql://root:@localhost/moneta", table: "datamapper_first")
   first.clear
 
-  second = Moneta::Adapters::DataMapper.new(:repository => :sample, :setup => "mysql://root:@localhost/moneta", :table => "datamapper_second")
+  second = Moneta::Adapters::DataMapper.new(repository: :sample, setup: "mysql://root:@localhost/moneta", table: "datamapper_second")
   second.clear
 
   first['key'] = 'value'
@@ -1294,10 +1304,10 @@ it 'does not cross contaminate when storing' do
 end
 
 it 'does not cross contaminate when deleting' do
-  first = Moneta::Adapters::DataMapper.new(:setup => "mysql://root:@localhost/moneta", :table => "datamapper_first")
+  first = Moneta::Adapters::DataMapper.new(setup: "mysql://root:@localhost/moneta", table: "datamapper_first")
   first.clear
 
-  second = Moneta::Adapters::DataMapper.new(:repository => :sample, :setup => "mysql://root:@localhost/moneta", :table => "datamapper_second")
+  second = Moneta::Adapters::DataMapper.new(repository: :sample, setup: "mysql://root:@localhost/moneta", table: "datamapper_second")
   second.clear
 
   first['key'] = 'value'
@@ -1310,73 +1320,73 @@ end
 }
   },
   'adapter_dbm' => {
-    :build => 'Moneta::Adapters::DBM.new(:file => File.join(make_tempdir, "adapter_dbm"))',
-    :specs => ADAPTER_SPECS.without_multiprocess
+    build: 'Moneta::Adapters::DBM.new(file: File.join(make_tempdir, "adapter_dbm"))',
+    specs: ADAPTER_SPECS.without_multiprocess
   },
   'adapter_tdb' => {
-    :build => 'Moneta::Adapters::TDB.new(:file => File.join(make_tempdir, "adapter_tdb"))',
-    :specs => ADAPTER_SPECS.without_multiprocess
+    build: 'Moneta::Adapters::TDB.new(file: File.join(make_tempdir, "adapter_tdb"))',
+    specs: ADAPTER_SPECS.without_multiprocess
   },
   'adapter_daybreak' => {
-    :build => 'Moneta::Adapters::Daybreak.new(:file => File.join(make_tempdir, "adapter_daybreak"))',
-    :specs => ADAPTER_SPECS.without_multiprocess.returnsame
+    build: 'Moneta::Adapters::Daybreak.new(file: File.join(make_tempdir, "adapter_daybreak"))',
+    specs: ADAPTER_SPECS.without_multiprocess.returnsame
   },
   'adapter_file' => {
-    :build => 'Moneta::Adapters::File.new(:dir => File.join(make_tempdir, "adapter_file"))',
-    :specs => ADAPTER_SPECS
+    build: 'Moneta::Adapters::File.new(dir: File.join(make_tempdir, "adapter_file"))',
+    specs: ADAPTER_SPECS
   },
   'adapter_fog' => {
-    :build => "Moneta::Adapters::Fog.new(:aws_access_key_id => 'fake_access_key_id',
-    :aws_secret_access_key  => 'fake_secret_access_key',
-    :provider               => 'AWS',
-    :dir                    => 'adapter_fog')",
+    build: "Moneta::Adapters::Fog.new(aws_access_key_id: 'fake_access_key_id',
+    aws_secret_access_key:  'fake_secret_access_key',
+    provider:               'AWS',
+    dir:                    'adapter_fog')",
     # Put Fog into testing mode
-    :preamble               => "require 'fog'\nFog.mock!\n",
+    preamble:               "require 'fog'\nFog.mock!\n",
     # Fog returns same object in mocking mode (in-memory store)
-    :specs => ADAPTER_SPECS.without_increment.without_create.returnsame
+    specs: ADAPTER_SPECS.without_increment.without_create.returnsame
   },
   'adapter_gdbm' => {
-    :build => 'Moneta::Adapters::GDBM.new(:file => File.join(make_tempdir, "adapter_gdbm"))',
-    :specs => ADAPTER_SPECS.without_multiprocess
+    build: 'Moneta::Adapters::GDBM.new(file: File.join(make_tempdir, "adapter_gdbm"))',
+    specs: ADAPTER_SPECS.without_multiprocess
   },
   'adapter_localmemcache' => {
-    :build => 'Moneta::Adapters::LocalMemCache.new(:file => File.join(make_tempdir, "adapter_localmemcache"))',
-    :specs => ADAPTER_SPECS.without_increment.without_create
+    build: 'Moneta::Adapters::LocalMemCache.new(file: File.join(make_tempdir, "adapter_localmemcache"))',
+    specs: ADAPTER_SPECS.without_increment.without_create
   },
   'adapter_memcached_dalli' => {
-    :build => 'Moneta::Adapters::MemcachedDalli.new(:namespace => "adapter_memcached_dalli")',
-    :specs => ADAPTER_SPECS.with_native_expires
+    build: 'Moneta::Adapters::MemcachedDalli.new(namespace: "adapter_memcached_dalli")',
+    specs: ADAPTER_SPECS.with_native_expires
   },
   'adapter_memcached_dalli_with_default_expires' => {
-    :build => %{Moneta::Adapters::MemcachedDalli.new(:expires => 1)},
-    :specs => ADAPTER_SPECS.with_native_expires.with_default_expires
+    build: %{Moneta::Adapters::MemcachedDalli.new(expires: 1)},
+    specs: ADAPTER_SPECS.with_native_expires.with_default_expires
   },
   'adapter_memcached_native' => {
-    :build => 'Moneta::Adapters::MemcachedNative.new(:namespace => "adapter_memcached_native")',
-    :specs => ADAPTER_SPECS.with_native_expires
+    build: 'Moneta::Adapters::MemcachedNative.new(namespace: "adapter_memcached_native")',
+    specs: ADAPTER_SPECS.with_native_expires
   },
   'adapter_memcached_native_with_default_expires' => {
-    :build => %{Moneta::Adapters::MemcachedNative.new(:expires => 1)},
-    :specs => ADAPTER_SPECS.with_native_expires.with_default_expires
+    build: %{Moneta::Adapters::MemcachedNative.new(expires: 1)},
+    specs: ADAPTER_SPECS.with_native_expires.with_default_expires
   },
   'adapter_memcached' => {
-    :build => 'Moneta::Adapters::Memcached.new(:namespace => "adapter_memcached")',
-    :specs => ADAPTER_SPECS.with_native_expires
+    build: 'Moneta::Adapters::Memcached.new(namespace: "adapter_memcached")',
+    specs: ADAPTER_SPECS.with_native_expires
   },
   'adapter_memcached_with_default_expires' => {
-    :build => %{Moneta::Adapters::Memcached.new(:expires => 1)},
-    :specs => ADAPTER_SPECS.with_native_expires.with_default_expires
+    build: %{Moneta::Adapters::Memcached.new(expires: 1)},
+    specs: ADAPTER_SPECS.with_native_expires.with_default_expires
   },
   'adapter_memory' => {
-    :build => 'Moneta::Adapters::Memory.new',
-    :specs => STANDARD_SPECS.without_transform.returnsame.without_persist
+    build: 'Moneta::Adapters::Memory.new',
+    specs: STANDARD_SPECS.without_transform.returnsame.without_persist
   },
   'adapter_lruhash' => {
-    :build => 'Moneta::Adapters::LRUHash.new',
-    :specs => ADAPTER_SPECS.without_persist.returnsame,
-    :tests => %{
+    build: 'Moneta::Adapters::LRUHash.new',
+    specs: ADAPTER_SPECS.without_persist.returnsame,
+    tests: %{
 it 'deletes oldest' do
-  store = Moneta::Adapters::LRUHash.new(:max_size => 10)
+  store = Moneta::Adapters::LRUHash.new(max_size: 10)
   store[0]  = 'y'
   (1..1000).each do |i|
     store[i] = 'x'
@@ -1390,87 +1400,110 @@ it 'deletes oldest' do
 end}
   },
   'adapter_mongo' => {
-    :build => 'Moneta::Adapters::Mongo.new(:db => "adapter_mongo")',
-    :specs => ADAPTER_SPECS.with_native_expires.simplevalues_only,
-    :tests => %{
+    build: 'Moneta::Adapters::Mongo.new(db: "adapter_mongo")',
+    specs: ADAPTER_SPECS.with_native_expires.simplevalues_only
+  },
+  'adapter_mongo_with_default_expires' => {
+    build: %{Moneta::Adapters::Mongo.new(expires: 1)},
+    specs: ADAPTER_SPECS.with_expires.with_default_expires.simplevalues_only
+  },
+  'adapter_mongo_moped' => {
+    build: 'Moneta::Adapters::MongoMoped.new(db: "adapter_mongo")',
+    specs: ADAPTER_SPECS.with_native_expires.simplevalues_only,
+    tests: %{
 it 'automatically deletes expired document' do
-  store.store('key', 'val', :expires => 5)
+  store.store('key', 'val', expires: 5)
+  store.instance_variable_get(:@collection).find('_id' => ::Moped::BSON::Binary.new(:generic, 'key')).one.should_not be_nil
+  sleep 70 # Mongo needs up to 60 seconds
+  store.instance_variable_get(:@collection).find('_id' => ::Moped::BSON::Binary.new(:generic, 'key')).one.should be_nil
+end}
+  },
+  'adapter_mongo_moped_with_default_expires' => {
+    build: %{Moneta::Adapters::MongoMoped.new(expires: 1)},
+    specs: ADAPTER_SPECS.with_expires.with_default_expires.simplevalues_only
+  },
+  'adapter_mongo_official' => {
+    build: 'Moneta::Adapters::MongoOfficial.new(db: "adapter_mongo")',
+    specs: ADAPTER_SPECS.with_native_expires.simplevalues_only,
+    tests: %{
+it 'automatically deletes expired document' do
+  store.store('key', 'val', expires: 5)
   store.instance_variable_get(:@collection).find_one('_id' => ::BSON::Binary.new('key')).should_not be_nil
   sleep 70 # Mongo needs up to 60 seconds
   store.instance_variable_get(:@collection).find_one('_id' => ::BSON::Binary.new('key')).should be_nil
 end}
   },
-  'adapter_mongo_with_default_expires' => {
-    :build => %{Moneta::Adapters::Mongo.new(:expires => 1)},
-    :specs => ADAPTER_SPECS.with_expires.with_default_expires.simplevalues_only
+  'adapter_mongo_official_with_default_expires' => {
+    build: %{Moneta::Adapters::MongoOfficial.new(expires: 1)},
+    specs: ADAPTER_SPECS.with_expires.with_default_expires.simplevalues_only
   },
   'adapter_pstore' => {
-    :build => 'Moneta::Adapters::PStore.new(:file => File.join(make_tempdir, "adapter_pstore"))',
-    :specs => STANDARD_SPECS.without_transform
+    build: 'Moneta::Adapters::PStore.new(file: File.join(make_tempdir, "adapter_pstore"))',
+    specs: STANDARD_SPECS.without_transform
   },
   'adapter_redis' => {
-    :build => 'Moneta::Adapters::Redis.new',
-    :specs => ADAPTER_SPECS.with_native_expires
+    build: 'Moneta::Adapters::Redis.new',
+    specs: ADAPTER_SPECS.with_native_expires
   },
   'adapter_redis_with_default_expires' => {
-    :build => %{Moneta::Adapters::Redis.new(:expires => 1)},
-    :specs => ADAPTER_SPECS.with_native_expires.with_default_expires
+    build: %{Moneta::Adapters::Redis.new(expires: 1)},
+    specs: ADAPTER_SPECS.with_native_expires.with_default_expires
   },
   'adapter_riak' => {
-    :build => 'Moneta::Adapters::Riak.new',
-    :options => ":bucket => 'adapter_riak'",
-    :specs => ADAPTER_SPECS.without_increment.without_create,
+    build: 'Moneta::Adapters::Riak.new',
+    options: ":bucket => 'adapter_riak'",
+    specs: ADAPTER_SPECS.without_increment.without_create,
     # We don't want Riak warnings in tests
-    :preamble => "require 'riak'\n\nRiak.disable_list_keys_warnings = true\n\n"
+    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_SPECS.without_multiprocess.without_large
+    build: 'Moneta::Adapters::SDBM.new(file: File.join(make_tempdir, "adapter_sdbm"))',
+    specs: ADAPTER_SPECS.without_multiprocess.without_large
   },
   'adapter_lmdb' => {
-    :build => 'Moneta::Adapters::LMDB.new(:dir => File.join(make_tempdir, "adapter_lmdb"))',
-    :specs => ADAPTER_SPECS.without_concurrent
+    build: 'Moneta::Adapters::LMDB.new(dir: File.join(make_tempdir, "adapter_lmdb"))',
+    specs: ADAPTER_SPECS.without_concurrent
   },
   'adapter_lmdb_with_db' => {
-    :build => 'Moneta::Adapters::LMDB.new(:dir => File.join(make_tempdir, "adapter_lmdb"), :db => "adapter_lmdb_with_db")',
-    :specs => ADAPTER_SPECS.without_concurrent
+    build: 'Moneta::Adapters::LMDB.new(dir: File.join(make_tempdir, "adapter_lmdb"), db: "adapter_lmdb_with_db")',
+    specs: ADAPTER_SPECS.without_concurrent
   },
   'adapter_leveldb' => {
-    :build => 'Moneta::Adapters::LevelDB.new(:dir => File.join(make_tempdir, "adapter_leveldb"))',
-    :specs => ADAPTER_SPECS.without_multiprocess
+    build: 'Moneta::Adapters::LevelDB.new(dir: File.join(make_tempdir, "adapter_leveldb"))',
+    specs: ADAPTER_SPECS.without_multiprocess
   },
   'adapter_sequel' => {
-    :build => 'Moneta::Adapters::Sequel.new(:db => (defined?(JRUBY_VERSION) ? "jdbc:mysql://localhost/moneta?user=root" : "mysql2://root:@localhost/moneta"), :table => "adapter_sequel")',
-    :specs => ADAPTER_SPECS
+    build: 'Moneta::Adapters::Sequel.new(db: (defined?(JRUBY_VERSION) ? "jdbc:mysql://localhost/moneta?user=root" : "mysql2://root:@localhost/moneta"), table: "adapter_sequel")',
+    specs: ADAPTER_SPECS
   },
   'adapter_sqlite' => {
-    :build => 'Moneta::Adapters::Sqlite.new(:file => File.join(make_tempdir, "adapter_sqlite"))',
-    :specs => ADAPTER_SPECS.without_concurrent
+    build: 'Moneta::Adapters::Sqlite.new(file: File.join(make_tempdir, "adapter_sqlite"))',
+    specs: ADAPTER_SPECS.without_concurrent
   },
   'adapter_kyotocabinet' => {
-    :build => 'Moneta::Adapters::KyotoCabinet.new(:file => File.join(make_tempdir, "adapter_kyotocabinet.kch"))',
-    :specs => ADAPTER_SPECS.without_multiprocess
+    build: 'Moneta::Adapters::KyotoCabinet.new(file: File.join(make_tempdir, "adapter_kyotocabinet.kch"))',
+    specs: ADAPTER_SPECS.without_multiprocess
   },
   'adapter_tokyocabinet_bdb' => {
-    :build => 'Moneta::Adapters::TokyoCabinet.new(:file => File.join(make_tempdir, "adapter_tokyocabinet_bdb"), :type => :bdb)',
-    :specs => ADAPTER_SPECS.without_multiprocess
+    build: 'Moneta::Adapters::TokyoCabinet.new(file: File.join(make_tempdir, "adapter_tokyocabinet_bdb"), type: :bdb)',
+    specs: ADAPTER_SPECS.without_multiprocess
   },
   'adapter_tokyocabinet_hdb' => {
-    :build => 'Moneta::Adapters::TokyoCabinet.new(:file => File.join(make_tempdir, "adapter_tokyocabinet_hdb"), :type => :hdb)',
-    :specs => ADAPTER_SPECS.without_multiprocess
+    build: 'Moneta::Adapters::TokyoCabinet.new(file: File.join(make_tempdir, "adapter_tokyocabinet_hdb"), type: :hdb)',
+    specs: ADAPTER_SPECS.without_multiprocess
   },
   'adapter_tokyotyrant' => {
-    :build => 'Moneta::Adapters::TokyoTyrant.new',
-    :specs => ADAPTER_SPECS
+    build: 'Moneta::Adapters::TokyoTyrant.new',
+    specs: ADAPTER_SPECS
   },
   'adapter_yaml' => {
-    :build => 'Moneta::Adapters::YAML.new(:file => File.join(make_tempdir, "adapter_yaml"))',
-    :specs => STANDARD_SPECS.simplevalues_only.simplekeys_only.without_transform.without_concurrent
+    build: 'Moneta::Adapters::YAML.new(file: File.join(make_tempdir, "adapter_yaml"))',
+    specs: STANDARD_SPECS.simplevalues_only.simplekeys_only.without_transform.without_concurrent
   },
   'mutex' => {
-    :store => :Memory,
-    :specs => Specs.new,
-    :tests => %{
+    store: :Memory,
+    specs: Specs.new,
+    tests: %{
 it 'should have #lock' do
   mutex = Moneta::Mutex.new(store, 'mutex')
   mutex.lock.should be_true
@@ -1525,9 +1558,9 @@ end
   }
   },
   'semaphore' => {
-    :store => :Memory,
-    :specs => Specs.new,
-    :tests => %{
+    store: :Memory,
+    specs: Specs.new,
+    tests: %{
 it 'should have #lock' do
   mutex = Moneta::Semaphore.new(store, 'semaphore')
   mutex.lock.should be_true
@@ -1595,17 +1628,17 @@ end
   }
   },
   'optionmerger' => {
-    :store => :Memory,
-    :specs => Specs.new,
-    :tests => %{
+    store: :Memory,
+    specs: Specs.new,
+    tests: %{
 it '#with should return OptionMerger' do
-  options = {:optionname => :optionvalue}
+  options = {optionname: :optionvalue}
   merger = store.with(options)
   merger.should be_instance_of(Moneta::OptionMerger)
 end
 
 it 'saves default options' do
-  options = {:optionname => :optionvalue}
+  options = {optionname: :optionvalue}
   merger = store.with(options)
   Moneta::OptionMerger::METHODS.each do |method|
     merger.default_options[method].should equal(options)
@@ -1615,42 +1648,42 @@ end
 PREFIX = [['alpha', nil], ['beta', nil], ['alpha', 'beta']]
 
 it 'merges options' do
-  merger = store.with(:opt1 => :val1, :opt2 => :val2).with(:opt2 => :overwrite, :opt3 => :val3)
+  merger = store.with(opt1: :val1, opt2: :val2).with(opt2: :overwrite, opt3: :val3)
   Moneta::OptionMerger::METHODS.each do |method|
-    merger.default_options[method].should == {:opt1 => :val1, :opt2 => :overwrite, :opt3 => :val3}
+    merger.default_options[method].should == {opt1: :val1, opt2: :overwrite, opt3: :val3}
   end
 end
 
 it 'merges options only for some methods' do
   PREFIX.each do |(alpha,beta)|
-    options = {:opt1 => :val1, :opt2 => :val2, :prefix => alpha}
-    merger = store.with(options).with(:opt2 => :overwrite, :opt3 => :val3, :prefix => beta, :only => :clear)
+    options = {opt1: :val1, opt2: :val2, prefix: alpha}
+    merger = store.with(options).with(opt2: :overwrite, opt3: :val3, prefix: beta, only: :clear)
     (Moneta::OptionMerger::METHODS - [:clear]).each do |method|
       merger.default_options[method].should equal(options)
     end
-    merger.default_options[:clear].should == {:opt1 => :val1, :opt2 => :overwrite, :opt3 => :val3, :prefix => "\#{alpha}\#{beta}"}
+    merger.default_options[:clear].should == {opt1: :val1, opt2: :overwrite, opt3: :val3, prefix: "\#{alpha}\#{beta}"}
 
-    merger = store.with(options).with(:opt2 => :overwrite, :opt3 => :val3, :prefix => beta, :only => [:load, :store])
+    merger = store.with(options).with(opt2: :overwrite, opt3: :val3, prefix: beta, only: [:load, :store])
     (Moneta::OptionMerger::METHODS - [:load, :store]).each do |method|
       merger.default_options[method].should equal(options)
     end
-    merger.default_options[:load].should == {:opt1 => :val1, :opt2 => :overwrite, :opt3 => :val3, :prefix => "\#{alpha}\#{beta}"}
-    merger.default_options[:store].should == {:opt1 => :val1, :opt2 => :overwrite, :opt3 => :val3, :prefix => "\#{alpha}\#{beta}"}
+    merger.default_options[:load].should == {opt1: :val1, opt2: :overwrite, opt3: :val3, prefix: "\#{alpha}\#{beta}"}
+    merger.default_options[:store].should == {opt1: :val1, opt2: :overwrite, opt3: :val3, prefix: "\#{alpha}\#{beta}"}
   end
 end
 
 it 'merges options except for some methods' do
   PREFIX.each do |(alpha,beta)|
-    options = {:opt1 => :val1, :opt2 => :val2, :prefix => alpha}
-    merger = store.with(options).with(:opt2 => :overwrite, :opt3 => :val3, :except => :clear, :prefix => beta)
+    options = {opt1: :val1, opt2: :val2, prefix: alpha}
+    merger = store.with(options).with(opt2: :overwrite, opt3: :val3, except: :clear, prefix: beta)
     (Moneta::OptionMerger::METHODS - [:clear]).each do |method|
-      merger.default_options[method].should == {:opt1 => :val1, :opt2 => :overwrite, :opt3 => :val3, :prefix => "\#{alpha}\#{beta}"}
+      merger.default_options[method].should == {opt1: :val1, opt2: :overwrite, opt3: :val3, prefix: "\#{alpha}\#{beta}"}
     end
     merger.default_options[:clear].should equal(options)
 
-    merger = store.with(options).with(:opt2 => :overwrite, :opt3 => :val3, :prefix => beta, :except => [:load, :store])
+    merger = store.with(options).with(opt2: :overwrite, opt3: :val3, prefix: beta, except: [:load, :store])
     (Moneta::OptionMerger::METHODS - [:load, :store]).each do |method|
-      merger.default_options[method].should == {:opt1 => :val1, :opt2 => :overwrite, :opt3 => :val3, :prefix => "\#{alpha}\#{beta}"}
+      merger.default_options[method].should == {opt1: :val1, opt2: :overwrite, opt3: :val3, prefix: "\#{alpha}\#{beta}"}
     end
     merger.default_options[:load].should equal(options)
     merger.default_options[:store].should equal(options)
@@ -1658,29 +1691,29 @@ it 'merges options except for some methods' do
 end
 
 it 'has method #raw' do
-  store.raw.default_options.should == {:store=>{:raw=>true},:create=>{:raw=>true},:load=>{:raw=>true},:delete=>{:raw=>true}}
+  store.raw.default_options.should == {store:{raw:true},create:{raw:true},load:{raw:true},delete:{raw:true}}
   store.raw.should equal(store.raw.raw)
 end
 
 it 'has method #expires' do
-  store.expires(10).default_options.should == {:store=>{:expires=>10},:create=>{:expires=>10},:increment=>{:expires=>10}}
+  store.expires(10).default_options.should == {store:{expires:10},create:{expires:10},increment:{expires:10}}
 end
 
 it 'has method #prefix' do
-  store.prefix('a').default_options.should == {:store=>{:prefix=>'a'},:load=>{:prefix=>'a'},:create=>{:prefix=>'a'},
-                                               :delete=>{:prefix=>'a'},:key? => {:prefix=>'a'},:increment=>{:prefix=>'a'}}
+  store.prefix('a').default_options.should == {store:{prefix:'a'},load:{prefix:'a'},create:{prefix:'a'},
+                                               delete:{prefix:'a'},key?: {prefix:'a'},increment:{prefix:'a'}}
 
-  store.prefix('a').prefix('b').default_options.should == {:store=>{:prefix=>'ab'},:load=>{:prefix=>'ab'},:create=>{:prefix=>'ab'},
-                                                           :delete=>{:prefix=>'ab'},:key? => {:prefix=>'ab'},:increment=>{:prefix=>'ab'}}
+  store.prefix('a').prefix('b').default_options.should == {store:{prefix:'ab'},load:{prefix:'ab'},create:{prefix:'ab'},
+                                                           delete:{prefix:'ab'},key?: {prefix:'ab'},increment:{prefix:'ab'}}
 
-  store.raw.prefix('b').default_options.should == {:store=>{:raw=>true,:prefix=>'b'},:load=>{:raw=>true,:prefix=>'b'},:create=>{:raw=>true,:prefix=>'b'},:delete=>{:raw=>true,:prefix=>'b'},:key? => {:prefix=>'b'},:increment=>{:prefix=>'b'}}
+  store.raw.prefix('b').default_options.should == {store:{raw:true,prefix:'b'},load:{raw:true,prefix:'b'},create:{raw:true,prefix:'b'},delete:{raw:true,prefix:'b'},key?: {prefix:'b'},increment:{prefix:'b'}}
 
-  store.prefix('a').raw.default_options.should == {:store=>{:raw=>true,:prefix=>'a'},:load=>{:raw=>true,:prefix=>'a'},:create=>{:raw=>true,:prefix=>'a'},:delete=>{:raw=>true,:prefix=>'a'},:key? => {:prefix=>'a'},:increment=>{:prefix=>'a'}}
+  store.prefix('a').raw.default_options.should == {store:{raw:true,prefix:'a'},load:{raw:true,prefix:'a'},create:{raw:true,prefix:'a'},delete:{raw:true,prefix:'a'},key?: {prefix:'a'},increment:{prefix:'a'}}
 end
 
 it 'supports adding proxis using #with' do
-  compressed_store = store.with(:prefix => 'compressed') do
-    use :Transformer, :value => :zlib
+  compressed_store = store.with(prefix: 'compressed') do
+    use :Transformer, value: :zlib
   end
   store['key'] = 'uncompressed value'
   compressed_store['key'] = 'compressed value'
@@ -1768,7 +1801,7 @@ it 'fetches a key with a block with fetch, if the key is not available' do
 end
 
 it 'accepts frozen options' do
-  options = {:option1 => 1, :options2 => 2}
+  options = {option1: 1, options2: 2}
   options.freeze
   store.key?(#{key1}, options).should be_false
   store.load(#{key1}, options).should be_nil
@@ -1902,8 +1935,8 @@ SPECS['multiprocess'] = %{it 'supports access by multiple instances/processes' d
   store2.close
 end}
 
-SPECS['expires'] = %{it 'supports expires on store and []', :retry => 3 do
-  store.store('key1', 'val1', :expires => 3)
+SPECS['expires'] = %{it 'supports expires on store and []', retry: 3 do
+  store.store('key1', 'val1', expires: 3)
   store['key1'].should == 'val1'
   sleep 1
   store['key1'].should == 'val1'
@@ -1912,14 +1945,14 @@ SPECS['expires'] = %{it 'supports expires on store and []', :retry => 3 do
 end
 
 it 'supports strict expires on store and []' do
-  store.store('key1', 'val1', :expires => 2)
+  store.store('key1', 'val1', expires: 2)
   store['key1'].should == 'val1'
   sleep 3 # Sleep 3 seconds because after 2 seconds the value can still exist!
   store['key1'].should be_nil
 end
 
-it 'supports expires on store and fetch', :retry => 3 do
-  store.store('key1', 'val1', :expires => 3)
+it 'supports expires on store and fetch', retry: 3 do
+  store.store('key1', 'val1', expires: 3)
   store.fetch('key1').should == 'val1'
   sleep 1
   store.fetch('key1').should == 'val1'
@@ -1928,28 +1961,28 @@ it 'supports expires on store and fetch', :retry => 3 do
 end
 
 it 'supports strict expires on store and fetch' do
-  store.store('key1', 'val1', :expires => 2)
+  store.store('key1', 'val1', expires: 2)
   store.fetch('key1').should == 'val1'
   sleep 3 # Sleep 3 seconds because after 2 seconds the value can still exist!
   store.fetch('key1').should be_nil
 end
 
 it 'supports 0 as no-expires on store and []' do
-  store.store('key1', 'val1', :expires => 0)
+  store.store('key1', 'val1', expires: 0)
   store['key1'].should == 'val1'
   sleep 2
   store['key1'].should == 'val1'
 end
 
 it 'supports false as no-expires on store and []' do
-  store.store('key1', 'val1', :expires => false)
+  store.store('key1', 'val1', expires: false)
   store['key1'].should == 'val1'
   sleep 2
   store['key1'].should == 'val1'
 end
 
-it 'supports expires on store and load', :retry => 3 do
-  store.store('key1', 'val1', :expires => 3)
+it 'supports expires on store and load', retry: 3 do
+  store.store('key1', 'val1', expires: 3)
   store.load('key1').should == 'val1'
   sleep 1
   store.load('key1').should == 'val1'
@@ -1958,14 +1991,14 @@ it 'supports expires on store and load', :retry => 3 do
 end
 
 it 'supports strict expires on store and load' do
-  store.store('key1', 'val1', :expires => 2)
+  store.store('key1', 'val1', expires: 2)
   store.load('key1').should == 'val1'
   sleep 3 # Sleep 3 seconds because after 2 seconds the value can still exist!
   store.load('key1').should be_nil
 end
 
-it 'supports expires on store and #key?', :retry => 3 do
-  store.store('key1', 'val1', :expires => 3)
+it 'supports expires on store and #key?', retry: 3 do
+  store.store('key1', 'val1', expires: 3)
   store.key?('key1').should be_true
   sleep 1
   store.key?('key1').should be_true
@@ -1974,17 +2007,17 @@ it 'supports expires on store and #key?', :retry => 3 do
 end
 
 it 'supports strict expires on store and #key?' do
-  store.store('key1', 'val1', :expires => 2)
+  store.store('key1', 'val1', expires: 2)
   store.key?('key1').should be_true
   sleep 3 # Sleep 3 seconds because after 2 seconds the value can still exist!
   store.key?('key1').should be_false
 end
 
-it 'supports updating the expiration time in load', :retry => 3 do
-  store.store('key2', 'val2', :expires => 3)
+it 'supports updating the expiration time in load', retry: 3 do
+  store.store('key2', 'val2', expires: 3)
   store['key2'].should == 'val2'
   sleep 1
-  store.load('key2', :expires => 5).should == 'val2'
+  store.load('key2', expires: 5).should == 'val2'
   store['key2'].should == 'val2'
   sleep 3
   store['key2'].should == 'val2'
@@ -1993,24 +2026,24 @@ it 'supports updating the expiration time in load', :retry => 3 do
 end
 
 it 'supports 0 as no-expires in load' do
-  store.store('key1', 'val1', :expires => 2)
-  store.load('key1', :expires => 0).should == 'val1'
+  store.store('key1', 'val1', expires: 2)
+  store.load('key1', expires: 0).should == 'val1'
   sleep 3
   store.load('key1').should == 'val1'
 end
 
 it 'supports false as no-expires in load' do
-  store.store('key1', 'val1', :expires => 2)
-  store.load('key1', :expires => false).should == 'val1'
+  store.store('key1', 'val1', expires: 2)
+  store.load('key1', expires: false).should == 'val1'
   sleep 3
   store.load('key1').should == 'val1'
 end
 
-it 'supports updating the expiration time in #key?', :retry => 3 do
-  store.store('key2', 'val2', :expires => 3)
+it 'supports updating the expiration time in #key?', retry: 3 do
+  store.store('key2', 'val2', expires: 3)
   store['key2'].should == 'val2'
   sleep 1
-  store.key?('key2', :expires => 5).should be_true
+  store.key?('key2', expires: 5).should be_true
   store['key2'].should == 'val2'
   sleep 3
   store['key2'].should == 'val2'
@@ -2019,24 +2052,24 @@ it 'supports updating the expiration time in #key?', :retry => 3 do
 end
 
 it 'supports 0 as no-expires in #key?' do
-  store.store('key1', 'val1', :expires => 2)
-  store.key?('key1', :expires => 0).should be_true
+  store.store('key1', 'val1', expires: 2)
+  store.key?('key1', expires: 0).should be_true
   sleep 3
   store['key1'].should == 'val1'
 end
 
 it 'supports false as no-expires in #key?' do
-  store.store('key1', 'val1', :expires => 2)
-  store.key?('key1', :expires => false ).should be_true
+  store.store('key1', 'val1', expires: 2)
+  store.key?('key1', expires: false ).should be_true
   sleep 3
   store['key1'].should == 'val1'
 end
 
-it 'supports updating the expiration time in fetch', :retry => 3 do
-  store.store('key1', 'val1', :expires => 3)
+it 'supports updating the expiration time in fetch', retry: 3 do
+  store.store('key1', 'val1', expires: 3)
   store['key1'].should == 'val1'
   sleep 1
-  store.fetch('key1', nil, :expires => 5).should == 'val1'
+  store.fetch('key1', nil, expires: 5).should == 'val1'
   store['key1'].should == 'val1'
   sleep 3
   store['key1'].should == 'val1'
@@ -2045,28 +2078,28 @@ it 'supports updating the expiration time in fetch', :retry => 3 do
 end
 
 it 'supports 0 as no-expires in fetch' do
-  store.store('key1', 'val1', :expires => 2)
-  store.fetch('key1', nil, :expires => 0).should == 'val1'
+  store.store('key1', 'val1', expires: 2)
+  store.fetch('key1', nil, expires: 0).should == 'val1'
   sleep 3
   store.load('key1').should == 'val1'
 end
 
 it 'supports false as no-expires in fetch' do
-  store.store('key1', 'val1', :expires => 2)
-  store.fetch('key1', nil, :expires => false).should == 'val1'
+  store.store('key1', 'val1', expires: 2)
+  store.fetch('key1', nil, expires: false).should == 'val1'
   sleep 3
   store.load('key1').should == 'val1'
 end
 
 it 'strictly respects expires in delete' do
-  store.store('key2', 'val2', :expires => 2)
+  store.store('key2', 'val2', expires: 2)
   store['key2'].should == 'val2'
   sleep 3 # Sleep 3 seconds because after 2 seconds the value can still exist!
   store.delete('key2').should be_nil
 end
 
-it 'respects expires in delete', :retry => 3 do
-  store.store('key2', 'val2', :expires => 3)
+it 'respects expires in delete', retry: 3 do
+  store.store('key2', 'val2', expires: 3)
   store['key2'].should == 'val2'
   sleep 1
   store['key2'].should == 'val2'
@@ -2074,8 +2107,8 @@ it 'respects expires in delete', :retry => 3 do
   store.delete('key2').should be_nil
 end
 
-it 'supports the #expires syntactic sugar', :retry => 3 do
-  store.store('persistent_key', 'persistent_value', :expires => 0)
+it 'supports the #expires syntactic sugar', retry: 3 do
+  store.store('persistent_key', 'persistent_value', expires: 0)
   store.expires(1).store('key2', 'val2')
   store['key2'].should == 'val2'
   sleep 2
@@ -2084,32 +2117,32 @@ it 'supports the #expires syntactic sugar', :retry => 3 do
 end
 
 it 'supports false as no-expires on store and []' do
-  store.store('key1', 'val1', :expires => false)
+  store.store('key1', 'val1', expires: false)
   store['key1'].should == 'val1'
   sleep 2
   store['key1'].should == 'val1'
 end
 
-it 'does not update the expiration time in #key? when not asked to do so', :retry => 3 do
-  store.store('key1', 'val1', :expires => 1)
+it 'does not update the expiration time in #key? when not asked to do so', retry: 3 do
+  store.store('key1', 'val1', expires: 1)
   store.key?('key1').should be_true
-  store.key?('key1', :expires => nil).should be_true
+  store.key?('key1', expires: nil).should be_true
   sleep 2
   store.key?('key1').should be_false
 end
 
-it 'does not update the expiration time in fetch when not asked to do so', :retry => 3 do
-  store.store('key1', 'val1', :expires => 1)
+it 'does not update the expiration time in fetch when not asked to do so', retry: 3 do
+  store.store('key1', 'val1', expires: 1)
   store.fetch('key1').should == 'val1'
-  store.fetch('key1', :expires => nil).should == 'val1'
+  store.fetch('key1', expires: nil).should == 'val1'
   sleep 2
   store.fetch('key1').should be_nil
 end
 
-it 'does not update the expiration time in load when not asked to do so', :retry => 3 do
-  store.store('key1', 'val1', :expires => 1)
+it 'does not update the expiration time in load when not asked to do so', retry: 3 do
+  store.store('key1', 'val1', expires: 1)
   store.load('key1').should == 'val1'
-  store.load('key1', :expires => nil).should == 'val1'
+  store.load('key1', expires: nil).should == 'val1'
   sleep 2
   store.load('key1').should be_nil
 end}
@@ -2142,10 +2175,10 @@ SPECS['concurrent_increment'] = %{def increment_thread(name)
     s = new_store
     100.times do |i|
       100.times do |j|
-        s.increment("counter\#{j}", 1, :expires => false)
+        s.increment("counter\#{j}", 1, expires: false)
         Thread.pass if rand(1000) >= 995
       end
-      s.store("\#{name}\#{i}", i.to_s, :expires => false)
+      s.store("\#{name}\#{i}", i.to_s, expires: false)
     end
     s.close
   end
@@ -2172,7 +2205,7 @@ SPECS['concurrent_create'] = %{def create_thread(name)
   Thread.new do
     s = new_store
     1000.times do |i|
-      s[i.to_s].should == name if s.create(i.to_s, name, :expires => false)
+      s[i.to_s].should == name if s.create(i.to_s, name, expires: false)
       Thread.pass if rand(100) >= 99
     end
     s.close
@@ -2194,9 +2227,9 @@ SPECS['increment'] = %{it 'initializes in #increment with 1' do
   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.load('inckey', raw: true).should == '1'
 
-  store.delete('inckey', :raw => true).should == '1'
+  store.delete('inckey', raw: true).should == '1'
   store.key?('inckey').should be_false
 end
 
@@ -2204,14 +2237,14 @@ it 'initializes in #increment with higher value' do
   store.increment('inckey', 42).should == 42
   store.key?('inckey').should be_true
   store.raw['inckey'].should == '42'
-  store.delete('inckey', :raw => true).should == '42'
+  store.delete('inckey', raw: true).should == '42'
 end
 
 it 'initializes in #increment with 0' do
   store.increment('inckey', 0).should == 0
   store.key?('inckey').should be_true
   store.raw['inckey'].should == '0'
-  store.delete('inckey', :raw => true).should == '0'
+  store.delete('inckey', raw: true).should == '0'
 end
 
 it 'initializes in #decrement with 0' do
@@ -2253,7 +2286,7 @@ it 'supports decrementing existing value' do
 end
 
 it 'interprets raw value as integer' do
-  store.store('inckey', '42', :raw => true)
+  store.store('inckey', '42', raw: true)
   store.increment('inckey').should == 43
   store.raw['inckey'].should == '43'
 end
@@ -2318,15 +2351,15 @@ SPECS['not_create'] = %{it 'does not support #create' do
 end}
 
 SPECS['create_expires'] = %{it 'creates the given key and expires it' do
-  store.create('key','value', :expires => 1).should be_true
+  store.create('key','value', expires: 1).should be_true
   store['key'].should == 'value'
   sleep 2
   store.key?('key').should be_false
 end
 
 it 'does not change expires if the key exists' do
-  store.store('key', 'value', :expires => false).should == 'value'
-  store.create('key','another value', :expires => 1).should be_false
+  store.store('key', 'value', expires: false).should == 'value'
+  store.create('key','another value', expires: 1).should be_false
   store['key'].should == 'value'
   sleep 2
   store['key'].should == 'value'
@@ -2383,11 +2416,11 @@ end}
 
 SPECS['transform_value']  = %{it 'allows to bypass transformer with :raw' do
   store['key'] = 'value'
-  load_value(store.load('key', :raw => true)).should == 'value'
+  load_value(store.load('key', raw: true)).should == 'value'
 
-  store.store('key', 'value', :raw => true)
-  store.load('key', :raw => true).should == 'value'
-  store.delete('key', :raw => true).should == 'value'
+  store.store('key', 'value', raw: true)
+  store.load('key', raw: true).should == 'value'
+  store.delete('key', raw: true).should == 'value'
 end
 
 it 'allows to bypass transformer with raw syntactic sugar' do
@@ -2404,12 +2437,12 @@ it 'allows to bypass transformer with raw syntactic sugar' do
 end
 
 it 'returns unmarshalled value' do
-  store.store('key', 'unmarshalled value', :raw => true)
-  store.load('key', :raw => true).should == 'unmarshalled value'
+  store.store('key', 'unmarshalled value', raw: true)
+  store.load('key', raw: true).should == 'unmarshalled value'
 end
 
 it 'might raise exception on invalid value' do
-  store.store('key', 'unmarshalled value', :raw => true)
+  store.store('key', 'unmarshalled value', raw: true)
 
   begin
     store['key'].should == load_value('unmarshalled value')
@@ -2426,30 +2459,30 @@ end}
 
 SPECS['transform_value_expires']  = %{it 'allows to bypass transformer with :raw' do
   store['key'] = 'value'
-  load_value(store.load('key', :raw => true)).should == 'value'
+  load_value(store.load('key', raw: true)).should == 'value'
   store['key'] = [1,2,3]
-  load_value(store.load('key', :raw => true)).should == [[1,2,3]]
+  load_value(store.load('key', raw: true)).should == [[1,2,3]]
   store['key'] = nil
-  load_value(store.load('key', :raw => true)).should == [nil]
+  load_value(store.load('key', raw: true)).should == [nil]
   store['key'] = false
-  load_value(store.load('key', :raw => true)).should be_false
+  load_value(store.load('key', raw: true)).should be_false
 
-  store.store('key', 'value', :expires => 10)
-  load_value(store.load('key', :raw => true)).first.should == 'value'
-  load_value(store.load('key', :raw => true)).last.should respond_to(:to_int)
+  store.store('key', 'value', expires: 10)
+  load_value(store.load('key', raw: true)).first.should == 'value'
+  load_value(store.load('key', raw: true)).last.should respond_to(:to_int)
 
-  store.store('key', 'value', :raw => true)
-  store.load('key', :raw => true).should == 'value'
-  store.delete('key', :raw => true).should == 'value'
+  store.store('key', 'value', raw: true)
+  store.load('key', raw: true).should == 'value'
+  store.delete('key', raw: true).should == 'value'
 end
 
 it 'returns unmarshalled value' do
-  store.store('key', 'unmarshalled value', :raw => true)
-  store.load('key', :raw => true).should == 'unmarshalled value'
+  store.store('key', 'unmarshalled value', raw: true)
+  store.load('key', raw: true).should == 'unmarshalled value'
 end
 
 it 'might raise exception on invalid value' do
-  store.store('key', 'unmarshalled value', :raw => true)
+  store.store('key', 'unmarshalled value', raw: true)
 
   begin
     store['key'].should == load_value('unmarshalled value')
@@ -2509,7 +2542,7 @@ TESTS.each do |name, options|
   opts = options.delete(:options)
   opts = ', ' << opts if opts
 
-  build ||= "Moneta.new(#{store.inspect}#{opts}, :logger => {:file => File.join(make_tempdir, '#{name}.log')})"
+  build ||= "Moneta.new(#{store.inspect}#{opts}, logger: {file: File.join(make_tempdir, '#{name}.log')})"
 
   code = %{#{header}require 'helper'