freeform 0.0.1 → 0.0.2

data/.project

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>freeform</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+	</buildSpec>
+	<natures>
+		<nature>com.aptana.projects.webnature</nature>
+	</natures>
+</projectDescription>

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/README.md

@@ -1,6 +1,12 @@
-# Freeform
+# FreeForm
 
-TODO: Write a gem description
+FreeForm is a gem designed to give you total control over form objects, allowing you to map form objects to domain objects in any way that you see fit.
+
+It is still a very-pre-beta work in progess, but hopefully it can showcase the power of form objects.
+
+FreeForm is designed primarily with Rails in mind, but it should work on any Ruby framework.
+
+FreeForm is compatible with (as far as I know) most form gems, including simpleform, formbuilder, and Ryan Bate's nested_form gem.
 
 ## Installation
 
@@ -16,9 +22,208 @@ Or install it yourself as:
 
     $ gem install freeform
 
-## Usage
+## How It Works
+
+FreeForm can 1-*n* models, exposing whatever attributes you wish from each model, and delegating those assignments back to the models themselves.  This means that one form can be used just as easily to support parent/child models, multiple unrelated models, etc.  Your database relationships can change, and your forms won't have to.
+
+**Example**
+
+```ruby
+class RegistrationForm < FreeForm::Form
+  form_models :user, :address
+
+  property :username,              :on => :user
+  property :email,                 :on => :user
+  property :password,              :on => :user
+
+  property :street,                :on => :address
+  property :city,                  :on => :address
+  property :state,                 :on => :address
+  property :zip_code,              :on => :address
+end
+
+class User < ActiveRecord::Base
+  has_one :address
+  ...
+end
+
+class Address < ActiveRecord::Base
+  belongs_to :user
+  ...
+end
+
+user = User.new
+RegistrationForm.new(:user => user, :address => user.build_address)
+```
+**Oh No!**
+Our domain model has changed, and we needs users to have multiple addresses!  We'll change our model...but our form remains the same.
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :addresses
+  ...
+end
+
+class Address < ActiveRecord::Base
+  belongs_to :user
+  ...
+end
+
+user = User.new
+RegistrationForm.new(:user => user, :address => user.addresses.build)
+```
+
+## Defining Forms
+
+FreeForm doesn't assume a lot, so you need to tell it:
+  * The names of the models it's going to be mapping (specified as `form_model` or `form_models`)
+  * The properties of the form, and which model they map to (specified as `property` or `properties`).  Properties that don't map to a model are considered to be just form attributes.
+  * How to validate, if at all (see below)
+  
+```ruby
+class RegistrationForm < FreeForm::Form
+  form_models :user, :address
+
+  property :username,              :on => :user
+  property :email,                 :on => :user
+  property :password,              :on => :user
+
+  property :street,                :on => :address
+  property :city,                  :on => :address
+  property :state,                 :on => :address
+  property :zip_code,              :on => :address
+end
+
+class User < ActiveRecord::Base
+  has_one :address
+  ...
+end
+
+class Address < ActiveRecord::Base
+  belongs_to :user
+  ...
+end
+
+user = User.new
+RegistrationForm.new(:user => user, :address => user.build_address)
+```
+## Form Validations
+
+FreeForm handles validations wherever you define them.  If you want to check model validations, simply specify that option in your form definition
+
+```ruby
+class UserForm < FreeForm::Form
+  form_models :user
+  validate_models  # This will check to see that the :user model itself is valid
+
+  property :username,              :on => :user
+  property :email,                 :on => :user
+  property :current_password
+  
+  # But you can also validate in the form itself!
+  validates :email, :presence => true  
+  validate :valid_current_password
+  
+  def valid_current_password
+    user.password == current_password
+  end
+end
+```
+Personally, I use validations in both places.  My domain models have their own validations, which I use for things that are universally true of that model (e.g. email is correctly formatted).  Some forms have validations though that are specific to that form, and they live in the form itself (see above example with `current_password`) 
+
+## Nesting Forms
+
+Sometimes, you need to be able to support a collection of unknown size (e.g. a user with many phone numbers).  Since FreeForm makes no assumptions about your domain models, we nest forms themselves.
+
+```ruby
+class UserForm < FreeForm::Form
+  form_models :user
+
+  property :username,              :on => :user
+  property :email,                 :on => :user
+  
+  nested_form :phone_numbers do
+    form_models :phone
+	
+	property :area_code,              :on => :phone
+	property :number,                 :on => :phone
+  end
+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.
+
+When using a nested form, the form starts with **no** nested forms pre-built.  FreeForm provides a method called `build_#{nested_form_model}` (e.g. `build_phone_numbers`) that you can use to build a nested form.  You must provide the initializer:
+```ruby
+form = UserForm.new(:user => User.new)
+form.build_phone_numbers(:phone => Phone.new)
+# The singularized version is aliased as well.
+form.build_phone_number(:phone => Phone.new) 
+```
+
+You can specify the default initializers for that form with the accessor `#{nested_form_name}_form_initializer`.
+```ruby
+form = UserForm.new(
+  :user => User.new, 
+  :phone_numbers_form_initializer => {:phone => Phone.new} )
+
+form.build_phone_numbers
+form.build_phone_number
+```
+This is a necessary parameter if you're using the `nested_form` gem, as new nested forms are initialized automatically.
+
+## Initialize With Care!
+
+FreeForm's flexibility comes at a bit of a cost - it makes no assumptions about relationships between initialized models or nested forms.  So initializing the form correctly is important.
+
+** Example **
+```ruby
+current_user               # => #<User:0x100124b88>
+current_user.phone_numbers # => [#<Phone:0x100194867>, #<Phone:0x100100cd4>]
+
+class UserForm < FreeForm::Form
+  form_models :user
+
+  property :username,              :on => :user
+  property :email,                 :on => :user
+  
+  nested_form :phone_numbers do
+    form_models :phone
+	
+	property :area_code,              :on => :phone
+	property :number,                 :on => :phone
+  end
+end
+
+form = UserForm.new(:user => current_user)
+```
+
+Will the current_user's phone numbers automatically appear as nested forms? **No.**
+If you want them there, put them there, like this:
+
+```ruby
+current_user.phone_numbers.each do |phone_number|
+  form.build_phone_number(:phone => phone_number)
+end
+```
+
+## Extras!
+
+I'm open to trying to build out little helper features wherever possible. Right now, FreeForm comes with one handy option called `form_input_key`.  Setting this determines the parameter key that your forms are rendered with in Rails.
+
+*Why use this?*
+Well, I like to keep my form keys fairly concise, but in a bigger application I often end up namespacing my forms.  And changing namespaces sometimes breaks Cucumber specs, which might be hardcoded to find a particular ID.  No more!
+
+```ruby
+class MyScope::UserForm < FreeForm::Form
+  form_input_key :user # Sets the parameter key for HTML rendering.
+  form_models :user
 
-TODO: Write usage instructions here
+  property :email, :on => :user
+end
+```
+Would render with HTML input fields like 
+`<input id="user_email" ... name="user[email]"></input>` instead of
+`<input id="my_scope_user_form_email" ... name="my_scope_user_form[email]"></input>`
 
 ## Contributing
 

