active_form 0.0.1

data/test/fixtures/book.rb

@@ -0,0 +1,14 @@
+class Book < ActiveRecord::Base
+  
+  validates_presence_of :title, :isbn
+  validates_format_of :isbn, :with => /(\d[- ]?){9,9}([0-9xX])/
+  
+  has_and_belongs_to_many :authors
+  belongs_to :publisher
+
+  belongs_to :categorization
+  has_many :categories, :through => :categorizations  
+  
+  acts_as_dropdown
+      
+end

data/test/fixtures/books.yml

@@ -0,0 +1,8 @@
+awdr:
+  id: 1
+  title: Agile Web Development with Rails
+  isbn: 0-9766940-0-X
+  publication_date: 2005-08-01
+  publisher_id: 1
+  created_at: <%= 5.minutes.ago.to_s :db %>
+  updated_at: <%= 5.minutes.ago.to_s :db %>

data/test/fixtures/categorization.rb

@@ -0,0 +1,2 @@
+class Categorization < ActiveRecord::Base
+end

data/test/fixtures/category.rb

@@ -0,0 +1,8 @@
+class Category < ActiveRecord::Base
+  
+  belongs_to :categorization
+  has_many :books, :through => :categorization
+  
+  acts_as_dropdown
+    
+end

data/test/fixtures/publisher.rb

@@ -0,0 +1,5 @@
+class Publisher < ActiveRecord::Base
+  
+    acts_as_dropdown
+  
+end

data/test/fixtures/publishers.yml

@@ -0,0 +1,10 @@
+pragprog:
+  id: 1
+  name: The Pragmatic Programmers
+  created_at: <%= 5.minutes.ago.to_s :db %>
+  updated_at: <%= 5.minutes.ago.to_s :db %>
+oreilly:
+  id: 2
+  name: O'Reilly
+  created_at: <%= 5.minutes.ago.to_s :db %>
+  updated_at: <%= 5.minutes.ago.to_s :db %>

data/test/fixtures/schema.rb

@@ -0,0 +1,43 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table "authors", :force => true do |t|
+    t.column "first_name", :string
+    t.column "last_name", :string
+    t.column "birth_date", :date
+    t.column "created_at", :datetime
+    t.column "updated_at", :datetime
+  end
+
+  create_table "authors_books", :force => true do |t|
+    t.column "author_id", :integer
+    t.column "book_id", :integer
+  end
+
+  create_table "books", :force => true do |t|
+    t.column "title", :string
+    t.column "isbn", :string
+    t.column "publication_date", :date
+    t.column "publisher_id", :integer, :default => 1
+    t.column "created_at", :datetime
+    t.column "updated_at", :datetime
+  end
+
+  create_table "categories", :force => true do |t|
+    t.column "name", :string, :limit => 64
+    t.column "description", :string
+  end
+
+  create_table "categorizations", :force => true do |t|
+    t.column "category_id", :integer
+    t.column "book_id", :integer
+    t.column "created_at", :datetime
+    t.column "updated_at", :datetime
+  end
+
+  create_table "publishers", :force => true do |t|
+    t.column "name", :string
+    t.column "created_at", :datetime
+    t.column "updated_at", :datetime
+  end
+
+end

data/test/rails/test_model_autodefinition.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+class TestModelAutoDefinition < Test::Unit::TestCase
+  
+  fixtures :authors, :books, :categories, :categorizations, :publishers
+  
+  def test_model_instance_attribute
+    book = books(:awdr)
+    form = ActiveForm::Model::build(book)
+    assert form.respond_to?(:model_instance)
+    assert form.respond_to?(:model_instance=)
+    assert_equal book, form.model_instance
+  end
+  
+  def test_form_name_from_model
+    form = ActiveForm::Model::build(Book.new)
+    assert_equal :book_form, form.name 
+  end
+  
+  def test_form_name_from_args
+    form = ActiveForm::Model::build(Book.new, :myform)
+    assert_equal :myform, form.name 
+  end
+  
+  def test_new_record_values
+    form = ActiveForm::Model::build(Book.new)
+    assert_equal '', form[:title].export_value
+    assert_equal '', form[:isbn].export_value
+    assert_kind_of Date, form[:publication_date].export_value
+    assert_equal 1, form[:publisher_id].export_value
+    assert_kind_of Time, form[:created_at].export_value
+    assert_kind_of Time, form[:updated_at].export_value
+  end
+  
+  def test_date_defaults_to_now
+    form = ActiveForm::Model::build(Book.new)
+    now_date = Date.today.to_s
+    assert_equal now_date, form[:publication_date].export_value.to_s
+  end
+  
+  def test_time_defaults_to_now
+    form = ActiveForm::Model::build(Book.new)
+    now_time = Time.now.to_s.gsub(/(\d\d:\d\d):(\d\d)/, '\1:00')
+    assert_equal now_time, form[:created_at].export_value.to_s
+    assert_equal now_time, form[:updated_at].export_value.to_s
+  end
+  
+  def test_override_time_defaults
+    current_time = Time.local(2004, 1, 1, 13, 15, 5)
+    current_time_string = current_time.to_s.gsub(/(\d\d:\d\d):(\d\d)/, '\1:00')
+    assert_equal "Thu Jan 01 13:15:00 +0100 2004", current_time_string
+    book = Book.new(:created_at => current_time)
+    form = ActiveForm::Model::build(book)
+    assert_equal current_time_string, form[:created_at].export_value.to_s
+  end
+  
+  def test_difference_between_two_build_methods
+    form = ActiveForm::Model::build(Book.new)
+    assert_equal [:id, :title, :isbn, :publication_date, :publisher_id, :created_at, :updated_at], form.collect(&:name)
+    form = ActiveForm::Model::build!(Book.new)
+    assert_equal [:id, :title, :isbn, :publication_date, :publisher_id, :created_at, :updated_at, :submit], form.collect(&:name)
+  end
+  
+  def test_form_elements_for_new_book
+    form = ActiveForm::Model::build(Book.new)
+    assert_kind_of ActiveForm::Definition, form
+    form.submit_element
+    assert_equal [:id, :title, :isbn, :publication_date, :publisher_id, :created_at, :updated_at, :submit], form.collect(&:name)
+    assert_equal ["Id", "Title", "Isbn", "Publication date", "Publisher", "Created at", "Updated at", "Submit"], form.collect(&:label)
+    assert_equal [:hidden, :text, :text, :select_date, :select_from_model, :select_datetime, :select_datetime, :submit], form.collect(&:element_type)
+    assert_equal [:integer, :string, :string, :date, :integer, :time, :time, nil], form.collect(&:type_cast)
+  end
+  
+  def test_form_elements_for_new_author
+    form = ActiveForm::Model::build(Author.new)
+    form.submit_element
+    assert_equal [:id, :first_name, :last_name, :birth_date, :created_at, :updated_at, :submit], form.collect(&:name)
+    assert_equal ["Id", "First name", "Last name", "Birth date", "Created at", "Updated at", "Submit"], form.collect(&:label)
+    assert_equal [:hidden, :text, :text, :select_date, :select_datetime, :select_datetime, :submit], form.collect(&:element_type)
+    assert_equal [:integer, :string, :string, :date, :time, :time, nil], form.collect(&:type_cast)
+  end
+  
+  def test_form_elements_for_book
+    form = ActiveForm::Model::build(books(:awdr))
+    assert_equal 1, form[:id].export_value
+    assert_equal 'Agile Web Development with Rails', form[:title].export_value
+    assert_equal '0-9766940-0-X', form[:isbn].export_value
+    assert_equal '2005-08-01', form[:publication_date].export_value.to_s
+    assert_equal 1, form[:publisher_id].export_value
+  end
+  
+  def test_validate_form_with_ar_validations
+    form = ActiveForm::Model::build(Book.new)
+    assert !form.validate
+    assert_equal ["ar_blank", "ar_blank", "ar_invalid"], form.all_errors.collect(&:code)
+    assert_equal ["Title: can't be blank", "Isbn: can't be blank", "Isbn: is invalid"], form.all_errors.collect(&:message)
+    assert_equal ["Title: can't be blank", "Isbn: can't be blank"], form.initial_errors.collect(&:message)
+    assert_equal 1, form[:title].errors.length
+    assert_equal 2, form[:isbn].errors.length
+  end
+  
+  def test_localization_of_ar_error_messages
+    translations = { 
+      'book_form_title_label' => 'Titel',
+      'book_form_title_validates_ar_blank' => 'Geef een titel op',
+      'book_form_isbn_label' => 'ISBN nummer',   
+      'book_form_isbn_validates_ar_blank' => 'Geef het ISBN nummer',
+      'book_form_isbn_validates_ar_invalid' => 'Onjuist ISBN nummer formaat'
+    }
+    form = ActiveForm::Model::build(Book.new)
+    form.define_localizer { |formname, elemname, key| translations[ [formname, elemname, key].compact.join('_') ] }  
+    assert !form.validate
+    expected = ["Geef een titel op", "Geef het ISBN nummer", "Onjuist ISBN nummer formaat"]
+    assert_equal expected, form.all_errors.collect(&:message)
+  end
+  
+  def test_aggregations
+    
+  end
+    
+end

