moneta 1.1.1 → 1.4.1

data/lib/moneta/adapters/null.rb

@@ -6,8 +6,7 @@ module Moneta
       include Defaults
 
       # @param [Hash] options Options hash
-      def initialize(options = {})
-      end
+      def initialize(options = {}); end
 
       # (see Proxy#key?)
       def key?(key, options = {})

data/lib/moneta/adapters/pstore.rb

@@ -48,7 +48,7 @@ module Moneta
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        transaction {@backend[key] = value }
+        transaction { @backend[key] = value }
       end
 
       # (see Proxy#delete)
@@ -59,7 +59,8 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         transaction do
-          value = Utils.to_int(@backend[key]) + amount
+          existing = @backend[key]
+          value = (existing == nil ? 0 : Integer(existing)) + amount
           @backend[key] = value.to_s
           value
         end

data/lib/moneta/adapters/redis.rb

@@ -26,7 +26,11 @@ module Moneta
       # number as a time to live in seconds.
       def key?(key, options = {})
         with_expiry_update(key, default: nil, **options) do
-          @backend.exists(key)
+          if @backend.respond_to?(:exists?)
+            @backend.exists?(key)
+          else
+            @backend.exists(key)
+          end
         end
       end
 
@@ -100,7 +104,7 @@ module Moneta
       # (see Defaults#values_at)
       def values_at(*keys, **options)
         with_expiry_update(*keys, default: nil, **options) do
-          @backend.mget *keys
+          @backend.mget(*keys)
         end
       end
 
@@ -112,7 +116,7 @@ module Moneta
           old_values = @backend.mget(*keys)
           updates = pairs.each_with_index.with_object({}) do |(pair, i), updates|
             old_value = old_values[i]
-            if !old_value.nil?
+            if old_value != nil
               key, new_value = pair
               updates[key] = yield(key, old_value, new_value)
             end
@@ -146,7 +150,7 @@ module Moneta
 
       def with_expiry_update(*keys, default: @default_expires, **options)
         expires = expires_value(options, default)
-        if expires.nil?
+        if expires == nil
           yield
         else
           future = nil

data/lib/moneta/adapters/restclient.rb

@@ -11,10 +11,19 @@ module Moneta
 
       # @param [Hash] options
       # @option options [String] :url URL
-      # @option options [Faraday connection] :backend Use existing backend instance
+      # @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 = {})
-        raise ArgumentError, 'Option :url is required' unless url = options[:url]
-        @backend = options[:backend] || ::Faraday.new(url: url)
+        @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
       end
 
       # (see Proxy#key?)

data/lib/moneta/adapters/riak.rb

@@ -30,7 +30,7 @@ module Moneta
       # (see Proxy#load)
       def load(key, options = {})
         @bucket.get(key, options.dup).raw_data
-      rescue ::Riak::FailedRequest => ex
+      rescue ::Riak::FailedRequest
         nil
       end
 
@@ -53,7 +53,7 @@ module Moneta
       # (see Proxy#clear)
       def clear(options = {})
         @bucket.keys do |keys|
-          keys.each{ |key| @bucket.delete(key) }
+          keys.each { |key| @bucket.delete(key) }
         end
         self
       end

data/lib/moneta/adapters/sequel.rb

@@ -7,9 +7,10 @@ module Moneta
     class Sequel
       include Defaults
 
-      # Sequel::UniqueConstraintViolation is defined since sequel 3.44.0
-      # older versions raise a Sequel::DatabaseError.
-      UniqueConstraintViolation = defined?(::Sequel::UniqueConstraintViolation) ? ::Sequel::UniqueConstraintViolation : ::Sequel::DatabaseError
+      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
@@ -35,58 +36,27 @@ module Moneta
       #   possible to specify a separate connection to use for `#each_key`.  Use
       #   in conjunction with Sequel's `:servers` option
       # @option options All other options passed to `Sequel#connect`
