moneta 1.0.0 → 1.1.0

data/lib/moneta/adapters/sqlite.rb

@@ -8,30 +8,36 @@ module Moneta
       include Defaults
       include IncrementSupport
 
-      supports :create
+      supports :create, :each_key
       attr_reader :backend
 
       # @param [Hash] options
       # @option options [String] :file Database file
       # @option options [String] :table ('moneta') Table name
-      # @option options [Fixnum] :busy_timeout (1000) Sqlite timeout if database is busy
+      # @option options [Integer] :busy_timeout (1000) Sqlite timeout if database is busy
       # @option options [::Sqlite3::Database] :backend Use existing backend instance
+      # @option options [String, Symbol] :journal_mode Set the journal mode for the connection
       def initialize(options = {})
-        table = options[:table] || 'moneta'
+        @table = options[:table] || 'moneta'
         @backend = options[:backend] ||
           begin
             raise ArgumentError, 'Option :file is required' unless options[:file]
             ::SQLite3::Database.new(options[:file])
           end
         @backend.busy_timeout(options[:busy_timeout] || 1000)
-        @backend.execute("create table if not exists #{table} (k blob not null primary key, v blob)")
+        @backend.execute("create table if not exists #{@table} (k blob not null primary key, v blob)")
+        if journal_mode = options[:journal_mode]
+          @backend.journal_mode = journal_mode.to_s
+        end
         @stmts =
-          [@exists  = @backend.prepare("select exists(select 1 from #{table} where k = ?)"),
-           @select  = @backend.prepare("select v from #{table} where k = ?"),
-           @replace = @backend.prepare("replace into #{table} values (?, ?)"),
-           @delete  = @backend.prepare("delete from #{table} where k = ?"),
-           @clear   = @backend.prepare("delete from #{table}"),
-           @create  = @backend.prepare("insert into #{table} values (?, ?)")]
+          [@exists  = @backend.prepare("select exists(select 1 from #{@table} where k = ?)"),
+           @select  = @backend.prepare("select v from #{@table} where k = ?"),
+           @replace = @backend.prepare("replace into #{@table} values (?, ?)"),
+           @delete  = @backend.prepare("delete from #{@table} where k = ?"),
+           @clear   = @backend.prepare("delete from #{@table}"),
+           @create  = @backend.prepare("insert into #{@table} values (?, ?)"),
+           @keys    = @backend.prepare("select k from #{@table}"),
+           @count   = @backend.prepare("select count(*) from #{@table}")]
       end
 
       # (see Proxy#key?)
@@ -86,6 +92,64 @@ module Moneta
         @backend.close
         nil
       end
+
+      # (see Proxy#slice)
+      def slice(*keys, **options)
+        query = "select k, v from #{@table} where k in (#{(['?'] * keys.length).join(',')})"
+        @backend.execute(query, keys)
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        hash = Hash[slice(*keys, **options)]
+        keys.map { |key| hash[key] }
+      end
+
+      # (see Proxy#fetch_values)
+      def fetch_values(*keys, **options)
+        return values_at(*keys, **options) unless block_given?
+        hash = Hash[slice(*keys, **options)]
+        keys.map do |key|
+          if hash.key?(key)
+            hash[key]
+          else
+            yield key
+          end
+        end
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        transaction = if block_given?; @backend.transaction end
+
+        if block_given?
+          existing = Hash[slice(*pairs.map { |k, _| k }.to_a)]
+          pairs = pairs.map do |key, new_value|
+            new_value = yield(key, existing[key], new_value) if existing.key?(key)
+            [key, new_value]
+          end.to_a
+        else
+          pairs = pairs.to_a
+        end
+
+        query = "replace into #{@table} (k, v) values" + (['(?, ?)'] * pairs.length).join(',')
+        @backend.query(query, pairs.flatten).close
+      rescue
+        @backend.rollback if transaction
+        raise
+      else
+        @backend.commit if transaction
+        self
+      end
+
+      # (see Proxy#each_key)
+      def each_key
+        return enum_for(:each_key) { @count.execute!.first.first } unless block_given?
+        @keys.execute!.each do |row|
+          yield row.first
+        end
+        self
+      end
     end
   end
 end

data/lib/moneta/adapters/tdb.rb

@@ -4,7 +4,14 @@ module Moneta
   module Adapters
     # TDB backend
     # @api public
