josevalim-inherited_resources 0.6.3 → 0.7.0

data/lib/inherited_resources/has_scope_helpers.rb

@@ -0,0 +1,65 @@
+module InheritedResources
+
+  # = has_scopes
+  #
+  # This module in included in your controller when has_scope is called for the
+  # first time.
+  #
+  module HasScopeHelpers
+    TRUE_VALUES = ["true", true, "1", 1] unless self.const_defined?(:TRUE_VALUES)
+
+    protected
+
+      # Overwrites apply to scope to implement default scope logic.
+      #
+      def apply_scope_to(target_object, target_name) #:nodoc:
+        @current_scopes ||= {}
+        scope_config = self.scopes_configuration[target_name] || {}
+
+        scope_config.each do |scope, options|
+          next unless apply_scope_to_action?(options)
+          key = options[:key]
+
+          if params.key?(key)
+            value, call_scope = params[key], true
+          elsif options.key?(:default)
+            value, call_scope = options[:default], true
+          end
+
+          if call_scope
+            @current_scopes[key] = value
+
+            if options[:boolean]
+              target_object = target_object.send(scope) if TRUE_VALUES.include?(value)
+            else
+              target_object = target_object.send(scope, value)
+            end
+          end
+        end
+
+        target_object
+      end
+
+      # Given an options with :only and :except arrays, check if the scope
+      # can be performed in the current action.
+      #
+      def apply_scope_to_action?(options) #:nodoc:
+        if options[:only].empty?
+          if options[:except].empty?
+            true
+          else
+            !options[:except].include?(action_name.to_sym)
+          end
+        else
+          options[:only].include?(action_name.to_sym)
+        end
+      end
+
+      # Returns the scopes used in this action.
+      #
+      def current_scopes
+        @current_scopes || {}
+      end
+
+  end
+end

data/lib/inherited_resources/polymorphic_helpers.rb

@@ -1,8 +1,94 @@
-module InheritedResources #:nodoc:
-  module PolymorphicHelpers #:nodoc:
+module InheritedResources
+
+  # = polymorphic associations
+  #
+  # In some cases you have a resource that belongs to two different resources
+  # but not at the same time. For example, let's suppose you have File, Message
+  # and Task as resources and they are all commentable.
+  #
+  # Polymorphic associations allows you to create just one controller that will
+  # deal with each case.
+  #
+  #   class Comment < InheritedResources::Base
+  #     belongs_to :file, :message, :task, :polymorphic => true
+  #   end
+  #
+  # Your routes should be something like:
+  #
+  #   m.resources :files,    :has_many => :comments #=> /files/13/comments
+  #   m.resources :tasks,    :has_many => :comments #=> /tasks/17/comments
+  #   m.resources :messages, :has_many => :comments #=> /messages/11/comments
+  #
+  # When using polymorphic associations, you get some free helpers:
+  #
+  #   parent?         #=> true
+  #   parent_type     #=> :task
+  #   parent_class    #=> Task
+  #   parent          #=> @task
+  #
+  # This polymorphic controllers thing is a great idea by James Golick and he
+  # built it in resource_controller. Here is just a re-implementation.
+  #
+  # = optional polymorphic associations
+  #
+  # Let's take another break from ProjectsController. Let's suppose we are
+  # building a store, which sell products.
+  #
+  # On the website, we can show all products, but also products scoped to
+  # categories, brands, users. In this case case, the association is optional, and
+  # we deal with it in the following way:
+  #
+  #   class ProductsController < InheritedResources::Base
+  #     belongs_to :category, :brand, :user, :polymorphic => true, :optional => true
+  #   end
+  #
+  # This will handle all those urls properly:
+  #
+  #   /products/1
+  #   /categories/2/products/5
+  #   /brands/10/products/3
+  #   /user/13/products/11
+  #
+  # = nested polymorphic associations
+  #
+  # You can have polymorphic associations with nested resources. Let's suppose
+  # that our File, Task and Message resources in the previous example belongs to
+  # a project.
+  #
+  # This way we can have:
+  #
+  #   class CommentsController < InheritedResources::Base
+  #     belongs_to :project {
+  #       belongs_to :file, :message, :task, :polymorphic => true
+  #     }
+  #   end
+  #
+  # Or:
+  #
+  #   class CommentsController < InheritedResources::Base
+  #     nested_belongs_to :project
+  #     nested_belongs_to :file, :message, :task, :polymorphic => true
+  #   end
+  #
+  # Choose the syntax that makes more sense to you. :)
+  #
+  # Finally your routes should be something like:
+  #
+  #   map.resources :projects do |m|
+  #     m.resources :files,    :has_many => :comments #=> /projects/1/files/13/comments
+  #     m.resources :tasks,    :has_many => :comments #=> /projects/1/tasks/17/comments
+  #     m.resources :messages, :has_many => :comments #=> /projects/1/messages/11/comments
+  #   end
+  #
+  # The helpers work in the same way as above.
+  #
+  module PolymorphicHelpers
 
     protected
 
