karsthammer-inherited_resources 1.1.2

data/lib/inherited_resources/responder.rb

@@ -0,0 +1,6 @@
+module InheritedResources
+  class Responder < ActionController::Responder
+    include Responders::FlashResponder
+    include Responders::HttpCacheResponder
+  end
+end

data/lib/inherited_resources/singleton_helpers.rb

@@ -0,0 +1,95 @@
+module InheritedResources
+
+  # = singleton
+  #
+  # Singletons are usually used in associations which are related through has_one
+  # and belongs_to. You declare those associations like this:
+  #
+  #   class ManagersController < InheritedResources::Base
+  #     belongs_to :project, :singleton => true
+  #   end
+  #
+  # But in some cases, like an AccountsController, you have a singleton object
+  # that is not necessarily associated with another:
+  #
+  #   class AccountsController < InheritedResources::Base
+  #     defaults :singleton => true
+  #   end
+  #
+  # Besides that, you should overwrite the methods :resource and :build_resource
+  # to make it work properly:
+  #
+  #   class AccountsController < InheritedResources::Base
+  #     defaults :singleton => true
+  #
+  #     protected
+  #       def resource
+  #         @current_user.account
+  #       end
+  #
+  #       def build_resource(attributes = {})
+  #         Account.new(attributes)
+  #       end
+  #   end
+  #
+  # When you have a singleton controller, the action index is removed.
+  #
+  module SingletonHelpers
+
+    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, not find.
+      #
+      def resource
+        get_resource_ivar || set_resource_ivar(end_of_association_chain.send(resource_instance_name))
+      end
+
+    private
+
+      # Returns the appropriated method to build the resource.
+      #
+      def method_for_association_build #:nodoc:
+        :"build_#{resource_instance_name}"
+      end
+
+      # Sets the method_for_association_chain to nil. See <tt>resource</tt>
+      # above for more information.
+      #
+      def method_for_association_chain #:nodoc:
+        nil
+      end
+
+  end
+end

data/lib/inherited_resources/url_helpers.rb

@@ -0,0 +1,188 @@
+module InheritedResources
+  # = 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
+  #  parent_url            # => /posts/1
+  #
+  #  # /projects/1/tasks
+  #  resource_url          # => /projects/1/tasks/#{@task.to_param}
+  #  resource_url(task)    # => /projects/1/tasks/#{task.to_param}
+  #  new_resource_url      # => /projects/1/tasks/new
+  #  edit_resource_url     # => /projects/1/tasks/#{@task.to_param}/edit
+  #  collection_url        # => /projects/1/tasks
+  #  parent_url            # => /projects/1
+  #
+  #  # /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
+  #  parent_url            # => /
+  #
+  # The nice thing is that those urls are not guessed during runtime. They are
+  # all created when you inherit.
+  #
+  module UrlHelpers
+
+    # 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 create_resources_url_helpers!
+      resource_segments, resource_ivars = [], []
+      resource_config = self.resources_configuration[:self]
+
+      singleton   = self.resources_configuration[:self][:singleton]
+      polymorphic = self.parents_symbols.include?(:polymorphic)
+
+      # Add route_prefix if any.
+      unless resource_config[:route_prefix].blank?
+        if polymorphic
+          resource_ivars << resource_config[:route_prefix].to_s.inspect
+        else
+          resource_segments << resource_config[:route_prefix]
+        end
+      end
+
+      # Deal with belongs_to associations and polymorphic associations.
+      # Remember that we don't have to build the segments in polymorphic cases,
+      # because the url will be polymorphic_url.
+      #
+      self.parents_symbols.each do |symbol|
+        if symbol == :polymorphic
+          resource_ivars << :parent
+        else
+          config = self.resources_configuration[symbol]
+          resource_segments << config[:route_name]
+          resource_ivars    << :"@#{config[:instance_name]}"
+        end
+      end
+
+      collection_ivars    = resource_ivars.dup
+      collection_segments = resource_segments.dup
+
+      # Generate parent url before we add resource instances.
+      unless parents_symbols.empty?
+        generate_url_and_path_helpers nil,   :parent, resource_segments, resource_ivars
+        generate_url_and_path_helpers :edit, :parent, resource_segments, resource_ivars
+      end
+
+      # This is the default route configuration, later we have to deal with
+      # exception from polymorphic and singleton cases.
+      #
+      collection_segments << resource_config[:route_collection_name]
+      resource_segments   << resource_config[:route_instance_name]
+      resource_ivars      << :"@#{resource_config[:instance_name]}"
+
+      # In singleton cases, we do not send the current element instance variable
+      # because the id is not in the URL. For example, we should call:
+      #
+      #   project_manager_url(@project)
+      #
+      # Instead of:
+      #
+      #   project_manager_url(@project, @manager)
+      #
+      # Another exception in singleton cases is that collection url does not
+      # exist. In such cases, we create the parent collection url. So in the
+      # manager case above, the collection url will be:
+      #
+      #    project_url(@project)
+      #
+      # If the singleton does not have a parent, it will default to root_url.
+      #
+      # Finally, polymorphic cases we have to give hints to the polymorphic url
+      # builder. This works by attaching new ivars as symbols or records.
+      #
+      if singleton
+        collection_segments.pop
+        resource_ivars.pop
+
+        if polymorphic
+          resource_ivars << resource_config[:instance_name].inspect
+          new_ivars       = resource_ivars
+        end
+      elsif polymorphic
+        collection_ivars << '(@_resource_class_new ||= resource_class.new)'
+      end
+      
+      # If route is uncountable then add "_index" suffix to collection index route name
+      # 
+      if !singleton && resource_config[:route_collection_name] == resource_config[:route_instance_name]
+        collection_segments << :index
+      end
+
+      generate_url_and_path_helpers nil,   :collection, collection_segments, collection_ivars
+      generate_url_and_path_helpers :new,  :resource,   resource_segments,   new_ivars || collection_ivars
+      generate_url_and_path_helpers nil,   :resource,   resource_segments,   resource_ivars
+      generate_url_and_path_helpers :edit, :resource,   resource_segments,   resource_ivars
+    end
+
+    def generate_url_and_path_helpers(prefix, name, resource_segments, resource_ivars) #:nodoc:
+      ivars = resource_ivars.dup
+
+      singleton   = self.resources_configuration[:self][:singleton]
+      polymorphic = self.parents_symbols.include?(:polymorphic)
+
+      # If it's not a singleton, ivars are not empty, not a collection or
+      # not a "new" named route, we can pass a resource as argument.
+      #
+      unless (singleton && name != :parent) || ivars.empty? || name == :collection || prefix == :new
+        ivars.push "(given_args.first || #{ivars.pop})"
+      end
+
+      # In collection in polymorphic cases, allow an argument to be given as a
+      # replacemente for the parent.
+      #
+      if name == :collection && polymorphic
+        index = ivars.index(:parent)
+        ivars.insert index, "(given_args.first || parent)"
+        ivars.delete(:parent)
+      end
+
+      # When polymorphic is true, the segments must be replace by :polymorphic
+      # and ivars should be gathered into an array, which is compacted when
+      # optional.
+      #
+      if polymorphic
+        segments = :polymorphic
+        ivars    = "[#{ivars.join(', ')}]"
+        ivars   << '.compact' if self.resources_configuration[:polymorphic][:optional]
+      else
+        segments = resource_segments.empty? ? 'root' : resource_segments.join('_')
+        ivars    = ivars.join(', ')
+      end
+
+      prefix = prefix ? "#{prefix}_" : ''
+      ivars << (ivars.empty? ? 'given_options' : ', given_options')
+
+      class_eval <<-URL_HELPERS, __FILE__, __LINE__
+        protected
+          def #{prefix}#{name}_path(*given_args)
+            given_options = given_args.extract_options!
+            #{prefix}#{segments}_path(#{ivars})
+          end
+
+          def #{prefix}#{name}_url(*given_args)
+            given_options = given_args.extract_options!
+            #{prefix}#{segments}_url(#{ivars})
+          end
+      URL_HELPERS
+    end
+
+  end
+end

data/lib/inherited_resources/version.rb

@@ -0,0 +1,3 @@
+module InheritedResources
+  VERSION = '1.1.2'.freeze
+end

data/test/aliases_test.rb

