formed 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 328d9eb07d649d40bc0d35abcb958b5d8a7481eeef634de0ad15fb29f511449a
+  data.tar.gz: 3bddab39a1183163ec0c2d3247653b7503b162ace61a8b7340fa85f75519abb7
+SHA512:
+  metadata.gz: d376a17f42644a25ef81f1d5a901327405122a248ae78e263f71aa5600345e5e5e8cd275b830ebf97a71f2fafeb4d5f78df65fe2e31a467465f4d466a48647ab
+  data.tar.gz: 86315bf92ce6ec953d5712e3d0f8a9ff50be6606716c79761e892e0069c9818c428b1c5fefdaaf725b910b7a565187c38645e3de060a61aded6146d0cbc25188

data/README.md

@@ -0,0 +1,146 @@
+# Formed
+
+Formed is the form object pattern you never knew you needed: uses ActiveModel under the hood, and supports associations just like ActiveRecord.
+
+## Contents
+
+* [Usage](#usage)
+* [Installation](*installation)
+* [Acknowledgements](*acknowledgements)
+* [Contributing](*contribuing)
+
+## Usage
+
+Formed form objects act just like the ActiveRecord models you started forcing into form helpers.
+
+### Basic form 
+
+```ruby
+class ProductForm < Formed::Base 
+  acts_like_model :product 
+  
+  attribute :title 
+  attribute :content, :text 
+end
+```
+
+### With validations
+
+Use all the validations your heart desires.
+
+```ruby
+class PostForm < Formed::Base 
+  acts_like_model :post 
+  
+  attribute :title  
+  attribute :content, :text 
+  
+  validates :title, presence: true 
+  validates :content, presence: true 
+end
+```
+
+### Associations
+
+Here's the big one:
+
+```ruby
+class TicketForm < Formed::Base 
+  acts_like_model :ticket 
+  
+  attribute :name
+
+  # automatically applies accepts_nested_attributes_for
+  has_many :ticket_prices, class_name: "TicketPriceForm"
+
+  validates :name, presence: true  
+end
+```
+
+```ruby
+class TicketPriceForm < Formed::Base
+  acts_like_model :ticket_price
+
+  attribute :price_in_cents, :integer
+
+  validates :price_in_cents, presence: true, numericality: { greater_than: 0 }
+end
+```
+
+### Context
+
+Add context:
+
+```ruby
+class OrganizationForm < Formed::Base 
+  acts_like_model :organization 
+  
+  attribute :location_id, :integer 
+  
+  def location_id_options
+    context.organization.locations
+  end
+end
+```
+
+```ruby
+form = OrganizationForm.new
+form.with_context(organization: @organization)
+```
+
+Context gets passed down to all associations too.
+
+```ruby
+class OrganizationForm < Formed::Base 
+  acts_like_model :organization 
+  
+  has_many :users, class_name: "UserForm"
+  
+  attribute :location_id, :integer 
+  
+  def location_id_options
+    context.organization.locations
+  end
+end
+```
+
+```ruby
+form = OrganizationForm.new 
+form.with_context(organization: @organization)
+user = form.users.new
+user.context == form.context # true 
+```
+
+## Suggestions
+
+### Let forms be forms, not forms with actions
+
+Forms should only know do one thing: represent a form and the form's state. Leave logic to its own.
+
+If you use something like ActiveDuty, you could do this:
+
+```ruby
+class MyCommand < ApplicationCommand
+  def initialize(form)
+    @form = form 
+  end
+  
+  def call
+    return broadcast(:invalid, form) unless @form.valid? 
+    
+    # ...
+  end
+end
+```
+
+## Contributing
+
+By submitting a Pull Request, you disavow any rights or claims to any changes submitted to the Formed project and assign the copyright of those changes to joshmn.
+
+If you cannot or do not want to reassign those rights (your employment contract for your employer may not allow this), you should not submit a PR. Open an issue and someone else can do the work.
+
+This is a legal way of saying "If you submit a PR to us, that code becomes ours". 99.99% of the time that's what you intend anyways; we hope it doesn't scare you away from contributing.
+
+## Acknowledgements
+
+This was heavily inspired by — and tries to be backwards compatible with — AndyPike's Rectify form pattern.  

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/active_form.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/module/delegation"
+require "mutex_m"
+require "active_model"
+
+require_relative "formed/version"
+require "formed/base"
+
+module Formed
+  ; end

data/lib/formed/acts_like_model.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Formed
+  module ActsLikeModel
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def inherit_model_validations(model, *attributes)
+        attributes.each do |attr|
+          model._validators[attr].each do |validator|
+            if validator.options.none?
+              validates attr, validator.kind => true
+            else
+              validates attr, validator.kind => validator.options
+            end
+          end
+        end
+      end
+
+      def acts_like_model(model)
+        self.model = model
+      end
+    end
+
+    def map_model(record); end
+  end
+end

data/lib/formed/association_relation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Formed
+  class AssociationRelation < Relation # :nodoc:
+    def initialize(klass, association, **)
+      super(klass)
+      @association = association
+    end
+
+    def proxy_association
+      @association
+    end
+
+    def ==(other)
+      other == records
+    end
+
+    def merge!(other, *rest) # :nodoc:
+      # no-op #
+    end
+  end
+end

data/lib/formed/associations/association.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Formed
+  module Associations
+    class Association # :nodoc:
+      attr_reader :owner, :target, :reflection, :disable_joins
+
+      delegate :options, to: :reflection
+
+      def initialize(owner, reflection)
+        reflection.check_validity!
+
+        @owner = owner
+        @reflection = reflection
+
+        reset
+        reset_scope
+      end
+
+      def reset
+        @loaded = true
+        @target = nil
+        @stale_state = nil
+      end
+
+      def reset_negative_cache # :nodoc:
+        reset if loaded? && target.nil?
+      end
+
+      # Reloads the \target and returns +self+ on success.
+      # The QueryCache is cleared if +force+ is true.
+      def reload(force = false)
+        reset
+        reset_scope
+        load_target
+        self unless target.nil?
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded!
+        @loaded = true
+        @stale_state = stale_state
+      end
+
+      def stale_target?
+        loaded? && @stale_state != stale_state
+      end
+
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      def scope
+        target
+      end
+
+      def reset_scope
+        @association_scope = nil
+      end
+
+      # Set the inverse association, if possible
+      def set_inverse_instance(record)
+        if (inverse = inverse_association_for(record))
+          inverse.inversed_from(owner)
+        end
+        record
+      end
+
+      def klass
+        reflection.klass
+      end
+
+      def extensions
+        extensions = reflection.extensions
+
+        extensions |= reflection.scope_for(klass.unscoped, owner).extensions if reflection.scope
+
+        extensions
+      end
+
+      def load_target
+        @target = find_target if (@stale_state && stale_target?) || find_target?
+
+        loaded! unless loaded?
+        target
+      end
+
+      # We can't dump @reflection and @through_reflection since it contains the scope proc
+      def marshal_dump
+        ivars = (instance_variables - %i[@reflection @through_reflection]).map do |name|
+          [name, instance_variable_get(name)]
+        end
+        [@reflection.name, ivars]
+      end
+
+      def marshal_load(data)
+        reflection_name, ivars = data
+        ivars.each { |name, val| instance_variable_set(name, val) }
+        @reflection = @owner.class._reflect_on_association(reflection_name)
+      end
+
+      def initialize_attributes(record, except_from_scope_attributes = nil) # :nodoc:
+        except_from_scope_attributes ||= {}
+        skip_assign = [reflection.foreign_key, reflection.type].compact
+        assigned_keys = record.changed
+        assigned_keys += except_from_scope_attributes.keys.map(&:to_s)
+        attributes = {}.except!(*(assigned_keys - skip_assign))
+        record.send(:_assign_attributes, attributes) if attributes.any?
+        set_inverse_instance(record)
+      end
+
+      private
+
+      # Reader and writer methods call this so that consistent errors are presented
+      # when the association target class does not exist.
+      def ensure_klass_exists!
+        klass
+      end
+
+      def find_target
+
+      end
+
+      def violates_strict_loading?
+        return reflection.strict_loading? if reflection.options.key?(:strict_loading)
+
+        false # owner.strict_loading? && !owner.strict_loading_n_plus_one_only?
+      end
+
+      def association_scope
+        klass
+      end
+
+      def target_scope
+        AssociationRelation.create(klass, self).merge!({})
+      end
+
+      def find_target?
+        !loaded? && (!owner.new_record?) && klass
+      end
+
+      def inverse_association_for(record)
+        return unless invertible_for?(record)
+
+        record.association(inverse_reflection_for(record).name)
+      end
+
+      # Returns true if inverse association on the given record needs to be set.
+      # This method is redefined by subclasses.
+      def invertible_for?(record)
+        foreign_key_for?(record) && inverse_reflection_for(record)
+      end
+
+      # Returns true if record contains the foreign_key
+      def foreign_key_for?(record)
+        record._has_attribute?(reflection.foreign_key)
+      end
+
+      # This should be implemented to return the values of the relevant key(s) on the owner,
+      # so that when stale_state is different from the value stored on the last find_target,
+      # the target is stale.
+      #
+      # This is only relevant to certain associations, which is why it returns +nil+ by default.
+      def stale_state; end
+
+      def build_record(attributes)
+        reflection.build_association(attributes) do |record|
+          initialize_attributes(record, attributes)
+          yield(record) if block_given?
+        end
+      end
+
+      def inversable?(record)
+        record &&
+          ((!record.persisted? || !owner.persisted?) || matches_foreign_key?(record))
+      end
+
+      def matches_foreign_key?(record)
+        if foreign_key_for?(record)
+          record.read_attribute(reflection.foreign_key) == owner.id ||
+            (foreign_key_for?(owner) && owner.read_attribute(reflection.foreign_key) == record.id)
+        else
+          owner.read_attribute(reflection.foreign_key) == record.id
+        end
+      end
+    end
+  end
+end

data/lib/formed/associations/builder/association.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Formed
+  module Associations
+    module Builder
+      class Association
+        class << self
+          attr_accessor :extensions
+        end
+        self.extensions = []
+
+        VALID_OPTIONS = %i[
+          class_name anonymous_class primary_key foreign_key validate inverse_of
+        ].freeze # :nodoc:
+
+        def self.build(model, name, scope, options, &block)
+          reflection = create_reflection(model, name, scope, options, &block)
+          define_accessors model, reflection
+          define_callbacks model, reflection
+          define_validations model, reflection
+          define_change_tracking_methods model, reflection
+          reflection
+        end
+
+        def self.create_reflection(model, name, scope, options, &block)
+          raise ArgumentError, "association names must be a Symbol" unless name.is_a?(Symbol)
+
+          validate_options(options)
+
+          extension = define_extensions(model, name, &block)
+          options[:extend] = [*options[:extend], extension] if extension
+
+          scope = build_scope(scope)
+
+          Reflection.create(macro, name, scope, options, model)
+        end
+
+        def self.build_scope(scope)
+          if scope&.arity&.zero?
+            proc { instance_exec(&scope) }
+          else
+            scope
+          end
+        end
+
+        def self.macro
+          raise NotImplementedError
+        end
+
+        def self.valid_options(_options)
+          VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
+        end
+
+        def self.validate_options(options)
+          options.assert_valid_keys(valid_options(options))
+        end
+
+        def self.define_extensions(model, name); end
+
+        def self.define_callbacks(model, reflection)
+          Association.extensions.each do |extension|
+            extension.build model, reflection
+          end
+        end
+
+        # Defines the setter and getter methods for the association
+        # class Post < ActiveRecord::Base
+        #   has_many :comments
+        # end
+        #
+        # Post.first.comments and Post.first.comments= methods are defined by this method...
+        def self.define_accessors(model, reflection)
+          mixin = model.generated_association_methods
+          name = reflection.name
+          define_readers(mixin, name)
+          define_writers(mixin, name)
+        end
+
+        def self.define_readers(mixin, name)
+          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}
+          association(:#{name}).reader
+        end
+          CODE
+        end
+
+        def self.define_writers(mixin, name)
+          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          association(:#{name}).writer(value)
+        end
+          CODE
+        end
+
+        def self.define_validations(model, reflection)
+          # noop
+        end
+
+        def self.define_change_tracking_methods(model, reflection)
+          # noop
+        end
+
+        def self.valid_dependent_options
+          raise NotImplementedError
+        end
+
+        def self.check_dependent_options(dependent, model)
+        end
+
+        private_class_method :build_scope, :macro, :valid_options, :validate_options, :define_extensions,
+                             :define_callbacks, :define_accessors, :define_readers, :define_writers, :define_validations,
+                             :define_change_tracking_methods, :valid_dependent_options, :check_dependent_options
+      end
+    end
+  end
+end

data/lib/formed/associations/builder/collection_association.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Formed
+  module Associations
+    module Builder
+      class CollectionAssociation < ::Formed::Associations::Builder::Association # :nodoc:
+        CALLBACKS = %i[before_add after_add before_remove after_remove].freeze
+
+        def self.valid_options(options)
+          super + %i[before_add after_add before_remove after_remove extend]
+        end
+
+        def self.define_callbacks(model, reflection)
+          super
+          name    = reflection.name
+          options = reflection.options
+          CALLBACKS.each do |callback_name|
+            define_callback(model, callback_name, name, options)
+          end
+        end
+
+        def self.define_extensions(model, name, &block)
+          return unless block_given?
+
+          extension_module_name = "#{name.to_s.camelize}AssociationExtension"
+          extension = Module.new(&block)
+          model.const_set(extension_module_name, extension)
+        end
+
+        def self.define_callback(model, callback_name, name, options)
+          full_callback_name = "#{callback_name}_for_#{name}"
+
+          callback_values = Array(options[callback_name.to_sym])
+          method_defined = model.respond_to?(full_callback_name)
+
+          # If there are no callbacks, we must also check if a superclass had
+          # previously defined this association
+          return if callback_values.empty? && !method_defined
+
+          unless method_defined
+            model.class_attribute(full_callback_name, instance_accessor: false, instance_predicate: false)
+          end
+
+          callbacks = callback_values.map do |callback|
+            case callback
+            when Symbol
+              ->(_method, owner, record) { owner.send(callback, record) }
+            when Proc
+              ->(_method, owner, record) { callback.call(owner, record) }
+            else
+              ->(method, owner, record) { callback.send(method, owner, record) }
+            end
+          end
+          model.send "#{full_callback_name}=", callbacks
+        end
+
+        def self.define_writers(mixin, name)
+          super
+
+          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
+        end
+          CODE
+        end
+
+        private_class_method :valid_options, :define_callback, :define_extensions, :define_readers, :define_writers
+      end
+    end
+  end
+end

data/lib/formed/associations/builder/has_many.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Formed
+  module Associations
+    module Builder
+      class HasMany < ::Formed::Associations::Builder::CollectionAssociation # :nodoc:
+        def self.macro
+          :has_many
+        end
+
+        def self.valid_options(options)
+          valid = super
+          valid += [:as] if options[:as]
+          valid += %i[through source source_type] if options[:through]
+          valid
+        end
+
+        def self.valid_dependent_options; end
+
+        private_class_method :macro, :valid_options, :valid_dependent_options
+      end
+    end
+  end
+end

data/lib/formed/associations/builder/has_one.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Formed
+  module Associations
+    module Builder
+      class HasOne < SingularAssociation # :nodoc:
+        def self.macro
+          :has_one
+        end
+
+        def self.valid_options(options)
+          valid = super
+          valid += [:as] if options[:as]
+          valid += %i[through source source_type] if options[:through]
+          valid
+        end
+
+        def self.valid_dependent_options
+          []
+        end
+
+        def self.define_callbacks(model, reflection)
+          super
+          add_touch_callbacks(model, reflection) if reflection.options[:touch]
+        end
+
+        def self.define_validations(model, reflection)
+          super
+          return unless reflection.options[:required]
+
+          model.validates_presence_of reflection.name, message: :required
+          model.validate :"ensure_#{reflection.name}_valid!"
+
+          model.define_method "ensure_#{reflection.name}_valid!" do
+            errors.add(reflection.name, :invalid) unless public_send(reflection.name).valid?
+          end
+        end
+
+        private_class_method :macro, :valid_options, :valid_dependent_options,
+                             :define_callbacks, :define_validations
+      end
+    end
+  end
+end