acts_as_table 0.0.1

data/app/models/acts_as_table/has_many_target.rb

@@ -0,0 +1,40 @@
+module ActsAsTable
+  # ActsAsTable collection macro association target.
+  #
+  # @!attribute [rw] position
+  #   Returns the position of this ActsAsTable collection macro association target.
+  #
+  #   @return [Integer]
+  class HasManyTarget < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.has_many_targets_table
+
+    # Returns the ActsAsTable collection macro association for this target.
+    belongs_to :has_many, **{
+      class_name: 'ActsAsTable::HasMany',
+      inverse_of: :has_many_targets,
+      required: true,
+    }
+
+    # Returns the ActsAsTable record model for this ActsAsTable collection macro association target.
+    belongs_to :record_model, **{
+      class_name: 'ActsAsTable::RecordModel',
+      inverse_of: :has_many_targets,
+      required: true,
+    }
+
+    validates :position, **{
+      numericality: {
+        greater_than_or_equal_to: 1,
+        only_integer: true,
+      },
+      presence: true,
+      uniqueness: {
+        scope: ['has_many_id'],
+      },
+    }
+  end
+end

data/app/models/acts_as_table/lense.rb

@@ -0,0 +1,131 @@
+module ActsAsTable
+  # ActsAsTable attribute accessor (value provider).
+  #
+  # @note The name "Lense" was selected for 2 reasons: similarity of behavior of this class and the corresponding type(s) in the Haskell package, [lens](https://hackage.haskell.org/package/lens); and that "Attribute" is not allowed as a Ruby on Rails model class name (because the corresponding table name would be "attributes", which would conflict with {ActiveRecord::AttributeMethods#attributes}).
+  #
+  # @!attribute [rw] default_value
+  #   Returns the default value for this ActsAsTable attribute accessor.
+  #
+  #   @return [String, nil]
+  # @!attribute [rw] method_name
+  #   Returns the method name for this ActsAsTable attribute accessor (an `attr_reader` or a Ruby on Rails model column name).
+  #
+  #   @return [String]
+  class Lense < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProvider::InstanceMethods
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.lenses_table
+
+    acts_as_table_value_provider
+
+    # Returns the ActsAsTable column model for this ActsAsTable attribute accessor or `nil`.
+    #
+    # @return [ActsAsTable::ColumnModel, nil]
+    belongs_to :column_model, **{
+      class_name: 'ActsAsTable::ColumnModel',
+      inverse_of: :lenses,
+      required: false,
+    }
+
+    # Returns the ActsAsTable record model for this ActsAsTable attribute accessor.
+    belongs_to :record_model, **{
+      class_name: 'ActsAsTable::RecordModel',
+      inverse_of: :lenses,
+      required: true,
+    }
+
+    # Returns the ActsAsTable values that have been provided by this ActsAsTable attribute accessor.
+    has_many :values, **{
+      as: :value_provider,
+      class_name: 'ActsAsTable::Value',
+      dependent: :restrict_with_exception,
+      foreign_key: 'value_provider_id',
+      foreign_type: 'value_provider_type',
+      inverse_of: :value_provider,
+    }
+
+    validates :default_value, **{
+      presence: {
+        unless: :column_model,
+      },
+    }
+
+    validates :method_name, **{
+      presence: true,
+    }
+
+    validate :record_model_class_must_respond_to_method_name, **{
+      if: ::Proc.new { |lense| lense.method_name.present? },
+    }
+
+    protected
+
+    # @param [ActiveRecord::Base, nil] base
+    # @return [Object, nil]
+    def _get_value(base = nil)
+      if base.nil?
+        nil
+      else
+        base.send(:"#{self.method_name}")
+      end
+    end
+
+    # @param [ActiveRecord::Base, nil] base
+    # @param [Object, nil] new_value
+    # @return [Array<Object>]
+    def _set_value(base = nil, new_value = nil)
+      if base.nil?
+        [
+          nil,
+          false,
+        ]
+      else
+        # @return [Object, nil]
+        orig_value = _get_value(base)
+
+        # @return [Boolean]
+        changed = !self.column_model.nil? && !(orig_value.nil? ? new_value.nil? : (new_value.nil? ? false : orig_value.to_s.eql?(new_value.to_s)))
+
+        [
+          base.send(:"#{self.method_name}=", new_value),
+          changed,
+        ]
+      end
+    end
+
+    private
+
+    # @param [Class] klass
+    # @param [String] attribute_name
+    # @return [Boolean]
+    def _attr_accessor?(klass, attribute_name)
+      [
+        :"#{attribute_name}",
+        :"#{attribute_name}=",
+      ].all? { |sym|
+        klass.instance_methods.include?(sym)
+      }
+    end
+
+    # @param [Class] klass
+    # @param [String] column_name
+    # @return [Boolean]
+    def _column?(klass, column_name)
+      klass.column_names.include?(column_name.to_s)
+    end
+
+    # @return [void]
+    def record_model_class_must_respond_to_method_name
+      self.record_model.try { |record_model| record_model.class_name.constantize rescue nil }.try { |klass|
+        unless _attr_accessor?(klass, self.method_name) || _column?(klass, self.method_name)
+          self.errors.add('method_name', :required)
+        end
+      }
+
+      return
+    end
+  end
+end

