blanks 1.0.0

data/examples/post_form_example.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "blanks"
+
+class ImageForm < Blanks::Base
+  attribute :url, :string
+  attribute :caption, :string
+
+  validates :url, presence: true
+end
+
+class CoverPhotoForm < Blanks::Base
+  attribute :url, :string
+
+  validates :url, presence: true
+end
+
+class PostForm < Blanks::Base
+  has_one :cover_photo
+  has_many :images
+
+  attribute :title, :string
+  attribute :content, :string
+  attribute :created_at, :datetime, default: -> { Time.current }
+
+  validates :title, presence: true
+  validates :content, presence: true
+  validates :created_at, presence: true
+end
+
+form = PostForm.new
+puts "empty form valid: #{form.valid?}"
+
+form = PostForm.new(
+  title: "hello world",
+  content: "this is content",
+  created_at: Time.now,
+  cover_photo_attributes: { url: "https://example.com/cover.jpg" },
+  images_attributes: [
+    { url: "https://example.com/1.jpg", caption: "first" },
+    { url: "https://example.com/2.jpg", caption: "second" }
+  ]
+)
+
+puts "form with attributes valid: #{form.valid?}"
+puts "title: #{form.title}"
+puts "cover photo url: #{form.cover_photo.url}"
+puts "images count: #{form.images.count}"
+
+form = PostForm.new
+form.images.new(url: "https://example.com/new.jpg", caption: "new image")
+puts "form with new image count: #{form.images.count}"

data/lib/blanks/association_proxy.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Blanks
+  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
+      if record.respond_to?(:id) && record.id.present?
+        @records_by_id[record.id.to_s] = record
+      end
+      self
+    end
+    alias_method :<<, :push
+
+    def each(&block)
+      @records.each(&block)
+    end
+
+    def size
+      @records.size
+    end
+    alias_method :length, :size
+    alias_method :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/blanks/associations.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Blanks
+  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, **options)
+        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, **options)
+      end
+
+      def has_many(name, class_name: nil, primary_key: :id, **options)
+        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, **options)
+      end
+    end
+  end
+end

data/lib/blanks/base.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module Blanks
+  class Base
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Validations
+    include ActiveModel::Dirty
+    include ActiveModel::Callbacks
+
+    include Blanks::ModelNaming
+    include Blanks::Normalization
+    include Blanks::Associations
+    include Blanks::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 = attrs & Array(only).map(&:to_sym) if only
+        attrs = 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)
+        return true if validator.is_a?(ActiveRecord::Validations::AssociatedValidator)
+      end
+
+      opts = validator.options
+      [: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|
+        if model.respond_to?(attr_name)
+          public_send("#{attr_name}=", model.public_send(attr_name))
+        end
+      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.each_with_object({}) do |name, hash|
+        hash[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/blanks/model_naming.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Blanks
+  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 = self.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/blanks/nested_attributes.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Blanks
+  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]
+
+          unless association
+            raise ArgumentError, "No association found for name '#{association_name}'"
+          end
+
+          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
+
+    private
+
+    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] || {}
+      form_class = 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/blanks/normalization.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Blanks
+  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/blanks/version.rb

@@ -0,0 +1,3 @@
+module Blanks
+  VERSION = "1.0.0"
+end

data/lib/blanks.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+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 "blanks/version"
+require "blanks/association_proxy"
+require "blanks/model_naming"
+require "blanks/normalization"
+require "blanks/associations"
+require "blanks/nested_attributes"
+require "blanks/base"
+
+module Blanks
+  class Error < StandardError; end
+end