Initial stab at using association classes instead of Form and FormCollection.

Author: kaspth

lib/active_form/associatable.rb

@@ -0,0 +1,28 @@
+module ActiveForm
+  concern :Associatable do
+    def association(name, options = {})
+      association = child_class_for(options).new(name, options)
+      association_scope.add_child(association, Proc.new)
+      define_association_accessors(name, association)
+    end
+
+    def association_scope
+      self
+    end
+
+    private
+      def child_class_for(options)
+        options.key?(:records) ? CollectionAssociation : ModelAssociation
+      end
+
+      def define_association_accessors(name, association)
+        class_eval do
+          define_method(name) { association }
+          define_method("#{name}=") { |i| association.instance = i }
+          define_method("#{name}_attributes=") do |attrs|
+            association.attributes = attrs
+          end
+        end
+      end
+  end
+end

lib/active_form/base.rb

@@ -1,71 +1,71 @@
-require 'active_form/abstract_form'
+require 'active_form/model_association'
+require 'active_form/collection_association'
+require 'active_form/associatable'
 
 module ActiveForm
-  class Base < AbstractForm
-    include ActiveModel::Model
-
-    delegate :persisted?, :to_model, :to_key, :to_param, :to_partial_path, to: :model
-    attr_reader :model
-
-    def initialize(model)
-      @model = model
-
-      @forms = []
-      populate_forms
+  class Base
+    extend Associatable
+
+    # SignupForm.new(user: User.find(params[:user_id]))
+    def initialize(models = nil)
+      if models.respond_to?(:each)
+        assign_attributes(models)
+      else
+        main_association.instance = models
+      end
     end
 
     def save
       return false unless valid?
 
-      if ActiveRecord::Base.transaction { model.save }
-        forms.each(&:reset)
+      ActiveRecord::Base.transaction do
+        main_association.save
       end
     end
 
-    class << self
-      attr_accessor :main_model
-      delegate :reflect_on_association, to: :model_class
-
-      def attributes(*names)
-        options = names.pop if names.last.is_a?(Hash)
-
-        if options && options[:required]
-          validates_presence_of *names
-        end
-
-        names.each do |attribute|
-          delegate attribute, "#{attribute}=", to: :model
-        end
-      end
+    def submit(params)
+      assign_attributes(params)
+    end
 
-      alias_method :attribute, :attributes
+    mattr_accessor :main_model, instance_writer: false
 
-      def association(name, options = {}, &block)
-        define_method(name) { instance_variable_get("@#{name}").models }
-        define_method("#{name}_attributes=") {}
+    delegate :id, :persisted?, :to_model, :to_partial_path, to: :main_association
 
-        forms << [name, options, block]
+    class << self
+      delegate :attributes, :association_scope, to: :main_association
+
+      def main_association
+        @@main_association ||= \
+          if main_model
+            ModelAssociation.new(main_model)
+          else
+            raise ArgumentError, "you need to set the main_model for this form," \
+              " like self.main_model = :article"
+          end
       end
+    end
 
-      def forms
-        @forms ||= []
+    private
+      def respond_to_missing?(meth, include_private = false)
+        main_association.respond_to?(meth)
       end
 
-      private
-        def model_class
-          @model_class ||= main_model.to_s.camelize.constantize
+      def method_missing(meth, *args, &block)
+        if main_association.respond_to?(meth)
+          main_association.send(meth, *args, &block)
+        else
+          super
         end
-    end
+      end
 
-    private
+      def main_association
+        @@main_association
+      end
 
-    def populate_forms
-      self.class.forms.each do |(name, options, block)|
-        FormDefinition.new(name, block, options).build_for(model).tap do |form|
-          forms << form
-          instance_variable_set("@#{name}", form)
-        end
+      def assign_attributes(attributes)
+        attributes.each do |key, value|
+          self.public_send("#{key}=", value)
+        end if attributes
       end
-    end
   end
 end

lib/active_form/collection_association.rb

