moneta 0.8.0 → 0.8.1

data/lib/moneta/adapters/sequel.rb

@@ -28,7 +28,7 @@ module Moneta
           end
         @backend.create_table?(table) do
           String :k, null: false, primary_key: true
-          Blob :v
+          File :v
         end
         @table = @backend[table]
       end

data/lib/moneta/adapters/tokyotyrant.rb

@@ -14,6 +14,9 @@ module Moneta
       include Defaults
       include HashAdapter
 
+      # error code: no record found
+      ENOREC = 7
+
       supports :create, :increment
       attr_reader :backend
 
@@ -29,7 +32,7 @@ module Moneta
         elsif defined?(::TokyoTyrant::RDB)
           # Use ruby client
           @backend = ::TokyoTyrant::RDB.new
-          @backend.open(options[:host], options[:port]) or raise @backend.errmsg(@backend.ecode)
+          @backend.open(options[:host], options[:port]) or error
         else
           # Use native client
           @backend = ::TokyoTyrant::DB.new(options[:host], options[:port])
@@ -44,12 +47,14 @@ module Moneta
       # (see Proxy#load)
       def load(key, options = {})
         value = @backend[key]
+        # raise if there is an error and the error is not "no record"
+        error if value.nil? && @backend.ecode != ENOREC
         value && unpack(value)
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @backend[key] = pack(value)
+        @backend.put(key, pack(value)) or error
         value
       end
 
@@ -57,14 +62,14 @@ module Moneta
       def delete(key, options = {})
         value = load(key, options)
         if value
-          @backend.delete(key)
+          @backend.delete(key) or error
           value
         end
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @backend.addint(key, amount) || raise('Tried to increment non integer value')
+        @backend.addint(key, amount) or error
       end
 
       # (see Proxy#create)
@@ -113,6 +118,10 @@ module Moneta
           value
         end
       end
+
+      def error
+        raise "#{@backend.class.name} error: #{@backend.errmsg}"
+      end
     end
   end
 end

data/lib/moneta/builder.rb

@@ -63,7 +63,7 @@ module Moneta
 
     def new_proxy(klass, *args, &block)
       klass.new(*args, &block)
-    rescue ArgumentError => ex
+    rescue ArgumentError
       check_arity(klass, klass.allocate, args.size)
       raise
     end

data/lib/moneta/transformer/config.rb

@@ -5,7 +5,7 @@ module Moneta
       # 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'          ],
+      bson:     [ :serialize, 'Helper::BSON.load(%s)',        'Helper::BSON.dump(%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'       ],
@@ -13,7 +13,7 @@ module Moneta
       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'         ],
+      bzip2:    [ :compress,  'Helper.bunzip2(%s)',           'Helper.bzip2(%s)',                'rbzip2'        ],
       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'       ],

data/lib/moneta/transformer/helper.rb

@@ -14,11 +14,11 @@ module Moneta
 
       def hmacverify(value, secret)
         hash, value = value[0..31], value[32..-1]
-        value if hash == OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha256'), secret, value)
+        value if hash == OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), secret, value)
       end
 
       def hmacsign(value, secret)
-        OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha256'), secret, value) << value
+        OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), secret, value) << value
       end
 
       def truncate(value, maxlen)
@@ -32,6 +32,20 @@ module Moneta
       def spread(value)
         ::File.join(value[0..1], value[2..-1])
       end
+
+      def bzip2(value)
+        io = ::StringIO.new
+        bz = ::RBzip2::Compressor.new(io)
+        bz.write(value)
+        bz.close
+        io.string
+      end
+
+      def bunzip2(value)
+        ::RBzip2::Decompressor.new(::StringIO.new(value)).read
+      end
+
+      autoload :BSON, 'moneta/transformer/helper/bson'
     end
   end
 end

data/lib/moneta/transformer/helper/bson.rb

@@ -0,0 +1,25 @@
+module Moneta
+  class Transformer
+    module Helper::BSON
+      extend self
+
+      if ::BSON::VERSION >= '4.0.0'
+        def load value
+          ::BSON::Document.from_bson(::BSON::ByteBuffer.new(value))['v']
+        end
+
+        def dump value
+          ::BSON::Document['v'=>value].to_bson.to_s
+        end
+      else
+        def load value
+          ::BSON::Document.from_bson(::StringIO.new(value))['v']
+        end
+
+        def dump value
+          ::BSON::Document['v'=>value].to_bson
+        end
+      end
+    end
+  end
+end

