voids 2.0.0

data/lib/voids/association_proxy.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Voids
+  # Array-like proxy for form associations.
+  class AssociationProxy
+    include Enumerable
+
+    def initialize(class_name)
+      @class_name = class_name
+      @records = []
+      @records_by_id = {}
+    end
+
+    def new(attributes = {})
+      form_class = @class_name.constantize
+      instance = form_class.new(attributes)
+      push(instance)
+      instance
+    end
+
+    def build(attributes = {})
+      new(attributes)
+    end
+
+    def find_by_id(id)
+      @records_by_id[id.to_s]
+    end
+
+    def find_by(attribute, value)
+      return @records_by_id[value.to_s] if attribute.to_s == 'id' && @records_by_id.key?(value.to_s)
+
+      @records.find do |record|
+        record.respond_to?(attribute) && record.public_send(attribute).to_s == value.to_s
+      end
+    end
+
+    def push(record)
+      @records << record
+      @records_by_id[record.id.to_s] = record if record.respond_to?(:id) && record.id.present?
+      self
+    end
+    alias << push
+
+    def each(&)
+      @records.each(&)
+    end
+
+    def size
+      @records.size
+    end
+    alias length size
+    alias count size
+
+    def empty?
+      @records.empty?
+    end
+
+    def any?
+      @records.any?
+    end
+
+    def [](index)
+      @records[index]
+    end
+
+    def clear
+      @records.clear
+      @records_by_id.clear
+    end
+
+    def to_a
+      @records
+    end
+
+    def to_ary
+      @records
+    end
+
+    def persisted?
+      false
+    end
+
+    def valid?
+      @records.all?(&:valid?)
+    end
+
+    def errors
+      @records.flat_map(&:errors)
+    end
+  end
+end

data/lib/voids/associations.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Voids
+  # Association declarations for form objects (`has_one` / `has_many`)
+  module Associations
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :associations, default: {}
+    end
+
+    class_methods do
+      def has_one(name, class_name: nil, primary_key: :id, **)
+        association_class_name = class_name || "#{name.to_s.camelize}Form"
+
+        self.associations = associations.merge(
+          name.to_s => { type: :has_one, class_name: association_class_name, primary_key: primary_key.to_s }
+        )
+
+        attr_reader name
+
+        define_method("#{name}=") do |value|
+          instance_variable_set("@#{name}", value)
+        end
+
+        define_method("build_#{name}") do |attributes = {}|
+          form_class = association_class_name.constantize
+          instance = form_class.new(attributes)
+          instance_variable_set("@#{name}", instance)
+          instance
+        end
+
+        accepts_nested_attributes_for(name, primary_key: primary_key, **)
+      end
+
+      def has_many(name, class_name: nil, primary_key: :id, **)
+        association_class_name = class_name || "#{name.to_s.singularize.camelize}Form"
+
+        self.associations = associations.merge(
+          name.to_s => { type: :has_many, class_name: association_class_name, primary_key: primary_key.to_s }
+        )
+
+        define_method(name) do
+          ivar = "@#{name}"
+          unless instance_variable_defined?(ivar)
+            instance_variable_set(ivar, AssociationProxy.new(association_class_name))
+          end
+          instance_variable_get(ivar)
+        end
+
+        define_method("#{name}=") do |value|
+          instance_variable_set("@#{name}", value)
+        end
+
+        accepts_nested_attributes_for(name, primary_key: primary_key, **)
+      end
+    end
+  end
+end

