moneta 1.4.2 → 1.5.0

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

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

@@ -12,7 +12,7 @@ module Moneta
 
         def key?(key, options = {})
           if @key
-            row = @key.call(row: @row, key: key) || false
+            row = @key.call(row: config.hstore, key: key) || false
             row && row[:present]
           else
             @key_pl.get(key)
@@ -22,13 +22,13 @@ module Moneta
         def store(key, value, options = {})
           @backend.transaction do
             create_row
-            @store.call(row: @row, pair: ::Sequel.hstore(key => value))
+            @store.call(row: config.hstore, pair: ::Sequel.hstore(key => value))
           end
           value
         end
 
         def load(key, options = {})
-          if row = @load.call(row: @row, key: key)
+          if row = @load.call(row: config.hstore, key: key)
             row[:value]
           end
         end
@@ -36,7 +36,7 @@ module Moneta
         def delete(key, options = {})
           @backend.transaction do
             value = load(key, options)
-            @delete.call(row: @row, key: key)
+            @delete.call(row: config.hstore, key: key)
             value
           end
         end
@@ -44,7 +44,7 @@ module Moneta
         def increment(key, amount = 1, options = {})
           @backend.transaction do
             create_row
-            if row = @increment.call(row: @row, key: key, amount: amount).first
+            if row = @increment.call(row: config.hstore, key: key, amount: amount).first
               row[:value].to_i
             end
           end
@@ -55,23 +55,23 @@ module Moneta
             create_row
             1 ==
               if @create
-                @create.call(row: @row, key: key, pair: ::Sequel.hstore(key => value))
+                @create.call(row: config.hstore, key: key, pair: ::Sequel.hstore(key => value))
               else
                 @table
-                  .where(key_column => @row)
-                  .exclude(::Sequel[value_column].hstore.key?(key))
-                  .update(value_column => ::Sequel[value_column].hstore.merge(key => value))
+                  .where(config.key_column => config.hstore)
+                  .exclude(::Sequel[config.value_column].hstore.key?(key))
+                  .update(config.value_column => ::Sequel[config.value_column].hstore.merge(key => value))
               end
           end
         end
 
         def clear(options = {})
-          @clear.call(row: @row)
+          @clear.call(row: config.hstore)
           self
         end
 
         def values_at(*keys, **options)
-          if row = @values_at.call(row: @row, keys: ::Sequel.pg_array(keys))
+          if row = @values_at.call(row: config.hstore, keys: ::Sequel.pg_array(keys))
             row[:values].to_a
           else
             []
@@ -79,7 +79,7 @@ module Moneta
         end
 
         def slice(*keys, **options)
-          if row = @slice.call(row: @row, keys: ::Sequel.pg_array(keys))
+          if row = @slice.call(row: config.hstore, keys: ::Sequel.pg_array(keys))
             row[:pairs].to_h
           else
             []
@@ -91,24 +91,24 @@ module Moneta
             create_row
             pairs = yield_merge_pairs(pairs, &block) if block_given?
             hash = Hash === pairs ? pairs : Hash[pairs.to_a]
-            @store.call(row: @row, pair: ::Sequel.hstore(hash))
+            @store.call(row: config.hstore, pair: ::Sequel.hstore(hash))
           end
 
           self
         end
 
         def each_key
-          return enum_for(:each_key) { @size.call(row: @row)[:size] } unless block_given?
+          return enum_for(:each_key) { @size.call(row: config.hstore)[:size] } unless block_given?
 
           ds =
-            if @each_key_server
-              @table.server(@each_key_server)
+            if config.each_key_server
+              @table.server(config.each_key_server)
             else
               @table
             end
           ds = ds.order(:skeys) unless @table.respond_to?(:use_cursor)
-          ds.where(key_column => @row)
-            .select(::Sequel[value_column].hstore.skeys)
+          ds.where(config.key_column => config.hstore)
+            .select(::Sequel[config.value_column].hstore.skeys)
             .paged_each do |row|
               yield row[:skeys]
             end
@@ -118,14 +118,14 @@ module Moneta
         protected
 
         def create_row
