moneta 0.7.3 → 0.7.4

data/lib/moneta/adapters/restclient.rb

@@ -1,4 +1,4 @@
-require 'httpi'
+require 'net/http'
 
 module Moneta
   module Adapters
@@ -10,38 +10,47 @@ module Moneta
       # @param [Hash] options
       # @option options [String] :url URL
       def initialize(options = {})
-        raise ArgumentError, 'Option :url is required' unless @url = options[:url]
+        raise ArgumentError, 'Option :url is required' unless url = options[:url]
+        url = URI(url)
+        @path = url.path
+        @client = ::Net::HTTP.start(url.host, url.port)
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        response = HTTPI.head(@url + key)
-        response.code == 200
+        response = @client.request_head(@path + key)
+        response.code == '200'
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        response = HTTPI.get(@url + key)
-        response.code == 200 ? response.body : nil
+        response = @client.request_get(@path + key)
+        response.code == '200' ? response.body : nil
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        HTTPI.post(@url + key, value)
+        response = @client.request_post(@path + key, value)
+        raise "HTTP error #{response.code}" unless response.code == '200'
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        response = HTTPI.delete(@url + key)
-        response.code == 200 ? response.body : nil
+        response = @client.request(::Net::HTTP::Delete.new(@path + key))
+        response.code == '200' ? response.body : nil
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        HTTPI.delete(@url)
+        @client.request(::Net::HTTP::Delete.new(@path))
         self
       end
+
+      def close
+        @client.finish
+        nil
+      end
     end
   end
 end

data/lib/moneta/adapters/sequel.rb

@@ -6,6 +6,7 @@ module Moneta
     # @api public
     class Sequel
       include Defaults
+      include IncrementSupport
 
       # @param [Hash] options
       # @option options [String] :db Sequel database
@@ -50,12 +51,9 @@ module Moneta
         @db.transaction do
           locked_table = @table.for_update
           if record = locked_table[:k => key]
-            value = record[:v]
-            intvalue = value.to_i
-            raise 'Tried to increment non integer value' unless value == nil || intvalue.to_s == value.to_s
-            intvalue += amount
-            locked_table.update(:k => key, :v => intvalue.to_s)
-            intvalue
+            value = convert_for_increment(record[:v]) + amount
+            locked_table.update(:k => key, :v => value.to_s)
+            value
           else
             locked_table.insert(:k => key, :v => amount.to_s)
             amount

data/lib/moneta/adapters/tdb.rb

@@ -0,0 +1,22 @@
+require 'tdb'
+
+module Moneta
+  module Adapters
+    # TDB backend
+    # @api public
+    class TDB < Memory
+      # @param [Hash] options
+      # @option options [String] :file Database file
+      def initialize(options = {})
+        raise ArgumentError, 'Option :file is required' unless file = options.delete(:file)
+        @hash = ::TDB.new(file, options)
+      end
+
+      # (see Proxy#close)
+      def close
+        @hash.close
+        nil
+      end
+    end
+  end
+end

data/lib/moneta/expires.rb

@@ -1,17 +1,19 @@
 module Moneta
   # Adds expiration support to the underlying store
   #
-  # #store and #load support the :expires option to set/update
+  # `#store`, `#load` and `#key?` support the `:expires` option to set/update
   # the expiration time.
   #
   # @api public
   class Expires < Proxy
+    include ExpiresSupport
+
     # @param [Moneta store] adapter The underlying store
     # @param [Hash] options
     # @option options [String] :expires Default expiration time
     def initialize(adapter, options = {})
       super
-      @expires = options[:expires]
+      self.default_expires = options[:expires]
     end
 
     # (see Proxy#key?)
@@ -33,14 +35,12 @@ module Moneta
     # (see Proxy#store)
     def store(key, value, options = {})
       return super if options.include?(:raw)
