activesupport 7.1.1 → 7.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecb3bcd9549f6429e9a7b2e3e54bd529a71608135834c95ecad50ed60dd8935a
-  data.tar.gz: 23c6ef54d1fbef9a19494322bae6ed4f4719d1a9f0b60e3f507dc1ccd4cf9adf
+  metadata.gz: 1d05cf683e37c600f522c4be11034dfa45e30ef52cea9e41dc0087a624fd4063
+  data.tar.gz: 7e7ba21207beeb10e1093ac45cd02a096fda507504e229f8df559b746937f1e9
 SHA512:
-  metadata.gz: abdba26b48e19b8f107f9110e2934f315f8f4fcf87340309f4786faf0998903a21e791d362e106550439088016039c692e00c90b380b5b7602b497244ea30419
-  data.tar.gz: 8f256ca213eea9aed13061094dca338c5886ba2bd3454036cd39649938399cc41ec74ff09ec28beabc21b9a57713c98e60125b13306e63a56aa908ad269b2316
+  metadata.gz: 96c1bc0122ee7fcd400846ada8641591d06ca82c42bb4d35bc87c7c8062826b1aa6eec7d2fe81144947353ff29195fd9ca3b4b307c9d21aa366a0717c974eb40
+  data.tar.gz: 668f85b8c485c9bc089781d623d3e6a6c84e8e2c57afb350d35ce346ad629679df837e9c9ea8db31b72a8b05839ab296f5e8ac8289103195ecd27b227ebe696d

data/CHANGELOG.md

