well_formed 0.1.0

data/lib/well_formed/initializer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module WellFormed
+  module Initializer
+    def self.included(base)
+      raise ArgumentError, "#{name} must be prepended, not included. Use `prepend #{name}` instead."
+    end
+
+    attr_reader :resource
+
+    def initialize(resource, params = {})
+      @resource = resource
+      super(resource_defaults.merge(params))
+      after_initialize if respond_to?(:after_initialize, true)
+    end
+
+    delegate :id, :persisted?, :to_param, to: :resource, allow_nil: true
+
+    def new_record? = !persisted?
+
+    private
+
+    def resource_defaults
+      return {} unless resource
+
+      self.class.attribute_names.each_with_object({}) do |name, hash|
+        hash[name] = resource.public_send(name) if resource.respond_to?(name)
+      end
+    end
+  end
+end

data/lib/well_formed/nested_attributes.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module WellFormed
+  module NestedAttributes
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Defines a collection nested form for validating nested attributes on a has_many association.
+      #
+      # Both `{name}_attributes=` (Rails form_with / form_for) and `{name}=` (API, no suffix)
+      # setters are defined automatically — whichever key your params contain will work.
+      #
+      # @param name [Symbol] the association name (e.g. :line_items)
+      # @param form_class [Class, nil] a ResourceForm class. Omit when supplying a block.
+      # @yieldparam block inline class body evaluated on an anonymous WellFormed::Base subclass.
+      #
+      # Records with `_destroy: true` are excluded from validation but forwarded to the resource.
+      #
+      # Example — inline block:
+      #   class CreateOrderForm < WellFormed::Base
+      #     include WellFormed::NestedAttributes
+      #     nested_attributes_for :line_items do
+      #       attribute :name, :string
+      #       validates :name, presence: true
+      #     end
+      #   end
+      def nested_attributes_for(name, form_class = nil, &block)
+        _register_nested(name, form_class, collection: true, &block)
+      end
+
+      # Defines a singular nested form for validating nested attributes on a has_one/belongs_to.
+      #
+      # Both `{name}_attributes=` and `{name}=` setters are defined automatically.
+      #
+      # Example — inline block:
+      #   class CreateOrderForm < WellFormed::Base
+      #     include WellFormed::NestedAttributes
+      #     nested_attribute_for :billing_address do
+      #       attribute :street, :string
+      #       validates :street, presence: true
+      #     end
+      #   end
+      def nested_attribute_for(name, form_class = nil, &block)
+        _register_nested(name, form_class, collection: false, &block)
+      end
+
+      def registered_nested_attributes
+        inherited = superclass.respond_to?(:registered_nested_attributes) ? superclass.registered_nested_attributes : {}
+        inherited.merge(@registered_nested_attributes ||= {})
+      end
+
+      private
+
+      def _nested_form_builder(synthetic_name, &block)
+        form_class = Class.new(WellFormed::SimpleNestedForm, &block)
+        form_class.define_singleton_method(:model_name) do
+          ActiveModel::Name.new(self, nil, synthetic_name)
+        end
+        form_class
+      end
+
+      def _register_nested(name, form_class, collection:, &block)
+        macro = collection ? "nested_attributes_for" : "nested_attribute_for"
+
+        if form_class && block
+          raise ArgumentError, "Pass either a form_class or a block to #{macro} :#{name}, not both"
+        end
+
+        if block
+          synthetic_name = name.to_s.singularize.camelize
+          form_class = _nested_form_builder(synthetic_name, &block)
+        end
+
+        raise ArgumentError, "A form_class or block is required for #{macro} :#{name}" unless form_class
+
+        (@registered_nested_attributes ||= {})[name] = {form_class: form_class, collection: collection}
+
+        define_method(name) do
+          if instance_variable_defined?(:"@#{name}")
+            instance_variable_get(:"@#{name}")
+          elsif resource.respond_to?(name)
+            raw = resource.public_send(name)
+            if collection
+              Array(raw).map { |r| _build_nested_form(form_class, r) }
+            else
+              raw ? _build_nested_form(form_class, raw) : nil
+            end
+          else
+            collection ? [] : nil
+          end
+        end
+
+        define_method(:"#{name}_attributes=") do |raw_attributes|
+          _build_nested_attributes(name, raw_attributes)
+        end
+
+        define_method(:"#{name}=") do |raw_attributes|
+          _build_nested_attributes(name, raw_attributes)
+        end
+
+        validate :"_validate_nested_#{name}"
+
+        define_method(:"_validate_nested_#{name}") do
+          instances = instance_variable_get(:"@#{name}")
+          return unless instances
+
+          config = self.class.registered_nested_attributes[name]
+
+          if config[:collection]
+            Array(instances).each_with_index do |nested_form, index|
+              next if nested_form.valid?
+              nested_form.errors.each do |error|
+                attr = :"#{name}[#{index}].#{error.attribute}"
+                if error.type.is_a?(Symbol)
+                  errors.add(attr, error.type, **error.options.merge(message: error.message))
+                else
+                  errors.add(attr, error.message)
+                end
+              end
+            end
+          else
+            return if instances.valid?
+            instances.errors.each do |error|
+              attr = :"#{name}.#{error.attribute}"
+              if error.type.is_a?(Symbol)
+                errors.add(attr, error.type, **error.options.merge(message: error.message))
+              else
+                errors.add(attr, error.message)
+              end
+            end
+          end
+        end
+        private :"_validate_nested_#{name}"
+      end
+    end
+
+    # ActiveModel::Error#generate_message always calls read_attribute_for_validation
+    # to supply a :value interpolation, even when a custom :message is present.
+    # Compound nested attribute names (e.g. :"line_items[0].name") are not real
+    # methods on the form — return nil for any attribute scoped under a registered
+    # nested association to avoid a NoMethodError.
+    def read_attribute_for_validation(attr)
+      attr_str = attr.to_s
+      nested_names = self.class.registered_nested_attributes.keys.map(&:to_s)
+      return nil if nested_names.any? { |name| attr_str.start_with?("#{name}[", "#{name}.") }
+      super
+    end
+
+    private
+
+    def _build_nested_attributes(name, raw_attributes)
+      @_nested_attributes_raw ||= {}
+      @_nested_attributes_raw[:"#{name}_attributes"] = raw_attributes
+
+      resource.public_send(:"#{name}_attributes=", raw_attributes) if resource.respond_to?(:"#{name}_attributes=")
+
+      config = self.class.registered_nested_attributes[name]
+      form_class = config[:form_class]
+      boolean_type = ActiveModel::Type::Boolean.new
+
+      if config[:collection]
+        attrs_list = raw_attributes.is_a?(Array) ? raw_attributes : Array(raw_attributes).map { |_, v| v }
+        instances = attrs_list.filter_map do |item_attrs|
+          item_attrs = item_attrs.to_h.with_indifferent_access
+          next if boolean_type.cast(item_attrs["_destroy"])
+
+          sub_resource = _find_collection_resource(name, item_attrs)
+          _build_nested_form(form_class, sub_resource, item_attrs.except("id", "_destroy"))
+        end
+        instance_variable_set(:"@#{name}", instances)
+      else
+        item_attrs = raw_attributes.to_h.with_indifferent_access
+        sub_resource = resource.respond_to?(name) ? resource.public_send(name) : nil
+        instance_variable_set(:"@#{name}", _build_nested_form(form_class, sub_resource, item_attrs))
+      end
+    end
+
+    def _build_nested_form(form_class, resource, attrs = {})
+      form_class.new(resource, attrs)
+    end
+
+    def _find_collection_resource(name, item_attrs)
+      id = item_attrs["id"]
+      return nil unless id && resource.respond_to?(name)
+
+      id_str = id.to_s
+      resource.public_send(name).find { |r| r.respond_to?(:id) && r.id.to_s == id_str }
+    rescue
+      nil
+    end
+  end
+end