data/app/models/acts_as_table/primary_key.rb

@@ -0,0 +1,108 @@
+module ActsAsTable
+  # ActsAsTable primary key (value provider).
+  #
+  # @!attribute [rw] method_name
+  #   Returns the method name for this ActsAsTable primary key (a Ruby on Rails model column name).
+  #
+  #   @return [String]
+  class PrimaryKey < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProvider::InstanceMethods
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.primary_keys_table
+
+    acts_as_table_value_provider
+
+    # Returns the ActsAsTable column model for this ActsAsTable primary key or `nil`.
+    #
+    # @return [ActsAsTable::ColumnModel, nil]
+    belongs_to :column_model, **{
+      class_name: 'ActsAsTable::ColumnModel',
+      inverse_of: :primary_keys,
+      required: false,
+    }
+
+    # Returns the ActsAsTable record model for this ActsAsTable primary key.
+    belongs_to :record_model, **{
+      class_name: 'ActsAsTable::RecordModel',
+      inverse_of: :primary_keys,
+      required: true,
+    }
+
+    # Returns the ActsAsTable values that have been provided by this ActsAsTable primary key.
+    has_many :values, **{
+      as: :value_provider,
+      class_name: 'ActsAsTable::Value',
+      dependent: :restrict_with_exception,
+      foreign_key: 'value_provider_id',
+      foreign_type: 'value_provider_type',
+      inverse_of: :value_provider,
+    }
+
+    validates :method_name, **{
+      presence: true,
+    }
+
+    validates :record_model_id, **{
+      uniqueness: true,
+    }
+
+    validate :record_model_class_must_respond_to_method_name, **{
+      if: ::Proc.new { |primary_key| primary_key.method_name.present? },
+    }
+
+    protected
+
+    # @param [ActiveRecord::Base, nil] base
+    # @return [Object, nil]
+    def _get_value(base = nil)
+      if base.nil?
+        nil
+      else
+        base.send(:"#{self.method_name}")
+      end
+    end
+
+    # @param [ActiveRecord::Base, nil] base
+    # @param [Object, nil] new_value
+    # @return [Array<Object>]
+    def _set_value(base = nil, new_value = nil)
+      if base.nil?
+        [
+          nil,
+          false,
+        ]
+      else
+        # @return [Object, nil]
+        orig_value = _get_value(base)
+
+        [
+          orig_value,
+          false,
+        ]
+      end
+    end
+
+    private
+
+    # @param [Class] klass
+    # @param [String] column_name
+    # @return [Boolean]
+    def _column?(klass, column_name)
+      klass.column_names.include?(column_name.to_s)
+    end
+
+    # @return [void]
+    def record_model_class_must_respond_to_method_name
+      self.record_model.try { |record_model| record_model.class_name.constantize rescue nil }.try { |klass|
+        unless _column?(klass, self.method_name)
+          self.errors.add('method_name', :required)
+        end
+      }
+
+      return
+    end
+  end
+end

data/app/models/acts_as_table/record.rb

