moneta 1.4.1 → 1.5.1

data/lib/moneta/adapters/pstore.rb

@@ -5,63 +5,61 @@ module Moneta
   module Adapters
     # PStore backend
     # @api public
-    class PStore
-      include Defaults
+    class PStore < Adapter
       include NilValues
 
       supports :create, :increment, :each_key
-      attr_reader :backend
+
+      backend do |file:, threadsafe: false|
+        FileUtils.mkpath(::File.dirname(file))
+        ::PStore.new(file, threadsafe)
+      end
 
       # @param [Hash] options
       # @option options [String] :file PStore file
+      # @option options [Boolean] :threadsafe Makes the PStore thread-safe
       # @option options [::PStore] :backend Use existing backend instance
       def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            FileUtils.mkpath(::File.dirname(options[:file]))
-            new_store(options)
-          end
-
+        super
         @id = "Moneta::Adapters::PStore(#{object_id})"
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        transaction(true) { @backend.root?(key) }
+        transaction(true) { backend.root?(key) }
       end
 
       # (see Proxy#each_key)
       def each_key(&block)
-        return enum_for(:each_key) { transaction(true) { @backend.roots.size } } unless block_given?
+        return enum_for(:each_key) { transaction(true) { backend.roots.size } } unless block_given?
 
         transaction(true) do
-          @backend.roots.each { |k| yield(k) }
+          backend.roots.each { |k| yield(k) }
         end
         self
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        transaction(true) { @backend[key] }
+        transaction(true) { backend[key] }
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        transaction { @backend[key] = value }
+        transaction { backend[key] = value }
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        transaction { @backend.delete(key) }
+        transaction { backend.delete(key) }
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         transaction do
-          existing = @backend[key]
+          existing = backend[key]
           value = (existing == nil ? 0 : Integer(existing)) + amount
-          @backend[key] = value.to_s
+          backend[key] = value.to_s
           value
         end
       end
@@ -69,10 +67,10 @@ module Moneta
       # (see Proxy#create)
       def create(key, value, options = {})
         transaction do
-          if @backend.root?(key)
+          if backend.root?(key)
             false
           else
-            @backend[key] = value
+            backend[key] = value
             true
           end
         end
@@ -81,8 +79,8 @@ module Moneta
       # (see Proxy#clear)
       def clear(options = {})
         transaction do
-          @backend.roots.each do |key|
-            @backend.delete(key)
+          backend.roots.each do |key|
+            backend.delete(key)
           end
         end
         self
@@ -109,10 +107,6 @@ module Moneta
 
       class TransactionError < StandardError; end
 
-      def new_store(options)
-        ::PStore.new(options[:file], options[:threadsafe])
-      end
-
       def transaction(read_only = false)
         case Thread.current[@id]
         when read_only, false
@@ -122,7 +116,7 @@ module Moneta
         else
           begin
             Thread.current[@id] = read_only
-            @backend.transaction(read_only) { yield }
+            backend.transaction(read_only) { yield }
           ensure
             Thread.current[@id] = nil
           end

data/lib/moneta/adapters/redis.rb

@@ -4,32 +4,28 @@ module Moneta
   module Adapters
     # Redis backend
     # @api public
-    class Redis
-      include Defaults
+    class Redis < Adapter
       include ExpiresSupport
 
       supports :create, :increment, :each_key
-      attr_reader :backend
-
-      # @param [Hash] options
-      # @option options [Integer] :expires Default expiration time
-      # @option options [::Redis] :backend Use existing backend instance
-      # @option options Other options passed to `Redis#new`
-      def initialize(options = {})
-        self.default_expires = options.delete(:expires)
-        @backend = options[:backend] || ::Redis.new(options)
-      end
+
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [Integer] :expires Default expiration time
+      #   @option options [::Redis] :backend Use existing backend instance
+      #   @option options Other options passed to `Redis#new`
+      backend { |**options| ::Redis.new(options) }
 
       # (see Proxy#key?)
       #
       # This method considers false and 0 as "no-expire" and every positive
       # number as a time to live in seconds.
       def key?(key, options = {})
