moneta 1.0.0 → 1.5.1

data/lib/moneta/adapters/tokyotyrant.rb

@@ -10,51 +10,50 @@ module Moneta
   module Adapters
     # TokyoTyrant backend
     # @api public
-    class TokyoTyrant
-      include Defaults
+    class TokyoTyrant < Adapter
       include HashAdapter
 
       # error code: no record found
       ENOREC = 7
 
       supports :create, :increment
-      attr_reader :backend
+
+      backend do |host: '127.0.0.1', port: 1978|
+        if defined?(::TokyoTyrant::RDB)
+          # Use ruby client
+          ::TokyoTyrant::RDB.new.tap do |backend|
+            backend.open(host, port) or raise backend.errmsg
+          end
+        else
+          # Use native client
+          ::TokyoTyrant::DB.new(host, port)
+        end
+      end
 
       # @param [Hash] options
       # @option options [String] :host ('127.0.0.1') Server host name
       # @option options [Integer] :port (1978) Server port
       # @option options [::TokyoTyrant::RDB] :backend Use existing backend instance
       def initialize(options = {})
-        options[:host] ||= '127.0.0.1'
-        options[:port] ||= 1978
-        if options[:backend]
-          @backend = options[:backend]
-        elsif defined?(::TokyoTyrant::RDB)
-          # Use ruby client
-          @backend = ::TokyoTyrant::RDB.new
-          @backend.open(options[:host], options[:port]) or error
-        else
-          # Use native client
-          @backend = ::TokyoTyrant::DB.new(options[:host], options[:port])
-        end
-        @native = @backend.class.name != 'TokyoTyrant::RDB'
+        super
+        @native = backend.class.name != 'TokyoTyrant::RDB'
         probe = '__tokyotyrant_endianness_probe'
-        @backend.delete(probe)
-        @backend.addint(probe, 1)
-        @pack = @backend.delete(probe) == [1].pack('l>') ? 'l>' : 'l<'
+        backend.delete(probe)
+        backend.addint(probe, 1)
+        @pack = backend.delete(probe) == [1].pack('l>') ? 'l>' : 'l<'
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        value = @backend[key]
+        value = backend[key]
         # raise if there is an error and the error is not "no record"
-        error if value.nil? && @backend.ecode != ENOREC
+        error if value == nil && backend.ecode != ENOREC
         value && unpack(value)
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @backend.put(key, pack(value)) or error
+        backend.put(key, pack(value)) or error
         value
       end
 
@@ -62,14 +61,14 @@ module Moneta
       def delete(key, options = {})
         value = load(key, options)
         if value
-          @backend.delete(key) or error
+          backend.delete(key) or error
           value
         end
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @backend.addint(key, amount) or error
+        backend.addint(key, amount) or error
       end
 
       # (see Proxy#create)
@@ -77,21 +76,43 @@ module Moneta
         if @native
           begin
             # Native client throws an exception
-            @backend.putkeep(key, pack(value))
+            backend.putkeep(key, pack(value))
           rescue TokyoTyrantError
             false
           end
         else
-          @backend.putkeep(key, pack(value))
+          backend.putkeep(key, pack(value))
         end
       end
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         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)
@@ -120,7 +141,7 @@ module Moneta
       end
 
       def error
-        raise "#{@backend.class.name} error: #{@backend.errmsg}"
+        raise "#{backend.class.name} error: #{backend.errmsg}"
       end
     end
   end

data/lib/moneta/adapters/yaml.rb

@@ -5,11 +5,7 @@ module Moneta
     # YAML::Store backend
     # @api public
     class YAML < PStore
-      protected
-
-      def new_store(options)
-        ::YAML::Store.new(options[:file])
-      end
+      backend { |file:| ::YAML::Store.new(file) }
     end
   end
 end

data/lib/moneta/builder.rb

@@ -17,12 +17,12 @@ module Moneta
       adapter = @proxies.first
       if Array === adapter
         klass, options, block = adapter
-        adapter = new_proxy(klass, options, &block)
+        adapter = new_proxy(klass, options.dup, &block)
         check_arity(klass, adapter, 1)
       end
       @proxies[1..-1].inject([adapter]) do |result, proxy|
         klass, options, block = proxy