-    class TDB < Memory
+    class TDB
+      include Defaults
+      include HashAdapter
+      include IncrementSupport
+      include EachKeySupport
+
+      supports :create
+
       # @param [Hash] options
       # @option options [String] :file Database file
       # @option options [::TDB] :backend Use existing backend instance
@@ -21,6 +28,14 @@ module Moneta
         @backend.close
         nil
       end
+
+      # (see Proxy#create)
+      def create(key, value, options = {})
+        @backend.insert!(key, value)
+        true
+      rescue ::TDB::ERR::EXISTS
+        false
+      end
     end
   end
 end

data/lib/moneta/adapters/tokyocabinet.rb

@@ -4,7 +4,13 @@ module Moneta
   module Adapters
     # TokyoCabinet backend
     # @api public
-    class TokyoCabinet < Memory
+    class TokyoCabinet
+      include Defaults
+      include HashAdapter
+      include IncrementSupport
+      include CreateSupport
+      include EachKeySupport
+
       # @param [Hash] options
       # @option options [String] :file Database file
       # @option options [Symbol] :type (:hdb) Database type (:bdb and :hdb possible)

data/lib/moneta/adapters/tokyotyrant.rb

@@ -92,6 +92,28 @@ module Moneta
         nil
       end
 
+      # (see Proxy#slice)
+      def slice(*keys, **options)
+        hash =
+          if @native
+            @backend.mget(*keys)
+          else
+            hash = Hash[keys.map { |key| [key] }]
+            raise unless @backend.mget(hash) >= 0
+            hash
+          end
+
+        hash.each do |key, value|
+          hash[key] = unpack(value)
+        end
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        hash = slice(*keys, **options)
+        keys.map { |key| hash[key] }
+      end
+
       private
 
       def pack(value)

data/lib/moneta/cache.rb

@@ -101,9 +101,19 @@ module Moneta
       @adapter.close
     end
 
+    # (see Proxy#each_key)
+    def each_key(&block)
+      raise NotImplementedError, 'adapter doesn\'t support #each_key' \
+        unless supports? :each_key
+
+      return enum_for(:each_key) unless block_given?
+      @adapter.each_key(&block)
+      self
+    end
+
     # (see Proxy#features)
     def features
-      @features ||= ((@cache.features + [:create, :increment]) & @adapter.features).freeze
+      @features ||= ((@cache.features + [:create, :increment, :each_key]) & @adapter.features).freeze
     end
   end
 end

data/lib/moneta/expires.rb

@@ -44,7 +44,7 @@ module Moneta
     def delete(key, options = {})
       return super if options.include?(:raw)
       value, expires = super
-      value if !expires || Time.now.to_i <= expires
+      value if !expires || Time.now <= Time.at(expires)
     end
 
     # (see Proxy#store)
@@ -54,34 +54,136 @@ module Moneta
       @adapter.create(key, new_entry(value, expires), Utils.without(options, :expires))
     end
 
+    # (see Defaults#values_at)
+    def values_at(*keys, **options)
+      return super if options.include?(:raw)
+      new_expires = expires_at(options, nil)
+      options = Utils.without(options, :expires)
+      with_updates(options) do |updates|
+        keys.zip(@adapter.values_at(*keys, **options)).map do |key, entry|
+          entry = invalidate_entry(key, entry, new_expires) do |new_entry|
+            updates[key] = new_entry
+          end
+          next if entry.nil?
+          value, _ = entry
+          value
+        end
+      end
+    end
+
+    # (see Defaults#fetch_values)
+    def fetch_values(*keys, **options)
+      return super if options.include?(:raw)
+      new_expires = expires_at(options, nil)
+      options = Utils.without(options, :expires)
+      substituted = {}
+      block = if block_given?
+                lambda do |key|
+                  substituted[key] = true
+                  yield key
+                end
+              end
+
+      with_updates(options) do |updates|
+        keys.zip(@adapter.fetch_values(*keys, **options, &block)).map do |key, entry|
+          next entry if substituted[key]
+          entry = invalidate_entry(key, entry, new_expires) do |new_entry|
+            updates[key] = new_entry
+          end
+          if entry.nil?
+            value = if block_given?
+                      yield key
+                    end
+          else
+            value, _ = entry
+          end
+          value
+        end
+      end
+    end
+
+    # (see Defaults#slice)
+    def slice(*keys, **options)
+      return super if options.include?(:raw)
+      new_expires = expires_at(options, nil)
+      options = Utils.without(options, :expires)
+
+      with_updates(options) do |updates|
+        @adapter.slice(*keys, **options).map do |key, entry|
+          entry = invalidate_entry(key, entry, new_expires) do |new_entry|
+            updates[key] = new_entry
+          end
+          next if entry.nil?
+          value, _ = entry
+          [key, value]
+        end.reject(&:nil?)
+      end
+    end
+
+    # (see Defaults#merge!)
+    def merge!(pairs, options={})
+      expires = expires_at(options)
+      options = Utils.without(options, :expires)
+
+      block = if block_given?
+                lambda do |key, old_entry, entry|
+                  old_entry = invalidate_entry(key, old_entry)
+                  if old_entry.nil?
+                    entry # behave as if no replace is happening
+                  else
+                    old_value, _ = old_entry
+                    new_value, _ = entry
+                    new_entry(yield(key, old_value, new_value), expires)
+                  end
+                end
+              end
+
+      entry_pairs = pairs.map do |key, value|
+        [key, new_entry(value, expires)]
+      end
+      @adapter.merge!(entry_pairs, options, &block)
+      self
+    end
+
     private
 
     def load_entry(key, options)
       new_expires = expires_at(options, nil)
       options = Utils.without(options, :expires)
       entry = @adapter.load(key, options)