data/freeform.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency             "activemodel"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
 

data/lib/freeform/form/form_input_key.rb

@@ -0,0 +1,17 @@
+module FreeForm
+  module FormInputKey
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+        
+    module ClassMethods
+      def form_input_key(name)
+        constant = name.to_s.camelize
+        Object.const_set(constant, Class.new) unless Object.const_defined?(constant)    
+        define_singleton_method(:model_name) do
+          ActiveModel::Name.new(constant.constantize)
+        end
+      end
+    end
+  end
+end

data/lib/freeform/form/nested.rb

@@ -0,0 +1,110 @@
+require 'freeform/form/property'
+
+module FreeForm
+  module Nested
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+        
+    module ClassMethods
+      # Nested Forms
+      #------------------------------------------------------------------------
+      attr_accessor :nested_forms      
+
+      def nested_form(attribute, options={}, &block)
+        # 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)
+        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)
+
+        # Setup Handling for nested attributes
+        define_nested_attribute_methods(attribute, nested_form_class)
+      end
+      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)
+        singularized_attribute = attribute.to_s.singularize.to_s
+
+        # Example: form.addresses will return all nested address forms 
+        define_method(:"#{attribute}") do
+          @nested_attributes ||= []
+        end
+        
+        # Example: form.address_form_initializer (aliased to form.addresses_form_initializer)
+        attr_accessor :"#{attribute}_form_initializer"
+        alias_method :"#{singularized_attribute}_form_initializer", :"#{attribute}_form_initializer"
+        alias_method :"#{singularized_attribute}_form_initializer=", :"#{attribute}_form_initializer="
+
+        # Example: form.build_addresses (optional custom initializer)
+        define_method(:"build_#{attribute}") do |initializer=nil|
+          # Get correct class
+          form_class = self.class.nested_forms[:"#{attribute}"]
+          
+          # Set default intializer if none provided
+          initializer ||= send("#{attribute}_form_initializer")
+
+          # Build new model
+          form_model = form_class.new(initializer)
+          @nested_attributes ||= []
+          @nested_attributes << form_model
+          form_model
+        end
+        alias_method :"build_#{singularized_attribute}", :"build_#{attribute}"
+      end
+
+      # Defining Helper Methods For Nested Attributes
+      #------------------------------------------------------------------------
+      def define_nested_attribute_methods(attribute, nested_form_class)
+        # Equivalent of "address_attributes=" for "address" attribute
+        define_method(:"#{attribute}_attributes=") do |params|
+          build_models_from_param_count(attribute, params)
+
+          self.send(:"#{attribute}").zip(params).each do |model, params_array|
+            identifier = params_array[0]
+            attributes = params_array[1]
+            #TODO: Check the key against id?
+            model.fill(attributes)
+          end
+        end
+      end
+    end
+
+    # Instance Methods
+    #--------------------------------------------------------------------------
+    protected
+    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
+      num_built_models = self.send(:"#{attribute}").nil? ? 0 : self.send(:"#{attribute}").length          
+      additional_models_needed = num_param_models - num_built_models
+
+      # Make up the difference by building new nested form models
+      additional_models_needed.times do
+        send("build_#{attribute.to_s}")
+      end
+    end
+  end
+end

