inherited_resources 1.1.2 → 1.2.0

data/lib/inherited_resources/base_helpers.rb

@@ -20,7 +20,7 @@ module InheritedResources
       #   end
       #
       def collection
-        get_collection_ivar || set_collection_ivar(end_of_association_chain.find(:all))
+        get_collection_ivar || set_collection_ivar(end_of_association_chain.all)
       end
 
       # This is how the resource is loaded.
@@ -38,7 +38,7 @@ module InheritedResources
       # probably render a 500 error message.
       #
       def resource
-        get_resource_ivar || set_resource_ivar(end_of_association_chain.find(params[:id]))
+        get_resource_ivar || set_resource_ivar(end_of_association_chain.send(method_for_find, params[:id]))
       end
 
       # This method is responsable for building the object on :new and :create
@@ -46,7 +46,7 @@ module InheritedResources
       # instance variable.
       #
       def build_resource
-        get_resource_ivar || set_resource_ivar(end_of_association_chain.send(method_for_build, params[resource_instance_name] || {}))
+        get_resource_ivar || set_resource_ivar(end_of_association_chain.send(method_for_build, params[resource_request_name] || {}))
       end
 
       # Responsible for saving the resource on :create method. Overwriting this
@@ -155,6 +155,10 @@ module InheritedResources
         self.resources_configuration[:self][:instance_name]
       end
 
+      def resource_request_name
+        self.resources_configuration[:self][:request_name]
+      end
+
       # This methods gets your begin_of_association_chain, join it with your
       # parents chain and returns the scoped association.
       #
@@ -195,6 +199,11 @@ module InheritedResources
         resource_collection_name
       end
 
+      # Returns finder method for instantiate resource by params[:id]
+      def method_for_find
+        resources_configuration[:self][:finder] || :find
+      end
+
       # Get resource ivar based on the current resource controller.
       #
       def get_resource_ivar #:nodoc:
@@ -265,6 +274,26 @@ module InheritedResources
         []
       end
 
+      # URL to redirect to when redirect implies resource url.
+      def smart_resource_url
+        url = nil
+        if respond_to? :show
+          url = resource_url rescue nil
+        end
+        url ||= smart_collection_url
+      end
+
+      # URL to redirect to when redirect implies collection url.
+      def smart_collection_url
+        url = nil
+        if respond_to? :index
+          url ||= collection_url rescue nil
+        end
+        if respond_to? :parent
+          url ||= parent_url rescue nil
+        end
+        url ||= root_url rescue nil
+      end
   end
 end
 

data/lib/inherited_resources/class_methods.rb

@@ -30,22 +30,31 @@ module InheritedResources
       #
       # * <tt>:singleton</tt> - Tells if this controller is singleton or not.
       #
+      # * <tt>:finder</tt> - Specifies which method should be called to instantiate the resource.
+      #
+      #     defaults :project, :finder => :find_by_slug
+      #
       def defaults(options)
         raise ArgumentError, 'Class method :defaults expects a hash of options.' unless options.is_a? Hash
 
         options.symbolize_keys!
         options.assert_valid_keys(:resource_class, :collection_name, :instance_name,
                                   :class_name, :route_prefix, :route_collection_name,
-                                  :route_instance_name, :singleton)
+                                  :route_instance_name, :singleton, :finder)
 
-        self.resource_class = options.delete(:resource_class)         if options.key?(:resource_class)
-        self.resource_class = options.delete(:class_name).constantize if options.key?(:class_name)
+        self.resource_class = options[:resource_class] if options.key?(:resource_class)
+        self.resource_class = options[:class_name].constantize if options.key?(:class_name)
 
         acts_as_singleton! if options.delete(:singleton)
 
         config = self.resources_configuration[:self]
         config[:route_prefix] = options.delete(:route_prefix) if options.key?(:route_prefix)
 
+        if options.key?(:resource_class) or options.key?(:class_name)
+          config[:request_name] = self.resource_class.to_s.underscore.gsub('/', '_')
+          options.delete(:resource_class) and options.delete(:class_name)
+        end
+
         options.each do |key, value|
           config[key] = value.to_sym
         end