-      expires = options.include?(:expires) && (options = options.dup; options.delete(:expires))
-      if expires ||= @expires
-        super(key, [value, Time.now.to_i + expires], options)
-      elsif Array === value || value == nil
-        super(key, [value], options)
-      else
-        super(key, value, options)
+      expires = expires_at(options)
+      if options.include?(:expires)
+        options = options.dup
+        options.delete(:expires)
       end
+      store_entry(key, value, expires, options)
       value
     end
 
@@ -54,20 +54,36 @@ module Moneta
     private
 
     def load_entry(key, options)
-      new_expires = options.include?(:expires) && (options = options.dup; options.delete(:expires))
+      new_expires = expires_at(options, nil)
+      if options.include?(:expires)
+        options = options.dup
+        options.delete(:expires)
+      end
       entry = @adapter.load(key, options)
       if entry != nil
         value, expires = entry
         if expires && Time.now.to_i > expires
           delete(key)
           nil
-        elsif new_expires
-          @adapter.store(key, [value, Time.now.to_i + new_expires], options)
+        elsif new_expires != nil
+          store_entry(key, value, new_expires, options)
           entry
         else
           entry
         end
       end
     end
+
+    def store_entry(key, value, expires, options)
+      entry =
+        if expires
+          [value, expires.to_i]
+        elsif Array === value || value == nil
+          [value]
+        else
+          value
+        end
+      @adapter.store(key, entry, options)
+    end
   end
 end

data/lib/moneta/mixins.rb

@@ -51,6 +51,9 @@ module Moneta
     #
     # @param [Object] key
     # @param [Hash] options
+    # @option options [Integer] :expires Update expiration time (See `Moneta::Expires`)
+    # @option options [String] :prefix Prefix key (See `Moneta::Transformer`)
+    # @option options Other options as defined by the adapters or middleware
     # @return [Boolean]
     # @api public
     def key?(key, options = {})
@@ -146,11 +149,16 @@ module Moneta
     # (see Defaults#increment)
     # @api public
     def increment(key, amount = 1, options = {})
-      value = load(key, options)
+      value = convert_for_increment(load(key, options)) + amount
+      store(key, value.to_s, options)
+      value
+    end
+
+    protected
+
+    def convert_for_increment(value)
       intvalue = value.to_i
       raise 'Tried to increment non integer value' unless value == nil || intvalue.to_s == value.to_s
-      intvalue += amount
-      store(key, intvalue.to_s, options)
       intvalue
     end
   end
@@ -204,4 +212,57 @@ module Moneta
       io.write(pack(o))
     end
   end
+
+  # This mixin handles the calculation of expiration times.
+  #
+  #
+  module ExpiresSupport
+    attr_accessor :default_expires
+
+    protected
+
+    # Calculates the time when something will expire.
+    #
+    # This method considers false and 0 as "no-expire" and every positive
+    # number as a time to live in seconds.
+    #
+    # @param [Hash] options Options hash
+    # @option options [0,false,nil,Numeric] :expires expires value given by user
+    # @param [0,false,nil,Numeric] default default expiration time
+    #
+    # @return [false] if it should not expire
+    # @return [Time] the time when something should expire
+    # @return [nil] if it is not known
+    def expires_at(options, default = @default_expires)
+      value = expires_value(options, default)
+      Numeric === value ? Time.now + value : value
+    end
+
+    # Calculates the number of seconds something should last.
+    #
+    # This method considers false and 0 as "no-expire" and every positive
+    # number as a time to live in seconds.
+    #
+    # @param [Hash] options Options hash
+    # @option options [0,false,nil,Numeric] :expires expires value given by user
+    # @param [0,false,nil,Numeric] default default expiration time
+    #
+    # @return [false] if it should not expire
+    # @return [Numeric] seconds until expiration
+    # @return [nil] if it is not known
+    def expires_value(options, default = @default_expires)
+      case value = options[:expires]
+      when 0, false
+        false
+      when nil
+        default ? default.to_i : nil
+      when Numeric
+        value = value.to_i
+        raise ArgumentError, ":expires must be a positive value, got #{value}" if value < 0
+        value
+      else
+        raise ArgumentError, ":expires must be Numeric or false, got #{value.inspect}"
+      end
+    end
+  end
 end

