formed 1.0.0

data/lib/formed/associations.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Formed
+  module Associations
+    extend ActiveSupport::Concern
+
+    def association(name) # :nodoc:
+      association = association_instance_get(name)
+
+      if association.nil?
+        unless (reflection = self.class._reflect_on_association(name))
+          raise AssociationNotFoundError.new(self, name)
+        end
+
+        association = reflection.association_class.new(self, reflection)
+        association_instance_set(name, association)
+      end
+
+      association
+    end
+
+    def association_cached?(name) # :nodoc:
+      @association_cache.key?(name)
+    end
+
+    def initialize_dup(*) # :nodoc:
+      @association_cache = {}
+      super
+    end
+
+    private
+
+    def init_internals
+      @association_cache = {}
+      super
+    end
+
+    # Returns the specified association instance if it exists, +nil+ otherwise.
+    def association_instance_get(name)
+      @association_cache[name]
+    end
+
+    # Set the specified association instance.
+    def association_instance_set(name, association)
+      @association_cache[name] = association
+    end
+
+    class_methods do
+      def has_many(name, scope = nil, **options, &extension)
+        reflection = Builder::HasMany.build(self, name, scope, options, &extension)
+        Reflection.add_reflection self, name, reflection
+        accepts_nested_attributes_for name
+      end
+
+      def has_one(name, scope = nil, **options)
+        reflection = Builder::HasOne.build(self, name, scope, options)
+        Reflection.add_reflection self, name, reflection
+        accepts_nested_attributes_for name
+      end
+    end
+  end
+end

data/lib/formed/attributes.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Formed
+  module Attributes
+    extend ActiveSupport::Concern
+
+    def _has_attribute?(name)
+      attributes.key?(name)
+    end
+
+    def attribute_present?(attr_name)
+      attr_name = attr_name.to_s
+      attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      value = _read_attribute(attr_name)
+      !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
+    end
+
+    def type_for_attribute(attr)
+      self.class.attribute_types[attr].type
+    end
+
+    def column_for_attribute(attr)
+      model.column_for_attribute(attr)
+    end
+
+    def has_attribute?(attr_name)
+      attr_name = attr_name.to_s
+      attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      @attributes.key?(attr_name)
+    end
+
+    def attributes_with_values
+      attributes.select { |_, v| v.present? }
+    end
+
+    module ClassMethods
+      def _has_attribute?(name)
+        attribute_types.key?(name.to_s)
+      end
+    end
+  end
+end