data/lib/freeform/form/persistence.rb

@@ -0,0 +1,57 @@
+module FreeForm
+  module Persistence
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+        
+    module ClassMethods
+      def validate_models
+        validate :model_validity
+      end
+    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
+          return false unless send(form_model).save
+        end
+      end
+      return true
+    end
+  
+    def save!
+      raise StandardError, "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
+          send(form_model).save!
+        end
+      end
+    end
+  
+    protected
+    def model_validity
+      model_validity = true
+      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 }
+        else
+          model_validity = validate_and_append_errors(send(form_model)) && model_validity
+        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
+      end
+      return true
+    end
+  end
+end

data/lib/freeform/form/property.rb

@@ -0,0 +1,90 @@
+module FreeForm
+  module Property
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      include Forwardable
+
+      # Models
+      #------------------------------------------------------------------------
+      def models
+        @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
+
+      # Properties
+      #------------------------------------------------------------------------
+      def ignored_blank_params
+        @ignored_blank_params ||= []
+      end
+
+      def property(attribute, options={})
+        if options[:on]
+          def_delegator options[:on], attribute
+          def_delegator options[:on], "#{attribute}=".to_sym
+        else
+          attr_accessor attribute
+        end
+        @ignored_blank_params ||= []
+        @ignored_blank_params << attribute if options[:ignore_blank]
+      end
+    end
+
+    def assign_params(params)
+      filter_dates(params)
+      params.each_pair do |attribute, value|
+        self.send :"#{attribute}=", value unless ignore?(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)
+    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
+    end
+  end
+end

data/lib/freeform/form.rb

@@ -0,0 +1,24 @@
+require 'forwardable'
+require 'ostruct'
+require 'active_model'
+
+module FreeForm
+  class Form
+    extend Forwardable
+    extend ActiveModel::Naming
+    extend ActiveModel::Callbacks
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+
+    # Instance Methods
+    #----------------------------------------------------------------------------
+    # Required for ActiveModel
+    def persisted?
+      false
+    end
+
+    def initialize(h={})
+      h.each {|k,v| send("#{k}=",v)}
+    end  
+  end
+end

data/lib/freeform/version.rb

@@ -1,3 +1,3 @@
 module Freeform
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/freeform.rb

@@ -1,5 +1,14 @@
-require "freeform/version"
+require 'freeform/version'
+require 'freeform/form'
+#require 'reform/form/composition'
+#require 'reform/form/active_model'
 
+if defined?(Rails) # DISCUSS: is everyone ok with this?
+ # require 'reform/rails'
+end
+
+=begin
 module Freeform
   # Your code goes here...
 end
+=end