data/lib/well_formed/nested_form.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module WellFormed
+  # Minimal base class for anonymous nested-attribute forms built via
+  # +nested_attributes_for+ / +nested_attribute_for+ blocks.
+  #
+  # Provides attribute definitions, validations, and collection helpers
+  # without the persistence / transactional concerns of ResourceForm.
+  # @api private
+  class NestedForm < SimpleNestedForm
+    include NestedAttributes
+    prepend WithUser
+  end
+end

data/lib/well_formed/performer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module WellFormed
+  module Performer
+    module Abstract
+      private
+
+      def perform
+        super
+      end
+    end
+
+    def self.included(base)
+      base.include(ActiveSupport::Callbacks)
+      base.define_callbacks(:perform)
+      base.extend(ClassMethods)
+      base.prepend(Abstract)
+    end
+
+    module ClassMethods
+      def before_perform(*args, &block)
+        set_callback(:perform, :before, *args, &block)
+      end
+
+      def after_perform(*args, &block)
+        set_callback(:perform, :after, *args, &block)
+      end
+
+      def inherited(subclass)
+        super
+        subclass.prepend(Abstract)
+      end
+    end
+
+    def submit!
+      submit || raise(WellFormed::RecordInvalid.new(self))
+    end
+
+    def submit
+      return false unless valid?
+
+      performed = false
+      run_callbacks(:perform) do
+        perform
+        performed = true
+      end
+      errors.add(:base, :could_not_be_performed, message: "could not be performed") if !performed && errors.empty?
+      performed
+    end
+
+    private
+
+    def perform
+      raise NotImplementedError, "#{self.class} must implement #perform"
+    end
+  end
+end

