form_assistant 1.0.0

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+gem "rake", "0.8.7"
+
+group :development do
+  gem "activesupport", "~> 2.3"
+  gem "actionpack",    "~> 2.3"
+  gem "activerecord",  "~> 2.3"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", "~> 1.8.4"
+  gem "rcov", ">= 0"
+  gem "mocha", :require => false
+end

data/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionpack (2.3.14)
+      activesupport (= 2.3.14)
+      rack (~> 1.1.0)
+    activerecord (2.3.14)
+      activesupport (= 2.3.14)
+    activesupport (2.3.14)
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.3)
+    metaclass (0.0.1)
+    mocha (0.12.0)
+      metaclass (~> 0.0.1)
+    rack (1.1.3)
+    rake (0.8.7)
+    rcov (1.0.0)
+    rdoc (3.12)
+      json (~> 1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  actionpack (~> 2.3)
+  activerecord (~> 2.3)
+  activesupport (~> 2.3)
+  bundler (>= 1.0.0)
+  jeweler (~> 1.8.4)
+  mocha
+  rake (= 0.8.7)
+  rcov
+  rdoc (~> 3.12)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Chris Scharf
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,128 @@
+h1. FormAssistant
+
+This is a Rails plugin that provides a custom form builder that attempts to make forms somewhat friendly.
+
+h2. Usage
+
+Once installed, use the form assistant just like #form_for():
+
+<pre><code><% form_assistant_for @project do |form| %>
+  // typical form_for stuff
+<% end %></code></pre>
+
+Or if you'd rather use #form_for() everywhere, you can set the form assistant's builder to be your default across the entire application like so:
+
+<pre><code>ActionView::Base.default_form_builder = RPH::FormAssistant::FormBuilder</code></pre>
+
+h2. Defaults and Configuration
+
+Things you can customize...
+
+<pre><code># config/initializers/form_assistant.rb
+  
+RPH::FormAssistant::FormBuilder.ignore_templates = true         # defaults to false
+RPH::FormAssistant::FormBuilder.ignore_labels = true            # defaults to false
+RPH::FormAssistant::FormBuilder.ignore_errors = true            # defaults to false
+RPH::FormAssistant::FormBuilder.template_root = '...'           # defaults to app/views/forms
+</code></pre>
+
+The only thing worth mentioning deals with ignoring templates. If you ignore the templates, you will still get access to all of the custom helpers and your form helpers (@text_field@, @text_area@, etc) will automatically have labels attached to them. The form assistant considers trailing labels, too, meaning if you have a @check_box@ the label will be _after_ the check box instead of before it. It will also be given a CSS class of 'inline'.
+
+h2. Examples
+
+Here are a few reasons why it's worth using the form assistant.
+
+I'm going to refer to a @form@ object in the examples. Assume this object is yielded back to the block of a form assistant call, like so:
+
+<pre><code><% form_assistant_for @project do |form| %>
+  // the 'form' object would be used in here
+<% end %>
+</code></pre>
+
+And just to be clear, the regular @fields_for()@ doesn't inherit the builder from the builder object, but as long as you're using the form assistant, this problem has been taken care of automatically. Just call the @fields_for()@ helper on the builder object, like so:
+
+<pre><code><% form_assistant_for @project do |form| %>
+  <% form.fields_for :tasks do |task_fields| %>
+    <%= task_fields.text_field :name %>
+  <% end %>
+<% end %>
+</code></pre>
+
+h3. Form Templates
+
+The new and improved form assistant uses partials to format your fields, labels, errors (if any), and tips. To get started, run...
+
+<pre><code>$> rake form_assistant:install</code></pre>
+
+...from your project root. That will put some example form partials in app/views/forms/*.
+
+By default, the form assistant will try to render a template based on the name of the helper. For instance, calling <pre><code><%= form.text_field :title %></code></pre> will look for a template called _text_field.html.erb located in app/views/forms. However, you can specify a different template easily:
+
+<pre><code><%= form.text_field :title, :template => 'custom_template' %></code></pre>
+
+If a specified template doesn't exist, a fallback template will be used (called '_field.html.erb').
+
+There's also a @#fieldset()@ helper available to you, although it doesn't belong to the form object (it's mixed into action view itself).
+
+<pre><code><% fieldset 'User Registration' do %>
+  <%= form.text_field :name %>
+  <%= form.text_field :username %>
+  <%= form.text_field :password %>
+<% end %>
+</code></pre>
+
+The nice thing about that is it's also controlled by a template (cleverly called '_fieldset.html.erb').
+
+h3. Required Fields
+
+You can now pass a @:required@ flag to the field helpers, and it will be available within the templates.
+
+<pre><code><%= form.text_field :title, :required => true %></code></pre>
+
+Then you can check the 'required' local variable and handle it accordingly. Naturally, this defaults to false.
+
+h3. Form Labels
+
+Another convenient thing about the form assistant is the ability to control labels from their respective helper. For example...
+
+<pre><code><%= form.text_field :title, :label => 'Project Title' %>
+<%= form.text_field :title, :label_text => 'Project Title' %>
+<%= form.text_field :title, :label_class => 'required' %>
+<%= form.text_field :title, :label_id => 'dom_id' %>
+<%= form.text_field :title, :label => { :text => 'Project Title', :id => 'dom_id', :class => 'required' } %>
+<%= form.text_field :title, :label => false %>
+</code></pre>
+
+That works for all form helpers (text_area, check_box, etc). And by default, the label will be the humanized version of the field name, so that's what you'll get if you ignore the label options altogether.
+
+h3. Form Widgets
+
+Sometimes, a single form field isn't enough.  Form assistant provides a construct to help you
+with this, called widget:
+
+<pre><code><% form.widget :expiration_date, :label => 'Card expiration date' do %>
+  <%= form.select :expiration_month, (1..12) %>
+  <%= form.select :expiration_month, (1..12) %>
+<% end %></code></pre>
+
+There are a few things to note about this new feature:
+
+  * error messages will come from the errors on the field name ('expiration_date' in the above example)
+  * templates and labels are disabled for the duration of the block
+  * the default template for widgets is the fallback template (===_field.html.erb=== unless configured otherwise)
+
+h3. Custom Helpers
+
+@#partial()@ helper:
+
+<pre><code><%= form.partial 'shared/new', :locals => { ... } %></code></pre>
+
+The builder variable will be automatically passed as a local called 'form'.
+
+h2. Requirements
+
+The form assistant requires _at least_ Rails version 2.1.0. This is mainly due to the usage of the convenience methods now included in the Rails module (for things like @Rails.version@ and @Rails.root@).
+
+h2. Licensing
+
+(c) 2008 Ryan Heath, released under the MIT license

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "form_assistant"
+  gem.homepage = "http://github.com/scharfie/form_assistant"
+  gem.license = "MIT"
+  gem.summary = %Q{Custom form builder that attempts to make your forms friendly}
+  gem.description = %Q{Custom form builder that attempts to make your forms friendly}
+  gem.email = "scharfie@gmail.com"
+  gem.authors = ["Ryan Heath", "Chris Scharf"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "gem #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "testunit" }

data/autotest/testunit.rb

@@ -0,0 +1,26 @@
+require 'autotest'
+
+class Autotest::Testunit < Autotest
+  def initialize # :nodoc:
+    super
+    @exceptions = /^\.\/(?:config|doc|log|tmp|website)/
+
+    @test_mappings = {
+      %r%^test/.*\.rb$% => proc { |filename, _|
+        filename
+      },
+      %r%^lib/(.*)\.rb$% => proc { |_, m|
+        ["test/#{m[1]}_test.rb"]
+      },
+      %r%^test/test_helper.rb$% => proc {
+        files_matching %r%^test/.*_test\.rb$%
+      },
+    }
+  end
+
+  # Given the string filename as the path, determine
+  # the corresponding tests for it, in an array.
+  def tests_for_file(filename)
+    super.select { |f| @files.has_key? f }
+  end
+end

data/forms/_check_box.html.erb

@@ -0,0 +1,4 @@
+<p>
+  <%= element %> <%= label %> <span><%= tip %></span><br />
+  <%= errors %>
+</p>

data/forms/_field.html.erb

@@ -0,0 +1,5 @@
+<%= label %>
+<p>
+  <%= element %> <span><%= tip %></span><br />
+  <%= errors %>
+</p>

data/forms/_fieldset.html.erb

@@ -0,0 +1,4 @@
+<h2><%= legend %></h2>
+<div class="fieldset">
+  <%= fields %>
+</div>

data/forms/_file_field.html.erb

@@ -0,0 +1,5 @@
+<%= label %>
+<p>
+  <%= element %> <span><%= tip %></span><br />
+  <%= errors %>
+</p>

data/forms/_password_field.html.erb

@@ -0,0 +1,5 @@
+<%= label %>
+<p>
+  <%= element %> <span><%= tip %></span><br />
+  <%= errors %>
+</p>

data/forms/_radio_button.html.erb

@@ -0,0 +1,4 @@
+<p>
+  <%= element %> <%= label %> <span><%= tip %></span><br />
+  <%= errors %>
+</p>

data/forms/_text_area.html.erb

@@ -0,0 +1,5 @@
+<%= label %>
+<p>
+  <%= element %> <span><%= tip %></span><br />
+  <%= errors %>
+</p>

data/forms/_text_field.html.erb

@@ -0,0 +1,5 @@
+<%= label %>
+<p>
+  <%= element %> <span><%= tip %></span><br />
+  <%= errors %>
+</p>

data/init.rb

@@ -0,0 +1,2 @@
+require 'form_assistant'
+ActionView::Base.send :include, RPH::FormAssistant::ActionView

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/form_assistant.rb

@@ -0,0 +1,373 @@
+%w(error field_errors rules).each do |f|
+  require File.join(File.dirname(__FILE__), 'form_assistant', f)
+end
+
+# Developed by Ryan Heath (http://rpheath.com)
+module RPH
+  # The idea is to make forms extremely less painful and a lot more DRY
+  module FormAssistant
+    FORM_HELPERS = [
+      ActionView::Helpers::FormBuilder.field_helpers + 
+      %w(date_select datetime_select time_select collection_select select country_select time_zone_select) - 
+      %w(hidden_field label fields_for)
+    ].flatten.freeze
+        
+    # FormAssistant::FormBuilder
+    #   * provides several convenient helpers (see helpers.rb) and
+    #     an infrastructure to easily add your own
+    #   * method_missing hook to wrap content "on the fly"
+    #   * optional: automatically attach labels to field helpers
+    #   * optional: format fields using partials (extremely extensible)
+    # 
+    # Usage:
+    #
+    #   <% form_for @project, :builder => RPH::FormAssistant::FormBuilder do |form| %>
+    #     // fancy form stuff
+    #   <% end %>
+    #
+    #   - or -
+    # 
+    #   <% form_assistant_for @project do |form| %>
+    #     // fancy form stuff
+    #   <% end %>
+    #
+    #   - or -
+    #
+    #   # in config/intializers/form_assistant.rb
+    #   ActionView::Base.default_form_builder = RPH::FormAssistant::FormBuilder
+    class FormBuilder < ActionView::Helpers::FormBuilder
+      cattr_accessor :ignore_templates
+      cattr_accessor :ignore_labels
+      cattr_accessor :ignore_errors
+      cattr_accessor :template_root
+      
+      # used if no other template is available
+      attr_accessor :fallback_template
+      
+      # if set to true, none of the templates will be used;
+      # however, labels can still be automatically attached
+      # and all FormAssistant helpers are still avaialable
+      self.ignore_templates = false
+      
+      # if set to true, labels will become nil everywhere (both 
+      # with and without templates)
+      self.ignore_labels = false
+      
+      # set to true if you'd rather use #error_messages_for()
+      self.ignore_errors = false
+
+      # sets the root directory where templates will be searched
+      # note: the template root should be nested within the
+      # configured view path (which defaults to app/views)
+      self.template_root = File.join(Rails.configuration.view_path, 'forms')
+      
+      # override the field_error_proc so that it no longer wraps the field
+      # with <div class="fieldWithErrors">...</div>, but just returns the field
+      ActionView::Base.field_error_proc = Proc.new { |html_tag, instance| html_tag }
+      
+    private
+      # render(:partial => '...') doesn't want the full path of the template
+      def self.template_root(full_path = false)
+        full_path ? @@template_root : @@template_root.gsub(Rails.configuration.view_path + '/', '')
+      end
+      
+      # get the error messages (if any) for a field
+      def error_message_for(fields)
+        errors = []
+        fields = [fields] unless Array === fields
+
+        fields.each do |field|
+          next unless has_errors?(field)
+          
+          errors += if RPH::FormAssistant::Rules.has_I18n_support?
+            full_messages_for(field)
+          else
+            human_field_name = field.to_s.humanize
+            errors += [*object.errors[field]].map do |error|
+              "#{human_field_name} #{error}"
+            end  
+          end
+        end
+
+        errors.empty? ? nil : RPH::FormAssistant::FieldErrors.new(errors)
+      end
+      
+      # Returns full error messages for given field (uses I18n)
+      def full_messages_for(field)
+        attr_name = object.class.human_attribute_name(field.to_s)
+
+        object.errors[field].inject([]) do |full_messages, message|
+          next unless message
+          full_messages << attr_name + I18n.t('activerecord.errors.format.separator', :default => ' ') + message
+        end
+      end
+      
+      # returns true if a field is invalid
+      def has_errors?(field)
+        !(object.nil? || object.errors[field].blank?)
+      end
+      
+      # checks to make sure the template exists
+      def template_exists?(template)
+        File.exists?(File.join(self.class.template_root(true), "_#{template}.html.erb"))
+      end
+      
+    protected
+      # renders the appropriate partial located in the template root
+      def render_partial_for(element, field, label, tip, template, helper, required, extra_locals, args)
+        errors = self.class.ignore_errors ? nil : error_message_for(field)
+        locals = (extra_locals || {}).merge(:element => element, :field => field, :builder => self, :object => object, :object_name => object_name, :label => label, :errors => errors, :tip => tip, :helper => helper, :required => required)
+
+        @template.render :partial => "#{self.class.template_root}/#{template}.html.erb", :locals => locals
+      end
+      
+      # render the element with an optional label (does not use the templates)
+      def render_element(element, field, name, options, ignore_label = false)
+        return element if ignore_label
+        
+        # need to consider if the shortcut label option was used
+        # i.e. <%= form.text_field :title, :label => 'Project Title' %>
+        text, label_options = if options[:label].is_a?(String)
+          [options.delete(:label), {}]
+        else
+          [options[:label].delete(:text), options.delete(:label)]
+        end
+        
+        # consider trailing labels
+        if %w(check_box radio_button).include?(name)
+          label_options[:class] = (label_options[:class].to_s + ' inline').strip
+          element + label(field, text, label_options)
+        else
+          label(field, text, label_options) + element
+        end
+      end
+    
+      def extract_options_for_label(field, options={})
+        label_options = {}
+
+        # consider the global setting for labels and
+        # allow for turning labels off on a per-helper basis
+        # <%= form.text_field :title, :label => false %>
+        if self.class.ignore_labels || options[:label] === false || field.blank?
+          label_options[:label] = false
+        else  
+          # ensure that the :label option is a Hash from this point on
+          options[:label] ||= {}
+        
+          # allow for a cleaner way of setting label text
+          # <%= form.text_field :whatever, :label => 'Whatever Title' %>
+          label_options.merge!(options[:label].is_a?(String) ? {:text => options[:label]} : options[:label])
+
+          # allow for a more convenient way to set common label options
+          # <%= form.text_field :whatever, :label_id => 'dom_id' %>
+          # <%= form.text_field :whatever, :label_class => 'required' %>
+          # <%= form.text_field :whatever, :label_text => 'Whatever' %>
+          %w(id class text).each do |option|
+            label_option = "label_#{option}".to_sym
+            label_options.merge!(option.to_sym => options.delete(label_option)) if options[label_option]
+          end
+        
+          # Ensure we have default label text 
+          # (since Rails' label() does not currently respect I18n)
+          label_options[:text] ||= object.class.human_attribute_name(field.to_s)
+        end
+          
+        label_options
+      end
+
+      def extract_options_for_template(helper_name, options={})
+        template_options = {}
+        
+        if options.has_key?(:template) && options[:template].kind_of?(FalseClass)
+          template_options[:template] = false
+        else  
+          # grab the template
+          template = options.delete(:template) || helper_name.to_s
+          template = self.fallback_template unless template_exists?(template)
+          template_options[:template] = template
+        end
+          
+        template_options
+      end  
+    
+    public
+      def fallback_template
+        @fallback_template ||= 'field'
+      end
+    
+      def self.assist(helper_name)
+        define_method(helper_name) do |field, *args|
+          options          = (helper_name == 'check_box' ? args.shift : args.extract_options!) || {}
+          label_options    = extract_options_for_label(field, options)
+          template_options = extract_options_for_template(helper_name, options)
+          extra_locals     = options.delete(:locals) || {}
+          
+          # build out the label element (if desired)
+          label = label_options[:label] === false ? nil : self.label(field, label_options.delete(:text), label_options)
+
+          # grab the tip, if any
+          tip = options.delete(:tip)
+          
+          # is the field required?
+          required = !!options.delete(:required)
+          
+          # ensure that we don't have any custom options pass through
+          field_options = options.except(:label, :template, :tip, :required)
+          
+          # call the original render for the element
+          super_args = helper_name == 'check_box' ? args.unshift(field_options) : args.push(field_options)
+          element = super(field, *super_args)
+          
+          return element if template_options[:template] === false
+          
+          # return the helper with an optional label if templates are not to be used
+          return render_element(element, field, helper_name, options, label_options[:label] === false) if self.class.ignore_templates
+          
+          # render the partial template from the desired template root
+          render_partial_for(element, field, label, tip, template_options[:template], helper_name, required, extra_locals, args)
+        end
+      end
+      
+      # redefining all traditional form helpers so that they
+      # behave the way FormAssistant thinks they should behave
+      RPH::FormAssistant::FORM_HELPERS.each do |helper_name|
+        assist(helper_name)
+      end
+    
+      def without_assistance(options={}, &block)
+        # TODO - allow options to only turn off templates and/or labels
+        ignore_labels, ignore_templates = self.class.ignore_labels, self.class.ignore_templates
+       
+        begin
+          self.class.ignore_labels, self.class.ignore_templates = true, true
+          result = yield
+        ensure  
+          self.class.ignore_labels, self.class.ignore_templates = ignore_labels, ignore_templates
+        end  
+
+        result
+      end
+    
+      def widget(*args, &block)
+        options          = args.extract_options!
+        fields           = args.shift || nil 
+        field            = Array === fields ? fields.first : fields
+        
+        label_options    = extract_options_for_label(field, options)
+        template_options = extract_options_for_template(self.fallback_template, options)
+        label            = label_options[:label] === false ? nil : self.label(field, label_options.delete(:text), label_options)
+        tip              = options.delete(:tip)
+        locals           = options.delete(:locals)
+        required         = !!options.delete(:required)
+
+        if block_given?
+          element = without_assistance do
+            @template.capture(&block)
+          end  
+        else
+          element = nil
+        end    
+        
+        partial = render_partial_for(element, fields, label, tip, template_options[:template], 'widget', required, locals, args)
+        RPH::FormAssistant::Rules.binding_required? ? @template.concat(partial, block.binding) : @template.concat(partial)
+      end
+      
+      # Renders a partial, passing the form object as a local
+      # variable named 'form'
+      # <%= form.partial 'shared/new', :locals => { :whatever => @whatever } %>
+      def partial(name, options={})
+        (options[:locals] ||= {}).update :form => self
+        options.update :partial => name
+        @template.render options
+      end
+      
+      def input(field, *args)
+        helper_name = case column_type(field)
+          when :string
+            field.to_s.include?('password') ? :password_field : :text_field
+          when :text                      ; :text_area
+          when :integer, :float, :decimal ; :text_field
+          when :date                      ; :date_select
+          when :datetime, :timestamp      ; :datetime_select
+          when :time                      ; :time_select
+          when :boolean                   ; :check_box
+          else                            ; :text_field
+        end
+        
+        send(helper_name, field, *args)
+      end
+      
+      def inputs(*args)
+        options = args.extract_options!
+        args.flatten.map do |field|
+          input(field, options.dup)
+        end.join('')
+      end
+
+      def column_type(field)
+        object.class.columns_hash[field.to_s].type rescue :string
+      end
+      
+      # since #fields_for() doesn't inherit the builder from form_for, we need
+      # to provide a means to set the builder automatically (works with nesting, too)
+      #
+      # Usage: simply call #fields_for() on the builder object
+      #
+      #   <% form_assistant_for @project do |form| %>
+      #     <%= form.text_field :title %>
+      #     <% form.fields_for :tasks do |task_fields| %>
+      #       <%= task_fields.text_field :name %>
+      #     <% end %>
+      #   <% end %>
+      def fields_for_with_form_assistant(record_or_name_or_array, *args, &proc)
+        options = args.extract_options!
+        # hand control over to the original #fields_for()
+        fields_for_without_form_assistant(record_or_name_or_array, *(args << options.merge!(:builder => self.class)), &proc)
+      end
+      
+      # used to intercept #fields_for() and set the builder
+      alias_method_chain :fields_for, :form_assistant
+    end
+    
+    # methods that mix into ActionView::Base
+    module ActionView
+      private
+        # used to ensure that the desired builder gets set before calling #form_for()
+        def form_for_with_builder(record_or_name_or_array, builder, *args, &proc)
+          options = args.extract_options!
+          # hand control over to the original #form_for()
+          form_for(record_or_name_or_array, *(args << options.merge!(:builder => builder)), &proc)
+        end
+        
+        # determines if binding is needed for #concat()
+        # (Rails 2.2.0 and greater no longer requires the binding)
+        def binding_required
+          RPH::FormAssistant::Rules.binding_required?
+        end
+      
+      public
+        # easy way to make use of FormAssistant::FormBuilder
+        #
+        # <% form_assistant_for @project do |form| %>
+        #   // fancy form stuff
+        # <% end %>
+        def form_assistant_for(record_or_name_or_array, *args, &proc)
+          form_for_with_builder(record_or_name_or_array, RPH::FormAssistant::FormBuilder, *args, &proc)
+        end
+        
+        # (borrowed the #fieldset() helper from Chris Scharf: 
+        #   http://github.com/scharfie/slate/tree/master/app/helpers/application_helper.rb)
+        #
+        # <% fieldset 'User Registration' do %>
+        #   // fields
+        # <% end %>
+        def fieldset(legend, &block)
+          locals = { :legend => legend, :fields => capture(&block) }
+          partial = render(:partial => "#{RPH::FormAssistant::FormBuilder.template_root}/fieldset.html.erb", :locals => locals)
+          
+          # render the fields
+          binding_required ? concat(partial, block.binding) : concat(partial)
+        end
+    end
+  end   
+end