data/lib/voids/base.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module Voids
+  # Main class to be subclassed by collaborators
+  class Base
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Validations
+    include ActiveModel::Dirty
+    include ActiveModel::Callbacks
+    include Voids::ModelNaming
+    include Voids::Normalization
+    include Voids::Associations
+    include Voids::NestedAttributes
+
+    define_model_callbacks :validation
+
+    def self.inherit_attributes_from(model_class, only: nil, except: nil)
+      raise ArgumentError, 'cannot specify both :only and :except' if only && except
+
+      attribute_names = if model_class.respond_to?(:attribute_types)
+                          model_class.attribute_types.keys
+                        elsif model_class.respond_to?(:columns)
+                          model_class.columns.map(&:name)
+                        else
+                          raise ArgumentError, "#{model_class} does not respond to :attribute_types or :columns"
+                        end
+
+      attribute_names = Array(only).map(&:to_s) if only
+      attribute_names -= Array(except).map(&:to_s) if except
+
+      attribute_names.each do |attr_name|
+        next if attribute_types.key?(attr_name)
+
+        attr_type = if model_class.respond_to?(:attribute_types)
+                      model_class.attribute_types[attr_name]
+                    elsif model_class.respond_to?(:columns)
+                      column = model_class.columns.find { |c| c.name == attr_name }
+                      column&.type
+                    end
+
+        attribute attr_name.to_sym, attr_type&.type || :value
+      end
+    end
+
+    def self.inherit_validations_from(model_class, only: nil, except: nil)
+      raise ArgumentError, 'cannot specify both :only and :except' if only && except
+
+      model_class.validators.each do |validator|
+        next if skip_validator?(validator)
+
+        attrs = validator.attributes.dup
+        attrs &= Array(only).map(&:to_sym) if only
+        attrs -= Array(except).map(&:to_sym) if except
+        next if attrs.empty?
+
+        options = validator.options.except(:class)
+        kind = validator.kind
+
+        if options.empty?
+          validates(*attrs, kind => true)
+        else
+          validates(*attrs, kind => options)
+        end
+      end
+    end
+
+    def self.skip_validator?(validator)
+      if defined?(ActiveRecord::Validations::AssociatedValidator) && validator.is_a?(ActiveRecord::Validations::AssociatedValidator)
+        return true
+      end
+
+      opts = validator.options
+      %i[if unless].any? { |key| opts[key].is_a?(Proc) }
+    end
+    private_class_method :skip_validator?
+
+    def self.from_model(model)
+      instance = new
+      instance.from_model(model)
+      instance
+    end
+
+    def initialize(attributes = {})
+      super()
+      @marked_for_destruction = false
+      assign_attributes(attributes) if attributes.present?
+    end
+
+    def assign_attributes(new_attributes)
+      return if new_attributes.blank?
+
+      attrs = if new_attributes.respond_to?(:to_unsafe_h)
+                new_attributes.to_unsafe_h.stringify_keys
+              elsif new_attributes.respond_to?(:to_h)
+                new_attributes.to_h.stringify_keys
+              else
+                new_attributes.stringify_keys
+              end
+
+      attrs.each do |key, value|
+        if key.end_with?('_attributes')
+          association_name = key.delete_suffix('_attributes')
+          send("#{association_name}_attributes=", value)
+        elsif key == '_destroy'
+          self._destroy = value
+        else
+          public_send("#{key}=", value)
+        end
+      end
+
+      changes_applied
+    end
+
+    def from_model(model)
+      return self if model.nil?
+
+      self.class.attribute_names.each do |attr_name|
+        public_send("#{attr_name}=", model.public_send(attr_name)) if model.respond_to?(attr_name)
+      end
+
+      self.class.associations.each do |name, association|
+        next unless model.respond_to?(name)
+
+        associated_value = model.public_send(name)
+        next if associated_value.nil?
+
+        case association[:type]
+        when :has_one
+          form_instance = association[:class_name].constantize.new
+          form_instance.from_model(associated_value)
+          public_send("#{name}=", form_instance)
+        when :has_many
+          associated_value.each do |record|
+            form_instance = association[:class_name].constantize.new
+            form_instance.from_model(record)
+            public_send(name).push(form_instance)
+          end
+        end
+      end
+
+      self
+    end
+
+    def persisted?
+      respond_to?(:id) && id.present?
+    end
+
+    def to_key
+      persisted? ? [id] : nil
+    end
+
+    def to_param
+      persisted? ? id.to_s : nil
+    end
+
+    def to_model
+      self
+    end
+
+    def marked_for_destruction?
+      @marked_for_destruction
+    end
+
+    def mark_for_destruction
+      @marked_for_destruction = true
+    end
+
+    def _destroy
+      @marked_for_destruction
+    end
+
+    def _destroy=(value)
+      @marked_for_destruction = ActiveModel::Type::Boolean.new.cast(value)
+    end
+
+    def valid?(context = nil)
+      run_callbacks :validation do
+        super(context) && nested_forms_valid?
+      end
+    end
+
+    def model_attributes
+      attribute_names.to_h do |name|
+        [name, public_send(name)]
+      end
+    end
+
+    def attributes
+      attrs = model_attributes.dup
+
+      self.class.associations.each do |name, association|
+        nested_form = public_send(name)
+        next if nested_form.nil?
+
+        case association[:type]
+        when :has_one
+          nested_attrs = nested_form.attributes
+          nested_attrs['_destroy'] = true if nested_form.marked_for_destruction?
+          attrs["#{name}_attributes"] = nested_attrs
+        when :has_many
+          attrs["#{name}_attributes"] = nested_form.map do |form|
+            form_attrs = form.attributes
+            form_attrs['_destroy'] = true if form.marked_for_destruction?
+            form_attrs
+          end
+        end
+      end
+
+      attrs
+    end
+
+    def assignable_attributes(exclude: [:id])
+      excluded_keys = Array(exclude).map(&:to_s)
+      attributes.except(*excluded_keys)
+    end
+
+    private
+
+    def nested_forms_valid?
+      self.class.associations.all? do |name, association|
+        nested_form = public_send(name)
+        next true if nested_form.nil?
+
+        case association[:type]
+        when :has_one
+          if nested_form.valid?
+            true
+          else
+            copy_nested_errors(name, nested_form)
+            false
+          end
+        when :has_many
+          if nested_form.valid?
+            true
+          else
+            nested_form.each_with_index do |form, index|
+              copy_nested_errors("#{name}[#{index}]", form) unless form.valid?
+            end
+            false
+          end
+        end
+      end
+    end
+
+    def copy_nested_errors(association_name, nested_form)
+      nested_form.errors.each do |error|
+        errors.add("#{association_name}.#{error.attribute}", error.message)
+      end
+    end
+  end
+end