data/lib/well_formed/persistence.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module WellFormed
+  module Persistence
+    def self.included(base)
+      base.include(ActiveSupport::Callbacks)
+      base.include(AttributeAssignment)
+      base.define_callbacks(:save)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def before_save(*args, &block)
+        set_callback(:save, :before, *args, &block)
+      end
+
+      def after_save(*args, &block)
+        set_callback(:save, :after, *args, &block)
+      end
+
+      def merge_model_errors
+        @merge_model_errors = true
+      end
+
+      def merge_model_errors?
+        @merge_model_errors || false
+      end
+    end
+
+    def save
+      return false unless valid?
+
+      result = nil
+      catch(:abort) do
+        assign_attributes_to(resource)
+        run_callbacks(:save) do
+          result = perform
+          throw(:abort) unless result
+        end
+      end
+      errors.add(:base, :could_not_be_saved, message: "could not be saved") if result == false && errors.empty?
+      result || false
+    end
+
+    def save!
+      save || raise(WellFormed::RecordInvalid.new(self))
+    end
+
+    def submit
+      save && resource
+    end
+
+    private
+
+    def perform
+      result = resource.save
+      errors.merge!(resource.errors) if !result && self.class.merge_model_errors?
+      result
+    end
+  end
+end

data/lib/well_formed/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module WellFormed
+  class Railtie < Rails::Railtie
+    generators do
+      require_relative "../../generators/resource_form_generator"
+    end
+  end
+end

data/lib/well_formed/record_identity.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module WellFormed
+  module RecordIdentity
+    module CreateBehavior
+      def persisted? = false
+      def id = nil
+      def to_param = nil
+    end
+
+    module UpdateBehavior
+      def persisted? = true
+      def id = resource.respond_to?(:id) ? resource.id : nil
+      delegate :to_param, to: :resource
+    end
+
+    module ClassMethods
+      def create_action
+        prepend CreateBehavior
+      end
+
+      def update_action
+        prepend UpdateBehavior
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.create_action
+    end
+  end
+end

data/lib/well_formed/resource_form.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module WellFormed
+  class ResourceForm < SimpleResource
+    prepend WithUser
+  end
+end

data/lib/well_formed/simple_action.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module WellFormed
+  class SimpleAction
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include Translations
+    include AttributeAssignment
+    include Performer
+    include NestedAttributes
+    prepend Initializer
+    include RecordIdentity
+  end
+end

data/lib/well_formed/simple_nested_form.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module WellFormed
+  class SimpleNestedForm
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include Translations
+    include Collections
+    include NestedAttributes
+    prepend Initializer
+  end
+end

data/lib/well_formed/simple_resource.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module WellFormed
+  class SimpleResource
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include Translations
+    include Persistence
+    include Transactional
+    include Collections
+    include NestedAttributes
+    prepend Initializer
+  end
+end

data/lib/well_formed/simple_struct.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module WellFormed
+  class SimpleStruct
+    module PoroInterface
+      def id
+        resource.respond_to?(:id) ? resource.id : nil
+      end
+
+      def persisted?
+        resource.respond_to?(:persisted?) ? resource.persisted? : false
+      end
+    end
+
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include Translations
+    include Persistence
+    include NestedAttributes
+    prepend Initializer
+    prepend PoroInterface
+
+    private
+
+    def perform
+      raise NotImplementedError, "#{self.class} must implement #perform"
+    end
+  end
+end

data/lib/well_formed/struct.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module WellFormed
+  class Struct < SimpleStruct
+    prepend WithUser
+  end
+end