data/spec/form/form_input_key_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'freeform/form/form_input_key'
+
+describe FreeForm::FormInputKey do
+  describe "form input key", :form_input_key => true do
+    let(:form_class) do
+      Class.new(Module) do
+        include FreeForm::FormInputKey
+        form_input_key :test_key
+        
+        attr_accessor :my_accessor
+      end
+    end
+
+    it "sets form_input_key" do
+      form_class.model_name.should eq("TestKey")
+    end
+  end
+end

data/spec/form/nested_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'freeform/form/property'
+require 'freeform/form/nested'
+
+describe FreeForm::Nested do
+  describe "class methods", :class_methods => true do
+    describe "has_many", :has_many => true do
+      let(:form_class) do
+        klass = Class.new(Module) do
+          include FreeForm::Property
+          include FreeForm::Nested
+
+          has_many :mailing_addresses do
+            declared_model :address
+            
+            property :street, :on => :address
+          end
+          
+          def initialize(h={})
+            h.each {|k,v| send("#{k}=",v)}
+          end  
+        end
+        # This wrapper just avoids CONST warnings
+        v, $VERBOSE = $VERBOSE, nil
+          Module.const_set("DummyForm", klass)
+        $VERBOSE = v
+        klass
+      end
+  
+      let(:form) do
+        form_class.new( :mailing_address_form_initializer => { :address => OpenStruct.new } )
+      end
+
+      describe "form class" do
+        it "sets nested_form in models" do
+          form_class.models.should eq([:mailing_addresses])
+        end
+      end
+      
+      describe "building nested models" do
+        it "initializes with no nested models prebuilt" do
+          form.mailing_addresses.should eq([])
+        end
+        
+        it "allows nested_forms to be built" do
+          form.build_mailing_addresses
+          form.mailing_addresses.should be_an(Array)
+          form.mailing_addresses.should_not be_empty
+          form.mailing_addresses.first.should be_a(Module::DummyForm::MailingAddressesForm)
+        end
+
+        it "allows nested_forms to be built with custom initializers" do
+          form.build_mailing_address(:address => OpenStruct.new(:street => "1600 Pennsylvania Ave."))
+          form.mailing_addresses.first.street.should eq("1600 Pennsylvania Ave.")
+        end
+
+        it "reflects on association" do
+          reflection = form_class.reflect_on_association(:mailing_addresses)
+          reflection.klass.should eq(Module::DummyForm::MailingAddressesForm)
+        end
+      end
+      
+      describe "setting attributes" do
+        describe "nested attribute assignment" do
+          let(:attributes) do
+            { :mailing_addresses_attributes => { "0" => { :street => "123 Main St." } } }
+          end
+  
+          it "assigns nested attributes" do
+            form.fill(attributes)
+            form.mailing_addresses.first.street.should eq("123 Main St.")
+          end
+        end
+      end      
+    end
+  end
+end