-        proxy = new_proxy(klass, result.last, options, &block)
+        proxy = new_proxy(klass, result.last, options.dup, &block)
         check_arity(klass, proxy, 2)
         result << proxy
       end
@@ -79,5 +79,4 @@ Please check your Moneta builder block:
 }) if args != expected
     end
   end
-
 end

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/config.rb

@@ -0,0 +1,101 @@
+require 'set'
+
+module Moneta
+  # Some docs here
+  module Config
+    # @api private
+    module ClassMethods
+      def config(name, coerce: nil, default: nil, required: false, &block)
+        raise ArgumentError, 'name must be a symbol' unless Symbol === name
+
+        defaults = config_defaults
+
+        raise ArgumentError, "#{name} is already a config option" if defaults.key?(name)
+        raise ArgumentError, "coerce must respond to :to_proc" if coerce && !coerce.respond_to?(:to_proc)
+
+        defaults.merge!(name => default.freeze).freeze
+        instance_variable_set :@config_defaults, defaults
+
+        instance_variable_set :@config_coercions, config_coercions.merge!(name => coerce.to_proc) if coerce
+        instance_variable_set :@config_required_keys, config_required_keys.add(name).freeze if required
+        instance_variable_set :@config_blocks, config_blocks.merge!(name => block) if block
+      end
+
+      def config_variable(name)
+        if instance_variable_defined?(name)
+          instance_variable_get(name).dup
+        elsif superclass.respond_to?(:config_variable)
+          superclass.config_variable(name)
+        end
+      end
+
+      def config_defaults
+        config_variable(:@config_defaults) || {}
+      end
+
+      def config_required_keys
+        config_variable(:@config_required_keys) || Set.new
+      end
+
+      def config_coercions
+        config_variable(:@config_coercions) || {}
+      end
+
+      def config_blocks
+        config_variable(:@config_blocks) || {}
+      end
+
+      def config_struct
+        unless @config_struct
+          keys = config_defaults.keys
+          @config_struct = Struct.new(*keys) unless keys.empty?
+        end
+
+        @config_struct
+      end
+    end
+
+    def config
+      raise "Not configured" unless defined?(@config)
+      @config
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    protected
+
+    def configure(**options)
+      raise 'Already configured' if defined?(@config)
+
+      self.class.config_required_keys.each do |key|
+        raise ArgumentError, "#{key} is required" unless options.key? key
+      end
+
+      defaults = self.class.config_defaults
+
+      overrides, remainder = options
+        .partition { |key,| defaults.key? key }
+        .map { |pairs| pairs.to_h }
+
+      self.class.config_coercions.each do |key, coerce|
+        overrides[key] = coerce.call(overrides[key]) if overrides.key?(key)
+      end
+
+      overridden = defaults.merge!(overrides)
+
+      config_blocks = self.class.config_blocks
+      values = overridden.map do |key, value|
+        if config_block = config_blocks[key]
+          instance_exec(**overridden, &config_block)
+        else
+          value
+        end
+      end
+
+      @config = self.class.config_struct&.new(*values).freeze
+      remainder
+    end
+  end
+end

data/lib/moneta/create_support.rb

@@ -0,0 +1,21 @@
+module Moneta
+  # Implements simple create using key? and store.
+  #
+  # This is sufficient for non-shared stores or if atomicity is not required.
+  # @api private
+  module CreateSupport
+    # (see Defaults#create)
+    def create(key, value, options = {})
+      if key? key
+        false
+      else
+        store(key, value, options)
+        true
+      end
+    end
+
+    def self.included(base)
+      base.supports(:create) if base.respond_to?(:supports)
+    end
+  end
+end

data/lib/moneta/dbm_adapter.rb

@@ -0,0 +1,31 @@
+module Moneta
+  # 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
+end

data/lib/moneta/defaults.rb

