freeform 1.0.11 → 2.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjA0MmU0YThkYWRkNjhmZjc4N2Y2NmUyOTE3MWE4MWZjZTVkZDc0NA==
+    ZmM3NmYwN2Q0MzBjODk2MTRlNzA3NjU0YWRjMWI1YTY3MjMxNjI1Yw==
   data.tar.gz: !binary |-
-    ZTRmMGY1Yjc4YzkxNDUwNWEwNTZlNjVmYWNlODdhM2M2M2I0NTA3MQ==
+    YjVmOTEzMDZmNTNiNmQ2MGIwZTllMGRjMmI5NWU4ODFiYWFhMzhjMw==
 SHA512:
   metadata.gz: !binary |-
-    NTM4ZjNlYmM5MGYyNjQ0OGYyN2VhZTIxNmY2Y2Y0Y2IyNzY0ODI2MTQ2NTQy
-    MWIyZjMxNjRmODc4ZGE4NTIyYTBhOTM2NGNkNTFmNmQ5ZWM5OGFlOTNiMTI5
-    MTg0YTRkYTI1YzhkN2UzOTY2OTE0M2RkZTAwMzMyZjg0ZmFhYWM=
+    YjU2ZDBlNTA2ZjNkZDdjZjgyMzY4NTg0NWRjZjM0ZTI0NjUwNWI5ZjZmZWMy
+    ZjUxNWFhZWQ2ZjZmODMyYzdmYjI4ZjJkNGIzNmEyYjhiNzNkMzMyY2E3NDMx
+    ZDgyOWI2M2ZlNjZiMTQxNDBkYzdjZWVmOTg0NzE3YzlhMDVlMWY=
   data.tar.gz: !binary |-
-    NTgzODg1NTFjM2YyNzVkNmRlMjYzZjAzODhlY2VmYmQ3Y2FiZDJmNGRhZmJk
-    NzEyMWIwMDFjNzUxZjMyMDY5ZjMzZDkwY2MxZDE0MTQyYTk2OTBhOTU4ZDkx
-    N2E2ZTkzZWZhNWJhNDliYmU2YzhhMzYyMDdmMDA2MTFjMzUyMWM=
+    NTZhNjZjYmEzZWQxOWI4YTZmMjlhMjg5MTQ4OGJiYWY1MzQyZmE3NDVlYjA0
+    M2I4MGM2NDhkZGRkODdiYjZjMTU0YWRhMzRhNGQ5OTEyNDU4OTZkNTI0ZDJm
+    OTNiMTc0ZmU1YzZhMTE2ODBiZTIxOTQ4NTk2NWY2ZTA5YjA2NGQ=

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    freeform (1.0.9)
+    freeform (2.0.0rc1)
       activemodel
       formtastic
       rails (>= 3.2.0)
@@ -46,7 +46,7 @@ GEM
       rack-test (>= 0.5.4)
       selenium-webdriver (~> 2.0)
       xpath (~> 0.1.4)
-    childprocess (0.5.2)
+    childprocess (0.5.3)
       ffi (~> 1.0, >= 1.0.11)
     diff-lcs (1.2.5)
     erubis (2.7.0)
@@ -110,7 +110,7 @@ GEM
       rspec-core (~> 2.14.0)
       rspec-expectations (~> 2.14.0)
       rspec-mocks (~> 2.14.0)
-    rubyzip (1.1.2)
+    rubyzip (1.1.3)
     selenium-webdriver (2.41.0)
       childprocess (>= 0.5.0)
       multi_json (~> 1.0)

data/README.md

@@ -10,11 +10,13 @@ FreeForm is designed primarily with Rails in mind, but it should work on any Rub
 
 **FreeForm will not work with Ryan Bate's nested_form gem, but provides its own identical behavior**
 
+Please use/migrate to version 2.x of this gem.  Version 1.x will no longer be supported, and version 2.x provides a better DSL, additional features, and cleaner source code.
+
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'freeform', '>= 1.0.0'
+    gem 'freeform', '>= 2.0.0'
 
 And then execute:
 
