activesupport 6.0.2.2 → 6.0.3.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7bf8048c7cb74c8a78b675b8a60c273101aeeae4160b72754fa4f25cf99d32f0
-  data.tar.gz: d7863b004d5dc872914d96a429f7a4046d3adcf738b9a6d6ac18080819fc1f7a
+  metadata.gz: f9a3640584c7bec116a2753b05a7bce56fe1f8c20792cd0a203c27b7f32cbc4c
+  data.tar.gz: 4250f2f8de4fd670f64fd3bb7b92c35cf494ad54bc8bc7aa6e9e37509ae49892
 SHA512:
-  metadata.gz: 70a16e7d86c63ddd518f5013d00b2e4730a3a1d9847f8e31d151c40e250934f216eeb4c4277921d869fff015479dc1aeca05c8b87e782c75dcebbed1ff8cd776
-  data.tar.gz: 549b1f814d15ec89d3468425f976a6c38a5e50a3827088d3aef600fdfd1666fe84ca8ab2afc277d491e3dcd1a712c489bd8dc3eca4e1ad40a272471c7df58998
+  metadata.gz: ebeefc050565be0566159148f0e4fdcf1735c0538f8b3c79f7f865522497284e7c298929b9d78c2f60bda713323ae3fe8119a2b52578f3679e992538b1cb318f
+  data.tar.gz: 102293ec9dbc84dbff803c972960684d73edb62b06e8028618825976ee83e90629bc8075ba66f21837dc322568b053f2063a3935d11a14e02d885a72a1dc5ba3

data/CHANGELOG.md

@@ -1,3 +1,30 @@
+## Rails 6.0.3.rc1 (April 30, 2020) ##
+
+*   `Array#to_sentence` no longer returns a frozen string.
+
+    Before:
+
+        ['one', 'two'].to_sentence.frozen?
+        # => true
+
+    After:
+
+        ['one', 'two'].to_sentence.frozen?
+        # => false
+
+    *Nicolas Dular*
+
+*   Update `ActiveSupport::Messages::Metadata#fresh?` to work for cookies with expiry set when
+    `ActiveSupport.parse_json_times = true`.
+
+    *Christian Gregg*
+
+
+## Rails 6.0.2.2 (March 19, 2020) ##
+
+*   No changes.
+
+
 ## Rails 6.0.2.1 (December 18, 2019) ##
 
 *   No changes.

data/README.rdoc

@@ -37,4 +37,4 @@ Bug reports for the Ruby on Rails project can be filed here:
 
 Feature requests should be discussed on the rails-core mailing list here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core

data/lib/active_support/backtrace_cleaner.rb

@@ -85,7 +85,6 @@ module ActiveSupport
     end
 
     private
-
       FORMATTED_GEMS_PATTERN = /\A[^\/]+ \([\w.]+\) /
 
       def add_gem_filter

data/lib/active_support/cache.rb

@@ -52,12 +52,13 @@ module ActiveSupport
       #
       #   ActiveSupport::Cache.lookup_store(MyOwnCacheStore.new)
       #   # => returns MyOwnCacheStore.new
-      def lookup_store(*store_option)
-        store, *parameters = *Array.wrap(store_option).flatten
-
+      def lookup_store(store = nil, *parameters)
         case store
         when Symbol
-          retrieve_store_class(store).new(*parameters)
+          options = parameters.extract_options!
+          retrieve_store_class(store).new(*parameters, **options)
+        when Array
+          lookup_store(*store)
         when nil
           ActiveSupport::Cache::MemoryStore.new
         else
@@ -318,7 +319,7 @@ module ActiveSupport
 
           entry = nil
           instrument(:read, name, options) do |payload|
-            cached_entry = read_entry(key, options) unless options[:force]
+            cached_entry = read_entry(key, **options) unless options[:force]
             entry = handle_expired_entry(cached_entry, key, options)
             entry = nil if entry && entry.mismatched?(normalize_version(name, options))
             payload[:super_operation] = :fetch if payload
@@ -326,9 +327,9 @@ module ActiveSupport
           end
 
           if entry
-            get_entry_value(entry, name, options)
+            get_entry_value(entry, name, **options)
           else
-            save_block_result_to_cache(name, options) { |_name| yield _name }
+            save_block_result_to_cache(name, **options) { |_name| yield _name }
           end
         elsif options && options[:force]
           raise ArgumentError, "Missing block: Calling `Cache#fetch` with `force: true` requires a block."
