From db045dbbf60b53dbe013ef25554fd013baf88134 Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Wed, 24 Nov 2004 01:04:44 +0000 Subject: Initial git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@4 5ecf4fe2-1ee6-0310-87b1-e25e094e27de --- .../action_view/helpers/active_record_helper.rb | 171 +++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 actionpack/lib/action_view/helpers/active_record_helper.rb (limited to 'actionpack/lib/action_view/helpers/active_record_helper.rb') diff --git a/actionpack/lib/action_view/helpers/active_record_helper.rb b/actionpack/lib/action_view/helpers/active_record_helper.rb new file mode 100644 index 0000000000..b02b807fe1 --- /dev/null +++ b/actionpack/lib/action_view/helpers/active_record_helper.rb @@ -0,0 +1,171 @@ +require 'cgi' +require File.dirname(__FILE__) + '/form_helper' + +module ActionView + class Base + @@field_error_proc = Proc.new{ |html_tag, instance| "
#{html_tag}
" } + cattr_accessor :field_error_proc + end + + module Helpers + # The Active Record Helper makes it easier to create forms for records kept in instance variables. The most far-reaching is the form + # method that creates a complete form for all the basic content types of the record (not associations or aggregations, though). This + # is a great of making the record quickly available for editing, but likely to prove lacklusters for a complicated real-world form. + # In that case, it's better to use the input method and the specialized form methods in link:classes/ActionView/Helpers/FormHelper.html + module ActiveRecordHelper + # Returns a default input tag for the type of object returned by the method. Example + # (title is a VARCHAR column and holds "Hello World"): + # input("post", "title") => + # + def input(record_name, method) + InstanceTag.new(record_name, method, self).to_tag + end + + # Returns an entire form with input tags and everything for a specified Active Record object. Example + # (post is a new record that has a title using VARCHAR and a body using TEXT): + # form("post") => + #
+ #

+ #
+ # + #

+ #

+ #
+ # + #

+ # + #
+ # + # It's possible to specialize the form builder by using a different action name and by supplying another + # block renderer. Example (entry is a new record that has a message attribute using VARCHAR): + # + # form("entry", :action => "sign", :input_block => + # Proc.new { |record, column| "#{column.human_name}: #{input(record, column.name)}
" }) => + # + #
+ # Message: + #
+ # + #
+ def form(record_name, options = {}) + record = instance_eval("@#{record_name}") + action = options[:action] || (record.new_record? ? "create" : "update") + id_field = record.new_record? ? "" : InstanceTag.new(record_name, "id", self).to_input_field_tag("hidden") + + "
" + + id_field + all_input_tags(record, record_name, options) + + "" + + "
" + end + + # Returns a string containing the error message attached to the +method+ on the +object+, if one exists. + # This error message is wrapped in a DIV tag, which can be specialized to include both a +prepend_text+ and +append_text+ + # to properly introduce the error and a +css_class+ to style it accordingly. Examples (post has an error message + # "can't be empty" on the title attribute): + # + # <%= error_message_on "post", "title" %> => + #
can't be empty
+ # + # <%= error_message_on "post", "title", "Title simply ", " (or it won't work)", "inputError" %> => + #
Title simply can't be empty (or it won't work)
+ def error_message_on(object, method, prepend_text = "", append_text = "", css_class = "formError") + if errors = instance_eval("@#{object}").errors.on(method) + "
#{prepend_text + (errors.is_a?(Array) ? errors.first : errors) + append_text}
" + end + end + + def error_messages_for(object_name) + object = instance_eval("@#{object_name}") + unless object.errors.empty? + "
" + + "

#{object.errors.count} error#{"s" unless object.errors.count == 1} prohibited this #{object_name.gsub("_", " ")} from being saved

" + + "

There were problems with the following fields (marked in red below):

" + + "" + + "
" + end + end + + private + def all_input_tags(record, record_name, options) + input_block = options[:input_block] || default_input_block + record.class.content_columns.collect{ |column| input_block.call(record_name, column) }.join("\n") + end + + def default_input_block + Proc.new { |record, column| "


#{input(record, column.name)}

" } + end + end + + class InstanceTag #:nodoc: + def to_tag(options = {}) + case column_type + when :string + field_type = @method_name.include?("password") ? "password" : "text" + to_input_field_tag(field_type, options) + when :text + to_text_area_tag(options) + when :integer, :float + to_input_field_tag("text", options) + when :date + to_date_select_tag(options) + when :datetime + to_datetime_select_tag(options) + when :boolean + to_boolean_select_tag(options) + end + end + + alias_method :tag_without_error_wrapping, :tag + + def tag(name, options) + if object.respond_to?("errors") && object.errors.respond_to?("on") + error_wrapping(tag_without_error_wrapping(name, options), object.errors.on(@method_name)) + else + tag_without_error_wrapping(name, options) + end + end + + alias_method :content_tag_without_error_wrapping, :content_tag + + def content_tag(name, value, options) + if object.respond_to?("errors") && object.errors.respond_to?("on") + error_wrapping(content_tag_without_error_wrapping(name, value, options), object.errors.on(@method_name)) + else + content_tag_without_error_wrapping(name, value, options) + end + end + + alias_method :to_date_select_tag_without_error_wrapping, :to_date_select_tag + def to_date_select_tag(options = {}) + if object.respond_to?("errors") && object.errors.respond_to?("on") + error_wrapping(to_date_select_tag_without_error_wrapping(options), object.errors.on(@method_name)) + else + to_date_select_tag_without_error_wrapping(options) + end + end + + alias_method :to_datetime_select_tag_without_error_wrapping, :to_datetime_select_tag + def to_datetime_select_tag(options = {}) + if object.respond_to?("errors") && object.errors.respond_to?("on") + error_wrapping(to_datetime_select_tag_without_error_wrapping(options), object.errors.on(@method_name)) + else + to_datetime_select_tag_without_error_wrapping(options) + end + end + + def error_wrapping(html_tag, has_error) + has_error ? Base.field_error_proc.call(html_tag, self) : html_tag + end + + def error_message + object.errors.on(@method_name) + end + + def column_type + object.send("column_for_attribute", @method_name).type + end + end + end +end -- cgit v1.2.3