moneta 1.5.2 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61d01584fc8497503e70aa6cb4fcea5ead6a05b9f4f1c2c9db138cd0470f948f
-  data.tar.gz: b7e2822f9aac62ab718964f4f8a3b4bf7a4473aa6ab9291b0df28882a3de2bca
+  metadata.gz: 4b7e4bbe0345dcfa33a7217af5a4bbcef559b3d9cb0d8a53301a7c9ff30a7118
+  data.tar.gz: 7d3fe5f86885f39a418e8647f15243cb3728fad2daf12fd841b237c23d796fd4
 SHA512:
-  metadata.gz: fd8eb44d64eb8b62529497770bbea915fdd6880e907d697de82156aa1c9ca2f7bb58b7bb68157eefab138a8bc9aab8debf4186d4a8828bb664385c59027cd2a3
-  data.tar.gz: 1d97a4b4de9f0242fa260e1b197d35333a527019c43b01fab3a913c3f833a5963b47776ac78c3b9da7be70a117eaafcbb09e81108b233135ea6a018280f1b3a3
+  metadata.gz: 667443d645a8b75775bc43633e58eab9434e5c291043e2f4165a971391c67f5fdd5dffdda76f76924de56b28d2bd1f14c25eef0d16c032859aa91e67a22d123c
+  data.tar.gz: cf76836caa72d5fa5a2179b8937e06a24571f42eb7e26ba6ad4b606fbd70305817dbf6d33ae75a181d91e4f76b267db15b7fbb26e4471d148826a00ab8f9f6b6

data/CHANGES