data/test/rails/test_model_loader.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+class TestModelLoader < Test::Unit::TestCase
+  
+  fixtures :authors, :books, :categories, :categorizations, :publishers
+  
+  def setup
+    ActiveForm::Definition.load_paths << File.join(File.dirname(__FILE__), '..', 'resources', 'models')
+  end
+  
+  def test_load_model_form
+    form = ActiveForm::Model::load!(Book.new)
+    assert_kind_of ActiveForm::BookForm, form
+    assert_equal [:id, :title, :isbn, :publication_date, :publisher_id, :submit], form.collect(&:name)
+    assert_equal [:integer, :string, :string, :date, :integer, nil], form.collect(&:type_cast)
+    assert_equal [:day, :month, :year], form[:publication_date].collect(&:name)
+    assert_equal "", form[:title].value
+    assert_equal 1, form[:publisher_id].value    
+  end
+  
+  def test_load_model_for_record
+    form = ActiveForm::Model::load(books(:awdr))
+    assert_kind_of ActiveForm::BookForm, form
+    assert_equal 1, form[:id].export_value
+    assert_equal 'Agile Web Development with Rails', form[:title].export_value
+    assert_equal '0-9766940-0-X', form[:isbn].export_value
+    assert_equal '2005-08-01', form[:publication_date].export_value.to_s
+    assert_equal 1, form[:publisher_id].export_value
+  end
+  
+  def test_load_specific_form
+    form = ActiveForm::Model::load(:register, publishers(:pragprog))
+    assert_kind_of ActiveForm::RegisterPublisherForm, form
+    assert_equal [:id, :name], form.collect(&:name)
+    assert_equal 1, form[:id].export_value
+    assert_equal 'The Pragmatic Programmers', form[:name].export_value
+  end
+  
+  def test_difference_between_two_load_methods
+    form = ActiveForm::Model::load(publishers(:pragprog))
+    assert_equal [:id, :name, :created_at, :updated_at], form.collect(&:name)     
+    form = ActiveForm::Model::load!(publishers(:pragprog))
+    assert_equal [:id, :name, :created_at, :updated_at, :submit], form.collect(&:name) 
+  end
+  
+  def test_validate_form_with_ar_validations
+    form = ActiveForm::Model::load(Book.new)
+    assert_kind_of ActiveForm::BookForm, form
+    assert !form.validate
+    assert_equal ["ar_blank", "ar_blank", "ar_invalid"], form.all_errors.collect(&:code)
+    assert_equal ["Title: can't be blank", "Isbn: can't be blank", "Isbn: is invalid"], form.all_errors.collect(&:message)
+    assert_equal ["Title: can't be blank", "Isbn: can't be blank"], form.initial_errors.collect(&:message)
+    assert_equal 1, form[:title].errors.length
+    assert_equal 2, form[:isbn].errors.length
+  end
+  
+  def teardown
+    ActiveForm::Definition.load_paths.clear
+  end
+  
+end

data/test/resources/elements/chunky.rb

@@ -0,0 +1,11 @@
+ActiveForm::Element::Base::create :chunky do
+  
+  def render_element(builder = create_builder)
+    builder.h1('Chunky Bacon!', element_attributes)
+  end
+  
+  def default_attributes
+    { :id => identifier, :class => css  }
+  end
+  
+end

data/test/resources/forms/demo.rb

@@ -0,0 +1,5 @@
+ActiveForm::Definition::create :demo do |f|
+  f.text_element :firstname
+  f.text_element :lastname
+  f.submit_element             
+end

data/test/resources/models/book.rb

@@ -0,0 +1,8 @@
+ActiveForm::Definition::create :book do |f|
+  
+  f.text_element :title
+  f.text_element :isbn
+  f.select_date_element :publication_date, :format => [:day, :month, :year], :range => (2005..2010)
+  f.select_from_model_element :publisher_id        
+
+end

data/test/resources/models/register_publisher.rb

@@ -0,0 +1,5 @@
+ActiveForm::Definition::create :register_publisher do |f|
+  
+  f.text_element :name     
+
+end

data/test/resources/sections/demo.rb

@@ -0,0 +1,6 @@
+ActiveForm::Element::Section::create :demo do |s|       
+  
+  s.text_element :firstname
+  s.text_element :lastname     
+
+end

data/test/resources/sections/foo.rb

@@ -0,0 +1,6 @@
+ActiveForm::Element::Section::create :foo do |s|       
+  
+  s.text_element :title
+  s.textarea_element :body        
+
+end

data/test/resources/validators/foo.rb

@@ -0,0 +1,9 @@
+ActiveForm::Validator::Base.create :foo do
+  
+  default_message "%s: should be foo-matic!"
+  
+  def validate
+    element.errors << advice[code] unless value =~ /^(foo|bar|baz|qux)+$/
+  end
+  
+end

data/test/resources/widgets/custom.rb

@@ -0,0 +1,13 @@
+ActiveForm::Widget::create :custom do |w|       
+  
+  w.text_element :firstname,  :title => 'First Name'
+  w.text_element :lastname,   :title => 'Last Name'    
+
+  def w.render_element(builder = create_builder)
+    builder.table {
+      builder.tr { builder.td { label_for_firstname(builder) }; builder.td { label_for_lastname(builder) } }
+      builder.tr { builder.td { html_for_firstname(builder)  }; builder.td { html_for_lastname(builder)  } }
+    }
+  end
+
+end

data/test/test_active_form.rb