data/lib/voids/model_naming.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Voids
+  # Allows form objects to override `model_name` for Rails helpers.
+  module ModelNaming
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_model_name_override
+    end
+
+    class_methods do
+      def model_name
+        return _model_name_override if _model_name_override
+
+        name_without_form = name.sub(/Form$/, '')
+        ActiveModel::Name.new(self, nil, name_without_form)
+      end
+
+      def model_name_for(name)
+        self._model_name_override = ActiveModel::Name.new(self, nil, name.to_s.camelize)
+      end
+    end
+  end
+end

data/lib/voids/nested_attributes.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Voids
+  # A lightweight `accepts_nested_attributes_for` implementation for Voids forms.
+  module NestedAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :nested_attributes_options, default: {}
+    end
+
+    class_methods do
+      def accepts_nested_attributes_for(*attr_names)
+        options = attr_names.extract_options!
+
+        attr_names.each do |association_name|
+          self.nested_attributes_options = nested_attributes_options.merge(
+            association_name.to_s => options
+          )
+
+          define_nested_attributes_method(association_name)
+        end
+      end
+
+      private
+
+      def define_nested_attributes_method(association_name)
+        define_method("#{association_name}_attributes=") do |attributes|
+          association = self.class.associations[association_name.to_s]
+
+          raise ArgumentError, "No association found for name '#{association_name}'" unless association
+
+          case association[:type]
+          when :has_one
+            assign_nested_attributes_for_one_to_one_association(association_name, attributes)
+          when :has_many
+            assign_nested_attributes_for_collection_association(association_name, attributes)
+          end
+        end
+      end
+    end
+
+    def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
+      return if attributes.blank?
+
+      association = self.class.associations[association_name.to_s]
+      options = self.class.nested_attributes_options[association_name.to_s] || {}
+      form_class = association[:class_name].constantize
+      attrs_hash = attributes.stringify_keys
+
+      if has_destroy_flag?(attrs_hash) && options[:allow_destroy]
+        instance = public_send(association_name)
+        instance&.mark_for_destruction
+        return
+      end
+
+      instance = public_send(association_name)
+      attrs_without_destroy = attrs_hash.except('_destroy')
+      if instance
+        instance.assign_attributes(attrs_without_destroy)
+      else
+        instance = form_class.new(attrs_without_destroy)
+        public_send("#{association_name}=", instance)
+      end
+    end
+
+    def assign_nested_attributes_for_collection_association(association_name, attributes)
+      return if attributes.blank?
+
+      attributes_collection = attributes.is_a?(Hash) ? attributes.values : attributes
+      association = self.class.associations[association_name.to_s]
+      options = self.class.nested_attributes_options[association_name.to_s] || {}
+      association[:class_name].constantize
+      collection = public_send(association_name)
+      primary_key = (options[:primary_key] || association[:primary_key] || 'id').to_s
+
+      attributes_collection.each do |attrs|
+        next if call_reject_if(association_name, attrs)
+
+        attrs_hash = attrs.is_a?(Hash) ? attrs.stringify_keys : attrs
+
+        if has_destroy_flag?(attrs_hash)
+          if options[:allow_destroy] && attrs_hash[primary_key].present?
+            existing = collection.find_by(primary_key, attrs_hash[primary_key])
+            if existing
+              existing.mark_for_destruction
+            else
+              new_form = collection.new(attrs_hash.except('_destroy'))
+              new_form.mark_for_destruction
+            end
+          end
+          next
+        end
+
+        if attrs_hash[primary_key].present?
+          existing = collection.find_by(primary_key, attrs_hash[primary_key])
+          if existing
+            existing.assign_attributes(attrs_hash.except(primary_key, '_destroy'))
+          else
+            collection.new(attrs_hash.except('_destroy'))
+          end
+        else
+          collection.new(attrs_hash.except('_destroy'))
+        end
+      end
+    end
+
+    def call_reject_if(association_name, attributes)
+      options = self.class.nested_attributes_options[association_name.to_s]
+      return false unless options
+
+      reject_if = options[:reject_if]
+      return false unless reject_if
+
+      if reject_if.is_a?(Symbol)
+        method(reject_if).call(attributes)
+      else
+        reject_if.call(attributes)
+      end
+    end
+
+    def has_destroy_flag?(attributes)
+      attrs = attributes.stringify_keys
+      value = attrs['_destroy']
+      ActiveModel::Type::Boolean.new.cast(value)
+    end
+  end
+end

