josevalim-inherited_resources 0.1

data/lib/inherited_resources/singleton_helpers.rb

@@ -0,0 +1,53 @@
+module InheritedResources #:nodoc:
+  module SingletonHelpers #:nodoc:
+
+    # Protected helpers. You might want to overwrite some of them.
+    protected
+      # Singleton methods does not deal with collections.
+      #
+      def collection
+        nil
+      end
+
+      # Overwrites how singleton deals with resource.
+      # If you are going to overwrite it, you should notice that the
+      # end_of_association_chain here is not the same as in default belongs_to.
+      #
+      #   class TasksController < InheritedResources::Base
+      #     belongs_to :project
+      #   end
+      #
+      # In this case, the association chain would be:
+      #
+      #   Project.find(params[:project_id]).tasks
+      #
+      # So you would just have to call find(:all) at the end of association
+      # chain. And this is what happened.
+      #
+      # In singleton controllers:
+      #
+      #   class ManagersController < InheritedResources::Base
+      #     belongs_to :project, :singleton => true
+      #   end
+      #
+      # The association chain will be:
+      #
+      #   Project.find(params[:project_id])
+      #
+      # So we have to call manager on it. And again, this is what happens.
+      #
+      def resource
+        get_resource_ivar || set_resource_ivar(end_of_association_chain.send(resource_instance_name))
+      end
+
+    # Private helpers, you probably don't have to worry with them.
+    private
+
+      # Returns the appropriated method to build the resource.
+      #
+      def method_for_build
+        "build_#{resource_instance_name}"
+      end
+
+  end
+end

data/lib/inherited_resources/url_helpers.rb

