josevalim-inherited_resources 0.5.2 → 0.6.0

data/CHANGELOG

@@ -1,4 +1,11 @@
-# Version 0.5.2
+# Version 0.6
+
+* Cleaned up tests and responder structure. Whenever you pass a block to aliases
+  and this block responds to the request, the other blocks are not parsed improcing performance.
+* [BACKWARDS INCOMPATIBLE] By default, Inherited Resources respond only :html requests
+* Added a quick way to overwrite the redirect to url in :create, :update and :destroy
+
+# Version 0.5
 
 * Decoupled routes name from :instance_name and :collection_name. This way we
   have more flexibility. Use route_instance_name and route_collection_name to
@@ -6,7 +13,7 @@
 * Avoid calling human_name on nil when a resource class is not defined.
 * Only call I18n if it's defined.
 
-# Version 0.4.6-0
+# Version 0.4
 
 * Dealing with namespaced controllers out of the box.
 * Added support to namespaced routes through :route_prefix.
@@ -24,7 +31,7 @@
   categories/1/products/2 and /products/2 with just one controller.
 * Cleaned up tests.
 
-# Version 0.3.0
+# Version 0.3
 
 * Minor bump after three bug fixes.
 * Bug fix when showing warning of constant redefinition.
@@ -33,13 +40,13 @@
   raise "NoMethodError _url", not it will call root_url.
 * More comments on UrlHelpers.
 
-# Version 0.2.1-0
+# Version 0.2
 
 * Bug fix when ApplicationController is already loaded when we load respond_to.
 * Added support success/failure blocks.
 * Eager loading of files to work properly in multithreaded environments.
 
-# Version 0.1.2-0
+# Version 0.1
 
 * Added more helper_methods.
 * Added Rails 2.3.0 and changed tests to work with ActionController::TestCase.

data/README

@@ -1,10 +1,10 @@
 Inherited Resources
 License: MIT
-Version: 0.5.2
+Version: 0.6.0
 
 You can also read this README in pretty html at the GitHub project Wiki page:
 
-  http://github.com/josevalim/inherited_resources/wikis/home
+  http://wiki.github.com/josevalim/inherited_resources
 
 Description
 -----------
@@ -199,11 +199,21 @@ equivalent:
    class ProjectsController < InheritedResources::Base
      def destroy
        destroy! do |format|
-         format.html { redirect_to projects_url }
+         format.html { redirect_to root_url }
        end
      end
    end
 
+Even more, since most of the times that you change a :create, :update or :destroy
+action is because you want to to change to where it redirects, a shortcut is
+provided. So you can do:
+
+   class ProjectsController < InheritedResources::Base
+     def destroy
+       destroy!(root_url)
+     end
+   end
+
 Now let's suppose that before create a project you have to do something special
 but you don't want to create a before filter for it:
 

data/lib/inherited_resources/base.rb

@@ -54,7 +54,7 @@
 #   class ProjectController < InheritedResources::Base
 #     def destroy
 #       super do |format|
-#         format.html { redirect_to projects_url }
+#         format.html { redirect_to root_url }
 #       end
 #     end
 #   end
@@ -65,11 +65,21 @@
 #   class ProjectController < InheritedResources::Base
 #     def destroy
 #       destroy! do |format|
-#         format.html { redirect_to projects_url }
+#         format.html { redirect_to root_url }
 #       end
 #     end
 #   end
 #
+# Even more, since most of the times that you change a :create, :update or :destroy
+# action is because you want to to change to where it redirects, a shortcut is
+# provided. So you can do:
+#
+#   class ProjectsController < InheritedResources::Base
+#     def destroy
+#       destroy!(root_url)
+#     end
+#   end
+#
 # Since this is actually Ruby (and not a new DSL), if you want to do something
 # before creating the project that is to small to deserve a before_filter, you
 # could simply do:
@@ -231,22 +241,23 @@ module InheritedResources
       alias :edit! :edit
 
       # POST /resources
-      def create(&block)
+      def create(redirect_to=nil, &block)
         object = build_resource(params[resource_instance_name])
 
         if object.save
           set_flash_message!(:notice, '{{resource_name}} was successfully created.')
-          location_url = resource_url rescue nil # Sometimes resource_url is undefined
 
-          respond_to(:with => object, :status => :created, :location => location_url) do |format|
-            block.call(args_for_block(block, format, true)) if block_given?
-            format.html { redirect_to(resource_url) }
+          options = { :with => object, :status => :created, :location => (resource_url rescue nil) }
+
+          respond_to_with_dual_blocks(true, block, options) do |format|
+            format.html { redirect_to(redirect_to || resource_url) }
           end
         else
           set_flash_message!(:error)
 
-          respond_to(:with => object.errors, :status => :unprocessable_entity) do |format|
-            block.call(args_for_block(block, format, false)) if block_given?
+          options = { :with => object.errors, :status => :unprocessable_entity }
+
+          respond_to_with_dual_blocks(false, block, options) do |format|
             format.html { render :action => 'new' }
           end
         end
@@ -254,22 +265,22 @@ module InheritedResources
       alias :create! :create
 
       # PUT /resources/1
-      def update(&block)
+      def update(redirect_to=nil, &block)
         object = resource
 
         if object.update_attributes(params[resource_instance_name])
           set_flash_message!(:notice, '{{resource_name}} was successfully updated.')
 
-          respond_to do |format|
-            block.call(args_for_block(block, format, true)) if block_given?
-            format.html { redirect_to(resource_url) }
+          respond_to_with_dual_blocks(true, block) do |format|
+            format.html { redirect_to(redirect_to || resource_url) }
             format.all  { head :ok }
           end
         else
           set_flash_message!(:error)
 
-          respond_to(:with => object.errors, :status => :unprocessable_entity) do |format|
-            block.call(args_for_block(block, format, false)) if block_given?
+          options = { :with => object.errors, :status => :unprocessable_entity }
+
+          respond_to_with_dual_blocks(false, block, options) do |format|
             format.html { render :action => 'edit' }
           end
         end
@@ -277,14 +288,13 @@ module InheritedResources
       alias :update! :update
 
       # DELETE /resources/1
-      def destroy
+      def destroy(redirect_to=nil, &block)
         resource.destroy
 
         set_flash_message!(:notice, '{{resource_name}} was successfully destroyed.')
 
-        respond_to do |format|
-          yield(format) if block_given?
-          format.html { redirect_to(collection_url) }
+        respond_to_with_dual_blocks(nil, block) do |format|
+          format.html { redirect_to(redirect_to || collection_url) }
           format.all  { head :ok }
         end
       end

data/lib/inherited_resources/base_helpers.rb

@@ -226,17 +226,26 @@ module InheritedResources #:nodoc:
       #     end
       #   end
       #
-      def args_for_block(block_to_check_args, format, success = true)
-        if block_to_check_args.arity == 2
-          dumb_responder = InheritedResources::DumbResponder.new
-          if success
-            return format, dumb_responder
+      def respond_to_with_dual_blocks(success, dual_block, options={}, &block)
+        responder = ActionController::MimeResponds::Responder.new(self)
+
+        if dual_block
+          if dual_block.arity == 2
+            dumb_responder = InheritedResources::DumbResponder.new
+            if success
+              dual_block.call(responder, dumb_responder)
+            else
+              dual_block.call(dumb_responder, responder)
+            end
           else
-            return dumb_responder, format
+            dual_block.call(responder)
           end
-        else
-          return format
+
+          # Try to respond with the block given
+          responder.respond_except_any
         end
+
+        respond_to(options.merge(:responder => responder), &block) unless performed?
       end
 
   end

data/lib/inherited_resources/respond_to.rb

@@ -59,9 +59,8 @@ module ActionController #:nodoc:
       end
       class_inheritable_reader :formats_for_respond_to
 
-      # Define defaults respond_to
+      # By default, responds only to :html
       respond_to :html
-      respond_to :xml, :except => [ :edit ]
 
       # Method to clear all respond_to declared until the current controller.
       # This is like freeing the controller from the inheritance chain. :)
@@ -119,20 +118,12 @@ module ActionController #:nodoc:
       def respond_with(object, options = {})
         attempt_to_respond = false
 
-        # You can also send a responder object as parameter.
-        #
-        responder = options.delete(:responder) || Responder.new(self)
+        responder           = options.delete(:responder) || Responder.new(self)
+        skip_not_acceptable = options.delete(:skip_not_acceptable)
 
-        # Check for given mime types
-        #
         mime_types = Array(options.delete(:to))
         mime_types.map!{ |mime| mime.to_sym }
 
-        # If :skip_not_acceptable is sent, it will not render :not_acceptable
-        # if the mime type sent by the client cannot be found.
-        #
-        skip_not_acceptable = options.delete(:skip_not_acceptable)
-
         for priority in responder.mime_type_priority
           if priority == Mime::ALL && template_exists?
             render options.merge(:action => action_name)
@@ -206,58 +197,38 @@ module ActionController #:nodoc:
       #
       def respond_to(*types, &block)
         options = types.extract_options!
-        object = options.delete(:with)
-        responder = Responder.new(self)
-        
-        # This is the default respond_to behaviour, when no object is given.
+
+        object              = options.delete(:with)
+        responder           = options.delete(:responder) || Responder.new(self)
+
         if object.nil?
           block ||= lambda { |responder| types.each { |type| responder.send(type) } }
           block.call(responder)
           responder.respond
-          return true # we are done here
-
+          return true
         else
-          # If a block is given, it checks if we can perform the requested format.
-          #
           # Even if Mime::ALL is sent by the client, we do not respond_to it now.
-          # This is done using calling :respond_to_block instead of :respond.
-          #
-          # It's worth to remember that responder_to_block does not respond
-          # :not_acceptable also.
+          # This is done using calling :respond_except_any instead of :respond.
           #
           if block_given?
             block.call(responder)
-            responder.respond_to_block
-            return true if responder.responded? || performed?
+            return true if responder.respond_except_any
           end
 
-          # Let's see if we get lucky rendering with :respond_with.
-          # At the end, respond_with checks for Mime::ALL if any template exist.
-          #
-          # Notice that we are sending the responder (for performance gain) and
-          # sending :skip_not_acceptable because we don't want to respond
-          # :not_acceptable yet.
-          #
-          if respond_with(object, options.merge(:to => types, :responder => responder, :skip_not_acceptable => true))
-            return true
+          options.merge!(:to => types, :responder => responder, :skip_not_acceptable => true)
 
-          # Since respond_with couldn't help us, our last chance is to reply to
-          # any block given if the user send all as mime type.
-          #
+          if respond_with(object, options)
+            return true
           elsif block_given?
-            return true if responder.respond_to_all
+            return true if responder.respond_any
           end
         end
 
-        # If we get here it means that we could not satisfy our request.
-        # Now we finally return :not_acceptable.
-        #
         head :not_acceptable
         return false
       end
 
     private
-
       # Define template_exists? for Rails 2.3
       unless ActionController::Base.private_instance_methods.include?('template_exists?') ||
              ActionController::Base.private_instance_methods.include?(:template_exists?)
@@ -282,43 +253,35 @@ module ActionController #:nodoc:
   module MimeResponds #:nodoc:
     class Responder #:nodoc:
 
-      # Create an attr_reader for @mime_type_priority
       attr_reader :mime_type_priority
 
-      # Stores if this Responder instance called any block.
-      def responded?; @responded; end
-
-      # Similar as respond but if we can't find a valid mime type,
-      # we do not send :not_acceptable message as head.
+      # Similar as respond but if we can't find a valid mime type, we do not
+      # send :not_acceptable message as head and it does not respond to
+      # Mime::ALL in any case.
       #
