acts_as_table 0.0.1

data/app/models/acts_as_table/row_model.rb

@@ -0,0 +1,285 @@
+module ActsAsTable
+  # ActsAsTable row model (value provider).
+  #
+  # @!attribute [rw] name
+  #   Returns the name of this ActsAsTable row model.
+  #
+  #   @return [String]
+  class RowModel < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProvider::InstanceMethods
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.row_models_table
+
+    acts_as_table_value_provider
+
+    # Returns the root ActsAsTable record model for this ActsAsTable row model.
+    belongs_to :root_record_model, **{
+      class_name: 'ActsAsTable::RecordModel',
+      inverse_of: :row_models_as_root,
+      required: true,
+    }
+
+    # Returns the ActsAsTable column models for this ActsAsTable row model.
+    has_many :column_models, -> { order(position: :asc) }, **{
+      autosave: true,
+      class_name: 'ActsAsTable::ColumnModel',
+      dependent: :destroy,
+      foreign_key: 'row_model_id',
+      inverse_of: :row_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable singular macro associations for this ActsAsTable row model.
+    has_many :belongs_tos, **{
+      autosave: true,
+      class_name: 'ActsAsTable::BelongsTo',
+      dependent: :destroy,
+      foreign_key: 'row_model_id',
+      inverse_of: :row_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable collection macro associations for this ActsAsTable row model.
+    has_many :has_manies, **{
+      autosave: true,
+      class_name: 'ActsAsTable::HasMany',
+      dependent: :destroy,
+      foreign_key: 'row_model_id',
+      inverse_of: :row_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable record models for this ActsAsTable row model.
+    has_many :record_models, **{
+      autosave: true,
+      class_name: 'ActsAsTable::RecordModel',
+      dependent: :destroy,
+      foreign_key: 'row_model_id',
+      inverse_of: :row_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable tables that have been provided by this ActsAsTable row model.
+    has_many :tables, **{
+      class_name: 'ActsAsTable::Table',
+      dependent: :restrict_with_exception,
+      foreign_key: 'row_model_id',
+      inverse_of: :row_model,
+    }
+
+    validates :name, **{
+      presence: true,
+    }
+
+    validate :record_models_includes_root_record_model, **{
+      if: ::Proc.new { |row_model| row_model.root_record_model.present? },
+    }
+
+    # Draw an ActsAsTable row model.
+    #
+    # @yieldparam [ActsAsTable::Mapper::RowModel] row_model_mapper
+    # @yieldreturn [void]
+    # @return [void]
+    #
+    # @see ActsAsTable::Mapper::RowModel
+    def draw(&block)
+      ActsAsTable::Mapper::RowModel.new(self, &block)
+
+      return
+    end
+
+    # Returns the ActsAsTable headers array object for the ActsAsTable column models for this ActsAsTable row model.
+    #
+    # @return [ActsAsTable::Headers::Array]
+    def to_headers
+      ActsAsTable::Headers::Array.new(self.column_models)
+    end
+
+    # Returns the ActsAsTable records for the given row.
+    #
+    # @param [Array<String, nil>, nil] row
+    # @param [ActiveRecord::Relation<ActsAsTable::Record>] records
+    # @return [Array<ActsAsTable::Record>]
+    # @raise [ArgumentError] If the name of a class for a given record does not match the class name for the corresponding ActsAsTable record model.
+    def from_row(row = [], records = ActsAsTable::Record.all)
+      # @return [Hash<ActsAsTable::RecordModel, Hash<ActsAsTable::ValueProvider::InstanceMethods, Object>>]
+      value_by_record_model_and_value_provider = self.record_models.inject({}) { |acc_for_record_model, record_model|
+        acc_for_record_model[record_model] = record_model.each_acts_as_table_value_provider(except: [:row_model]).inject({}) { |acc_for_value_provider, value_provider|
+          acc_for_value_provider[value_provider] = value_provider.column_model.try { |column_model|
+            # @return [Integer]
+            index = column_model.position - 1
+
+            if (index >= 0) && (index < row.size)
+              row[index]
+            else
+              nil
+            end
+          }
+
+          acc_for_value_provider
+        }
+
+        acc_for_record_model
+      }
+
+      # @return [ActsAsTable::ValueProvider::WrappedValue]
+      hash = ActsAsTable.adapter.set_value_for(self, nil, value_by_record_model_and_value_provider, default: true)
+
+      hash.target_value.each_pair.collect { |pair|
+        record_model, pair = *pair
+
+        new_record_or_persisted, pair_by_value_provider = *pair
+
+        records.build(record_model_changed: pair_by_value_provider.changed?) do |record|
+          record.base = new_record_or_persisted
+
+          record.record_model = record_model
+
+          # @note {ActiveRecord::Validations#validate} is an alias for {ActiveRecord::Validations#valid?} that does not raise an exception when the record is invalid.
+          new_record_or_persisted.validate
+
+          # @return [Array<String>]
+          attribute_names = []
+
+          pair_by_value_provider.target_value.each do |value_provider, target_value|
+            # @return [String]
+            attribute_name = \
+              case value_provider
+              when ActsAsTable::ForeignKey
+                klass = record_model.class_name.constantize
+
+                reflection = klass.reflect_on_association(value_provider.method_name)
+
+                reflection.foreign_key
+              else
+                value_provider.method_name
+              end
+
+            attribute_names << attribute_name
+
+            record.values.build(target_value: target_value.target_value, value_provider_changed: target_value.changed?) do |value|
+              value.value_provider = value_provider
+
+              value_provider.column_model.try { |column_model|
+                value.column_model = column_model
+
+                value.position = column_model.position
+
+                # @return [Integer]
+                index = column_model.position - 1
+
+                value.source_value = \
+                  if (index >= 0) && (index < row.size)
+                    row[index]
+                  else
+                    nil
+                  end
+              }
+
+              new_record_or_persisted.errors[attribute_name].each do |message|
+                value.record_errors.build(attribute_name: attribute_name, message: message)
+              end
+            end
+          end
+
+          new_record_or_persisted.errors.each do |attribute_name, message|
+            unless attribute_names.include?(attribute_name.to_s)
+              record.record_errors.build(attribute_name: attribute_name, message: message)
+            end
+          end
+        end
+      }
+    end
+
+    # Returns the row for the given record.
+    #
+    # @param [ActiveRecord::Base, nil] base
+    # @return [Array<String, nil>, nil]
+    # @raise [ArgumentError]
+    def to_row(base = nil)
+      # @return [ActsAsTable::ValueProvider::WrappedValue]
+      value_by_record_model_and_value_provider = ActsAsTable.adapter.get_value_for(self, base, default: false)
+
+      # @return [Integer]
+      column_models_maximum_position = (self.persisted? ? self.column_models.maximum(:position) : self.column_models.to_a.collect(&:position).max) || 0
+
+      # @return [Array<String, nil>]
+      row = ::Array.new(column_models_maximum_position) { nil }
+
+      self.record_models.each do |record_model|
+        # @return [ActsAsTable::ValueProvider::WrappedValue, nil]
+        value_by_value_provider = value_by_record_model_and_value_provider.target_value.try(:[], record_model)
+
+        record_model.each_acts_as_table_value_provider(except: [:row_model]) do |value_provider|
+          value_provider.column_model.try { |column_model|
+            # @return [Integer]
+            index = column_model.position - 1
+
+            if (index >= 0) && (index < column_models_maximum_position)
+              # @return [ActsAsTable::ValueProvider::WrappedValue, nil]
+              value = value_by_value_provider.try(:target_value).try(:[], value_provider)
+
+              row[index] = value.try(:target_value)
+            end
+          }
+        end
+      end
+
+      row.all?(&:nil?) ? nil : row
+    end
+
+    include ActsAsTable::RecordModelClassMethods
+
+    # Returns `true` if the given ActsAsTable record model is reachable from the root ActsAsTable record model for this ActsAsTable row model. Otherwise, returns `false`.
+    #
+    # @param [ActsAsTable::RecordModel] record_model
+    # @return [Boolean]
+    def reachable_record_model?(record_model)
+      self.class.reachable_record_model_for?(self.root_record_model, record_model)
+    end
+
+    # Returns the ActsAsTable record models that are reachable from the root ActsAsTable record model for this ActsAsTable row model (in topological order).
+    #
+    # @return [Array<ActsAsTable::RecordModel>]
+    def reachable_record_models
+      self.class.reachable_record_models_for(self.root_record_model)
+    end
+
+    # Get the value for the given record using the given options.
+    #
+    # @param [ActiveRecord::Base, nil] base
+    # @param [Hash<Symbol, Object>] options
+    # @option options [Boolean] :default
+    # @return [ActsAsTable::ValueProvider::WrappedValue]
+    # @raise [ArgumentError]
+    def get_value(base = nil, **options)
+      self.class.get_value_for(self.root_record_model, base, **options)
+    end
+
+    # Set the new value for the given record using the given options.
+    #
+    # @param [ActiveRecord::Base, nil] base
+    # @param [Hash<ActsAsTable::RecordModel, Hash<ActsAsTable::ValueProvider::InstanceMethods, Object>>] new_value_by_record_model_and_value_provider
+    # @param [Hash<Symbol, Object>] options
+    # @option options [Boolean] :default
+    # @return [ActsAsTable::ValueProvider::WrappedValue]
+    # @raise [ArgumentError]
+    def set_value(base = nil, new_value_by_record_model_and_value_provider = {}, **options)
+      self.class.set_value_for(self.root_record_model, base, new_value_by_record_model_and_value_provider, **options)
+    end
+
+    private
+
+    # @return [void]
+    def record_models_includes_root_record_model
+      unless self.record_models.include?(self.root_record_model)
+        self.errors.add('root_record_model_id', :inclusion)
+      end
+
+      return
+    end
+  end
+end

data/app/models/acts_as_table/table.rb

@@ -0,0 +1,41 @@
+module ActsAsTable
+  # ActsAsTable table.
+  #
+  # @!attribute [r] records_count
+  #   Returns the number of ActsAsTable records for this ActsAsTable table.
+  #
+  #   @return [Integer]
+  class Table < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.tables_table
+
+    # Returns the ActsAsTable row model for this ActsAsTable table.
+    belongs_to :row_model, **{
+      class_name: 'ActsAsTable::RowModel',
+      inverse_of: :tables,
+      required: true,
+    }
+
+    # Returns the ActsAsTable records for this ActsAsTable table.
+    has_many :records, -> { order(position: :asc) }, **{
+      autosave: true,
+      class_name: 'ActsAsTable::Record',
+      dependent: :destroy,
+      foreign_key: 'table_id',
+      inverse_of: :table,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable records for the given row.
+    #
+    # @param [Array<String, nil>, nil] row
+    # @return [Array<ActsAsTable::Record>]
+    # @raise [ArgumentError] If the name of a class for a given record does not match the class name for the corresponding ActsAsTable record model.
+    def from_row(row = [])
+      self.row_model.from_row(row, self.records)
+    end
+  end
+end

data/app/models/acts_as_table/value.rb

@@ -0,0 +1,80 @@
+module ActsAsTable
+  # ActsAsTable value.
+  #
+  # @!attribute [rw] position
+  #   Returns the position of this ActsAsTable value or `nil`.
+  #
+  #   @return [Integer, nil]
+  # @!attribute [r] record_errors_count
+  #   Returns the number of ActsAsTable record errors for this ActsAsTable value.
+  #
+  #   @return [Integer]
+  # @!attribute [rw] source_value
+  #   Returns the source value for this ActsAsTable value.
+  #
+  #   @return [String, nil]
+  # @!attribute [rw] target_value
+  #   Returns the target value for this ActsAsTable value.
+  #
+  #   @return [String, nil]
+  # @!attribute [rw] value_provider_changed
+  #   Returns `true` if the ActsAsTable value provider changed the value for this ActsAsTable value. Otherwise, returns `false`.
+  #
+  #   @return [Boolean]
+  class Value < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.values_table
+
+    # Returns the ActsAsTable column model that provided this ActsAsTable value or `nil`.
+    #
+    # @return [ActsAsTable::ColumnModel, nil]
+    belongs_to :column_model, **{
+      class_name: 'ActsAsTable::ColumnModel',
+      inverse_of: :values,
+      required: false,
+    }
+
+    # Returns the ActsAsTable record for this ActsAsTable value.
+    belongs_to :record, **{
+      class_name: 'ActsAsTable::Record',
+      counter_cache: 'values_count',
+      inverse_of: :values,
+      required: true,
+    }
+
+    # Returns the ActsAsTable value provider that provider the value for this ActsAsTable value.
+    #
+    # @return [ActsAsTable::ValueProvider::InstanceMethods]
+    belongs_to :value_provider, **{
+      polymorphic: true,
+      required: true,
+    }
+
+    # Returns the ActsAsTable record errors for this ActsAsTable value.
+    has_many :record_errors, -> { order(attribute_name: :asc, message: :asc) }, **{
+      autosave: false,
+      class_name: 'ActsAsTable::RecordError',
+      dependent: :nullify,
+      foreign_key: 'value_id',
+      inverse_of: :values,
+      validate: false,
+    }
+
+    validates :record_id, **{
+      uniqueness: {
+        scope: ['value_provider_id', 'value_provider_type'],
+      },
+    }
+
+    # validates :position, **{}
+
+    # validates :source_value, **{}
+
+    # validates :target_value, **{}
+
+    # validates :value_provider_changed, **{}
+  end
+end

data/app/models/concerns/acts_as_table/record_model_class_methods.rb

@@ -0,0 +1,554 @@
+require 'singleton'
+
+module ActsAsTable
+  # ActsAsTable record model class methods (concern).
+  module RecordModelClassMethods
+    extend ::ActiveSupport::Concern
+
+    class_methods do
+      # Returns `true` if the target ActsAsTable record model is reachable from the source ActsAsTable record model. Otherwise, returns `false`.
+      #
+      # @param [ActsAsTable::RecordModel] source_record_model
+      # @param [ActsAsTable::RecordModel] target_record_model
+      # @return [Boolean]
+      def reachable_record_model_for?(source_record_model, target_record_model)
+        Inject.instance.inject(false, source_record_model) { |acc, path, &block|
+          # @note Continue until the target ActsAsTable record model is reached.
+          acc || (path.options.dig(:data, :target_record_model) == target_record_model) || block.call(acc)
+        }
+      end
+
+      # Returns the ActsAsTable record models that are reachable from the given ActsAsTable record models (in topological order).
+      #
+      # @param [ActsAsTable::RecordModel] record_model
+      # @return [Array<ActsAsTable::RecordModel>]
+      def reachable_record_models_for(record_model)
+        Inject.instance.inject([], record_model) { |acc, path, &block|
+          # @return [ActsAsTable::RecordModel]
+          target_record_model = path.options.dig(:data, :target_record_model)
+
+          # @note Continue until every target ActsAsTable record is reached one or more times.
+          if acc.include?(target_record_model)
+            acc
+          else
+            acc << target_record_model
+
+            block.call(acc)
+          end
+        }
+      end
+
+      # Get the value for the given record using the given options.
+      #
+      # @param [ActsAsTable::RecordModel] record_model
+      # @param [ActiveRecord::Base, nil] base
+      # @param [Hash<Symbol, Object>] options
+      # @option options [Boolean] :default
+      # @return [ActsAsTable::ValueProvider::WrappedValue]
+      # @raise [ArgumentError]
+      def get_value_for(record_model, base = nil, **options)
+        GetValue.new(**options).call(record_model, base)
+      end
+
+      # Set the new value for the given record using the given options.
+      #
+      # @param [ActsAsTable::RecordModel] record_model
+      # @param [ActiveRecord::Base, nil] base
+      # @param [Hash<ActsAsTable::RecordModel, Hash<ActsAsTable::ValueProvider::InstanceMethods, Object>>] new_value_by_record_model_and_value_provider
+      # @param [Hash<Symbol, Object>] options
+      # @option options [Boolean] :default
+      # @return [ActsAsTable::ValueProvider::WrappedValue]
+      # @raise [ArgumentError]
+      def set_value_for(record_model, base = nil, new_value_by_record_model_and_value_provider = {}, **options)
+        SetValue.new(new_value_by_record_model_and_value_provider, **options).call(record_model, base)
+      end
+    end
+
+    # ActsAsTable "non-destructive" traversal (does not create new records if they are not found).
+    class Inject
+      include ::Singleton
+
+      # Combine all ActsAsTable paths using an associative binary operation.
+      #
+      # @param [Object] acc
+      # @param [ActsAsTable::RecordModel] record_model
+      # @yieldparam [Object] acc
+      # @yieldparam [ActsAsTable::Path] path
+      # @yieldreturn [Object]
+      # @return [Object]
+      def inject(acc, record_model, &block)
+        # @return [Class]
+        klass = record_model.class_name.constantize
+
+        # @return [ActsAsTable::Path]
+        path = ActsAsTable::Path.new(klass, nil, data: {
+          source_record_model: nil,
+          target_record_model: record_model,
+        })
+
+        _inject(acc, path, &block)
+      end
+
+      private
+
+      # @param [Object] orig_acc
+      # @yieldparam [ActsAsTable::Path] orig_path
+      # @yieldparam [Object] acc
+      # @yieldparam [ActsAsTable::Path] path
+      # @yieldreturn [Object]
+      # @return [Object]
+      def _inject(orig_acc, orig_path, &block)
+        block.call(orig_acc, orig_path) do |new_acc|
+          # @return [ActsAsTable::RecordModel]
+          source_record_model = orig_path.options.dig(:data, :target_record_model)
+
+          %i(belongs_to).each do |macro|
+            # @return [Array<ActsAsTable::BelongsTo>]
+            macro_reflection_models = source_record_model.persisted? ? source_record_model.send(:"#{macro.to_s.pluralize}_as_source").to_a : source_record_model.row_model.send(:"#{macro.to_s.pluralize}").to_a.select { |macro_reflection_model| macro_reflection_model.source_record_model == source_record_model }
+
+            macro_reflection_models.each do |macro_reflection_model|
+              # @return [ActsAsTable::RecordModel]
+              target_record_model = macro_reflection_model.target_record_model
+
+              # @return [ActsAsTable::Path]
+              new_path = orig_path.send(macro_reflection_model.macro, macro_reflection_model.method_name, data: {
+                source_record_model: source_record_model,
+                target_record_model: target_record_model,
+              })
+
+              new_acc = _inject(new_acc, new_path, &block)
+            end
+          end
+
+          %i(has_many).each do |macro|
+            # @return [Array<ActsAsTable::HasMany>]
+            macro_reflection_models = source_record_model.persisted? ? source_record_model.send(:"#{macro.to_s.pluralize}_as_source").to_a : source_record_model.row_model.send(:"#{macro.to_s.pluralize}").to_a.select { |macro_reflection_model| macro_reflection_model.source_record_model == source_record_model }
+
+            macro_reflection_models.each do |macro_reflection_model|
+              # @return [Array<ActsAsTable::HasManyTarget>]
+              macro_reflection_model_targets = macro_reflection_model.persisted? ? macro_reflection_model.send(:"#{macro.to_s.singularize}_targets").to_a : macro_reflection_model.send(:"#{macro.to_s.singularize}_targets").to_a.sort_by(&:position)
+
+              macro_reflection_model_targets.each do |macro_reflection_model_target|
+                # @return [ActsAsTable::RecordModel]
+                target_record_model = macro_reflection_model_target.record_model
+
+                # @return [Integer]
+                index = macro_reflection_model_target.position - 1
+
+                # @return [ActsAsTable::Path]
+                new_path = orig_path.send(macro_reflection_model.macro, macro_reflection_model.method_name, index, data: {
+                  source_record_model: source_record_model,
+                  target_record_model: target_record_model,
+                })
+
+                new_acc = _inject(new_acc, new_path, &block)
+              end
+            end
+          end
+
+          new_acc
+        end
+      end
+    end
+
+    # ActsAsTable "destructive" traversal (creates new records if they are not found and updates persisted records).
+    class FindOrInitializeBy
+      # Returns the number of mandatory arguments.
+      #
+      # @return [Integer]
+      def arity
+        1
+      end
+
+      # Invokes the traversal.
+      #
+      # @param [ActsAsTable::RecordModel] record_model
+      # @param [ActiveRecord::Base, nil] base
+      # @return [ActsAsTable::ValueProvider::WrappedValue]
+      # @raise [ArgumentError] If the name of a class for a given record does not match the class name for the corresponding ActsAsTable record model.
+      def call(record_model, base = nil)
+        raise ::NotImplementedError.new("#{self.class}#call")
+      end
+
+      # Combine all ActsAsTable paths using an associative binary operation.
+      #
+      # @param [Object] acc
+      # @param [ActsAsTable::RecordModel] record_model
+      # @param [ActiveRecord::Base, nil] base
+      # @yieldparam [Object] acc
+      # @yieldparam [ActsAsTable::Path] path
+      # @yieldreturn [Object]
+      # @return [Object]
+      # @raise [ArgumentError] If the name of a class for a given record does not match the class name for the corresponding ActsAsTable record model.
+      def inject(acc, record_model, base = nil)
+        # @return [Class]
+        klass = record_model.class_name.constantize
+
+        # @return [ActsAsTable::Path]
+        path = ActsAsTable::Path.new(klass, nil, data: {
+          source_record_model: nil,
+          source_record: nil,
+          target_record_model: record_model,
+          target_record: base,
+        })
+
+        _inject(acc, path, **{
+          find_or_initialize_by: ::Proc.new { |*args, &block|
+            ActsAsTable.adapter.find_or_initialize_by_for(record_model, klass, :find_by!, *args, &block)
+          },
+          new: ::Proc.new { |*args, &block|
+            ActsAsTable.adapter.new_for(record_model, klass, :new, *args, &block)
+          },
+        })
+      end
+
+      protected
+
+      # @param [Object] acc
+      # @param [ActsAsTable::Path] path
+      # @yieldparam [Object] acc
+      # @yieldparam [ActsAsTable::Path] path
+      # @yieldreturn [Object]
+      # @return [Object]
+      # @raise [ArgumentError]
+      def _around_inject(acc, path, &block)
+        block.call(acc)
+      end
+
+      # @param [Object] acc
+      # @param [ActsAsTable::RecordModel] record_model
+      # @param [ActiveRecord::Base, nil] base
+      # @param [Hash<Symbol, Object>] options
+      # @option options [#call] :find_or_initialize_by
+      # @option options [#call] :new
+      # @return [Array<Object>]
+      def _find_or_initialize(acc, record_model, base = nil, **options)
+        [acc, base]
+      end
+
+      # @param [Object] acc
+      # @param [ActsAsTable::RecordModel] record_model
+      # @return [ActiveRecord::Base, nil]
+      def _at(acc, record_model)
+        nil
+      end
+
+      private
+
+      # @param [Object] orig_acc
+      # @param [ActsAsTable::Path] orig_path
+      # @param [Hash<Symbol, Object>] options
+      # @option options [#call] :find_or_initialize_by
+      # @option options [#call] :new
+      # @yieldparam [ActsAsTable::Path] orig_path
+      # @yieldparam [Object] acc
+      # @yieldparam [ActsAsTable::Path] path
+      # @yieldreturn [Object]
+      # @return [Object]
+      # @raise [ArgumentError]
+      def _inject(orig_acc, orig_path, **options)
+        options.assert_valid_keys(:find_or_initialize_by, :new)
+
+        _around_inject(orig_acc, orig_path) do |new_acc|
+          # @return [ActsAsTable::RecordModel]
+          source_record_model = orig_path.options.dig(:data, :target_record_model)
+
+          # @return [ActiveRecord::Base, nil]
+          source_record = orig_path.options.dig(:data, :target_record)
+
+          unless source_record.nil? || source_record.class.name.eql?(source_record_model.class_name)
+            raise ::ArgumentError.new("#{self.name}#_inject - source_record - expected: #{source_record_model.class_name.inspect}, found: #{source_record.inspect}")
+          end
+
+          new_acc, source_record = *_find_or_initialize(new_acc, source_record_model, source_record, **options)
+
+          unless source_record.nil?
+            %i(belongs_to).each do |macro|
+              # @return [Array<ActsAsTable::BelongsTo>]
+              macro_reflection_models = source_record_model.persisted? ? source_record_model.send(:"#{macro.to_s.pluralize}_as_source").to_a : source_record_model.row_model.send(:"#{macro.to_s.pluralize}").to_a.select { |macro_reflection_model| macro_reflection_model.source_record_model == source_record_model }
+
+              macro_reflection_models.each do |macro_reflection_model|
+                # @return [ActsAsTable::RecordModel]
+                target_record_model = macro_reflection_model.target_record_model
+
+                # @return [ActiveRecord::Reflection::MacroReflection]
+                reflection = source_record.class.reflect_on_association(macro_reflection_model.method_name)
+
+                # @return [ActiveRecord::Base, nil]
+                target_record = source_record.send(reflection.name)
+
+                if target_record.nil?
+                  target_record = source_record.send(:"#{reflection.name}=", _at(new_acc, target_record_model))
+                end
+
+                # @return [ActsAsTable::Path]
+                new_path = orig_path.send(macro_reflection_model.macro, macro_reflection_model.method_name, data: {
+                  source_record_model: source_record_model,
+                  source_record: source_record,
+                  target_record_model: target_record_model,
+                  target_record: target_record,
+                })
+
+                new_acc = _inject(new_acc, new_path, **options.merge({
+                  find_or_initialize_by: ::Proc.new { |*args, &block|
+                    source_record.send(:"#{reflection.name}=", ActsAsTable.adapter.find_or_initialize_by_for(target_record_model, reflection.klass, :find_by!, *args, &block))
+                  },
+                  new: ::Proc.new { |*args, &block|
+                    source_record.send(:"#{reflection.name}=", nil)
+
+                    ActsAsTable.adapter.new_for(target_record_model, source_record, :"build_#{reflection.name}", *args, &block)
+                  },
+                }))
+              end
+            end
+
+            %i(has_many).each do |macro|
+              # @return [Array<ActsAsTable::HasMany>]
+              macro_reflection_models = source_record_model.persisted? ? source_record_model.send(:"#{macro.to_s.pluralize}_as_source").to_a : source_record_model.row_model.send(:"#{macro.to_s.pluralize}").to_a.select { |macro_reflection_model| macro_reflection_model.source_record_model == source_record_model }
+
+              macro_reflection_models.each do |macro_reflection_model|
+                # @return [ActiveRecord::Reflection::MacroReflection]
+                reflection = source_record.class.reflect_on_association(macro_reflection_model.method_name)
+
+                # @return [ActiveRecord::Relation<ActiveRecord::Base>]
+                relation = source_record.send(reflection.name)
+
+                # @return [Array<ActiveRecord::Base>]
+                target_records = relation.to_a
+
+                # @return [Array<ActsAsTable::HasManyTarget>]
+                macro_reflection_model_targets = macro_reflection_model.persisted? ? macro_reflection_model.send(:"#{macro.to_s.singularize}_targets").to_a : macro_reflection_model.send(:"#{macro.to_s.singularize}_targets").to_a.sort_by(&:position)
+
+                macro_reflection_model_targets.each do |macro_reflection_model_target|
+                  # @return [ActsAsTable::RecordModel]
+                  target_record_model = macro_reflection_model_target.record_model
+
+                  # @return [Integer]
+                  index = macro_reflection_model_target.position - 1
+
+                  target_record = \
+                    if (index >= 0) && (index < target_records.size)
+                      target_records[index]
+                    else
+                      nil
+                    end
+
+                  if target_record.nil?
+                    target_record = _at(new_acc, target_record_model)
+
+                    unless target_record.nil? || target_records.include?(target_record)
+                      relation.proxy_association.add_to_target(target_record)
+                    end
+                  end
+
+                  # @return [ActsAsTable::Path]
+                  new_path = orig_path.send(macro_reflection_model.macro, macro_reflection_model.method_name, index, data: {
+                    source_record_model: source_record_model,
+                    source_record: source_record,
+                    target_record_model: target_record_model,
+                    target_record: target_record,
+                  })
+
+                  new_acc = _inject(new_acc, new_path, **options.merge({
+                    find_or_initialize_by: ::Proc.new { |*args, &block|
+                      ActsAsTable.adapter.find_or_initialize_by_for(target_record_model, relation, :find_by!, *args, &block)
+                    },
+                    new: ::Proc.new { |*args, &block|
+                      ActsAsTable.adapter.new_for(target_record_model, relation, :build, *args, &block)
+                    },
+                  }))
+                end
+              end
+            end
+          end
+
+          new_acc
+        end
+      end
+    end
+
+    # Get the value for the given record using the given options.
+    #
+    # @!attribute [r] options
+    #   The options for this ActsAsTable "destructive" traversal.
+    #
+    #   @return [Hash<Symbol, Object>]
+    class GetValue < FindOrInitializeBy
+      attr_reader :options
+
+      # Returns a new ActsAsTable "destructive" traversal.
+      #
+      # @param [Hash<Symbol, Object>] options
+      # @option options [Boolean] :default
+      # @return [ActsAsTable::RecordModelClassMethods::GetValue]
+      def initialize(**options)
+        super()
+
+        options.assert_valid_keys(:default)
+
+        @options = options.dup
+      end
+
+      # Invokes the traversal.
+      #
+      # @param [ActsAsTable::RecordModel] record_model
+      # @param [ActiveRecord::Base, nil] base
+      # @return [ActsAsTable::ValueProvider::WrappedValue]
+      # @raise [ArgumentError] If the name of a class for a given record does not match the class name for the corresponding ActsAsTable record model.
+      def call(record_model, base = nil)
+        ActsAsTable.adapter.wrap_value_for(record_model, base, nil, self.inject({}, record_model, base))
+      end
+
+      protected
+
+      # @param [Hash<ActsAsTable::RecordModel, ActsAsTable::ValueProvider::WrappedValue>] acc
+      # @param [ActsAsTable::Path] path
+      # @yieldparam [Hash<ActsAsTable::RecordModel, ActsAsTable::ValueProvider::WrappedValue>] acc
+      # @yieldparam [ActsAsTable::Path] path
+      # @yieldreturn [Hash<ActsAsTable::RecordModel, ActsAsTable::ValueProvider::WrappedValue>]
+      # @return [Hash<ActsAsTable::RecordModel, ActsAsTable::ValueProvider::WrappedValue>]
+      # @raise [ArgumentError]
+      def _around_inject(acc, path, &block)
+        acc.key?(path.options.dig(:data, :target_record_model)) ? acc : block.call(acc)
+      end
+
+      # @param [Hash<ActsAsTable::RecordModel, ActsAsTable::ValueProvider::WrappedValue>] acc
+      # @param [ActiveRecord::Base, nil] base
+      # @param [Hash<Symbol, Object>] options
+      # @option options [#call] :find_or_initialize_by
+      # @option options [#call] :new
+      # @return [Array<Object>]
+      # @raise [ArgumentError]
+      def _find_or_initialize(acc, record_model, base = nil, **options)
+        acc[record_model] ||= ActsAsTable.adapter.get_value_for(record_model, base, **@options)
+
+        [acc, base]
+      end
+    end
+
+    # Set the new value for the given record using the given options.
+    #
+    # @!attribute [r] new_value_by_record_model_and_value_provider
+    #   The new values by ActsAsTable record model and value provider for this ActsAsTable "destructive" traversal.
+    #
+    #   @return [Hash<ActsAsTable::RecordModel, Hash<ActsAsTable::ValueProvider::InstanceMethods, Object>>]
+    # @!attribute [r] options
+    #   The options for this ActsAsTable "destructive" traversal.
+    #
+    #   @return [Hash<Symbol, Object>]
+    class SetValue < FindOrInitializeBy
+      attr_reader :new_value_by_record_model_and_value_provider, :options
+
+      # Returns a new ActsAsTable "destructive" traversal.
+      #
+      # @param [Hash<ActsAsTable::RecordModel, Hash<ActsAsTable::ValueProvider::InstanceMethods, Object>>] new_value_by_record_model_and_value_provider
+      # @param [Hash<Symbol, Object>] options
+      # @option options [Boolean] :default
+      # @return [ActsAsTable::RecordModelClassMethods::SetValue]
+      def initialize(new_value_by_record_model_and_value_provider = {}, **options)
+        super()
+
+        options.assert_valid_keys(:default)
+
+        @new_value_by_record_model_and_value_provider, @options = new_value_by_record_model_and_value_provider, options.dup
+      end
+
+      # Invokes the traversal.
+      #
+      # @param [ActsAsTable::RecordModel] record_model
+      # @param [ActiveRecord::Base, nil] base
+      # @return [ActsAsTable::ValueProvider::WrappedValue]
+      # @raise [ArgumentError] If the name of a class for a given record does not match the class name for the corresponding ActsAsTable record model.
+      def call(record_model, base = nil)
+        ActsAsTable.adapter.wrap_value_for(record_model, base, nil, self.inject({}, record_model, base))
+      end
+
+      protected
+
+      # @param [Hash<ActsAsTable::RecordModel, Array<Object>>] acc
+      # @param [ActsAsTable::Path] path
+      # @yieldparam [Hash<ActsAsTable::RecordModel, Array<Object>>] acc
+      # @yieldparam [ActsAsTable::Path] path
+      # @yieldreturn [Hash<ActsAsTable::RecordModel, Array<Object>>]
+      # @return [Hash<ActsAsTable::RecordModel, Array<Object>>]
+      # @raise [ArgumentError]
+      def _around_inject(acc, path, &block)
+        # @return [ActsAsTable::RecordModel]
+        source_record_model = path.options.dig(:data, :source_record_model)
+
+        # @return [ActsAsTable::RecordModel]
+        target_record_model = path.options.dig(:data, :target_record_model)
+
+        if path.collect(&:options).any? { |options| options.dig(:data, :source_record_model) == target_record_model }
+          acc
+        else
+          # @return [Hash<ActsAsTable::RecordModel, Array<Object>>]
+          new_acc = block.call(acc)
+
+          unless source_record_model.nil?
+            if new_acc[target_record_model][1].changed?
+              new_acc[source_record_model][1].changed!
+            end
+          end
+
+          new_acc
+        end
+      end
+
+      # @param [Hash<ActsAsTable::RecordModel, Array<Object>>] acc
+      # @param [ActsAsTable::RecordModel] record_model
+      # @return [ActiveRecord::Base, nil]
+      def _at(acc, record_model)
+        acc.key?(record_model) ? acc[record_model][0] : nil
+      end
+
+      # @param [Hash<ActsAsTable::RecordModel, Array<Object>>] acc
+      # @param [ActsAsTable::RecordModel] record_model
+      # @param [ActiveRecord::Base, nil] base
+      # @param [Hash<Symbol, Object>] options
+      # @option options [#call] :find_or_initialize_by
+      # @option options [#call] :new
+      # @return [Array<Object>]
+      # @raise [ArgumentError]
+      def _find_or_initialize(acc, record_model, base = nil, **options)
+        acc[record_model] ||= begin
+          # @return [Hash<ActsAsTable::ValueProvider::InstanceMethods, Object>, nil]
+          orig_value_by_value_provider = @new_value_by_record_model_and_value_provider.try(:[], record_model)
+
+          unless (primary_key = record_model.primary_keys.first).nil? || (base_id = orig_value_by_value_provider.try(:[], primary_key)).nil?
+            # @return [ActiveRecord::Base]
+            # @raise [ActiveRecord::RecordNotFound]
+            base = options[:find_or_initialize_by].call({
+              primary_key.method_name => base_id,
+            })
+
+            # @return [Hash<ActsAsTable::ValueProvider::InstanceMethods, Object>, nil]
+            new_value_by_value_provider = orig_value_by_value_provider.try(:each_pair).try(:all?) { |pair|
+              (pair[0] == primary_key) || pair[0].column_model.nil? || pair[1].nil?
+            } ? orig_value_by_value_provider.try(:delete_if) { |value_provider, value|
+              value_provider != primary_key
+            } : orig_value_by_value_provider.try(:delete_if) { |value_provider, value|
+              value_provider.column_model.nil?
+            }
+
+            [
+              base,
+              ActsAsTable.adapter.set_value_for(record_model, base, new_value_by_value_provider, **@options),
+            ]
+          else
+            if base.nil?
+              base = options[:new].call
+            end
+
+            [
+              base,
+              ActsAsTable.adapter.set_value_for(record_model, base, orig_value_by_value_provider, **@options),
+            ]
+          end
+        end
+
+        [acc, base]
+      end
+    end
+  end
+end