@@ -0,0 +1,147 @@
+# = URLHelpers
+#
+# When you use InheritedResources it creates some UrlHelpers for you.
+# And they handle everything for you.
+#
+#  # /posts/1/comments
+#  resource_url          # => /posts/1/comments/#{@comment.to_param}
+#  resource_url(comment) # => /posts/1/comments/#{comment.to_param}
+#  new_resource_url      # => /posts/1/comments/new
+#  edit_resource_url     # => /posts/1/comments/#{@comment.to_param}/edit
+#  collection_url        # => /posts/1/comments
+#
+#  # /projects/1/tasks
+#  resource_url          # => /products/1/tasks/#{@task.to_param}
+#  resource_url(task)    # => /products/1/tasks/#{task.to_param}
+#  new_resource_url      # => /products/1/tasks/new
+#  edit_resource_url     # => /products/1/tasks/#{@task.to_param}/edit
+#  collection_url        # => /products/1/tasks
+#
+#  # /users
+#  resource_url          # => /users/#{@user.to_param}
+#  resource_url(user)    # => /users/#{user.to_param}
+#  new_resource_url      # => /users/new
+#  edit_resource_url     # => /users/#{@user.to_param}/edit
+#  collection_url        # => /users
+#
+# The nice thing is that those urls are not guessed during runtime. They are
+# all created when you inherit.
+#
+module InheritedResources #:nodoc:
+  module UrlHelpers #:nodoc:
+
+    # This method hard code url helpers in the class.
+    #
+    # We are doing this because is cheaper than guessing them when our action
+    # is being processed (and even more cheaper when we are using nested
+    # resources).
+    #
+    # When we are using polymorphic associations, those helpers rely on 
+    # polymorphic_url Rails helper.
+    #
+    def self.create_resources_url_helpers!(base)
+      resource_segments, resource_ivars = [], []
+      resource_config = base.resources_configuration[:self]
+      polymorphic = false
+
+      # Deal with belongs_to associations.
+      #
+      # If we find a :polymorphic symbol, it means that we should not add
+      # :route_name to resource_segments (which will be useless anyway).
+      #
+      base.parents_symbols.map do |symbol|
+        if symbol == :polymorphic
+          polymorphic = true
+          resource_ivars << :parent_instance
+        else
+          config = base.resources_configuration[symbol]
+          resource_segments << config[:route_name]
+          resource_ivars    << config[:instance_name]
+        end
+      end
+
+      # Deals with singleton.
+      # We define collection_url to singletons just for compatibility mode.
+      #
+      # The collection_url for singleton is the parent show url. For example,
+      # if we have ProjectsController with ManagerController, where the second
+      # is the singleton, the collection url would be: project_url.
+      #
+      # This is where you are going to be redirected after destroing the manager.
+      #
+      unless base.singleton
+        resource_segments << resource_config[:collection_name] 
+        generate_url_and_path_helpers(base, nil, :collection, resource_segments, resource_ivars, polymorphic)
+        resource_segments.pop
+      else
+        generate_url_and_path_helpers(base, nil, :collection, resource_segments, resource_ivars, polymorphic)
+      end
+
+      # Prepare and add new_resource_url
+      resource_segments << resource_config[:instance_name]
+      generate_url_and_path_helpers(base, :new, :resource, resource_segments, resource_ivars, polymorphic)
+
+      # We don't add the resource ivar to edit and resource url if singleton
+      resource_ivars << resource_config[:instance_name] unless base.singleton
+
+      # Prepare and add resource_url and edit_resource_url
+      generate_url_and_path_helpers(base, nil, :resource, resource_segments, resource_ivars, polymorphic)
+      generate_url_and_path_helpers(base, :edit, :resource, resource_segments, resource_ivars, polymorphic)
+    end
+
+    def self.generate_url_and_path_helpers(base, prefix, name, resource_segments, resource_ivars, polymorphic=false)
+        ivars = resource_ivars.map{|i| i == :parent_instance ? :parent_instance : "@#{i}" }
+
+        # If it's not a singleton, ivars are not empty, not a collection or
+        # not a new hew helper, we can add args to the method.
+        #
+        arg = unless base.singleton || ivars.empty? || name == :collection || prefix == :new
+          ivars.push("(given_arg || #{ivars.pop})")
+          'given_arg=nil'
+        else
+          ''
+        end
+
+        # When polymorphic is true, the segments must be replace by :polymorphic
+        # and ivars should be gathered into an array.
+        #
+        if polymorphic
+          segments = :polymorphic
+
+          # Customization to allow polymorphic with singletons.
+          #
+          # In such cases, we must send a string with the resource instance name
+          # to polymorphic_url.
+          #
+          # When not a singleton, but a collection or new url, we should add
+          # resource_class.new to instance ivars to allow polymorphic_url to
+          # deal with it properly.
+          #
+          if base.singleton
+            ivars << base.resources_configuration[:self][:instance_name].inspect unless name == :collection
+          elsif name == :collection || prefix == :new
+            ivars << 'resource_class.new'
+          end
+
+          ivars  = "[#{ivars.join(', ')}]"
+        else
+          segments = resource_segments.join('_')
+          ivars    = ivars.join(', ')
+        end
+
+        prefix   = prefix ? "#{prefix}_" : ''
+
+        base.class_eval <<URL_HELPERS, __FILE__, __LINE__
+protected
+  def #{prefix}#{name}_path(#{arg})
+    #{prefix}#{segments}_path(#{ivars})
+  end
+
+  def #{prefix}#{name}_url(#{arg})
+    #{prefix}#{segments}_url(#{ivars})
+  end
+URL_HELPERS
+    end
+
+  end
+end

data/test/aliases_test.rb