-          @create_row.call(row: @row)
+          @create_row.call(row: config.hstore)
         end
 
         def create_table
-          key_column = self.key_column
-          value_column = self.value_column
+          key_column = config.key_column
+          value_column = config.value_column
 
-          @backend.create_table?(@table_name) do
+          @backend.create_table?(config.table) do
             column key_column, String, null: false, primary_key: true
             column value_column, :hstore
             index value_column, type: :gin
@@ -134,7 +134,7 @@ module Moneta
 
         def slice_for_update(pairs)
           keys = pairs.map { |k, _| k }.to_a
-          if row = @slice_for_update.call(row: @row, keys: ::Sequel.pg_array(keys))
+          if row = @slice_for_update.call(row: config.hstore, keys: ::Sequel.pg_array(keys))
             row[:pairs].to_h
           else
             {}
@@ -152,53 +152,53 @@ module Moneta
         def prepare_create_row
           @create_row = @table
             .insert_ignore
-            .prepare(:insert, statement_id(:hstore_create_row), key_column => :$row, value_column => '')
+            .prepare(:insert, statement_id(:hstore_create_row), config.key_column => :$row, config.value_column => '')
         end
 
         def prepare_clear
-          @clear = @table.where(key_column => :$row).prepare(:update, statement_id(:hstore_clear), value_column => '')
+          @clear = @table.where(config.key_column => :$row).prepare(:update, statement_id(:hstore_clear), config.value_column => '')
         end
 
         def prepare_key
           if defined?(JRUBY_VERSION)
             @key_pl = ::Sequel::Dataset::PlaceholderLiteralizer.loader(@table) do |pl, ds|
-              ds.where(key_column => @row).select(::Sequel[value_column].hstore.key?(pl.arg))
+              ds.where(config.key_column => config.hstore).select(::Sequel[config.value_column].hstore.key?(pl.arg))
             end
           else
-            @key = @table.where(key_column => :$row)
-              .select(::Sequel[value_column].hstore.key?(:$key).as(:present))
+            @key = @table.where(config.key_column => :$row)
+              .select(::Sequel[config.value_column].hstore.key?(:$key).as(:present))
               .prepare(:first, statement_id(:hstore_key))
           end
         end
 
         def prepare_store
           @store = @table
-            .where(key_column => :$row)
-            .prepare(:update, statement_id(:hstore_store), value_column => ::Sequel[value_column].hstore.merge(:$pair))
+            .where(config.key_column => :$row)
+            .prepare(:update, statement_id(:hstore_store), config.value_column => ::Sequel[config.value_column].hstore.merge(:$pair))
         end
 
         def prepare_increment
           pair = ::Sequel[:hstore]
             .function(:$key, (
-              ::Sequel[:coalesce].function(::Sequel[value_column].hstore[:$key].cast(Integer), 0) +
+              ::Sequel[:coalesce].function(::Sequel[config.value_column].hstore[:$key].cast(Integer), 0) +
               :$amount
             ).cast(String))
 
           @increment = @table
-            .returning(::Sequel[value_column].hstore[:$key].as(:value))
-            .where(key_column => :$row)
-            .prepare(:update, statement_id(:hstore_increment), value_column => ::Sequel.join([value_column, pair]))
+            .returning(::Sequel[config.value_column].hstore[:$key].as(:value))
+            .where(config.key_column => :$row)
+            .prepare(:update, statement_id(:hstore_increment), config.value_column => ::Sequel.join([config.value_column, pair]))
         end
 
         def prepare_load
-          @load = @table.where(key_column => :$row)
-            .select(::Sequel[value_column].hstore[:$key].as(:value))
+          @load = @table.where(config.key_column => :$row)
+            .select(::Sequel[config.value_column].hstore[:$key].as(:value))
             .prepare(:first, statement_id(:hstore_load))
         end
 
         def prepare_delete
-          @delete = @table.where(key_column => :$row)
-            .prepare(:update, statement_id(:hstore_delete), value_column => ::Sequel[value_column].hstore.delete(:$key))
+          @delete = @table.where(config.key_column => :$row)
+            .prepare(:update, statement_id(:hstore_delete), config.value_column => ::Sequel[config.value_column].hstore.delete(:$key))
         end
 
         def prepare_create