@@ -132,9 +141,10 @@ module InheritedResources
         options.symbolize_keys!
         options.assert_valid_keys(:class_name, :parent_class, :instance_name, :param,
                                   :finder, :route_name, :collection_name, :singleton,
-                                  :polymorphic, :optional)
+                                  :polymorphic, :optional, :shallow)
 
         optional    = options.delete(:optional)
+        shallow     = options.delete(:shallow)
         singleton   = options.delete(:singleton)
         polymorphic = options.delete(:polymorphic)
         finder      = options.delete(:finder)
@@ -143,6 +153,7 @@ module InheritedResources
 
         acts_as_singleton!   if singleton
         acts_as_polymorphic! if polymorphic || optional
+        acts_as_shallow!     if shallow
 
         raise ArgumentError, 'You have to give me at least one association name.' if symbols.empty?
         raise ArgumentError, 'You cannot define multiple associations with options: #{options.keys.inspect} to belongs to.' unless symbols.size == 1 || options.empty?
@@ -158,6 +169,8 @@ module InheritedResources
             self.parents_symbols << symbol
           end
 
+          self.resources_configuration[:self][:shallow] = true if shallow
+
           config = self.resources_configuration[symbol] = {}
 
           config[:parent_class] = options.delete(:parent_class) || begin
@@ -180,6 +193,7 @@ module InheritedResources
         else
           create_resources_url_helpers!
         end
+        helper_method :parent, :parent?
       end
       alias :nested_belongs_to :belongs_to
 
@@ -207,6 +221,40 @@ module InheritedResources
         belongs_to(*symbols << options, &block)
       end
 
+      # Defines custom restful actions by resource or collection basis.
+      #
+      #   custom_actions :resource => [:delete, :transit], :collection => :search
+      #
+      # == Options
+      #
+      # * <tt>:resource</tt> -  Allows you to specify resource actions.
+      #     custom_actions :resource => :delete
+      #                         This macro creates 'delete' method in controller and defines
+      #                         delete_reource_{path,url} helpers. The body of generated 'delete'
+      #                         method is same as 'show' method. So you can override it if need
+      #
+      # * <tt>:collection</tt> - Allows you to specify collection actions.
+      #     custom_actions :collection => :search
+      #                         This macro creates 'search' method in controller and defines
+      #                         search_reources_{path,url} helpers. The body of generated 'search'
+      #                         method is same as 'index' method. So you can override it if need
+      #
+      def custom_actions(options)
+        self.resources_configuration[:self][:custom_actions] = options
+        options.each do | resource_or_collection, actions |
+          [*actions].each do | action |
+            create_custom_action(resource_or_collection, action)
+          end
+        end
+        create_resources_url_helpers!
+        [*options[:resource]].each do | action |
+          helper_method "#{action}_resource_path", "#{action}_resource_url"
+        end
+        [*options[:collection]].each do | action |
+          helper_method "#{action}_resources_path", "#{action}_resources_url"
+        end
+      end
+
     private
 
       def acts_as_singleton! #:nodoc:
@@ -220,15 +268,35 @@ module InheritedResources
       def acts_as_polymorphic! #:nodoc:
         unless self.parents_symbols.include?(:polymorphic)
           include PolymorphicHelpers
-          helper_method :parent, :parent_type, :parent_class, :parent?
+          helper_method :parent_type, :parent_class
         end
       end
 
+      def acts_as_shallow! #:nodoc:
+        include ShallowHelpers
+      end
+
       # Initialize resources class accessors and set their default values.
       #
       def initialize_resources_class_accessors! #:nodoc:
-        # Initialize resource class
+        # First priority is the namespaced modek, e.g. User::Group
         self.resource_class = begin
