josevalim-inherited_resources 0.7.3 → 0.8.1

data/CHANGELOG

@@ -1,3 +1,9 @@
+# Version 0.8
+
+* Allow InheritedResources to be called without inheritance.
+* Ensure that controllers that inherit from a controller with InheritedResources
+  works properly.
+
 # Version 0.7
 
 * Allow procs as default value in has scope to be able to use values from session, for example.

data/README

@@ -1,6 +1,6 @@
 Inherited Resources
 License: MIT
-Version: 0.7.3
+Version: 0.8.0
 
 You can also read this README in pretty html at the GitHub project Wiki page:
 
@@ -93,6 +93,13 @@ In your views, you will get the following helpers:
 As you might expect, collection (@projects instance variable) is only available
 on index actions.
 
+If for some reason you cannot inherit from InheritedResources::Base, you can
+call inherit_resources or resource_controller in your controller class scope:
+
+  class AccountsController < ApplicationController
+    inherit_resources # or resource_controller
+  end
+
 Overwriting defaults
 --------------------
 

data/lib/inherited_resources.rb

@@ -4,3 +4,26 @@
 require File.join(File.dirname(__FILE__), 'inherited_resources', 'respond_to')
 
 module InheritedResources; end
+
+class ActionController::Base
+  class << self
+    # If you cannot inherit from InheritedResources::Base you can call
+    # inherit_resource or resource_controller in your controller to have all
+    # the required modules and funcionality included.
+    #
+    def inherit_resources
+      include InheritedResources::Actions
+      include InheritedResources::BaseHelpers
+      extend  InheritedResources::ClassMethods
+      extend  InheritedResources::UrlHelpers
+
+      helper_method :collection_url, :collection_path, :resource_url, :resource_path,
+                    :new_resource_url, :new_resource_path, :edit_resource_url, :edit_resource_path,
+                    :resource, :collection, :resource_class
+
+      initialize_resources_class_accessors!
+      create_resources_url_helpers!
+    end
+    alias :resource_controller :inherit_resources
+  end
+end

data/lib/inherited_resources/actions.rb

@@ -0,0 +1,96 @@
+module InheritedResources
+  RESOURCES_ACTIONS = [ :index, :show, :new, :edit, :create, :update, :destroy ] unless self.const_defined?(:RESOURCES_ACTIONS)
+
+  # Holds all default actions for InheritedResouces.
+  module Actions
+
+    # GET /resources
+    def index(&block)
+      respond_to(:with => collection, &block)
+    end
+    alias :index! :index
+
+    # GET /resources/1
+    def show(&block)
+      respond_to(:with => resource, &block)
+    end
+    alias :show! :show
+
+    # GET /resources/new
+    def new(&block)
+      respond_to(:with => build_resource, &block)
+    end
+    alias :new! :new
+
+    # GET /resources/1/edit
+    def edit(&block)
+      respond_to(:with => resource, &block)
+    end
+    alias :edit! :edit
+
+    # POST /resources
+    def create(redirect_url=nil, &block)
+      object = build_resource(params[resource_instance_name])
+      respond_block, redirect_block = select_block_by_arity(block)
+
+      if object.save
+        set_flash_message!(:notice, '{{resource_name}} was successfully created.')
+        options = { :with => object, :status => :created, :location => (resource_url rescue nil) }
+
+        respond_to_with_dual_blocks(true, respond_block, options) do |format|
+          format.html { redirect_to(redirect_block ? redirect_block.call : resource_url) }
+        end
+      else
+        set_flash_message!(:error)
+        options = { :with => object.errors, :status => :unprocessable_entity }
+
+        respond_to_with_dual_blocks(false, respond_block, options) do |format|
+          format.html { render :action => 'new' }
+        end
+      end
+    end
+    alias :create! :create
+
+    # PUT /resources/1
+    def update(redirect_url=nil, &block)
+      object = resource
+      respond_block, redirect_block = select_block_by_arity(block)
+
+      if object.update_attributes(params[resource_instance_name])
+        set_flash_message!(:notice, '{{resource_name}} was successfully updated.')
+
+        respond_to_with_dual_blocks(true, block) do |format|
+          format.html { redirect_to(redirect_block ? redirect_block.call : resource_url) }
+          format.all  { head :ok }
+        end
+      else
+        set_flash_message!(:error)
+
+        options = { :with => object.errors, :status => :unprocessable_entity }
+
+        respond_to_with_dual_blocks(false, block, options) do |format|
+          format.html { render :action => 'edit' }
+        end
+      end
+    end
+    alias :update! :update
+
+    # DELETE /resources/1
+    def destroy(redirect_url=nil, &block)
+      resource.destroy
+      respond_block, redirect_block = select_block_by_arity(block)
+
+      set_flash_message!(:notice, '{{resource_name}} was successfully destroyed.')
+
+      respond_to_with_dual_blocks(nil, respond_block) do |format|
+        format.html { redirect_to(redirect_block ? redirect_block.call : collection_url) }
+        format.all  { head :ok }
+      end
+    end
+    alias :destroy! :destroy
+
+    # Make aliases protected
+    protected :index!, :show!, :new!, :create!, :edit!, :update!, :destroy!
+
+  end
+end