-      # It does not respond to Mime::ALL in priority as well.
-      #
-      def respond_to_block
+      def respond_except_any
         for priority in @mime_type_priority
           next if priority == Mime::ALL
 
           if @responses[priority]
             @responses[priority].call
-            return (@responded = true) # mime type match found, be happy and return
+            return true
           end
         end
 
-        if @order.include?(Mime::ALL)
-          @responses[Mime::ALL].call
-          return (@responded = true)
-        else
-          return (@responded = false)
-        end
+        false
       end
 
       # Respond to the first format given if Mime::ALL is included in the
       # mime type priorites. This is the behaviour expected when the client
       # sends "*/*" as mime type.
       #
-      def respond_to_all
-        if @mime_type_priority.include?(Mime::ALL) && first = @responses[@order.first]
-          first.call
-          return (@responded = true)
+      def respond_any
+        any = @responses[@order.include?(Mime::ALL) ? Mime::ALL : @order.first]
+
+        if any && @mime_type_priority.include?(Mime::ALL)
+          any.call
+          return true
         end
       end
 

data/test/aliases_test.rb

@@ -1,5 +1,3 @@
-# Now we are going to test aliases defined in base.rb and if overwriting
-# methods works properly.
 require File.dirname(__FILE__) + '/test_helper'
 
 class Student;
@@ -40,13 +38,8 @@ class StudentsController < InheritedResources::Base
 
 end
 
-class AliasesBaseTest < TEST_CLASS
-
-  def setup
-    @controller          = StudentsController.new
-    @controller.request  = @request  = ActionController::TestRequest.new
-    @controller.response = @response = ActionController::TestResponse.new
-  end
+class AliasesTest < ActionController::TestCase
+  tests StudentsController
 
   def test_assignments_before_calling_alias
     Student.stubs(:new).returns(mock_student)
@@ -92,7 +85,7 @@ class AliasesBaseTest < TEST_CLASS
     assert_equal "I won't redirect!", @response.body
   end
 
-  def test_dumb_responder_with_quietly_receive_everything_on_failure
+  def test_dumb_responder_quietly_receives_everything_on_failure
     Student.stubs(:new).returns(mock_student(:save => false, :errors => []))
     @controller.stubs(:resource_url).returns('http://test.host/')
     post :create
@@ -107,8 +100,9 @@ class AliasesBaseTest < TEST_CLASS
     assert_equal "I won't render!", @response.body
   end
 
-  def test_dumb_responder_with_quietly_receive_everything_on_success
+  def test_dumb_responder_quietly_receives_everything_on_success
     Student.stubs(:find).returns(mock_student(:update_attributes => true))
+    @controller.stubs(:resource_url).returns('http://test.host/')
     put :update, :id => '42', :student => {:these => 'params'}
     assert_equal mock_student, assigns(:student)
   end

data/test/base_helpers_test.rb

@@ -19,12 +19,10 @@ class Admin::AddressesController < InheritedResources::Base
     end
 end
 
-class FlashBaseHelpersTest < TEST_CLASS
+class FlashBaseHelpersTest < ActionController::TestCase
+  tests AddressesController
 
   def setup
-    @controller          = AddressesController.new
-    @controller.request  = @request  = ActionController::TestRequest.new
-    @controller.response = @response = ActionController::TestResponse.new
     @request.accept      = 'application/xml'
   end
 
@@ -90,6 +88,7 @@ class Pet
 end
 
 class PetsController < InheritedResources::Base
+  respond_to :xml
   attr_accessor :current_user
   
   def edit
@@ -107,12 +106,10 @@ class PetsController < InheritedResources::Base
     end
 end
 
-class AssociationChainBaseHelpersTest < TEST_CLASS
+class AssociationChainBaseHelpersTest < ActionController::TestCase
+  tests PetsController
 
   def setup
-    @controller              = PetsController.new
-    @controller.request      = @request  = ActionController::TestRequest.new
-    @controller.response     = @response = ActionController::TestResponse.new
     @controller.current_user = mock()
     @request.accept          = 'application/xml'
   end