@@ -1,3 +1,204 @@
+## Rails 7.1.5 (October 30, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.4.2 (October 23, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.4.1 (October 15, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.4 (August 22, 2024) ##
+
+*   Improve compatibility for `ActiveSupport::BroadcastLogger`.
+
+    *Máximo Mussini*
+
+*   Pass options along to write_entry in handle_expired_entry method.
+
+    *Graham Cooper*
+
+*   Fix Active Support configurations deprecations.
+
+    *fatkodima*
+
+*   Fix teardown callbacks.
+
+    *Tristan Starck*
+
+*   `BacktraceCleaner` silence core internal methods by default.
+
+    *Jean Boussier*
+
+*   Fix `delegate_missing_to allow_nil: true` when called with implict self
+
+    ```ruby
+    class Person
+      delegate_missing_to :address, allow_nil: true
+
+      def address
+        nil
+      end
+
+      def berliner?
+        city == "Berlin"
+      end
+    end
+
+    Person.new.city # => nil
+    Person.new.berliner? # undefined local variable or method `city' for an instance of Person (NameError)
+    ```
+
+    *Jean Boussier*
+
+*   Work around a Ruby bug that can cause a VM crash.
+
+    This would happen if using `TaggerLogger` with a Proc
+    formatter on which you called `object_id`.
+
+    ```
+    [BUG] Object ID seen, but not in mapping table: proc
+    ```
+
+    *Jean Boussier*
+
+*   Fix `ActiveSupport::Notifications.publish_event` to preserve units.
+
+    This solves the incorrect reporting of time spent running Active Record
+    asynchronous queries (by a factor `1000`).
+
+    *Jean Boussier*
+
+
+## Rails 7.1.3.4 (June 04, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3.3 (May 16, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3.2 (February 21, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3.1 (February 21, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3 (January 16, 2024) ##
+
+*   Handle nil `backtrace_locations` in `ActiveSupport::SyntaxErrorProxy`.
+
+    *Eugene Kenny*
+
+*   Fix `ActiveSupport::JSON.encode` to prevent duplicate keys.
+
+    If the same key exist in both String and Symbol form it could
+    lead to the same key being emitted twice.
+
+    *Manish Sharma*
+
+*   Fix `ActiveSupport::Cache::Store#read_multi` when using a cache namespace
+    and local cache strategy.
+
+    *Mark Oleson*
+
+*   Fix `Time.now/DateTime.now/Date.today` to return results in a system timezone after `#travel_to`.
+
+    There is a bug in the current implementation of #travel_to:
+    it remembers a timezone of its argument, and all stubbed methods start
+    returning results in that remembered timezone. However, the expected
+    behaviour is to return results in a system timezone.
+
+    *Aleksei Chernenkov*
+
+*   Fix `:unless_exist` option for `MemoryStore#write` (et al) when using a
+    cache namespace.
+
+    *S. Brent Faulkner*
+
+*   Fix ActiveSupport::Deprecation to handle blaming generated code.
+
+    *Jean Boussier*, *fatkodima*
+
+
+## Rails 7.1.2 (November 10, 2023) ##
+
+*   Fix `:expires_in` option for `RedisCacheStore#write_multi`.
+
+    *fatkodima*
+
+*   Fix deserialization of non-string "purpose" field in Message serializer
+
+    *Jacopo Beschi*
+
+*   Prevent global cache options being overwritten when setting dynamic options
+    inside a `ActiveSupport::Cache::Store#fetch` block.
+
+    *Yasha Krasnou*
+
+*   Fix missing `require` resulting in `NoMethodError` when running
+    `bin/rails secrets:show` or `bin/rails secrets:edit`.
+
+    *Stephen Ierodiaconou*
+
+*   Ensure `{down,up}case_first` returns non-frozen string.
+
+    *Jonathan Hefner*
+
+*   Fix `#to_fs(:human_size)` to correctly work with negative numbers.
+
+    *Earlopain*
+
+*   Fix `BroadcastLogger#dup` so that it duplicates the logger's `broadcasts`.
+
+    *Andrew Novoselac*
+
+*   Fix issue where `bootstrap.rb` overwrites the `level` of a `BroadcastLogger`'s `broadcasts`.
+
+    *Andrew Novoselac*
+
+*   Fix `ActiveSupport::Cache` to handle outdated Marshal payload from Rails 6.1 format.
+
+    Active Support's Cache is supposed to treat a Marshal payload that can no longer be
+    deserialized as a cache miss. It fail to do so for compressed payload in the Rails 6.1
+    legacy format.
+
+    *Jean Boussier*
+
+*   Fix `OrderedOptions#dig` for array indexes.
+
+    *fatkodima*
+
+*   Fix time travel helpers to work when nested using with separate classes.
+
+    *fatkodima*
+
+*   Fix `delete_matched` for file cache store to work with keys longer than the
+    max filename size.
+
+    *fatkodima* and *Jonathan Hefner*
+
+*   Fix compatibility with the `semantic_logger` gem.
+
+    The `semantic_logger` gem doesn't behave exactly like stdlib logger in that
+    `SemanticLogger#level` returns a Symbol while stdlib `Logger#level` returns an Integer.
+
+    This caused the various `LogSubscriber` classes in Rails to break when assigned a
+    `SemanticLogger` instance.
+
+    *Jean Boussier*, *ojab*
+
 ## Rails 7.1.1 (October 11, 2023) ##
 
 *   Add support for keyword arguments when delegating calls to custom loggers from `ActiveSupport::BroadcastLogger`.

data/lib/active_support/backtrace_cleaner.rb

@@ -33,6 +33,7 @@ module ActiveSupport
   class BacktraceCleaner
     def initialize
       @filters, @silencers = [], []
+      add_core_silencer
       add_gem_filter
       add_gem_silencer
       add_stdlib_silencer
@@ -116,6 +117,10 @@ module ActiveSupport
         add_filter { |line| line.sub(gems_regexp, gems_result) }
       end
 
+      def add_core_silencer
+        add_silencer { |line| line.include?("<internal:") }
+      end
+
       def add_gem_silencer
         add_silencer { |line| FORMATTED_GEMS_PATTERN.match?(line) }
       end

data/lib/active_support/broadcast_logger.rb

@@ -113,33 +113,33 @@ module ActiveSupport
       dispatch { |logger| logger.<<(message) }
     end
 