-      def self.new(options = {})
+      def initialize(options = {})
         extensions = options.delete(:extensions)
         connection_validation_timeout = options.delete(:connection_validation_timeout)
         optimize = options.delete(:optimize)
-        backend = options.delete(:backend) ||
-          begin
-            raise ArgumentError, 'Option :db is required' unless db = options.delete(:db)
-            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
-
-        instance =
-          if optimize.nil? || optimize
-            case backend.database_type
-            when :mysql
-              MySQL.allocate
-            when :postgres
-              if options[:hstore]
-                PostgresHStore.allocate
-              elsif matches = backend.get(::Sequel[:version].function).match(/PostgreSQL (\d+)\.(\d+)/)
-                # Our optimisations only work on Postgres 9.5+
-                major, minor = matches[1..2].map(&:to_i)
-                Postgres.allocate if major > 9 || (major == 9 && minor >= 5)
-              end
-            when :sqlite
-              SQLite.allocate
-            end
-          end || allocate
+        @backend = options.delete(:backend) ||
+          connect(extensions: extensions, connection_validation_timeout: connection_validation_timeout, **options)
 
-        instance.instance_variable_set(:@backend, backend)
-        instance.send(:initialize, options)
-        instance
-      end
+        if hstore = options.delete(:hstore)
+          @row = hstore.to_s
+          extend Sequel::PostgresHStore
+        elsif optimize == nil || optimize
+          add_optimizations
+        end
 
-      # @api private
-      def initialize(options)
         @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 create_proc == nil
           create_table
         elsif create_proc
           create_proc.call(@backend)
@@ -124,7 +94,7 @@ module Moneta
       def create(key, value, options = {})
         @create.call(key: key, value: blob(value))
         true
-      rescue UniqueConstraintViolation
+      rescue ::Sequel::ConstraintViolation
         false
       end
 
@@ -231,8 +201,39 @@ module Moneta
 
       protected
 
-      def blob(s)
-        ::Sequel.blob(s) unless s == nil
+      # @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
+        when :mysql
+          extend Sequel::MySQL
+        when :postgres
+          if matches = backend.get(::Sequel[:version].function).match(/PostgreSQL (\d+)\.(\d+)/)
+            # Our optimisations only work on Postgres 9.5+
+            major, minor = matches[1..2].map(&:to_i)
+            extend Sequel::Postgres if major > 9 || (major == 9 && minor >= 5)
+          end
+        when :sqlite
+          extend Sequel::SQLite
+        end
+      end
+
+      def blob(str)
+        ::Sequel.blob(str) unless str == nil
       end
 
       def blob_pairs(pairs)
@@ -279,41 +280,41 @@ module Moneta
       end
 
       def prepare_key
-        @key = @table.
-          where(key_column => :$key).select(1).
-          prepare(:first, statement_id(:key))
+        @key = @table
+          .where(key_column => :$key).select(1)
+          .prepare(:first, statement_id(:key))
       end
 
       def prepare_load
-        @load = @table.
-          where(key_column => :$key).select(value_column).
-          prepare(:first, statement_id(:load))
+        @load = @table
+          .where(key_column => :$key).select(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)
+        @store_update = @table
+          .where(key_column => :$key)
+          .prepare(:update, statement_id(:store_update), value_column => :$value)
       end
 
       def prepare_create
-        @create = @table.
-          prepare(:insert, statement_id(:create), key_column => :$key, value_column => :$value)
+        @create = @table
+          .prepare(:insert, statement_id(:create), key_column => :$key, value_column => :$value)
       end
 
       def prepare_increment
-        @load_for_update = @table.
-          where(key_column => :$key).for_update.
-          select(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)
+        @load_for_update = @table
+          .where(key_column => :$key).for_update
+          .select(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)
       end
 
       def prepare_delete
-        @delete = @table.where(key_column => :$key).
-          prepare(:delete, statement_id(:delete))
+        @delete = @table.where(key_column => :$key)
+          .prepare(:delete, statement_id(:delete))
       end
 
       def prepare_slice