data/lib/well_formed/transactional.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module WellFormed
+  module Transactional
+    def self.included(base)
+      base.define_callbacks(:save_commit)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def after_save_commit(*args, &block)
+        set_callback(:save_commit, :after, *args, &block)
+      end
+
+      def save_within_transaction
+        set_callback(:save, :around) do |form, block|
+          saved = false
+          form.resource.class.transaction do
+            catch(:abort) do
+              block.call
+              saved = true
+            end
+            raise ActiveRecord::Rollback unless saved
+          end
+          throw(:abort) unless saved
+        end
+      end
+    end
+
+    def save
+      result = super
+      ::ActiveRecord.after_all_transactions_commit { run_callbacks(:save_commit) } if result
+      result || false
+    end
+  end
+end

data/lib/well_formed/translations.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module WellFormed
+  module Translations
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def resource_alias(resource)
+        resolved = case resource
+        when Class
+          raise ArgumentError, "#{resource} does not respond to model_name" unless resource.respond_to?(:model_name)
+
+          resource.model_name
+        when Symbol, String
+          name_str = ActiveSupport::Inflector.camelize(resource.to_s)
+          ActiveModel::Name.new(Class.new, nil, name_str)
+        else
+          raise ArgumentError, "resource_alias expects a Class, Symbol, or String, got #{resource.class}"
+        end
+
+        define_singleton_method(:model_name) { resolved }
+
+        alias_name = resolved.element.to_sym
+        alias_method alias_name, :resource
+      end
+    end
+  end
+end

data/lib/well_formed/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WellFormed
+  VERSION = "0.1.0"
+end

data/lib/well_formed/with_user.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module WellFormed
+  module WithUser
+    @extensions = []
+
+    def self.register_extension(mod)
+      @extensions << mod
+    end
+
+    def self.prepended(base)
+      base.extend(ClassMethods)
+      @extensions.each { |mod| base.include(mod) }
+    end
+
+    def self.included(base)
+      raise ArgumentError, "#{name} must be prepended, not included. Use `prepend #{name}` instead."
+    end
+
+    module ClassMethods
+      # Builds an anonymous nested form class rooted at NestedForm.
+      def _nested_form_builder(synthetic_name, &block)
+        form_class = Class.new(WellFormed::NestedForm, &block)
+        form_class.define_singleton_method(:model_name) do
+          ActiveModel::Name.new(self, nil, synthetic_name)
+        end
+        form_class
+      end
+    end
+
+    attr_reader :user
+
+    # Instantiates a nested form with the current user.
+    def _build_nested_form(form_class, resource, attrs = {})
+      form_class.new(resource, user, attrs)
+    end
+
+    def initialize(resource, user, params = {})
+      @user = user
+      super(resource, params)
+    end
+  end
+end

data/lib/well_formed.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_model"
+require_relative "well_formed/version"
+require_relative "well_formed/errors"
+require_relative "well_formed/railtie" if defined?(Rails::Railtie)
+
+module WellFormed
+  autoload :Initializer, "well_formed/initializer"
+  autoload :WithUser, "well_formed/with_user"
+  autoload :AttributeAssignment, "well_formed/attribute_assignment"
+  autoload :Persistence, "well_formed/persistence"
+  autoload :Transactional, "well_formed/transactional"
+  autoload :Performer, "well_formed/performer"
+  autoload :RecordIdentity, "well_formed/record_identity"
+  autoload :Translations, "well_formed/translations"
+  autoload :NestedAttributes, "well_formed/nested_attributes"
+  autoload :Collections, "well_formed/collections"
+  autoload :SimpleNestedForm, "well_formed/simple_nested_form"
+  autoload :NestedForm, "well_formed/nested_form"
+  autoload :SimpleResource, "well_formed/simple_resource"
+  autoload :SimpleAction, "well_formed/simple_action"
+  autoload :SimpleStruct, "well_formed/simple_struct"
+  autoload :ResourceForm, "well_formed/resource_form"
+  autoload :ActionForm, "well_formed/action_form"
+  autoload :Struct, "well_formed/struct"
+
+  def self.included(base)
+    base.include ActiveModel::Model
+    base.include ActiveModel::Attributes
+    base.include Translations
+    base.include Persistence
+    base.include Transactional
+    base.include Collections
+    base.include NestedAttributes
+    base.prepend Initializer
+  end
+end

data/rbs_collection.yaml

@@ -0,0 +1,19 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+# gems:
+#   # If you want to avoid installing rbs files for gems, you can specify them here.
+#   - name: GEM_NAME
+#     ignore: true