-    def add(*args, &block)
-      dispatch { |logger| logger.add(*args, &block) }
+    def add(...)
+      dispatch { |logger| logger.add(...) }
     end
     alias_method :log, :add
 
-    def debug(*args, &block)
-      dispatch { |logger| logger.debug(*args, &block) }
+    def debug(...)
+      dispatch { |logger| logger.debug(...) }
     end
 
-    def info(*args, &block)
-      dispatch { |logger| logger.info(*args, &block) }
+    def info(...)
+      dispatch { |logger| logger.info(...) }
     end
 
-    def warn(*args, &block)
-      dispatch { |logger| logger.warn(*args, &block) }
+    def warn(...)
+      dispatch { |logger| logger.warn(...) }
     end
 
-    def error(*args, &block)
-      dispatch { |logger| logger.error(*args, &block) }
+    def error(...)
+      dispatch { |logger| logger.error(...) }
     end
 
-    def fatal(*args, &block)
-      dispatch { |logger| logger.fatal(*args, &block) }
+    def fatal(...)
+      dispatch { |logger| logger.fatal(...) }
     end
 
-    def unknown(*args, &block)
-      dispatch { |logger| logger.unknown(*args, &block) }
+    def unknown(...)
+      dispatch { |logger| logger.unknown(...) }
     end
 
     def formatter=(formatter)
@@ -218,9 +218,18 @@ module ActiveSupport
       dispatch { |logger| logger.fatal! }
     end
 
+    def initialize_copy(other)
+      @broadcasts = []
+      @progname = other.progname.dup
+      @formatter = other.formatter.dup
+
+      broadcast_to(*other.broadcasts.map(&:dup))
+    end
+
     private
       def dispatch(&block)
         @broadcasts.each { |logger| block.call(logger) }
+        true
       end
 
       def method_missing(name, *args, **kwargs, &block)

data/lib/active_support/cache/entry.rb

@@ -121,7 +121,13 @@ module ActiveSupport
 
       private
         def uncompress(value)
-          Marshal.load(Zlib::Inflate.inflate(value))
+          marshal_load(Zlib::Inflate.inflate(value))
+        end
+
+        def marshal_load(payload)
+          Marshal.load(payload)
+        rescue ArgumentError => error
+          raise Cache::DeserializationError, error.message
         end
     end
   end

data/lib/active_support/cache/file_store.rb

@@ -176,7 +176,7 @@ module ActiveSupport
 
         # Translate a file path into a key.
         def file_path_key(path)
-          fname = path[cache_path.to_s.size..-1].split(File::SEPARATOR, 4).last
+          fname = path[cache_path.to_s.size..-1].split(File::SEPARATOR, 4).last.delete(File::SEPARATOR)
           URI.decode_www_form_component(fname, Encoding::UTF_8)
         end
 

data/lib/active_support/cache/mem_cache_store.rb

@@ -24,11 +24,11 @@ module ActiveSupport
     #
     # Special features:
     # - Clustering and load balancing. One can specify multiple memcached servers,
-    #   and MemCacheStore will load balance between all available servers. If a
-    #   server goes down, then MemCacheStore will ignore it until it comes back up.
+    #   and +MemCacheStore+ will load balance between all available servers. If a
+    #   server goes down, then +MemCacheStore+ will ignore it until it comes back up.
     #
-    # MemCacheStore implements the Strategy::LocalCache strategy which implements
-    # an in-memory cache inside of a block.
+    # +MemCacheStore+ implements the Strategy::LocalCache strategy which
+    # implements an in-memory cache inside of a block.
     class MemCacheStore < Store
       # These options represent behavior overridden by this implementation and should
       # not be allowed to get down to the Dalli client
@@ -106,14 +106,14 @@ module ActiveSupport
         end
       end
 
-      # Creates a new MemCacheStore object, with the given memcached server
+      # Creates a new +MemCacheStore+ object, with the given memcached server
       # addresses. Each address is either a host name, or a host-with-port string
       # in the form of "host_name:port". For example:
       #
       #   ActiveSupport::Cache::MemCacheStore.new("localhost", "server-downstairs.localnetwork:8229")
       #
       # If no addresses are provided, but <tt>ENV['MEMCACHE_SERVERS']</tt> is defined, it will be used instead. Otherwise,
-      # MemCacheStore will connect to localhost:11211 (the default memcached port).
+      # +MemCacheStore+ will connect to localhost:11211 (the default memcached port).
       # Passing a +Dalli::Client+ instance is deprecated and will be removed. Please pass an address instead.
       def initialize(*addresses)
         addresses = addresses.flatten
@@ -270,14 +270,22 @@ module ActiveSupport
         def read_multi_entries(names, **options)
           keys_to_names = names.index_by { |name| normalize_key(name, options) }
 
-          raw_values = @data.with { |c| c.get_multi(keys_to_names.keys) }
+          raw_values = begin
+            @data.with { |c| c.get_multi(keys_to_names.keys) }
+          rescue Dalli::UnmarshalError
+            {}
+          end
+
           values = {}
 
           raw_values.each do |key, value|
             entry = deserialize_entry(value, raw: options[:raw])
 
             unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
-              values[keys_to_names[key]] = entry.value
+              begin
+                values[keys_to_names[key]] = entry.value
+              rescue DeserializationError
+              end
             end
           end
 

data/lib/active_support/cache/memory_store.rb

@@ -18,13 +18,13 @@ module ActiveSupport
     # a cleanup will occur which tries to prune the cache down to three quarters
     # of the maximum size by removing the least recently used entries.
     #
-    # Unlike other Cache store implementations, MemoryStore does not compress
-    # values by default. MemoryStore does not benefit from compression as much
+    # Unlike other Cache store implementations, +MemoryStore+ does not compress
+    # values by default. +MemoryStore+ does not benefit from compression as much
     # as other Store implementations, as it does not send data over a network.
     # However, when compression is enabled, it still pays the full cost of
     # compression in terms of cpu use.
     #
-    # MemoryStore is thread-safe.
+    # +MemoryStore+ is thread-safe.
     class MemoryStore < Store
       module DupCoder # :nodoc:
         extend self
@@ -209,7 +209,7 @@ module ActiveSupport
         def write_entry(key, entry, **options)
           payload = serialize_entry(entry, **options)
           synchronize do
-            return false if options[:unless_exist] && exist?(key)
+            return false if options[:unless_exist] && exist?(key, namespace: nil)
 
             old_payload = @data[key]
             if old_payload

data/lib/active_support/cache/redis_cache_store.rb

@@ -19,22 +19,23 @@ module ActiveSupport
   module Cache
     # = Redis \Cache \Store
     #
-    # Deployment note: Take care to use a *dedicated Redis cache* rather
-    # than pointing this at your existing Redis server. It won't cope well
-    # with mixed usage patterns and it won't expire cache entries by default.
+    # Deployment note: Take care to use a <b>dedicated Redis cache</b> rather
+    # than pointing this at a persistent Redis server (for example, one used as
+    # an Active Job queue). Redis won't cope well with mixed usage patterns and it
+    # won't expire cache entries by default.
     #
     # Redis cache server setup guide: https://redis.io/topics/lru-cache
     #
-    # * Supports vanilla Redis, hiredis, and Redis::Distributed.
-    # * Supports Memcached-like sharding across Redises with Redis::Distributed.
+    # * Supports vanilla Redis, hiredis, and +Redis::Distributed+.
+    # * Supports Memcached-like sharding across Redises with +Redis::Distributed+.
     # * Fault tolerant. If the Redis server is unavailable, no exceptions are
     #   raised. Cache fetches are all misses and writes are dropped.
     # * Local cache. Hot in-memory primary cache within block/middleware scope.