data/lib/moneta/version.rb

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

data/lib/rack/cache/moneta.rb

@@ -1,7 +1,7 @@
 require 'moneta'
 require 'rack/cache/key'
-require 'rack/cache/metastore'
-require 'rack/cache/entitystore'
+require 'rack/cache/meta_store'
+require 'rack/cache/entity_store'
 
 module Rack
   module Cache

data/script/generate-specs

@@ -425,17 +425,17 @@ end
   },
   'standard_mongo' => {
     store: :Mongo,
-    options: "db: 'standard_mongo'",
+    options: "db: 'standard_mongo', collection: 'default'",
     specs: STANDARD_SPECS.with_native_expires
   },
   'standard_mongo_moped' => {
     store: :MongoMoped,
-    options: "db: 'standard_mongo_moped'",
+    options: "db: 'standard_mongo', collection: 'moped'",
     specs: STANDARD_SPECS.with_native_expires
   },
   'standard_mongo_official' => {
     store: :MongoOfficial,
-    options: "db: 'standard_mongo_official'",
+    options: "db: 'standard_mongo', collection: 'official'",
     specs: STANDARD_SPECS.with_native_expires
   },
   'standard_null' => {
@@ -633,7 +633,7 @@ end},
 it 'shares values' do
   store['shared_key'] = 'shared_value'
   second = new_store
-  second.key?('shared_key').should be_true
+  second.key?('shared_key').should be true
   second['shared_key'].should == 'shared_value'
   second.close
 end
@@ -650,7 +650,7 @@ end},
 it 'shares values' do
   store['shared_key'] = 'shared_value'
   second = new_store
-  second.key?('shared_key').should be_true
+  second.key?('shared_key').should be true
   second['shared_key'].should == 'shared_value'
   second.close
 end
@@ -710,7 +710,7 @@ end}
   adapter :Memory
 end},
     specs: TRANSFORMER_SPECS.stringvalues_only,
-    load_value: '::Bzip2.uncompress(value)',
+    load_value: '::RBzip2::Decompressor.new(::StringIO.new(value)).read',
     tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
@@ -828,7 +828,12 @@ end}
   adapter :Memory
 end},
     specs: TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
-    load_value: "::BSON.deserialize(value)['v']",
+    load_value: %{
+    if ::BSON::VERSION >= '4.0.0'
+      ::BSON::Document.from_bson(::BSON::ByteBuffer.new(value))['v']
+    else
+      ::BSON::Document.from_bson(::StringIO.new(value))['v']
+    end},
     tests: %{
 it 'compile transformer class' do
   store.should_not be_nil
@@ -1314,7 +1319,7 @@ it 'does not cross contaminate when deleting' do
   second['key'] = 'value2'
 
   first.delete('key').should == 'value'
-  first.key?('key').should be_false
+  first.key?('key').should be false
   second['key'].should == 'value2'
 end
 }
@@ -1395,46 +1400,168 @@ it 'deletes oldest' do
     (0...[9, i-1].min).each do |j|
       store.instance_variable_get(:@entry)[i-j].should_not be_nil
     end
-    store.key?(i-9).should be_false if i > 9
+    store.key?(i-9).should be false if i > 9
   end