-        with_expiry_update(key, default: nil, **options) do
-          if @backend.respond_to?(:exists?)
-            @backend.exists?(key)
+        with_expiry_update(key, default: nil, **options) do |pipeline_handle|
+          if pipeline_handle.respond_to?(:exists?)
+            pipeline_handle.exists?(key)
           else
-            @backend.exists(key)
+            pipeline_handle.exists(key)
           end
         end
       end
@@ -44,8 +40,8 @@ module Moneta
 
       # (see Proxy#load)
       def load(key, options = {})
-        with_expiry_update(key, default: nil, **options) do
-          @backend.get(key)
+        with_expiry_update(key, default: nil, **options) do |pipeline_handle|
+          pipeline_handle.get(key)
         end
       end
 
@@ -63,17 +59,17 @@ module Moneta
       # (see Proxy#delete)
       def delete(key, options = {})
         future = nil
-        @backend.pipelined do
-          future = @backend.get(key)
-          @backend.del(key)
+        @backend.pipelined do |pipeline|
+          future = pipeline.get(key)
+          pipeline.del(key)
         end
         future.value
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        with_expiry_update(key, **options) do
-          @backend.incrby(key, amount)
+        with_expiry_update(key, **options) do |pipeline_handle|
+          pipeline_handle.incrby(key, amount)
         end
       end
 
@@ -85,10 +81,10 @@ module Moneta
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        expires = expires_value(options, @default_expires)
+        expires = expires_value(options, config.expires)
 
         if @backend.setnx(key, value)
-          update_expires(key, expires)
+          update_expires(@backend, key, expires)
           true
         else
           false
@@ -103,8 +99,8 @@ module Moneta
 
       # (see Defaults#values_at)
       def values_at(*keys, **options)
-        with_expiry_update(*keys, default: nil, **options) do
-          @backend.mget(*keys)
+        with_expiry_update(*keys, default: nil, **options) do |pipeline_handle|
+          pipeline_handle.mget(*keys)
         end
       end
 
@@ -130,8 +126,8 @@ module Moneta
           end
         end
 
-        with_expiry_update(*keys, **options) do
-          @backend.mset(*pairs.to_a.flatten(1))
+        with_expiry_update(*keys, **options) do |pipeline_handle|
+          pipeline_handle.mset(*pairs.to_a.flatten(1))
         end
 
         self
@@ -139,24 +135,33 @@ module Moneta
 
       protected
 
-      def update_expires(key, expires)
+      def update_expires(pipeline_handle, key, expires)
         case expires
         when false
-          @backend.persist(key)
+          pipeline_handle.persist(key)
         when Numeric
-          @backend.pexpire(key, (expires * 1000).to_i)
+          pipeline_handle.pexpire(key, (expires * 1000).to_i)
         end
       end
 
-      def with_expiry_update(*keys, default: @default_expires, **options)
+      def with_expiry_update(*keys, default: config.expires, **options)
         expires = expires_value(options, default)
         if expires == nil
-          yield
+          yield(@backend)
         else
           future = nil
-          @backend.multi do
-            future = yield
-            keys.each { |key| update_expires(key, expires) }
+          @backend.multi do |pipeline|
+            # as of redis 4.6 calling redis methods on the redis client itself
+            # is deprecated in favor of a pipeline handle provided by the
+            # +multi+ call. This will cause in error in redis >= 5.0.
+            #
+            # In order to continue supporting redis versions < 4.6, the following
+            # fallback has been introduced and can be removed once moneta
+            # no longer supports redis < 4.6.
+
+            pipeline_handle = pipeline || @backend
+            future = yield(pipeline_handle)
+            keys.each { |key| update_expires(pipeline_handle, key, expires) }
           end
           future.value
         end

data/lib/moneta/adapters/restclient.rb

@@ -4,55 +4,47 @@ module Moneta
   module Adapters
     # Moneta rest client backend which works together with {Rack::MonetaRest}
     # @api public