@@ -0,0 +1,1050 @@
+require 'test_helper'
+
+class TestActiveForm < Test::Unit::TestCase
+
+  def test_common_stub_instance_methods
+    assert ActiveForm::Definition.instance_methods.include?('to_html')
+    assert ActiveForm::Element::Base.instance_methods.include?('to_html')   
+    assert ActiveForm::Element::Section.instance_methods.include?('to_html')  
+  end
+  
+  def test_element_module_loading
+    assert ActiveForm::Element::load(:text)
+    assert ActiveForm::Element::load(:section)
+    assert_raises(ActiveForm::Element::NotFoundException) do
+      ActiveForm::Element::load(:unknown)
+    end 
+    assert ActiveForm::Element::loaded?(:text)
+    assert ActiveForm::Element::loaded?(:section)
+    assert !ActiveForm::Element::loaded?(:unknown)
+  end
+  
+  def test_element_module_create
+    assert_kind_of ActiveForm::Element::Text, ActiveForm::Element::build(:text, :test_element)
+    assert_kind_of ActiveForm::Element::Section, ActiveForm::Element::build(:section, :test_element)
+    assert_nil ActiveForm::Element::build(:unknown, :test_element)
+  end
+  
+  def test_element_module_type_existence
+    assert ActiveForm::Element::exists?(:text)
+    assert ActiveForm::Element::exists?(:section)
+    assert !ActiveForm::Element::exists?(:unknown)
+  end
+  
+  def test_is_element_by_module
+    assert ActiveForm::Element::element?(ActiveForm::Element::Text)
+    assert ActiveForm::Element::element?(ActiveForm::Element::Section)
+    assert ActiveForm::Element::element?(ActiveForm::Definition)
+    assert !ActiveForm::Element::element?(ActiveForm)
+  end
+  
+  def test_is_element_by_class
+    assert ActiveForm::Definition.element?
+    assert ActiveForm::compose(:form).element?
+    assert ActiveForm::Element::Base.element?
+    assert ActiveForm::Element::Base.new(:element).element?
+    assert ActiveForm::Element::Section.element?
+    assert ActiveForm::Element::Section.new(:section).element?
+  end
+  
+  def test_is_container
+    assert ActiveForm::Definition.container?
+    assert ActiveForm::compose(:test_form).container?
+    assert !ActiveForm::Element::Base.container?
+    assert !ActiveForm::Element::Base.new(:test_element).container?
+    assert ActiveForm::Element::Section.container?
+    assert ActiveForm::Element::Section.new(:test_group).container?
+  end
+  
+  def test_element_name
+    form = ActiveForm::compose :test_form
+    assert_equal :test_form, form.name
+    section = ActiveForm::Element::Section.new :test_group
+    assert_equal :test_group, section.name
+    elem = ActiveForm::Element::Base.new :test_element
+    assert_equal :test_element, elem.name    
+  end
+  
+  def test_element_type
+    form = ActiveForm::compose :test_form
+    assert_equal :form, form.element_type
+    section = ActiveForm::Element::Section.new :test_group
+    assert_equal :section, section.element_type
+    elem = ActiveForm::Element::Base.new :test_element
+    assert_equal :base, elem.element_type 
+    elem = ActiveForm::Element::Text.new :test_element
+    assert_equal :text, elem.element_type
+  end
+  
+  def test_container_reference
+    form = ActiveForm::compose :test_form
+    assert_equal nil, form.container
+    assert !form.contained?
+    elem = ActiveForm::Element::Base.new form, :element
+    assert_equal form, elem.container
+    assert elem.contained?
+    section = ActiveForm::Element::Section.new form, :element
+    assert_equal form, section.container
+    assert section.contained?
+  end
+  
+  def test_standalone_identifier
+    form = ActiveForm::compose :test_form
+    assert_equal "test_form", form.identifier
+    section = ActiveForm::Element::Section.new :test_section
+    assert_equal "test_section", section.identifier
+    elem = ActiveForm::Element::Base.new :test_element
+    assert_equal "test_element", elem.identifier    
+  end
+  
+  def test_nested_identifier
+    form = ActiveForm::compose :form
+    assert_equal "form", form.identifier
+    section = ActiveForm::Element::Section.new(form, :section)
+    assert_equal "form_section", section.identifier
+    elem = ActiveForm::Element::Base.new(form, :element)
+    assert_equal "form_element", elem.identifier   
+  end
+  
+  def test_nested_section_identifier
+    form = ActiveForm::compose :form
+    assert_equal "form", form.identifier
+    section = ActiveForm::Element::Section.new(form, :section_a)
+    assert_equal "form_section_a", section.identifier
+    elem_a = ActiveForm::Element::Base.new(section, :element_a)
+    assert_equal "form_section_a_element_a", elem_a.identifier
+    elem_b = ActiveForm::Element::Base.new(section, :element_b)
+    assert_equal "form_section_a_element_b", elem_b.identifier
+  end
+  
+  def test_nested_definition_identifier
+    form_a = ActiveForm::compose :form_a
+    assert_equal "form_a", form_a.identifier
+    form_b = ActiveForm::compose form_a, :form_b
+    assert_equal "form_a_form_b", form_b.identifier
+    form_c = ActiveForm::compose form_b, :form_c
+    assert_equal "form_a_form_b_form_c", form_c.identifier
+    elem = ActiveForm::Element::Base.new(form_c, :element)
+    assert_equal "form_a_form_b_form_c_element", elem.identifier
+  end
+  
+  def test_nested_section_identifier
+    form = ActiveForm::compose :form
+    assert_equal "form", form.identifier
+    section_a = ActiveForm::Element::Section.new(form, :section_a)
+    assert_equal "form_section_a", section_a.identifier
+    section_b = ActiveForm::Element::Section.new(section_a, :section_b)
+    assert_equal "form_section_a_section_b", section_b.identifier
+    section_c = ActiveForm::Element::Section.new(section_b, :section_c)
+    assert_equal "form_section_a_section_b_section_c", section_c.identifier
+    elem = ActiveForm::Element::Base.new(section_c, :element)
+    assert_equal "form_section_a_section_b_section_c_element", elem.identifier
+  end
+  
+  def test_nested_section_name
+    form = ActiveForm::compose :form
+    assert_equal "form", form.element_name
+    section = ActiveForm::Element::Section.new(form, :section_a)
+    assert_equal "form[section_a]", section.element_name
+    elem_a = ActiveForm::Element::Base.new(section, :element_a)
+    assert_equal "form[section_a][element_a]", elem_a.element_name
+    elem_b = ActiveForm::Element::Base.new(section, :element_b)
+    assert_equal "form[section_a][element_b]", elem_b.element_name
+  end
+  
+  def test_nested_definition_name
+    form_a = ActiveForm::compose :form_a
+    assert_equal "form_a", form_a.element_name
+    form_b = ActiveForm::compose form_a, :form_b
+    assert_equal "form_a[form_b]", form_b.element_name
+    form_c = ActiveForm::compose form_b, :form_c
+    assert_equal "form_a[form_b][form_c]", form_c.element_name
+    elem = ActiveForm::Element::Base.new(form_c, :element)
+    assert_equal "form_a[form_b][form_c][element]", elem.element_name
+  end
+  
+  def test_nested_section_name
+    form = ActiveForm::compose :form
+    assert_equal "form", form.element_name
+    section_a = ActiveForm::Element::Section.new(form, :section_a)
+    assert_equal "form[section_a]", section_a.element_name
+    section_b = ActiveForm::Element::Section.new(section_a, :section_b)
+    assert_equal "form[section_a][section_b]", section_b.element_name
+    section_c = ActiveForm::Element::Section.new(section_b, :section_c)
+    assert_equal "form[section_a][section_b][section_c]", section_c.element_name
+    elem = ActiveForm::Element::Base.new(section_c, :element)
+    assert_equal "form[section_a][section_b][section_c][element]", elem.element_name
+  end
+  
+  def test_default_element_label
+    form = ActiveForm::compose :form do |f|
+      f.text_element :element_a
+      f.text_element :element_b, :label => 'B-label'
+      f.text_element :element_c
+      f.section :section_a do |s|
+        s.text_element :element_d
+        s.text_element :element_e
+      end
+    end
+    assert_equal 'Element A', form[:element_a].label
+    assert_equal 'B-label', form[:element_b].label
+    assert_equal 'Element D', form[:section_a][:element_d].label
+    assert_equal 'form[section_a][element_d]', form[:section_a][:element_d].element_name
+  end
+  
+  def test_set_elements
+    elem_a = ActiveForm::Element::build(:text, :element_a)
+    elem_b = ActiveForm::Element::build(:text, :element_b)
+    elem_c = ActiveForm::Element::build(:text, :element_c)
+    form = ActiveForm::compose :form
+    form.elements = [elem_a, elem_b, elem_c]
+    assert_equal [:element_a, :element_b, :element_c], form.element_names
+  end
+  
+  def test_insert_one_loose_element
+    form = ActiveForm::compose :form
+    elem_a = ActiveForm::Element::build(:text, :element_a)
+    assert form.insert_element(elem_a)
+    elem_b = ActiveForm::Element::build(:text, :element_b)
+    assert form.insert_element(elem_b)
+    assert_equal [:element_a, :element_b], form.element_names
+    elem_c = ActiveForm::Element::build(:text, :element_c)
+    elem_d = ActiveForm::Element::build(:text, :element_d)
+    assert form << elem_c << elem_d
+    assert_equal [:element_a, :element_b, :element_c, :element_d], form.element_names
+  end
+  
+  def test_insert_multiple_loose_elements
+    elem_a = ActiveForm::Element::build(:text, :element_a)
+    elem_b = ActiveForm::Element::build(:text, :element_b)
+    elem_c = ActiveForm::Element::build(:text, :element_c)
+    form = ActiveForm::compose :form
+    form.insert_elements(elem_a, elem_b, elem_c)    
+    assert_equal [:element_a, :element_b, :element_c], form.element_names
+    form = ActiveForm::compose :form
+    form.insert_elements([elem_a, elem_b, elem_c])    
+    assert_equal [:element_a, :element_b, :element_c], form.element_names
+  end
+  
+  def test_insert_one_element_at
+    elem_a = ActiveForm::Element::build(:text, :element_a)
+    elem_b = ActiveForm::Element::build(:text, :element_b)
+    elem_c = ActiveForm::Element::build(:text, :element_c)
+    elem_d = ActiveForm::Element::build(:text, :element_d)
+    form = ActiveForm::compose :form
+    form.insert_element(elem_a, 0)
+    form.insert_element(elem_b, 0)
+    form.insert_element(elem_c, 0)
+    assert_equal [:element_c, :element_b, :element_a], form.element_names
+    form = ActiveForm::compose :form
+    form.insert_element(elem_a)
+    form.insert_element(elem_b)
+    form.insert_element(elem_c, 0)
+    assert_equal [:element_c, :element_a, :element_b], form.element_names
+    form.insert_element(elem_d, 2)
+    assert_equal [:element_c, :element_a, :element_d, :element_b], form.element_names
+  end
+  
+  def test_insert_multiple_elements_at
+    elem_a = ActiveForm::Element::build(:text, :element_a)
+    elem_b = ActiveForm::Element::build(:text, :element_b)
+    elem_c = ActiveForm::Element::build(:text, :element_c)
+    elem_d = ActiveForm::Element::build(:text, :element_d)
+    form = ActiveForm::compose :form
+    form.insert_elements(elem_a, elem_b)
+    form.insert_elements(elem_c, elem_d, 1)
+    assert_equal [:element_a, :element_c, :element_d, :element_b], form.element_names
+  end
+  
+  # define element methods:
+  
+  def test_define_element
+    form = ActiveForm::compose :form
+    assert form.define_element(:text, :element_a)
+    assert_equal 1, form.elements.length
+    assert_equal :element_a, form.elements.last.name
+    assert form.element_names.include?(:element_a)
+    assert form.define_element(:text, :element_b)
+    assert_equal 2, form.elements.length
+    assert_equal :element_b, form.elements.last.name
+    assert form.element_names.include?(:element_b)    
+  end
+  
+  def test_define_element_at
+    form = ActiveForm::compose :form
+    assert form.define_element_at(0, :text, :element_a)
+    assert form.define_element_at(0, :text, :element_b)
+    assert form.define_element_at(1, :text, :element_c)
+    assert form.define_element_at(2, :text, :element_d)
+    assert_equal [:element_b, :element_c, :element_d, :element_a], form.element_names
+  end
+  
+  def test_define_element_at_top
+    form = ActiveForm::compose :form
+    assert form.define_element_at_top(:text, :element_a)
+    assert form.define_element_at_top(:text, :element_b)
+    assert form.define_element_at_top(:text, :element_c)
+    assert_equal [:element_c, :element_b, :element_a], form.element_names
+  end
+  
+  def test_define_element_at_bottom
+    form = ActiveForm::compose :form
+    assert form.define_element_at_bottom(:text, :element_a)
+    assert form.define_element_at_bottom(:text, :element_b)
+    assert form.define_element_at_bottom(:text, :element_c)
+    assert_equal [:element_a, :element_b, :element_c], form.element_names
+  end
+  
+  def test_define_element_using_syntactic_sugar
+    form = ActiveForm::compose :form
+    form.text_element     :element_a, :label => 'a text element'
+    form.hidden_element   :element_b, :label => 'a hidden element'
+    form.password_element :element_c, :label => 'a password element'
+    assert_equal [:element_a, :element_b, :element_c], form.elements.collect(&:name)
+    assert_equal [:text, :hidden, :password], form.elements.collect(&:element_type)
+    assert_equal ['a text element', 'a hidden element', 'a password element'], form.elements.collect(&:label)
+  end
+  
+  def test_define_element_initialize_with_options_and_attributes
+    form = ActiveForm::compose :form
+    form.text_element :element_a, :label => 'test label', :css_style => 'color: red', :css_class => 'special'
+    assert_equal 'test label', form.elements.first.label
+    assert_equal 'color: red', form.elements.first.css_style.to_s
+    assert_equal 'special', form.elements.first.css_class.to_s
+  end  
+  
+  def test_define_element_with_block
+   form = ActiveForm::compose :form
+    form.define_element :text, :element_a do |e|
+      e.css_class << 'special'
+      e.css_style = 'color: red'
+    end
+    expected = { "type" => "text", "name"=>"form[element_a]", "class"=>"elem_text special", "id"=>"form_element_a", "style"=>"color: red", "value"=>"", "size"=>30 }
+    assert_equal expected, form[:element_a].element_attributes
+  end
+  
+  def test_update_attributes_and_options_on_sample_element
+    form = ActiveForm::compose :form
+    elem = form.extended_sample_element :element_a, :label => 'test label', :css_style => 'color: red', :css_class => 'special', :flipped => true
+    assert elem.flipped?
+    assert_equal 'test label', form.elements.first.label
+    assert_equal 'special', form.elements.first.css_class.to_s
+    elem.update :label => 'changed label', :css_class => 'other', :flipped => false, :flopped => true
+    assert !elem.flipped?
+    assert elem.flopped?
+    assert_equal 'changed label', form.elements.first.label
+    assert_equal 'other', form.elements.first.css_class.to_s
+  end
+  
+  def test_update_attributes_and_options_on_text_element
+    form = ActiveForm::compose :form
+    elem = form.text_element :element_a, :label => 'test label', :css_style => 'color: red', :css_class => 'special'
+    assert_equal 'test label', form.elements.first.label
+    assert_equal 'special', form.elements.first.css_class.to_s
+    elem.update :label => 'changed label', :css_class => 'other'
+    assert_equal 'changed label', form.elements.first.label
+    assert_equal 'other', form.elements.first.css_class.to_s
+  end
+  
+  def test_update_all_elements
+    form = ActiveForm::compose :form do |f|
+      f.text_element :element_a, :label => 'one',   :description => 'this is the first'
+      f.text_element :element_b, :label => 'two',   :description => 'this is the second'
+      f.text_element :element_c, :label => 'three', :description => 'this is the third'
+    end
+    assert_equal ['one', 'two', 'three'], form.elements.collect(&:label)
+    assert_equal ['this is the first', 'this is the second', 'this is the third'], form.elements.collect(&:description)
+    form.update_elements(:description => nil)
+    assert_equal [nil, nil, nil], form.elements.collect(&:description)
+    form.update_elements(:label => 'new', :css_class => 'marked')
+    assert_equal ['new', 'new', 'new'], form.elements.collect(&:label)
+    assert_equal ['marked', 'marked', 'marked'], form.elements.collect { |e| e.css_class.to_s }
+  end
+  
+  def test_update_some_elements
+    form = ActiveForm::compose :form do |f|
+      f.text_element :element_a, :label => 'one'
+      f.text_element :element_b, :label => 'two'  
+      f.text_element :element_c, :label => 'three'
+    end
+    assert_equal ['one', 'two', 'three'], form.elements.collect(&:label)
+    form.update_elements(:element_a, :element_c, :label => 'new')
+    assert_equal ['new', 'two', 'new'], form.elements.collect(&:label)
+    form.update_elements(:element_b, :element_c, :css_class => 'marked')
+    assert_equal ['elem_text', 'marked', 'marked'], form.elements.collect { |e| e.css_class.to_s }
+  end
+  
+  def test_index_of_element
+    form = ActiveForm::compose :form
+    form.define_element(:text, :element_a)
+    form.define_element(:text, :element_b)
+    form.define_element(:text, :element_c)
+    assert_equal 0, form.index_of_element(:element_a)
+    assert_equal 1, form.index_of_element(:element_b)
+    assert_equal 2, form.index_of_element(:element_c)
+  end
+  
+  def test_get_element_by_index
+    form = ActiveForm::compose :form
+    elem_a = form.define_element(:text, :element_a)
+    elem_b = form.define_element(:text, :element_b)
+    elem_c = form.define_element(:text, :element_c)
+    assert_equal elem_a, form.get_element_by_index(0)
+    assert_equal elem_b, form.get_element_by_index(1)
+    assert_equal elem_c, form.get_element_by_index(2)
+  end
+  
+  def test_if_container_element_exists
+    form = ActiveForm::compose :form
+    form.define_element(:text, :element_a)
+    form.define_element(:text, :element_b)
+    assert form.element_exists?(:element_a)
+    assert form.element_exists?(:element_b)
+    assert !form.element_exists?(:unknown)
+  end
+  
+  def test_reset_elements
+    form = ActiveForm::compose :form
+    form.define_element(:text, :element_a)
+    form.define_element(:text, :element_b)
+    assert_equal [:element_a, :element_b], form.element_names
+    assert_equal 2, form.elements.length
+    assert_equal 2, form.name_to_index_lookup.length
+    form.reset_elements!
+    assert_equal [], form.element_names
+    assert_equal 0, form.elements.length
+    assert_equal 0, form.name_to_index_lookup.length
+  end
+  
+  def test_name_to_index_lookup_assignment_fails
+    form = ActiveForm::compose :form
+    assert_raises(NoMethodError) { form.name_to_index_lookup = Hash.new }
+  end
+  
+  def test_container_set_and_replace_element
+    form = ActiveForm::compose :form
+    elem_a = form.define_element(:text, :element_a)
+    elem_b = form.define_element(:text, :element_b)
+    assert_equal [elem_a, elem_b], form.elements
+    good_replacement = ActiveForm::Element::build(:section, :element_b)
+    assert form.set_element(:element_b, good_replacement)
+    assert_equal [elem_a, good_replacement], form.elements
+    new_replacement = ActiveForm::Element::build(:text, :element_a)
+    form[:element_a] = new_replacement
+    assert_equal [new_replacement, good_replacement], form.elements 
+    bad_replacement = ActiveForm::Element::build(:section, :element_c)
+    assert_raises(ActiveForm::Element::MismatchException) { form.set_element(:element_b, bad_replacement) }  
+  end
+  
+  def test_container_get_element
+    form = ActiveForm::compose :form
+    elem_a = form.define_element(:text, :element_a)
+    elem_b = form.define_element(:text, :element_b)
+    elem_c = form.define_element(:text, :element_c)
+    assert_equal elem_a, form.get_element(:element_a)
+    assert_equal elem_b, form.get_element(:element_b)
+    assert_equal elem_c, form.get_element(:element_c)
+  end
+  
+  def test_container_get_element_with_hash_syntax
+    form = ActiveForm::compose :form
+    elem_a = form.define_element(:text, :element_a)
+    elem_b = form.define_element(:text, :element_b)
+    elem_c = form.define_element(:text, :element_c)
+    assert_equal elem_a, form[:element_a]
+    assert_equal elem_b, form[:element_b]
+    assert_equal elem_c, form[:element_c]
+  end
+  
+  def test_container_get_element_at
+    form = ActiveForm::compose :form
+    elem_a = form.define_element(:text, :element_a)
+    elem_b = form.define_element(:text, :element_b)
+    elem_c = form.define_element(:text, :element_c)
+    assert_equal elem_a, form.element_at(0)
+    assert_equal elem_b, form.element_at(1)
+    assert_equal elem_c, form.element_at(2)
+  end
+  
+  def test_container_remove_element
+    form = ActiveForm::compose :form do |f|
+      f.define_element(:text, :element_a)
+      f.define_element(:text, :element_b)
+      f.define_element(:text, :element_c)
+      f.define_element(:text, :element_d)
+    end
+    assert_equal [:element_a, :element_b, :element_c, :element_d], form.collect(&:name)
+    expected = {:element_a=>0, :element_c=>2, :element_b=>1, :element_d=>3}
+    assert_equal expected, form.name_to_index_lookup
+    assert form.remove_element(:element_b)
+    assert_equal [:element_a, :element_c, :element_d], form.collect(&:name)
+    expected = {:element_a=>0, :element_c=>1, :element_d=>2}
+    assert form.remove_elements(:element_a, :element_d)
+    assert_equal [:element_c], form.collect(&:name)
+    expected = {:element_c=>0}
+  end
+  
+  def test_container_remove_element_at
+    form = ActiveForm::compose :form do |f|
+      f.define_element(:text, :element_a)
+      f.define_element(:text, :element_b)
+      f.define_element(:text, :element_c)
+      f.define_element(:text, :element_d)
+    end
+    assert_equal [:element_a, :element_b, :element_c, :element_d], form.collect(&:name)
+    expected = {:element_a=>0, :element_c=>2, :element_b=>1, :element_d=>3}
+    assert_equal expected, form.name_to_index_lookup
+    assert form.remove_element_at(1)
+    assert_equal [:element_a, :element_c, :element_d], form.collect(&:name)
+    expected = {:element_a=>0, :element_c=>1, :element_d=>2}
+    assert form.remove_elements_at(0, 2)
+    assert_equal [:element_c], form.collect(&:name)
+    expected = {:element_c=>0}
+  end
+  
+  def test_container_remove_elements_of_type
+    form = ActiveForm::compose :form do |f|
+      f.define_element(:text, :element_a)
+      f.define_element(:password, :element_b)
+      f.define_element(:textarea, :element_c)
+      f.define_element(:submit, :element_d)
+    end
+    assert_equal [:element_a, :element_b, :element_c, :element_d], form.collect(&:name)
+    form.remove_elements_of_type(:text)
+    assert_equal [:element_b, :element_c, :element_d], form.collect(&:name)
+    form.remove_elements_of_type(:submit, :textarea)
+    assert_equal [:element_b], form.collect(&:name)
+  end
+  
+  # value handling
+    
+  def test_unbound_element_value
+    elem = ActiveForm::Element::build(:text, :elem_a) 
+    elem.element_value = 'one'
+    assert_equal 'one', elem.element_value    
+  end 
+  
+  def test_bound_element_value
+    form = ActiveForm::compose :form
+    elem = form.text_element :elem_a
+    expected = {"elem_a"=>nil}
+    assert_equal expected, form.values
+    elem.element_value = 'value'
+    expected = { "elem_a" => 'value' }
+    assert_equal expected, form.values
+    form.values[:elem_a] = 'changed'
+    assert_equal 'changed', elem.element_value
+  end
+    
+  def test_assign_values
+    values = { :elem_b => "two", :elem_a => "one" }
+    form = ActiveForm::compose :form, :values => values do |f|
+      f.text_element :elem_a
+      f.text_element :elem_b
+    end
+    assert_equal 'one', form[:elem_a].element_value
+    assert_equal 'two', form[:elem_b].element_value
+    
+    form[:elem_a].element_value = 'new'
+    assert_equal 'new', form[:elem_a].element_value
+    values[:elem_b] = 'other'
+    assert_equal 'other', form[:elem_b].element_value
+    form[:elem_b].element_value = 'changed'
+    assert_equal 'changed', values[:elem_b]
+  end
+  
+  # formatting and casting
+  
+  def test_define_formatting_filter
+    filter = lambda { |value| value.join(' ') }
+    elem = ActiveForm::Element::build :text, :elem_a, :formatting_filter => filter
+    assert_equal 'a b c', elem.formatting_filter(['a', 'b', 'c'])
+    elem = ActiveForm::Element::build :text, :elem_a do |e|
+      filter = e.define_formatting_filter { |value| value.join('-') }
+    end
+    assert_equal 'a-b-c', elem.formatting_filter(['a', 'b', 'c'])
+  end  
+  
+  def test_define_casting_filter
+    filter = lambda { |value| value.split(' ') }
+    elem = ActiveForm::Element::build :text, :elem_a, :casting_filter => filter
+    assert_equal ['a', 'b', 'c'], elem.casting_filter('a b c')
+    elem = ActiveForm::Element::build :text, :elem_a do |e|
+      filter = e.define_casting_filter { |value| value.split('-') }
+    end
+    assert_equal ['a', 'b', 'c'], elem.casting_filter('a-b-c')
+  end
+  
+  def test_internal_element_value
+    form = ActiveForm::compose :contact_form do |f|       
+      f.text_element :firstname, :value => %w{ F r e d } do |e|
+        e.define_formatting_filter { |value| value.join }
+        e.define_casting_filter { |value| value.split('') }
+      end
+      f.text_element :lastname, :value => 'flintstone' do |e|
+        e.define_formatting_filter { |value| value.upcase }
+        e.define_casting_filter { |value| value.downcase }
+      end
+    end
+    assert_equal ["F", "r", "e", "d"], form[:firstname].element_value
+    assert_equal 'Fred', form[:firstname].formatted_value
+    form[:firstname].value = 'Barney'
+    assert_equal ["B", "a", "r", "n", "e", "y"], form[:firstname].element_value
+    assert_equal 'Barney', form[:firstname].formatted_value
+    
+    assert_equal 'flintstone', form[:lastname].element_value
+    assert_equal 'FLINTSTONE', form[:lastname].formatted_value    
+    form[:lastname].value = 'RUBBLE'    
+    assert_equal 'rubble', form[:lastname].element_value
+    assert_equal 'RUBBLE', form[:lastname].formatted_value
+  end
+     
+  def test_nested_value_assignment 
+    values = ActiveForm::Values.new
+    values[:section_a] = {}
+    values[:section_a][:section_b] = {}
+    values[:section_a][:section_b][:section_c] = {}
+    values[:section_a][:section_b][:section_c][:element] = 'test value'
+    
+    form = ActiveForm::compose :form, :values => values do |f|
+      f.section :section_a do |ga|
+        ga.section :section_b do |gb|
+          gb.section :section_c do |gc|
+            elem = gc.text_element :element
+          end
+        end
+      end
+    end
+    
+    assert_equal :element, form[:section_a][:section_b][:section_c][:element].name
+    assert_equal :section_c, form[:section_a][:section_b][:section_c].name
+    assert_equal :section_b, form[:section_a][:section_b].name
+    assert_equal :section_a, form[:section_a].name
+    
+    assert_equal values[:section_a][:section_b][:section_c][:element], form[:section_a][:section_b][:section_c][:element].element_value
+    assert_equal values[:section_a][:section_b][:section_c], form[:section_a][:section_b][:section_c].element_value
+    assert_equal values[:section_a][:section_b], form[:section_a][:section_b].element_value
+    assert_equal values[:section_a], form[:section_a].element_value
+    assert_equal values, form.element_value
+    
+    assert_equal values[:section_a][:section_b][:section_c][:element], form[:section_a][:section_b][:section_c][:element].values
+    assert_equal values[:section_a][:section_b][:section_c], form[:section_a][:section_b][:section_c].values
+    assert_equal values[:section_a][:section_b], form[:section_a][:section_b].values
+    assert_equal values[:section_a], form[:section_a].values
+    assert_equal values, form.values
+    
+    values[:section_a][:section_b][:section_c][:element] = 'changed value'    
+    assert_equal 'changed value', form[:section_a][:section_b][:section_c][:element].element_value
+    expected = { "element" => "changed value" }
+    assert_equal expected, form[:section_a][:section_b][:section_c].element_value
+    
+    form[:section_a][:section_b][:section_c][:element].element_value = 'new value'   
+    assert_equal 'new value', form[:section_a][:section_b][:section_c][:element].element_value
+    assert_equal 'new value', values[:section_a][:section_b][:section_c][:element]
+    expected = { "element" => "new value" }
+    assert_equal expected, form[:section_a][:section_b][:section_c].element_value
+    
+    new_values = { "section_c" => { "element" => "other value" } }  
+    form[:section_a][:section_b].update_values(new_values)
+    assert_equal new_values, form[:section_a][:section_b].values    
+    assert_equal "other value", form[:section_a][:section_b][:section_c][:element].element_value    
+    
+    new_values = ActiveForm::Values.new
+    new_values[:section_a] = {}
+    new_values[:section_a][:section_b] = {}
+    new_values[:section_a][:section_b][:section_c] = {}
+    new_values[:section_a][:section_b][:section_c][:element] = 'updated value'
+    
+    form.update_values(new_values)    
+    assert_equal values[:section_a][:section_b][:section_c][:element], form[:section_a][:section_b][:section_c][:element].element_value
+        
+    form.update_values({}, true)  
+    assert_equal nil, form[:section_a][:section_b][:section_c][:element].element_value
+    expected = { "element" => nil }  
+    assert_equal expected, form[:section_a][:section_b][:section_c].element_value
+    expected = { "section_c"=> { "element" => nil } }
+    assert_equal expected , form[:section_a][:section_b].element_value
+    expected = { "section_b" => { "section_c"=> { "element" => nil } } }
+    assert_equal expected, form[:section_a].element_value 
+    expected = { "section_a" => { "section_b" => { "section_c"=> { "element" => nil } } } }
+    assert_equal expected, form.element_value
+    
+    new_values = { "section_c" => { "element" => "other value" } } 
+    form[:section_a][:section_b].update_values(new_values)  
+    assert_equal new_values, form[:section_a][:section_b].values    
+    assert_equal "other value", form[:section_a][:section_b][:section_c][:element].element_value  
+  end
+    
+  def test_more_nested_tests_one
+    
+    values = ActiveForm::Values.new
+    
+    form = ActiveForm::compose :form, :values => values do |f|
+      f.section :section_a do |ga|
+        ga.section :section_b do |gb|
+          gb.section :section_c do |gc|
+            gc.text_element :element do |e|
+              e.define_formatting_filter { |value| value.join }
+              e.define_casting_filter { |value| value.is_a?(Array) ? value : value.split('') }
+            end
+          end
+        end
+      end
+    end
+    
+    params = Hash.new
+    params[:form] = {}
+    params[:form][:section_a] = {}
+    params[:form][:section_a][:section_b] = {}
+    params[:form][:section_a][:section_b][:section_c] = {}
+    params[:form][:section_a][:section_b][:section_c][:element] = 'Fred'
+    
+    form[:section_a][:section_b][:section_c][:element].element_value = ["B", "a", "r", "n", "e", "y"] 
+    
+    assert_equal ["B", "a", "r", "n", "e", "y"], form[:section_a][:section_b][:section_c][:element].element_value    
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>["B", "a", "r", "n", "e", "y"]}}}}   
+    assert_equal expected, form.values 
+    
+    form.update_from_params(params)
+    
+    assert_equal ["F", "r", "e", "d"], form[:section_a][:section_b][:section_c][:element].element_value 
+    assert_equal 'Fred', form[:section_a][:section_b][:section_c][:element].formatted_value
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>["F", "r", "e", "d"]}}}}
+    assert_equal expected, form.values  
+           
+    form[:section_a][:section_b][:section_c][:element].element_value = ["B", "a", "r", "n", "e", "y"]
+    
+    assert_equal ["B", "a", "r", "n", "e", "y"], form[:section_a][:section_b][:section_c][:element].element_value 
+    assert_equal 'Barney', form[:section_a][:section_b][:section_c][:element].formatted_value
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>["B", "a", "r", "n", "e", "y"]}}}}
+    assert_equal expected, form.values
+    
+    params[:form][:section_a][:section_b][:section_c][:element] = 'Betty'    
+    form.update_from_params(params)
+    
+    assert_equal ["B", "e", "t", "t", "y"], form[:section_a][:section_b][:section_c][:element].element_value 
+    assert_equal 'Betty', form[:section_a][:section_b][:section_c][:element].formatted_value 
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>["B", "e", "t", "t", "y"]}}}}
+    assert_equal expected, form.values
+    
+    form[:section_a][:section_b][:section_c][:element].element_value = 'Wilma'
+    
+    assert_equal ["W", "i", "l", "m", "a"], form[:section_a][:section_b][:section_c][:element].element_value
+    assert_equal 'Wilma', form[:section_a][:section_b][:section_c][:element].formatted_value  
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>["W", "i", "l", "m", "a"]}}}}
+    assert_equal expected, form.values
+    
+    form[:section_a][:section_b][:section_c][:element].element_value =  ['P', 'e', 'b', 'b', 'l', 'e', 's']
+    
+    ref = form[:section_a][:section_b][:section_c][:element]
+    
+    assert_equal ['P', 'e', 'b', 'b', 'l', 'e', 's'], form[:section_a][:section_b][:section_c][:element].element_value
+    assert_equal 'Pebbles', form[:section_a][:section_b][:section_c][:element].formatted_value  
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>['P', 'e', 'b', 'b', 'l', 'e', 's']}}}}
+    assert_equal ['P', 'e', 'b', 'b', 'l', 'e', 's'], ref.element_value
+    assert_equal expected, form.values
+    
+    form.params = {"form"=>{"section_a"=>{"section_b"=>{"section_c"=>{"element"=>'Other'}}}}}
+    assert_equal 'Other', form[:section_a][:section_b][:section_c][:element].formatted_value
+    assert_equal ["O", "t", "h", "e", "r"], form[:section_a][:section_b][:section_c][:element].element_value
+    assert_equal ["O", "t", "h", "e", "r"], ref.element_value
+  end  
+  
+  def test_more_nested_tests
+    
+    values = ActiveForm::Values.new
+    
+    form = ActiveForm::compose :form, :values => values do |f|
+      f.section :section_a do |ga|
+        ga.section :section_b do |gb|
+          gb.section :section_c do |gc|
+            gc.text_element :element do |e|
+              e.define_formatting_filter { |value| value.to_s }
+              e.define_casting_filter { |value| value.to_i }
+            end
+          end
+        end
+      end
+    end
+    
+    params = Hash.new
+    params[:form] = {}
+    params[:form][:section_a] = {}
+    params[:form][:section_a][:section_b] = {}
+    params[:form][:section_a][:section_b][:section_c] = {}
+    params[:form][:section_a][:section_b][:section_c][:element] = '123'
+    
+    form[:section_a][:section_b][:section_c][:element].element_value = 456
+    
+    assert_equal 456, form[:section_a][:section_b][:section_c][:element].element_value 
+    assert_equal '456', form[:section_a][:section_b][:section_c][:element].formatted_value    
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>456}}}}   
+    assert_equal expected, form.values 
+    
+    form.update_from_params(params)
+    
+    assert_equal 123, form[:section_a][:section_b][:section_c][:element].element_value 
+    assert_equal '123', form[:section_a][:section_b][:section_c][:element].formatted_value 
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>123}}}}
+    assert_equal expected, form.values  
+          
+    form[:section_a][:section_b][:section_c][:element].element_value = '456'
+
+    expected = {"section_b"=>{"section_c"=>{"element"=>456}}}
+    assert_equal expected, form[:section_a].element_value
+        
+    assert_equal 456, form[:section_a][:section_b][:section_c][:element].element_value  
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>456}}}}
+    assert_equal expected, form.values
+    
+    params[:form][:section_a][:section_b][:section_c][:element] = '789'      
+    form.update_from_params(params)
+   
+    assert_equal 789, form[:section_a][:section_b][:section_c][:element].element_value  
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>789}}}}
+    assert_equal expected, form.values
+    
+    form[:section_a][:section_b][:section_c][:element].element_value = '007'
+    
+    assert_equal 7, form[:section_a][:section_b][:section_c][:element].element_value  
+    expected = {"section_a"=>{"section_b"=>{"section_c"=>{"element"=>7}}}}
+    assert_equal expected, form.values  
+  end
+  
+  def test_custom_value_object
+    obj = CustomValueObject.new  
+    form = ActiveForm::compose :form, :binding => obj do |f|
+      f.text_element :name
+      f.text_element :city
+    end
+    
+    obj.value['name'] = 'Fred Flintstone'
+    obj.value['city'] = 'Bedrock'
+    
+    assert_equal 'Fred Flintstone', form[:name].element_value
+    assert_equal 'Bedrock', form[:city].element_value
+    
+    form[:city].element_value = 'Yellowstone'    
+    assert_equal 'Yellowstone', form[:city].element_value
+    assert_equal 'Yellowstone', obj.value['city']
+    
+    form.params = { "form" => { "city" => "Bricktown" } }
+    assert_equal 'Bricktown', form[:city].element_value
+    assert_equal 'Bricktown', obj.value['city']    
+  end
+  
+  def test_custom_value_object_binding
+    form = ActiveForm::compose :form do |f|
+      f.text_element :name
+      f.text_element :city
+    end
+  
+    obj = form.bind_to(CustomValueObject.new)   
+    form.params = { "form" => { "name" => "Fred Flintstone", "city" => "Bricktown" } }
+    
+    assert_equal 'Fred Flintstone', form[:name].element_value
+    assert_equal 'Fred Flintstone', obj.value['name'] 
+    assert_equal 'Bricktown', form[:city].element_value
+    assert_equal 'Bricktown', obj.value['city']    
+  end
+  
+  def test_default_fallback_value
+    form = ActiveForm::compose :form do |f|
+      f.text_element :name, :default => 'anonymous'
+      f.text_element :language, :default => 'EN', :value => 'NL'
+    end
+    assert_equal nil, form[:name].value
+    assert_equal 'anonymous', form[:name].fallback_value
+    assert_equal 'anonymous', form[:name].export_value
+    assert_equal 'NL', form[:language].value
+    assert_equal 'EN', form[:language].fallback_value
+    assert_equal 'NL', form[:language].export_value
+    form[:language].value = nil
+    assert_equal nil, form[:language].value
+    assert_equal 'EN', form[:language].fallback_value
+    assert_equal 'EN', form[:language].export_value
+    form[:language].value = "   "
+    assert_equal '   ', form[:language].value
+    assert_equal 'EN', form[:language].fallback_value
+    assert_equal 'EN', form[:language].export_value
+  end
+  
+  def test_export_values_with_default_values
+    form = ActiveForm::compose :form do |f|
+      f.text_element :name, :default => 'anonymous'
+      f.section :details do |s|
+        s.text_element :city
+        s.text_element :district
+        s.text_element :country, :default => 'US'
+        s.section :specs do |gg|
+          gg.text_element :specification, :default => 'special'
+        end
+      end
+    end
+    assert_equal nil, form[:name].value
+    assert_equal 'anonymous', form[:name].fallback_value
+    assert_equal 'anonymous', form[:name].export_value
+    
+    expected = {"name"=>nil, "details"=>{"city"=>nil, "specs"=>{"specification"=>nil}, "district"=>nil, "country"=>nil}}
+    assert_equal expected, form.values
+    
+    expected = {"name"=>"anonymous", "details"=>{"city"=>nil, "specs"=>{"specification"=>"special"}, "district"=>nil, "country"=>"US"}}
+    assert_equal expected, form.export_values
+    
+    form[:details][:country].value = 'BE'   
+    expected = {"name"=>"anonymous", "details"=>{"city"=>nil, "specs"=>{"specification"=>"special"}, "district"=>nil, "country"=>"BE"}}
+    assert_equal expected, form.values(true) # equivalent to export_values
+    
+    form[:name].value = 'Fred Flintstone'  
+    assert_equal 'Fred Flintstone', form[:name].value
+    assert_equal 'anonymous', form[:name].fallback_value
+    assert_equal 'Fred Flintstone', form[:name].export_value
+  end
+  
+  def test_localizer 
+    translations = {
+      'contact_form_firstname_label' => 'Voornaam',
+      'contact_form_lastname_label' => 'Achternaam',
+      'contact_form_country_label' => 'Land',
+      'contact_form_password_label' => 'Wachtwoord',
+      'contact_form_password_new_label' => 'Nieuw wachtwoord',
+      'contact_form_password_confirm_label' => 'Wachtwoord bevestiging'      
+    }   
+    form = ActiveForm::compose :contact_form do |f|
+      f.define_localizer { |formname, elemname, key| translations[ [formname, elemname, key].compact.join('_') ] }
+      f.text_element :firstname
+      f.text_element :lastname
+      f.text_element :country
+      f.section :password do |s|
+        s.password_element :new
+        s.password_element :confirm
+      end       
+    end
+    assert form.localized?
+    assert form[:firstname].localized?
+    assert form[:password][:confirm].localized?       
+    form.elements.each do |e|
+      assert_equal translations[e.identifier + '_label'], e.label
+    end 
+  end
+  
+  def test_localizer_fallback
+    translations = {
+      'contact_form_firstname_title' => 'Uw voornaam',
+      'contact_form_firstname_label' => 'Voornaam',
+      'contact_form_lastname_label' => 'Achternaam',
+      'contact_form_country_label' => nil
+    }
+    form = ActiveForm::compose :contact_form do |f|
+      f.define_localizer { |formname, elemname, key| translations[ [formname, elemname, key].compact.join('_') ] }       
+      f.text_element :firstname,  :title => 'Your firstname'
+      f.text_element :lastname,   :title => 'Your familyname'
+      f.text_element :country
+      f.password_element :password                
+    end
+    assert form.localized? 
+    assert_equal 'Uw voornaam', form[:firstname].title
+    assert_equal 'Voornaam', form[:firstname].label
+    assert_equal 'Achternaam', form[:lastname].label
+    assert_equal 'Your familyname', form[:lastname].title
+    assert_equal 'Country', form[:country].label
+    assert_equal 'Password', form[:password].label
+  end
+  
+  def test_form_submitted
+    form = ActiveForm::compose :form do |f|
+      f.text_element :name
+      f.text_element :language
+      f.submit_element :send
+    end
+    assert !form.submitted?
+    # coming from click on submit button
+    form[:send].value = 'Send' 
+    assert form.submitted?
+  end
+  
+  def test_render_individual_element
+    form = ActiveForm::compose :form do |f|
+      f.text_element :name
+      f.text_element :language
+      f.submit_element :send
+    end
+    expected = %|<label for="form_name">Name</label>\n|
+    assert_equal expected, form.label_for_name
+    expected = %|<input class="elem_text" id="form_name" name="form[name]" size="30" type="text"/>\n|
+    assert_equal expected, form.html_for_name
+    assert_equal form[:language].to_html, form.html_for_language
+    assert_equal form[:send].to_html, form.html_for_send
+  end
+  
+end
+
+# class TestHtmlRendering < Test::Unit::TestCase
+#   
+#   def test_truth
+#     
+#     form = ActiveForm::compose :form do |f|
+#       f.text_element :elem_a
+#       f.text_element :elem_b
+#       f.section :section, :class => 'specialsection' do |s|
+#         g.text_element :elem_a, :style => 'color: red' do |e|
+#           e.define_formatting_filter { |value| value.join(', ') }
+#           e.define_casting_filter { |value| value.split(/,\s+/) }
+#         end       
+#         g.text_element :elem_b, :class => 'specialelem'
+#         g.section :section do |s|
+#           g.text_element :elem_a, :disabled => true
+#           g.text_element :elem_b, :readonly => true
+#         end
+#       end
+#     end 
+#     
+#     form.define_form :one do |f|
+#       f.text_element :sub_a
+#       f.text_element :sub_b
+#     end
+#     
+#     form.define_form :two do |f|
+#       f.text_element :sub_a
+#       f.text_element :sub_b do |e|
+#         e.onblur = "alert('yes!')"
+#       end
+#     end
+#     
+#     ActiveForm::Definition.define_container_wrapper do |builder, elem, render|      
+#       builder.form(elem.element_attributes) {
+#         builder.table(:border => 1) {
+#           builder.thead { builder.tr { builder.th(elem.label, :colspan => 2) } }
+#           builder.tbody { elem.render_elements(builder) }
+#         }
+#         builder << elem.script_tag
+#       }   
+#     end
+#     
+#     ActiveForm::Definition.define_element_wrapper do |builder, elem, render|
+#       style = StyleAttribute.new
+#       style << 'margin: 20px'
+#       style << 'display: none' if elem.hidden?
+#       builder.tr { builder.td { builder.table(:border => 1, :style => style, &render) } }
+#     end  
+#     
+#     ActiveForm::Element::Base.define_element_wrapper do |builder, elem, render|
+#       builder.tr(:class => 'label') { builder.td(:colspan => 2) { elem.render_label(builder) } }
+#       builder.tr(:id => "elem_#{elem.identifier}", :class => elem.css, :style => elem.style) { builder.td(:class => 'elem', :colspan => 2, &render) }
+#     end
+#     
+#     ActiveForm::Element::Section.define_element_wrapper do |builder, elem, render|
+#       builder.tr { builder.td { builder.table(:border => 1, :style => 'background: orange; margin: 20px', &render) } }
+#     end
+#     
+#     form.update_from_params(:form => { :elem_a => 'test', :elem_b => 'tester', :section => { :elem_a => 'one, two, three' }, :two => { :sub_a => 'subvalue' } })
+#     
+#     #form.display
+#     
+#     ActiveForm::Definition.reset_element_wrapper
+#     ActiveForm::Definition.reset_container_wrapper
+#     ActiveForm::Element::Base.reset_element_wrapper
+#     ActiveForm::Element::Section.reset_element_wrapper
+#   end
+#   
+# end