data/lib/formed/base.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "formed/relation/delegation"
+require "formed/associations"
+require "formed/core"
+require "formed/inheritance"
+require "formed/reflection"
+require "formed/relation"
+require "formed/attributes"
+require "formed/nested_attributes"
+require "formed/association_relation"
+require "formed/associations/association"
+require "formed/associations/singular_association"
+require "formed/associations/collection_association"
+require "formed/associations/foreign_association"
+require "formed/associations/collection_proxy"
+require "formed/associations/builder"
+require "formed/associations/builder/association"
+require "formed/associations/builder/singular_association"
+require "formed/associations/builder/collection_association"
+require "formed/associations/builder/has_one"
+require "formed/associations/builder/has_many"
+require "formed/associations/has_many_association"
+require "formed/associations/has_one_association"
+
+require "formed/acts_like_model"
+require "formed/from_model"
+require "formed/from_params"
+
+module Formed
+  RESTRICTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
+
+  class FormedError < StandardError
+  end
+
+  class AssociationTypeMismatch < FormedError
+  end
+
+  class Base
+    extend  Relation::Delegation::DelegateCache
+
+    include Formed::Associations
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    include ActiveModel::Attributes
+    include ActiveModel::AttributeAssignment
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Callbacks
+    include ActiveModel::Dirty
+    include Formed::Attributes
+
+    include Formed::Core
+    include Formed::Inheritance
+    include Formed::Reflection
+    include Formed::NestedAttributes
+
+    include Formed::ActsLikeModel
+    include Formed::FromParams
+    include FromModel
+
+    def init_internals
+      @marked_for_destruction   = false
+      @association_cache = {}
+      klass = self.class
+
+      @strict_loading      = false
+      @strict_loading_mode = :all
+
+      klass.define_attribute_methods
+    end
+
+    def initialize_internals_callback; end
+
+    def initialize(attributes = nil)
+      @new_record = true
+      @attributes = self.class._default_attributes.deep_dup
+
+      init_internals
+      initialize_internals_callback
+
+      assign_attributes(attributes) if attributes
+
+      yield self if block_given?
+      _run_initialize_callbacks
+    end
+
+    class_attribute :inheritance_column, default: :type
+
+    define_model_callbacks :initialize, only: [:after]
+    define_model_callbacks :validation, only: %i[before after]
+
+    attribute :id, :integer
+    attribute :_destroy, :boolean
+
+    class_attribute :model
+    class_attribute :primary_key, default: "id"
+    class_attribute :model_name
+    class_attribute :default_ignored_attributes, default: %w[id created_at updated_at]
+    class_attribute :ignored_attributes, default: []
+
+    def with_context(contexts = {})
+      @context = OpenStruct.new(contexts)
+      _reflections.each do |_, reflection|
+        if (instance = public_send(reflection.name))
+          instance.with_context(@context)
+        end
+      end
+
+      self
+    end
+
+    attr_reader :context
+
+    def inspect
+      # We check defined?(@attributes) not to issue warnings if the object is
+      # allocated but not initialized.
+      inspection = if defined?(@attributes) && @attributes
+                     self.class.attribute_names.filter_map do |name|
+                       "#{name}: #{_read_attribute(name).inspect}" if self.class.attribute_types.key?(name)
+                     end.join(", ")
+                   else
+                     "not initialized"
+                   end
+
+      "#<#{self.class} #{inspection}>"
+    end
+
+    def persisted?
+      id.present? && id.to_i.positive?
+    end
+
+    def self.from_json(json)
+      params = JSON.parse(json)
+      from_params(params)
+    end
+
+    def valid?(options = {})
+      run_callbacks(:validation) do
+        options     = {} if options.blank?
+        context     = options[:context]
+        validations = [super(context)]
+
+        validations.all?
+      end
+    end
+
+    def invalid?(options = {})
+      !valid?(options)
+    end
+
+    def to_key
+      [id]
+    end
+
+    def self.model_name
+      if model.is_a?(Symbol)
+        ActiveModel::Name.new(self, nil, model.to_s)
+      elsif model.present?
+        ActiveModel::Name.new(self, nil, model.model_name.name.split("::").last)
+      else
+        name = self.name.demodulize.delete_suffix("Form")
+        name = self.name if name.blank?
+        ActiveModel::Name.new(self, nil, name)
+      end
+    end
+
+    def model_name
+      self.class.model_name
+    end
+
+    def new_record?
+      !persisted?
+    end
+
+    def marked_for_destruction?
+      attributes["_destroy"]
+    end
+
+    def destroy?
+      _destroy
+    end
+  end
+end

