support_table_data 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6aa6d124e04e60a539f6a56207da866bb6aa0d277484104f6685d9499b41d504
-  data.tar.gz: f3c9791bf9e6b2a46416cca2a154abdb1fe18e108f3e386670818939cabac1a2
+  metadata.gz: 7e8cc498db34d48c4547f0c076553eb1c087b198d9b76d467558bcfd9a5249f7
+  data.tar.gz: 38b94d4df77e5b75ed7b24c0e21f129d37f1a3a07cf6cc6ce515c537743cc45b
 SHA512:
-  metadata.gz: cec5bdca6906dac42489e2f43798bf647eebaf6fd1df1d314bb259cf46170c6f7833aeccd7f7d59917ea0406699f6cc99905afc5977bd907c1e19f750dc0b3e5
-  data.tar.gz: eb748280d59753b9bde5618900d0f25ae8e01c3ace0a37cdb5021cad1f1751832b14cc6e4bd624b200398178cd8bd3636e5d8d128c829180fe3c547d67ac88db
+  metadata.gz: d64e26277408f30222ad135a317172cf0d2ae288bcfdc4c7b8a4113b52f9477d4cb2e0536b9feacdcdeb9af3044c0220c6b16131dee18f468455c2260b305979
+  data.tar.gz: df40bb09b9688ac653f8e590fff81d50d4d9cf18d3b3c797d6f28e02603c0fe7a1375b8426ad3df75392fba51cc4b24e8973c52bf8994011542741c11a067444

data/CHANGELOG.md

@@ -4,6 +4,41 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.7.0
+
+### Fixed
+
+- `sync_table_data!` now retries once on `ActiveRecord::RecordNotUnique` errors caused by a concurrent sync in another process inserting the same rows.
+- `sync_table_data!` with `delete_missing: true` now raises an `ArgumentError` instead of deleting every row in the table when the data files contain no rows.
+- `sync_table_data!` now raises an `ArgumentError` when a data file row has no value for the key attribute. Previously such rows were collapsed into a single record with a blank key.
+- `sync_table_data!` now returns an empty array instead of `nil` when the table does not exist.
+- Fixed broken cycle detection in the autosave association check during syncs that could cause infinite recursion on cyclic autosave associations.
+- Syncing a single table inheritance subclass no longer inserts duplicate or wrongly typed rows for records defined in the base class' data files. Existing rows are matched without the inheritance type condition, and new rows default to the type of the class whose data file defines them.
+- Single table inheritance subclasses now share the support table state defined on their base class regardless of load order. Previously class methods like `instance_names` and `protected_instance?` raised `NoMethodError` and named instance helpers could be missing on subclasses.
+- `protected_instance?` and `instance_keys` now include data files added to single table inheritance subclasses and no longer return stale results when data files are added after their values were first computed.
+- `sync_table_data!` with `delete_missing: true` no longer deletes rows that are managed by data files added to single table inheritance subclasses.
+- Records are now merged in strict data file order, so later files take precedence even when named instance files are mixed with list format files.
+- Data files that override attributes on a named instance are now merged by the instance name rather than only by the key attribute. Previously an override that did not repeat the key attribute value was treated as a new record and inserted as an extra row on every sync.
+- Named instance helper methods and `named_instance_data` now return the merged values that are synced to the database. Previously the helpers permanently returned the values from the first file that defined the named instance.
+- Entries under a name beginning with an underscore are treated as anonymous records even when the value is a single hash. Previously two files reusing the same underscore name each with a single hash were merged into one record, silently dropping rows.
+- YAML data files can now use anchors/aliases and date/time values. Previously these raised `Psych::AliasesNotEnabled` or `Psych::DisallowedClass` errors.
+- Generated predicate methods (e.g. `record.active?`) now cast the data file value to the attribute type before comparing, so they no longer silently return `false` when the types differ (always the case for CSV data files, where all values are strings).
+- `named_instance` now raises an `ActiveRecord::RecordNotFound` error for undefined named instances instead of querying the database for a `nil` key.
+- `named_instance_attribute_helpers` can now be called again with an attribute that was already registered without raising an `ArgumentError`.
+- Modifications to memoized class-level state are now synchronized to avoid races on Ruby implementations without a global interpreter lock.
+- Setting `config.support_table.auto_sync = false` before the gem is loaded is no longer overwritten back to `true` by the Railtie.
+- Data file names containing extra dots no longer break the class name detection used by `SupportTableData.sync_all!` to eager load models.
+- Error messages for invalid named instance definitions now include the model class name instead of repeating the instance name.
+- The `:compact` YARD format now emits macros that YARD can actually expand. Previously the generated docs resolved to methods with no description, `@return`, or `@raise` tags and documented the predicate methods as class methods. Macro names are also namespaced per class so models do not overwrite each other's macros.
+- The documentation tasks now remove duplicated generated YARD doc blocks (e.g. left over from a bad merge) instead of corrupting the model source file.
+- The documentation tasks no longer report success when a model raises an `ArgumentError` for an invalid named instance definition.
+
+## 1.6.1
+
+### Fixed
+
+- Fixed issue with YARD and RBS documentation tasks possibly raising an error if a named value method is deprecated and wrapped to return an error. Types are now inferred directly from the data rather than calling a method.
+
 ## 1.6.0
 
 ### Added

data/README.md

@@ -68,6 +68,8 @@ class Status < ApplicationRecord
 
 You cannot update the value of the key attribute in a record in the data file. If you do, a new record will be created and the existing record will be left unchanged.
 
+When you add multiple data files, records defined in more than one file are merged together, with later files taking precedence. Records in files defined as a hash of named instances are matched by the instance name, so an override file only needs to specify the attributes it is changing. Records in files defined as a list are matched by the key attribute value, which must be repeated in each file.
+
 You can specify data files as relative paths. This can be done by setting the `SupportTableData.data_directory` value. You can override this value for a model by setting the `support_table_data_directory` attribute on its class. Otherwise, relative file paths will be resolved from the current working directory. You must define the directory to load relative files from before loading your model classes.
 
 In a Rails application, `SupportTableData.data_directory` will be automatically set to `db/support_tables/`. This can be overridden by setting the `config.support_table.data_directory` option in the Rails application configuration.
@@ -203,7 +205,7 @@ A good practice is to add a check to your CI pipeline to ensure the documentatio
 Each model can choose how its YARD docs are generated by setting `support_table_yard_docs` to one of three values:
 
 - `:full` — verbose comment block per generated method (the default)