+      invalidate_entry(key, entry, new_expires) do |new_entry|
+        @adapter.store(key, new_entry, options)
+      end
+    end
+
+    def invalidate_entry(key, entry, new_expires = nil)
       if entry != nil
         value, expires = entry
-        if expires && Time.now.to_i > expires
+        if expires && Time.now > Time.at(expires)
           delete(key)
-          nil
+          entry = nil
         elsif new_expires != nil
-          @adapter.store(key, new_entry(value, new_expires), options)
-          entry
-        else
-          entry
+          yield new_entry(value, new_expires) if block_given?
         end
       end
+      entry
     end
 
     def new_entry(value, expires)
       if expires
-        [value, expires.to_i]
+        [value, expires.to_r]
       elsif Array === value || value == nil
         [value]
       else
         value
       end
     end
+
+    def with_updates(options)
+      updates = {}
+      yield(updates).tap do
+        @adapter.merge!(updates, options) unless updates.empty?
+      end
+    end
   end
 end

data/lib/moneta/lock.rb

@@ -1,4 +1,4 @@
-require 'thread'
+require 'set'
 
 module Moneta
   # Locks the underlying stores with a Mutex
@@ -14,8 +14,27 @@ module Moneta
 
     protected
 
-    def wrap(*args, &block)
+    def wrap(name, *args, &block)
+      if locked?
+        block.call
+      else
+        lock!(&block)
+      end
+    end
+
+    def locks
+      Thread.current['Moneta::Lock'] ||= Set.new
+    end
+
+    def lock!(&block)
+      locks << @lock
       @lock.synchronize(&block)
+    ensure
+      locks.delete @lock
+    end
+
+    def locked?
+      locks.include? @lock
     end
   end
 end

data/lib/moneta/mixins.rb

@@ -74,7 +74,26 @@ module Moneta
       #     end
       #   end
       def supports(*features)
-        @features = (self.features + features).uniq.freeze
+        @features = (self.features | features).freeze
+      end
+
+      # Declares that this adapter does not support the given feature, and adds
+      # a stub method that raises a NotImplementedError.  Useful when inheriting
+      # from another adapter.
+      #
+      # @example
+      #   class MyAdapter < OtherAdapterWithCreate
+      #     include Moneta::Defaults
+      #     not_supports :create
+      #   end
+      def not_supports(*features)
+        features.each do |feature|
+          define_method(feature) do
+            raise ::NotImplementedError, "#{feature} not supported"
+          end
+        end
+
+        @features = (self.features - features).freeze
       end
     end
 
@@ -188,6 +207,24 @@ module Moneta
       store(key, value)
     end
 
+    # Calls block once for each key in store, passing the key as a parameter. If
+    # no block is given, an enumerator is returned instead.
+    #
+    # @note Not every Moneta store implements this method,
+    #       a NotImplementedError is raised if it is not supported.
+    #
+    # @overload each_key
+    #   @return [Enumerator] An all-the-keys enumerator
+    #
+    # @overload each_key
+    #   @yieldparam key [Object] Each key is yielded to the supplied block
+    #   @return [self]
+    #
+    # @api public
+    def each_key
+      raise NotImplementedError, 'each_key is not supported'
+    end
+
     # Atomically sets a key to value if it's not set.
     #
     # @note Not every Moneta store implements this method,