@@ -0,0 +1,320 @@
+module Moneta
+  # Simple interface to key/value stores with Hash-like interface.
+  # @api public
+  module Defaults
+    include ::Moneta::OptionSupport
+
+    # @api private
+    module ClassMethods
+      # Returns features list
+      #
+      # @return [Array<Symbol>] list of features
+      def features
+        @features ||= superclass.respond_to?(:features) ? superclass.features : [].freeze
+      end
+
+      # Declares that this adapter supports the given feature.
+      #
+      # @example
+      #   class MyAdapter
+      #     include Moneta::Defaults
+      #     supports :create
+      #     def create(key, value, options = {})
+      #       # implement create!
+      #     end
+      #   end
+      def supports(*features)
+        @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
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Exists the value with key
+    #
+    # @param [Object] key
+    # @param [Hash] options
+    # @option options [Integer] :expires Update expiration time (See {Expires})
+    # @option options [String] :prefix Prefix key (See {Transformer})
+    # @option options Other options as defined by the adapters or middleware
+    # @return [Boolean]
+    # @api public
+    def key?(key, options = {})
+      load(key, options) != nil
+    end
+
+    # Atomically increment integer value with key
+    #
+    # This method also accepts negative amounts.
+    #
+    # @note Not every Moneta store implements this method,
+    #       a NotImplementedError is raised if it is not supported.
+    # @param [Object] key
+    # @param [Integer] amount
+    # @param [Hash] options
+    # @option options [String] :prefix Prefix key (See {Transformer})
+    # @option options Other options as defined by the adapters or middleware
+    # @return [Object] value from store
+    # @api public
+    def increment(key, amount = 1, options = {})
+      raise NotImplementedError, 'increment is not supported'
+    end
+
+    # Atomically decrement integer value with key
+    #
+    # This is just syntactic sugar for calling #increment with a negative value.
+    #
+    # This method also accepts negative amounts.
+    #
+    # @param [Object] key
+    # @param [Integer] amount
+    # @param [Hash] options
+    # @option options [String] :prefix Prefix key (See {Transformer})
+    # @option options Other options as defined by the adapters or middleware
+    # @return [Object] value from store
+    # @api public
+    def decrement(key, amount = 1, options = {})
+      increment(key, -amount, options)
+    end
+
+    # Explicitly close the store
+    # @return nil
+    # @api public
+    def close; end
+
+    # Fetch a value with a key
+    #
+    # @overload fetch(key, options = {}, &block)
+    #   retrieve a key. if the key is not available, execute the
+    #   block and return its return value.
+    #   @param [Object] key
+    #   @param [Hash] options
+    #   @option options [Integer] :expires Update expiration time (See {Expires})
+    #   @option options [Boolean] :raw Raw access without value transformation (See {Transformer})
+    #   @option options [String] :prefix Prefix key (See {Transformer})
+    #   @return [Object] value from store
+    #
+    # @overload fetch(key, default, options = {})
+    #   retrieve a key. if the key is not available, return the default value.
+    #   @param [Object] key
+    #   @param [Object] default Default value
+    #   @param [Hash] options
+    #   @option options [Integer] :expires Update expiration time (See {Expires})
+    #   @option options [Boolean] :raw Raw access without value transformation (See {Transformer})
+    #   @option options [String] :prefix Prefix key (See {Transformer})
+    #   @return [Object] value from store
+    #
+    # @api public
+    def fetch(key, default = nil, options = nil)
+      if block_given?
+        raise ArgumentError, 'Only one argument accepted if block is given' if options
+        result = load(key, default || {})
+        result == nil ? yield(key) : result
+      else
+        result = load(key, options || {})
+        result == nil ? default : result
+      end
+    end
+
+    # Fetch value with key. Return nil if the key doesn't exist
+    #
+    # @param [Object] key
+    # @return [Object] value
+    # @api public
+    def [](key)
+      load(key)
+    end
+
+    # Store value with key
+    #
+    # @param [Object] key
+    # @param [Object] value
+    # @return value
+    # @api public
+    def []=(key, value)
+      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,
+    #       a NotImplementedError is raised if it is not supported.
+    # @param [Object] key
+    # @param [Object] value
+    # @param [Hash] options
+    # @option options [Integer] :expires Update expiration time (See {Expires})
+    # @option options [Boolean] :raw Raw access without value transformation (See {Transformer})
+    # @option options [String] :prefix Prefix key (See {Transformer})
+    # @return [Boolean] key was set
+    # @api public
+    def create(key, value, options = {})
+      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
+    def features
+      self.class.features
+    end
+
+    # Return true if adapter supports the given feature.
+    #
+    # @return [Boolean]
+    def supports?(feature)
+      features.include?(feature)
+    end
+  end
+end

data/lib/moneta/each_key_support.rb

@@ -0,0 +1,27 @@
+module Moneta
+  # 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
+end