support_table_data 1.2.4 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25c555ca2a0e07c825f2b13c70224cf4e4ae27e489bad54e4e9f5983fa26df8a
-  data.tar.gz: b033e09b4eac22c923dc489d8d9762ffad9fdfec65f8fe25f20d13bd76339a48
+  metadata.gz: 246d91c74bc3b4a5afc75899786785139dc4b9bde91f0af778af63d1f374306b
+  data.tar.gz: c7290495c52166a9068806ffce68fbb6f161cdebf87546e6eae4a9b9c97deacc
 SHA512:
-  metadata.gz: ad12a5e0be457211552148035f0102b484ac27d17868f7a41d471b95b65b2e933e95e6179068f9fd6f4e09987e005bcf22bdef9748dbb8e04e566cc30053f542
-  data.tar.gz: a891b014ff3d7b92d26375223e61cf0f8419f05bbb0f55b2a16d8602b634c36f9f8d3449e301bc1fd23a03defadb24150c64902ea0f5530914db8d62780279a5
+  metadata.gz: f32896080f819f65bfcc59e38801cb69a5a5f98ccc83e6218c587766c5b769aab034b606452909cf9e62a6ea82a23e79150bae42201b73c374489563ed3d1537
+  data.tar.gz: ea9af78e06f7439854e7444eab0f96a541a14b7c5918767a464eb56094f415c71b5349b4a2043d12ac1bdebff47d1b8ee485e329cd10112b6c11f11389cbe595

data/CHANGELOG.md

@@ -4,6 +4,18 @@ 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.3.1
+
+### Added
+
+- Added support for autosave associations. Data in autosave associations will be persisted when the support table is synced if it was changed by the support table data.
+
+## 1.3.0
+
+### Added
+
+- Added `support_table_dependency` method to explicitly define support table dependencies that cannot be inferred from model associations.
+
 ## 1.2.4
 
 ### Fixed

data/README.md

@@ -57,6 +57,8 @@ You cannot update the value of the key attribute in a record in the data file. I
 
 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. In a Rails application, `SupportTableData.data_directory` will be automatically set to `db/support_tables/`. 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.
 
+**Note**: If you're using CSV files and Ruby 3.4 or higher, you'll need to include the `csv` gem in your Gemfile since it was removed from the standard library in Ruby 3.4.
+
 ### Named Instances
 
 You can also automatically define helper methods to load instances and determine if they match specific values. This allows you to add more natural ways of referencing specific records.
@@ -212,7 +214,37 @@ Loading data is done inside a database transaction. No changes will be persisted
 
 You can synchronize the data in all models by calling `SupportTableData.sync_all!`. This method will discover all ActiveRecord models that include `SupportTableData` and synchronize each of them. (Note that there can be issues discovering all support table models in a Rails application if eager loading is turned off.) The discovery mechanism will try to detect unloaded classes by looking at the file names in the support table data directory so it's best to stick to standard Rails naming conventions for your data files.
 
-The load order for models will resolve any dependencies between models. So if one model has a `belongs_to` association with another model, then the belongs to model will be loaded first.
+The load order for models will resolve any dependencies between models. So if one model has a `belongs_to` association with another model, then the belongs to model will be loaded first. You can also explicitly define dependencies with the `support_table_dependency` method. If you have a join table between support tables that creates a circular dependency, then you will need to define which model to load first.
+
+```ruby
+class Widget < ApplicationRecord
+  include SupportTableData
+
+  add_support_table_data "widgets.yml"
+
+  has_many :thing_widgets
+  has_many :things, through: :thing_widgets
+end
+
+class Thing < ApplicationRecord
+  include SupportTableData
+
+  add_support_table_data "things.yml"
+
+  has_many :thing_widgets
+  has_many :widgets, through: :thing_widgets, autosave: true
+
+  # The Thing model is responsible for loading the thing_widgets join table by means of the widget_names=
+  # setter method. We need to define the depdenency to ensure widgets are loaded first.
+  support_table_dependency "Widget"
+
+  def widget_names=(widget_names)
+    self.widgets = Widget.where(name: widget_names)
+  end
+end
+```
+
+If you use a method to set a `has_many` association on your model, you **must** set the `autosave` option to `true` on the association (see the above example). This will ensure the association records are always saved even if there were no changes to the parent record.
 
 You need to call `SupportTableData.sync_all!` when deploying your application. This gem includes a rake task `support_table_data:sync` that is suitable for hooking into deploy scripts. An easy way to hook it into a Rails application is by enhancing the `db:migrate` task so that the sync task runs immediately after database migrations are run. You can do this by adding code to a Rakefile in your application's `lib/tasks` directory:
 