@@ -204,6 +241,119 @@ module Moneta
       raise NotImplementedError, 'create is not supported'
     end
 
+    # Returns an array containing the values associated with the given keys, in
+    # the same order as the supplied keys. If a key is not present in the
+    # key-value-store, nil is returned in its place.
+    #
+    # @note Some adapters may implement this method atomically, but the default
+    #   implementation simply makes repeated calls to {#load}.
+    #
+    # @param keys [<Object>] The keys for the values to fetch
+    # @param options [Hash]
+    # @option options (see Proxy#load)
+    # @return [Array<Object, nil>] Array containing the values requested, with
+    #   nil for missing values
+    # @api public
+    def values_at(*keys, **options)
+      keys.map { |key| load(key, options) }
+    end
+
+    # Behaves identically to {#values_at} except that it accepts an optional
+    # block. When supplied, the block will be called successively with each
+    # supplied key that is not present in the store.  The return value of the
+    # block call will be used in place of nil in returned the array of values.
+    #
+    # @note Some adapters may implement this method atomically. The default
+    #   implmentation uses {#values_at}.
+    #
+    # @overload fetch_values(*keys, **options)
+    #   @param (see #values_at)
+    #   @option options (see #values_at)
+    #   @return (see #values_at)
+    # @overload fetch_values(*keys, **options)
+    #   @param (see #values_at)
+    #   @option options (see #values_at)
+    #   @yieldparam key [Object] Each key that is not found in the store
+    #   @yieldreturn [Object, nil] The value to substitute for the missing one
+    #   @return [Array<Object, nil>] Array containing the values requested, or
+    #     where keys are missing, the return values from the corresponding block
+    #     calls
+    # @api public
+    def fetch_values(*keys, **options)
+      values = values_at(*keys, **options)
+      return values unless block_given?
+      keys.zip(values).map do |key, value|
+        if value == nil
+          yield key
+        else
+          value
+        end
+      end
+    end
+
+    # Returns a collection of key-value pairs corresponding to those supplied
+    # keys which are present in the key-value store, and their associated
+    # values.  Only those keys present in the store will have pairs in the
+    # return value.  The return value can be any enumerable object that yields
+    # pairs, so it could be a hash, but needn't be.
+    #
+    # @note The keys in the return value may be the same objects that were
+    #   supplied (i.e. {Object#equal?}), or may simply be equal (i.e.
+    #   {Object#==}).
+    #
+    # @note Some adapters may implement this method atomically. The default
+    #   implmentation uses {#values_at}.
+    #
+    # @param (see #values_at)
+    # @option options (see #values_at)
+    # @return [<(Object, Object)>] A collection of key-value pairs
+    # @api public
+    def slice(*keys, **options)
+      keys.zip(values_at(*keys, **options)).reject do |_, value|
+        value == nil
+      end
+    end
+
+    # Stores the pairs in the key-value store, and returns itself. When a block
+    # is provided, it will be called before overwriting any existing values with
+    # the key, old value and supplied value, and the return value of the block
+    # will be used in place of the supplied value.
+    #
+    # @note Some adapters may implement this method atomically, or in two passes
+    #   when a block is provided. The default implmentation uses {#key?},
+    #   {#load} and {#store}.
+    #
+    # @overload merge!(pairs, options={})
+    #   @param [<(Object, Object)>] pairs A collection of key-value pairs to store
+    #   @param [Hash] options
+    #   @option options (see Proxy#store)
+    #   @return [self]
+    # @overload merge!(pairs, options={})
+    #   @param [<(Object, Object)>] pairs A collection of key-value pairs to store
+    #   @param [Hash] options
+    #   @option options (see Proxy#store)
+    #   @yieldparam key [Object] A key that whose value is being overwritten
+    #   @yieldparam old_value [Object] The existing value which is being overwritten
+    #   @yieldparam new_value [Object] The value supplied in the method call
+    #   @yieldreturn [Object] The value to use for overwriting
+    #   @return [self]
+    # @api public
+    def merge!(pairs, options={})
+      pairs.each do |key, value|
+        if block_given?
+          existing = load(key, options)
+          value = yield(key, existing, value) unless existing == nil
+        end
+        store(key, value, options)
+      end
+      self
+    end
+
+    # (see #merge!)
+    def update(pairs, options = {}, &block)
+      merge!(pairs, options, &block)
+    end
+
     # Returns features list
     #
     # @return [Array<Symbol>] list of features