-    # * +read_multi+ and +write_multi+ support for Redis mget/mset. Use Redis::Distributed
-    #   4.0.1+ for distributed mget support.
+    # * +read_multi+ and +write_multi+ support for Redis mget/mset. Use
+    #   +Redis::Distributed+ 4.0.1+ for distributed mget support.
     # * +delete_matched+ support for Redis KEYS globs.
     class RedisCacheStore < Store
-      # Keys are truncated with the ActiveSupport digest if they exceed 1kB
+      # Keys are truncated with the Active Support digest if they exceed 1kB
       MAX_KEY_BYTESIZE = 1024
 
       DEFAULT_REDIS_OPTIONS = {
@@ -110,8 +111,11 @@ module ActiveSupport
 
       # Creates a new Redis cache store.
       #
-      # Handles four options: :redis block, :redis instance, single :url
-      # string, and multiple :url strings.
+      # There are four ways to provide the Redis client used by the cache: the
+      # +:redis+ param can be a Redis instance or a block that returns a Redis
+      # instance, or the +:url+ param can be a string or an array of strings
+      # which will be used to create a Redis instance or a +Redis::Distributed+
+      # instance.
       #
       #   Option  Class       Result
       #   :redis  Proc    ->  options[:redis].call
@@ -134,7 +138,7 @@ module ActiveSupport
       #
       # Race condition TTL is not set by default. This can be used to avoid
       # "thundering herd" cache writes when hot cache entries are expired.
-      # See <tt>ActiveSupport::Cache::Store#fetch</tt> for more.
+      # See ActiveSupport::Cache::Store#fetch for more.
       #
       # Setting <tt>skip_nil: true</tt> will not cache nil results:
       #
@@ -242,7 +246,7 @@ module ActiveSupport
       # Decrement a cached integer value using the Redis decrby atomic operator.
       # Returns the updated value.
       #
-      # If the key is unset or has expired, it will be set to -amount:
+      # If the key is unset or has expired, it will be set to +-amount+:
       #
       #   cache.decrement("foo") # => -1
       #
@@ -332,7 +336,10 @@ module ActiveSupport
             if value
               entry = deserialize_entry(value, raw: raw)
               unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(name, options))
-                results[name] = entry.value
+                begin
+                  results[name] = entry.value
+                rescue DeserializationError
+                end
               end
             end
           end
@@ -383,7 +390,7 @@ module ActiveSupport
         end
 
         # Nonstandard store provider API to write multiple values at once.
-        def write_multi_entries(entries, expires_in: nil, race_condition_ttl: nil, **options)
+        def write_multi_entries(entries, **options)
           return if entries.empty?
 
           failsafe :write_multi_entries do

data/lib/active_support/cache/strategy/local_cache.rb

@@ -131,17 +131,20 @@ module ActiveSupport
             end
           end
 
-          def read_multi_entries(keys, **options)
+          def read_multi_entries(names, **options)
             return super unless local_cache
 
-            local_entries = local_cache.read_multi_entries(keys)
+            keys_to_names = names.index_by { |name| normalize_key(name, options) }
+
+            local_entries = local_cache.read_multi_entries(keys_to_names.keys)
+            local_entries.transform_keys! { |key| keys_to_names[key] }
             local_entries.transform_values! do |payload|
-              deserialize_entry(payload)&.value
+              deserialize_entry(payload, **options)&.value
             end
-            missed_keys = keys - local_entries.keys
+            missed_names = names - local_entries.keys
 
-            if missed_keys.any?
-              local_entries.merge!(super(missed_keys, **options))
+            if missed_names.any?
+              local_entries.merge!(super(missed_names, **options))
             else
               local_entries
             end

data/lib/active_support/cache.rb

@@ -160,8 +160,8 @@ module ActiveSupport
     # Some implementations may not support all methods beyond the basic cache
     # methods of #fetch, #write, #read, #exist?, and #delete.
     #