data/lib/inherited_resources/base.rb

@@ -1,13 +1,4 @@
-# Whenever Base is required, we eager load the base files. belongs_to, polymorphic
-# and singleton helpers are loaded on demand.
-require File.dirname(__FILE__) + '/base_helpers.rb'
-require File.dirname(__FILE__) + '/class_methods.rb'
-require File.dirname(__FILE__) + '/dumb_responder.rb'
-require File.dirname(__FILE__) + '/url_helpers.rb'
-
 module InheritedResources
-  RESOURCES_ACTIONS = [ :index, :show, :new, :edit, :create, :update, :destroy ] unless self.const_defined?(:RESOURCES_ACTIONS)
-
   # = Base
   #
   # This is the base class that holds all actions. If you see the code for each
@@ -20,114 +11,19 @@ module InheritedResources
   class Base < ::ApplicationController
     unloadable
 
+    include InheritedResources::Actions
     include InheritedResources::BaseHelpers
-    extend InheritedResources::ClassMethods
+    extend  InheritedResources::ClassMethods
+    extend  InheritedResources::UrlHelpers
 
     helper_method :collection_url, :collection_path, :resource_url, :resource_path,
                   :new_resource_url, :new_resource_path, :edit_resource_url, :edit_resource_path,
                   :resource, :collection, :resource_class
 
     def self.inherited(base) #:nodoc:
-      base.class_eval do
-        # Make all resources actions public
-        public *RESOURCES_ACTIONS
-      end
-
-      # Call super to register class in ApplicationController
-      super
-
-      # Creates and sets class accessors default values
-      initialize_resources_class_accessors!(base)
+      super(base)
+      base.send :initialize_resources_class_accessors!
+      base.send :create_resources_url_helpers!
     end
-
-    protected
-
-      # GET /resources
-      def index(&block)
-        respond_to(:with => collection, &block)
-      end
-      alias :index! :index
-
-      # GET /resources/1
-      def show(&block)
-        respond_to(:with => resource, &block)
-      end
-      alias :show! :show
-
-      # GET /resources/new
-      def new(&block)
-        respond_to(:with => build_resource, &block)
-      end
-      alias :new! :new
-
-      # GET /resources/1/edit
-      def edit(&block)
-        respond_to(:with => resource, &block)
-      end
-      alias :edit! :edit
-
-      # POST /resources
-      def create(redirect_url=nil, &block)
-        object = build_resource(params[resource_instance_name])
-        respond_block, redirect_block = select_block_by_arity(block)
-
-        if object.save
-          set_flash_message!(:notice, '{{resource_name}} was successfully created.')
-          options = { :with => object, :status => :created, :location => (resource_url rescue nil) }
-
-          respond_to_with_dual_blocks(true, respond_block, options) do |format|
-            format.html { redirect_to parse_redirect_url(redirect_url, :resource_url, redirect_block) }
-          end
-        else
-          set_flash_message!(:error)
-
-          options = { :with => object.errors, :status => :unprocessable_entity }
-
-          respond_to_with_dual_blocks(false, respond_block, options) do |format|
-            format.html { render :action => 'new' }
-          end
-        end
-      end
-      alias :create! :create
-
-      # PUT /resources/1
-      def update(redirect_url=nil, &block)
-        object = resource
-        respond_block, redirect_block = select_block_by_arity(block)
-
-        if object.update_attributes(params[resource_instance_name])
-          set_flash_message!(:notice, '{{resource_name}} was successfully updated.')
-
-          respond_to_with_dual_blocks(true, block) do |format|
-            format.html { redirect_to parse_redirect_url(redirect_url, :resource_url, redirect_block) }
-            format.all  { head :ok }
-          end
-        else
-          set_flash_message!(:error)
-
-          options = { :with => object.errors, :status => :unprocessable_entity }
-
-          respond_to_with_dual_blocks(false, block, options) do |format|
-            format.html { render :action => 'edit' }
-          end
-        end
-      end
-      alias :update! :update
-
-      # DELETE /resources/1
-      def destroy(redirect_url=nil, &block)
-        resource.destroy
-        respond_block, redirect_block = select_block_by_arity(block)
-
-        set_flash_message!(:notice, '{{resource_name}} was successfully destroyed.')
-
-        respond_to_with_dual_blocks(nil, respond_block) do |format|
-          format.html { redirect_to parse_redirect_url(redirect_url, :collection_url, redirect_block) }
-          format.all  { head :ok }
-        end
-      end
-      alias :destroy! :destroy
-
   end
 end
