moneta 1.4.2 → 1.5.0

data/lib/moneta/adapters/sequel.rb

@@ -4,16 +4,31 @@ module Moneta
   module Adapters
     # Sequel backend
     # @api public
-    class Sequel
-      include Defaults
-
+    class Sequel < Adapter
       autoload :MySQL, 'moneta/adapters/sequel/mysql'
       autoload :Postgres, 'moneta/adapters/sequel/postgres'
       autoload :PostgresHStore, 'moneta/adapters/sequel/postgres_hstore'
       autoload :SQLite, 'moneta/adapters/sequel/sqlite'
 
       supports :create, :increment, :each_key
-      attr_reader :backend, :key_column, :value_column
+
+      config :table, default: :moneta, coerce: :to_sym
+      config :optimize, default: true
+      config :create_table, default: true
+      config :key_column, default: :k
+      config :value_column, default: :v
+      config :hstore, coerce: :to_s
+      config :each_key_server
+
+      backend do |db:, extensions: [], connection_validation_timeout: nil, **options|
+        ::Sequel.connect(db, options).tap do |backend|
+          extensions.map(&:to_sym).each(&backend.method(:extension))
+
+          if connection_validation_timeout
+            backend.pool.connection_validation_timeout = connection_validation_timeout
+          end
+        end
+      end
 
       # @param [Hash] options
       # @option options [String] :db Sequel database
@@ -22,7 +37,7 @@ module Moneta
       # @option options [Integer] :connection_validation_timeout (nil) Sequel connection_validation_timeout
       # @option options [Sequel::Database] :backend Use existing backend instance
       # @option options [Boolean] :optimize (true) Set to false to prevent database-specific optimisations
-      # @option options [Proc, Boolean] :create_table Provide a Proc for creating the table, or
+      # @option options [Proc, Boolean] :create_table (true) Provide a Proc for creating the table, or
       #   set to false to disable table creation all together.  If a Proc is given, it will be
       #   called regardless of whether the table exists already.
       # @option options [Symbol] :key_column (:k) The name of the key column
@@ -37,32 +52,21 @@ module Moneta
       #   in conjunction with Sequel's `:servers` option
       # @option options All other options passed to `Sequel#connect`
       def initialize(options = {})
-        extensions = options.delete(:extensions)
-        connection_validation_timeout = options.delete(:connection_validation_timeout)
-        optimize = options.delete(:optimize)
-        @backend = options.delete(:backend) ||
-          connect(extensions: extensions, connection_validation_timeout: connection_validation_timeout, **options)
-
-        if hstore = options.delete(:hstore)
-          @row = hstore.to_s
+        super
+
+        if config.hstore
           extend Sequel::PostgresHStore
-        elsif optimize == nil || optimize
+        elsif config.optimize
           add_optimizations
         end
 
-        @table_name = (options.delete(:table) || :moneta).to_sym
-        @key_column = options.delete(:key_column) || :k
-        @value_column = options.delete(:value_column) || :v
-        @each_key_server = options.delete(:each_key_server)
-
-        create_proc = options.delete(:create_table)
-        if create_proc == nil
+        if config.create_table.respond_to?(:call)
+          config.create_table.call(backend)
+        elsif config.create_table
           create_table
-        elsif create_proc
-          create_proc.call(@backend)
         end
 
-        @table = @backend[@table_name]
+        @table = backend[config.table]
         prepare_statements
       end
 
@@ -74,7 +78,7 @@ module Moneta
       # (see Proxy#load)
       def load(key, options = {})
         if row = @load.call(key: key)
-          row[value_column]
+          row[config.value_column]
         end
       end
 
@@ -100,9 +104,9 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @backend.transaction do
+        backend.transaction do
           if existing = @load_for_update.call(key: key)
