freeform 0.0.4 → 1.0.0

data/lib/freeform/form/nested.rb

@@ -1,5 +1,3 @@
-require 'freeform/form/property'
-
 module FreeForm
   module Nested
     def self.included(base)
@@ -9,55 +7,18 @@ module FreeForm
     module ClassMethods
       # Nested Forms
       #------------------------------------------------------------------------
-      attr_accessor :nested_forms      
+      attr_accessor :nested_forms
 
-      def nested_form(attribute, options={}, &block)
-        # Specify the class method on which we're defining the initializer for this form.
-        parent_class = self
-        initializer_method = options[:class_initializer]
-        unless initializer_method.nil?
-          define_singleton_method(:"#{initializer_method}") do
-            var = instance_variable_get(:"@#{initializer_method}")
-            var ||= {}
-            var
-          end
-  
-          define_singleton_method(:"#{initializer_method}=") do |val|
-            instance_variable_set(:"@#{initializer_method}", val)
-          end
-        end
+      def nested_form(attribute, options={})
+        nested_form_class = options[:class]
+        @nested_forms ||= {}
+        @nested_forms.merge!({:"#{attribute}" => nested_form_class})
 
         # Define an attr_accessor for the parent class to hold this attribute
         declared_model(attribute)
 
-        # Define the new class, and set it up with a new name
-        nested_form_class = Class.new(FreeForm::Form) do
-          include FreeForm::Property
-          self.instance_eval(&block)
-          
-          define_singleton_method(:default_initializer) do
-            unless initializer_method.nil?
-              method = parent_class.send(initializer_method)
-              if method.is_a? Proc
-                method.call
-              else
-                method
-              end
-            end
-          end
-
-          def initialize(p={}, *args)
-            p = self.class.default_initializer.merge(p)
-            super(p, *args)
-          end
-        end
-        self.const_set("#{attribute.to_s.camelize}Form", nested_form_class)
-
-        @nested_forms ||= {}
-        @nested_forms.merge!({:"#{attribute}" => nested_form_class})
-
         # Defined other methods
-        define_nested_model_methods(attribute, nested_form_class)
+        define_nested_model_methods(attribute, nested_form_class, options)
 
         # Setup Handling for nested attributes
         define_nested_attribute_methods(attribute, nested_form_class)
@@ -65,18 +26,10 @@ module FreeForm
       alias_method :has_many, :nested_form
       alias_method :has_one, :nested_form
 
-      # Supporting Methods
-      #------------------------------------------------------------------------
-      def reflect_on_association(key, *args)
-        reflection = OpenStruct.new
-        reflection.klass = self.nested_forms[key]
-        reflection
-      end
-
       protected
       # Defining Helper Methods For Models
       #------------------------------------------------------------------------
-      def define_nested_model_methods(attribute, form_class)
+      def define_nested_model_methods(attribute, form_class, options={})
         singularized_attribute = attribute.to_s.singularize.to_s
 
         # Example: form.addresses will return all nested address forms 
@@ -85,9 +38,18 @@ module FreeForm
         end
         
         # Example: form.build_addresses (optional custom initializer)
-        define_method(:"build_#{attribute}") do |initializer={}|
+        define_method(:"build_#{attribute}") do |initializer=nil|
+          # Builder object
+          parent_object = self
+          
           # Get correct class
           form_class = self.class.nested_forms[:"#{attribute}"]
+          
+          # Default Initializer
+          if options[:default_initializer]
+            initializer ||= instance_eval(&options[:default_initializer])
+          end
+          initializer ||= {}
 
           # Build new model
           form_model = form_class.new(initializer)

data/lib/freeform/form/property.rb

@@ -13,6 +13,10 @@ module FreeForm
         @models ||= []
       end
 
+      def child_models
+        @child_models ||= []
+      end
+
       def declared_model(name, opts={})
         @models ||= []
         @models << name        
@@ -27,73 +31,109 @@ module FreeForm
       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 ignored_blank_params