@@ -0,0 +1,109 @@
+module ActsAsTable
+  # ActsAsTable record.
+  #
+  # @!attribute [rw] position
+  #   Returns the position of this ActsAsTable record.
+  #
+  #   @return [Integer]
+  # @!attribute [r] record_errors_count
+  #   Returns the number of ActsAsTable record errors for this ActsAsTable record.
+  #
+  #   @return [Integer]
+  # @!attribute [rw] record_model_changed
+  #   Returns `true` if the ActsAsTable record model changed the record for this ActsAsTable record. Otherwise, returns `false`.
+  #
+  #   @return [Boolean]
+  # @!attribute [r] values_count
+  #   Returns the number of ActsAsTable values for this ActsAsTable record.
+  #
+  #   @return [Integer]
+  class Record < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.records_table
+
+    # Returns the record for this ActsAsTable record or `nil`.
+    #
+    # @return [ActiveRecord::Base, nil]
+    belongs_to :base, **{
+      polymorphic: true,
+      required: false,
+    }
+
+    # Returns the ActsAsTable record model for this ActsAsTable record.
+    belongs_to :record_model, **{
+      class_name: 'ActsAsTable::RecordModel',
+      inverse_of: :records,
+      required: true,
+    }
+
+    # Returns the ActsAsTable table for this ActsAsTable record.
+    belongs_to :table, **{
+      class_name: 'ActsAsTable::Table',
+      counter_cache: 'records_count',
+      inverse_of: :records,
+      required: true,
+    }
+
+    # Returns the ActsAsTable record errors for this ActsAsTable record.
+    has_many :record_errors, -> { order(attribute_name: :asc, message: :asc) }, **{
+      autosave: true,
+      class_name: 'ActsAsTable::RecordError',
+      dependent: :destroy,
+      foreign_key: 'record_id',
+      inverse_of: :record,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable values for this ActsAsTable record.
+    has_many :values, -> { order(position: :asc) }, **{
+      autosave: true,
+      class_name: 'ActsAsTable::Value',
+      dependent: :destroy,
+      foreign_key: 'record_id',
+      inverse_of: :record,
+      validate: true,
+    }
+
+    validates :position, **{
+      numericality: {
+        greater_than_or_equal_to: 1,
+        only_integer: true,
+      },
+      presence: true,
+      uniqueness: {
+        scope: ['table_id', 'record_model_id'],
+      },
+    }
+
+    # validates :record_model_changed, **{}
+
+    validate :record_must_be_valid_class, :record_model_must_belong_to_row_model_for_table, **{
+      if: ::Proc.new { |record| record.record_model.present? },
+    }
+
+    private
+
+    # @return [void]
+    def record_must_be_valid_class
+      self.record_type.try { |record_type|
+        unless record_type.eql?(self.record_model.class_name)
+          self.errors.add('record_type', :invalid)
+        end
+      }
+    end
+
+    # @return [void]
+    def record_model_must_belong_to_row_model_for_table
+      self.table.try(:row_model).try(:record_models).try { |record_models|
+        unless record_models.include?(self.record_model)
+          self.errors.add('record_model_id', :invalid)
+        end
+      }
+
+      return
+    end
+  end
+end

data/app/models/acts_as_table/record_error.rb

@@ -0,0 +1,50 @@
+module ActsAsTable
+  # ActsAsTable record error.
+  #
+  # @!attribute [rw] attribute_name
+  #   Returns the attribute name for this ActsAsTable record error.
+  #
+  #   @note The attribute name for model-level errors is "base".
+  #
+  #   @return [String]
+  # @!attribute [rw] message
+  #   Returns the message for this ActsAsTable record error.
+  #
+  #   @return [String]
+  class RecordError < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.record_errors_table
+
+    # Returns the ActsAsTable record for this error.
+    belongs_to :record, **{
+      class_name: 'ActsAsTable::Record',
+      counter_cache: 'record_errors_count',
+      inverse_of: :record_errors,
+      required: true,
+    }
+
+    # Returns the ActsAsTable value for this error or `nil`.
+    #
+    # @return [ActsAsTable::Value, nil]
+    belongs_to :value, **{
+      class_name: 'ActsAsTable::Value',
+      counter_cache: 'record_errors_count',
+      inverse_of: :record_errors,
+      required: false,
+    }
+
+    validates :attribute_name, **{
+      presence: true,
+    }
+
+    validates :message, **{
+      presence: true,
+      uniqueness: {
+        scope: ['record_id', 'attribute_name'],
+      },
+    }
+  end
+end

data/app/models/acts_as_table/record_model.rb

@@ -0,0 +1,194 @@
+module ActsAsTable
+  # ActsAsTable record model (value provider).
+  #
+  # @!attribute [rw] class_name
+  #   Returns the ActiveRecord model class name for this ActsAsTable record model.
+  #
+  #   @return [String]
+  class RecordModel < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProvider::InstanceMethods
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.record_models_table
+
+    acts_as_table_value_provider
+
+    # Returns the ActsAsTable row model for this ActsAsTable record model.
+    belongs_to :row_model, **{
+      class_name: 'ActsAsTable::RowModel',
+      inverse_of: :record_models,
+      required: true,
+    }
+
+    # Returns the ActsAsTable singular macro associations where this ActsAsTable record model is the source of the association.
+    has_many :belongs_tos_as_source, **{
+      autosave: true,
+      class_name: 'ActsAsTable::BelongsTo',
+      dependent: :destroy,
+      foreign_key: 'source_record_model_id',
+      inverse_of: :source_record_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable singular macro associations where this ActsAsTable record model is the target of the association.
+    has_many :belongs_tos_as_target, **{
+      autosave: true,
+      class_name: 'ActsAsTable::BelongsTo',
+      dependent: :destroy,
+      foreign_key: 'target_record_model_id',
+      inverse_of: :target_record_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable foreign keys for this ActsAsTable record model.
+    has_many :foreign_keys, **{
+      autosave: true,
+      class_name: 'ActsAsTable::ForeignKey',
+      dependent: :destroy,
+      foreign_key: 'record_model_id',
+      inverse_of: :record_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable collection macro associations where this ActsAsTable record model is the source of the association.
+    has_many :has_manies_as_source, **{
+      autosave: true,
+      class_name: 'ActsAsTable::HasMany',
+      dependent: :destroy,
+      foreign_key: 'source_record_model_id',
+      inverse_of: :source_record_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable collection macro associations where this ActsAsTable record model is the target of the association.
+    has_many :has_manies_as_target, -> { readonly }, **{
+      source: :has_many,
+      through: :has_many_targets,
+    }
+
+    # Returns the ActsAsTable collection macro association targets for this ActsAsTable record model.
+    has_many :has_many_targets, **{
+      autosave: true,
+      class_name: 'ActsAsTable::HasManyTarget',
+      dependent: :destroy,
+      foreign_key: 'record_model_id',
+      inverse_of: :record_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable attribute accessors for this ActsAsTable record model.
+    has_many :lenses, **{
+      autosave: true,
+      class_name: 'ActsAsTable::Lense',
+      dependent: :destroy,
+      foreign_key: 'record_model_id',
+      inverse_of: :record_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable primary keys for this ActsAsTable record model.
+    has_many :primary_keys, **{
+      autosave: true,
+      class_name: 'ActsAsTable::PrimaryKey',
+      dependent: :destroy,
+      foreign_key: 'record_model_id',
+      inverse_of: :record_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable records that have been provided by this ActsAsTable record model.
+    has_many :records, **{
+      class_name: 'ActsAsTable::Record',
+      dependent: :restrict_with_exception,
+      foreign_key: 'record_model_id',
+      inverse_of: :record_model,
+    }
+
+    # Returns the ActsAsTable row models where this ActsAsTable record model is the root.
+    has_many :row_models_as_root, **{
+      class_name: 'ActsAsTable::RowModel',
+      dependent: :restrict_with_exception,
+      foreign_key: 'root_record_model_id',
+      inverse_of: :root_record_model,
+    }
+
+    validates :class_name, **{
+      presence: true,
+    }
+
+    validate :base_must_be_reachable
+
+    validate :class_name_must_constantize, **{
+      if: ::Proc.new { |record_model| record_model.class_name.present? },
+    }
+
+    # 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]
+    def get_value(base = nil, **options)
+      unless base.nil? || self.class_name.eql?(base.class.name)
+        raise ::ArgumentError.new("record - invalid class - expected: #{self.class_name.inspect}, found: #{base.inspect}")
+      end
+
+      # @return [Hash<ActsAsTable::ValueProvider::InstanceMethods, Object>]
+      value_by_value_provider = self.each_acts_as_table_value_provider(except: [:row_model]).inject({}) { |acc, value_provider|
+        acc[value_provider] ||= base.nil? ? ActsAsTable.adapter.wrap_value_for(value_provider, base, nil, nil) : ActsAsTable.adapter.get_value_for(value_provider, base, **options)
+        acc
+      }
+
+      ActsAsTable.adapter.wrap_value_for(self, base, nil, value_by_value_provider)
+    end
+
+    # Set the new value for the given record using the given options.
+    #
+    # @param [ActiveRecord::Base, nil] base
+    # @param [Hash<ActsAsTable::ValueProvider::InstanceMethods, Object>] new_value_by_value_provider
+    # @param [Hash<Symbol, Object>] options
+    # @option options [Boolean] :default
+    # @return [ActsAsTable::ValueProvider::WrappedValue]
+    def set_value(base = nil, new_value_by_value_provider = {}, **options)
+      unless base.nil? || self.class_name.eql?(base.class.name)
+        raise ::ArgumentError.new("record - invalid class - expected: #{self.class_name.inspect}, found: #{base.inspect}")
+      end
+
+      # @return [Array<Object>]
+      value_by_value_provider, changed = *self.each_acts_as_table_value_provider(except: [:row_model]).inject([{}, false]) { |acc, value_provider|
+        # @return [Object, nil]
+        new_value = new_value_by_value_provider.try(:[], value_provider)
+
+        acc[0][value_provider] ||= base.nil? ? ActsAsTable.adapter.wrap_value_for(value_provider, base, nil, nil) : ActsAsTable.adapter.set_value_for(value_provider, base, new_value, **options)
+        acc[1] ||= acc[0][value_provider].changed?
+        acc
+      }
+
+      ActsAsTable.adapter.wrap_value_for(self, base, nil, value_by_value_provider, changed: changed)
+    end
+
+    private
+
+    # @return [void]
+    def base_must_be_reachable
+      if self.row_model.try(:reachable_record_model?, self) == false
+        self.errors.add(:base, :unreachable)
+      end
+
+      return
+    end
+
+    # @return [void]
+    def class_name_must_constantize
+      begin
+        self.class_name.constantize
+      rescue ::NameError
+        self.errors.add('class_name', :invalid)
+      end
+
+      return
+    end
+  end
+end