@@ -352,11 +353,11 @@ module ActiveSupport
         version = normalize_version(name, options)
 
         instrument(:read, name, options) do |payload|
-          entry = read_entry(key, options)
+          entry = read_entry(key, **options)
 
           if entry
             if entry.expired?
-              delete_entry(key, options)
+              delete_entry(key, **options)
               payload[:hit] = false if payload
               nil
             elsif entry.mismatched?(version)
@@ -384,7 +385,7 @@ module ActiveSupport
         options = merged_options(options)
 
         instrument :read_multi, names, options do |payload|
-          read_multi_entries(names, options).tap do |results|
+          read_multi_entries(names, **options).tap do |results|
             payload[:hits] = results.keys
           end
         end
@@ -396,10 +397,10 @@ module ActiveSupport
 
         instrument :write_multi, hash, options do |payload|
           entries = hash.each_with_object({}) do |(name, value), memo|
-            memo[normalize_key(name, options)] = Entry.new(value, options.merge(version: normalize_version(name, options)))
+            memo[normalize_key(name, options)] = Entry.new(value, **options.merge(version: normalize_version(name, options)))
           end
 
-          write_multi_entries entries, options
+          write_multi_entries entries, **options
         end
       end
 
@@ -438,7 +439,7 @@ module ActiveSupport
         options = merged_options(options)
 
         instrument :read_multi, names, options do |payload|
-          reads   = read_multi_entries(names, options)
+          reads   = read_multi_entries(names, **options)
           writes  = {}
           ordered = names.each_with_object({}) do |name, hash|
             hash[name] = reads.fetch(name) { writes[name] = yield(name) }
@@ -447,7 +448,7 @@ module ActiveSupport
           payload[:hits] = reads.keys
           payload[:super_operation] = :fetch_multi
 
-          write_multi(writes, options)
+          write_multi(writes, **options)
 
           ordered
         end
@@ -460,8 +461,8 @@ module ActiveSupport
         options = merged_options(options)
 
         instrument(:write, name, options) do
-          entry = Entry.new(value, options.merge(version: normalize_version(name, options)))
-          write_entry(normalize_key(name, options), entry, options)
+          entry = Entry.new(value, **options.merge(version: normalize_version(name, options)))
+          write_entry(normalize_key(name, options), entry, **options)
         end
       end
 
@@ -472,7 +473,7 @@ module ActiveSupport
         options = merged_options(options)
 
         instrument(:delete, name) do
-          delete_entry(normalize_key(name, options), options)
+          delete_entry(normalize_key(name, options), **options)
         end
       end
 
@@ -483,7 +484,7 @@ module ActiveSupport
         options = merged_options(options)
 
         instrument(:exist?, name) do
-          entry = read_entry(normalize_key(name, options), options)
+          entry = read_entry(normalize_key(name, options), **options)
           (entry && !entry.expired? && !entry.mismatched?(normalize_version(name, options))) || false
         end
       end
@@ -556,28 +557,28 @@ module ActiveSupport
 
         # Reads an entry from the cache implementation. Subclasses must implement
         # this method.
-        def read_entry(key, options)
+        def read_entry(key, **options)
           raise NotImplementedError.new
         end
 
         # Writes an entry to the cache implementation. Subclasses must implement
         # this method.
-        def write_entry(key, entry, options)
+        def write_entry(key, entry, **options)
           raise NotImplementedError.new
         end
 
         # Reads multiple entries from the cache implementation. Subclasses MAY
         # implement this method.
-        def read_multi_entries(names, options)
+        def read_multi_entries(names, **options)
           results = {}
           names.each do |name|
             key     = normalize_key(name, options)
             version = normalize_version(name, options)
-            entry   = read_entry(key, options)
+            entry   = read_entry(key, **options)
 
             if entry
               if entry.expired?
-                delete_entry(key, options)
+                delete_entry(key, **options)
               elsif entry.mismatched?(version)
                 # Skip mismatched versions
               else
@@ -590,15 +591,15 @@ module ActiveSupport
 
         # Writes multiple entries to the cache implementation. Subclasses MAY
         # implement this method.
-        def write_multi_entries(hash, options)
+        def write_multi_entries(hash, **options)
           hash.each do |key, entry|
-            write_entry key, entry, options
+            write_entry key, entry, **options
           end
         end
 
         # Deletes an entry from the cache implementation. Subclasses must
         # implement this method.