-

data/lib/inherited_resources/base_helpers.rb

@@ -1,3 +1,6 @@
+# Whenever base is required load the dumb responder since it's used inside actions.
+require File.dirname(__FILE__) + '/dumb_responder.rb'
+
 module InheritedResources
   # Base helpers for InheritedResource work. Some methods here can be overwriten
   # and you will need to do that to customize your controllers from time to time.
@@ -42,7 +45,7 @@ module InheritedResources
       # methods. You probably won't need to change it. Again, if you overwrite
       # don't forget to cache the result in an instance_variable.
       #
-      def build_resource(attributes = {})
+      def build_resource(attributes={})
         get_resource_ivar || set_resource_ivar(end_of_association_chain.send(method_for_build, attributes))
       end
 
@@ -126,7 +129,14 @@ module InheritedResources
       # Returns the appropriated method to build the resource.
       #
       def method_for_build #:nodoc:
-        (begin_of_association_chain || parent?) ? :build : :new
+        (begin_of_association_chain || parent?) ? method_for_association_build : :new
+      end
+
+      # Returns the name of the method used for build the resource in cases
+      # where we have a parent. This is overwritten in singleton scenarios.
+      #
+      def method_for_association_build
+        :build
       end
 
       # Returns the name of the method to be called, before returning the end
@@ -297,20 +307,6 @@ module InheritedResources
         []
       end
 
-      # If block is not nil, call it and uses the result as redirect to url.
-      # Otherwise, send the default url as message.
-      #
-      def parse_redirect_url(redirect_url, default_url, block) #:nodoc:
-        if redirect_url
-          line = caller.detect{|l| l =~ Regexp.new(Regexp.escape(RAILS_ROOT)) }
-          ActiveSupport::Deprecation.warn("#{action_name}!(redirect_url) is deprecated. " << 
-                                          "Use #{action_name}!{ redirect_url } instead.", [line])
-          return redirect_url
-        end
-
-        block ? block.call : send(default_url)
-      end
-
       # Holds InheritedResources block structure. It returns two blocks: the first
       # is used in respond_to blocks and the second is the redirect_to url.
       #

data/lib/inherited_resources/class_methods.rb

@@ -53,7 +53,7 @@ module InheritedResources
           config[key] = value.to_sym
         end
 
-        InheritedResources::UrlHelpers.create_resources_url_helpers!(self)
+        create_resources_url_helpers!
       end
 
       # Defines wich actions to keep from the inherited controller.
@@ -244,7 +244,7 @@ module InheritedResources
         if block_given?
           class_eval(&block)
         else
-          InheritedResources::UrlHelpers.create_resources_url_helpers!(self)
+          create_resources_url_helpers!
         end
       end
       alias :nested_belongs_to :belongs_to
@@ -292,49 +292,44 @@ module InheritedResources
 
       # Initialize resources class accessors and set their default values.
       #
-      def initialize_resources_class_accessors!(base) #:nodoc:
+      def initialize_resources_class_accessors! #:nodoc:
         # Add and protect class accessors
-        base.class_eval do
-          metaklass = (class << self; self; end)
+        metaklass = (class << self; self; end)
 
-          RESOURCES_CLASS_ACCESSORS.each do |cattr|
-            cattr_accessor "#{cattr}", :instance_writer => false
+        RESOURCES_CLASS_ACCESSORS.each do |cattr|
+          cattr_accessor "#{cattr}", :instance_writer => false
 
-            # Protect instance methods
-            self.send :protected, cattr
+          # Protect instance methods
+          self.send :protected, cattr
 
-            # Protect class writer
-            metaklass.send :protected, "#{cattr}="
-          end
+          # Protect class writer
+          metaklass.send :protected, "#{cattr}="
         end
 
         # Initialize resource class