@@ -219,6 +369,40 @@ module Moneta
     end
   end
 
+  # This contains overrides of methods in Defaults where additional nil
+  # checks are required, because nil values are possible in the store.
+  # @api private
+  module NilValues
+    def fetch_values(*keys, **options)
+      values = values_at(*keys, **options)
+      return values unless block_given?
+      keys.zip(values).map do |key, value|
+        if value == nil && !key?(key)
+          yield key
+        else
+          value
+        end
+      end
+    end
+
+    def slice(*keys, **options)
+      keys.zip(values_at(*keys, **options)).reject do |key, value|
+        value == nil && !key?(key)
+      end
+    end
+
+    def merge!(pairs, options={})
+      pairs.each do |key, value|
+        if block_given? && key?(key, options)
+          existing = load(key, options)
+          value = yield(key, existing, value)
+        end
+        store(key, value, options)
+      end
+      self
+    end
+  end
+
   # @api private
   module IncrementSupport
     # (see Defaults#increment)
@@ -233,6 +417,32 @@ module Moneta
     end
   end
 
+  # This provides an each_key implementation that works in most cases.
+  # @api private
+  module EachKeySupport
+    def each_key
+      return enum_for(:each_key) unless block_given?
+
+      if @backend.respond_to?(:each_key)
+        @backend.each_key { |key| yield key }
+      elsif @backend.respond_to?(:keys)
+        if keys = @backend.keys
+          keys.each { |key| yield key }
+        end
+      elsif @backend.respond_to?(:each)
+        @backend.each { |key, _| yield key }
+      else
+        raise ::NotImplementedError, "No enumerable found on backend"
+      end
+
+      self
+    end
+
+    def self.included(base)
+      base.supports(:each_key) if base.respond_to?(:supports)
+    end
+  end
+
   # Implements simple create using key? and store.
   #
   # This is sufficient for non-shared stores or if atomicity is not required.
@@ -282,6 +492,72 @@ module Moneta
       @backend.clear
       self
     end
+
+    # (see Defaults#values_at)
+    def values_at(*keys, **options)
+      return super unless @backend.respond_to? :values_at
+      @backend.values_at(*keys)
+    end
+
+    # (see Defaults#fetch_values)
+    def fetch_values(*keys, **options, &defaults)
+      return super unless @backend.respond_to? :fetch_values
+      defaults ||= {} # prevents KeyError
+      @backend.fetch_values(*keys, &defaults)
+    end
+
+    # (see Defaults#slice)
+    def slice(*keys, **options)
+      return super unless @backend.respond_to? :slice
+      @backend.slice(*keys)
+    end
+
+    # (see Defaults#merge!)
+    def merge!(pairs, options={}, &block)
+      return super unless method = [:merge!, :update].find do |method|
+        @backend.respond_to? method
+      end
+
+      hash = Hash === pairs ? pairs : Hash[pairs.to_a]
+      case method
+      when :merge!
+        @backend.merge!(hash, &block)
+      when :update
+        @backend.update(hash, &block)
+      end
+
+      self
+    end
+  end
+
+  # This is for adapters that conform to the DBM interface
+  # @api private
+  module DBMAdapter
+    include HashAdapter
+
+    # (see Proxy#close)
+    def close
+      @backend.close
+      nil
+    end
+
+    # (see Proxy#merge!)
+    def merge!(pairs, options = {})
+      hash =
+        if block_given?
+          keys = pairs.map { |k, _| k }
+          old_pairs = Hash[slice(*keys)]
+          Hash[pairs.map do |key, new_value|
+            new_value = yield(key, old_pairs[key], new_value) if old_pairs.key?(key)
+            [key, new_value]
+          end.to_a]
+        else
+          Hash === pairs ? pairs : Hash[pairs.to_a]
+        end
+
+      @backend.update(hash)
+      self
+    end
   end
 
   # This mixin handles the calculation of expiration times.
@@ -326,9 +602,9 @@ module Moneta
       when 0, false
         false
       when nil
-        default ? default.to_i : nil
+        default ? default.to_r : nil
       when Numeric
-        value = value.to_i
+        value = value.to_r
         raise ArgumentError, ":expires must be a positive value, got #{value}" if value < 0
         value
       else