-        def delete_entry(key, options)
+        def delete_entry(key, **options)
           raise NotImplementedError.new
         end
 
@@ -699,7 +700,7 @@ module ActiveSupport
               entry.expires_at = Time.now + race_ttl
               write_entry(key, entry, expires_in: race_ttl * 2)
             else
-              delete_entry(key, options)
+              delete_entry(key, **options)
             end
             entry = nil
           end
@@ -711,7 +712,7 @@ module ActiveSupport
           entry.value
         end
 
-        def save_block_result_to_cache(name, options)
+        def save_block_result_to_cache(name, **options)
           result = instrument(:generate, name, options) do
             yield(name)
           end

data/lib/active_support/cache/file_store.rb

@@ -36,15 +36,15 @@ module ActiveSupport
       def clear(options = nil)
         root_dirs = (Dir.children(cache_path) - GITKEEP_FILES)
         FileUtils.rm_r(root_dirs.collect { |f| File.join(cache_path, f) })
-      rescue Errno::ENOENT
+      rescue Errno::ENOENT, Errno::ENOTEMPTY
       end
 
       # Preemptively iterates through all stored keys and removes the ones which have expired.
       def cleanup(options = nil)
         options = merged_options(options)
         search_dir(cache_path) do |fname|
-          entry = read_entry(fname, options)
-          delete_entry(fname, options) if entry && entry.expired?
+          entry = read_entry(fname, **options)
+          delete_entry(fname, **options) if entry && entry.expired?
         end
       end
 
@@ -66,14 +66,13 @@ module ActiveSupport
           matcher = key_matcher(matcher, options)
           search_dir(cache_path) do |path|
             key = file_path_key(path)
-            delete_entry(path, options) if key.match(matcher)
+            delete_entry(path, **options) if key.match(matcher)
           end
         end
       end
 
       private
-
-        def read_entry(key, options)
+        def read_entry(key, **options)
           if File.exist?(key)
             File.open(key) { |f| Marshal.load(f) }
           end
@@ -82,14 +81,14 @@ module ActiveSupport
           nil
         end
 
-        def write_entry(key, entry, options)
+        def write_entry(key, entry, **options)
           return false if options[:unless_exist] && File.exist?(key)
           ensure_cache_path(File.dirname(key))
           File.atomic_write(key, cache_path) { |f| Marshal.dump(entry, f) }
           true
         end
 
-        def delete_entry(key, options)
+        def delete_entry(key, **options)
           if File.exist?(key)
             begin
               File.delete(key)

data/lib/active_support/cache/mem_cache_store.rb

@@ -28,7 +28,7 @@ module ActiveSupport
       # Provide support for raw values in the local cache strategy.
       module LocalCacheWithRaw # :nodoc:
         private
-          def read_entry(key, options)
+          def read_entry(key, **options)
             entry = super
             if options[:raw] && local_cache && entry
               entry = deserialize_entry(entry.value)
@@ -36,11 +36,11 @@ module ActiveSupport
             entry
           end
 
-          def write_entry(key, entry, options)
+          def write_entry(key, entry, **options)
             if options[:raw] && local_cache
               raw_entry = Entry.new(entry.value.to_s)
               raw_entry.expires_at = entry.expires_at
-              super(key, raw_entry, options)
+              super(key, raw_entry, **options)
             else
               super
             end
@@ -142,12 +142,12 @@ module ActiveSupport
 
       private
         # Read an entry from the cache.
-        def read_entry(key, options)
+        def read_entry(key, **options)
           rescue_error_with(nil) { deserialize_entry(@data.with { |c| c.get(key, options) }) }
         end
 
         # Write an entry to the cache.
-        def write_entry(key, entry, options)
+        def write_entry(key, entry, **options)
           method = options && options[:unless_exist] ? :add : :set
           value = options[:raw] ? entry.value.to_s : entry
           expires_in = options[:expires_in].to_i
@@ -156,12 +156,12 @@ module ActiveSupport
             expires_in += 5.minutes
           end
           rescue_error_with false do
-            @data.with { |c| c.send(method, key, value, expires_in, options) }
+            @data.with { |c| c.send(method, key, value, expires_in, **options) }
           end
         end
 
         # Reads multiple entries from the cache implementation.
-        def read_multi_entries(names, options)
+        def read_multi_entries(names, **options)
           keys_to_names = Hash[names.map { |name| [normalize_key(name, options), name] }]
 
           raw_values = @data.with { |c| c.get_multi(keys_to_names.keys) }