-        base.resource_class = begin
-          base.controller_name.classify.constantize
+        self.resource_class = begin
+          self.controller_name.classify.constantize
         rescue NameError
           nil
         end
 
         # Initialize resources configuration hash
-        base.resources_configuration = {}
-        config = base.resources_configuration[:self] = {}
-        config[:collection_name] = base.controller_name.to_sym
-        config[:instance_name]   = base.controller_name.singularize.to_sym
+        self.resources_configuration = {}
+        config = self.resources_configuration[:self] = {}
+        config[:collection_name] = self.controller_name.to_sym
+        config[:instance_name]   = self.controller_name.singularize.to_sym
 
         config[:route_collection_name] = config[:collection_name]
         config[:route_instance_name]   = config[:instance_name]
 
         # Deal with namespaced controllers
-        namespaces = base.controller_path.split('/')[0..-2]
+        namespaces = self.controller_path.split('/')[0..-2]
         config[:route_prefix] = namespaces.join('_') unless namespaces.empty?
 
         # Initialize polymorphic, singleton, scopes and belongs_to parameters
-        base.parents_symbols      = []
-        base.scopes_configuration = {}
-        base.resources_configuration[:polymorphic] = { :symbols => [], :optional => false }
-
-        # Create helpers
-        InheritedResources::UrlHelpers.create_resources_url_helpers!(base)
+        self.parents_symbols      = []
+        self.scopes_configuration = {}
+        self.resources_configuration[:polymorphic] = { :symbols => [], :optional => false }
       end
 
   end

data/lib/inherited_resources/singleton_helpers.rb

@@ -80,8 +80,8 @@ module InheritedResources
 
       # Returns the appropriated method to build the resource.
       #
-      def method_for_build #:nodoc:
-        "build_#{resource_instance_name}"
+      def method_for_association_build #:nodoc:
+        :"build_#{resource_instance_name}"
       end
 
       # Sets the method_for_association_chain to nil. See <tt>resource</tt>

data/lib/inherited_resources/url_helpers.rb

@@ -39,10 +39,9 @@ module InheritedResources
     # When we are using polymorphic associations, those helpers rely on 
     # polymorphic_url Rails helper.
     #
-    def self.create_resources_url_helpers!(base)
+    def create_resources_url_helpers!
       resource_segments, resource_ivars = [], []
-      resource_config = base.resources_configuration[:self]
-      polymorphic = false
+      resource_config = self.resources_configuration[:self]
 
       # Add route_prefix if any.
       resource_segments << resource_config[:route_prefix] unless resource_config[:route_prefix].blank?
@@ -51,150 +50,108 @@ module InheritedResources
       # Remember that we don't have to build the segments in polymorphic cases,
       # because the url will be polymorphic_url.
       #
-      base.parents_symbols.map do |symbol|
+      self.parents_symbols.each do |symbol|
         if symbol == :polymorphic
-          polymorphic = true
           resource_ivars << :parent
         else
-          config = base.resources_configuration[symbol]
+          config = self.resources_configuration[symbol]
           resource_segments << config[:route_name]
-          resource_ivars    << config[:instance_name]
+          resource_ivars    << :"@#{config[:instance_name]}"
         end
       end
 
-      # Deals with singleton.
+      singleton   = self.resources_configuration[:self][:singleton]
+      polymorphic = self.parents_symbols.include?(:polymorphic)
+
+      collection_ivars    = resource_ivars.dup
+      collection_segments = resource_segments.dup
+
+      # This is the default route configuration, later we have to deal with
+      # exception from polymorphic and singleton cases.
       #
-      # If not a singleton, we add the current collection name and build the
-      # collection url. It can build for example:
+      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_tasks_url
+      #   project_manager_url(@project)
       #
-      # If it's a singleton we also build a collection, just for compatibility.
-      # 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(@project).
+      # Instead of:
       #
-      # This is where you are going to be redirected after destroying the manager.
+      #   project_manager_url(@project, @manager)
       #
-      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
-      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[:route_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 show url if singleton.
-      # Singletons are simply:
+      # 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:
       #
-      #   edit_project_manager_url(@project)
+      #    project_url(@project)
       #
-      # Instead of:
+      # If the singleton does not have a parent, it will default to root_url.
       #
-      #   edit_project_manager_url(@project, @manager)
+      # Finally, polymorphic cases we have to give hints to the polymorphic url
+      # builder. This works by attaching new ivars as symbols or records.
       #
-      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) #:nodoc:
-        ivars = resource_ivars.map{|i| i == :parent ? :parent : "@#{i}" }
+      if singleton
+        collection_segments.pop
+        resource_ivars.pop
 