-            existing_value = existing[value_column]
+            existing_value = existing[config.value_column]
             amount += Integer(existing_value)
             raise IncrementError, "no update" unless @increment_update.call(
               key: key,
@@ -135,13 +139,13 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @backend.disconnect
+        backend.disconnect
         nil
       end
 
       # (see Proxy#slice)
       def slice(*keys, **options)
-        @slice.all(keys).map! { |row| [row[key_column], row[value_column]] }
+        @slice.all(keys).map! { |row| [row[config.key_column], row[config.value_column]] }
       end
 
       # (see Proxy#values_at)
@@ -165,10 +169,10 @@ module Moneta
 
       # (see Proxy#merge!)
       def merge!(pairs, options = {})
-        @backend.transaction do
+        backend.transaction do
           existing = Hash[slice_for_update(pairs)]
           update_pairs, insert_pairs = pairs.partition { |k, _| existing.key?(k) }
-          @table.import([key_column, value_column], blob_pairs(insert_pairs))
+          @table.import([config.key_column, config.value_column], blob_pairs(insert_pairs))
 
           if block_given?
             update_pairs.map! do |key, new_value|
@@ -187,8 +191,10 @@ module Moneta
       # (see Proxy#each_key)
       def each_key
         return enum_for(:each_key) { @table.count } unless block_given?
-        if @each_key_server
-          @table.server(@each_key_server).order(key_column).select(key_column).paged_each do |row|
+
+        key_column = config.key_column
+        if config.each_key_server
+          @table.server(config.each_key_server).order(key_column).select(key_column).paged_each do |row|
             yield row[key_column]
           end
         else
@@ -201,21 +207,6 @@ module Moneta
 
       protected
 
-      # @api private
-      def connect(db:, extensions: nil, connection_validation_timeout: nil, **options)
-        other_cols = [:table, :create_table, :key_column, :value_column, :hstore]
-        ::Sequel.connect(db, options.reject { |k,| other_cols.member?(k) }).tap do |backend|
-          if extensions
-            raise ArgumentError, 'Option :extensions must be an Array' unless extensions.is_a?(Array)
-            extensions.map(&:to_sym).each(&backend.method(:extension))
-          end
-
-          if connection_validation_timeout
-            backend.pool.connection_validation_timeout = connection_validation_timeout
-          end
-        end
-      end
-
       # @api private
       def add_optimizations
         case backend.database_type
@@ -243,9 +234,9 @@ module Moneta
       end
 
       def create_table
-        key_column = self.key_column
-        value_column = self.value_column
-        @backend.create_table?(@table_name) do
+        key_column = config.key_column
+        value_column = config.value_column
+        backend.create_table?(config.table) do
           String key_column, null: false, primary_key: true
           File value_column
         end
@@ -253,7 +244,7 @@ module Moneta
 
       def slice_for_update(pairs)
         @slice_for_update.all(pairs.map { |k, _| k }.to_a).map! do |row|
-          [row[key_column], row[value_column]]
+          [row[config.key_column], row[config.value_column]]
         end
       end
 
@@ -266,7 +257,7 @@ module Moneta
       end
 
       def statement_id(id)
-        "moneta_#{@table_name}_#{id}".to_sym
+        "moneta_#{config.table}_#{id}".to_sym
       end
 
       def prepare_statements
@@ -281,49 +272,49 @@ module Moneta
 
       def prepare_key
         @key = @table
-          .where(key_column => :$key).select(1)
+          .where(config.key_column => :$key).select(1)
           .prepare(:first, statement_id(:key))
       end
 
       def prepare_load
         @load = @table
-          .where(key_column => :$key).select(value_column)
+          .where(config.key_column => :$key).select(config.value_column)
           .prepare(:first, statement_id(:load))
       end
 
       def prepare_store
         @store_update = @table
-          .where(key_column => :$key)
-          .prepare(:update, statement_id(:store_update), value_column => :$value)
+          .where(config.key_column => :$key)
+          .prepare(:update, statement_id(:store_update), config.value_column => :$value)
       end
 
       def prepare_create
         @create = @table
-          .prepare(:insert, statement_id(:create), key_column => :$key, value_column => :$value)
+          .prepare(:insert, statement_id(:create), config.key_column => :$key, config.value_column => :$value)
       end
 
       def prepare_increment
         @load_for_update = @table
-          .where(key_column => :$key).for_update
-          .select(value_column)
+          .where(config.key_column => :$key).for_update
+          .select(config.value_column)
           .prepare(:first, statement_id(:load_for_update))
         @increment_update ||= @table
-          .where(key_column => :$key, value_column => :$value)
-          .prepare(:update, statement_id(:increment_update), value_column => :$new_value)
+          .where(config.key_column => :$key, config.value_column => :$value)
+          .prepare(:update, statement_id(:increment_update), config.value_column => :$new_value)
       end
 
       def prepare_delete
-        @delete = @table.where(key_column => :$key)
+        @delete = @table.where(config.key_column => :$key)
           .prepare(:delete, statement_id(:delete))
       end
 
       def prepare_slice
         @slice_for_update = ::Sequel::Dataset::PlaceholderLiteralizer.loader(@table) do |pl, ds|
-          ds.filter(key_column => pl.arg).select(key_column, value_column).for_update
+          ds.filter(config.key_column => pl.arg).select(config.key_column, config.value_column).for_update
         end
 
         @slice = ::Sequel::Dataset::PlaceholderLiteralizer.loader(@table) do |pl, ds|
-          ds.filter(key_column => pl.arg).select(key_column, value_column)
+          ds.filter(config.key_column => pl.arg).select(config.key_column, config.value_column)
         end
       end
 

data/lib/moneta/adapters/sqlite.rb

@@ -4,12 +4,16 @@ module Moneta
   module Adapters
     # Sqlite3 backend
     # @api public
-    class Sqlite
-      include Defaults
+    class Sqlite < Adapter
       include IncrementSupport
 
       supports :create, :each_key
-      attr_reader :backend
+
+      config :table, default: 'moneta'
+      config :busy_timeout, default: 1000
+      config :journal_mode
+
+      backend { |file:| ::SQLite3::Database.new(file) }
 
       # @param [Hash] options
       # @option options [String] :file Database file
@@ -18,31 +22,29 @@ module Moneta
       # @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'
-        @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)")
-        if journal_mode = options[:journal_mode]
-          @backend.journal_mode = journal_mode.to_s
+        super
+
+        backend.busy_timeout(config.busy_timeout)
+        backend.execute("create table if not exists #{config.table} (k blob not null primary key, v blob)")
+
+        if journal_mode = config.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 (?, ?)"),
-           @keys = @backend.prepare("select k from #{@table}"),
-           @count = @backend.prepare("select count(*) from #{@table}")]
-
-        version = @backend.execute("select sqlite_version()").first.first
+          [@exists = backend.prepare("select exists(select 1 from #{config.table} where k = ?)"),
+           @select = backend.prepare("select v from #{config.table} where k = ?"),
+           @replace = backend.prepare("replace into #{config.table} values (?, ?)"),
+           @delete = backend.prepare("delete from #{config.table} where k = ?"),
+           @clear = backend.prepare("delete from #{config.table}"),
+           @create = backend.prepare("insert into #{config.table} values (?, ?)"),
+           @keys = backend.prepare("select k from #{config.table}"),
+           @count = backend.prepare("select count(*) from #{config.table}")]
+
+        version = backend.execute("select sqlite_version()").first.first
         if @can_upsert = ::Gem::Version.new(version) >= ::Gem::Version.new('3.24.0')