+      # Returns the parent type. A Comments class can have :task, :file, :note
+      # as parent types.
+      #
       def parent_type
         @parent_type
       end
@@ -11,12 +97,15 @@ module InheritedResources #:nodoc:
         parent.class if @parent_type
       end
 
+      # Returns the parent object. They are also available with the instance
+      # variable name: @task, @file, @note...
+      #
       def parent
         instance_variable_get("@#{@parent_type}") if @parent_type
       end
 
-    private
-
+      # If the polymorphic association is optional, we might not have a parent.
+      #
       def parent?
         if resources_configuration[:polymorphic][:optional]
           parents_symbols.size > 1 || !@parent_type.nil?
@@ -25,6 +114,8 @@ module InheritedResources #:nodoc:
         end
       end
 
+    private
+
       # Maps parents_symbols to build association chain.
       #
       # If the parents_symbols find :polymorphic, it goes through the
@@ -33,7 +124,7 @@ module InheritedResources #:nodoc:
       # When optional is given, it does not raise errors if the polymorphic
       # params are missing.
       #
-      def symbols_for_chain
+      def symbols_for_association_chain #:nodoc:
         polymorphic_config = resources_configuration[:polymorphic]
 
         parents_symbols.map do |symbol|

data/lib/inherited_resources/respond_to.rb

@@ -1,8 +1,8 @@
-# Provides an extension for Rails respond_to by expading MimeResponds::Responder
-# and adding respond_to class method and respond_with instance method.
-#
-module ActionController #:nodoc:
-  class Base #:nodoc:
+module ActionController
+  # Provides an extension for Rails respond_to by expading MimeResponds::Responder
+  # and adding respond_to class method and respond_with instance method.
+  #
+  class Base
 
     protected
       # Defines respond_to method to store formats that are rendered by default.
@@ -240,10 +240,10 @@ module ActionController #:nodoc:
 
     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?)
 
+        # Define template_exists? for Rails 2.3
         def template_exists?
           default_template ? true : false
         rescue ActionView::MissingTemplate
@@ -254,7 +254,7 @@ module ActionController #:nodoc:
       # We respond to the default template if it's a valid format AND the template
       # exists.
       #
-      def respond_to_default_template?(responder)
+      def respond_to_default_template?(responder) #:nodoc:
         responder.action_respond_to_format?(default_template_format) && template_exists?
       end
 

data/lib/inherited_resources/singleton_helpers.rb

@@ -1,8 +1,43 @@
-module InheritedResources #:nodoc:
-  module SingletonHelpers #:nodoc:
+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 helpers. You might want to overwrite some of them.
     protected
+
       # Singleton methods does not deal with collections.
       #
       def collection
@@ -10,6 +45,7 @@ module InheritedResources #:nodoc:
       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.
       #
@@ -34,20 +70,26 @@ module InheritedResources #:nodoc:
       #
       #   Project.find(params[:project_id])
       #
-      # So we have to call manager on it. And again, this is what happens.
+      # 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 helpers, you probably don't have to worry with them.
     private
 
       # Returns the appropriated method to build the resource.
       #
-      def method_for_build
+      def method_for_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