-        # 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.resources_configuration[:self][:singleton] || ivars.empty? ||
-               name == :collection || prefix == :new
-          ivars.push "(given_args.first || #{ivars.pop})"
+        if polymorphic
+          resource_ivars << resource_config[:instance_name].inspect
+          new_ivars       = resource_ivars
         end
+      elsif polymorphic
+        collection_ivars << 'resource_class.new'
+      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.
-          #
-          # Let's take the projects and companies where each one has one manager
-          # example. The url helpers would be:
-          #
-          #   company_manager_url(@company)
-          #   project_manager_url(@project)
-          #
-          # Notice how the manager is not sent in the helper, because it's a
-          # singleton. So, polymorphic urls would be:
-          #
-          #   polymorphic_url(@company)
-          #   polymorphic_url(@project)
-          #
-          # Obviously, this won't work properly. So in such polymorphic with
-          # singletons cases we have to do this:
-          #
-          #   polymorphic_url(@company, 'manager')
-          #   polymorphic_url(@project, 'manager')
-          #
-          # This is exactly what we are doing here.
-          #
-          # The other case to handle is collection and new helpers with
-          # polymorphic urls. In such cases, we usually would not send anything:
-          #
-          #   project_tasks_url(@project)
-          #   new_project_task_url(@project)
-          #
-          # But this wouldn't work with polymorphic urls by the same reason as
-          # singletons:
-          #
-          #   polymorphic_url(@project)
-          #   new_polymorphic_url(@project)
-          #
-          # So we have to do this:
-          #
-          #   polymorphic_url(@project, Task.new)
-          #   new_polymorphic_url(@project, Task.new)
-          #
-          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'
-          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
 
-          ivars  = "[#{ivars.join(', ')}]"
+    def generate_url_and_path_helpers(prefix, name, resource_segments, resource_ivars) #:nodoc:
+      ivars = resource_ivars.dup
 
-          # Add compact to deal with polymorphic optional associations.
-          ivars << '.compact' if base.resources_configuration[:polymorphic][:optional]
-        else
-          # In the last case, if segments is empty (this usually happens with
-          # root singleton resources, we set it to root)
-          #
-          segments = resource_segments.empty? ? 'root' : resource_segments.join('_')
-          ivars    = ivars.join(', ')
-        end
+      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 || ivars.empty? || name == :collection || prefix == :new
+        ivars.push "(given_args.first || #{ivars.pop})"
+      end
 
-        prefix = prefix ? "#{prefix}_" : ''
+      # 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
 
-        # Add given_options to ivars
-        ivars << (ivars.empty? ? 'given_options' : ', given_options')
+      prefix = prefix ? "#{prefix}_" : ''
+      ivars << (ivars.empty? ? 'given_options' : ', given_options')
 
-        base.class_eval <<URL_HELPERS, __FILE__, __LINE__
-protected
-  def #{prefix}#{name}_path(*given_args)
-    given_options = given_args.extract_options!
-    #{prefix}#{segments}_path(#{ivars})
-  end
+      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
+          def #{prefix}#{name}_url(*given_args)
+            given_options = given_args.extract_options!
+            #{prefix}#{segments}_url(#{ivars})
+          end
+      URL_HELPERS
     end
 
   end

data/test/aliases_test.rb

@@ -4,7 +4,8 @@ class Student;
   def self.human_name; 'Student'; end
 end
 
-class StudentsController < InheritedResources::Base
+class StudentsController < ApplicationController
+  inherit_resources
 
   def edit
     edit! do |format|

data/test/base_test.rb

@@ -4,7 +4,10 @@ class User
   def self.human_name; 'User'; end
 end
 
-class UsersController < InheritedResources::Base
+class AccountsController < InheritedResources::Base
+end
+
+class UsersController < AccountsController
   respond_to :html, :xml
 end
 

data/test/class_methods_test.rb

@@ -81,7 +81,7 @@ class DefaultsClassMethodTest < ActiveSupport::TestCase
   end
 
   def test_url_helpers_are_recreated_when_defaults_change
-    InheritedResources::UrlHelpers.expects(:create_resources_url_helpers!).returns(true).once
+    BooksController.expects(:create_resources_url_helpers!).returns(true).once
     BooksController.send(:defaults, :instance_name => 'string', :collection_name => 'strings')
   end
 end