data/lib/moneta/pool.rb

@@ -0,0 +1,37 @@
+module Moneta
+  # Creates a pool of stores.
+  # Each thread gets its own store.
+  #
+  # @example Add `Moneta::Pool` to proxy stack
+  #   Moneta.build do
+  #     use(:Pool) do
+  #       # Every thread gets its own instance
+  #       adapter :MemcachedNative
+  #     end
+  #   end
+  #
+  # @api public
+  class Pool < Wrapper
+    # @param [Moneta store] adapter The underlying store
+    # @param [Hash] options
+    def initialize(options = {}, &block)
+      super(nil)
+      @builder = Builder.new(&block)
+      @pool, @active = [], {}
+    end
+
+    protected
+
+    def adapter
+      @active[Thread.current]
+    end
+
+    def wrap(*args)
+      @pool << @builder.build.last if @pool.empty?
+      @active[Thread.current] = @pool.pop
+      yield
+    ensure
+      @pool << @active.delete(Thread.current)
+    end
+  end
+end

data/lib/moneta/proxy.rb

@@ -14,27 +14,31 @@ module Moneta
 
     # (see Defaults#key?)
     def key?(key, options = {})
-      @adapter.key?(key, options)
+      adapter.key?(key, options)
     end
 
     # (see Defaults#increment)
     def increment(key, amount = 1, options = {})
-      @adapter.increment(key, amount, options)
+      adapter.increment(key, amount, options)
     end
 
     # (see Defaults#close)
     def close
-      @adapter.close
+      adapter.close
     end
 
     # Fetch value with key. Return nil if the key doesn't exist
     #
     # @param [Object] key
     # @param [Hash] options
+    # @option options [Integer] :expires Update expiration time (See `Moneta::Expires`)
+    # @option options [Boolean] :raw Raw access without value transformation (See `Moneta::Transformer`)
+    # @option options [String] :prefix Prefix key (See `Moneta::Transformer`)
+    # @option options Other options as defined by the adapters or middleware
     # @return [Object] value
     # @api public
     def load(key, options = {})
-      @adapter.load(key, options)
+      adapter.load(key, options)
     end
 
     # Store value with key
@@ -42,10 +46,14 @@ module Moneta
     # @param [Object] key
     # @param [Object] value
     # @param [Hash] options
+    # @option options [Integer] :expires Set expiration time (See `Moneta::Expires`)
+    # @option options [Boolean] :raw Raw access without value transformation (See `Moneta::Transformer`)
+    # @option options [String] :prefix Prefix key (See `Moneta::Transformer`)
+    # @option options Other options as defined by the adapters or middleware
     # @return value
     # @api public
     def store(key, value, options = {})
-      @adapter.store(key, value, options)
+      adapter.store(key, value, options)
     end
 
     # Delete the key from the store and return the current value
@@ -53,9 +61,12 @@ module Moneta
     # @param [Object] key
     # @return [Object] current value
     # @param [Hash] options
+    # @option options [Boolean] :raw Raw access without value transformation (See `Moneta::Transformer`)
+    # @option options [String] :prefix Prefix key (See `Moneta::Transformer`)
+    # @option options Other options as defined by the adapters or middleware
     # @api public
     def delete(key, options = {})
-      @adapter.delete(key, options)
+      adapter.delete(key, options)
     end
 
     # Clear all keys in this store
@@ -64,7 +75,7 @@ module Moneta
     # @return [void]
     # @api public
     def clear(options = {})
-      @adapter.clear(options)
+      adapter.clear(options)
       self
     end
   end

data/lib/moneta/server.rb

@@ -59,7 +59,7 @@ module Moneta
       client = accept
       handle(client) if client
     rescue Exception => ex