@@ -0,0 +1,144 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+
+class Student
+  extend ActiveModel::Naming
+end
+
+class ApplicationController < ActionController::Base
+  include InheritedResources::DSL
+end
+
+class StudentsController < ApplicationController
+  inherit_resources
+  respond_to :html, :xml
+
+  def edit
+    edit! do |format|
+      format.xml { render :text => 'Render XML' }
+    end
+  end
+
+  def new
+    @something = 'magical'
+    new!
+  end
+
+  create!(:location => "http://test.host/") do |success, failure|
+    success.html { render :text => "I won't redirect!" }
+    failure.xml { render :text => "I shouldn't be rendered" }
+  end
+
+  update! do |success, failure|
+    success.html { redirect_to(resource_url) }
+    failure.html { render :text => "I won't render!" }
+  end
+
+  destroy! do |format|
+    format.html { render :text => "Destroyed!" }
+  end
+end
+
+class AliasesTest < ActionController::TestCase
+  tests StudentsController
+
+  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_requested_user_on_edit
+    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
+
+  def test_is_not_redirected_on_create_with_success_if_success_block_is_given
+    Student.stubs(:new).returns(mock_student(:save => true))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    post :create
+    assert_response :success
+    assert_equal "I won't redirect!", @response.body
+  end
+
+  def test_dumb_responder_quietly_receives_everything_on_failure
+    @request.accept = 'text/html'
+    Student.stubs(:new).returns(mock_student(:save => false, :errors => {:some => :error}))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    post :create
+    assert_response :success
+    assert_equal "New HTML", @response.body.strip
+  end
+
+  def test_html_is_the_default_when_only_xml_is_overwriten
+    @request.accept = '*/*'
+    Student.stubs(:new).returns(mock_student(:save => false, :errors => {:some => :error}))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    post :create
+    assert_response :success
+    assert_equal "New HTML", @response.body.strip
+  end
+
+  def test_wont_render_edit_template_on_update_with_failure_if_failure_block_is_given
+    Student.stubs(:find).returns(mock_student(:update_attributes => false, :errors => { :fail => true }))
+    put :update
+    assert_response :success
+    assert_equal "I won't render!", @response.body
+  end
+
+  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
+
+  def test_block_is_called_when_student_is_destroyed
+    Student.stubs(:find).returns(mock_student(:destroy => true))
+    delete :destroy
+    assert_response :success
+    assert_equal "Destroyed!", @response.body
+  end
+
+  def test_options_are_used_in_respond_with
+    @request.accept = "application/xml"
+    Student.stubs(:new).returns(mock_student(:save => true, :to_xml => "XML"))
+    post :create
+    assert_equal "http://test.host/", @response.location
+  end
+
+  protected
+    def mock_student(expectations={})
+      @mock_student ||= begin
+        student = mock(expectations.except(:errors))
+        student.stubs(:class).returns(Student)
+        student.stubs(:errors).returns(expectations.fetch(:errors, {})) 
+        student
+      end
+    end
+end
+

data/test/association_chain_test.rb

@@ -0,0 +1,125 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+
+class Pet
+  extend ActiveModel::Naming
+end
+
+class Puppet
+  extend ActiveModel::Naming
+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 BeginOfAssociationChainTest < ActionController::TestCase
+  tests PetsController
+
+  def setup
+    @controller.current_user = mock()
+  end
+
+  def test_begin_of_association_chain_is_called_on_index
+    @controller.current_user.expects(:pets).returns(Pet)
+    Pet.expects(:all).returns(mock_pet)
+    get :index
+    assert_response :success
+    assert_equal 'Index HTML', @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)
+    get :new
+    assert_response :success
+    assert_equal 'New HTML', @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)
+    get :show, :id => '47'
+    assert_response :success
+    assert_equal 'Show HTML', @response.body.strip
+  end
+
+  def test_instance_variable_should_not_be_set_if_already_defined
+    @controller.current_user.expects(:pets).never
+    Pet.expects(:find).never
+    get :edit
+    assert_response :success
+    assert_equal 'new pet', assigns(:pet)
+  end
+
+  def test_model_is_not_initialized_with_nil
+    @controller.current_user.expects(:pets).returns(Pet)
+    Pet.expects(:build).with({}).returns(mock_pet)
+    get :new
+    assert_equal mock_pet, assigns(:pet)
+  end
+
+  def test_begin_of_association_chain_is_included_in_chain
+    @controller.current_user.expects(:pets).returns(Pet)
+    Pet.expects(:build).with({}).returns(mock_pet)
+    get :new
+    assert_equal [@controller.current_user], @controller.send(:association_chain)
+  end
+
+  protected
+    def mock_pet(stubs={})
+      @mock_pet ||= mock(stubs)
+    end
+
+end
+
+class PuppetsController < InheritedResources::Base
+  optional_belongs_to :pet
+end
+
+class AssociationChainTest < ActionController::TestCase
+  tests PuppetsController
+
+  def setup
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_parent_is_added_to_association_chain
+    Pet.expects(:find).with('37').returns(mock_pet)
+    mock_pet.expects(:puppets).returns(Puppet)
+    Puppet.expects(:find).with('42').returns(mock_puppet)
+    mock_puppet.expects(:destroy)
+    delete :destroy, :id => '42', :pet_id => '37'
+    assert_equal [mock_pet], @controller.send(:association_chain)
+  end
+
+  def test_parent_is_added_to_association_chain_if_not_available
+    Puppet.expects(:find).with('42').returns(mock_puppet)
+    mock_puppet.expects(:destroy)
+    delete :destroy, :id => '42'
+    assert_equal [], @controller.send(:association_chain)
+  end
+
+  protected
+    def mock_pet(stubs={})
+      @mock_pet ||= mock(stubs)
+    end
+
+    def mock_puppet(stubs={})
+      @mock_puppet ||= mock(stubs)
+    end
+end