activerecord-cached_at 2.0.12 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8176a13705e644ac3fa27b5690c68ec7c4d43f46
-  data.tar.gz: e022fb6d8d7c6da36aa819fb3809a05a86c2f06d
+SHA256:
+  metadata.gz: d0d9e3d63dbd18d8baab8017ad304e44f55b73ebe42060e0723438b252dc4cfe
+  data.tar.gz: 1c6cbb926a39f8c2cabe19a44d918e063df2f6278d443ea3d13ffae37b28e608
 SHA512:
-  metadata.gz: 9b0cc35ece0124d0027967d615b1665f58ca15451aa148e87f154455e4c599bedbd71dbc951b174ae12271cc9aece81a390a9124765608d66af1782edbfcdde6
-  data.tar.gz: 9131194d596d3fb06f205068c4afdcb6731dbd5d83902c0f5980c4bb07d875bf378332b1bd2659ed010c08a8394040162d9aa31db7e73c23e211fb980f13ce62
+  metadata.gz: bfafa9a17b95d329a28b0b7b3cc2c570b5cb206b9e9ab51a653f263b971fa59e5d56b4ecc87db02c1a0a526e98ff2ef3012ccc49b31b73da3f7c65cec9d7fc5b
+  data.tar.gz: 1311efa1ca1b808d636739c417ceb5561976e9d6565096ba871a51bed9e2faa40110de75a000c48d93e51e63e3022f523cdfd7fb05e956e9a82e734c81c704fa

data/README.md

@@ -1,15 +1,16 @@
-# ActiveRecord - CachedAt
+# ActiveRecord - CachedAt [![Travis CI](https://travis-ci.org/malomalo/activerecord-cached_at.svg?branch=master)](https://travis-ci.org/malomalo/activerecord-cached_at)
 
 This gem causes ActiveRecord to update a `cached_at` column if present, like the
 `updated_at` column.
 
 When calculating a `cache_key` for a model it will also consider the `cached_at`
-column to determin the key of a model.
+column to determine the key of a model.
 
 Any `ActiveRecord::Migration` that calls `timestamps` will include a `cached_at`
 column.
 