+end
+
+it 'adds a value that is the same as max_size' do
+  store = Moneta::Adapters::LRUHash.new(max_size: 21)
+  store[:a_key] = 'This is 21 bytes long'
+  store[:a_key].should eq('This is 21 bytes long')
+end
+
+it 'does not add a value that is larger than max_size' do
+  store = Moneta::Adapters::LRUHash.new(max_size: 20)
+  store[:too_long] = 'This is 21 bytes long'
+  store[:too_long].should be_nil
+end
+
+it 'removes an existing key that is replaced by an item that is larger than max_size' do
+  store = Moneta::Adapters::LRUHash.new(max_size: 20)
+  store[:a_key] = 'This will fit'
+  store[:a_key] = 'This is 21 bytes long'
+  store[:a_key].should be_nil
+end
+
+it 'does not add a value that is larger than max_size, when max_value is explicitly missing' do
+  store = Moneta::Adapters::LRUHash.new(max_size: 20, max_value: nil)
+  store[:too_long] = 'This is 21 bytes long'
+  store[:too_long].should be_nil
+end
+
+it 'does not add a value that is larger than max_size, even if max_value is larger than max_size' do
+  store = Moneta::Adapters::LRUHash.new(max_size: 20, max_value: 25)
+  store[:too_long] = 'This is 21 bytes long'
+  store[:too_long].should be_nil
+end
+
+it 'adds a value that is as large as the default max_size when max_size is missing' do
+  store = Moneta::Adapters::LRUHash.new
+  large_item = 'Really big'
+  allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash::DEFAULT_MAX_SIZE)
+  store[:really_big] = large_item
+  store[:really_big].should eq(large_item)
+end
+
+it 'does not add values that are larger than the default max_size when max_size is missing' do
+  store = Moneta::Adapters::LRUHash.new
+  large_item = 'Really big'
+  allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash::DEFAULT_MAX_SIZE + 1)
+  store[:really_big] = large_item
+  store[:really_big].should be_nil
+end
+
+it 'adds values that are larger than the default max_size when max_size is nil' do
+  store = Moneta::Adapters::LRUHash.new(max_size: nil)
+  large_item = 'Really big'
+  allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash::DEFAULT_MAX_SIZE + 1)
+  store[:really_big] = large_item
+  store[:really_big].should eq(large_item)
+end
+
+it 'adds an individual value that is equal to max_value' do
+  store = Moneta::Adapters::LRUHash.new(max_value: 13)
+  store[:a_key] = '13 bytes long'
+  store[:a_key].should eq('13 bytes long')
+end
+
+it 'does not add a value that is larger than max_value' do
+  store = Moneta::Adapters::LRUHash.new(max_value: 20)
+  store[:too_long] = 'This is 21 bytes long'
+  store[:too_long].should be_nil
+end
+
+it 'removes keys that are replaced by values larger than max_value' do
+  store = Moneta::Adapters::LRUHash.new(max_value: 20)
+  store[:too_long] = 'This will fit'
+  store[:too_long] = 'This is 21 bytes long'
+  store[:too_long].should be_nil
+end
+
+it 'only allows the default number of items when max_count is missing' do
+  stub_const('Moneta::Adapters::LRUHash::DEFAULT_MAX_COUNT', 5)
+  store = Moneta::Adapters::LRUHash.new(max_value: nil, max_size: nil)
+  (1..6).each { |n| store[n] = n }
+  store.key?(1).should be false
+  store[1].should be_nil
+  store[2].should eq(2)
+  store[6].should eq(6)
+end
+
+it 'adds more values than DEFAULT_MAX_COUNT allows when max_count is nil' do
+  stub_const('Moneta::Adapters::LRUHash::DEFAULT_MAX_COUNT', 5)
+  store = Moneta::Adapters::LRUHash.new(max_count: nil, max_value: nil, max_size: nil)
+  (1..6).each { |n| store[n] = n }
+  store[1].should eq(1)
+  store[2].should eq(2)
+  store[6].should eq(6)
 end}
   },
   'adapter_mongo' => {
-    build: 'Moneta::Adapters::Mongo.new(db: "adapter_mongo")',
+    build: %{\
+Moneta::Adapters::Mongo.new(db: "adapter_mongo",
+                            collection: 'default')},
     specs: ADAPTER_SPECS.with_native_expires.simplevalues_only
   },
   'adapter_mongo_with_default_expires' => {
-    build: %{Moneta::Adapters::Mongo.new(expires: 1)},
+    build: %{\
+Moneta::Adapters::Mongo.new(db: "adapter_mongo",
+                            collection: 'with_default_expires',
+                            expires: 1)},
     specs: ADAPTER_SPECS.with_expires.with_default_expires.simplevalues_only
   },
   'adapter_mongo_moped' => {
-    build: 'Moneta::Adapters::MongoMoped.new(db: "adapter_mongo")',
+    build: %{\
+Moneta::Adapters::MongoMoped.new(db: "adapter_mongo",
+                                 collection: 'moped')},
     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('_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
+
+  i = 0
+  query = store.instance_variable_get(:@collection).find(_id: ::BSON::Binary.new('key'))
+  while i < 70 && query.first
+    i += 1
+    sleep 1 # Mongo needs up to 60 seconds
+  end
+
+  i.should be > 0 # Indicates that it took at least one sleep to expire
+  query.count.should == 0
 end}
   },
   'adapter_mongo_moped_with_default_expires' => {
-    build: %{Moneta::Adapters::MongoMoped.new(expires: 1)},
+    build: %{\
+Moneta::Adapters::MongoMoped.new(db: "adapter_mongo",
+                                 collection: 'moped_with_default_expires',
+                                 expires: 1)},
     specs: ADAPTER_SPECS.with_expires.with_default_expires.simplevalues_only
   },
   'adapter_mongo_official' => {
-    build: 'Moneta::Adapters::MongoOfficial.new(db: "adapter_mongo")',
+    build: %{\
+Moneta::Adapters::MongoOfficial.new(db: "adapter_mongo",
+                                    collection: 'official')},
     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
+
+  i = 0
+  query = store.instance_variable_get(:@collection).find(_id: ::BSON::Binary.new('key'))
+  while i < 70 && query.first
+    i += 1
+    sleep 1 # Mongo needs up to 60 seconds
+  end
+
+  i.should be > 0 # Indicates that it took at least one sleep to expire
+  query.count.should == 0
 end}
   },
   'adapter_mongo_official_with_default_expires' => {
-    build: %{Moneta::Adapters::MongoOfficial.new(expires: 1)},
+    build: %{\
+Moneta::Adapters::MongoOfficial.new(db: "adapter_mongo",
+                                    collection: 'official_with_default_expires',
+                                    expires: 1)},
     specs: ADAPTER_SPECS.with_expires.with_default_expires.simplevalues_only
   },
   'adapter_pstore' => {
@@ -1506,8 +1633,8 @@ end}
     tests: %{
 it 'should have #lock' do
   mutex = Moneta::Mutex.new(store, 'mutex')
-  mutex.lock.should be_true
-  mutex.locked?.should be_true
+  mutex.lock.should be true
+  mutex.locked?.should be true
   expect do
    mutex.lock
   end.to raise_error(RuntimeError)
@@ -1515,13 +1642,13 @@ it 'should have #lock' do
    mutex.try_lock
   end.to raise_error(RuntimeError)
   mutex.unlock.should be_nil
-  mutex.locked?.should be_false
+  mutex.locked?.should be false
 end
 
 it 'should have #enter' do
   mutex = Moneta::Mutex.new(store, 'mutex')
-  mutex.enter.should be_true
-  mutex.locked?.should be_true
+  mutex.enter.should be true
+  mutex.locked?.should be true
   expect do
    mutex.enter
   end.to raise_error(RuntimeError)
@@ -1529,31 +1656,31 @@ it 'should have #enter' do
    mutex.try_enter
   end.to raise_error(RuntimeError)
   mutex.leave.should be_nil
-  mutex.locked?.should be_false
+  mutex.locked?.should be false
 end
 
 it 'should lock with #lock' do
   a = Moneta::Mutex.new(store, 'mutex')
   b = Moneta::Mutex.new(store, 'mutex')
-  a.lock.should be_true
-  b.try_lock.should be_false
+  a.lock.should be true
+  b.try_lock.should be false
   a.unlock.should be_nil
 end
 
 it 'should have lock timeout' do
   a = Moneta::Mutex.new(store, 'mutex')
   b = Moneta::Mutex.new(store, 'mutex')
-  a.lock.should be_true
-  b.lock(1).should be_false
+  a.lock.should be true
+  b.lock(1).should be false
   a.unlock.should be_nil
 end
 
 it 'should have #synchronize' do
   mutex = Moneta::Mutex.new(store, 'mutex')
   mutex.synchronize do
-    mutex.locked?.should be_true
+    mutex.locked?.should be true
   end
-  mutex.locked?.should be_false
+  mutex.locked?.should be false
 end
   }
   },