-    class RestClient
-      include Defaults
-
-      attr_reader :backend
-
-      # @param [Hash] options
-      # @option options [String] :url URL
-      # @option options [Symbol] :adapter The adapter to tell Faraday to use
-      # @option options [Faraday::Connection] :backend Use existing backend instance
-      # @option options Other options passed to {Faraday::new} (unless
-      #   :backend option is provided).
-      def initialize(options = {})
-        @backend = options.delete(:backend) ||
-          begin
-            raise ArgumentError, 'Option :url is required' unless url = options.delete(:url)
-            block = if faraday_adapter = options.delete(:adapter)
-                      proc { |faraday| faraday.adapter faraday_adapter }
-                    end
-            ::Faraday.new(url, options, &block)
-          end
+    class RestClient < Adapter
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :url URL
+      #   @option options [Symbol] :adapter The adapter to tell Faraday to use
+      #   @option options [Faraday::Connection] :backend Use existing backend instance
+      #   @option options Other options passed to {Faraday::new} (unless
+      #     :backend option is provided).
+      backend do |url:, adapter: nil, **options|
+        ::Faraday.new(url, options) do |faraday|
+          faraday.adapter adapter if adapter
+        end
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @backend.head(key).status == 200
+        backend.head(key).status == 200
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        response = @backend.get(key)
+        response = backend.get(key)
         response.status == 200 ? response.body : nil
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        response = @backend.post(key, value)
+        response = backend.post(key, value)
         raise "HTTP error #{response.status}" unless response.status == 200
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        response = @backend.delete(key)
+        response = backend.delete(key)
         response.status == 200 ? response.body : nil
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @backend.delete ''
+        backend.delete ''
         self
       end
     end

data/lib/moneta/adapters/riak.rb

@@ -5,21 +5,20 @@ module Moneta
     # Riak backend
     # @api public
     # @author Potapov Sergey (aka Blake)
-    class Riak
-      include Defaults
+    class Riak < Adapter
+      config :bucket, default: 'moneta'
+      config :content_type, default: 'application/octet-stream'
 
-      attr_reader :backend
+      backend { |**options| ::Riak::Client.new(options) }
 
       # @param [Hash] options
       # @option options [String] :bucket ('moneta') Bucket name
       # @option options [String] :content_type ('application/octet-stream') Default content type
-      # @option options All other options passed to `Riak::Client#new`
       # @option options [::Riak::Client] :backend Use existing backend instance
+      # @option options All other options passed to `Riak::Client#new`
       def initialize(options = {})
-        bucket = options.delete(:bucket) || 'moneta'
-        @content_type = options.delete(:content_type) || 'application/octet-stream'
-        @backend = options[:backend] || ::Riak::Client.new(options)
-        @bucket = @backend.bucket(bucket)
+        super
+        @bucket = backend.bucket(config.bucket)
       end
 
       # (see Proxy#key?)
@@ -44,7 +43,7 @@ module Moneta
       # (see Proxy#store)
       def store(key, value, options = {})
         obj = ::Riak::RObject.new(@bucket, key)
-        obj.content_type = options[:content_type] || @content_type
+        obj.content_type = options[:content_type] || config.content_type
         obj.raw_data = value
         obj.store(options.dup)
         value

data/lib/moneta/adapters/sdbm.rb

@@ -4,23 +4,17 @@ module Moneta
   module Adapters
     # SDBM backend
     # @api public
-    class SDBM
-      include Defaults
+    class SDBM < Adapter
       include DBMAdapter
       include IncrementSupport
       include CreateSupport
       include EachKeySupport
 
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::SDBM] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::SDBM.new(options[:file])
-          end
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::SDBM] :backend Use existing backend instance
+      backend { |file:| ::SDBM.new(file) }
     end
   end
 end

data/lib/moneta/adapters/sequel/mysql.rb

@@ -14,7 +14,7 @@ module Moneta
             # "gap lock").
             if row = @load_for_update.call(key: key)
               # Integer() will raise an exception if the existing value cannot be parsed
-              amount += Integer(row[value_column])
+              amount += Integer(row[config.value_column])
               @increment_update.call(key: key, value: amount)
             else
               @create.call(key: key, value: amount)
@@ -31,17 +31,17 @@ module Moneta
             pairs = yield_merge_pairs(pairs, &block) if block_given?
             @table
               .on_duplicate_key_update
-              .import([key_column, value_column], blob_pairs(pairs).to_a)
+              .import([config.key_column, config.value_column], blob_pairs(pairs).to_a)
           end
 
           self
         end
 
         def each_key