-TODO: Document about relationship caches
+Call to [`ActiveRecord::Persistence::touch`](https://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-touch)
+will also touch the `cached_at` column.
 
 ## Installation
 
@@ -22,12 +23,94 @@ aren't updating the models you can just require the helpers:
 
     gem 'activerecord-cached_at', require: 'cached_at/helpers'
 
+## Configuration
 
+By default updates to the `cached_at`, `updated_at`, and `created_at` columns
+will not trigger and update to the `cached_at` column. You can add aditional
+fields to ignore:
+
+```ruby
+class User
+  cached_at ignore: :my_column
+end
+
+class Photo
+  cached_at ignore: :column_a, :column_b
+end
+```
+## Relationship Cache Keys
+
+CachedAt also allows you to keep cache keys for relationships. This allows you
+to use the record to determine if a cache is valid for a relationship instead
+of doing another database query.
+
+For example:
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :photos
+end
+
+class Photo
+  belongs_to :user, cached_at: true
+end
+
+bob_ross = User.create(name: 'Bob Ross')
+# => INSERT INTO "users"
+#    ("name", "cached_at", "updated_at_", "created_at")
+#    VALUES
+#    ("Bob Ross", "2020-07-19 20:22:03", "2020-07-19 20:22:03", "2020-07-19 20:22:03")
+
+photo = Photo.create(user: bob_ross, file: ...)
+# =>INSERT INTO "photos" ("user_id", "cached_at", "updated_at_", "created_at") VALUES (1, "Bob Ross", "2020-07-19 20:22:04", "2020-07-19 20:22:04", "2020-07-19 20:22:04")
+# => UPDATE "users" SET "photos_cached_at" = "2020-07-19 20:22:04" WHERE "users"."id" = 1
+
+photo.update(file: ...)
+# =>UPDATE "photos" (..., "cached_at", "updated_at_") VALUES (..., "2020-07-19 20:22:05", "2020-07-19 20:22:05", "2020-07-19 20:22:05")
+# => UPDATE "users" SET "photos_cached_at" = "2020-07-19 20:22:05" WHERE "users"."id" = 1
+
+photo.update(user: not_bob_ross)
+# =>UPDATE "photos" ("user_id", "cached_at", "updated_at_") VALUES (2, "2020-07-19 20:22:06", "2020-07-19 20:22:06", "2020-07-19 20:22:06")
+# => UPDATE "users" SET "photos_cached_at" = "2020-07-19 20:22:06" WHERE "users"."id" IN (1, 2)
+
+photo.destroy
+# => UPDATE "users" SET "photos_cached_at" = "2020-07-19 20:22:07" WHERE "users"."id" = 2
+# => DELETE FROM "users" WHERE WHERE "users"."id" = 2
+```
+
+# Usage
+
+`cached_at` will automatically be used for determining the cache key in Rails.
+
+However if you need to calculate the cache key based on relationship cache keys
+you will need to manually compute the cache key. Examples are below:
+
+The cache key here is the maxium of the following keys: `cached_at`,
+`listings_cached_at`, and `photos_cached_at`
+
+```erb
+<%= render partial: 'row', collection: @properties, as: :property, cached: Proc.new { |item|
+  [item.cache_key_with_version(:listings, :photos), current_account.id ]
+} %>
+
+<% cache @property.cache_key_with_version(:listings, :photos) do %>
+  <b>All the info on this property</b>
+  <%= @property.name %>
+  <% @property.listings.each do |listing| %>
+    <%= listing.info %>
+  <% end %>
+  <% @property.photos.each do |photo| %>
+    <%= image_tag(photo.url) %>
+  <% end %>
+<% end %>
+
+```
 ## TODO:
 
- Add a `cache_key` method to the Model class that gets `MAX(cached_at)`
+* Document going more than one level with cached_at keys
 
+* Add a `cache_key` method to the Model class that gets `MAX(cached_at)`
 
+* change option to cache: true
 
-change option to cache: true
-add cache_association helper
+* add cache_association helper

data/lib/cached_at/association_extension.rb

@@ -2,6 +2,7 @@ module CachedAt
   module AssociationExtension
 
     def self.build(model, reflection)
+      return unless reflection.options[:cached_at]
     end
     
     def self.valid_options
@@ -11,4 +12,4 @@ module CachedAt
   end
 end
 
-ActiveRecord::Associations::Builder::Association.extensions << CachedAt::AssociationExtension
+ActiveRecord::Associations::Builder::Association.extensions << CachedAt::AssociationExtension

data/lib/cached_at/associations/association.rb

@@ -1,9 +1,5 @@
 module CachedAt
   module Association
-
-    def initialize(owner, reflection)
-      super
-    end
     
     def traverse_relationships(klass, relationships, query, cache_column, timestamp)
       if relationships.is_a?(Symbol)
@@ -45,7 +41,7 @@ module CachedAt
         
         source_assoc = owner.association(r.source_reflection_name.to_sym)
         if source_assoc.loaded?
-          source_assoc.target.raw_write_attribute(cache_column, timestamp)
+          source_assoc.target.send(:write_attribute_without_type_cast, cache_column, timestamp)
         end
         query = r.klass.where(r.association_primary_key => owner.send(r.foreign_key))
         query.update_all({ cache_column => timestamp })

data/lib/cached_at/associations/belongs_to_association.rb

@@ -13,8 +13,8 @@ module CachedAt
 
       cache_column = "#{options[:inverse_of]}_cached_at"
       if options[:polymorphic]
-        oldtype = owner.send("#{reflection.foreign_type}_was")
-        oldid = owner.send("#{reflection.foreign_key}_was")
+        oldtype = owner.send("#{reflection.foreign_type}_before_last_save")
+        oldid = owner.send("#{reflection.foreign_key}_before_last_save")
         newtype = owner.send(reflection.foreign_type)
         newid = owner.send(reflection.foreign_key)
         if !oldtype.nil? && oldtype == newtype
@@ -38,14 +38,14 @@ module CachedAt
           end
         end
       else
-        ids = [owner.send(reflection.foreign_key), owner.send("#{reflection.foreign_key}_was")].compact.uniq
+        ids = [owner.send(reflection.foreign_key), owner.send("#{reflection.foreign_key}_before_last_save")].compact.uniq
         query = klass.where({ reflection.association_primary_key => ids })
         query.update_all({ cache_column => timestamp })
         traverse_relationships(klass, options[:cached_at], query, cache_column, timestamp)
       end
       
       if loaded? && target
-        target.raw_write_attribute(cache_column, timestamp)
+        target.send(:write_attribute_without_type_cast, cache_column, timestamp)
       end
     end
     
@@ -54,7 +54,7 @@ module CachedAt
         timestamp = Time.now
         cache_column = "#{options[:inverse_of]}_cached_at"
         if loaded? && target
-          target.raw_write_attribute(cache_column, timestamp)
+          target.send(:write_attribute_without_type_cast, cache_column, timestamp)
         end
       end
       

data/lib/cached_at/associations/collection_association.rb

@@ -10,11 +10,11 @@ module CachedAt
       end
 
       cache_column = "#{reflection.inverse_of.name}_cached_at"
-      ids = [owner.send(reflection.association_primary_key), owner.send("#{reflection.association_primary_key}_was")].compact.uniq
+      ids = [owner.send(reflection.association_primary_key), owner.send("#{reflection.association_primary_key}_before_last_save")].compact.uniq
       query = klass.where({ reflection.foreign_key => ids })
     
       if loaded?
-        target.each { |r| r.raw_write_attribute(cache_column, timestamp) }
+        target.each { |r| r.send(:write_attribute_without_type_cast, cache_column, timestamp) }
       end
       
       if method != :destroy
@@ -40,7 +40,7 @@ module CachedAt
 
       cache_column = "#{reflection.inverse_of.name}_cached_at"
 
-      records.each { |r| r.raw_write_attribute(cache_column, timestamp) unless r.destroyed? }
+      records.each { |r| r.send(:write_attribute_without_type_cast, cache_column, timestamp) unless r.destroyed? }
 
       query = klass.where({ klass.primary_key => records.map(&:id) })
       query.update_all({ cache_column => timestamp })

data/lib/cached_at/associations/collection_proxy.rb

@@ -0,0 +1,10 @@
+module CachedAt
+  module CollectionProxy
+    def delete(*records)
+      @association.touch_records_cached_at(records, Time.now) unless @association.owner.new_record?
+      super
+    end
+  end
+end
+
+ActiveRecord::Associations::CollectionProxy.prepend(CachedAt::CollectionProxy)

data/lib/cached_at/associations/has_many_through_association.rb

@@ -15,10 +15,10 @@ module CachedAt
 
         query = nil
         if loaded?
-          target.each { |r| r.raw_write_attribute(cache_column, timestamp) }
+          target.each { |r| r.send(:write_attribute_without_type_cast, cache_column, timestamp) }
           query = klass.where(klass.primary_key => target.map(&:id))
         else
-          ids = [owner.send(using_reflection.association_primary_key), owner.send("#{using_reflection.association_primary_key}_was")].compact.uniq
+          ids = [owner.send(using_reflection.association_primary_key), owner.send("#{using_reflection.association_primary_key}_before_last_save")].compact.uniq
           arel_table = klass._reflections[using_reflection.inverse_of.options[:through].to_s].klass.arel_table
           query = klass.joins(using_reflection.inverse_of.options[:through])
           query = if using_reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
@@ -35,7 +35,7 @@ module CachedAt
       #TODO: test with new record (fails in mls)
       if !owner.new_record? && using_reflection.inverse_of && using_reflection.inverse_of.options[:cached_at]
         cache_column = "#{using_reflection.name}_cached_at"
-        owner.raw_write_attribute(cache_column, timestamp)
+        owner.send(:write_attribute_without_type_cast, cache_column, timestamp)
         owner.update_columns(cache_column => timestamp)
       end
     end
@@ -50,7 +50,7 @@ module CachedAt
         end
 
         cache_column = "#{using_reflection.inverse_of.name}_cached_at"
-        records.each { |r| r.raw_write_attribute(cache_column, timestamp) }
+        records.each { |r| r.send(:write_attribute_without_type_cast, cache_column, timestamp) }
         query = klass.where(klass.primary_key => records.map(&:id))
         query.update_all({ cache_column => timestamp })
         traverse_relationships(klass, using_reflection.options[:cached_at], query, cache_column, timestamp)

data/lib/cached_at/associations/has_one_association.rb

@@ -10,7 +10,7 @@ module CachedAt
       end
   
       cache_column = "#{reflection.inverse_of.name}_cached_at"
-      ids = [owner.send(reflection.association_primary_key), owner.send("#{reflection.association_primary_key}_was")].compact.uniq
+      ids = [owner.send(reflection.association_primary_key), owner.send("#{reflection.association_primary_key}_before_last_save")].compact.uniq
       query = klass.where({ reflection.foreign_key => ids })
   
       case options[:dependent]
@@ -24,7 +24,7 @@ module CachedAt
       end
       
       if loaded? && target
-        target.raw_write_attribute(cache_column, timestamp)
+        target.send(:write_attribute_without_type_cast, cache_column, timestamp)
       end
     end
     

data/lib/cached_at/base.rb

@@ -3,6 +3,7 @@ require File.expand_path(File.join(__FILE__, '../associations/association'))
 require File.expand_path(File.join(__FILE__, '../associations/has_one_association'))
 require File.expand_path(File.join(__FILE__, '../associations/belongs_to_association'))
 require File.expand_path(File.join(__FILE__, '../associations/collection_association'))
+require File.expand_path(File.join(__FILE__, '../associations/collection_proxy'))
 require File.expand_path(File.join(__FILE__, '../associations/has_many_through_association'))
 
 require File.expand_path(File.join(__FILE__, '../reflections/abstract_reflection'))
@@ -12,27 +13,42 @@ module CachedAt
     extend ActiveSupport::Concern
 
     included do
+      class_attribute   :cached_at_settings, default: {ignore: ['cached_at', 'updated_at', 'created_at']}
+      before_save       :set_cached_at
       before_save       :update_belongs_to_cached_at_keys
       before_destroy    { update_relations_cached_at(method: :destroy) }
 
       after_touch       { update_relations_cached_at_from_cached_at(method: :touch) }
-      after_save     :update_relations_cached_at_from_cached_at
+      after_save        :update_relations_cached_at_from_cached_at
+    end
+
+    class_methods do
+      def cached_at(ignore: [])
+        ignore = [ignore] if !ignore.is_a?(Array)
+        self.cached_at_settings[:ignore].push(*ignore.map(&:to_s))
+      end
+    end
+
+    def touch(*names, time: nil)
+      names.push('cached_at')
+      super(*names, time: time)
     end
 
     private
     
     def update_relations_cached_at_from_cached_at(method: nil)
-      update_relations_cached_at({
+      update_relations_cached_at(
         timestamp: (self.class.column_names.include?('cached_at') ? cached_at : nil),
         method: method
-      })
+      )
     end
     
     def update_relations_cached_at(timestamp: nil, method: nil)
       method = instance_variable_defined?(:@new_record_before_save) && @new_record_before_save ? :create : :update if method.nil?
       
-      return if method == :create && changes.empty?
-      return if method == :update && changes.empty?
+      diff = saved_changes.transform_values(&:first)
+      return if method == :create && diff.empty?
+      return if method == :update && diff.empty?
       
       timestamp ||= current_time_from_proper_timezone
 
@@ -47,22 +63,30 @@ module CachedAt
       end
     end
 
+    def set_cached_at
+      return if !self.class.column_names.include?('cached_at')
+      diff = changes.transform_values(&:first)
+      return if diff.keys.all? { |k| cached_at_settings[:ignore].include?(k) }
+
+      self.cached_at = current_time_from_proper_timezone
+    end
+
     def update_belongs_to_cached_at_keys
       self.class.reflect_on_all_associations.each do |reflection|
         next unless reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
         cache_column = "#{reflection.name}_cached_at"
 
         if self.attribute_names.include?(cache_column)
-          if self.changes.has_key?(reflection.foreign_key) && self.changes[reflection.foreign_key][1].nil?
+          if self.changes_to_save.has_key?(reflection.foreign_key) && self.changes_to_save[reflection.foreign_key][1].nil?
             self.assign_attributes({ cache_column => current_time_from_proper_timezone })
-          elsif (self.changes[reflection.foreign_key] || self.new_record? || (self.association(reflection.name).loaded? && self.send(reflection.name) && self.send(reflection.name).id.nil?)) && self.send(reflection.name).try(:cached_at)
+          elsif (self.changes_to_save[reflection.foreign_key] || self.new_record? || (self.association(reflection.name).loaded? && self.send(reflection.name) && self.send(reflection.name).id.nil?)) && self.send(reflection.name).try(:cached_at)
             self.assign_attributes({ cache_column => self.send(reflection.name).cached_at })
           end
         end
         
       end
     end
-    
+
   end
 end
 

data/lib/cached_at/connection_adapters/abstract/schema_definitions.rb

@@ -2,14 +2,12 @@ module ActiveRecord
   module ConnectionAdapters #:nodoc:
     
     class TableDefinition
-      def timestamps(*args)
-        options = args.extract_options!
-        
+      def timestamps(**options)
         options[:null] = false if options[:null].nil?
         
         column(:created_at, :datetime, options)
         column(:updated_at, :datetime, options)
-        column(:cached_at, :datetime, options)
+        column(:cached_at,  :datetime, options)
       end
     end
     

data/lib/cached_at/connection_adapters/abstract/schema_statements.rb

@@ -7,7 +7,7 @@ module ActiveRecord
         
         add_column table_name, :created_at, :datetime, options
         add_column table_name, :updated_at, :datetime, options
-        add_column table_name, :cached_at, :datetime, options
+        add_column table_name, :cached_at,  :datetime, options
       end
       
       def remove_timestamps(table_name, options = {})

data/lib/cached_at/helpers.rb

@@ -29,16 +29,40 @@ module CachedAt
 
       end
 
-      def cache_key(includes = nil)
+      def cache_key(*includes)
         if includes.nil? || includes.empty?
-          super
+          if cache_versioning
+            "#{model_name.cache_key}/#{id}"
+          else
+            "#{model_name.cache_key}/#{id}@#{cache_version}"
+          end
+        else
+          digest = Digest::MD5.hexdigest(paramaterize_cache_includes(includes))
+          if cache_versioning
+            "#{model_name.cache_key}/#{id}+#{digest}"
+          else
+            "#{model_name.cache_key}/#{id}+#{digest}@#{cache_version(includes)}"
+          end
+        end
+      end
+
+      def cache_key_with_version(*includes)
+        if version = cache_version(*includes)
+          "#{cache_key(*includes)}-#{version}"
+        else
+          cache_key(*includes)
+        end
+      end
+
+      def cache_version(*includes)
+        timestamp = if includes.empty?
+          try(:cached_at) || try(:cached_at)
         else
           timestamp_keys = ['cached_at'] + self.class.cached_at_columns_for_includes(includes)
-          timestamp = max_updated_column_timestamp(timestamp_keys).utc.to_s(cache_timestamp_format)
-          digest ||= Digest::MD5.new()
-          digest << paramaterize_cache_includes(includes)
-          "#{model_name.cache_key}/#{id}+#{digest.hexdigest}@#{timestamp}"
+          timestamp = timestamp_keys.map { |attr| self[attr]&.to_time }.compact.max
         end
+        
+        timestamp.utc.to_s(:usec)
       end
 
       # TODO
@@ -84,4 +108,4 @@ module CachedAt
   end
 end
 
-ActiveRecord::Base.include(CachedAt::Base::Helpers)
+ActiveRecord::Base.include(CachedAt::Base::Helpers)

data/lib/cached_at/reflections/abstract_reflection.rb

@@ -1,30 +1,42 @@
 module CachedAt
   module AbstractReflection
   
-    def through_relationship_endpoints
-      return @through_relationship_endpoints if instance_variable_defined?(:@through_relationship_endpoints)
-    
-      @through_relationship_endpoints = []
-      active_record.reflections.each do |name, r|
-        next if r == self
-        begin
-          if r.polymorphic?
-            # TODO
-          else
-            r.klass.reflections.each do |name2, r2|
-              if r2.options[:cached_at] && r2.options[:through] && r2.options[:through] == r.inverse_of&.name
-                @through_relationship_endpoints << r2
-              end
-            end
-          end
-        rescue NameError
-        end
+    def cache_through_relationship_endpoints
+      if defined?(Rails)
+        Rails.application.config.cache_classes
+      else
+        true
       end
+    end
     
+    def through_relationship_endpoints
+      return @through_relationship_endpoints if instance_variable_defined?(:@through_relationship_endpoints) && cache_through_relationship_endpoints
+
+      @through_relationship_endpoints = if defined?(Rails)
+        Rails.application.reloader.wrap { calculate_through_relationship_endpoints }
+      else
+        calculate_through_relationship_endpoints
+      end
+
       @through_relationship_endpoints
     end
   
+    def calculate_through_relationship_endpoints
+      endpoints = []
+      
+      if self.polymorphic?
+      else
+        self.klass._reflections.each do |name, r|
+          if r.options[:cached_at] && r.options[:through] && r.options[:through] == self.inverse_of&.name
+            endpoints << r
+          end
+        end
+      end
+
+      endpoints
+    end
+    
   end
 end
 
-ActiveRecord::Reflection::AbstractReflection.include(CachedAt::AbstractReflection)
+ActiveRecord::Reflection::AbstractReflection.include(CachedAt::AbstractReflection)

data/lib/cached_at/timestamp.rb

@@ -1,15 +1,22 @@
 module ActiveRecord
-  module Timestamp
-
-    private
+  module CachedAt
+    module Timestamp
+      extend ActiveSupport::Concern
+      
+      class_methods do
+        private
     
-    def timestamp_attributes_for_update
-      [:updated_at, :cached_at]
-    end
+        def timestamp_attributes_for_update
+          ['updated_at']
+        end
+
+        def timestamp_attributes_for_create
+          ['created_at', 'udpated_at', 'cached_at'] + column_names.select{|c| c.end_with?('_cached_at') }
+        end
 
-    def timestamp_attributes_for_create
-      [:created_at, :udpated_at, :cached_at] + self.class.column_names.select{|c| c.end_with?('_cached_at') }.map(&:to_sym)
+      end
     end
-    
   end
-end
+end
+
+ActiveRecord::Base.include(ActiveRecord::CachedAt::Timestamp)

data/lib/cached_at/version.rb

@@ -1,3 +1,3 @@
 module CachedAt
-  VERSION = '2.0.12'
+  VERSION = '6.0.0'
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-cached_at
 version: !ruby/object:Gem::Version
-  version: 2.0.12
+  version: 6.0.0
 platform: ruby
 authors:
 - Jon Bracy
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-01-11 00:00:00.000000000 Z
+date: 2020-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 5.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 5.2.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -139,6 +139,7 @@ files:
 - lib/cached_at/associations/association.rb
 - lib/cached_at/associations/belongs_to_association.rb
 - lib/cached_at/associations/collection_association.rb
+- lib/cached_at/associations/collection_proxy.rb
 - lib/cached_at/associations/has_many_through_association.rb
 - lib/cached_at/associations/has_one_association.rb
 - lib/cached_at/base.rb
@@ -152,7 +153,7 @@ homepage: https://github.com/malomalo/activerecord-cached_at
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -169,9 +170,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Allows ActiveRecord and Rails to use a `cached_at` column for the `cache_key`
   if available