@@ -0,0 +1,71 @@
+# 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; end
+
+class StudentsController < InheritedResources::Base
+
+  def edit
+    edit! do |format|
+      format.xml { render :text => 'Render XML' }
+    end
+  end
+
+  def new
+    @something = 'magical'
+    new!
+  end
+
+end
+
+class AliasesBaseTest < Test::Unit::TestCase
+
+  def setup
+    @controller          = StudentsController.new
+    @controller.request  = @request  = ActionController::TestRequest.new
+    @controller.response = @response = ActionController::TestResponse.new
+  end
+
+  def test_assignments_before_calling_alias
+    Student.stubs(:new).returns(mock_student)
+    get :new
+    assert_response :success
+    assert_equal 'magical', assigns(:something)
+  end
+
+  def test_controller_should_render_new
+    Student.stubs(:new).returns(mock_student)
+    get :new
+    assert_response :success
+    assert_equal 'New HTML', @response.body.strip
+  end
+
+  def test_expose_the_resquested_user
+    Student.expects(:find).with('42').returns(mock_student)
+    get :edit, :id => '42'
+    assert_equal mock_student, assigns(:student)
+    assert_response :success
+  end
+
+  def test_controller_should_render_edit
+    Student.stubs(:find).returns(mock_student)
+    get :edit
+    assert_response :success
+    assert_equal 'Edit HTML', @response.body.strip
+  end
+
+  def test_render_xml_when_it_is_given_as_a_block
+    @request.accept = 'application/xml'
+    Student.stubs(:find).returns(mock_student)
+    get :edit
+    assert_response :success
+    assert_equal 'Render XML', @response.body
+  end
+
+  protected
+    def mock_student(stubs={})
+      @mock_student ||= mock(stubs)
+    end
+end
+

data/test/base_helpers_test.rb

@@ -0,0 +1,130 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Address
+  def self.human_name; 'Address'; end
+end
+
+class AddressesController < InheritedResources::Base
+  protected
+    def interpolation_options
+      { :reference => 'Ocean Avenue' }
+    end
+end
+
+class FlashBaseHelpersTest < Test::Unit::TestCase
+
+  def setup
+    @controller          = AddressesController.new
+    @controller.request  = @request  = ActionController::TestRequest.new
+    @controller.response = @response = ActionController::TestResponse.new
+    @request.accept      = 'application/xml'
+  end
+
+  def test_default_success_flash_message_on_create
+    Address.stubs(:new).returns(mock_address(:save => true))
+    @controller.stubs(:address_url)
+    post :create
+    assert_equal 'You created a new address close to <b>Ocean Avenue</b>.', flash[:notice]
+  end
+
+  def test_set_success_flash_message_on_update
+    Address.stubs(:find).returns(mock_address(:update_attributes => true))
+    put :update
+    assert_response :success
+    assert_equal 'Nice! Address was updated with success!', flash[:notice]
+  end
+
+  def test_set_failure_flash_message_on_update
+    Address.stubs(:find).returns(mock_address(:update_attributes => false, :errors => []))
+    put :update
+    assert_equal 'Oh no! We could not update your address!', flash[:error]
+  end
+
+  def test_default_success_flash_message_on_destroy
+    Address.stubs(:find).returns(mock_address(:destroy => true))
+    delete :destroy
+    assert_equal 'Address was successfully destroyed.', flash[:notice]
+  end
+
+  protected
+    def mock_address(stubs={})
+      @mock_address ||= mock(stubs)
+    end
+
+end
+
+class Pet
+  def self.human_name; 'Pet'; end
+end
+
+class PetsController < InheritedResources::Base
+  attr_accessor :current_user
+  
+  def edit
+    @pet = 'new pet'
+    edit!
+  end
+
+  protected
+    def collection
+      @pets ||= end_of_association_chain.all
+    end
+
+    def begin_of_association_chain
+      @current_user
+    end
+end
+
+class AssociationChainBaseHelpersTest < Test::Unit::TestCase
+
+  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
+
+  def test_begin_of_association_chain_is_called_on_index
+    @controller.current_user.expects(:pets).returns(Pet)
+    Pet.expects(:all).returns(mock_pet)
+    mock_pet.expects(:to_xml).returns('Generated XML')
+    get :index
+    assert_response :success
+    assert 'Generated XML', @response.body.strip
+  end
+
+  def test_begin_of_association_chain_is_called_on_new
+    @controller.current_user.expects(:pets).returns(Pet)
+    Pet.expects(:build).returns(mock_pet)
+    mock_pet.expects(:to_xml).returns('Generated XML')
+    get :new
+    assert_response :success
+    assert 'Generated XML', @response.body.strip
+  end
+
+  def test_begin_of_association_chain_is_called_on_show
+    @controller.current_user.expects(:pets).returns(Pet)
+    Pet.expects(:find).with('47').returns(mock_pet)
+    mock_pet.expects(:to_xml).returns('Generated XML')
+    get :show, :id => '47'
+    assert_response :success
+    assert 'Generated XML', @response.body.strip
+  end
+
+  def test_instance_variable_should_not_be_set_if_already_defined
+    @request.accept = 'text/html'
+    @controller.current_user.expects(:pets).never
+    Pet.expects(:find).never
+    get :edit
+    assert_response :success
+    assert_equal 'new pet', assigns(:pet)
+  end
+
+  protected
+    def mock_pet(stubs={})
+      @mock_pet ||= mock(stubs)
+    end
+
+end
+