@@ -207,30 +207,30 @@ module Moneta
           # https://stackoverflow.com/questions/11940401/escaping-hstore-contains-operators-in-a-jdbc-prepared-statement
           return if defined?(JRUBY_VERSION)
           @create = @table
-            .where(key_column => :$row)
-            .exclude(::Sequel[value_column].hstore.key?(:$key))
-            .prepare(:update, statement_id(:hstore_create), value_column => ::Sequel[value_column].hstore.merge(:$pair))
+            .where(config.key_column => :$row)
+            .exclude(::Sequel[config.value_column].hstore.key?(:$key))
+            .prepare(:update, statement_id(:hstore_create), config.value_column => ::Sequel[config.value_column].hstore.merge(:$pair))
         end
 
         def prepare_values_at
           @values_at = @table
-            .where(key_column => :$row)
-            .select(::Sequel[value_column].hstore[::Sequel.cast(:$keys, :"text[]")].as(:values))
+            .where(config.key_column => :$row)
+            .select(::Sequel[config.value_column].hstore[::Sequel.cast(:$keys, :"text[]")].as(:values))
             .prepare(:first, statement_id(:hstore_values_at))
         end
 
         def prepare_slice
           slice = @table
-            .where(key_column => :$row)
-            .select(::Sequel[value_column].hstore.slice(:$keys).as(:pairs))
+            .where(config.key_column => :$row)
+            .select(::Sequel[config.value_column].hstore.slice(:$keys).as(:pairs))
           @slice = slice.prepare(:first, statement_id(:hstore_slice))
           @slice_for_update = slice.for_update.prepare(:first, statement_id(:hstore_slice_for_update))
         end
 
         def prepare_size
           @size = @backend
-            .from(@table.where(key_column => :$row)
-                        .select(::Sequel[value_column].hstore.each))
+            .from(@table.where(config.key_column => :$row)
+            .select(::Sequel[config.value_column].hstore.each))
             .select { count.function.*.as(:size) }
             .prepare(:first, statement_id(:hstore_size))
         end

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

@@ -10,7 +10,7 @@ module Moneta
         end
 
         def store(key, value, options = {})
-          @table.insert_conflict(:replace).insert(key_column => key, value_column => blob(value))
+          @table.insert_conflict(:replace).insert(config.key_column => key, config.value_column => blob(value))
           value
         end
 
@@ -25,7 +25,7 @@ module Moneta
         def merge!(pairs, options = {}, &block)
           @backend.transaction do
             pairs = yield_merge_pairs(pairs, &block) if block_given?
-            @table.insert_conflict(:replace).import([key_column, value_column], blob_pairs(pairs).to_a)
+            @table.insert_conflict(:replace).import([config.key_column, config.value_column], blob_pairs(pairs).to_a)
           end
 
           self
@@ -36,20 +36,20 @@ module Moneta
         def prepare_store
           @store = @table
             .insert_conflict(:replace)
-            .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
           return super unless @can_upsert
-          update_expr = (::Sequel[value_column].cast(Integer) + :$amount).cast(:blob)
+          update_expr = (::Sequel[config.value_column].cast(Integer) + :$amount).cast(:blob)
           @increment = @table
             .insert_conflict(
-              target: key_column,
-              update: { value_column => update_expr },
-              update_where: ::Sequel.|({ value_column => blob("0") },
-                                       { ::Sequel.~(::Sequel[value_column].cast(Integer)) => 0 })
+              target: config.key_column,
+              update: { config.value_column => update_expr },
+              update_where: ::Sequel.|({ config.value_column => blob("0") },
+                                       { ::Sequel.~(::Sequel[config.value_column].cast(Integer)) => 0 })
             )
-            .prepare(:insert, statement_id(:increment), key_column => :$key, value_column => :$value)
+            .prepare(:insert, statement_id(:increment), config.key_column => :$key, config.value_column => :$value)
         end
       end
     end