+          namespaced_class = self.name.sub(/Controller/, '').singularize
+          namespaced_class.constantize
+        rescue NameError
+          nil
+        end
+
+        # Second priority the camelcased c, i.e. UserGroup
+        self.resource_class ||= begin
+          camelcased_class = self.name.sub(/Controller/, '').gsub('::', '').singularize
+          camelcased_class.constantize
+        rescue NameError
+          nil
+        end
+
+        # Otherwise use the Group class, or fail
+        self.resource_class ||= begin
           class_name = self.controller_name.classify
           class_name.constantize
         rescue NameError => e
@@ -236,9 +304,16 @@ module InheritedResources
           nil
         end
 
+        self.parents_symbols = self.parents_symbols.try(:dup) || []
+
         # Initialize resources configuration hash
-        self.resources_configuration ||= {}
-        config = self.resources_configuration[:self] = {}
+        self.resources_configuration = self.resources_configuration.try(:dup) || {}
+        self.resources_configuration.each do |key, value|
+          next unless value.is_a?(Hash) || value.is_a?(Array)
+          self.resources_configuration[key] = value.dup
+        end
+
+        config = (self.resources_configuration[:self] ||= {})
         config[:collection_name] = self.controller_name.to_sym
         config[:instance_name]   = self.controller_name.singularize.to_sym
 
@@ -249,9 +324,26 @@ module InheritedResources
         namespaces = self.controller_path.split('/')[0..-2]
         config[:route_prefix] = namespaces.join('_') unless namespaces.empty?
 
+        # Deal with default request parameters in namespaced controllers, e.g.
+        # Forum::Thread#create will properly pick up the request parameter
+        # which will be forum_thread, and not thread
+        # Additionally make this work orthogonally with instance_name
+        config[:request_name] = self.name.sub(/Controller$/, '').underscore.gsub('/', '_').singularize
+
         # Initialize polymorphic, singleton, scopes and belongs_to parameters