-          @stmts << (@increment = @backend.prepare <<-SQL)
-            insert into #{@table} values (?, ?)
+          @stmts << (@increment = backend.prepare <<-SQL)
+            insert into #{config.table} values (?, ?)
             on conflict (k)
             do update set v = cast(cast(v as integer) + ? as blob)
             where v = '0' or v = X'30' or cast(v as integer) != 0
@@ -76,8 +78,8 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @backend.transaction(:exclusive) { return super } unless @can_upsert
-        @backend.transaction do
+        backend.transaction(:exclusive) { return super } unless @can_upsert
+        backend.transaction do
           @increment.execute!(key, amount.to_s, amount)
           return Integer(load(key))
         end
@@ -103,14 +105,14 @@ module Moneta
       # (see Proxy#close)
       def close
         @stmts.each { |s| s.close }
-        @backend.close
+        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)
+        query = "select k, v from #{config.table} where k in (#{(['?'] * keys.length).join(',')})"
+        backend.execute(query, keys)
       end
 
       # (see Proxy#values_at)
@@ -134,7 +136,7 @@ module Moneta
 
       # (see Proxy#merge!)
       def merge!(pairs, options = {})
-        transaction = @backend.transaction if block_given?
+        transaction = backend.transaction if block_given?
 
         if block_given?
           existing = Hash[slice(*pairs.map { |k, _| k }.to_a)]