@@ -1,34 +1,34 @@
-# = 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:
+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
+  #
+  #  # /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 UrlHelpers
 
     # This method hard code url helpers in the class.
     #
@@ -76,7 +76,7 @@ module InheritedResources #:nodoc:
       #
       # This is where you are going to be redirected after destroying the manager.
       #
-      unless base.singleton
+      unless base.resources_configuration[:self][:singleton]
         resource_segments << resource_config[:route_collection_name]
         generate_url_and_path_helpers(base, nil, :collection, resource_segments, resource_ivars, polymorphic)
         resource_segments.pop
@@ -97,20 +97,21 @@ module InheritedResources #:nodoc:
       #
       #   edit_project_manager_url(@project, @manager)
       #
-      resource_ivars << resource_config[:instance_name] unless base.singleton
+      resource_ivars << resource_config[:instance_name] unless base.resources_configuration[:self][: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)
+    def self.generate_url_and_path_helpers(base, prefix, name, resource_segments, resource_ivars, polymorphic=false) #:nodoc:
         ivars = resource_ivars.map{|i| i == :parent ? :parent : "@#{i}" }
 
         # 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 base.singleton || ivars.empty? || name == :collection || prefix == :new
+        unless base.resources_configuration[:self][:singleton] || ivars.empty? ||
+               name == :collection || prefix == :new
           ivars.push "(given_args.first || #{ivars.pop})"
         end
 
@@ -159,7 +160,7 @@ module InheritedResources #:nodoc:
           #   polymorphic_url(@project, Task.new)
           #   new_polymorphic_url(@project, Task.new)
           #
-          if base.singleton
+          if base.resources_configuration[:self][:singleton]
             ivars << base.resources_configuration[:self][:instance_name].inspect unless name == :collection
           elsif name == :collection || prefix == :new
             ivars << 'resource_class.new'

data/lib/inherited_resources.rb

@@ -1,4 +1,6 @@
-dir = File.dirname(__FILE__)
-require File.join(dir, 'inherited_resources', 'respond_to')
+# respond_to is the only file that should be loaded before hand. All others
+# are loaded on demand.
+#
+require File.join(File.dirname(__FILE__), 'inherited_resources', 'respond_to')
 
 module InheritedResources; end

data/test/base_helpers_test.rb

@@ -1,94 +1,10 @@
 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
-
-module Admin; end
-class Admin::AddressesController < InheritedResources::Base
-  protected
-    def interpolation_options
-      { :reference => 'Ocean Avenue' }
-    end
-end
-
-class FlashBaseHelpersTest < ActionController::TestCase
-  tests AddressesController
-
-  def setup
-    @request.accept      = 'application/xml'
-  end
-
-  def test_success_flash_message_on_create_with_yml
-    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_success_flash_message_on_create_with_namespaced_controller
-    @controller = Admin::AddressesController.new
-    Address.stubs(:new).returns(mock_address(:save => true))
-    @controller.stubs(:address_url)
-    post :create
-    assert_equal 'Admin, you created a new address close to <b>Ocean Avenue</b>.', flash[:notice]
-  end
-
-  def test_failure_flash_message_on_create_with_namespaced_controller_actions
-    @controller = Admin::AddressesController.new
-    Address.stubs(:new).returns(mock_address(:save => false))
-    @controller.stubs(:address_url)
-    post :create
-    assert_equal 'Admin error message.', flash[:error]
-  end
-
-  def test_inherited_success_flash_message_on_update_on_namespaced_controllers
-    @controller = Admin::AddressesController.new
-    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_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_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_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
-  respond_to :xml
   attr_accessor :current_user
   
   def edit
@@ -111,38 +27,33 @@ class AssociationChainBaseHelpersTest < ActionController::TestCase
 
   def setup
     @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
+    assert '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)
-    mock_pet.expects(:to_xml).returns('Generated XML')
     get :new
     assert_response :success
-    assert 'Generated XML', @response.body.strip
+    assert '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)
-    mock_pet.expects(:to_xml).returns('Generated XML')
     get :show, :id => '47'
     assert_response :success
-    assert 'Generated XML', @response.body.strip
+    assert 'Show HTML', @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