data/VERSION

@@ -1 +1 @@
-1.2.4
+1.3.1

data/lib/support_table_data.rb

@@ -15,6 +15,7 @@ module SupportTableData
     @support_table_attribute_helpers = {}
     @support_table_instance_names = {}
     @support_table_instance_keys = nil
+    @support_table_dependencies = []
 
     # Define the attribute used as the key of the hash in the data files.
     # This should be a value that never changes. By default the key attribute will be the id.
@@ -48,7 +49,7 @@ module SupportTableData
             attributes&.each do |name, value|
               record.send(:"#{name}=", value) if record.respond_to?(:"#{name}=", true)
             end
-            if record.changed?
+            if support_table_record_changed?(record)
               changes << record.changes
               record.save!
             end
@@ -205,6 +206,20 @@ module SupportTableData
       @protected_keys.include?(instance[key_attribute].to_s)
     end
 
+    # Explicitly define other support tables that this model depends on. A support table depends
+    # on another support table it needs to reference data on that table when loading its own data.
+    # Normally this is handled automatically by looking at the belongs_to associations on the model.
+    # In some cases, though, you may need to explicitly define the relationship. For instance, if
+    # there's a join table between two associations with the data poplulated from one support table's
+    # data file by referencing values maintained by the other support table. In this case,
+    # you need to define the dependency so that the tables are loaded in the correct order.
+    #
+    # @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)
+    end
+
     private
 
     def define_support_table_named_instances
@@ -308,6 +323,20 @@ module SupportTableData
 
       data
     end
+
+    def support_table_record_changed?(record, seen = Set.new)
+      return true if record.changed?
+
+      seen << self
+      record.class.reflect_on_all_associations.detect do |reflection|
+        next false if reflection.belongs_to?
+        next false unless reflection.options[:autosave]
+
+        record.association(reflection.name).target.any? do |child|
+          support_table_record_changed?(child, seen) unless seen.include?(child)
+        end
+      end
+    end
   end
 
   class << self
@@ -405,13 +434,17 @@ module SupportTableData
     #
     # @return [Array<Class>]
     def support_table_dependencies(klass)
-      dependencies = []
+      dependencies = klass.instance_variable_get(:@support_table_dependencies).collect(&:constantize)
 
       klass.reflections.values.each do |reflection|
         next if reflection.polymorphic?
         next unless reflection.klass.include?(SupportTableData)
         next if reflection.klass <= klass
         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)
 
         dependencies << reflection.klass
       rescue => e

data/support_table_data.gemspec

@@ -9,6 +9,12 @@ Gem::Specification.new do |spec|
   spec.homepage = "https://github.com/bdurand/support_table_data"
   spec.license = "MIT"
 
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/master/CHANGELOG.md"
+  }
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   ignore_files = %w[

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: support_table_data
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.3.1
 platform: ruby
 authors:
 - Brian Durand
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-26 00:00:00.000000000 Z
+date: 2025-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -56,7 +56,10 @@ files:
 homepage: https://github.com/bdurand/support_table_data
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/bdurand/support_table_data
+  source_code_uri: https://github.com/bdurand/support_table_data
+  changelog_uri: https://github.com/bdurand/support_table_data/blob/master/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths: