actionpack 1.2.0 → 1.3.0

data/lib/action_controller/templates/rescues/_request_and_response.rhtml

@@ -1,10 +1,13 @@
 <% if defined?(Breakpoint) %>
   <br /><br />
-  <%= form_tag({}, "method" => @request.method) %>
+  <%= form_tag({:params => {}, :only_path => true}, "method" => @request.method) %>
     <input type="hidden" name="BP-RETRY" value="1" />
-
-    <% for key, value in @request.params %>
-      <input type="hidden" name="<%= key %>" value="<%= value %>" />
+  
+    <% for key, values in @params %>
+      <% next if key == "BP-RETRY" %>
+      <% for value in Array(values) %>
+        <input type="hidden" name="<%= key %>" value="<%= value %>" />
+      <% end %>
     <% end %>
 
     <input type="submit" value="Retry with Breakpoint" />

data/lib/action_controller/test_process.rb

@@ -182,6 +182,15 @@ module ActionController #:nodoc:
     def has_template_object?(name=nil)
       !template_objects[name].nil?      
     end
+    
+    # Returns the response cookies, converted to a Hash of (name => CGI::Cookie) pairs
+    # Example:
+    # 
+    # assert_equal ['AuthorOfNewPage'], r.cookies['author'].value
+    def cookies
+      headers['cookie'].inject({}) { |hash, cookie| hash[cookie.name] = cookie; hash }
+    end
+
 end
 
   class TestSession #:nodoc:

data/lib/action_controller/url_rewriter.rb

@@ -49,7 +49,7 @@ module ActionController
 
       def rewrite_path(path, options)
         include_id_in_path_params(options)
-      
+
         path = rewrite_action(path, options)      if options[:action] || options[:action_prefix]
         path = rewrite_path_params(path, options) if options[:path_params]
         path = rewrite_controller(path, options)  if options[:controller] || options[:controller_prefix]
@@ -86,12 +86,15 @@ module ActionController
             # don't tell action_name about our little boo-boo
             path = path.sub(action_prefix, action_name(options, nil))
           elsif action_prefix && !action_prefix.empty?