-        @ignored_blank_params ||= []
+      def property_mappings
+        # Take the form of {:property => {:model => model, :field => field, :ignore_blank => false}}
+        @property_mappings ||= Hash.new
       end
 
       def allow_destroy_on_save
         # Define _destroy method for marked-for-destruction handling
         attr_accessor :_destroy
-        alias_method :marked_for_destruction, :_destroy
+        define_method(:_destroy=) do |value|
+          false_values = [nil, 0 , false, "0", "false"]
+          @_destroy = !(false_values.include?(value))
+        end
+        alias_method :marked_for_destruction?, :_destroy
+        define_method(:mark_for_destruction) do
+          @_destroy = true
+        end
       end
 
       def property(attribute, options={})
-        if options[:on]
-          def_delegator options[:on], attribute
-          def_delegator options[:on], "#{attribute}=".to_sym
-        else
+        @property_mappings ||= Hash.new
+        model = options[:on] ? options [:on] : :self
+        field = options[:as] ? options[:as] : attribute.to_sym
+        ignore_blank = options[:ignore_blank] ? options[:ignore_blank] : false
+        @property_mappings.merge!({field => {:model => model, :field => attribute.to_sym, :ignore_blank => ignore_blank}})
+
+        if model == :self
           attr_accessor attribute
+        else
+          define_method("#{field}") do
+            send("#{model}").send("#{attribute}")
+          end
+
+          define_method("#{field}=") do |value|
+            send("#{model}").send("#{attribute}=", value)
+          end
+        end
+      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
-        @ignored_blank_params ||= []
-        @ignored_blank_params << attribute if options[:ignore_blank]
       end
     end
 
     def assign_params(params)
-      filter_dates(params)
+      DateParamsFilter.new.call(params)
       params.each_pair do |attribute, value|
-        self.send :"#{attribute}=", value unless ignore?(attribute, value)
+        assign_attribute(attribute, value)
       end
       self
     end
     alias_method :assign_attributes, :assign_params
     alias_method :populate, :assign_params
     alias_method :fill, :assign_params
-    
-    def ignore?(attribute, value)
-      ignored_if_blank = self.class.ignored_blank_params
-      return (ignored_if_blank.include?(attribute.to_sym) && value.blank?)
-    end
 
-    private
-    #TODO: This should be its own model
-    def filter_dates(params)
-      date_attributes = {}
-      params.each do |attribute, value|
-        if attribute.to_s.include?("(1i)") || attribute.to_s.include?("(2i)") || attribute.to_s.include?("(3i)")
-          date_attribute = attribute.to_s.gsub(/(\(.*\))/, "")
-          date_attributes[date_attribute.to_sym] = params_to_date(
-            params.delete("#{date_attribute}(1i)"),
-            params.delete("#{date_attribute}(2i)"),
-            params.delete("#{date_attribute}(3i)")
-          )        
-        end
-      end
-      params.merge!(date_attributes)
+  private
+    def assign_attribute(attribute, value)
+      self.send :"#{attribute}=", value unless ignore?(attribute, value)      
     end
-    
-    def params_to_date(year, month, day)
-      day ||= 1
-      begin
-        return Date.new(year.to_i, month.to_i, day.to_i)
-      rescue => e
-        return nil
-      end
+
+    def ignore?(attribute, value)
+      mapping = self.class.property_mappings[attribute.to_sym]
+      return (mapping[:ignore_blank] && value.blank?) unless mapping.nil?
     end
   end
-  
-  #Instance Methods
-  #----------------------------------------------------------------------------
 end

data/lib/freeform/form/validation.rb

@@ -2,6 +2,7 @@ module FreeForm
   module Validation
     def self.included(base)
       base.extend(ClassMethods)
+      extend FreeForm::Property
     end
         
     module ClassMethods
@@ -10,25 +11,51 @@ module FreeForm
       end
     end
       
-    protected
+  protected
     def model_validity
-      model_validity = true
-      self.class.models.each do |form_model|
+      self.class.models.each do |form_model|                
         if send(form_model).is_a?(Array)
-          send(form_model).each { |model| model_validity = validate_and_append_errors(model) && model_validity }
+          # 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
-          model_validity = validate_and_append_errors(send(form_model)) && model_validity
+          # Otherwise, validate the form object
+          validate_form_model(form_model)
         end
       end
-      return model_validity
     end
   
-    def validate_and_append_errors(model)
-      unless model.valid?
-        model.errors.each { |error, message| self.errors.add(error, message) }
-        return false
+  private
+    def validate_nested_forms(form_array)
+      form_validity = true
+      form_array.each do |model| 
+        form_validity = false unless model.valid?
       end
-      return true
+      form_validity
+    end
+  
+    def validate_form_model(form_model)
+      model = send(form_model)
+      append_errors(form_model)
+      return model.valid?
+    end
+    
+    def append_errors(form_model)
+      model = send(form_model)
+      model.valid?
+      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
+      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)
+          return property
+        end
+      end
+      return false
     end
   end
 end

data/lib/freeform/form.rb

@@ -22,51 +22,48 @@ module FreeForm
     # Instance Methods
     #----------------------------------------------------------------------------
     # Required for ActiveModel
-    def persisted?
-      false
-    end
+    def persisted?; false end
 
     def initialize(h={})
       h.each {|k,v| send("#{k}=",v)}
+      initialize_child_models      
     end  
     
     def save
       return false unless valid?
+
       self.class.models.each do |form_model|
-        if send(form_model).is_a?(Array)
-          send(form_model).each { |model| return model.save }
-        else
-          if marked_for_destruction?
-            send(form_model).destroy
-          else
-            return false unless send(form_model).save
-          end
-        end
+        model = send(form_model)
+        model.is_a?(Array) ? model.each { |m| m.save } : save_or_destroy(model)
       end
-      return true
     end
   
     def save!
       raise FreeForm::FormInvalid, "form invalid." unless valid?
+
       self.class.models.each do |form_model|
-        if send(form_model).is_a?(Array)
-          send(form_model).each { |model| model.save! }
-        else
-          if marked_for_destruction?
-            send(form_model).destroy
-          else
-            send(form_model).save!
-          end
-        end
+        model = send(form_model)
+        model.is_a?(Array) ? model.each { |m| m.save! } : save_or_destroy!(model)
       end
     end    
     
+  private
+    def initialize_child_models
+      self.class.child_models.each do |c|
+        send("initialize_#{c}")
+      end      
+    end
+
+    def save_or_destroy(model)
+      marked_for_destruction? ? model.destroy : model.save
+    end
+    
+    def save_or_destroy!(model)
+      marked_for_destruction? ? model.destroy : model.save!
+    end
+
     def marked_for_destruction?
-      if self.respond_to?(:_destroy)
-        return self._destroy
-      else
-        return false
-      end
+      respond_to?(:_destroy) ? _destroy : false
     end
   end
 end

data/lib/freeform/version.rb

@@ -1,3 +1,3 @@
 module Freeform
-  VERSION = "0.0.4"
+  VERSION = "1.0.0"
 end

data/lib/freeform.rb

@@ -2,4 +2,8 @@ require 'freeform/version'
 require 'freeform/form'
 
 if defined?(Rails) # Where to include Rails specific modules...
+  require 'freeform/builder/builder_mixin'
+  require 'freeform/builder/builders'
+  require 'freeform/builder/view_helper'
+  require 'freeform/builder/engine'
 end

data/lib/generators/freeform/install_generator.rb

@@ -0,0 +1,17 @@
+module FreeForm
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      def self.source_root
+        File.expand_path('../../../../vendor/assets/javascripts', __FILE__)
+      end
+
+      def copy_jquery_file
+        if File.exists?('public/javascripts/prototype.js')
+          copy_file 'prototype_freeform.js', 'public/javascripts/freeform.js'
+        else
+          copy_file 'jquery_freeform.js', 'public/javascripts/freeform.js'
+        end
+      end
+    end
+  end
+end

data/lib/tasks/freeform_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :freeform do
+#   # Task goes here
+# end