data/lib/voids/normalization.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Voids
+  # Provides attribute writer normalization via `normalizes`.
+  module Normalization
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_normalizations, instance_writer: false, default: {}
+    end
+
+    class_methods do
+      def normalizes(*names, with:, apply_to_nil: false)
+        names.each do |name|
+          _normalizations[name.to_s] = { normalizer: with, apply_to_nil: apply_to_nil }
+
+          define_method("#{name}=") do |value|
+            normalized_value = self.class.normalize_value_for(name, value)
+            super(normalized_value)
+          end
+        end
+      end
+
+      def normalize_value_for(name, value)
+        normalization = _normalizations[name.to_s]
+        return value unless normalization
+
+        return value if value.nil? && !normalization[:apply_to_nil]
+
+        normalizer = normalization[:normalizer]
+        if normalizer.respond_to?(:call)
+          normalizer.call(value)
+        else
+          value.public_send(normalizer)
+        end
+      end
+    end
+  end
+end

data/lib/voids/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Voids
+  VERSION = '2.0.0'
+end

data/lib/voids.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'active_support/concern'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/object/blank'
+require 'zeitwerk'
+
+# Autoload gem internals.
+Zeitwerk::Loader.for_gem.setup
+
+# Top-level module
+module Voids
+  # Custom exception wrapper
+  class Error < StandardError; end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+
+SimpleCov.start do
+  skip 'spec'
+
+  if ENV['CI']
+    require 'simplecov_json_formatter'
+
+    formatter SimpleCov::Formatter::JSONFormatter
+  end
+end
+
+require 'voids'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end