-          return super unless block_given? && @each_key_server && @table.respond_to?(:stream)
+          return super unless block_given? && config.each_key_server && @table.respond_to?(:stream)
           # Order is not required when streaming
-          @table.server(@each_key_server).select(key_column).paged_each do |row|
-            yield row[key_column]
+          @table.server(config.each_key_server).select(config.key_column).paged_each do |row|
+            yield row[config.key_column]
           end
           self
         end
@@ -51,13 +51,13 @@ module Moneta
         def prepare_store
           @store = @table
             .on_duplicate_key_update
-            .prepare(:insert, statement_id(:store), key_column => :$key, value_column => :$value)
+            .prepare(:insert, statement_id(:store), config.key_column => :$key, config.value_column => :$value)
         end
 
         def prepare_increment
           @increment_update = @table
-            .where(key_column => :$key)
-            .prepare(:update, statement_id(:increment_update), value_column => :$value)
+            .where(config.key_column => :$key)
+            .prepare(:update, statement_id(:increment_update), config.value_column => :$value)
           super
         end
       end

data/lib/moneta/adapters/sequel/postgres.rb

@@ -12,14 +12,14 @@ module Moneta
         def increment(key, amount = 1, options = {})
           result = @increment.call(key: key, value: blob(amount.to_s), amount: amount)
           if row = result.first
-            row[value_column].to_i
+            row[config.value_column].to_i
           end
         end
 
         def delete(key, options = {})
           result = @delete.call(key: key)
           if row = result.first
-            row[value_column]
+            row[config.value_column]
           end
         end
 
@@ -27,19 +27,19 @@ module Moneta
           @backend.transaction do
             pairs = yield_merge_pairs(pairs, &block) if block_given?
             @table
-              .insert_conflict(target: key_column,
-                               update: { value_column => ::Sequel[:excluded][value_column] })
-              .import([key_column, value_column], blob_pairs(pairs).to_a)
+              .insert_conflict(target: config.key_column,
+                               update: { config.value_column => ::Sequel[:excluded][config.value_column] })
+              .import([config.key_column, config.value_column], blob_pairs(pairs).to_a)
           end
 
           self
         end
 
         def each_key
-          return super unless block_given? && !@each_key_server && @table.respond_to?(:use_cursor)
+          return super unless block_given? && !config.each_key_server && @table.respond_to?(:use_cursor)
           # With a cursor, this will Just Work.
-          @table.select(key_column).paged_each do |row|
-            yield row[key_column]
+          @table.select(config.key_column).paged_each do |row|
+            yield row[config.key_column]
           end
           self
         end
@@ -48,30 +48,30 @@ module Moneta
 
         def prepare_store
           @store = @table
-            .insert_conflict(target: key_column,
-                             update: { value_column => ::Sequel[:excluded][value_column] })
-            .prepare(:insert, statement_id(:store), key_column => :$key, value_column => :$value)
+            .insert_conflict(target: config.key_column,
+                             update: { config.value_column => ::Sequel[:excluded][config.value_column] })
+            .prepare(:insert, statement_id(:store), config.key_column => :$key, config.value_column => :$value)
         end
 
         def prepare_increment
           update_expr = ::Sequel[:convert_to].function(
             (::Sequel[:convert_from].function(
-              ::Sequel[@table_name][value_column],
+              ::Sequel[config.table][config.value_column],
               'UTF8'
             ).cast(Integer) + :$amount).cast(String),
             'UTF8'
           )
 
           @increment = @table
-            .returning(value_column)
-            .insert_conflict(target: key_column, update: { value_column => update_expr })
-            .prepare(:insert, statement_id(:increment), key_column => :$key, value_column => :$value)
+            .returning(config.value_column)
+            .insert_conflict(target: config.key_column, update: { config.value_column => update_expr })
+            .prepare(:insert, statement_id(:increment), config.key_column => :$key, config.value_column => :$value)
         end
 
         def prepare_delete
           @delete = @table
-            .returning(value_column)
-            .where(key_column => :$key)
+            .returning(config.value_column)
+            .where(config.key_column => :$key)
             .prepare(:delete, statement_id(:delete))
         end
       end