data/spec/form/persistence_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+require 'freeform/form/property'
+require 'freeform/form/nested'
+require 'freeform/form/persistence'
+
+describe FreeForm::Persistence do
+  let(:user) do
+    model = Class.new(Module) do
+      include ActiveModel::Validations
+      def self.model_name; ActiveModel::Name.new(self, nil, "user") end
+
+      attr_accessor :username
+      validates :username, :presence => true
+
+      def save; return valid? end
+      alias_method :save!, :save
+    end.new
+    model
+  end
+
+  let(:address) do
+    model = Class.new(Module) do
+      include ActiveModel::Validations
+      def self.model_name; ActiveModel::Name.new(self, nil, "address") end
+
+      attr_accessor :street
+      attr_accessor :city
+      validates :street, :presence => true
+
+      def save; return valid? end
+      alias_method :save!, :save
+    end.new
+    model
+  end
+
+  describe "validation", :validation => true do    
+    context "without model validation" do
+      let(:form_class) do
+        klass = Class.new(Module) do
+          include ActiveModel::Validations
+          include FreeForm::Property
+          include FreeForm::Nested
+          include FreeForm::Persistence
+
+          form_model :user
+          property :username, :on => :user
+          validates :username, :presence => true
+          
+          nested_form :addresses do
+            declared_model :address
+            
+            property :street, :on => :address
+          end
+          
+          def initialize(h={})
+            h.each {|k,v| send("#{k}=",v)}
+          end  
+        end
+        # This wrapper just avoids CONST warnings
+        v, $VERBOSE = $VERBOSE, nil
+          Module.const_set("DummyForm", klass)
+        $VERBOSE = v
+        klass
+      end
+  
+      let(:form) do
+        test_form = form_class.new( :user => OpenStruct.new, :address_form_initializer => { :address => OpenStruct.new } )
+        test_form.build_address
+        test_form
+      end
+
+      it "is not valid initially" do
+        form.should_not be_valid
+      end
+
+      it "has error on :username" do
+        form.valid?
+        form.errors[:username].should eq(["can't be blank"])
+      end
+
+      it "does not have errors on address" do
+        form.valid?
+        form.addresses.first.errors.should be_empty
+      end
+    end
+
+    context "with model validation" do
+      let(:form_class) do
+        klass = Class.new(Module) do
+          include ActiveModel::Validations
+          include FreeForm::Property
+          include FreeForm::Nested
+          include FreeForm::Persistence
+          validate_models
+
+          form_model :user
+          property :username, :on => :user
+          property :form_property
+          validates :form_property, :presence => true
+          
+          nested_form :addresses do
+            include ActiveModel::Validations
+            include FreeForm::Property
+            include FreeForm::Nested
+            include FreeForm::Persistence
+            validate_models
+            declared_model :address
+            
+            property :street, :on => :address
+            property :city, :on => :address
+          end
+          
+          def initialize(h={})
+            h.each {|k,v| send("#{k}=",v)}
+          end  
+        end
+        # This wrapper just avoids CONST warnings
+        v, $VERBOSE = $VERBOSE, nil
+          Module.const_set("DummyForm", klass)
+        $VERBOSE = v
+        klass
+      end
+  
+      let(:form) do
+        test_form = form_class.new( :user => user, :address_form_initializer => { :address => address } )
+        test_form.build_address
+        test_form
+      end
+
+      it "is not valid initially" do
+        form.should_not be_valid
+      end
+
+      it "has error on :username" do
+        form.valid?
+        form.errors[:username].should eq(["can't be blank"])
+      end
+
+      it "has error on :form_property" do
+        form.valid?
+        form.errors[:form_property].should eq(["can't be blank"])
+      end
+
+      it "has error on address street" do
+        form.valid?
+        form.addresses.first.errors[:street].should eq(["can't be blank"])
+      end
+    end
+  end
+
+  describe "saving", :saving => true do
+    let(:form_class) do
+      klass = Class.new(Module) do
+        include ActiveModel::Validations
+        include FreeForm::Property
+        include FreeForm::Nested
+        include FreeForm::Persistence
+        validate_models
+
+        form_model :user
+        property :username, :on => :user
+        property :form_property
+        validates :form_property, :presence => true
+        
+        nested_form :addresses do
+          include ActiveModel::Validations
+          include FreeForm::Property
+          include FreeForm::Nested
+          include FreeForm::Persistence
+          validate_models
+          declared_model :address
+          
+          property :street, :on => :address
+          property :city, :on => :address
+        end
+        
+        def initialize(h={})
+          h.each {|k,v| send("#{k}=",v)}
+        end  
+      end
+      # This wrapper just avoids CONST warnings
+      v, $VERBOSE = $VERBOSE, nil
+        Module.const_set("DummyForm", klass)
+      $VERBOSE = v
+      klass
+    end
+
+    let(:form) do
+      test_form = form_class.new( :user => user, :address_form_initializer => { :address => address } )
+      test_form.build_address
+      test_form
+    end
+    
+    context "form is invalid" do
+      it "should be invalid" do
+        form.should_not be_valid
+      end
+
+      it "should return false on 'save'" do
+        form.save.should be_false
+      end
+
+      it "should raise error on 'save!'" do
+        expect{ form.save!.should be_false }.to raise_error
+      end
+    end
+
+    context "form is valid" do
+      before(:each) do
+        form.fill({
+          :username => "myusername",
+          :form_property => "present",
+          :addresses_attributes => { "0" => {
+            :street => "123 Main St.",
+            :city => "Springfield"
+          } }
+        })
+      end
+
+      it "should be valid" do
+        form.should be_valid
+      end
+
+      it "should return true on 'save', and call save on other models" do
+        user.should_receive(:save).and_return(true)
+        address.should_receive(:save).and_return(true)
+        form.save.should be_true
+      end
+
+      it "should return true on 'save!', and call save! on other models" do
+        user.should_receive(:save!).and_return(true)
+        address.should_receive(:save!).and_return(true)
+        form.save!.should be_true
+      end
+    end
+  end
+end