@@ -146,13 +148,13 @@ module Moneta
           pairs = pairs.to_a
         end
 
-        query = "replace into #{@table} (k, v) values" + (['(?, ?)'] * pairs.length).join(',')
-        @backend.query(query, pairs.flatten).close
+        query = "replace into #{config.table} (k, v) values" + (['(?, ?)'] * pairs.length).join(',')
+        backend.query(query, pairs.flatten).close
       rescue
-        @backend.rollback if transaction
+        backend.rollback if transaction
         raise
       else
-        @backend.commit if transaction
+        backend.commit if transaction
         self
       end
 

data/lib/moneta/adapters/tdb.rb

@@ -4,34 +4,28 @@ module Moneta
   module Adapters
     # TDB backend
     # @api public
-    class TDB
-      include Defaults
+    class TDB < Adapter
       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
-      def initialize(options)
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless file = options.delete(:file)
-            ::TDB.new(file, options)
-          end
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::TDB] :backend Use existing backend instance
+      backend { |file:, **options| ::TDB.new(file, options) }
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
 
       # (see Proxy#create)
       def create(key, value, options = {})
-        @backend.insert!(key, value)
+        backend.insert!(key, value)
         true
       rescue ::TDB::ERR::EXISTS
         false

data/lib/moneta/adapters/tokyocabinet.rb

@@ -4,29 +4,31 @@ module Moneta
   module Adapters
     # TokyoCabinet backend
     # @api public
-    class TokyoCabinet
-      include Defaults
+    class TokyoCabinet < Adapter
       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)
-      # @option options [::TokyoCabinet::*DB] :backend Use existing backend instance
-      def initialize(options = {})
-        if options[:backend]
-          @backend = options[:backend]
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [Symbol] :type (:hdb) Database type (:bdb and :hdb possible)
+      #   @option options [::TokyoCabinet::*DB] :backend Use existing backend instance
+      backend do |file:, type: :hdb|
+        case type
+        when :bdb
+          ::TokyoCabinet::BDB.new.tap do |backend|
+            backend.open(file, ::TokyoCabinet::BDB::OWRITER | ::TokyoCabinet::BDB::OCREAT) or
+              raise backend.errmsg(backend.ecode)
+          end
+        when :hdb
+          ::TokyoCabinet::HDB.new.tap do |backend|
+            backend.open(file, ::TokyoCabinet::HDB::OWRITER | ::TokyoCabinet::HDB::OCREAT) or
+              raise backend.errmsg(backend.ecode)
+          end
         else
-          raise ArgumentError, 'Option :file is required' unless options[:file]
-          if options[:type] == :bdb
-            @backend = ::TokyoCabinet::BDB.new
-            @backend.open(options[:file], ::TokyoCabinet::BDB::OWRITER | ::TokyoCabinet::BDB::OCREAT)
-          else
-            @backend = ::TokyoCabinet::HDB.new
-            @backend.open(options[:file], ::TokyoCabinet::HDB::OWRITER | ::TokyoCabinet::HDB::OCREAT)
-          end or raise @backend.errmsg(@backend.ecode)
+          raise ArgumentError, ":type must be :bdb or :hdb"
         end
       end
 

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,18 +76,18 @@ 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
 
@@ -96,10 +95,10 @@ module Moneta
       def slice(*keys, **options)
         hash =
           if @native
-            @backend.mget(*keys)
+            backend.mget(*keys)
           else
             hash = Hash[keys.map { |key| [key] }]
-            raise unless @backend.mget(hash) >= 0
+            raise unless backend.mget(hash) >= 0
             hash
           end
 
@@ -142,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