@@ -1563,8 +1690,8 @@ end
     tests: %{
 it 'should have #lock' do
   mutex = Moneta::Semaphore.new(store, 'semaphore')
-  mutex.lock.should be_true
-  mutex.locked?.should be_true
+  mutex.lock.should be true
+  mutex.locked?.should be true
   expect do
    mutex.lock
   end.to raise_error(RuntimeError)
@@ -1572,13 +1699,13 @@ it 'should have #lock' do
    mutex.try_lock
   end.to raise_error(RuntimeError)
   mutex.unlock.should be_nil
-  mutex.locked?.should be_false
+  mutex.locked?.should be false
 end
 
 it 'should have #enter' do
   mutex = Moneta::Semaphore.new(store, 'semaphore')
-  mutex.enter.should be_true
-  mutex.locked?.should be_true
+  mutex.enter.should be true
+  mutex.locked?.should be true
   expect do
    mutex.enter
   end.to raise_error(RuntimeError)
@@ -1586,22 +1713,22 @@ it 'should have #enter' do
    mutex.try_enter
   end.to raise_error(RuntimeError)
   mutex.leave.should be_nil
-  mutex.locked?.should be_false
+  mutex.locked?.should be false
 end
 
 it 'should lock with #lock' do
   a = Moneta::Semaphore.new(store, 'semaphore')
   b = Moneta::Semaphore.new(store, 'semaphore')
-  a.lock.should be_true
-  b.try_lock.should be_false
+  a.lock.should be true
+  b.try_lock.should be false
   a.unlock.should be_nil
 end
 
 it 'should have lock timeout' do
   a = Moneta::Semaphore.new(store, 'semaphore')
   b = Moneta::Semaphore.new(store, 'semaphore')
-  a.lock.should be_true
-  b.lock(1).should be_false
+  a.lock.should be true
+  b.lock(1).should be false
   a.unlock.should be_nil
 end
 
@@ -1610,10 +1737,10 @@ it 'should count concurrent accesses' do
   b = Moneta::Semaphore.new(store, 'semaphore', 2)
   c = Moneta::Semaphore.new(store, 'semaphore', 2)
   a.synchronize do
-    a.locked?.should be_true
+    a.locked?.should be true
     b.synchronize do
-      b.locked?.should be_true
-      c.try_lock.should be_false
+      b.locked?.should be true
+      c.try_lock.should be false
     end
   end
 end
@@ -1621,9 +1748,9 @@ end
 it 'should have #synchronize' do
   semaphore = Moneta::Semaphore.new(store, 'semaphore')
   semaphore.synchronize do
-    semaphore.locked?.should be_true
+    semaphore.locked?.should be true
   end
-  semaphore.locked?.should be_false
+  semaphore.locked?.should be false
 end
   }
   },