-- `:compact` — shared `@!macro` definitions at the top of the documentation block plus a short `@!method` / `@!macro` pair per generated method. IDEs and `yard doc` resolve the macros into the same per-method documentation as `:full`. Useful when a model has many named instances and the verbose comment block is too long to be useful inline.
+- `:compact` — shared `@!macro` definitions plus a short comment block per generated method that expands them. YARD resolves it to exactly the same methods and return types as `:full`. Useful when a model has many named instances and the verbose comment block is too long to be useful inline.
 - `:none` — generate no YARD docs for this model. The rake task will also strip any previously generated YARD docs from the source file.
 
 ```ruby
@@ -279,6 +281,12 @@ SupportTableData.sync_all!(delete_missing: true)
 > [!CAUTION]
 > Use `delete_missing` with care. It will delete any records in the table that are not defined in the data files, which may include user-created data or fail due to foreign key constraints.
 
+As a safeguard, `sync_table_data!` will raise an `ArgumentError` rather than delete anything when `delete_missing` is enabled but the data files contain no rows (for instance, when a data file was accidentally emptied or truncated).
+
+Rows managed by data files added to a single table inheritance subclass are never deleted by a sync on the base class, even if the subclass has not been loaded yet. Each candidate row is resolved to its own class through the inheritance column before it is deleted, so the subclass is loaded on demand and gets to declare which rows it owns.
+
+It is recommended to add a unique database index on the key attribute column. Concurrent syncs from multiple processes (for example, parallel deployment jobs) could otherwise insert duplicate rows. If a sync hits a uniqueness violation from a concurrent insert, it will automatically retry once to pick up the other process' changes.
+
 The number of records contained in data files should be fairly small (ideally fewer than 100). It is possible to load just a subset of rows in a large table because only the rows listed in the data files will be synced. You can use this feature if your table allows user-entered data, but has a few rows that must exist for the code to work.
 
 Loading data is done inside a database transaction. No changes will be persisted to the database unless all rows for a model can be synced.

data/VERSION

@@ -1 +1 @@
-1.6.0
+1.7.0

data/lib/support_table_data/documentation/rbs_doc.rb

@@ -42,7 +42,7 @@ module SupportTableData
         lines << "def self.#{name}: () -> #{klass.name}"
         lines << "def #{name}?: () -> bool"
         klass.support_table_attribute_helpers.each do |attribute_name|
-          return_type = TypeInference.rbs_type(TypeInference.value_type(klass, "#{name}_#{attribute_name}"))
+          return_type = TypeInference.rbs_type(TypeInference.value_type(klass, name, attribute_name))
           lines << "def self.#{name}_#{attribute_name}: () -> #{return_type}"
         end
         lines

data/lib/support_table_data/documentation/source_file.rb

@@ -7,7 +7,7 @@ module SupportTableData
 
       BEGIN_YARD_COMMENT = "# Begin YARD docs for support_table_data"
       END_YARD_COMMENT = "# End YARD docs for support_table_data"
-      YARD_COMMENT_REGEX = /^(?<indent>[ \t]*)#{BEGIN_YARD_COMMENT}.*^[ \t]*#{END_YARD_COMMENT}$/m
+      YARD_COMMENT_REGEX = /^(?<indent>[ \t]*)#{BEGIN_YARD_COMMENT}.*?^[ \t]*#{END_YARD_COMMENT}$/m
       CLASS_DEF_REGEX = /^[ \t]*class [a-zA-Z_0-9:]+.*?$/
       UPDATE_COMMAND_COMMENT = "# To update these docs, run `bundle exec rake support_table_data:yard_docs`"
 
@@ -32,7 +32,7 @@ module SupportTableData
       #
       # @return [String]
       def source_without_yard_docs
-        "#{source.sub(YARD_COMMENT_REGEX, "").rstrip}#{trailing_newline}"
+        "#{source.gsub(YARD_COMMENT_REGEX, "").rstrip}#{trailing_newline}"
       end
 
       # Return the source code with the generated YARD documentation added.
@@ -63,8 +63,19 @@ module SupportTableData
           updated_source << "\n#{indent}end" if has_class_def
           updated_source << "\n#{indent}# rubocop:enable all"
           updated_source << "\n#{indent}#{END_YARD_COMMENT}"
-          updated_source << source[existing_yard_docs.end(0)..-1]
-          updated_source
+          # Strip out any duplicate generated blocks (i.e. left over from a bad merge)
+          # so that the file is left with exactly one block. Otherwise the tail of the
+          # file is preserved verbatim so that a file whose docs are already up to date
+          # compares byte for byte with its own source.
+          tail = source[existing_yard_docs.end(0)..]
+          deduped_tail = tail.gsub(YARD_COMMENT_REGEX, "")
+          if deduped_tail == tail
+            updated_source << tail
+            updated_source
+          else
+            updated_source << deduped_tail
+            "#{updated_source.rstrip}#{trailing_newline}"
+          end
         else
           yard_comments = <<~SOURCE.chomp("\n")
             #{BEGIN_YARD_COMMENT}

data/lib/support_table_data/documentation/type_inference.rb

@@ -3,26 +3,28 @@
 module SupportTableData
   module Documentation
     # Infers documentation types for the dynamically-defined attribute helpers
-    # by calling the generated method and inspecting the class of the value
-    # it returns. The values returned by these helpers are frozen literals from
-    # the parsed data file, so this does not require a database connection.
-    #
-    # This module must not be used on finder helpers (e.g. `Color.red`), which
-    # call `find_by!` and would hit the database.
+    # by reading the canonical value out of the parsed data file and
+    # inspecting its class. This avoids invoking the generated method, which
+    # may have been wrapped (e.g. deprecated) to raise.
     module TypeInference
       module_function
 
-      # Determine the documentation type for an attribute helper by calling
-      # the method and looking at the class of the returned value. Returns
-      # nil when the method is not defined.
+      # Determine the documentation type for a named-instance attribute
+      # helper by looking up the attribute value in the model's named
+      # instance data and returning its class. Returns nil when the
+      # attribute is not defined for the named instance.
       #
       # @param klass [Class] The model class
-      # @param method_name [String, Symbol] The class method name to call
+      # @param name [String, Symbol] The named instance name
+      # @param attribute_name [String, Symbol] The attribute name
       # @return [Class, nil]
-      def value_type(klass, method_name)
-        return nil unless klass.respond_to?(method_name)
+      def value_type(klass, name, attribute_name)
+        return nil unless klass.respond_to?(:named_instance_data)
 
-        klass.public_send(method_name).class
+        data = klass.named_instance_data(name)
+        return nil unless data.is_a?(Hash) && data.key?(attribute_name.to_s)
+
+        data[attribute_name.to_s].class
       end
 
       # Map a Ruby value class to a YARD type string.

data/lib/support_table_data/documentation/yard_doc.rb

@@ -3,10 +3,6 @@
 module SupportTableData
   module Documentation
     class YardDoc
-      MACRO_FINDER = "support_table_data_finder"
-      MACRO_PREDICATE = "support_table_data_predicate"
-      MACRO_ATTRIBUTE = "support_table_data_attribute"
-
       # @param klass [Class] The model class to generate documentation for
       def initialize(klass)
         @klass = klass
@@ -16,8 +12,8 @@ module SupportTableData
       # is controlled by the model's `support_table_yard_docs` setting:
       #
       # * `:full`    - verbose comment block per method (default)
-      # * `:compact` - shared @!macro definitions plus a short @!method/@!macro
-      #                pair per generated method
+      # * `:compact` - shared @!macro definitions plus a short comment block
+      #                per method that expands them
       # * `:none`    - generate no docs at all
       #
       # @return [String, nil] The YARD documentation, or nil if no docs should
@@ -107,16 +103,27 @@ module SupportTableData
         yard_lines.join("\n")
       end
 
+      # The compact format defines the shared documentation once as macros and expands
+      # them under each generated method. YARD imposes three rules on this layout: each
+      # method needs its own comment block (tags and the `self.` scope apply to the whole
+      # block), a macro invocation must be indented under its @!method line to attach to
+      # that method, and macro parameters ($1, etc.) cannot be used because YARD only
+      # fills them in from real method calls in the source. Macro names are global to the
+      # YARD registry, so they are namespaced with the class name.
       def generate_compact_yard_docs(instance_names)
         yard_lines = ["# @!group Named Instances"]
         yard_lines << ""
-        yard_lines << compact_preamble
-        yard_lines << ""
         yard_lines << compact_macro_definitions
 
         instance_names.sort.each do |name|
           yard_lines << ""
-          yard_lines << compact_instance_block(name)
+          yard_lines << compact_instance_helper_yard_doc(name)
+          yard_lines << ""
+          yard_lines << compact_predicate_helper_yard_doc(name)
+          klass.support_table_attribute_helpers.each do |attribute_name|
+            yard_lines << ""
+            yard_lines << compact_attribute_helper_yard_doc(name, attribute_name)
+          end
         end
 
         yard_lines << ""
@@ -125,57 +132,67 @@ module SupportTableData
         yard_lines.join("\n")
       end
 
-      def compact_preamble
-        <<~YARD.chomp("\n")
-          # The methods in this group are dynamically defined by support_table_data
-          # for each named instance in the data file. The macros below are the
-          # documentation templates; the per-instance @!method lines that follow
-          # invoke them with the instance name (and attribute name, where applicable).
-        YARD
-      end
-
       def compact_macro_definitions
-        attribute_macro = <<~YARD.chomp("\n")
-          # @!macro [new] #{MACRO_ATTRIBUTE}
-          #   Get the +$2+ attribute from the data file for the named instance +$1+.
-          #   @return [$3]
-          #   @!visibility public
-        YARD
-
         finder_macro = <<~YARD.chomp("\n")
-          # @!macro [new] #{MACRO_FINDER}
-          #   Find the named instance +$1+ from the database.
+          # @!macro [new] #{compact_macro_name("finder")}
+          #   Find this named instance from the database.
           #   @return [#{klass.name}]
           #   @raise [ActiveRecord::RecordNotFound] if the record does not exist
           #   @!visibility public
         YARD
 
         predicate_macro = <<~YARD.chomp("\n")
-          # @!macro [new] #{MACRO_PREDICATE}
-          #   Check if this record is the named instance +$1+.
+          # @!macro [new] #{compact_macro_name("predicate")}
+          #   Check if this record is this named instance.
           #   @return [Boolean]
           #   @!visibility public
         YARD
 
-        [finder_macro, "", predicate_macro, "", attribute_macro].join("\n")
-      end
+        macros = [finder_macro, "", predicate_macro]
 
-      def compact_instance_block(name)
-        lines = []
-        lines << "# @!method self.#{name}"
-        lines << "# @!macro #{MACRO_FINDER} #{name}"
-        lines << "# @!method #{name}?"
-        lines << "# @!macro #{MACRO_PREDICATE} #{name}"
-        klass.support_table_attribute_helpers.each do |attribute_name|
-          return_type = attribute_yard_return_type(name, attribute_name)
-          lines << "# @!method self.#{name}_#{attribute_name}"
-          lines << "# @!macro #{MACRO_ATTRIBUTE} #{name} #{attribute_name} #{return_type}"
+        if klass.support_table_attribute_helpers.any?
+          attribute_macro = <<~YARD.chomp("\n")
+            # @!macro [new] #{compact_macro_name("attribute")}
+            #   Get this attribute from the data file for this named instance.
+            #   @!visibility public
+          YARD
+          macros << ""
+          macros << attribute_macro
         end
-        lines.join("\n")
+
+        macros.join("\n")
+      end
+
+      def compact_instance_helper_yard_doc(name)
+        <<~YARD.chomp("\n")
+          # @!method self.#{name}
+          #   @!macro #{compact_macro_name("finder")}
+        YARD
+      end
+
+      def compact_predicate_helper_yard_doc(name)
+        <<~YARD.chomp("\n")
+          # @!method #{name}?
+          #   @!macro #{compact_macro_name("predicate")}
+        YARD
+      end
+
+      # The attribute macro cannot carry the @return tag because the return type differs
+      # per method, so each attribute method adds its own.
+      def compact_attribute_helper_yard_doc(name, attribute_name)
+        <<~YARD.chomp("\n")
+          # @!method self.#{name}_#{attribute_name}
+          #   @!macro #{compact_macro_name("attribute")}
+          #   @return [#{attribute_yard_return_type(name, attribute_name)}]
+        YARD
+      end
+
+      def compact_macro_name(suffix)
+        "support_table_#{klass.name.underscore.tr("/", "_")}_#{suffix}"
       end
 
       def attribute_yard_return_type(name, attribute_name)
-        TypeInference.yard_type(TypeInference.value_type(klass, "#{name}_#{attribute_name}"))
+        TypeInference.yard_type(TypeInference.value_type(klass, name, attribute_name))
       end
     end
   end

data/lib/support_table_data/railtie.rb

@@ -7,7 +7,7 @@ module SupportTableData
     end
 
     config.support_table.data_directory ||= "db/support_tables"
-    config.support_table.auto_sync ||= true
+    config.support_table.auto_sync = true if config.support_table.auto_sync.nil?
 
     initializer "support_table_data" do |app|
       SupportTableData.data_directory ||= app.root.join(app.config.support_table&.data_directory).to_s

data/lib/support_table_data/tasks/utils.rb

@@ -23,20 +23,20 @@ module SupportTableData
         # @param file_path [String, Pathname, nil] Optional file path to filter by.
         # @return [Array<SupportTableData::Documentation::SourceFile>]
         def support_table_sources(file_path = nil)
-          file_path = Pathname.new(file_path) if file_path.is_a?(String)
-          require file_path.expand_path if file_path
+          resolved_path = expand_file_path(file_path)
+          return [] if file_path && resolved_path.nil?
+
+          require resolved_path.to_s if resolved_path
 
           sources = []
 
           ActiveRecord::Base.descendants.each do |klass|
             next unless klass.include?(SupportTableData)
-
-            begin
-              next if klass.instance_names.empty?
-            rescue NoMethodError
-              # Skip models where instance_names is not properly initialized
-              next
-            end
+            # Only the class that added the data files is documented. Single table inheritance
+            # subclasses that don't add their own data files inherit the helper methods and
+            # would otherwise duplicate the base class documentation.
+            next unless klass.instance_variable_defined?(:@support_table_data_files)
+            next if klass.instance_names.empty?
 
             model_file_path = SupportTableData::Tasks::Utils.model_file_path(klass)
             next unless model_file_path&.file? && model_file_path.readable?
@@ -44,12 +44,9 @@ module SupportTableData
             sources << Documentation::SourceFile.new(klass, model_file_path)
           end
 
-          return sources if file_path.nil?
+          return sources if resolved_path.nil?
 
-          resolved_path = Pathname.new(file_path.to_s).expand_path
           sources.select { |source| source.path.expand_path == resolved_path }
-        rescue ArgumentError
-          []
         end
 
         # Return RBS file handlers for all support table models.
@@ -62,7 +59,21 @@ module SupportTableData
           end
         end
 
+        # Expand a file path argument to an absolute path.
+        #
+        # @param file_path [String, Pathname, nil]
+        # @return [Pathname, nil] nil if no path was given or it cannot be expanded.
+        def expand_file_path(file_path)
+          return nil if file_path.nil?
+
+          Pathname.new(file_path.to_s).expand_path
+        rescue ArgumentError
+          nil
+        end
+
         def model_file_path(klass)
+          return nil unless klass.name
+
           file_path = "#{klass.name.underscore}.rb"
           model_path = nil
 

data/lib/support_table_data.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/module/redefine_method"
+require "concurrent/map"
+
 # This concern can be mixed into models that represent static support tables. These are small tables
 # that have a limited number of rows, and have values that are often tied to the logic in the code.
 #
@@ -19,7 +22,7 @@ module SupportTableData
 
   included do
     # Internal variables used for memoization.
-    @mutex = Mutex.new
+    @support_table_mutex = Mutex.new
     @support_table_data_files = []
     @support_table_attribute_helpers = {}
     @support_table_instance_names = {}
@@ -67,8 +70,8 @@ module SupportTableData
     # Get the YARD documentation mode for this model. One of:
     #
     # * `:full`    - emit a verbose comment block per generated method (default)
-    # * `:compact` - emit shared @!macro definitions plus a short
-    #                @!method/@!macro pair per generated method
+    # * `:compact` - emit shared @!macro definitions plus a short comment
+    #                block per generated method that expands them
     # * `:none`    - generate no YARD docs for this model; the rake task will
     #                strip any existing generated YARD docs
     #
@@ -97,55 +100,84 @@ module SupportTableData
     #   files will be deleted. Use with caution.
     # @return [Array<Hash>] List of saved changes for each record that was created or modified.
     def sync_table_data!(delete_missing: false)
-      return unless table_exists?
-
-      canonical_data = support_table_data.each_with_object({}) do |attributes, hash|
-        hash[attributes[support_table_key_attribute].to_s] = attributes
-      end
-      records = where(support_table_key_attribute => canonical_data.keys)
-      changes = []
-
-      begin
-        ActiveSupport::Notifications.instrument("support_table_data.sync", class: self) do
-          synced_ids = []
-
-          transaction do
-            records.each do |record|
-              key = record[support_table_key_attribute].to_s
-              attributes = canonical_data.delete(key)
-              attributes&.each do |name, value|
-                record.send(:"#{name}=", value) if record.respond_to?(:"#{name}=", true)
-              end
-              if support_table_record_changed?(record)
-                changes << record.changes
-                record.save!
-              end
-
-              synced_ids << record.id if attributes
-            end
+      return [] unless table_exists?
+
+      retried = false
+
+      # The instrumentation wraps the retry so that one call emits one event even if the
+      # sync has to be attempted twice.
+      ActiveSupport::Notifications.instrument("support_table_data.sync", class: self) do
+        canonical_data = support_table_data.each_with_object({}) do |attributes, hash|
+          hash[attributes[support_table_key_attribute].to_s] = attributes
+        end
+
+        if canonical_data.include?("")
+          raise ArgumentError.new("Cannot sync #{name} because the data files contain a row with no value for the key attribute #{support_table_key_attribute}")
+        end
 
-            canonical_data.each_value do |attributes|
-              class_name = attributes[inheritance_column]
-              klass = class_name ? sti_class_for(class_name) : self
-              record = klass.new
-              attributes.each do |name, value|
-                record.send(:"#{name}=", value) if record.respond_to?(:"#{name}=", true)
-              end
+        if delete_missing && canonical_data.empty? && exists?
+          raise ArgumentError.new("Refusing to sync #{name} with delete_missing enabled because the data files contain no rows; this would delete every row in the table")
+        end
+
+        # Rows are matched on the key attribute alone, so the lookup must not be scoped
+        # to this class's single table inheritance type. A subclass syncing rows from
+        # inherited data files has to find them no matter what type they currently have
+        # or it would insert duplicates.
+        scope = finder_needs_type_condition? ? base_class : self
+        records = scope.where(support_table_key_attribute => canonical_data.keys)
+
+        # New rows default to the type of the class whose data files define them so that
+        # a subclass syncing inherited files does not create them with its own type.
+        record_classes = support_table_record_classes
+
+        changes = []
+        synced_ids = []
+
+        transaction do
+          records.each do |record|
+            key = record[support_table_key_attribute].to_s
+            attributes = canonical_data.delete(key)
+            attributes&.each do |name, value|
+              record.send(:"#{name}=", value) if record.respond_to?(:"#{name}=", true)
+            end
+            if support_table_record_changed?(record)
               changes << record.changes
               record.save!
-              synced_ids << record.id
             end
 
-            if delete_missing
-              where.not(primary_key => synced_ids).destroy_all
+            synced_ids << record.id if attributes
+          end
+
+          canonical_data.each_value do |attributes|
+            class_name = attributes[inheritance_column]
+            klass = if class_name
+              sti_class_for(class_name)
+            else
+              record_classes[attributes[support_table_key_attribute].to_s] || self
             end
+            record = klass.new
+            attributes.each do |name, value|
+              record.send(:"#{name}=", value) if record.respond_to?(:"#{name}=", true)
+            end
+            changes << record.changes
+            record.save!
+            synced_ids << record.id
           end
+
+          delete_missing_records(where.not(primary_key => synced_ids)) if delete_missing
         end
+
+        changes
       rescue ActiveRecord::RecordInvalid => e
         raise SupportTableData::ValidationError.new(e.record)
-      end
+      rescue ActiveRecord::RecordNotUnique
+        # A concurrent sync from another process may have inserted the same rows.
+        # The transaction was rolled back, so retry once to pick up those rows.
+        raise if retried
 
-      changes
+        retried = true
+        retry
+      end
     end
 
     # Add a data file that contains the support table data. This method can be called multiple times to
@@ -156,10 +188,12 @@ module SupportTableData
     #   this model or the global directory set with SupportTableData.data_directory.
     # @return [void]
     def add_support_table_data(data_file_path)
-      root_dir = (support_table_data_directory || SupportTableData.data_directory || Dir.pwd)
-      @mutex.synchronize do
-        @support_table_data_files += [File.expand_path(data_file_path, root_dir)]
-        @support_table_instance_keys = nil
+      root_dir = support_table_data_directory || SupportTableData.data_directory || Dir.pwd
+      support_table_mutex.synchronize do
+        # Only the files added directly to this class are stored on it. Files added to a
+        # base class are composed in at read time so a single table inheritance subclass
+        # sees files the base class adds later, no matter the order the classes set up in.
+        @support_table_data_files = (@support_table_data_files || []) + [File.expand_path(data_file_path, root_dir)]
       end
       define_support_table_named_instances
     end
@@ -172,8 +206,15 @@ module SupportTableData
     # @param attributes [String, Symbol] The names of the attributes to add helper methods for.
     # @return [void]
     def named_instance_attribute_helpers(*attributes)
-      @mutex.synchronize do
+      support_table_mutex.synchronize do
+        # Single table inheritance subclasses read the map from their base class. Copy it
+        # (including the lists of method names that have been defined) the first time a
+        # subclass registers its own helpers so the two classes don't mutate each other's state.
+        @support_table_attribute_helpers ||= support_table_attribute_helpers_map.transform_values(&:dup)
+
         attributes.flatten.collect(&:to_s).each do |attribute|
+          next if @support_table_attribute_helpers.include?(attribute)
+
           @support_table_attribute_helpers = @support_table_attribute_helpers.merge(attribute => [])
         end
       end
@@ -185,59 +226,37 @@ module SupportTableData
     #
     # @return [Array<String>] List of attribute names.
     def support_table_attribute_helpers
-      @support_table_attribute_helpers.keys
+      support_table_attribute_helpers_map.keys
     end
 
     # Get the data for the support table from the data files.
     #
     # @return [Array<Hash>] List of attributes for all records in the data files.
     def support_table_data
-      data = {}
-      @support_table_data_files.each do |data_file_path|
-        file_data = support_table_parse_data_file(data_file_path)
-        file_data = file_data.values if file_data.is_a?(Hash)
-        file_data = Array(file_data).flatten
-        file_data.each do |attributes|
-          key_value = attributes[support_table_key_attribute].to_s
-          existing = data[key_value]
-          if existing
-            existing.merge!(attributes)
-          else
-            data[key_value] = attributes
-          end
-        end
-      end
+      support_table_data_for_files(support_table_data_files)
+    end
 
-      data.values
+    # Get the data for the support table from a specific list of data files.
+    #
+    # @param data_files [Array<String>] The paths of the data files to read.
+    # @return [Array<Hash>] List of attributes for all records in the data files.
+    # @api private
+    def support_table_data_for_files(data_files)
+      support_table_merged_records(data_files).first
     end
 
     # Get the data for a named instances from the data files.
     #
     # @return [Hasn] Hash of named instance attributes.
     def named_instance_data(name)
-      data = {}
-      name = name.to_s
-
-      @support_table_data_files.each do |data_file_path|
-        file_data = support_table_parse_data_file(data_file_path)
-        next unless file_data.is_a?(Hash)
-
-        file_data.each do |instance_name, attributes|
-          next unless name == instance_name.to_s
-          next unless attributes.is_a?(Hash)
-
-          data.merge!(attributes)
-        end
-      end
-
-      data
+      support_table_merged_records(support_table_data_files).last[name.to_s] || {}
     end
 
     # Get the names of all named instances.
     #
     # @return [Array<String>] List of all instance names.
     def instance_names
-      @support_table_instance_names.keys
+      support_table_instance_names_map.keys
     end
 
     # Load a named instance from the database.
@@ -247,36 +266,50 @@ module SupportTableData
     # @raise [ActiveRecord::RecordNotFound] If the instance does not exist.
     def named_instance(instance_name)
       instance_name = instance_name.to_s
-      find_by!(support_table_key_attribute => @support_table_instance_names[instance_name])
+      instances = support_table_instance_names_map
+      unless instances.include?(instance_name)
+        raise ActiveRecord::RecordNotFound.new("Couldn't find #{name} named instance #{instance_name.inspect}")
+      end
+
+      find_by!(support_table_key_attribute => instances[instance_name])
     end
 
-    # Get the key values for all instances loaded from the data files.
+    # Get the key values for all instances loaded from the data files. Data files added to
+    # single table inheritance subclasses are included since those rows live in this table too.
     #
     # @return [Array] List of all the key attribute values.
     def instance_keys
-      if @support_table_instance_keys.nil?
+      support_table_cached_data_value(:@support_table_instance_keys, support_table_data_files_with_descendants) do |data_files|
         values = []
-        support_table_data.each do |attributes|
+        support_table_data_for_files(data_files).each do |attributes|
           key_value = attributes[support_table_key_attribute]
           instance = new
           instance.send(:"#{support_table_key_attribute}=", key_value)
           values << instance.send(support_table_key_attribute)
         end
-        @support_table_instance_keys = values.uniq
+        values.uniq
       end
-      @support_table_instance_keys
     end
 
-    # Return true if the instance has data being managed from a data file.
+    # Return true if the instance has data being managed from a data file. Instances are matched
+    # on the key attribute only. Single table inheritance types are intentionally not considered
+    # when matching since syncing also matches existing rows on just the key attribute and will
+    # overwrite a row regardless of the type it currently has. Data files added to single table
+    # inheritance subclasses are included since those rows live in this table too.
     #
     # @return [Boolean]
     def protected_instance?(instance)
-      unless defined?(@protected_keys)
-        keys = support_table_data.collect { |attributes| attributes[support_table_key_attribute].to_s }
-        @protected_keys = keys
-      end
+      key = instance[support_table_key_attribute].to_s
+      return true if support_table_protected_keys.include?(key)
+
+      # The instance may be a single table inheritance subclass that had not been loaded yet
+      # when the keys for this class were calculated. Loading a row instantiates it as its own
+      # subclass, so the subclass can be asked directly rather than relying on it having been
+      # eager loaded before this point.
+      instance_class = instance.class
+      return false if instance_class == self || !instance_class.include?(SupportTableData)
 
-      @protected_keys.include?(instance[support_table_key_attribute].to_s)
+      instance_class.send(:support_table_protected_keys).include?(key)
     end
 
     # Explicitly define other support tables that this model depends on. A support table depends
@@ -290,22 +323,130 @@ module SupportTableData
     # @param class_names [String] List of class names that this support table depends on.
     # @return [void]
     def support_table_dependency(*class_names)
-      @support_table_dependencies += class_names.flatten.collect(&:to_s)
+      support_table_mutex.synchronize do
+        @support_table_dependencies = support_table_dependency_names + class_names.flatten.collect(&:to_s)
+      end
     end
 
     private
 
-    def define_support_table_named_instances
-      @support_table_data_files.each do |file_path|
-        data = support_table_parse_data_file(file_path)
-        next unless data.is_a?(Hash)
+    # Destroy the rows in a relation that are not managed from a data file.
+    #
+    # Rows managed by data files added to single table inheritance subclasses live in this
+    # table, but they are synced by the subclass, so they must not be deleted here. Loading a
+    # row instantiates it as its own subclass, which loads that class if it hasn't been loaded
+    # yet, so `protected_instance?` can consult the subclass directly without having to eager
+    # load the entire application first.
+    #
+    # @param relation [ActiveRecord::Relation] The rows that are candidates for deletion.
+    # @return [void]
+    def delete_missing_records(relation)
+      relation.find_each do |record|
+        next if protected_instance?(record)
+
+        record.destroy
+      end
+    end
+
+    # The key attribute values of every row managed from this class' data files, including
+    # data files added to single table inheritance subclasses that have already been loaded.
+    #
+    # @return [Array<String>]
+    def support_table_protected_keys
+      support_table_cached_data_value(:@support_table_protected_keys, support_table_data_files_with_descendants) do |data_files|
+        support_table_data_for_files(data_files).collect { |attributes| attributes[support_table_key_attribute].to_s }
+      end
+    end
+
+    # Parse the data files and merge the records they define. Files are processed in
+    # order so that later files take precedence no matter how each file is structured.
+    # Records are matched both by their instance name and by their key attribute value.
+    # Entry names that begin with an underscore do not define named instances; their
+    # values hold anonymous records identified only by the key attribute.
+    #
+    # @param data_files [Array<String>] The paths of the data files to read.
+    # @return [Array(Array<Hash>, Hash<String, Hash>)] The ordered list of merged records
+    #   and the named instance records by name.
+    def support_table_merged_records(data_files)
+      records = []
+      named_records = {}
+      keyed_records = {}
+
+      merge_record = lambda do |attributes, instance_name|
+        record = named_records[instance_name] if instance_name
+        if record.nil? && (instance_name.nil? || attributes.include?(support_table_key_attribute))
+          record = keyed_records[attributes[support_table_key_attribute].to_s]
+        end
+
+        if record
+          record.merge!(attributes)
+        else
+          record = attributes.dup
+          records << record
+        end
 
-        data.each do |name, attributes|
-          @mutex.synchronize do
-            define_support_table_named_instance_methods(name, attributes)
+        named_records[instance_name] = record if instance_name
+        keyed_records[record[support_table_key_attribute].to_s] = record
+      end
+
+      data_files.each do |data_file_path|
+        file_data = support_table_parse_data_file(data_file_path)
+
+        unless file_data.is_a?(Hash)
+          Array(file_data).flatten.each { |attributes| merge_record.call(attributes, nil) }
+          next
+        end
+
+        file_data.each do |instance_name, attributes|
+          instance_name = instance_name.to_s
+          if instance_name.start_with?("_")
+            anonymous_records = attributes.is_a?(Hash) ? [attributes] : Array(attributes).flatten
+            anonymous_records.each { |record_attributes| merge_record.call(record_attributes, nil) }
+          elsif attributes.is_a?(Hash)
+            merge_record.call(attributes, instance_name)
+          else
+            raise ArgumentError.new("Cannot define named instance #{instance_name} on #{name}; value must be a Hash")
           end
         end
       end
+
+      [records, named_records]
+    end
+
+    # The classes in the hierarchy that added their own data files, listed base class
+    # first, along with the file paths each one added.
+    #
+    # @return [Array<Array(Class, Array<String>)>]
+    def support_table_data_file_owners
+      owners = superclass.include?(SupportTableData) ? superclass.send(:support_table_data_file_owners) : []
+      own_files = @support_table_data_files
+      owners += [[self, own_files]] if own_files && !own_files.empty?
+      owners
+    end
+
+    # Map each record's key attribute value to the class in the hierarchy whose own data
+    # files define it. Used to determine the single table inheritance type for new rows
+    # that do not specify one in the data files.
+    #
+    # @return [Hash<String, Class>]
+    def support_table_record_classes
+      record_classes = {}
+      support_table_data_file_owners.each do |owner, files|
+        next if owner == self
+
+        support_table_data_for_files(files).each do |attributes|
+          record_classes[attributes[support_table_key_attribute].to_s] ||= owner
+        end
+      end
+      record_classes
+    end
+
+    def define_support_table_named_instances
+      support_table_merged_records(support_table_data_files).last.each do |name, attributes|
+        support_table_mutex.synchronize do
+          define_support_table_named_instance_methods(name, attributes)
+        end
+      end
     end
 
     def define_support_table_named_instance_methods(name, attributes)
@@ -313,64 +454,101 @@ module SupportTableData
       return if method_name.start_with?("_")
 
       unless attributes.is_a?(Hash)
-        raise ArgumentError.new("Cannot define named instance #{method_name} on #{name}; value must be a Hash")
+        raise ArgumentError.new("Cannot define named instance #{method_name} on #{self.name}; value must be a Hash")
       end
 
       unless method_name.match?(/\A[a-z][a-z0-9_]+\z/)
-        raise ArgumentError.new("Cannot define named instance #{method_name} on #{name}; name contains illegal characters")
+        raise ArgumentError.new("Cannot define named instance #{method_name} on #{self.name}; name contains illegal characters")
       end
 
       key_value = attributes[support_table_key_attribute]
+      instance_names_map = support_table_instance_names_map
 
-      unless @support_table_instance_names.include?(method_name)
+      if instance_names_map.include?(method_name)
+        if instance_names_map[method_name] != key_value
+          define_support_table_instance_helper(method_name, support_table_key_attribute, key_value, redefine: true)
+          define_support_table_predicates_helper("#{method_name}?", support_table_key_attribute, key_value, redefine: true)
+          @support_table_instance_names = (@support_table_instance_names || {}).merge(method_name => key_value)
+        end
+      else
         define_support_table_instance_helper(method_name, support_table_key_attribute, key_value)
         define_support_table_predicates_helper("#{method_name}?", support_table_key_attribute, key_value)
-        @support_table_instance_names = @support_table_instance_names.merge(method_name => key_value)
+        @support_table_instance_names = (@support_table_instance_names || {}).merge(method_name => key_value)
       end
 
-      @support_table_attribute_helpers.each do |attribute_name, defined_methods|
+      support_table_attribute_helpers_map.each do |attribute_name, defined_methods|
         attribute_method_name = "#{method_name}_#{attribute_name}"
-        next if defined_methods.include?(attribute_method_name)
-
-        define_support_table_instance_attribute_helper(attribute_method_name, attributes[attribute_name])
-        defined_methods << attribute_method_name
+        if defined_methods.include?(attribute_method_name)
+          define_support_table_instance_attribute_helper(attribute_method_name, attributes[attribute_name], redefine: true)
+        else
+          define_support_table_instance_attribute_helper(attribute_method_name, attributes[attribute_name])
+          defined_methods << attribute_method_name
+        end
       end
     end
 
-    def define_support_table_instance_helper(method_name, attribute_name, attribute_value)
-      if respond_to?(method_name, true)
+    # Values from the data files are captured in the method closures rather than being
+    # interpolated into the method body as literals. Not every value that can appear in a
+    # data file has an `inspect` representation that is valid Ruby source (`Date` and `Time`
+    # are the notable ones), so interpolating them would raise a SyntaxError when the method
+    # is defined.
+    def define_support_table_instance_helper(method_name, attribute_name, attribute_value, redefine: false)
+      if redefine
+        singleton_class.silence_redefinition_of_method(method_name)
+      elsif respond_to?(method_name, true)
         raise ArgumentError.new("Could not define support table helper method #{name}.#{method_name} because it is already a defined method")
       end
 
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def self.#{method_name}
-          find_by!(#{attribute_name}: #{attribute_value.inspect})
-        end
-      RUBY
+      attribute_name = attribute_name.to_s
+      singleton_class.send(:define_method, method_name) do
+        find_by!(attribute_name => attribute_value)
+      end
     end
 
-    def define_support_table_instance_attribute_helper(method_name, attribute_value)
-      if respond_to?(method_name, true)
+    def define_support_table_instance_attribute_helper(method_name, attribute_value, redefine: false)
+      if redefine
+        singleton_class.silence_redefinition_of_method(method_name)
+      elsif respond_to?(method_name, true)
         raise ArgumentError.new("Could not define support table helper method #{name}.#{method_name} because it is already a defined method")
       end
 
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def self.#{method_name}
-          #{attribute_value.inspect}.freeze
-        end
-      RUBY
+      # The value is returned directly on every call, so it is copied and frozen to keep
+      # callers from mutating the data shared by all of them.
+      value = support_table_deep_freeze(attribute_value.dup)
+      singleton_class.send(:define_method, method_name) { value }
     end
 
-    def define_support_table_predicates_helper(method_name, attribute_name, attribute_value)
-      if method_defined?(method_name) || private_method_defined?(method_name)
+    def define_support_table_predicates_helper(method_name, attribute_name, attribute_value, redefine: false)
+      if redefine
+        silence_redefinition_of_method(method_name)
+      elsif method_defined?(method_name) || private_method_defined?(method_name)
         raise ArgumentError.new("Could not define support table helper method #{name}##{method_name} because it is already a defined method")
       end
 
-      class_eval <<~RUBY, __FILE__, __LINE__ + 1
-        def #{method_name}
-          #{attribute_name} == #{attribute_value.inspect}
+      attribute_name = attribute_name.to_s
+      # The value has to be cast to the attribute type before it can be compared to the value
+      # read off the record. The cast is done lazily and memoized per class because the type
+      # requires a database connection to resolve, which is not necessarily available when the
+      # model class is being loaded. The map is shared by every instance, so it needs to be
+      # thread safe on Ruby implementations without a global interpreter lock.
+      cast_values = Concurrent::Map.new
+      define_method(method_name) do
+        klass = self.class
+        cast_value = cast_values.fetch_or_store(klass) do
+          klass.type_for_attribute(attribute_name).cast(attribute_value)
         end
-      RUBY
+        send(attribute_name) == cast_value
+      end
+    end
+
+    def support_table_deep_freeze(value)
+      case value
+      when Hash
+        value.each_value { |element| support_table_deep_freeze(element) }
+      when Array
+        value.each { |element| support_table_deep_freeze(element) }
+      end
+      value.freeze
     end
 
     def support_table_parse_data_file(file_path)
@@ -390,7 +568,8 @@ module SupportTableData
         end
       else
         require "yaml" unless defined?(YAML)
-        data = YAML.safe_load(file_data)
+        require "date" unless defined?(Date)
+        data = YAML.safe_load(file_data, permitted_classes: [Date, Time], aliases: true)
       end
 
       data
@@ -399,7 +578,7 @@ module SupportTableData
     def support_table_record_changed?(record, seen = Set.new)
       return true if record.changed?
 
-      seen << self
+      seen << record
       record.class.reflect_on_all_associations.detect do |reflection|
         next false if reflection.belongs_to?
         next false unless reflection.options[:autosave]
@@ -409,6 +588,80 @@ module SupportTableData
         end
       end
     end
+
+    # Memoize a value calculated from the data files in an instance variable on this class.
+    # The list of data files used to calculate the value is cached along with it so that the
+    # value is recalculated whenever the list changes. This keeps the value from going stale
+    # when a data file is added after it was first calculated, including when the file is added
+    # to a base class after a single table inheritance subclass has cached its own copy or when
+    # a subclass that adds its own data files is loaded lazily.
+    #
+    # @param variable_name [Symbol] The name of the instance variable to memoize the value in.
+    # @param data_files [Array<String>] The data files the value is calculated from. These are
+    #   yielded to the block and cached with the value so it can be invalidated.
+    # @return [Object] The cached value.
+    def support_table_cached_data_value(variable_name, data_files)
+      cached = instance_variable_get(variable_name)
+      return cached.last if cached && cached.first == data_files
+
+      support_table_mutex.synchronize do
+        cached = instance_variable_get(variable_name)
+        unless cached && cached.first == data_files
+          cached = [data_files.dup.freeze, yield(data_files)].freeze
+          instance_variable_set(variable_name, cached)
+        end
+      end
+
+      cached.last
+    end
+
+    # Get the list of data files for this class along with any added to single table inheritance
+    # subclasses. Rows from a subclass' data files live in the same table, so they need to be
+    # included when determining which rows in the table are managed from data files.
+    #
+    # Note that this can only detect subclasses that have already been loaded by the application.
+    #
+    # @return [Array<String>] List of data file paths.
+    def support_table_data_files_with_descendants
+      files = support_table_data_files
+
+      descendants.each do |subclass|
+        next unless subclass.include?(SupportTableData)
+
+        files |= subclass.send(:support_table_data_files)
+      end
+
+      files
+    end
+
+    # The class level state used by the concern is stored in instance variables on the
+    # class where the concern was included. These readers compose in or fall back to the
+    # superclass state so that single table inheritance subclasses share the state defined
+    # on their base class rather than crashing on uninitialized instance variables.
+
+    def support_table_mutex
+      @support_table_mutex || (superclass.include?(SupportTableData) ? superclass.send(:support_table_mutex) : nil)
+    end
+
+    def support_table_data_files
+      inherited = superclass.include?(SupportTableData) ? superclass.send(:support_table_data_files) : []
+      own = @support_table_data_files || []
+      inherited.empty? ? own : inherited + own
+    end
+
+    def support_table_instance_names_map
+      inherited = superclass.include?(SupportTableData) ? superclass.send(:support_table_instance_names_map) : {}
+      own = @support_table_instance_names || {}
+      inherited.empty? ? own : inherited.merge(own)
+    end
+
+    def support_table_attribute_helpers_map
+      @support_table_attribute_helpers || (superclass.include?(SupportTableData) ? superclass.send(:support_table_attribute_helpers_map) : {})
+    end
+
+    def support_table_dependency_names
+      @support_table_dependencies || (superclass.include?(SupportTableData) ? superclass.send(:support_table_dependency_names) : [])
+    end
   end
 
   class << self
@@ -481,7 +734,7 @@ module SupportTableData
       if SupportTableData.data_directory && File.exist?(SupportTableData.data_directory) && File.directory?(SupportTableData.data_directory)
         Dir.glob(File.join(SupportTableData.data_directory, "**", "*")).sort.each do |file_name|
           file_name = file_name.delete_prefix("#{SupportTableData.data_directory}#{File::SEPARATOR}")
-          class_name = file_name.sub(/\.[^.]*/, "").singularize.camelize
+          class_name = file_name.sub(/\.[^.]*\z/, "").singularize.camelize
           class_name.safe_constantize
         end
       end
@@ -514,7 +767,7 @@ module SupportTableData
     #
     # @return [Array<Class>]
     def support_table_dependencies(klass)
-      dependencies = klass.instance_variable_get(:@support_table_dependencies).collect(&:constantize)
+      dependencies = klass.send(:support_table_dependency_names).collect(&:constantize)
 
       klass.reflections.values.each do |reflection|
         next if reflection.polymorphic?
@@ -523,8 +776,8 @@ module SupportTableData
         next unless reflection.belongs_to? || reflection.through_reflection?
         next if dependencies.include?(reflection.klass)
 
-        explicit_dependencies = reflection.klass.instance_variable_get(:@support_table_dependencies)
-        next if explicit_dependencies&.include?(klass.name)
+        explicit_dependencies = reflection.klass.send(:support_table_dependency_names)
+        next if explicit_dependencies.include?(klass.name)
 
         dependencies << reflection.klass
       rescue => e

data/lib/tasks/support_table_data.rake

@@ -80,8 +80,8 @@ namespace :support_table_data do
       SupportTableData::Tasks::Utils.eager_load!
       SupportTableData::Tasks::Utils.support_table_rbs_files(args[:file_path]).each do |rbs_file|
         next if rbs_file.up_to_date?
+        next unless rbs_file.write!
 
-        rbs_file.write!
         puts "Wrote RBS signatures for #{rbs_file.klass.name} to #{rbs_file.path}."
       end
     end

data/support_table_data.gemspec

@@ -35,9 +35,7 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.5"
+  spec.required_ruby_version = ">= 2.6"
 
   spec.add_dependency "activerecord", ">= 6"
-
-  spec.add_development_dependency "bundler"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: support_table_data
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Brian Durand
@@ -23,20 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 email:
 - bbdurand@gmail.com
 executables: []
@@ -75,14 +61,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Extension for ActiveRecord models to manage synchronizing data in support/lookup
   tables across environments. Also provides the ability to directly reference and