actionpack 1.11.2 → 1.12.0

data/lib/action_view/compiled_templates.rb

@@ -10,7 +10,7 @@ module ActionView
   #
   # To use a compiled template module, create a new instance and include it into the class
   # in which you want the template to be rendered.
-  class CompiledTemplates < Module
+  class CompiledTemplates < Module #:nodoc:
     attr_reader :method_names
 
     def initialize

data/lib/action_view/helpers/active_record_helper.rb

@@ -103,7 +103,7 @@ module ActionView
       def error_messages_for(object_name, options = {})
         options = options.symbolize_keys
         object = instance_variable_get("@#{object_name}")
-        unless object.errors.empty?
+        if object && !object.errors.empty?
           content_tag("div",
             content_tag(
               options[:header_tag] || "h2",
@@ -113,6 +113,8 @@ module ActionView
             content_tag("ul", object.errors.full_messages.collect { |msg| content_tag("li", msg) }),
             "id" => options[:id] || "errorExplanation", "class" => options[:class] || "errorExplanation"
           )
+        else
+          ""
         end
       end
 
@@ -139,7 +141,7 @@ module ActionView
             to_input_field_tag("text", options)
           when :date
             to_date_select_tag(options)
-          when :datetime
+          when :datetime, :timestamp
             to_datetime_select_tag(options)
           when :boolean
             to_boolean_select_tag(options)

data/lib/action_view/helpers/asset_tag_helper.rb

@@ -59,11 +59,10 @@ module ActionView
       # <tt>controllers/application.rb</tt> and <tt>helpers/application_helper.rb</tt>.
       def javascript_include_tag(*sources)
         options = sources.last.is_a?(Hash) ? sources.pop.stringify_keys : { }
-        if sources.first == :defaults
-          sources = @@javascript_default_sources.dup
-          if defined?(RAILS_ROOT) and File.exists?("#{RAILS_ROOT}/public/javascripts/application.js")
-            sources << 'application' 
-          end
+        if sources.include?(:defaults) 
+          sources = sources[0..(sources.index(:defaults))] + @@javascript_default_sources.dup + sources[(sources.index(:defaults) + 1)..sources.length] 
+          sources.delete(:defaults) 
+          sources << "application" if defined?(RAILS_ROOT) and File.exists?("#{RAILS_ROOT}/public/javascripts/application.js") 
         end
         sources.collect { |source|
           source = javascript_path(source)        
@@ -131,7 +130,7 @@ module ActionView
       # * file name, like "rss.gif", that gets expanded to "/images/rss.gif"
       # * file name without extension, like "logo", that gets expanded to "/images/logo.png"
       def image_tag(source, options = {})
-        options.symbolize_keys
+        options.symbolize_keys!
                 
         options[:src] = image_path(source)
         options[:alt] ||= File.basename(options[:src], '.*').split('.').first.capitalize
@@ -147,7 +146,7 @@ module ActionView
       private
         def compute_public_path(source, dir, ext)
           source = "/#{dir}/#{source}" unless source.first == "/" || source.include?(":")
-          source = "#{source}.#{ext}" unless source.include?(".")
+          source = "#{source}.#{ext}" unless source.split("/").last.include?(".")
           source = "#{@controller.request.relative_url_root}#{source}" unless %r{^[-a-z]+://} =~ source
           source = ActionController::Base.asset_host + source unless source.include?(":")
           source

data/lib/action_view/helpers/capture_helper.rb

@@ -43,24 +43,30 @@ module ActionView
       # instance variable. You can use this instance variable anywhere
       # in your templates and even in your layout. 
       # 
-      # Example:
+      # Example of capture being used in a .rhtml page:
       # 
       #   <% @greeting = capture do %>
       #     Welcome To my shiny new web page!
-      #   <% end %>      
+      #   <% end %>
+      #
+      # Example of capture being used in a .rxml page:
+      # 
+      #   @greeting = capture do
+      #     'Welcome To my shiny new web page!'
+      #   end
       def capture(*args, &block)
         # execute the block
-        buffer = eval("_erbout", block.binding)
-        pos = buffer.length
-        block.call(*args)
+        begin
+          buffer = eval("_erbout", block.binding)
+        rescue
+          buffer = nil
+        end
         
-        # extract the block 
-        data = buffer[pos..-1]
-        
-        # replace it in the original with empty string
-        buffer[pos..-1] = ''
-        
-        data
+        if buffer.nil?
+          capture_block(*args, &block)
+        else
+          capture_erb_with_buffer(buffer, *args, &block)
+        end
       end
       
       # Content_for will store the given block
@@ -84,6 +90,37 @@ module ActionView
       def content_for(name, &block)
         eval "@content_for_#{name} = (@content_for_#{name} || '') + capture(&block)"
       end
+
+      private
+        def capture_block(*args, &block)
+          block.call(*args)
+        end
+      
+        def capture_erb(*args, &block)
+          buffer = eval("_erbout", block.binding)
+          capture_erb_with_buffer(buffer, *args, &block)
+        end
+      
+        def capture_erb_with_buffer(buffer, *args, &block)
+          pos = buffer.length
+          block.call(*args)
+        
+          # extract the block 
+          data = buffer[pos..-1]
+        
+          # replace it in the original with empty string
+          buffer[pos..-1] = ''
+        
+          data
+        end
+      
+        def erb_content_for(name, &block)
+          eval "@content_for_#{name} = (@content_for_#{name} || '') + capture_erb(&block)"
+        end
+      
+        def block_content_for(name, &block)
+          eval "@content_for_#{name} = (@content_for_#{name} || '') + capture_block(&block)"
+        end
     end
   end
 end

data/lib/action_view/helpers/date_helper.rb

@@ -76,8 +76,8 @@ module ActionView
       #   date_select("user", "birthday",   :order => [:month, :day])
       #
       # The selects are prepared for multi-parameter assignment to an Active Record object.
-      def date_select(object, method, options = {})
-        InstanceTag.new(object, method, self).to_date_select_tag(options)
+      def date_select(object_name, method, options = {})
+        InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_date_select_tag(options)
       end
 
       # Returns a set of select tags (one for year, month, day, hour, and minute) pre-selected for accessing a specified datetime-based
@@ -87,8 +87,8 @@ module ActionView
       #   datetime_select("post", "written_on", :start_year => 1995)
       #
       # The selects are prepared for multi-parameter assignment to an Active Record object.
-      def datetime_select(object, method, options = {})
-        InstanceTag.new(object, method, self).to_datetime_select_tag(options)
+      def datetime_select(object_name, method, options = {})
+        InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_datetime_select_tag(options)
       end
 
       # Returns a set of html select-tags (one for year, month, and day) pre-selected with the +date+.
@@ -293,5 +293,15 @@ module ActionView
         datetime_select
       end
     end
+
+    class FormBuilder
+      def date_select(method, options = {})
+        @template.date_select(@object_name, method, options.merge(:object => @object))
+      end
+
+      def datetime_select(method, options = {})
+        @template.datetime_select(@object_name, method, options.merge(:object => @object))
+      end
+    end
   end
 end

data/lib/action_view/helpers/form_helper.rb

@@ -47,7 +47,7 @@ module ActionView
     #
     # If the object name contains square brackets the id for the object will be inserted. Example:
     #
-    #   <%= textfield "person[]", "name" %> 
+    #   <%= text_field "person[]", "name" %> 
     # 
     # ...becomes:
     #
@@ -65,6 +65,90 @@ module ActionView
     # There's also methods for helping to build form tags in link:classes/ActionView/Helpers/FormOptionsHelper.html,
     # link:classes/ActionView/Helpers/DateHelper.html, and link:classes/ActionView/Helpers/ActiveRecordHelper.html
     module FormHelper
+      # Creates a form and a scope around a specific model object, which is then used as a base for questioning about
+      # values for the fields. Examples:
+      #
+      #   <% form_for :person, @person, :url => { :action => "update" } do |f| %>
+      #     First name: <%= f.text_field :first_name %>
+      #     Last name : <%= f.text_field :last_name %>
+      #     Biography : <%= f.text_area :biography %>
+      #     Admin?    : <%= f.check_box :admin %>
+      #   <% end %>
+      #
+      # Worth noting is that the form_for tag is called in a ERb evaluation block, not a ERb output block. So that's <tt><% %></tt>, 
+      # not <tt><%= %></tt>. Also worth noting is that the form_for yields a form_builder object, in this example as f, which emulates
+      # the API for the stand-alone FormHelper methods, but without the object name. So instead of <tt>text_field :person, :name</tt>,
+      # you get away with <tt>f.text_field :name</tt>. 
+      #
+      # That in itself is a modest increase in comfort. The big news is that form_for allows us to more easily escape the instance
+      # variable convention, so while the stand-alone approach would require <tt>text_field :person, :name, :object => person</tt> 
+      # to work with local variables instead of instance ones, the form_for calls remain the same. You simply declare once with 
+      # <tt>:person, person</tt> and all subsequent field calls save <tt>:person</tt> and <tt>:object => person</tt>.
+      #
+      # Also note that form_for doesn't create an exclusive scope. It's still possible to use both the stand-alone FormHelper methods
+      # and methods from FormTagHelper. Example:
+      #
+      #   <% form_for :person, @person, :url => { :action => "update" } do |f| %>
+      #     First name: <%= f.text_field :first_name %>
+      #     Last name : <%= f.text_field :last_name %>
+      #     Biography : <%= text_area :person, :biography %>
+      #     Admin?    : <%= check_box_tag "person[admin]", @person.company.admin? %>
+      #   <% end %>
+      #
+      # Note: This also works for the methods in FormOptionHelper and DateHelper that are designed to work with an object as base.
+      # Like collection_select and datetime_select.
+      #
+      # Html attributes for the form tag can be given as :html => {...}. Example:
+      #     
+      #   <% form_for :person, @person, :html => {:id => 'person_form'} do |f| %>
+      #     ...
+      #   <% end %>
+      #
+      # You can also build forms using a customized FormBuilder class. Subclass FormBuilder and override or define some more helpers,
+      # then use your custom builder like so:
+      #   
+      #   <% form_for :person, @person, :url => { :action => "update" }, :builder => LabellingFormBuilder do |f| %>
+      #     <%= f.text_field :first_name %>
+      #     <%= f.text_field :last_name %>
+      #     <%= text_area :person, :biography %>
+      #     <%= check_box_tag "person[admin]", @person.company.admin? %>
+      #   <% end %>
+      # 
+      # In many cases you will want to wrap the above in another helper, such as:
+      #
+      #   def labelled_form_for(name, object, options, &proc)
+      #     form_for(name, object, options.merge(:builder => LabellingFormBuiler), &proc)
+      #   end
+      #
+      def form_for(object_name, *args, &proc)
+        raise ArgumentError, "Missing block" unless block_given?
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        concat(form_tag(options.delete(:url) || {}, options.delete(:html) || {}), proc.binding)
+        fields_for(object_name, *(args << options), &proc)
+        concat('</form>', proc.binding)
+      end
+
+      # Creates a scope around a specific model object like form_for, but doesn't create the form tags themselves. This makes
+      # fields_for suitable for specifying additional model objects in the same form. Example:
+      #
+      #   <% form_for :person, @person, :url => { :action => "update" } do |person_form| %>
+      #     First name: <%= person_form.text_field :first_name %>
+      #     Last name : <%= person_form.text_field :last_name %>
+      #     
+      #     <% fields_for :permission, @person.permission do |permission_fields| %>
+      #       Admin?  : <%= permission_fields.check_box :admin %>
+      #     <% end %>
+      #   <% end %>
+      #
+      # Note: This also works for the methods in FormOptionHelper and DateHelper that are designed to work with an object as base.
+      # Like collection_select and datetime_select.
+      def fields_for(object_name, *args, &proc)
+        raise ArgumentError, "Missing block" unless block_given?
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        object  = args.first
+        yield((options[:builder] || FormBuilder).new(object_name, object, self, options, proc))
+      end
+
       # Returns an input tag of the "text" type tailored for accessing a specified attribute (identified by +method+) on an object
       # assigned to the template (identified by +object+). Additional options on the input tag can be passed as a
       # hash with +options+.
@@ -72,23 +156,23 @@ module ActionView
       # Examples (call, result):
       #   text_field("post", "title", "size" => 20)
       #     <input type="text" id="post_title" name="post[title]" size="20" value="#{@post.title}" />
-      def text_field(object, method, options = {})
-        InstanceTag.new(object, method, self).to_input_field_tag("text", options)
+      def text_field(object_name, method, options = {})
+        InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_input_field_tag("text", options)
       end
 
       # Works just like text_field, but returns an input tag of the "password" type instead.
-      def password_field(object, method, options = {})
-        InstanceTag.new(object, method, self).to_input_field_tag("password", options)
+      def password_field(object_name, method, options = {})
+        InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_input_field_tag("password", options)
       end
 
       # Works just like text_field, but returns an input tag of the "hidden" type instead.
-      def hidden_field(object, method, options = {})
-        InstanceTag.new(object, method, self).to_input_field_tag("hidden", options)
+      def hidden_field(object_name, method, options = {})
+        InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_input_field_tag("hidden", options)
       end
 
       # Works just like text_field, but returns an input tag of the "file" type instead, which won't have a default value.
-      def file_field(object, method, options = {})
-        InstanceTag.new(object, method, self).to_input_field_tag("file", options)
+      def file_field(object_name, method, options = {})
+        InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_input_field_tag("file", options)
       end
 
       # Returns a textarea opening and closing tag set tailored for accessing a specified attribute (identified by +method+)
@@ -100,8 +184,8 @@ module ActionView
       #     <textarea cols="20" rows="40" id="post_body" name="post[body]">
       #       #{@post.body}
       #     </textarea>
-      def text_area(object, method, options = {})
-        InstanceTag.new(object, method, self).to_text_area_tag(options)
+      def text_area(object_name, method, options = {})
+        InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_text_area_tag(options)
       end
 
       # Returns a checkbox tag tailored for accessing a specified attribute (identified by +method+) on an object
@@ -120,8 +204,8 @@ module ActionView
       #   check_box("puppy", "gooddog", {}, "yes", "no")
       #     <input type="checkbox" id="puppy_gooddog" name="puppy[gooddog]" value="yes" />
       #     <input name="puppy[gooddog]" type="hidden" value="no" />
-      def check_box(object, method, options = {}, checked_value = "1", unchecked_value = "0")
-        InstanceTag.new(object, method, self).to_check_box_tag(options, checked_value, unchecked_value)
+      def check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0")
+        InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_check_box_tag(options, checked_value, unchecked_value)
       end
 
       # Returns a radio button tag for accessing a specified attribute (identified by +method+) on an object
@@ -134,8 +218,8 @@ module ActionView
       #     <input type="radio" id="post_category" name="post[category]" value="rails" checked="checked" />
       #     <input type="radio" id="post_category" name="post[category]" value="java" />
       #
-      def radio_button(object, method, tag_value, options = {})
-        InstanceTag.new(object, method, self).to_radio_button_tag(tag_value, options)
+      def radio_button(object_name, method, tag_value, options = {})
+        InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_radio_button_tag(tag_value, options)
       end
     end
 
@@ -149,9 +233,10 @@ module ActionView
       DEFAULT_TEXT_AREA_OPTIONS = { "cols" => 40, "rows" => 20 }.freeze unless const_defined?(:DEFAULT_TEXT_AREA_OPTIONS)
       DEFAULT_DATE_OPTIONS = { :discard_type => true }.freeze unless const_defined?(:DEFAULT_DATE_OPTIONS)
 
-      def initialize(object_name, method_name, template_object, local_binding = nil)
-        @object_name, @method_name = object_name.to_s, method_name.to_s
+      def initialize(object_name, method_name, template_object, local_binding = nil, object = nil)
+        @object_name, @method_name = object_name.to_s.dup, method_name.to_s.dup
         @template_object, @local_binding = template_object, local_binding
+        @object = object
         if @object_name.sub!(/\[\]$/,"")
           @auto_index = @template_object.instance_variable_get("@#{Regexp.last_match.pre_match}").id_before_type_cast
         end
@@ -186,7 +271,7 @@ module ActionView
       def to_text_area_tag(options = {})
         options = DEFAULT_TEXT_AREA_OPTIONS.merge(options.stringify_keys)
         add_default_name_and_id(options)
-        content_tag("textarea", html_escape(value_before_type_cast), options)
+        content_tag("textarea", html_escape(options.delete('value') || value_before_type_cast), options)
       end
 
       def to_check_box_tag(options = {}, checked_value = "1", unchecked_value = "0")
@@ -240,11 +325,13 @@ module ActionView
       end
       
       def object
-        @template_object.instance_variable_get "@#{@object_name}"
+        @object || @template_object.instance_variable_get("@#{@object_name}")
       end
 
       def value
-        object.send(@method_name) unless object.nil?
+        unless object.nil?
+          object.send(@method_name)
+        end
       end
 
       def value_before_type_cast
@@ -286,5 +373,34 @@ module ActionView
           "#{@object_name}_#{index}_#{@method_name}"
         end
     end
+
+    class FormBuilder #:nodoc:
+      # The methods which wrap a form helper call.
+      class_inheritable_accessor :field_helpers
+      self.field_helpers = (FormHelper.instance_methods - ['form_for'])
+
+      attr_accessor :object_name, :object
+
+      def initialize(object_name, object, template, options, proc)
+        @object_name, @object, @template, @options, @proc = object_name, object, template, options, proc        
+      end
+      
+      (field_helpers - %w(check_box radio_button)).each do |selector|
+        src = <<-end_src
+          def #{selector}(method, options = {})
+            @template.send(#{selector.inspect}, @object_name, method, options.merge(:object => @object))
+          end
+        end_src
+        class_eval src, __FILE__, __LINE__
+      end
+      
+      def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+        @template.check_box(@object_name, method, options.merge(:object => @object), checked_value, unchecked_value)
+      end
+      
+      def radio_button(method, tag_value, options = {})
+        @template.radio_button(@object_name, method, tag_value, options.merge(:object => @object))
+      end
+    end
   end
 end

data/lib/action_view/helpers/form_options_helper.rb

@@ -47,7 +47,7 @@ module ActionView
       #
       # could become:
       #
-      #   <select name="post[person_id">
+      #   <select name="post[person_id]">
       #     <option></option>
       #     <option value="1" selected="selected">David</option>
       #     <option value="2">Sam</option>
@@ -59,18 +59,21 @@ module ActionView
       # to the database. Instead, a second model object is created when the create request is received.
       # This allows the user to submit a form page more than once with the expected results of creating multiple records.
       # In addition, this allows a single partial to be used to generate form inputs for both edit and create forms.
+      #
+      # By default, post.person_id is the selected option.  Specify :selected => value to use a different selection
+      # or :selected => nil to leave all options unselected.
       def select(object, method, choices, options = {}, html_options = {})
-        InstanceTag.new(object, method, self).to_select_tag(choices, options, html_options)
+        InstanceTag.new(object, method, self, nil, options.delete(:object)).to_select_tag(choices, options, html_options)
       end
 
       # Return select and option tags for the given object and method using options_from_collection_for_select to generate the list of option tags.
       def collection_select(object, method, collection, value_method, text_method, options = {}, html_options = {})
-        InstanceTag.new(object, method, self).to_collection_select_tag(collection, value_method, text_method, options, html_options)
+        InstanceTag.new(object, method, self, nil, options.delete(:object)).to_collection_select_tag(collection, value_method, text_method, options, html_options)
       end
 
       # Return select and option tags for the given object and method, using country_options_for_select to generate the list of option tags.
       def country_select(object, method, priority_countries = nil, options = {}, html_options = {})
-        InstanceTag.new(object, method, self).to_country_select_tag(priority_countries, options, html_options)
+        InstanceTag.new(object, method, self, nil, options.delete(:object)).to_country_select_tag(priority_countries, options, html_options)
       end
 
       # Return select and option tags for the given object and method, using
@@ -82,7 +85,7 @@ module ActionView
       # zone model object. (See #time_zone_options_for_select for more
       # information.)
       def time_zone_select(object, method, priority_zones = nil, options = {}, html_options = {})
-        InstanceTag.new(object, method, self).to_time_zone_select_tag(priority_zones, options, html_options)
+        InstanceTag.new(object, method, self, nil, options.delete(:object)).to_time_zone_select_tag(priority_zones, options, html_options)
       end
 
       # Accepts a container (hash, array, enumerable, your type) and returns a string of option tags. Given a container
@@ -209,7 +212,7 @@ module ActionView
       end
 
       # Returns a string of option tags for pretty much any time zone in the
-      # world. Supply a TimeZone object as +selected+ to have it marked as the
+      # world. Supply a TimeZone name as +selected+ to have it marked as the
       # selected option tag. You can also supply an array of TimeZone objects
       # as +priority_zones+, so that they will be listed above the rest of the
       # (long) list. (You can use TimeZone.us_zones as a convenience for
@@ -296,7 +299,8 @@ module ActionView
       def to_select_tag(choices, options, html_options)
         html_options = html_options.stringify_keys
         add_default_name_and_id(html_options)
-        content_tag("select", add_options(options_for_select(choices, value), options, value), html_options)
+        selected_value = options.has_key?(:selected) ? options[:selected] : value
+        content_tag("select", add_options(options_for_select(choices, selected_value), options, value), html_options)
       end
 
       def to_collection_select_tag(collection, value_method, text_method, options, html_options)
@@ -335,5 +339,23 @@ module ActionView
           end
         end
     end
+
+    class FormBuilder
+      def select(method, choices, options = {}, html_options = {})
+        @template.select(@object_name, method, choices, options.merge(:object => @object), html_options)
+      end
+
+      def collection_select(method, collection, value_method, text_method, options = {}, html_options = {})
+        @template.collection_select(@object_name, method, collection, value_method, text_method, options.merge(:object => @object), html_options)
+      end
+
+      def country_select(method, priority_countries = nil, options = {}, html_options = {})
+        @template.country_select(@object_name, method, priority_countries, options.merge(:object => @object), html_options)
+      end
+
+      def time_zone_select(method, priority_zones = nil, options = {}, html_options = {})
+        @template.time_zone_select(@object_name, method, priority_zones, options.merge(:object => @object), html_options)
+      end
+    end
   end
 end