data/lib/formed/core.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Formed
+  module Core
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def inherited(child_class) # :nodoc:
+        # initialize cache at class definition for thread safety
+        unless child_class.base_class?
+          klass = self
+          klass = klass.superclass until klass.base_class?
+        end
+        super
+      end
+
+      def initialize_generated_modules # :nodoc:
+        generated_association_methods
+      end
+
+      def generated_association_methods # :nodoc:
+        @generated_association_methods ||= begin
+          mod = const_set(:GeneratedAssociationMethods, Module.new)
+          private_constant :GeneratedAssociationMethods
+          include mod
+
+          mod
+        end
+      end
+
+      # Returns columns which shouldn't be exposed while calling +#inspect+.
+      def filter_attributes
+        if defined?(@filter_attributes)
+          @filter_attributes
+        else
+          superclass.filter_attributes
+        end
+      end
+
+      # Specifies columns which shouldn't be exposed while calling +#inspect+.
+      def filter_attributes=(filter_attributes)
+        @inspection_filter = nil
+        @filter_attributes = filter_attributes
+      end
+
+      def inspection_filter # :nodoc:
+        if defined?(@filter_attributes)
+          @inspection_filter ||= begin
+            mask = InspectionMask.new(ActiveSupport::ParameterFilter::FILTERED)
+            ActiveSupport::ParameterFilter.new(@filter_attributes, mask: mask)
+          end
+        else
+          superclass.inspection_filter
+        end
+      end
+
+      # Returns a string like 'Post(id:integer, title:string, body:text)'
+      def inspect # :nodoc:
+        if self == Formed::Base
+          super
+        else
+          attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ", "
+          "#{super}(#{attr_list})"
+        end
+      end
+
+      # Override the default class equality method to provide support for decorated models.
+      def ===(object) # :nodoc:
+        object.is_a?(self)
+      end
+    end
+  end
+end

data/lib/formed/from_model.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Formed
+  module FromModel
+    class FromModelAssignment
+      def self.call(instance, record)
+        record.attributes.each do |k, v|
+          instance.public_send("#{k}=", v) if instance.attributes.key?(k)
+        end
+        record._reflections.each do |attr, _record_reflection|
+          next unless (form_reflection = instance._reflections[attr])
+
+          case form_reflection.macro
+          when :has_one
+            instance.send("build_#{attr}").from_model(record.public_send(attr))
+          when :has_many
+            record.public_send(attr).each do |associated_record|
+              instance.public_send(attr).build.from_model(associated_record)
+            end
+          end
+        end
+
+        instance.id = record.id
+        instance.map_model(record)
+        instance
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    def from_model(model)
+      FromModelAssignment.call(self, model)
+    end
+
+    module ClassMethods
+      def from_model(model)
+        new.from_model(model)
+      end
+    end
+  end
+end

data/lib/formed/from_params.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Formed
+  module FromParams
+    extend ActiveSupport::Concern
+
+    class FromParamsAssignment
+      def self.call(instance, attributes_hash)
+        attributes_hash.each do |k, v|
+          if instance.attributes.key?(k.to_s)
+            instance.public_send("#{k}=", v)
+          elsif instance.respond_to?("#{k}=")
+            instance.public_send("#{k}=", v)
+          end
+        end
+
+        instance
+      end
+    end
+
+    def from_params(params, additional_params = {})
+      attributes_hash = params.merge(additional_params)
+
+      FromParamsAssignment.call(self, attributes_hash)
+    end
+
+    module ClassMethods
+      def from_params(params, additional_params = {})
+        new.from_params(params, additional_params)
+      end
+    end
+  end
+end