@@ -0,0 +1,33 @@
+require 'active_form/model_association'
+
+module ActiveForm
+  class CollectionAssociation < ModelAssociation
+    def initialize(model_name, options)
+      super
+      @instances = []
+    end
+
+    def dynamic?
+      true # means we can add more instances in a form
+    end
+
+    delegate :each, :size, :[], to: :@instances
+
+    # Map model attributes by key to association
+    # doghouse_attributes: { '1' => { name: 'McDiniis' }, '2' => { name: 'McDunuus' } }
+    def attributes=(model_attributes)
+      model_attributes.each do |model_id, attrs|
+        fetch_instance(model_id.to_i).attributes = attrs
+      end
+    end
+
+    def build_instance
+      model_class.new.tap { |i| @instances << i }
+    end
+
+    private
+      def fetch_instance(id)
+        @instances[id] || build_instance
+      end
+  end
+end

lib/active_form/model_association.rb

@@ -0,0 +1,92 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_form/associatable'
+
+module ActiveForm
+  class ModelAssociation
+    include Associatable
+    include ActiveModel::Model
+
+    attr_accessor :parent_association
+
+    def initialize(model_name, options = {})
+      @model_name = model_name
+      @options = options
+    end
+
+    def add_child(child, block = nil)
+      children << child
+      child.parent_association = self
+      child.instance_eval(&block) if block
+    end
+
+    # Test compatibility method
+    def forms
+      @children
+    end
+
+    def instance=(instance)
+      @model = instance if instance.is_a?(model_class)
+    end
+
+    def attributes(*attribute_names)
+      options = attribute_names.extract_options!
+
+      delegate_accessors_to_model attribute_names, options[:prefix]
+
+      if options && options[:required]
+        validates_presence_of(*attribute_names)
+      end
+    end
+    alias :attribute :attributes
+
+    def attributes=(attributes)
+      attributes.each do |name, value|
+        self.public_send("#{name}=", value)
+      end if attributes
+    end
+
+    def model
+      @model ||= model_class.new
+    end
+
+    delegate :persisted?, to: :model
+
+    def dynamic?
+      false
+    end
+
+    def save
+      aggregate(&:save)
+    end
+
+    def valid?
+      aggregate(&:valid?)
+    end
+
+    delegate :reflect_on_association, to: :model_class
+
+    private
+      def children
+        @children ||= []
+      end
+
+      def reflection
+        parent_association.reflect_on_association(@name)
+      end
+
+      def model_class
+        @model_class ||= @model_name.to_s.singularize.camelize.constantize
+      end
+
+      def delegate_accessors_to_model(names, prefix = false)
+        names.each do |attr|
+          self.class.delegate attr, "#{attr}=", to: :model, prefix: prefix
+        end
+      end
+
+      def aggregate
+        yield model
+        children.each { |c| yield c }
+      end
+  end
+end

test/forms/conference_form_test.rb

@@ -12,27 +12,14 @@ def setup
   end
 
   test "contains getter for presentations sub-form" do
-    assert_respond_to @form.speaker, :presentations
-
-    presentations_form = @form.speaker.forms.first
-    assert_instance_of ActiveForm::CollectionForm, presentations_form
-  end
-
-  test "#represents? returns true if the argument matches the Form's association name, false otherwise" do
-    presentations_form = @form.speaker.forms.first
-
-    assert presentations_form.represents?("presentations")
-    assert_not presentations_form.represents?("presentation")
+    assert @form.speaker.presentations
   end
 
   test "main form provides getter method for collection objects" do
     assert_respond_to @form.speaker, :presentations
 
-    presentations = @form.speaker.presentations
-
-    presentations.each do |form|
-      assert_instance_of ActiveForm::Form, form
-      assert_instance_of Presentation, form.model
+    @form.speaker.presentations.each do |model|
+      assert_instance_of Presentation, model
     end
   end
 
@@ -47,12 +34,10 @@ def setup
   test "presentations sub-form initializes the number of records specified" do
     presentations_form = @form.speaker.forms.first
 
-    assert_respond_to presentations_form, :models
-    assert_equal 2, presentations_form.models.size
+    assert_equal 2, presentations_form.size
 
-    presentations_form.each do |form|
-      assert_instance_of ActiveForm::Form, form
-      assert_instance_of Presentation, form.model
+    presentations_form.each do |model|
+      assert_instance_of Presentation, form
 
       assert_respond_to form, :topic
       assert_respond_to form, :topic=