data/test/base_test.rb

@@ -0,0 +1,219 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# This test file is instead to test the how controller flow and actions.
+# This is done using mocks a la rspec.
+#
+class User
+  def self.human_name; 'User'; end
+end
+
+class UsersController < InheritedResources::Base
+end
+
+# Create a TestHelper module with some helpers
+module UserTestHelper
+  def setup
+    @controller          = UsersController.new
+    @controller.request  = @request  = ActionController::TestRequest.new
+    @controller.response = @response = ActionController::TestResponse.new
+  end
+
+  protected
+    def mock_user(stubs={})
+      @mock_user ||= mock(stubs)
+    end
+end
+
+class IndexActionBaseTest < Test::Unit::TestCase
+  include UserTestHelper
+
+  def test_expose_all_users_as_instance_variable
+    User.expects(:find).with(:all).returns([mock_user])
+    get :index
+    assert_equal [mock_user], assigns(:users)
+  end
+
+  def test_controller_should_render_index
+    User.stubs(:find).returns([mock_user])
+    get :index
+    assert_response :success
+    assert_equal 'Index HTML', @response.body.strip
+  end
+
+  def test_render_all_users_as_xml_when_mime_type_is_xml
+    @request.accept = 'application/xml'
+    User.expects(:find).with(:all).returns(mock_user)
+    mock_user.expects(:to_xml).returns('Generated XML')
+    get :index
+    assert_response :success
+    assert_equal 'Generated XML', @response.body
+  end
+end
+
+class ShowActionBaseTest < Test::Unit::TestCase
+  include UserTestHelper
+
+  def test_expose_the_resquested_user
+    User.expects(:find).with('42').returns(mock_user)
+    get :show, :id => '42'
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_controller_should_render_show
+    User.stubs(:find).returns(mock_user)
+    get :show
+    assert_response :success
+    assert_equal 'Show HTML', @response.body.strip
+  end
+
+  def test_render_exposed_user_as_xml_when_mime_type_is_xml
+    @request.accept = 'application/xml'
+    User.expects(:find).with('42').returns(mock_user)
+    mock_user.expects(:to_xml).returns("Generated XML")
+    get :show, :id => '42'
+    assert_response :success
+    assert_equal 'Generated XML', @response.body
+  end
+end
+
+class NewActionBaseTest < Test::Unit::TestCase
+  include UserTestHelper
+
+  def test_expose_a_new_user
+    User.expects(:new).returns(mock_user)
+    get :new
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_controller_should_render_new
+    User.stubs(:new).returns(mock_user)
+    get :new
+    assert_response :success
+    assert_equal 'New HTML', @response.body.strip
+  end
+
+  def test_render_exposed_a_new_user_as_xml_when_mime_type_is_xml
+    @request.accept = 'application/xml'
+    User.expects(:new).returns(mock_user)
+    mock_user.expects(:to_xml).returns("Generated XML")
+    get :new
+    assert_response :success
+    assert_equal 'Generated XML', @response.body
+  end
+end
+
+class EditActionBaseTest < Test::Unit::TestCase
+  include UserTestHelper
+
+  def test_expose_the_resquested_user
+    User.expects(:find).with('42').returns(mock_user)
+    get :edit, :id => '42'
+    assert_response :success
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_controller_should_render_edit
+    User.stubs(:find).returns(mock_user)
+    get :edit
+    assert_response :success
+    assert_equal 'Edit HTML', @response.body.strip
+  end
+end
+
+class CreateActionBaseTest < Test::Unit::TestCase
+  include UserTestHelper
+
+  def test_expose_a_newly_create_user_when_saved_with_success
+    User.expects(:new).with({'these' => 'params'}).returns(mock_user(:save => true))
+    post :create, :user => {:these => 'params'}
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_redirect_to_the_created_user
+    User.stubs(:new).returns(mock_user(:save => true))
+    @controller.expects(:resource_url).returns('http://test.host/').times(2)
+    post :create
+    assert_redirected_to 'http://test.host/'
+  end
+
+  def test_show_flash_message_when_success
+    User.stubs(:new).returns(mock_user(:save => true))
+    post :create
+    assert_equal flash[:notice], 'User was successfully created.'
+  end
+
+  def test_render_new_template_when_user_cannot_be_saved
+    User.stubs(:new).returns(mock_user(:save => false, :errors => []))
+    post :create
+    assert_response :success
+    assert_template 'new'
+  end
+
+  def test_dont_show_flash_message_when_user_cannot_be_saved
+    User.stubs(:new).returns(mock_user(:save => false, :errors => []))
+    post :create
+    assert flash.empty?
+  end
+end
+
+class UpdateActionBaseTest < Test::Unit::TestCase
+  include UserTestHelper
+
+  def test_update_the_requested_object
+    User.expects(:find).with('42').returns(mock_user)
+    mock_user.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+    put :update, :id => '42', :user => {:these => 'params'}
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_redirect_to_the_created_user
+    User.stubs(:find).returns(mock_user(:update_attributes => true))
+    @controller.expects(:resource_url).returns('http://test.host/')
+    put :update
+    assert_redirected_to 'http://test.host/'
+  end
+
+  def test_show_flash_message_when_success
+    User.stubs(:find).returns(mock_user(:update_attributes => true))
+    put :update
+    assert_equal flash[:notice], 'User was successfully updated.'
+  end
+
+  def test_render_edit_template_when_user_cannot_be_saved
+    User.stubs(:find).returns(mock_user(:update_attributes => false, :errors => []))
+    put :update
+    assert_response :success
+    assert_template 'edit'
+  end
+
+  def test_dont_show_flash_message_when_user_cannot_be_saved
+    User.stubs(:find).returns(mock_user(:update_attributes => false, :errors => []))
+    put :update
+    assert flash.empty?
+  end
+end
+
+class DestroyActionBaseTest < Test::Unit::TestCase
+  include UserTestHelper
+  
+  def test_the_resquested_user_is_destroyed
+    User.expects(:find).with('42').returns(mock_user)
+    mock_user.expects(:destroy)
+    delete :destroy, :id => '42'
+    assert_equal mock_user, assigns(:user)
+  end
+
+  def test_show_flash_message
+    User.stubs(:find).returns(mock_user(:destroy => true))
+    delete :destroy
+    assert_equal flash[:notice], 'User was successfully destroyed.'
+  end
+
+  def test_redirects_to_users_list
+    User.stubs(:find).returns(mock_user(:destroy => true))
+    @controller.expects(:collection_url).returns('http://test.host/')
+    delete :destroy
+    assert_redirected_to 'http://test.host/'
+  end
+end
+