-      puts ex.message
+      warn ex.message
       write(client, Error.new(ex.message)) if client
     end
 

data/lib/moneta/shared.rb

@@ -39,7 +39,7 @@ module Moneta
       @adapter ||= Adapters::Client.new(@options)
       yield
     rescue Exception => ex
-      puts "Failed to connect: #{ex.message}"
+      warn "Failed to connect: #{ex.message}"
       begin
         # TODO: Implement this using forking (MRI) and threading (JRuby)
         # to get maximal performance
@@ -48,7 +48,7 @@ module Moneta
         @thread = Thread.new { @server.run }
         sleep 0.1 until @server.running?
       rescue Exception => ex
-        puts "Failed to start server: #{ex.message}"
+        warn "Failed to start server: #{ex.message}"
         @adapter.close if @adapter
         @adapter = nil
       end

data/lib/moneta/transformer/helper.rb

@@ -24,7 +24,7 @@ module Moneta
       def truncate(value, maxlen)
         if value.size >= maxlen
           digest = Digest::MD5.hexdigest(value)
-          value = value[0, value.size-digest.size] << digest
+          value = value[0, maxlen-digest.size] << digest
         end
         value
       end

data/lib/moneta/version.rb

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

data/{spec/generate.rb → script/generate-specs.rb}

@@ -1,3 +1,7 @@
+#!/usr/bin/env ruby
+
+PATH = File.expand_path(File.join(__FILE__, '..', '..', 'spec'))
+
 class Specs
   attr_reader :key, :value, :specs
 
@@ -93,13 +97,19 @@ class Specs
     a.delete(:marshallable_value)
     Specs.new(a, key, value)
   end
+
+  def with_default_expires
+    a = specs.dup
+    a << :default_expires
+    Specs.new(a, key, value)
+  end
 end
 
 ADAPTER_SPECS = Specs.new([:null, :store, :returndifferent, :increment, :persist], %w(string), %w(string))
 STANDARD_SPECS = Specs.new([:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :persist])
 TRANSFORMER_SPECS = Specs.new([:null, :store, :returndifferent, :transform_value, :increment])
 
-header = "# Generated by #{__FILE__}\n"
+header = "# Generated by #{File.basename(__FILE__)}\n"
 
 TESTS = {
   'simple_client_tcp' => {
@@ -232,6 +242,26 @@ end
     :options => ':file => File.join(make_tempdir, "simple_dbm_with_expires"), :expires => true',
     :specs => STANDARD_SPECS.with_expires
   },
+  'simple_tdb' => {
+    :store => :TDB,
+    :options => ':file => File.join(make_tempdir, "simple_tdb")',
+    :specs => STANDARD_SPECS
+  },
+  'simple_tdb_with_expires' => {
+    :store => :TDB,
+    :options => ':file => File.join(make_tempdir, "simple_tdb_with_expires"), :expires => true',
+    :specs => STANDARD_SPECS.with_expires
+  },
+  'simple_daybreak' => {
+    :store => :Daybreak,
+    :options => ':file => File.join(make_tempdir, "simple_daybreak")',
+    :specs => STANDARD_SPECS
+  },
+  'simple_daybreak_with_expires' => {
+    :store => :Daybreak,
+    :options => ':file => File.join(make_tempdir, "simple_daybreak_with_expires"), :expires => true',
+    :specs => STANDARD_SPECS.with_expires
+  },
   'simple_gdbm' => {
     :store => :GDBM,
     :options => ':file => File.join(make_tempdir, "simple_gdbm")',
@@ -364,12 +394,7 @@ end
   'simple_mongo' => {
     :store => :Mongo,
     :options => ":db => 'simple_mongo'",
-    :specs => STANDARD_SPECS.without_increment
-  },
-  'simple_mongo_with_expires' => {
-    :store => :Mongo,
-    :options => ":db => 'simple_mongo_with_expires', :expires => true",
-    :specs => STANDARD_SPECS.without_increment.with_expires
+    :specs => STANDARD_SPECS.with_native_expires
   },
   'simple_null' => {
     :store => :Null,
@@ -453,19 +478,14 @@ end
   use :Expires
   adapter :Memory
 end},
-    :specs => STANDARD_SPECS.without_transform.with_expires.without_persist,
-    :tests => %{
-it 'supports default expiration time' do
-  store = Moneta.new(:Memory, :expires => 2)
-  store.store('key1', 'val1')
-  store.store('key2', 'val2', :expires => 60)
-  store.load('key1').should == 'val1'
-  sleep 1
-  store.load('key1').should == 'val1'
-  sleep 2
-  store.load('key1').should be_nil
-  store['key2'].should == 'val2'
-end}
+    :specs => STANDARD_SPECS.without_transform.with_expires.without_persist
+  },
+  'expires_memory_with_default_expires' => {
+    :build => %{Moneta.build do
+  use :Expires, :expires => 1
+  adapter :Memory
+end},
+    :specs => STANDARD_SPECS.without_transform.with_expires.with_default_expires.without_persist
   },
   'expires_file' => {
     :build => %{Moneta.build do
@@ -580,6 +600,14 @@ end},
 end},
     :specs => STANDARD_SPECS.without_transform.without_returndifferent.without_persist
   },