data/spec/form/property_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+require 'freeform/form/property'
+
+describe FreeForm::Property do
+  describe "class methods", :class_methods => true do
+    describe "models", :models => true do
+      describe "declared model", :declared_model => true do
+        let(:form_class) do
+          Class.new(Module) do
+            include FreeForm::Property
+            declared_model :test_model_1
+            declared_model :test_model_2
+    
+            def initialize(h={})
+              h.each {|k,v| send("#{k}=",v)}
+            end  
+          end
+        end
+    
+        let(:form) do
+          form_class.new(
+            :test_model_1 => OpenStruct.new(:dummy => "yes"),
+            :test_model_2 => OpenStruct.new(:test => "clearly")
+          )
+        end
+    
+        it "sets declared models as accessor" do
+          form.test_model_1.should eq(OpenStruct.new(:dummy => "yes"))
+          form.test_model_2.should eq(OpenStruct.new(:test => "clearly"))
+        end
+    
+        it "has writable set accessors" do
+          form.test_model_1 = "Something New"
+          form.test_model_1.should eq("Something New")
+        end
+    
+        it "sets @models in class to declared models" do
+          form_class.models.should eq([:test_model_1, :test_model_2])
+        end
+      end
+    
+      describe "form model", :form_model => true do
+        let(:form_class) do
+          Class.new(Module) do
+            include FreeForm::Property
+            form_model :test_model_1
+            form_model :test_model_2
+    
+            def initialize(h={})
+              h.each {|k,v| send("#{k}=",v)}
+            end  
+          end
+        end
+    
+        let(:form) do
+          form_class.new(
+            :test_model_1 => OpenStruct.new(:dummy => "yes"),
+            :test_model_2 => OpenStruct.new(:test => "clearly")
+          )
+        end
+    
+        it "sets declared models as accessor" do
+          form.test_model_1.should eq(OpenStruct.new(:dummy => "yes"))
+          form.test_model_2.should eq(OpenStruct.new(:test => "clearly"))
+        end
+    
+        it "has writable set accessors" do
+          form.test_model_1 = "Something New"
+          form.test_model_1.should eq("Something New")
+        end
+    
+        it "sets @models in class to declared models" do
+          form_class.models.should eq([:test_model_1, :test_model_2])
+        end
+      end
+    
+      describe "declared models", :declared_models => true do
+        let(:form_class) do
+          Class.new(Module) do
+            include FreeForm::Property
+            declared_models :test_model_1, :test_model_2
+    
+            def initialize(h={})
+              h.each {|k,v| send("#{k}=",v)}
+            end  
+          end
+        end
+    
+        let(:form) do
+          form_class.new(
+            :test_model_1 => OpenStruct.new(:dummy => "yes"),
+            :test_model_2 => OpenStruct.new(:test => "clearly")
+          )
+        end
+    
+        it "sets declared models as accessor" do
+          form.test_model_1.should eq(OpenStruct.new(:dummy => "yes"))
+          form.test_model_2.should eq(OpenStruct.new(:test => "clearly"))
+        end
+    
+        it "has writable set accessors" do
+          form.test_model_1 = "Something New"
+          form.test_model_1.should eq("Something New")
+        end
+    
+        it "sets @models in class to declared models" do
+          form_class.models.should eq([:test_model_1, :test_model_2])
+        end
+      end
+    
+      describe "form models", :form_models => true do
+        let(:form_class) do
+          Class.new(Module) do
+            include FreeForm::Property
+            form_models :test_model_1, :test_model_2
+    
+            def initialize(h={})
+              h.each {|k,v| send("#{k}=",v)}
+            end  
+          end
+        end
+    
+        let(:form) do
+          form_class.new(
+            :test_model_1 => OpenStruct.new(:dummy => "yes"),
+            :test_model_2 => OpenStruct.new(:test => "clearly")
+          )
+        end
+    
+        it "sets declared models as accessor" do
+          form.test_model_1.should eq(OpenStruct.new(:dummy => "yes"))
+          form.test_model_2.should eq(OpenStruct.new(:test => "clearly"))
+        end
+    
+        it "has writable set accessors" do
+          form.test_model_1 = "Something New"
+          form.test_model_1.should eq("Something New")
+        end
+    
+        it "sets @models in class to declared models" do
+          form_class.models.should eq([:test_model_1, :test_model_2])
+        end
+      end
+    end
+    
+    describe "properties", :properties => true do
+      describe "property", :property => true do
+        let(:form_class) do
+          Class.new(Module) do
+            include FreeForm::Property
+            declared_model :test_model
+            
+            property :attribute_1, :on => :test_model
+            property :attribute_2, :on => :test_model, :ignore_blank => true
+    
+            def initialize(h={})
+              h.each {|k,v| send("#{k}=",v)}
+            end  
+          end
+        end
+    
+        let(:form) do
+          form_class.new(
+            :test_model => OpenStruct.new(:attribute_1 => "yes"),
+          )
+        end
+    
+        it "delegates properties to models" do
+          form.attribute_1.should eq("yes")
+          form.attribute_2.should be_nil
+        end  
+  
+        it "allows properties to be written, and delegates the values" do
+          form.attribute_1 = "changed"
+          form.attribute_1.should eq("changed")
+          form.test_model.attribute_1.should eq("changed")
+        end  
+  
+        it "tracks ignored blank fields" do
+          form_class.ignored_blank_params.should eq([:attribute_2])
+        end  
+      end
+    end
+  end
+
+  describe "instance methods", :instance_methods => true do
+    describe "assign_attributes", :assign_attributes => true do
+      let(:form_class) do
+        Class.new(Module) do
+          include FreeForm::Property
+          declared_model :first_model
+          declared_model :second_model
+          
+          property :attribute_1, :on => :first_model
+          property :attribute_2, :on => :first_model, :ignore_blank => true
+          property :attribute_3, :on => :second_model, :ignore_blank => true
+          property :attribute_4, :on => :second_model
+  
+          def initialize(h)
+            h.each {|k,v| send("#{k}=",v)}
+          end
+        end
+      end
+  
+      let(:form) do
+        form_class.new(
+          :first_model  => OpenStruct.new(:attribute_1 => "first", :attribute_2 => "second"),
+          :second_model => OpenStruct.new(:attribute_3 => "third", :attribute_4 => "fourth"),
+        )
+      end
+      
+      it "delegates properties to models" do
+        form.assign_attributes({ 
+          :attribute_1 => "changed", :attribute_2 => 182.34, 
+          :attribute_3 => 45, :attribute_4 => Date.new(2013, 10, 10) })
+ 
+        form.attribute_1.should eq("changed")
+        form.attribute_2.should eq(182.34)
+        form.attribute_3.should eq(45)
+        form.attribute_4.should eq(Date.new(2013, 10, 10))
+      end
+
+      it "ignores blank params when set" do
+        form.assign_attributes({ 
+          :attribute_1 => "", :attribute_2 => "", 
+          :attribute_3 => nil, :attribute_4 => nil })
+ 
+        form.attribute_1.should eq("")
+        form.attribute_2.should eq("second")
+        form.attribute_3.should eq("third")
+        form.attribute_4.should eq(nil)
+      end
+
+      it "handles individiual date components" do
+        #TODO: should pass with symbols too!!
+        form.assign_attributes({  
+          "attribute_1(3i)" => 5, 
+          "attribute_1(2i)" => 6, 
+          "attribute_1(1i)" => 2013 })
+ 
+        form.attribute_1.should eq(Date.new(2013, 6, 5))
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'freeform'
+require 'active_model'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: freeform
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -11,6 +11,22 @@ bindir: bin
 cert_chain: []
 date: 2013-11-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -67,13 +83,25 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .project
+- .rspec
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - freeform.gemspec
 - lib/freeform.rb
+- lib/freeform/form.rb
+- lib/freeform/form/form_input_key.rb
+- lib/freeform/form/nested.rb
+- lib/freeform/form/persistence.rb
+- lib/freeform/form/property.rb
 - lib/freeform/version.rb
+- spec/form/form_input_key_spec.rb
+- spec/form/nested_spec.rb
+- spec/form/persistence_spec.rb
+- spec/form/property_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/brycesenz/freeform
 licenses:
 - MIT
@@ -100,4 +128,9 @@ signing_key:
 specification_version: 3
 summary: FreeForm lets you compose forms however you like, explicitly guiding how
   each field maps back to your domain models.  No more accepting nested attributes!
-test_files: []
+test_files:
+- spec/form/form_input_key_spec.rb
+- spec/form/nested_spec.rb
+- spec/form/persistence_spec.rb
+- spec/form/property_spec.rb
+- spec/spec_helper.rb