-    # ActiveSupport::Cache::Store can store any Ruby object that is supported by
-    # its +coder+'s +dump+ and +load+ methods.
+    # +ActiveSupport::Cache::Store+ can store any Ruby object that is supported
+    # by its +coder+'s +dump+ and +load+ methods.
     #
     #   cache = ActiveSupport::Cache::MemoryStore.new
     #
@@ -370,8 +370,8 @@ module ActiveSupport
       #
       # ==== Options
       #
-      # Internally, +fetch+ calls #read_entry, and calls #write_entry on a cache
-      # miss. Thus, +fetch+ supports the same options as #read and #write.
+      # Internally, +fetch+ calls +read_entry+, and calls +write_entry+ on a
+      # cache miss. Thus, +fetch+ supports the same options as #read and #write.
       # Additionally, +fetch+ supports the following options:
       #
       # * <tt>force: true</tt> - Forces a cache "miss," meaning we treat the
@@ -459,7 +459,17 @@ module ActiveSupport
             instrument(:read, name, options) do |payload|
               cached_entry = read_entry(key, **options, event: payload)
               entry = handle_expired_entry(cached_entry, key, options)
-              entry = nil if entry && entry.mismatched?(normalize_version(name, options))
+              if entry
+                if entry.mismatched?(normalize_version(name, options))
+                  entry = nil
+                else
+                  begin
+                    entry.value
+                  rescue DeserializationError
+                    entry = nil
+                  end
+                end
+              end
               payload[:super_operation] = :fetch if payload
               payload[:hit] = !!entry if payload
             end
@@ -511,7 +521,12 @@ module ActiveSupport
               nil
             else
               payload[:hit] = true if payload
-              entry.value
+              begin
+                entry.value
+              rescue DeserializationError
+                payload[:hit] = false
+                nil
+              end
             end
           else
             payload[:hit] = false if payload
@@ -803,7 +818,7 @@ module ActiveSupport
           end
         end
 
-        def deserialize_entry(payload)
+        def deserialize_entry(payload, **)
           payload.nil? ? nil : @coder.load(payload)
         rescue DeserializationError
           nil
@@ -1023,7 +1038,8 @@ module ActiveSupport
               # When an entry has a positive :race_condition_ttl defined, put the stale entry back into the cache
               # for a brief period while the entry is being recalculated.
               entry.expires_at = Time.now.to_f + race_ttl
-              write_entry(key, entry, expires_in: race_ttl * 2)
+              options[:expires_in] = race_ttl * 2
+              write_entry(key, entry, **options)
             else
               delete_entry(key, **options)
             end
@@ -1038,6 +1054,8 @@ module ActiveSupport
         end
 
         def save_block_result_to_cache(name, options)
+          options = options.dup
+
           result = instrument(:generate, name, options) do
             yield(name, WriteOptions.new(options))
           end
@@ -1047,6 +1065,10 @@ module ActiveSupport
         end
     end
 
+    # Enables the dynamic configuration of Cache entry options while ensuring
+    # that conflicting options are not both set. When a block is given to
+    # ActiveSupport::Cache::Store#fetch, the second argument will be an
+    # instance of +WriteOptions+.
     class WriteOptions
       def initialize(options) # :nodoc:
         @options = options
@@ -1064,6 +1086,9 @@ module ActiveSupport
         @options[:expires_in]
       end
 
+      # Sets the Cache entry's +expires_in+ value. If an +expires_at+ option was
+      # previously set, this will unset it since +expires_in+ and +expires_at+
+      # cannot both be set.
       def expires_in=(expires_in)
         @options.delete(:expires_at)
         @options[:expires_in] = expires_in
@@ -1073,6 +1098,9 @@ module ActiveSupport
         @options[:expires_at]
       end
 
+      # Sets the Cache entry's +expires_at+ value. If an +expires_in+ option was
+      # previously set, this will unset it since +expires_at+ and +expires_in+
+      # cannot both be set.
       def expires_at=(expires_at)
         @options.delete(:expires_in)
         @options[:expires_at] = expires_at