-            path = path.sub(action_prefix, action_name(options, action_prefix))
+            path = path.sub(%r(/#{action_prefix}/?), "/" + action_name(options, action_prefix))
           else
-            path = path.sub(%r(#{@controller}/?), @controller + "/" + action_name(options)) # " ruby-mode
+            path = path.sub(%r(#{@controller}/?$), @controller + "/" + action_name(options)) # " ruby-mode
           end
         else
-          path = path.sub(@controller + "/" + (action_prefix || "") + @action + (action_suffix || ""), @controller + "/" + action_name(options, action_prefix))
+          path = path.sub(
+            @controller + "/" + (action_prefix || "") + @action + (action_suffix || ""), 
+            @controller + "/" + action_name(options, action_prefix)
+          )
         end
 
         if options[:controller_prefix] && !options[:controller]
@@ -171,7 +174,12 @@ module ActionController
         elements = []
         query_string = ""
 
-        hash.each { |key, value| elements << "#{CGI.escape(key)}=#{CGI.escape(value.to_s)}" }
+        hash.each do |key, value|
+	  key = CGI.escape key
+	  key += '[]' if value.class == Array
+	  value = [ value ] unless value.class == Array
+	  value.each { |val| elements << "#{key}=#{CGI.escape(val.to_s)}" }
+	end
         unless elements.empty? then query_string << ("?" + elements.join("&")) end
         
         return query_string

data/lib/action_view/helpers/active_record_helper.rb

@@ -49,6 +49,13 @@ module ActionView
       #       <input id="post_title" name="post[title]" size="30" type="text" value="Hello World" /><br />
       #       <input type='submit' value='Sign' />
       #     </form>
+      #
+      # It's also possible to add additional content to the form by giving it a block, such as:
+      #
+      #   form("entry", :action => "sign") do |form|
+      #     form << content_tag("b", "Department")
+      #     form << collection_select("department", "id", @departments, "id", "name")
+      #   end
       def form(record_name, options = {})
         record   = instance_eval("@#{record_name}")
 
@@ -59,9 +66,9 @@ module ActionView
         
         id_field = record.new_record? ? "" : InstanceTag.new(record_name, "id", self).to_input_field_tag("hidden")
         
-        %(<form action="#{action}" method="post">#{id_field}) +
-          all_input_tags(record, record_name, options) +
-          %(<input type="submit" value="#{submit_value}" /></form>)
+        formtag = %(<form action="#{action}" method="post">#{id_field}) + all_input_tags(record, record_name, options)
+        yield formtag if block_given?
+        formtag +  %(<input type="submit" value="#{submit_value}" /></form>)
       end
 
       # Returns a string containing the error message attached to the +method+ on the +object+, if one exists.

data/lib/action_view/helpers/cache_helper.rb

@@ -0,0 +1,10 @@
+module ActionView
+  module Helpers
+    # See ActionController::Caching::Fragments for usage instructions.
+    module CacheHelper
+      def cache(binding, name = {})
+        @controller.cache_erb_fragment(binding, name) { yield }
+      end
+    end
+  end
+end

data/lib/action_view/helpers/form_helper.rb

@@ -45,6 +45,15 @@ module ActionView
     #     <input type="submit" value="Save">
     #   </form>    
     #
+    # If the helper is being used to generate a repetitive sequence of similar form elements, for example in a partial
+    # used by render_collection_of_partials, the "index" option may come in handy. Example:
+    #
+    #   <%= text_field "person", "name", "index" => 1 %>
+    #
+    # becomes
+    # 
+    #   <input type="text" id="person_1_name" name="person[1][name]" value="<%= @person.name %>" />
+    #
     # 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
@@ -201,17 +210,31 @@ module ActionView
 
       private
         def add_default_name_and_id(options)
-          options['name'] = tag_name unless options.has_key? "name"
-          options['id'] = tag_id unless options.has_key? "id"
+          if options.has_key? "index"
+            options['name'] = tag_name_with_index(options["index"]) unless options.has_key? "name"
+            options['id'] = tag_id_with_index(options["index"]) unless options.has_key? "id"
+            options.delete("index")
+          else
+            options['name'] = tag_name unless options.has_key? "name"
+            options['id'] = tag_id unless options.has_key? "id"
+          end
         end
 				
         def tag_name
           "#{@object_name}[#{@method_name}]"
         end
+				
+        def tag_name_with_index(index)
+          "#{@object_name}[#{index}][#{@method_name}]"
+        end
 
         def tag_id
           "#{@object_name}_#{@method_name}"
         end
+
+        def tag_id_with_index(index)
+          "#{@object_name}_#{index}_#{@method_name}"
+        end
     end
   end
 end

data/lib/action_view/helpers/form_options_helper.rb

@@ -4,8 +4,7 @@ require File.dirname(__FILE__) + '/form_helper'
 
 module ActionView
   module Helpers
-    # Provides a number of methods for turning different kinds of containers into a set of option tags. Neither of the methods provide
-    # the actual select tag, so you'll need to construct that in HTML manually.
+    # Provides a number of methods for turning different kinds of containers into a set of option tags.
     module FormOptionsHelper
       include ERB::Util
 

data/lib/action_view/helpers/url_helper.rb

@@ -13,15 +13,18 @@ module ActionView
 
       # Creates a link tag of the given +name+ using an URL created by the set of +options+. See the valid options in
       # link:classes/ActionController/Base.html#M000021. It's also possible to pass a string instead of an options hash to
-      # get a link tag that just points without consideration. The html_options have a special feature for creating javascript
-      # confirm alerts where if you pass :confirm => 'Are you sure?', the link will be guarded with a JS popup asking that question.
-      # If the user accepts, the link is processed, otherwise not.
+      # get a link tag that just points without consideration. If nil is passed as a name, the link itself will become the name. 
+      # The html_options have a special feature for creating javascript confirm alerts where if you pass :confirm => 'Are you sure?', 
+      # the link will be guarded with a JS popup asking that question. If the user accepts, the link is processed, otherwise not.
       def link_to(name, options = {}, html_options = {}, *parameters_for_method_reference)
         convert_confirm_option_to_javascript!(html_options) unless html_options.nil?
         if options.is_a?(String)
-          content_tag "a", name, (html_options || {}).merge({ "href" => options })
+          content_tag "a", name || options, (html_options || {}).merge({ "href" => options })
         else
-          content_tag("a", name, (html_options || {}).merge({ "href" => url_for(options, *parameters_for_method_reference) }))
+          content_tag(
+            "a", name || url_for(options, *parameters_for_method_reference), 
+            (html_options || {}).merge({ "href" => url_for(options, *parameters_for_method_reference) })
+          )
         end
       end
 

data/lib/action_view/partials.rb

@@ -39,11 +39,11 @@ module ActionView
       render("#{path}/_#{partial_name}", { partial_name => object }.merge(local_assigns))
     end
 
-    def render_collection_of_partials(partial_name, collection, partial_spacer_template = nil)
+    def render_collection_of_partials(partial_name, collection, partial_spacer_template = nil, local_assigns = {})
       collection_of_partials = Array.new
       counter_name = partial_counter_name(partial_name)
       collection.each_with_index do |element, counter|
-        collection_of_partials.push(render_partial(partial_name, element, counter_name => counter))
+        collection_of_partials.push(render_partial(partial_name, element, { counter_name => counter }.merge(local_assigns)))
       end
 
       return nil if collection_of_partials.empty?

data/rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'actionpack'
-PKG_VERSION   = '1.2.0' + PKG_BUILD
+PKG_VERSION   = '1.3.0' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 desc "Default Task"
@@ -18,7 +18,10 @@ task :default => [ :test ]
 
 Rake::TestTask.new { |t|
   t.libs << "test"
-  t.pattern = 'test/*/*_test.rb'
+# make sure we include the controller tests (c*) first as on some systems
+# this will not happen automatically and the tests (as a whole) will error
+  t.test_files=Dir.glob( "test/c*/*_test.rb" ) + Dir.glob( "test/[ft]*/*_test.rb" )
+#  t.pattern = 'test/*/*_test.rb'
   t.verbose = true
 }
 
@@ -102,4 +105,4 @@ task :lines do
     end
   }
   puts "Lines #{lines}, LOC #{codelines}"
-end
+end

data/test/controller/filters_test.rb

@@ -15,6 +15,74 @@ class FilterTest < Test::Unit::TestCase
       end
   end
   
+  class ConditionalFilterController < ActionController::Base
+    def show
+      render_text "ran action"
+    end
+
+    def another_action
+      render_text "ran action"
+    end
+
+    def show_without_filter
+      render_text "ran action without filter"
+    end
+
+    private
+      def ensure_login
+        @ran_filter ||= []
+        @ran_filter << "ensure_login"
+      end
+
+      def clean_up_tmp
+        @ran_filter ||= []
+        @ran_filter << "clean_up_tmp"
+      end
+      
+      def rescue_action(e) raise(e) end
+  end
+
+  class ConditionalCollectionFilterController < ConditionalFilterController
+    before_filter :ensure_login, :except => [ :show_without_filter, :another_action ]
+  end
+
+  class OnlyConditionSymController < ConditionalFilterController 
+    before_filter :ensure_login, :only => :show
+  end
+
+  class ExceptConditionSymController < ConditionalFilterController
+    before_filter :ensure_login, :except => :show_without_filter
+  end
+
+  class BeforeAndAfterConditionController < ConditionalFilterController
+    before_filter :ensure_login, :only => :show
+    after_filter  :clean_up_tmp, :only => :show 
+  end
+  
+  class OnlyConditionProcController < ConditionalFilterController 
+    before_filter(:only => :show) {|c| c.assigns["ran_proc_filter"] = true }
+  end
+
+  class ExceptConditionProcController < ConditionalFilterController
+    before_filter(:except => :show_without_filter) {|c| c.assigns["ran_proc_filter"] = true }
+  end
+
+  class ConditionalClassFilter
+    def self.filter(controller) controller.assigns["ran_class_filter"] = true end
+  end
+
+  class OnlyConditionClassController < ConditionalFilterController
+    before_filter ConditionalClassFilter, :only => :show
+  end
+
+  class ExceptConditionClassController < ConditionalFilterController
+    before_filter ConditionalClassFilter, :except => :show_without_filter
+  end
+
+  class AnomolousYetValidConditionController < ConditionalFilterController
+    before_filter(ConditionalClassFilter, :ensure_login, Proc.new {|c| c.assigns["ran_proc_filter1"] = true }, :except => :show_without_filter) { |c| c.assigns["ran_proc_filter2"] = true}
+  end
+
   class PrependingController < TestController
     prepend_before_filter :wonderful_life
 
@@ -125,6 +193,53 @@ class FilterTest < Test::Unit::TestCase
   def test_running_filters_with_class
     assert test_process(AuditController).template.assigns["was_audited"]
   end
+
+  def test_running_anomolous_yet_valid_condition_filters
+    response = test_process(AnomolousYetValidConditionController)
+    assert_equal %w( ensure_login ), response.template.assigns["ran_filter"]
+    assert response.template.assigns["ran_class_filter"]
+    assert response.template.assigns["ran_proc_filter1"]
+    assert response.template.assigns["ran_proc_filter2"]
+    
+    response = test_process(AnomolousYetValidConditionController, "show_without_filter")
+    assert_equal nil, response.template.assigns["ran_filter"]
+    assert !response.template.assigns["ran_class_filter"]
+    assert !response.template.assigns["ran_proc_filter1"]
+    assert !response.template.assigns["ran_proc_filter2"]
+  end
+
+  def test_running_collection_condition_filters
+    assert_equal %w( ensure_login ), test_process(ConditionalCollectionFilterController).template.assigns["ran_filter"]
+    assert_equal nil, test_process(ConditionalCollectionFilterController, "show_without_filter").template.assigns["ran_filter"]
+    assert_equal nil, test_process(ConditionalCollectionFilterController, "another_action").template.assigns["ran_filter"]
+  end
+
+  def test_running_only_condition_filters
+    assert_equal %w( ensure_login ), test_process(OnlyConditionSymController).template.assigns["ran_filter"]
+    assert_equal nil, test_process(OnlyConditionSymController, "show_without_filter").template.assigns["ran_filter"]
+
+    assert test_process(OnlyConditionProcController).template.assigns["ran_proc_filter"]
+    assert !test_process(OnlyConditionProcController, "show_without_filter").template.assigns["ran_proc_filter"]
+
+    assert test_process(OnlyConditionClassController).template.assigns["ran_class_filter"]
+    assert !test_process(OnlyConditionClassController, "show_without_filter").template.assigns["ran_class_filter"]
+  end
+
+  def test_running_except_condition_filters
+    assert_equal %w( ensure_login ), test_process(ExceptConditionSymController).template.assigns["ran_filter"]
+    assert_equal nil, test_process(ExceptConditionSymController, "show_without_filter").template.assigns["ran_filter"]
+
+    assert test_process(ExceptConditionProcController).template.assigns["ran_proc_filter"]
+    assert !test_process(ExceptConditionProcController, "show_without_filter").template.assigns["ran_proc_filter"]
+
+    assert test_process(ExceptConditionClassController).template.assigns["ran_class_filter"]
+    assert !test_process(ExceptConditionClassController, "show_without_filter").template.assigns["ran_class_filter"]
+  end
+
+  def test_running_before_and_after_condition_filters
+    assert_equal %w( ensure_login clean_up_tmp), test_process(BeforeAndAfterConditionController).template.assigns["ran_filter"]
+    assert_equal nil, test_process(BeforeAndAfterConditionController, "show_without_filter").template.assigns["ran_filter"]
+  end
   
   def test_bad_filter
     assert_raises(ActionController::ActionControllerError) { 
@@ -151,9 +266,9 @@ class FilterTest < Test::Unit::TestCase
   end
 
   private
-    def test_process(controller)
+    def test_process(controller, action = "show")
       request = ActionController::TestRequest.new
-      request.action = "show"
+      request.action = action
       controller.process(request, ActionController::TestResponse.new)
     end
-end
+end

data/test/controller/render_test.rb

@@ -126,6 +126,11 @@ class RenderTest < Test::Unit::TestCase
     assert_raises(ActionController::UnknownAction, "No action responded to [clone]") { process_request }
   end
 
+  def test_private_methods
+    @request.action = "determine_layout"
+    assert_raises(ActionController::UnknownAction, "No action responded to [determine_layout]") { process_request }
+  end
+
   def test_access_to_request_in_view
     ActionController::Base.view_controller_internals = false
 

data/test/controller/send_file_test.rb

@@ -65,4 +65,28 @@ class SendFileTest < Test::Unit::TestCase
     assert_kind_of String, response.body
     assert_equal file_data, response.body
   end
+
+  # Test that send_file_headers! is setting the correct HTTP headers.
+  def test_send_file_headers!
+    options = {
+      :length => 1,
+      :type => 'type',
+      :disposition => 'disposition',
+      :filename => 'filename'
+    }
+
+    # Do it a few times: the resulting headers should be identical
+    # no matter how many times you send with the same options.
+    # Test resolving Ticket #458.
+    @controller.headers = {}
+    @controller.send(:send_file_headers!, options)
+    @controller.send(:send_file_headers!, options)
+    @controller.send(:send_file_headers!, options)
+
+    h = @controller.headers
+    assert_equal 1, h['Content-Length']
+    assert_equal 'type', h['Content-Type']
+    assert_equal 'disposition; filename="filename"', h['Content-Disposition']
+    assert_equal 'binary', h['Content-Transfer-Encoding']
+  end
 end

data/test/controller/url_test.rb

@@ -12,6 +12,15 @@ class MockRequest
   end
 end
 
+class UrlMockFactory
+  def self.create(path, parameters)
+    ActionController::UrlRewriter.new(
+      MockRequest.new("http://", "example.com", 80, path, parameters), 
+      parameters["controller"], parameters["action"]
+    )
+  end
+end
+
 class UrlTest < Test::Unit::TestCase
   def setup
     @library_url = ActionController::UrlRewriter.new(MockRequest.new(
@@ -191,7 +200,6 @@ class UrlTest < Test::Unit::TestCase
     assert_equal "http://www.singlefile.com/login/logout", @clean_url_with_same_action_and_controller_name.rewrite(:action => "logout")
   end
 
-  # FIXME
   def xtest_same_module_and_controller_and_action_names
     assert_equal "http://www.singlefile.com/login/login/logout", @clean_url_with_same_action_and_controller_and_module_name.rewrite(:action => "logout")
   end
@@ -238,7 +246,18 @@ class UrlTest < Test::Unit::TestCase
       )
     end
   end
-  
+
+  def test_parameters_with_array
+    @clean_urls.each do |url|
+      assert_equal(
+        "http://www.singlefile.com/identity/show?id[]=3&id[]=5&id[]=10",
+	url.rewrite(
+		:action => "show",
+		:params => { 'id' => [ 3, 5, 10 ] } )
+      )
+    end
+  end
+
   def test_action_with_id
    assert_equal(
       "http://www.singlefile.com/identity/show/7", 
@@ -408,4 +427,30 @@ class UrlTest < Test::Unit::TestCase
     assert_equal("http://example.com/controller/foo", url.rewrite(:action => 'foo'))
   end
 
+  def test_rewriting_on_similar_fragments
+    url = UrlMockFactory.create("/advertisements/advert/", {"controller"=>"advert", "action"=>"index"})
+    assert_equal("http://example.com/advertisements/advert/news", url.rewrite(:action => 'news'))
+  end
+
+  def test_rewriting_on_similar_fragments_with_action_prefixes
+    url = UrlMockFactory.create(
+      "/clients/prall/1/msg/all/", 
+      { "category_name"=>"all", "client_name"=>"prall", "action"=>"index", "controller"=>"msg", "project_name"=>"1"}
+    )
+
+    assert_equal(
+      "http://example.com/clients/prall/1/msg/all/new", 
+      url.rewrite({ :controller => "msg", :action_prefix => "all", :action => "new" })
+    )
+
+    url = UrlMockFactory.create(
+      "/clients/prall/1/msg/all/", 
+      { "category_name"=>"all", "client_name"=>"prall", "action"=>"index", "controller"=>"msg", "project_name"=>"1"}
+    )
+
+    assert_equal(
+      "http://example.com/clients/prall/1/msg/allous/new", 
+      url.rewrite({ :controller => "msg", :action_prefix => "allous", :action => "new" })
+    )
+  end
 end