@@ -328,433 +329,6 @@ module Moneta
 
       # @api private
       class IncrementError < ::Sequel::DatabaseError; end
-
-      # @api private
-      class MySQL < Sequel
-        def store(key, value, options = {})
-          @store.call(key: key, value: blob(value))
-          value
-        end
-
-        def increment(key, amount = 1, options = {})
-          @backend.transaction do
-            # this creates a row-level lock even if there is no existing row (a
-            # "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])
-              @increment_update.call(key: key, value: amount)
-            else
-              @create.call(key: key, value: amount)
-            end
-            amount
-          end
-        rescue ::Sequel::SerializationFailure # Thrown on deadlock
-          tries ||= 0
-          (tries += 1) <= 3 ? retry : raise
-        end
-
-        def merge!(pairs, options = {}, &block)
-          @backend.transaction do
-            pairs = yield_merge_pairs(pairs, &block) if block_given?
-            @table.
-              on_duplicate_key_update.
-              import([key_column, 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)
-          # Order is not required when streaming
-          @table.server(@each_key_server).select(key_column).paged_each do |row|
-            yield row[key_column]
-          end
-          self
-        end
-
-        protected
-
-        def prepare_store
-          @store = @table.
-            on_duplicate_key_update.
-            prepare(:insert, statement_id(:store), key_column => :$key, value_column => :$value)
-        end
-
-        def prepare_increment
-          @increment_update = @table.
-            where(key_column => :$key).
-            prepare(:update, statement_id(:increment_update), value_column => :$value)
-          super
-        end
-      end
-
-      # @api private
-      class Postgres < Sequel
-        def store(key, value, options = {})
-          @store.call(key: key, value: blob(value))
-          value
-        end
-
-        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
-          end
-        end
-
-        def delete(key, options = {})
-          result = @delete.call(key: key)
-          if row = result.first
-            row[value_column]
-          end
-        end
-
-        def merge!(pairs, options = {}, &block)
-          @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)
-          end
-
-          self
-        end
-
-        def each_key
-          return super unless block_given? && !@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]
-          end
-          self
-        end
-
-        protected
-
-        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)
-        end
-
-        def prepare_increment
-          update_expr = ::Sequel[:convert_to].function(
-            (::Sequel[:convert_from].function(
-              ::Sequel[@table_name][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)
-        end
-
-        def prepare_delete
-          @delete = @table.
-            returning(value_column).
-            where(key_column => :$key).
-            prepare(:delete, statement_id(:delete))
-        end
-      end
-
-      # @api private
-      class PostgresHStore < Sequel
-        def initialize(options)
-          @row = options.delete(:hstore).to_s
-          @backend.extension :pg_hstore
-          ::Sequel.extension :pg_hstore_ops
-          @backend.extension :pg_array
-          super
-        end
-
-        def key?(key, options = {})
-          if @key
-            row = @key.call(row: @row, key: key) || false
-            row && row[:present]
-          else
-            @key_pl.get(key)
-          end
-        end
-
-        def store(key, value, options = {})
-          @backend.transaction do
-            create_row
-            @store.call(row: @row, pair: ::Sequel.hstore(key => value))
-          end
-          value
-        end
-
-        def load(key, options = {})
-          if row = @load.call(row: @row, key: key)
-            row[:value]
-          end
-        end
-
-        def delete(key, options = {})
-          @backend.transaction do
-            value = load(key, options)
-            @delete.call(row: @row, key: key)
-            value
-          end
-        end
-
-        def increment(key, amount = 1, options = {})
-          @backend.transaction do
-            create_row
-            if row = @increment.call(row: @row, key: key, amount: amount).first
-              row[:value].to_i
-            end
-          end
-        end
-
-        def create(key, value, options = {})
-          @backend.transaction do
-            create_row
-            1 ==
-              if @create
-                @create.call(row: @row, 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))
-              end
-          end
-        end
-
-        def clear(options = {})
-          @clear.call(row: @row)
-          self
-        end
-
-        def values_at(*keys, **options)
-          if row = @values_at.call(row: @row, keys: ::Sequel.pg_array(keys))
-            row[:values].to_a
-          else
-            []
-          end
-        end
-
-        def slice(*keys, **options)
-          if row = @slice.call(row: @row, keys: ::Sequel.pg_array(keys))
-            row[:pairs].to_h
-          else
-            []
-          end
-        end
-
-        def merge!(pairs, options = {}, &block)
-          @backend.transaction do
-            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))
-          end
-
-          self
-        end
-
-        def each_key
-          return enum_for(:each_key) { @size.call(row: @row)[:size] } unless block_given?
-
-          ds =
-            if @each_key_server
-              @table.server(@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).
-            paged_each do |row|
-              yield row[:skeys]
-            end
-          self
-        end
-
-        protected
-
-        def create_row
-          @create_row.call(row: @row)
-        end
-
-        def create_table
-          key_column = self.key_column
-          value_column = self.value_column
-
-          @backend.create_table?(@table_name) do
-            column key_column, String, null: false, primary_key: true
-            column value_column, :hstore
-            index value_column, type: :gin
-          end
-        end
-
-        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))
-            row[:pairs].to_h
-          else
-            {}
-          end
-        end
-
-        def prepare_statements
-          super
-          prepare_create_row
-          prepare_clear
-          prepare_values_at
-          prepare_size
-        end
-
-        def prepare_create_row
-          @create_row = @table.
-            insert_ignore.
-            prepare(:insert, statement_id(:hstore_create_row), key_column => :$row, value_column => '')
-        end
-
-        def prepare_clear
-          @clear = @table.where(key_column => :$row).prepare(:update, statement_id(:hstore_clear), 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))
-            end
-          else
-            @key = @table.where(key_column => :$row).
-              select(::Sequel[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))
-        end
-
-        def prepare_increment
-          pair = ::Sequel[:hstore].function(
-            :$key,
-            (::Sequel[:coalesce].function(
-              ::Sequel[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]))
-        end
-
-        def prepare_load
-          @load = @table.where(key_column => :$row).
-            select(::Sequel[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))
-        end
-
-        def prepare_create
-          # Under JRuby we can't use a prepared statement for queries involving
-          # the hstore `?` (key?) operator.  See
-          # 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))
-        end
-
-        def prepare_values_at
-          @values_at = @table.
-            where(key_column => :$row).
-            select(::Sequel[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))
-          @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)).
-            select { count.function.*.as(:size) }.
-            prepare(:first, statement_id(:hstore_size))
-        end
-      end
-
-      # @api private
-      class SQLite < Sequel
-        def initialize(options)
-          @version = backend.get(::Sequel[:sqlite_version].function)
-          # See https://sqlite.org/lang_UPSERT.html
-          @can_upsert = ::Gem::Version.new(@version) >= ::Gem::Version.new('3.24.0')
-          super
-        end
-
-        def store(key, value, options = {})
-          @table.insert_conflict(:replace).insert(key_column => key, value_column => blob(value))
-          value
-        end
-
-        def increment(key, amount = 1, options = {})
-          return super unless @can_upsert
-          @backend.transaction do
-            @increment.call(key: key, value: amount.to_s, amount: amount)
-            Integer(load(key))
-          end
-        end
-
-        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)
-          end
-
-          self
-        end
-
-        protected
-
-        def prepare_store
-          @store = @table.
-            insert_conflict(:replace).
-            prepare(:insert, statement_id(:store), key_column => :$key, value_column => :$value)
-        end
-
-        def prepare_increment
-          return super unless @can_upsert
-          update_expr = (::Sequel[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)).
-            prepare(:insert, statement_id(:increment), key_column => :$key, value_column => :$value)
-        end
-      end
     end
   end
 end