@@ -179,7 +179,7 @@ module ActiveSupport
         end
 
         # Delete an entry from the cache.
-        def delete_entry(key, options)
+        def delete_entry(key, **options)
           rescue_error_with(false) { @data.with { |c| c.delete(key) } }
         end
 

data/lib/active_support/cache/memory_store.rb

@@ -51,7 +51,7 @@ module ActiveSupport
           keys = synchronize { @data.keys }
           keys.each do |key|
             entry = @data[key]
-            delete_entry(key, options) if entry && entry.expired?
+            delete_entry(key, **options) if entry && entry.expired?
           end
         end
       end
@@ -67,7 +67,7 @@ module ActiveSupport
           instrument(:prune, target_size, from: @cache_size) do
             keys = synchronize { @key_access.keys.sort { |a, b| @key_access[a].to_f <=> @key_access[b].to_f } }
             keys.each do |key|
-              delete_entry(key, options)
+              delete_entry(key, **options)
               return if @cache_size <= target_size || (max_time && Concurrent.monotonic_time - start_time > max_time)
             end
           end
@@ -98,7 +98,7 @@ module ActiveSupport
           matcher = key_matcher(matcher, options)
           keys = synchronize { @data.keys }
           keys.each do |key|
-            delete_entry(key, options) if key.match(matcher)
+            delete_entry(key, **options) if key.match(matcher)
           end
         end
       end
@@ -114,14 +114,13 @@ module ActiveSupport
       end
 
       private
-
         PER_ENTRY_OVERHEAD = 240
 
         def cached_size(key, entry)
           key.to_s.bytesize + entry.size + PER_ENTRY_OVERHEAD
         end
 
-        def read_entry(key, options)
+        def read_entry(key, **options)
           entry = @data[key]
           synchronize do
             if entry
@@ -135,7 +134,7 @@ module ActiveSupport
           entry
         end
 
-        def write_entry(key, entry, options)
+        def write_entry(key, entry, **options)
           entry.dup_value!
           synchronize do
             old_entry = @data[key]
@@ -152,7 +151,7 @@ module ActiveSupport
           end
         end
 
-        def delete_entry(key, options)
+        def delete_entry(key, **options)
           synchronize do
             @key_access.delete(key)
             entry = @data.delete(key)

data/lib/active_support/cache/null_store.rb

@@ -33,14 +33,14 @@ module ActiveSupport
       end
 
       private
-        def read_entry(key, options)
+        def read_entry(key, **options)
         end
 
-        def write_entry(key, entry, options)
+        def write_entry(key, entry, **options)
           true
         end
 
-        def delete_entry(key, options)
+        def delete_entry(key, **options)
           false
         end
     end

data/lib/active_support/cache/redis_cache_store.rb

@@ -74,7 +74,7 @@ module ActiveSupport
       # Support raw values in the local cache strategy.
       module LocalCacheWithRaw # :nodoc:
         private
-          def read_entry(key, options)
+          def read_entry(key, **options)
             entry = super
             if options[:raw] && local_cache && entry
               entry = deserialize_entry(entry.value)
@@ -82,24 +82,24 @@ module ActiveSupport
             entry
           end
 
-          def write_entry(key, entry, options)
+          def write_entry(key, entry, **options)
             if options[:raw] && local_cache
               raw_entry = Entry.new(serialize_entry(entry, raw: true))
               raw_entry.expires_at = entry.expires_at
-              super(key, raw_entry, options)
+              super(key, raw_entry, **options)
             else
               super
             end
           end
 
-          def write_multi_entries(entries, options)
+          def write_multi_entries(entries, **options)
             if options[:raw] && local_cache
               raw_entries = entries.map do |key, entry|
                 raw_entry = Entry.new(serialize_entry(entry, raw: true))
                 raw_entry.expires_at = entry.expires_at
               end.to_h
 
-              super(raw_entries, options)
+              super(raw_entries, **options)
             else
               super
             end
@@ -346,13 +346,13 @@ module ActiveSupport
 
         # Store provider interface:
         # Read an entry from the cache.
-        def read_entry(key, options = nil)
+        def read_entry(key, **options)
           failsafe :read_entry do
             deserialize_entry redis.with { |c| c.get(key) }
           end
         end
 
-        def read_multi_entries(names, _options)
+        def read_multi_entries(names, **options)
           if mget_capable?
             read_multi_mget(*names)
           else