@@ -104,7 +104,7 @@ class BelongsToErrorsTest < ActiveSupport::TestCase
   end
 
   def test_url_helpers_are_recreated_just_once_when_belongs_to_is_called_with_block
-    InheritedResources::UrlHelpers.expects(:create_resources_url_helpers!).returns(true).once
+    DeansController.expects(:create_resources_url_helpers!).returns(true).once
     DeansController.send(:belongs_to, :school) do
       belongs_to :association
     end
@@ -113,7 +113,7 @@ class BelongsToErrorsTest < ActiveSupport::TestCase
   end
 
   def test_url_helpers_are_recreated_just_once_when_belongs_to_is_called_with_multiple_blocks
-    InheritedResources::UrlHelpers.expects(:create_resources_url_helpers!).returns(true).once
+    DeansController.expects(:create_resources_url_helpers!).returns(true).once
     DeansController.send(:belongs_to, :school) do
       belongs_to :association do
         belongs_to :nested

data/test/redirect_to_test.rb

@@ -1,63 +1,10 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class SuperMachine;
-  def self.human_name; 'Machine'; end
-end
-
-# Use this to test blocks with multiple arity in the future.
-class SuperMachinesController < InheritedResources::Base
-  def create
-    create!('http://test.host/')
-  end
-
-  def update
-    update!('http://test.host/')
-  end
-
-  def destroy
-    destroy!('http://test.host/')
-  end
-end
-
-class RedirectToWithArgumentTest < ActionController::TestCase
-  tests SuperMachinesController
-
-  def test_redirect_to_the_given_url_on_create
-    ActiveSupport::Deprecation.expects(:warn).with('create!(redirect_url) is deprecated. Use create!{ redirect_url } instead.', [nil])
-    SuperMachine.stubs(:new).returns(mock_machine(:save => true))
-    @controller.expects(:resource_url).times(0)
-    post :create
-    assert_redirected_to 'http://test.host/'
-  end
-
-  def test_redirect_to_the_given_url_on_update
-    ActiveSupport::Deprecation.expects(:warn).with('update!(redirect_url) is deprecated. Use update!{ redirect_url } instead.', [nil])
-    SuperMachine.stubs(:find).returns(mock_machine(:update_attributes => true))
-    @controller.expects(:resource_url).times(0)
-    put :update
-    assert_redirected_to 'http://test.host/'
-  end
-
-  def test_redirect_to_the_given_url_on_destroy
-    ActiveSupport::Deprecation.expects(:warn).with('destroy!(redirect_url) is deprecated. Use destroy!{ redirect_url } instead.', [nil])
-    SuperMachine.stubs(:find).returns(mock_machine(:destroy => true))
-    @controller.expects(:collection_url).times(0)
-    delete :destroy
-    assert_redirected_to 'http://test.host/'
-  end
-
-  protected
-    def mock_machine(stubs={})
-      @mock_machine ||= mock(stubs)
-    end
-end
-
 class Machine;
   def self.human_name; 'Machine'; end
 end
 
 class MachinesController < InheritedResources::Base
-
   def create
     create!{ complex_url(:create, true, true) }
   end
@@ -106,3 +53,25 @@ class RedirectToWithBlockTest < ActionController::TestCase
     end
 end
 
+
+# Use this to test blocks with multiple arity in the future.
+class SuperMachinesController < InheritedResources::Base
+  defaults :resource_class => Machine
+
+  def create
+    create! do |arg1, arg2, arg3|
+      # nothing
+    end
+  end
+end
+
+class RedirectToArityTest < ActionController::TestCase
+  tests SuperMachinesController
+
+  def test_redirect_to_the_given_url_on_create
+    Machine.stubs(:new).returns(:anything)
+    assert_raise ScriptError, /arity/ do
+      post :create
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: josevalim-inherited_resources
 version: !ruby/object:Gem::Version 
-  version: 0.7.3
+  version: 0.8.1
 platform: ruby
 authors: 
 - "Jos\xC3\xA9 Valim"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-28 00:00:00 -07:00
+date: 2009-05-23 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -28,6 +28,7 @@ files:
 - Rakefile
 - init.rb
 - lib/inherited_resources.rb
+- lib/inherited_resources/actions.rb
 - lib/inherited_resources/base.rb
 - lib/inherited_resources/base_helpers.rb
 - lib/inherited_resources/belongs_to_helpers.rb