@@ -198,19 +200,18 @@ class UserForm < FreeForm::Form
   property :username,              :on => :user
   property :email,                 :on => :user
 
-  has_many :phone_numbers, :class => PhoneNumberForm, :default_initializer => :phone_initializer
+  has_many :phone_numbers do
+    form_models :phone
+
+    property :area_code,              :on => :phone
+    property :number,                 :on => :phone
+  end
 
   def phone_initializer
     { :phone => user.phone_numbers.build }
   end
 end
 
-class PhoneNumberForm < FreeForm::Form
-  form_models :phone
-
-  property :area_code,              :on => :phone
-  property :number,                 :on => :phone
-end
 ```
 **Note:**  The method `nested_form` is also aliased as `has_many` and `has_one`, if you prefer the expressiveness of that syntax.  The functionality is the same in any case.
 
@@ -235,18 +236,16 @@ class UserForm < FreeForm::Form
   property :username,              :on => :user
   property :email,                 :on => :user
 
-  has_many :phone_numbers, :class => PhoneNumberForm, :default_initializer => :phone_initializer
+  has_many :phone_numbers do
+    form_models :phone
 
-  def phone_initializer
-    { :phone => user.phone_numbers.build }
+    property :area_code,              :on => :phone
+    property :number,                 :on => :phone
   end
-end
-
-class PhoneNumberForm < FreeForm::Form
-  form_models :phone
 
-  property :area_code,              :on => :phone
-  property :number,                 :on => :phone
+  def phone_initializer
+    { :phone => user.phone_numbers.build }
+  end  
 end
 
 form = UserForm.new(:user => current_user)

data/lib/freeform/form/date_params_filter.rb

@@ -0,0 +1,34 @@
+module FreeForm
+  class DateParamsFilter
+    def initialize(*args)
+    end
+
+    def call(params)
+      date_attributes = {}
+
+      params.each do |attribute, value|
+        if value.is_a?(Hash)
+          call(value) # TODO: #validate should only handle local form params.
+        elsif matches = attribute.match(/^(\w+)\(.i\)$/)
+          date_attribute = matches[1]
+          date_attributes[date_attribute] = params_to_date(
+            params.delete("#{date_attribute}(1i)"),
+            params.delete("#{date_attribute}(2i)"),
+            params.delete("#{date_attribute}(3i)")
+          )
+        end
+      end
+      params.merge!(date_attributes)
+    end
+
+  private
+    def params_to_date(year, month, day)
+      day ||= 1 # FIXME: is that really what we want? test.
+      begin # TODO: test fails.
+        return Date.new(year.to_i, month.to_i, day.to_i)
+      rescue ArgumentError => e
+        return nil
+      end
+    end
+  end
+end

data/lib/freeform/form/model.rb

@@ -0,0 +1,56 @@
+require 'freeform/form/date_params_filter'
+
+module FreeForm
+  module Model
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      include Forwardable
+
+      def models
+        @models ||= []
+      end
+
+      def child_models
+        @child_models ||= []
+      end
+
+      def declared_models(*names)
+        names.each do |name|
+          declared_model(name)
+        end
+      end
+      alias_method :form_models, :declared_models
+
+      def declared_model(name, opts={})
+        attr_accessor name
+        @models = (@models || []) << name
+      end
+      alias_method :form_model, :declared_model
+
+      def child_model(name, opts={}, &block)
+        declared_model(name)
+        @child_models = (@child_models || []) << name
+
+        # Defines an initializer method, such as 'initialize_address' 
+        #  that can be called on form initialization to build the model
+        define_method("initialize_#{name}") do
+          instance_variable_set("@#{name}", instance_eval(&block))
+        end
+      end
+    end
+
+    def models
+      Array.new.tap do |a|
+        self.class.models.each do |form_model|
+          a << send(form_model)
+        end
+        a.flatten!
+      end
+    end
+
+  private
+  end
+end

data/lib/freeform/form/nested.rb

@@ -9,64 +9,88 @@ module FreeForm
       #------------------------------------------------------------------------
       attr_accessor :nested_forms
 
-      def nested_form(attribute, options={})
-        nested_form_class = options[:class]
-        @nested_forms ||= {}
-        @nested_forms.merge!({:"#{attribute}" => nested_form_class})
+      def nested_form(attribute, options={}, &block)
+        # Initialize the instance variables on the parent class
+        initialize_instance_variables(attribute)
 
-        # Define an attr_accessor for the parent class to hold this attribute
-        declared_model(attribute)
+        # Define new nested class
+        klass = define_nested_class(attribute, options, &block)
 
-        # Defined other methods
-        define_nested_model_methods(attribute, nested_form_class, options)
-
-        # Setup Handling for nested attributes
-        define_nested_attribute_methods(attribute, nested_form_class)
+        # Define methods for working with nested models
+        define_nested_model_methods(attribute, klass)
       end
       alias_method :has_many, :nested_form
       alias_method :has_one, :nested_form
 
-      protected
-      # Defining Helper Methods For Models
-      #------------------------------------------------------------------------
-      def define_nested_model_methods(attribute, form_class, options={})
-        singularized_attribute = attribute.to_s.singularize.to_s
+    protected
+      def initialize_instance_variables(attribute)
+        declared_model attribute
 
-        # Example: form.addresses will return all nested address forms
         define_method(:"#{attribute}") do
           value = instance_variable_get("@nested_#{attribute}")
           value ||= []
           instance_variable_set("@nested_#{attribute}", value)
         end
+      end
 
-        # Example: form.build_addresses (optional custom initializer)
-        define_method(:"build_#{attribute}") do |initializer=nil|
-          # Builder object
-          parent_object = self
+      def register_nested_form(klass)
+        @nested_forms ||= []
+        @nested_forms << klass
+      end
 
-          # Get correct class
-          form_class = self.class.nested_forms[:"#{attribute}"]
+      def parent_class
+        self
+      end
 
-          # Default Initializer
-          if options[:default_initializer]
-            initializer ||= instance_eval(&options[:default_initializer])
-          end
-          initializer ||= {}
+      def attribute_to_form_class(attribute)
+        singularized_attribute(attribute).camelize
+      end
 
-          # Build new model
-          form_model = form_class.new(initializer)
-          value = instance_variable_get("@nested_#{attribute}")
-          value ||= []
-          value << form_model
-          instance_variable_set("@nested_#{attribute}", value)
+      def define_nested_class(attribute, options={}, &block)
+        # Define new nested class
+        klass = Class.new(FreeForm::Form) do
+        end
 
-          form_model
+        # Add whatever passed in methods, properties, etc. to the class
+        if block_given?
+          klass.class_eval(&block)
         end
-        alias_method :"build_#{singularized_attribute}", :"build_#{attribute}"
+
+        # Set the class name
+        form_class = attribute_to_form_class(attribute)
+        parent_class.const_set(form_class, klass)
+
+        # Register the class as being nested under the current class
+        register_nested_form(klass)
+        klass
       end
 
-      # Defining Helper Methods For Nested Attributes
-      #------------------------------------------------------------------------
+      def define_nested_model_methods(attribute, form_class, options={})
+        singular = singularized_attribute(attribute)
+
+        # Example: form.build_addresses (optional custom initializer)
+        define_method(:"build_#{attribute}") do |initializer=nil|
+          initializer ||= self.send("#{singular}_initializer")
+
+          form_class.new(initializer).tap do |obj|
+            # Add new object to parent model collection (e.g. the new address is in parent.addresses)
+            current_models = self.send(attribute)
+            current_models ||= []
+            current_models << obj
+            self.send("#{attribute}=", current_models)
+          end
+        end
+        alias_method :"build_#{singular}", :"build_#{attribute}"
+
+        # Define methods for working with nested models
+        define_nested_attribute_methods(attribute, form_class)
+      end
+
+      def singularized_attribute(attribute)
+        attribute.to_s.singularize
+      end
+
+      #TODO: Clean up this method!
       def define_nested_attribute_methods(attribute, nested_form_class)
         # Equivalent of "address_attributes=" for "address" attribute
         define_method(:"#{attribute}_attributes=") do |params|
@@ -79,12 +103,13 @@ module FreeForm
             model.fill(attributes)
           end
         end
-      end
+      end      
     end
 
     # Instance Methods
     #--------------------------------------------------------------------------
   protected
+    #TODO: Clean up this method!
     def build_models_from_param_count(attribute, params)
       # Get the difference between sets of params passed and current form objects
       num_param_models = params.length

data/lib/freeform/form/property.rb

@@ -1,3 +1,5 @@
+require 'freeform/form/date_params_filter'
+
 module FreeForm
   module Property
     def self.included(base)
@@ -7,43 +9,6 @@ module FreeForm
     module ClassMethods
       include Forwardable
 
-      # Models
-      #------------------------------------------------------------------------
-      def models
-        @models ||= []
-      end
-
-      def child_models
-        @child_models ||= []
-      end
-
-      def declared_model(name, opts={})
-        @models ||= []
-        @models << name
-        attr_accessor name
-      end
-      alias_method :form_model, :declared_model
-
-      def declared_models(*names)
-        names.each do |name|
-          declared_model(name)
-        end
-      end
-      alias_method :form_models, :declared_models
-
-      def child_model(name, opts={}, &block)
-        @models ||= []
-        @models << name
-        @child_models ||= []
-        @child_models << name
-        attr_accessor name
-        define_method("initialize_#{name}") do
-          instance_variable_set("@#{name}", instance_eval(&block))
-        end
-      end
-
-      # Properties
-      #------------------------------------------------------------------------
       def property_mappings
         # Take the form of {:property => {:model => model, :field => field, :ignore_blank => false}}
         @property_mappings ||= Hash.new
@@ -89,57 +54,48 @@ module FreeForm
       end
     end
 
-    attr_accessor :parent_form
-
-    class DateParamsFilter
-      def call(params)
-        date_attributes = {}
-
-        params.each do |attribute, value|
-          if value.is_a?(Hash)
-            call(value) # TODO: #validate should only handle local form params.
-          elsif matches = attribute.match(/^(\w+)\(.i\)$/)
-            date_attribute = matches[1]
-            date_attributes[date_attribute] = params_to_date(
-              params.delete("#{date_attribute}(1i)"),
-              params.delete("#{date_attribute}(2i)"),
-              params.delete("#{date_attribute}(3i)")
-            )
-          end
-        end
-        params.merge!(date_attributes)
-      end
-
-    private
-      def params_to_date(year, month, day)
-        day ||= 1 # FIXME: is that really what we want? test.
-        begin # TODO: test fails.
-          return Date.new(year.to_i, month.to_i, day.to_i)
-        rescue ArgumentError => e
-          return nil
-        end
-      end
-    end
-
     def assign_params(params)
-      DateParamsFilter.new.call(params)
-      params.each_pair do |attribute, value|
-        assign_attribute(attribute, value)
+      self.tap do |s|
+        FreeForm::DateParamsFilter.new.call(params)
+        before_assign_params(params)
+        params.each_pair do |attribute, value|
+          assign_attribute(attribute, value)
+        end
+        after_assign_params(params)
       end
-      self
     end
     alias_method :assign_attributes, :assign_params
     alias_method :populate, :assign_params
     alias_method :fill, :assign_params
 
+    def before_assign_params(params)
+    end
+    alias_method :before_assign_attributes, :before_assign_params
+    alias_method :before_populate, :before_assign_params
+    alias_method :before_fill, :before_assign_params
+
+    def after_assign_params(params)
+    end
+    alias_method :after_assign_attributes, :after_assign_params
+    alias_method :after_populate, :after_assign_params
+    alias_method :after_fill, :after_assign_params
+
+    def model_property_mappings
+      self.class.property_mappings
+    end
+
   private
     def assign_attribute(attribute, value)
       self.send :"#{attribute}=", value unless ignore?(attribute, value)
     end
 
     def ignore?(attribute, value)
-      mapping = self.class.property_mappings[attribute.to_sym]
-      return (mapping[:ignore_blank] && value.blank?) unless mapping.nil?
+      mapping = model_property_mappings[attribute.to_sym]
+      if mapping.present?
+        mapping[:ignore_blank] && value.blank?
+      else
+        false
+      end
     end
   end
 end

data/lib/freeform/form/validation.rb

@@ -6,59 +6,73 @@ module FreeForm
     end
 
     module ClassMethods
+      def validate_nested_forms
+        validate :validate_nested_forms
+      end
+
       def validate_models
-        validate :model_validity
+        validate :validate_component_models
       end
     end
 
   protected
-    def model_validity
-      self.class.models.each do |form_model|
-        if send(form_model).is_a?(Array)
-          # If it's an array, we're dealing with nested forms
-          errors.add(:base, "has invalid nested forms") unless validate_nested_forms(send(form_model))
-        else
-          # Otherwise, validate the form object
-          validate_form_model(form_model)
-        end
-      end
+    def validate_nested_forms
+      models.each { |m| validate_nested_form(m) if m.is_a?(FreeForm::Form) }
     end
 
-  private
-    def validate_nested_forms(form_array)
-      form_validity = true
-      form_array.each do |model|
-        destroyed = model.respond_to?(:marked_for_destruction?) ? model.marked_for_destruction? : false
-        unless model.valid? || destroyed
-          form_validity = false
-        end
-      end
-      form_validity
+    def validate_component_models
+      models.each { |m| validate_model(m) unless m.is_a?(FreeForm::Form) }
     end
 
-    def validate_form_model(form_model)
-      model = send(form_model)
-      append_errors(form_model)
-      return model.valid?
+  private
+    def validate_nested_form(form)
+      errors.add(:base, "has invalid nested forms") unless marked_for_destruction_or_valid?(form)
     end
 
-    def append_errors(form_model)
-      model = send(form_model)
+    def validate_model(model)
       model.valid?
+      add_model_errors_to_form(model)
+    end
+
+    def marked_for_destruction_or_valid?(form)
+      form_marked_for_destruction?(form) || form.valid?
+    end
+
+    def form_marked_for_destruction?(form)
+      form.respond_to?(:marked_for_destruction?) ? form.marked_for_destruction? : false
+    end
+
+    def add_model_errors_to_form(model)
       model.errors.each do |error, message|
-        if find_form_field_from_model_field(form_model, error)
-          self.errors.add(find_form_field_from_model_field(form_model, error), message)
-        end
+        add_error_to_form(model, error, message)
+      end
+    end
+
+    def add_error_to_form(model, error, message)
+      field = find_form_field_from_model_field(model, error)
+      if field
+        errors.add(field, message)
       end
     end
 
-    def find_form_field_from_model_field(model, field)
-      self.class.property_mappings.each_pair do |property, attributes|
-        if (attributes[:model] == model.to_sym) && (attributes[:field] == field.to_sym)
+    def find_form_field_from_model_field(model, error_field)
+      model_property_mappings.each_pair do |property, attributes|
+        model_sym = model_symbol_from_model(model)
+        field_sym = error_field.to_sym
+
+        if (attributes[:model] == model_sym) && (attributes[:field] == field_sym)
           return property
         end
       end
-      return false
+      nil
+    end
+
+    def model_symbol_from_model(model)
+      models_as_symbols.find { |sym| return sym if send(sym) == model }
+    end
+
+    def models_as_symbols
+      self.class.models.map { |x| x.to_sym }
     end
   end
 end