+  'pool' => {
+    :build => %{Moneta.build do
+  use :Pool do
+    adapter :File, :dir => File.join(make_tempdir, "pool")
+  end
+end},
+    :specs => ADAPTER_SPECS
+  },
   'transformer_zlib' => {
     :build => %{Moneta.build do
   use :Transformer, :value => :zlib
@@ -857,19 +885,11 @@ end
   },
   'adapter_cassandra' => {
     :build => "Moneta::Adapters::Cassandra.new(:keyspace => 'adapter_cassandra')",
-    :specs => ADAPTER_SPECS.without_increment.with_expires,
-    :tests => %{
-it 'supports default expiration time' do
-  store = Moneta::Adapters::Cassandra.new(:expires => 2, :keyspace => 'adapter_cassandra')
-  store.store('key1', 'val1')
-  store.store('key2', 'val2', :expires => 60)
-  store.load('key1').should == 'val1'
-  sleep 1
-  store.load('key1').should == 'val1'
-  sleep 2
-  store.load('key1').should be_nil
-  store['key2'].should == 'val2'
-end}
+    :specs => ADAPTER_SPECS.without_increment.with_native_expires
+  },
+  'adapter_cassandra_with_default_expires' => {
+    :build => %{Moneta::Adapters::Cassandra.new(:expires => 1)},
+    :specs => ADAPTER_SPECS.without_increment.with_native_expires.with_default_expires
   },
   'adapter_hbase' => {
     :build => "Moneta::Adapters::HBase.new(:table => 'adapter_hbase')",
@@ -923,6 +943,14 @@ end
     :build => 'Moneta::Adapters::DBM.new(:file => File.join(make_tempdir, "adapter_dbm"))',
     :specs => ADAPTER_SPECS
   },
+  'adapter_tdb' => {
+    :build => 'Moneta::Adapters::TDB.new(:file => File.join(make_tempdir, "adapter_tdb"))',
+    :specs => ADAPTER_SPECS
+  },
+  'adapter_daybreak' => {
+    :build => 'Moneta::Adapters::Daybreak.new(:file => File.join(make_tempdir, "adapter_daybreak"))',
+    :specs => ADAPTER_SPECS
+  },
   'adapter_file' => {
     :build => 'Moneta::Adapters::File.new(:dir => File.join(make_tempdir, "adapter_file"))',
     :specs => ADAPTER_SPECS
@@ -946,52 +974,27 @@ end
   },
   'adapter_memcached_dalli' => {
     :build => 'Moneta::Adapters::MemcachedDalli.new(:namespace => "adapter_memcached_dalli")',
-    :specs => ADAPTER_SPECS.with_expires,
-    :tests => %{
-it 'supports default expiration time' do
-  store = Moneta::Adapters::MemcachedDalli.new(:expires => 2, :namespace => "adapter_memcached_dalli")
-  store.store('key1', 'val1')
-  store.store('key2', 'val2', :expires => 60)
-  store.load('key1').should == 'val1'
-  sleep 1
-  store.load('key1').should == 'val1'
-  sleep 2
-  store.load('key1').should be_nil
-  store['key2'].should == 'val2'
-end}
+    :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
   },
   'adapter_memcached_native' => {
     :build => 'Moneta::Adapters::MemcachedNative.new(:namespace => "adapter_memcached_native")',
-    :specs => ADAPTER_SPECS.with_expires,
-    :tests => %{
-it 'supports default expiration time' do
-  store = Moneta::Adapters::MemcachedNative.new(:expires => 2, :namespace => "adapter_memcached_native")
-  store.store('key1', 'val1')
-  store.store('key2', 'val2', :expires => 60)
-  store.load('key1').should == 'val1'
-  sleep 1
-  store.load('key1').should == 'val1'
-  sleep 2
-  store.load('key1').should be_nil
-  store['key2'].should == 'val2'
-end
-}
+    :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
   },
   'adapter_memcached' => {
     :build => 'Moneta::Adapters::Memcached.new(:namespace => "adapter_memcached")',
-    :specs => ADAPTER_SPECS.with_expires,
-    :tests => %{
-it 'supports default expiration time' do
-  store = Moneta::Adapters::Memcached.new(:expires => 2, :namespace => "adapter_memcached")
-  store.store('key1', 'val1')
-  store.store('key2', 'val2', :expires => 60)
-  store.load('key1').should == 'val1'
-  sleep 1
-  store.load('key1').should == 'val1'
-  sleep 2
-  store.load('key1').should be_nil
-  store['key2'].should == 'val2'
-end}
+    :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
   },
   'adapter_memory' => {
     :build => 'Moneta::Adapters::Memory.new',
@@ -1017,7 +1020,18 @@ end}
   },
   'adapter_mongo' => {
     :build => 'Moneta::Adapters::Mongo.new(:db => "adapter_mongo")',
-    :specs => ADAPTER_SPECS.without_increment
+    :specs => ADAPTER_SPECS.with_native_expires,
+    :tests => %{
+it 'automatically deletes expired document' do
+  store.store('key', 'val', :expires => 30)
+  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
   },
   'adapter_pstore' => {
     :build => 'Moneta::Adapters::PStore.new(:file => File.join(make_tempdir, "adapter_pstore"))',
@@ -1025,19 +1039,11 @@ end}
   },
   'adapter_redis' => {
     :build => 'Moneta::Adapters::Redis.new',
-    :specs => ADAPTER_SPECS.with_expires,
-    :tests => %{
-it 'supports default expiration time' do
-  store = Moneta::Adapters::Redis.new(:expires => 2)
-  store.store('key1', 'val1')
-  store.store('key2', 'val2', :expires => 60)
-  store.load('key1').should == 'val1'
-  sleep 1
-  store.load('key1').should == 'val1'
-  sleep 2
-  store.load('key1').should be_nil
-  store['key2'].should == 'val2'
-end}
+    :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
   },
   'adapter_riak' => {
     :build => 'Moneta::Adapters::Riak.new',
@@ -1330,6 +1336,20 @@ SPECS['expires'] = %{it 'supports expires on store and #[]' do
   store['key1'].should be_nil
 end
 
+it 'supports 0 as no-expires on store and #[]' do
+  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['key1'].should == 'val1'
+  sleep 2
+  store['key1'].should == 'val1'
+end
+
 it 'supports expires on store and load' do
   store.store('key1', 'val1', :expires => 2)
   store.load('key1').should == 'val1'
@@ -1360,6 +1380,20 @@ it 'supports updating the expiration time in load' do
   store['key2'].should be_nil
 end
 
+it 'supports 0 as no-expires in load' do
+  store.store('key1', 'val1', :expires => 2)
+  store.load('key1', :expires => 0).should == 'val1'
+  sleep 2
+  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'
+  sleep 2
+  store.load('key1').should == 'val1'
+end
+
 it 'supports updating the expiration time in key?' do
   store.store('key2', 'val2', :expires => 2)
   store['key2'].should == 'val2'
@@ -1372,6 +1406,20 @@ it 'supports updating the expiration time in key?' do
   store['key2'].should be_nil
 end
 
+it 'supports 0 as no-expires in key?' do
+  store.store('key1', 'val1', :expires => 2)
+  store.key?('key1', :expires => 0).should be_true
+  sleep 2
+  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
+  sleep 2
+  store['key1'].should == 'val1'
+end
+
 it 'supports updating the expiration time in fetch' do
   store.store('key1', 'val1', :expires => 2)
   store['key1'].should == 'val1'
@@ -1384,6 +1432,20 @@ it 'supports updating the expiration time in fetch' do
   store['key1'].should be_nil
 end
 
+it 'supports 0 as no-expires in fetch' do
+  store.store('key1', 'val1', :expires => 2)
+  store.fetch('key1', nil, :expires => 0).should == 'val1'
+  sleep 2
+  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'
+  sleep 2
+  store.load('key1').should == 'val1'
+end
+
 it 'respects expires in delete' do
   store.store('key2', 'val2', :expires => 2)
   store['key2'].should == 'val2'
@@ -1394,14 +1456,56 @@ it 'respects expires in delete' do
 end
 
 it 'supports the #expires syntactic sugar' do
-  store['longlive_key'] = 'longlive_value'
+  store.store('persistent_key', 'persistent_value', :expires => 0)
   store.expires(2).store('key2', 'val2')
   store['key2'].should == 'val2'
   sleep 1
   store['key2'].should == 'val2'
   sleep 2
   store.delete('key2').should be_nil
-  store['longlive_key'].should == 'longlive_value'
+  store['persistent_key'].should == 'persistent_value'
+end
+
+it 'supports false as no-expires on store and #[]' do
+  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' do
+  store.store('key1', 'val1', :expires => 1)
+  store.key?('key1').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' do
+  store.store('key1', 'val1', :expires => 1)
+  store.fetch('key1').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' do
+  store.store('key1', 'val1', :expires => 1)
+  store.load('key1').should == 'val1'
+  store.load('key1', :expires => nil).should == 'val1'
+  sleep 2
+  store.load('key1').should be_nil
+end}
+
+SPECS['default_expires'] = %{it 'does set default expiration time' do
+  store['key1'] = 'val1'
+  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.fetch('key1').should be_nil
+  store.load('key1').should be_nil
 end}
 
 SPECS['not_increment'] = %{it 'does not support #increment' do
@@ -1637,7 +1741,7 @@ SPECS.each do |key, code|
     "shared_examples_for '#{key}' do\n  " << [code].flatten.join("\n\n").gsub("\n", "\n  ") << "\nend\n\n"
 end
 specs_code.gsub!(/\n +\n/, "\n\n")
-File.open(File.join(File.dirname(__FILE__), 'monetaspecs.rb'), 'w') {|out| out << specs_code }
+File.open(File.join(PATH, 'monetaspecs.rb'), 'w') {|out| out << specs_code }
 
 TESTS.each do |name, options|
   build = options.delete(:build)
@@ -1680,5 +1784,5 @@ end
 }
 
   code.gsub!(/\n +\n/, "\n\n")
-  File.open(File.join(File.dirname(__FILE__), 'moneta', "#{name}_spec.rb"), 'w') {|out| out << code }
+  File.open(File.join(PATH, 'moneta', "#{name}_spec.rb"), 'w') {|out| out << code }
 end