@@ -1,3 +1,15 @@
+1.6.0
+
+* Adapters - Support for Rails 6.1 and above (Adapters::ActiveRecord,
+             Adapters::ActiveSupportCache, ActiveSupportCache::MonetaStore)
+* Adapters::YAML - add `theadsafe` option
+* Adapters::Sequel - fix deadlock issue with #increment on MySQL in newer
+                     Sequel versions (#244)
+* Adapters::Sequel - fix issue with Postgres HStore on newer Postgres (#243)
+* Adapters - fixed an issue many adapters had where #merge! errored if passed
+             an empty hash (#246)
+* Support changes - Drop support for 2.3 and 2.4, add support for 3.x
+
 1.5.2
 
 * Proxy - handle returning config when the adapter does not use config

data/CONTRIBUTORS

@@ -22,6 +22,7 @@ Jay Mitchell <jaybmitchell@gmail.com>
 Jeremy Voorhis <jvoorhis@gmail.com>
 Jon Crosby <jon@joncrosby.me>
 Jonathan Gnagy <jonathan.l.gnagy@sherwin.com>
+Jérôme Charaoui <jerome@riseup.net>
 lakshan <lakshan@web2media.net>
 Mal McKay <mal.mckay@gmail.com>
 Marek Skrobacki <skrobul@skrobul.com>

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 - 2019 Daniel Mendler, Yehuda Katz, Alastair Pharo
+Copyright (c) 2009 - 2023 Daniel Mendler, Yehuda Katz, Alastair Pharo
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/active_support/cache/moneta_store.rb

@@ -101,37 +101,38 @@ module ActiveSupport
         end
       end
 
-      def read_entry(key, options)
+      def read_entry(key, **options)
         make_entry(@store.load(key, moneta_options(options, false)))
       end
 
-      def write_entry(key, entry, options)
+      def write_entry(key, entry, **options)
         value = options[:raw] ? entry.value.to_s : entry
         @store.store(key, value, moneta_options(options))
         true
       end
 
-      def delete_entry(key, options)
+      def delete_entry(key, **options)
         @store.delete(key, moneta_options(options))
         true
       end
 
-      def read_multi_entries(names, options)
+      def read_multi_entries(names, **options)
         keys = names.map { |name| normalize_key(name, options) }
         entries = @store
           .values_at(*keys, **moneta_options(options, false))
           .map(&method(:make_entry))
 
+        delete_options = moneta_options(options)
         names.zip(keys, entries).map do |name, key, entry|
           next if entry == nil
-          delete_entry(key, options) if entry.expired?
+          @store.delete(key, delete_options) if entry.expired?
           next if entry.expired? || entry.mismatched?(normalize_version(name, options))
 
           [name, entry.value]
         end.compact.to_h
       end
 
-      def write_multi_entries(hash, options)
+      def write_multi_entries(hash, **options)
         pairs = if options[:raw]
                   hash.transform_values { |entry| entry.value.to_s }
                 else
@@ -142,6 +143,31 @@ module ActiveSupport
         hash
       end
 
+      # Before Rails 6.1, the `*_entry` methods didn't use keyword args
+      module Rails5Support
+        def read_entry(key, options)
+          super(key, **options)
+        end
+
+        def write_entry(key, entry, options)
+          super(key, entry, **options)
+        end
+
+        def delete_entry(key, options)
+          super(key, **options)
+        end
+
+        def read_multi_entries(names, options)
+          super(names, **options)
+        end
+
+        def write_multi_entries(hash, options)
+          super(hash, **options)
+        end
+      end
+
+      prepend Rails5Support if ActiveSupport.version < ::Gem::Version.new('6.1.0')
+
       private
 
       def moneta_options(options, include_expires = true)

data/lib/moneta/adapters/activerecord/backend.rb

@@ -0,0 +1,50 @@
+require 'uri'
+
+module Moneta
+  module Adapters
+    class ActiveRecord
+      # @api private
+      class Backend
+        @connection_lock = ::Mutex.new
+
+        class << self
+          attr_reader :connection_lock
+        end
+
+        attr_reader :table_name
+        delegate :connection_handler, to: ::ActiveRecord::Base
+
+        def initialize(table:, connection: nil, **options)
+          @table_name = table
+          @connection = connection
+          if connection
+            @owner_name =
+              case connection
+              when Symbol, String
+                connection.to_s
+              when Hash
+                hash = connection.reject { |key| [:username, 'username', :password, 'password'].member?(key) }
+                'moneta?' + URI.encode_www_form(hash.to_a.sort)
+              when nil
+                nil
+              else
+                raise "Unexpected connection: #{connection}"
+              end
+          end
+        end
+
+        def connection_pool
+          if @connection
+            connection_handler.retrieve_connection_pool(@owner_name) ||
+              self.class.connection_lock.synchronize do
+                connection_handler.retrieve_connection_pool(@owner_name) ||
+                  connection_handler.establish_connection(@connection, owner_name: @owner_name)
+              end
+          else
+            ::ActiveRecord::Base.connection_pool
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/activerecord/v5_backend.rb

@@ -0,0 +1,80 @@
+require 'uri'
+
+module Moneta
+  module Adapters
+    class ActiveRecord
+      # @api private
+      class V5Backend
+        @connection_lock = ::Mutex.new
+
+        class << self
+          attr_reader :connection_lock
+          delegate :configurations, :configurations=, :connection_handler, to: ::ActiveRecord::Base
+
+          def retrieve_connection_pool(spec_name)
+            connection_handler.retrieve_connection_pool(spec_name.to_s)
+          end
+
+          def establish_connection(spec_name)
+            connection_lock.synchronize do
+              if connection_pool = retrieve_connection_pool(spec_name)
+                connection_pool
+              else
+                connection_handler.establish_connection(spec_name.to_sym)
+              end
+            end
+          end
+
+          def retrieve_or_establish_connection_pool(spec_name)
+            retrieve_connection_pool(spec_name) || establish_connection(spec_name)
+          end
+        end
+
+        attr_reader :table_name
+
+        def initialize(table:, connection: nil, **options)
+          @table_name = table
+          @spec =
+            case connection
+            when Symbol
+              connection
+            when Hash, String
+              # Normalize the connection specification to a hash
+              resolver = ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new \
+                'dummy' => connection
+
+              # Turn the config into a standardised hash, sans a couple of bits
+              hash = resolver.resolve(:dummy)
+              hash.delete('name')
+              hash.delete(:username) # For security
+              hash.delete(:password) # For security
+              # Make a name unique to this config
+              name = 'moneta?' + URI.encode_www_form(hash.to_a.sort)
+              # Add into configurations unless its already there (initially done without locking for
+              # speed)
+              unless self.class.configurations.key? name
+                self.class.connection_lock.synchronize do
+                  self.class.configurations[name] = connection \
+                    unless self.class.configurations.key? name
+                end
+              end
+
+              name.to_sym
+            when nil
+              nil
+            else
+              raise "Unexpected connection: #{connection}"
+            end
+        end
+
+        def connection_pool
+          if @spec
+            self.class.retrieve_or_establish_connection_pool(@spec)
+          else
+            ::ActiveRecord::Base.connection_pool
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/activerecord.rb

@@ -1,59 +1,49 @@
 require 'active_record'
-require 'uri'
 
 module Moneta
   module Adapters
     # ActiveRecord as key/value stores
     # @api public
     class ActiveRecord < Adapter
-      supports :create, :increment, :each_key
+      autoload :V5Backend, 'moneta/adapters/activerecord/v5_backend'
+      autoload :Backend, 'moneta/adapters/activerecord/backend'
 
-      attr_reader :table
-      delegate :with_connection, to: :connection_pool
+      @table_create_lock = ::Mutex.new
 
-      @connection_lock = ::Mutex.new
       class << self
-        attr_reader :connection_lock
-        delegate :configurations, :configurations=, :connection_handler, to: ::ActiveRecord::Base
-
-        def retrieve_connection_pool(spec_name)
-          connection_handler.retrieve_connection_pool(spec_name.to_s)
-        end
+        attr_reader :table_create_lock
+      end
 
-        def establish_connection(spec_name)
-          connection_lock.synchronize do
-            if connection_pool = retrieve_connection_pool(spec_name)
-              connection_pool
-            else
-              connection_handler.establish_connection(spec_name.to_sym)
-            end
-          end
-        end
+      supports :create, :increment, :each_key
 
-        def retrieve_or_establish_connection_pool(spec_name)
-          retrieve_connection_pool(spec_name) || establish_connection(spec_name)
-        end
-      end
+      attr_reader :table
+      delegate :connection_pool, to: :@backend
+      delegate :with_connection, to: :connection_pool
 
       config :key_column, default: :k
       config :value_column, default: :v
 
-      backend required: false do |table: :moneta, connection: nil, create_table: nil|
-        @spec = spec_for_connection(connection)
-
+      backend do |table: :moneta, create_table: true, **options|
         # Ensure the table name is a symbol.
         table_name = table.to_sym
 
-        if create_table == nil
-          default_create_table(table_name)
-        elsif create_table
-          with_connection(&create_table)
-        end
+        backend =
+          if ::ActiveRecord.version < ::Gem::Version.new('6.0.0')
+            ::Moneta::Adapters::ActiveRecord::V5Backend.new(table: table_name, **options)
+          else
+            ::Moneta::Adapters::ActiveRecord::Backend.new(table: table_name, **options)
+          end
 
-        @table = ::Arel::Table.new(table_name)
+        case create_table
+        when Proc
+          backend.connection_pool.with_connection(&create_table)
+        when true
+          backend.connection_pool.with_connection do |conn|
+            default_create_table(conn, table_name)
+          end
+        end
 
-        # backend is only used if there's an existing ActiveRecord model
-        nil
+        backend
       end
 
       # @param [Hash] options
@@ -67,12 +57,7 @@ module Moneta
       # @option options [Symbol]               :value_column (:v) The name of the column to use for values
       def initialize(options = {})
         super
-
-        # If a :backend was provided, use it to set the spec and table
-        if backend
-          @spec = backend.connection_pool.spec
-          @table = ::Arel::Table.new(backend.table_name)
-        end
+        @table = ::Arel::Table.new(backend.table_name)
       end
 
       # (see Proxy#key?)
@@ -127,19 +112,17 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         with_connection do |conn|
-          begin
-            conn_ins(conn, key, amount.to_s)
-            amount
-          rescue ::ActiveRecord::RecordNotUnique
-            conn.transaction do
-              sel = arel_sel_key(key).project(table[config.value_column]).lock
-              value = decode(conn, conn.select_value(sel))
-              value = (value ? Integer(value) : 0) + amount
-              # Re-raise if the upate affects no rows (i.e. row deleted after attempted insert,
-              # before select for update)
-              raise unless conn_upd(conn, key, value.to_s) == 1
-              value
-            end
+          conn_ins(conn, key, amount.to_s)
+          amount
+        rescue ::ActiveRecord::RecordNotUnique
+          conn.transaction do
+            sel = arel_sel_key(key).project(table[config.value_column]).lock
+            value = decode(conn, conn.select_value(sel))
+            value = (value ? Integer(value) : 0) + amount
+            # Re-raise if the upate affects no rows (i.e. row deleted after attempted insert,
+            # before select for update)
+            raise unless conn_upd(conn, key, value.to_s) == 1
+            value
           end
         end
       rescue ::ActiveRecord::RecordNotUnique, ::ActiveRecord::Deadlocked
@@ -170,7 +153,7 @@ module Moneta
       # (see Proxy#close)
       def close
         @table = nil
-        @spec = nil
+        @connection_pool = nil
       end
 
       # (see Proxy#slice)
@@ -248,16 +231,13 @@ module Moneta
 
       private
 
-      def connection_pool
-        self.class.retrieve_or_establish_connection_pool(@spec)
-      end
-
-      def default_create_table(table_name)
-        with_connection do |conn|
+      def default_create_table(conn, table_name)
+        # From 6.1, we can use the `if_not_exists?` check
+        if ::ActiveRecord.version < ::Gem::Version.new('6.1.0')
           return if conn.table_exists?(table_name)
 
           # Prevent multiple connections from attempting to create the table simultaneously.
-          self.class.connection_lock.synchronize do
+          self.class.table_create_lock.synchronize do
             conn.create_table(table_name, id: false) do |t|
               # Do not use binary key (Issue #17)
               t.string config.key_column, null: false
@@ -265,6 +245,13 @@ module Moneta
             end
             conn.add_index(table_name, config.key_column, unique: true)
           end
+        else
+          conn.create_table(table_name, id: false, if_not_exists: true) do |t|
+            # Do not use binary key (Issue #17)
+            t.string config.key_column, null: false
+            t.binary config.value_column
+          end
+          conn.add_index(table_name, config.key_column, unique: true, if_not_exists: true)
         end
       end
 
@@ -305,7 +292,7 @@ module Moneta
           conn.escape_bytea(value)
         elsif defined?(::ActiveRecord::ConnectionAdapters::SQLite3Adapter) &&
             conn.is_a?(::ActiveRecord::ConnectionAdapters::SQLite3Adapter)
-          Arel::Nodes::SqlLiteral.new("X'#{value.unpack('H*').first}'")
+          Arel::Nodes::SqlLiteral.new("X'#{value.unpack1('H*')}'")
         else
           value
         end
@@ -323,38 +310,6 @@ module Moneta
           value
         end
       end
-
-      # Feed the connection info into ActiveRecord and get back a name to use
-      # for getting the connection pool
-      def spec_for_connection(connection)
-        case connection
-        when Symbol
-          connection
-        when Hash, String
-          # Normalize the connection specification to a hash
-          resolver = ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new \
-            'dummy' => connection
-
-          # Turn the config into a standardised hash, sans a couple of bits
-          hash = resolver.resolve(:dummy)
-          hash.delete('name')
-          hash.delete(:password) # For security
-          # Make a name unique to this config
-          name = 'moneta?' + URI.encode_www_form(hash.to_a.sort)
-          # Add into configurations unless its already there (initially done without locking for
-          # speed)
-          unless self.class.configurations.key? name
-            self.class.connection_lock.synchronize do
-              self.class.configurations[name] = connection \
-                unless self.class.configurations.key? name
-            end
-          end
-
-          name.to_sym
-        else
-          ::ActiveRecord::Base.connection_pool.spec.name.to_s
-        end
-      end
     end
   end
 end

data/lib/moneta/adapters/activesupportcache.rb

@@ -15,20 +15,29 @@ module Moneta
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        backend.exist?(key).tap do |exists|
-          if exists && (expires = expires_value(options, nil)) != nil
-            value = backend.read(key, options)
-            backend.write(key, value, options.merge(expires_in: expires ? expires.seconds : nil))
+        exists =
+          begin
+            backend_exist?(key)
+          rescue ArgumentError, TypeError
+            # these errors happen when certain adapters try to deserialize
+            # values, which means there's something present
+            true
           end
+
+        if exists && (expires = expires_value(options, nil)) != nil
+          value = backend_read(key, **options)
+          backend_write(key, value, expires_in: expires ? expires.seconds : nil, **options)
         end
+
+        exists
       end
 
       # (see Proxy#load)
       def load(key, options = {})
         expires = expires_value(options, nil)
-        value = backend.read(key, options)
+        value = backend_read(key, **options)
         if value and expires != nil
-          backend.write(key, value, options.merge(expires_in: expires ? expires.seconds : nil))
+          backend_write(key, value, expires_in: expires ? expires.seconds : nil, **options)
         end
         value
       end
@@ -36,7 +45,7 @@ module Moneta
       # (see Proxy#store)
       def store(key, value, options = {})
         expires = expires_value(options)
-        backend.write(key, value, options.merge(expires_in: expires ? expires.seconds : nil))
+        backend_write(key, value, expires_in: expires ? expires.seconds : nil, **options)
         value
       end
 
@@ -44,11 +53,11 @@ module Moneta
       def increment(key, amount = 1, options = {})
         expires = expires_value(options)
         options.delete(:raw)
-        existing = Integer(backend.fetch(key, options.merge(raw: true)) { 0 })
+        existing = Integer(backend_fetch(key, raw: true, **options) { 0 })
         if amount > 0
-          backend.increment(key, amount, options.merge(expires_in: expires ? expires.seconds : nil))
+          backend_increment(key, amount, expires_in: expires ? expires.seconds : nil, **options)
         elsif amount < 0
-          backend.decrement(key, -amount, options.merge(expires_in: expires ? expires.seconds : nil))
+          backend_decrement(key, -amount, expires_in: expires ? expires.seconds : nil, **options)
         else
           existing
         end
@@ -56,9 +65,9 @@ module Moneta
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        value = backend.read(key, options)
+        value = backend_read(key, options)
         if value != nil
-          backend.delete(key, options)
+          backend_delete(key, **options)
           options[:raw] ? value.to_s : value
         end
       end
@@ -74,7 +83,7 @@ module Moneta
         hash = backend.read_multi(*keys)
         if (expires = expires_value(options, nil)) != nil
           hash.each do |key, value|
-            backend.write(key, value, options.merge(expires_in: expires ? expires.seconds : nil))
+            backend_write(key, value, expires_in: expires ? expires.seconds : nil, **options)
           end
         end
         if options[:raw]
@@ -106,7 +115,7 @@ module Moneta
 
         hash = Hash === pairs ? pairs : Hash[pairs.to_a]
         expires = expires_value(options)
-        backend.write_multi(hash, options.merge(expires_in: expires ? expires.seconds : nil))
+        backend_write_multi(hash, expires_in: expires ? expires.seconds : nil, **options)
         self
       end
 
@@ -115,6 +124,52 @@ module Moneta
       def expires_value(options, default = config.expires)
         super.tap { options.delete(:expires) unless options.frozen? }
       end
+
+      delegate :decrement, :delete, :exist?, :fetch, :increment, :read, :write, :write_multi,
+               to: :@backend,
+               prefix: :backend
+      private :backend_decrement, :backend_delete, :backend_exist?,
+              :backend_fetch, :backend_increment, :backend_read,
+              :backend_write, :backend_write_multi
+
+      # @api private
+      module Rails5Support
+        private
+
+        def backend_decrement(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_delete(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_exist?(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_fetch(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_increment(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_read(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_write(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_write_multi(*args, **options)
+          super(*args, options)
+        end
+      end
+
+      prepend Rails5Support if ::ActiveSupport.version < ::Gem::Version.new('6.1.0')
     end
   end
 end

data/lib/moneta/adapters/client.rb

@@ -132,7 +132,7 @@ module Moneta
       end
 
       def read_msg
-        size = read(4).unpack('N').first
+        size = read(4).unpack1('N')
         result = Marshal.load(read(size))
         raise result if Exception === result
         result

data/lib/moneta/adapters/hbase.rb

@@ -95,7 +95,7 @@ module Moneta
       def unpack(value)
         if value.bytesize == 8
           # Unpack 8 byte big endian
-          value.unpack('Q>').first.to_s
+          value.unpack1('Q>').to_s
         elsif value.bytesize >= 9 && value[-1] == ?\0
           # Remove nul character
           value[0..-2]

data/lib/moneta/adapters/redis.rb

@@ -106,7 +106,8 @@ module Moneta
 
       # (see Defaults#merge!)
       def merge!(pairs, options = {})
-        keys = pairs.map { |key, _| key }
+        keys = pairs.map { |key, _| key }.to_a
+        return self if keys.empty?
 
         if block_given?
           old_values = @backend.mget(*keys)