moneta 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 057afad07820c6a0099c1c8f0d08e8a8db0d8f163ae699a6c492b5114e7690da
-  data.tar.gz: 277352fb763982da85855f170234cf6a2660afeb3b90f6bf34df6dccda586291
+  metadata.gz: 4b7e4bbe0345dcfa33a7217af5a4bbcef559b3d9cb0d8a53301a7c9ff30a7118
+  data.tar.gz: 7d3fe5f86885f39a418e8647f15243cb3728fad2daf12fd841b237c23d796fd4
 SHA512:
-  metadata.gz: 0266a4e3016c53408a92a5929152f088ff26c0981561e279e0812726a085e65a6ea90305d362ca04383ee0225915bd470f687c97d9eeafeff960ca21de716616
-  data.tar.gz: 95f6df87a40afeeff7d0c490c88f9c9950a12949358df57da9014cff3ffba1e7893ca43cdfb1d90c20750050d6bc0617e76655a025bff58caa1c89567256a894
+  metadata.gz: 667443d645a8b75775bc43633e58eab9434e5c291043e2f4165a971391c67f5fdd5dffdda76f76924de56b28d2bd1f14c25eef0d16c032859aa91e67a22d123c
+  data.tar.gz: cf76836caa72d5fa5a2179b8937e06a24571f42eb7e26ba6ad4b606fbd70305817dbf6d33ae75a181d91e4f76b267db15b7fbb26e4471d148826a00ab8f9f6b6

data/CHANGES

@@ -1,3 +1,21 @@
+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
+* Avoid calling `supports?(:expires)` when expiry isn't needed
+* Adapters::Mongo - fix `merge!` behaviour when no values are inserted
+
 1.5.1
 
 * Adapters::File - fix an implicit hash issue in Ruby 3 (#222)

data/CONTRIBUTORS

@@ -3,11 +3,13 @@ Alastair Pharo <me@asph.dev>
 Alejandro Crosa <acrosa@sharing.local>
 Alessio Signorini <alessio@signorini.us>
 Anthony Eden <anthonyeden@gmail.com>
+Antoine Beaupré <anarcat@debian.org>
 Antonio Terceiro <terceiro@debian.org>
 Atoxhybrid <atoxhybrid@gmail.com>
 AtoxIO <atoxhybrid@gmail.com>
 Ben Schwarz <ben.schwarz@gmail.com>
 Benjamin Yu <benjaminlyu@gmail.com>
+Corey Smith <korkey128k@gmail.com>
 Daniel Mendler <mail@daniel-mendler.de>
 Denis Defreyne <denis.defreyne@stoneship.org>
 Derek Kastner <dkastner@gmail.com>
@@ -20,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>
@@ -34,6 +37,7 @@ Quin Hoxie <quin@aboutus.org>
 Ryan T. Hosford <tad.hosford@gmail.com>
 Scott Wadden <scott.wadden@gmail.com>
 Sven Riedel <sr@gimp.org>
+Thomas R. Koll <tomk32@tomk32.de>
 Timo Goebel <timo.goebel@dm.de>
 Tom Meier <ozmeier@yahoo.co.uk>
 Tony Han <h.bing612@gmail.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/README.md

@@ -106,11 +106,11 @@ Out of the box, it supports the following backends. Use the backend name symbol
 * Key/value databases:
     * [Berkeley DB using DBM interface or NDBM (Depends on Ruby environment)](http://www.ruby-doc.org/stdlib/libdoc/dbm/rdoc/DBM.html) (`:DBM`)
     * [Cassandra](http://cassandra.apache.org/) (`:Cassandra`)
-    * [Daybreak](http://propublica.github.com/daybreak/) (`:Daybreak`)
+    * [Daybreak](https://propublica.github.io/daybreak/) (`:Daybreak`)
     * [GDBM](http://www.ruby-doc.org/stdlib/libdoc/gdbm/rdoc/GDBM.html) (`:GDBM`)
     * [HBase](http://hbase.apache.org/) (`:HBase`)
     * [LevelDB](http://code.google.com/p/leveldb/) (`:LevelDB`)
-    * [LMDB](http://symas.com/mdb/) (`:LMDB`)
+    * [LMDB](http://symas.com/lmdb) (`:LMDB`)
     * [Redis](http://redis.io/) (`:Redis`)
     * [Riak](http://docs.basho.com/) (`:Riak`)
     * [SDBM](http://www.ruby-doc.org/stdlib/libdoc/sdbm/rdoc/SDBM.html) (`:SDBM`)
@@ -150,7 +150,7 @@ __NOTE:__ <a name="backend-matrix"></a>The backend matrix is much more readable
 
 <tr><td>File</td><td>-</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#F44">✗</td><td>File store</td></tr>
 
-<tr><td>LMDB</td><td>lmdb</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td><a href="http://symas.com/mdb/">Symas Lightning Memory-Mapped Database (LMDB)</a></td></tr>
+<tr><td>LMDB</td><td>lmdb</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td><a href="http://symas.com/lmdb">Symas Lightning Memory-Mapped Database (LMDB)</a></td></tr>
 
 <tr><td>Sequel</td><td>sequel</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td><a href="http://sequel.rubyforge.org/">Sequel</a> ORM</td></tr>
 
@@ -221,9 +221,7 @@ __NOTE:__ <a name="backend-matrix"></a>The backend matrix is much more readable
 3. Share a Moneta store between multiple processes using `Moneta::Shared` (See below).
 4. If a store provides atomic increment it can be used with `Moneta::Semaphore`. You can add weak `#increment` support using the `Moneta::WeakIncrement` proxy.
 5. If a store provides atomic creation it can be used with `Moneta::Mutex`. You can add weak `#create` support using the `Moneta::WeakCreate` proxy.
-6. Add expiration support by using `Moneta::Expires` or by passing the option
-   `expires: true` (or `expires: <seconds>` if you want all values to expire by
-   default) to `Moneta#new`.
+6. Add expiration support by using `Moneta::Expires` or by passing the option `expires: true` to `Moneta#new`.
 7. This indicates that there is some performance gain when fetching multiple values at once using `#values_at`/`#fetch_values` or `#slice`. For instance, the `MGET` instruction in Redis, or the ability to retrieve several rows in one query in SQL.
 8. This indicates that there is some performance gain when storing multiple key/value pairs at once using `#merge!`/`#update`.
 9. Sqlite/YAML/PStore are multiprocess safe, but the performance suffers badly since the whole database file must be locked for writing. Use a key/value server if you want multiprocess concurrency!

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