@@ -1719,7 +1846,7 @@ it 'supports adding proxis using #with' do
   compressed_store['key'] = 'compressed value'
   store['key'].should == 'uncompressed value'
   compressed_store['key'].should == 'compressed value'
-  store.key?('compressedkey').should be_true
+  store.key?('compressedkey').should be true
   # Check if value is compressed
   compressed_store['key'].should_not == store['compressedkey']
 end}
@@ -1772,7 +1899,7 @@ it 'guarantees that the same value is returned when setting a key' do
 end
 
 it 'returns false from #key? if a key is not available' do
-  store.key?(#{key1}).should be_false
+  store.key?(#{key1}).should be false
 end
 
 it 'returns nil from delete if a value for a key does not exist' do
@@ -1783,8 +1910,8 @@ it 'removes all keys from the store with clear' do
   store[#{key1}] = #{val1}
   store[#{key2}] = #{val2}
   store.clear.should equal(store)
-  store.key?(#{key1}).should be_false
-  store.key?(#{key2}).should be_false
+  store.key?(#{key1}).should be false
+  store.key?(#{key2}).should be false
 end
 
 it 'fetches a key with a default value with fetch, if the key is not available' do
@@ -1803,7 +1930,7 @@ end
 it 'accepts frozen options' do
   options = {option1: 1, options2: 2}
   options.freeze
-  store.key?(#{key1}, options).should be_false
+  store.key?(#{key1}, options).should be false
   store.load(#{key1}, options).should be_nil
   store.fetch(#{key1}, 42, options).should == 42
   store.fetch(#{key1}, options) { 42 }.should == 42
@@ -1821,7 +1948,7 @@ end
 
 it 'returns true from #key? if a key is available' do
   store[#{key1}] = #{val1}
-  store.key?(#{key1}).should be_true
+  store.key?(#{key1}).should be true
 end
 
 it 'stores values with #store' do
@@ -1843,7 +1970,7 @@ end
 it 'removes and returns a value from the backing store via delete if it exists' do
   store[#{key1}] = #{val1}
   store.delete(#{key1}).should == #{val1}
-  store.key?(#{key1}).should be_false
+  store.key?(#{key1}).should be false
 end
 
 it 'overwrites existing values' do
@@ -1999,18 +2126,18 @@ end
 
 it 'supports expires on store and #key?', retry: 3 do
   store.store('key1', 'val1', expires: 3)
-  store.key?('key1').should be_true
+  store.key?('key1').should be true
   sleep 1
-  store.key?('key1').should be_true
+  store.key?('key1').should be true
   sleep 3
-  store.key?('key1').should be_false
+  store.key?('key1').should be false
 end
 
 it 'supports strict expires on store and #key?' do
   store.store('key1', 'val1', expires: 2)
-  store.key?('key1').should be_true
+  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
+  store.key?('key1').should be false
 end
 
 it 'supports updating the expiration time in load', retry: 3 do
@@ -2043,7 +2170,7 @@ 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'
@@ -2053,14 +2180,14 @@ 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.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.key?('key1', expires: false ).should be true
   sleep 3
   store['key1'].should == 'val1'
 end
@@ -2125,10 +2252,10 @@ 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)
-  store.key?('key1').should be_true
-  store.key?('key1', expires: nil).should be_true
+  store.key?('key1').should be true
+  store.key?('key1', expires: nil).should be true
   sleep 2
-  store.key?('key1').should be_false
+  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
@@ -2149,11 +2276,11 @@ end}
 
 SPECS['default_expires'] = %{it 'does set default expiration time' do
   store['key1'] = 'val1'
-  store.key?('key1').should be_true
+  store.key?('key1').should be true
   store.fetch('key1').should == 'val1'
   store.load('key1').should == 'val1'
   sleep 2
-  store.key?('key1').should be_false
+  store.key?('key1').should be false
   store.fetch('key1').should be_nil
   store.load('key1').should be_nil
 end}
@@ -2222,27 +2349,27 @@ it 'have atomic create across multiple processes' do
 end}
 
 SPECS['increment'] = %{it 'initializes in #increment with 1' do
-  store.key?('inckey').should be_false
+  store.key?('inckey').should be false
   store.increment('inckey').should == 1
-  store.key?('inckey').should be_true
+  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.delete('inckey', raw: true).should == '1'
-  store.key?('inckey').should be_false
+  store.key?('inckey').should be false
 end
 
 it 'initializes in #increment with higher value' do
   store.increment('inckey', 42).should == 42
-  store.key?('inckey').should be_true
+  store.key?('inckey').should be true
   store.raw['inckey'].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.key?('inckey').should be true
   store.raw['inckey'].should == '0'
   store.delete('inckey', raw: true).should == '0'
 end
@@ -2310,36 +2437,36 @@ it 'supports Semaphore' do
   b = Moneta::Semaphore.new(store, 'semaphore', 2)
   c = Moneta::Semaphore.new(store, 'semaphore', 2)
   a.synchronize do
-    a.locked?.should be_true
+    a.locked?.should be true
     b.synchronize do
-      b.locked?.should be_true
-      c.try_lock.should be_false
+      b.locked?.should be true
+      c.try_lock.should be false
     end
   end
 end
 }
 
 SPECS['create'] = %{it 'creates the given key' do
-  store.create('key','value').should be_true
+  store.create('key','value').should be true
   store['key'].should == 'value'
 end
 
 it 'creates raw value with the given key' do
-  store.raw.create('key','value').should be_true
+  store.raw.create('key','value').should be true
   store.raw['key'].should == 'value'
 end
 
 it 'does not create a key if it exists' do
   store['key'] = 'value'
-  store.create('key','another value').should be_false
+  store.create('key','another value').should be false
   store['key'].should == 'value'
 end
 
 it 'supports Mutex' do
   a = Moneta::Mutex.new(store, 'mutex')
   b = Moneta::Mutex.new(store, 'mutex')
-  a.lock.should be_true
-  b.try_lock.should be_false
+  a.lock.should be true
+  b.try_lock.should be false
   a.unlock.should be_nil
 end
 }
@@ -2351,19 +2478,19 @@ 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
+  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.create('key','another value', expires: 1).should be false
   store['key'].should == 'value'
   sleep 2
   store['key'].should == 'value'
-  store.key?('key').should be_true
+  store.key?('key').should be true
 end}
 
 SPECS['marshallable_key']  = %{it 'refuses to #[] from keys that cannot be marshalled' do
@@ -2465,7 +2592,7 @@ SPECS['transform_value_expires']  = %{it 'allows to bypass transformer with :raw
   store['key'] = 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'
@@ -2502,14 +2629,14 @@ SPECS['features'] = %{it 'should report correct features' do
 end
 
 it 'should have frozen features' do
-  store.features.frozen?.should be_true
+  store.features.frozen?.should be true
 end
 
 it 'should have #supports?' do
   features.each do |f|
-    store.supports?(f).should be_true
+    store.supports?(f).should be true
   end
-  store.supports?(:unknown).should be_false
+  store.supports?(:unknown).should be false
 end}
 
 specs_code = "#{header}\n"