data/lib/formed/inheritance.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Formed
+  module Inheritance
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :store_full_class_name, instance_writer: false, default: true
+
+      set_base_class
+    end
+
+    module ClassMethods
+      # Determines if one of the attributes passed in is the inheritance column,
+      # and if the inheritance column is attr accessible, it initializes an
+      # instance of the given subclass instead of the base class.
+      def new(attributes = nil, &block)
+        if abstract_class? || self == Formed
+          raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
+        end
+
+        if _has_attribute?(inheritance_column)
+          subclass = subclass_from_attributes(attributes)
+
+          if subclass.nil? && (scope_attributes = current_scope&.scope_for_create)
+            subclass = subclass_from_attributes(scope_attributes)
+          end
+
+          subclass = subclass_from_attributes(column_defaults) if subclass.nil? && base_class?
+        end
+
+        if subclass && subclass != self
+          subclass.new(attributes, &block)
+        else
+          super
+        end
+      end
+
+      # Returns the class descending directly from ActiveRecord::Base, or
+      # an abstract class, if any, in the inheritance hierarchy.
+      #
+      # If A extends ActiveRecord::Base, A.base_class will return A. If B descends from A
+      # through some arbitrarily deep hierarchy, B.base_class will return A.
+      #
+      # If B < A and C < B and if A is an abstract_class then both B.base_class
+      # and C.base_class would return B as the answer since A is an abstract_class.
+      attr_reader :base_class
+
+      # Returns whether the class is a base class.
+      # See #base_class for more information.
+      def base_class?
+        base_class == self
+      end
+
+      attr_accessor :abstract_class
+
+      def abstract_class?
+        defined?(@abstract_class) && @abstract_class == true
+      end
+
+      def primary_abstract_class; end
+
+      def inherited(subclass)
+        subclass.set_base_class
+        subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
+        super
+      end
+
+      def dup # :nodoc:
+        # `initialize_dup` / `initialize_copy` don't work when defined
+        # in the `singleton_class`.
+        other = super
+        other.set_base_class
+        other
+      end
+
+      def initialize_clone(other) # :nodoc:
+        super
+        set_base_class
+      end
+
+      protected
+
+      # Returns the class type of the record using the current module as a prefix. So descendants of
+      # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
+      def compute_type(type_name)
+        if type_name.start_with?("::")
+          # If the type is prefixed with a scope operator then we assume that
+          # the type_name is an absolute reference.
+          type_name.constantize
+        else
+
+          type_candidate = @_type_candidates_cache[type_name]
+          if type_candidate && (type_constant = type_candidate.safe_constantize)
+            return type_constant
+          end
+
+          # Build a list of candidates to search for
+          candidates = []
+          name.scan(/::|$/) { candidates.unshift "#{::Regexp.last_match.pre_match}::#{type_name}" }
+          candidates << type_name
+          form_candidates = []
+          candidates.each do |candidate|
+            next if candidate.end_with?("Form")
+
+            form_candidates << "#{candidate}Form"
+          end
+
+          candidates += form_candidates
+
+          candidates.each do |candidate|
+            constant = candidate.safe_constantize
+            if candidate == constant.to_s
+              @_type_candidates_cache[type_name] = candidate
+              return constant
+            end
+          end
+
+          raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+        end
+      end
+
+      def set_base_class # :nodoc:
+        @base_class = if self == Formed::Base
+                        self
+                      else
+                        unless self < Formed::Base
+                          raise FormedError, "#{name} doesn't belong in a hierarchy descending from Formed"
+                        end
+
+                        if superclass == Formed || superclass.abstract_class?
+                          self
+                        else
+                          superclass.base_class
+                        end
+                      end
+      end
+
+      private
+
+      # Detect the subclass from the inheritance column of attrs. If the inheritance column value
+      # is not self or a valid subclass, raises ActiveRecord::SubclassNotFound
+      def subclass_from_attributes(attrs)
+        attrs = attrs.to_h if attrs.respond_to?(:permitted?)
+        return unless attrs.is_a?(Hash)
+
+        subclass_name = attrs[inheritance_column] || attrs[inheritance_column.to_sym]
+
+        return unless subclass_name.present?
+
+        find_sti_class(subclass_name)
+      end
+    end
+
+    def initialize_dup(other)
+      super
+      ensure_proper_type
+    end
+
+    private
+
+    def initialize_internals_callback
+      super
+      ensure_proper_type
+    end
+
+    # Sets the attribute used for single table inheritance to this class name if this is not the
+    # ActiveRecord::Base descendant.
+    # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to
+    # do Reply.new without having to set <tt>Reply[Reply.inheritance_column] = "Reply"</tt> yourself.
+    # No such attribute would be set for objects of the Message class in that example.
+    def ensure_proper_type
+      klass = self.class
+      return unless klass.finder_needs_type_condition?
+
+      _write_attribute(klass.inheritance_column, klass.sti_name)
+    end
+  end
+end