-        self.parents_symbols ||= []
-        self.resources_configuration[:polymorphic] ||= { :symbols => [], :optional => false }
+        polymorphic = self.resources_configuration[:polymorphic] || { :symbols => [], :optional => false }
+        polymorphic[:symbols] = polymorphic[:symbols].dup
+        self.resources_configuration[:polymorphic] = polymorphic
+      end
+
+      def create_custom_action(resource_or_collection, action)
+        class_eval <<-CUSTOM_ACTION, __FILE__, __LINE__
+          def #{action}(options={}, &block)
+            respond_with(*(with_chain(#{resource_or_collection}) << options), &block)
+          end
+          alias :#{action}! :#{action}
+          protected :#{action}!
+        CUSTOM_ACTION
       end
 
       # Hook called on inheritance.

data/lib/inherited_resources/shallow_helpers.rb

@@ -0,0 +1,87 @@
+module InheritedResources
+  # = belongs_to
+  #
+  # Let's suppose that we have some tasks that belongs to projects. To specify
+  # this assoication in your controllers, just do:
+  #
+  #    class TasksController < InheritedResources::Base
+  #      belongs_to :project
+  #    end
+  #
+  # belongs_to accepts several options to be able to configure the association.
+  # For example, if you want urls like /projects/:project_title/tasks, you
+  # can customize how InheritedResources find your projects:
+  #
+  #    class TasksController < InheritedResources::Base
+  #      belongs_to :project, :finder => :find_by_title!, :param => :project_title
+  #    end
+  #
+  # It also accepts :route_name, :parent_class and :instance_name as options.
+  # Check the lib/inherited_resources/class_methods.rb for more.
+  #
+  # = nested_belongs_to
+  #
+  # Now, our Tasks get some Comments and you need to nest even deeper. Good
+  # practices says that you should never nest more than two resources, but sometimes
+  # you have to for security reasons. So this is an example of how you can do it:
+  #
+  #    class CommentsController < InheritedResources::Base
+  #      nested_belongs_to :project, :task
+  #    end
+  #
+  # If you need to configure any of these belongs to, you can nested them using blocks:
+  #
+  #    class CommentsController < InheritedResources::Base
+  #      belongs_to :project, :finder => :find_by_title!, :param => :project_title do
+  #        belongs_to :task
+  #      end
+  #    end
+  #
+  # Warning: calling several belongs_to is the same as nesting them:
+  #
+  #    class CommentsController < InheritedResources::Base
+  #      belongs_to :project
+  #      belongs_to :task
+  #    end
+  #
+  # In other words, the code above is the same as calling nested_belongs_to.
+  #
+  module ShallowHelpers
+    include BelongsToHelpers
+
+    private
+
+      # Evaluate the parent given. This is used to nest parents in the
+      # association chain.
+      #
+
+      # Maps parents_symbols to build association chain. In this case, it
+      # simply return the parent_symbols, however on polymorphic belongs to,
+      # it has some customization.
+      #
+      def symbols_for_association_chain #:nodoc:
+        parent_symbols = parents_symbols.dup
+        if parents_symbols.size > 1 && !params[:id]
+          inst_class_name = parent_symbols.pop
+          finder_method = resources_configuration[inst_class_name][:finder] || :find
+          instance = resources_configuration[inst_class_name][:parent_class].send(finder_method, params[resources_configuration[inst_class_name][:param]])
+          load_parents(instance, parent_symbols)
+        end
+        if params[:id]
+          finder_method = resources_configuration[:self][:finder] || :find
+          instance = self.resource_class.send(finder_method, params[:id])
+          load_parents(instance, parent_symbols)
+        end
+        parents_symbols
+      end
+
+      def load_parents(instance, parent_symbols)
+
+        parent_symbols.reverse.each do |parent|
+          instance = instance.send(parent)
+          params[resources_configuration[parent][:param]] = instance.to_param
+        end
+      end
+  end
+
+end

data/lib/inherited_resources/url_helpers.rb

@@ -32,6 +32,7 @@ module InheritedResources
   # all created when you inherit.
   #
   module UrlHelpers
+    protected
 
     # This method hard code url helpers in the class.
     #
@@ -39,7 +40,7 @@ module InheritedResources
     # is being processed (and even more cheaper when we are using nested
     # resources).
     #
-    # When we are using polymorphic associations, those helpers rely on 
+    # When we are using polymorphic associations, those helpers rely on
     # polymorphic_url Rails helper.
     #
     def create_resources_url_helpers!
@@ -75,6 +76,7 @@ module InheritedResources
       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
@@ -120,15 +122,59 @@ module InheritedResources
         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
+
+      if resource_config[:custom_actions]
+        [*resource_config[:custom_actions][:resource]].each do | method |
+          generate_url_and_path_helpers method, :resource, resource_segments, resource_ivars
+        end
+        [*resource_config[:custom_actions][:collection]].each do | method |
+          generate_url_and_path_helpers method, :resources, collection_segments, collection_ivars
+        end
+      end
+    end
+
+    def handle_shallow_resource(prefix, name, segments, ivars) #:nodoc:
+      return segments, ivars unless self.resources_configuration[:self][:shallow]
+      case name
+      when :collection, :resources
+        segments = segments[-2..-1]
+        ivars = [ivars.last]
+      when :resource
+        if prefix == :new
+          segments = segments[-2..-1]
+          ivars = [ivars.last]
+        else
+          segments = [segments.last]
+          ivars = [ivars.last]
+        end
+      when :parent
+        segments = [segments.last]
+        ivars = [ivars.last]
+      end
+
+      segments ||= []
+
+      unless self.resources_configuration[:self][:route_prefix].blank?
+        segments.unshift self.resources_configuration[:self][:route_prefix]
+      end
+
+      return segments, ivars
     end
 
     def generate_url_and_path_helpers(prefix, name, resource_segments, resource_ivars) #:nodoc:
-      ivars = resource_ivars.dup
+      resource_segments, resource_ivars = handle_shallow_resource(prefix, name, resource_segments, resource_ivars)
 
+      ivars       = resource_ivars.dup
       singleton   = self.resources_configuration[:self][:singleton]
       polymorphic = self.parents_symbols.include?(:polymorphic)
 

data/lib/inherited_resources/version.rb

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

data/test/aliases_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require File.expand_path('test_helper', File.dirname(__FILE__))
 
 class Student
   extend ActiveModel::Naming