karsthammer-inherited_resources 1.1.2.1 → 1.2.1

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
@@ -208,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:
@@ -225,11 +272,31 @@ module InheritedResources
         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
@@ -237,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
 
@@ -250,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.resource_class.to_s.underscore.gsub('/', '_')
+
         # 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
@@ -119,9 +121,9 @@ module InheritedResources
       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
@@ -130,11 +132,49 @@ module InheritedResources
       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.1'.freeze
 end

data/lib/karsthammer-inherited_resources.rb

@@ -6,6 +6,7 @@ module InheritedResources
   autoload :Actions,            'inherited_resources/actions'
   autoload :Base,               'inherited_resources/base'
   autoload :BaseHelpers,        'inherited_resources/base_helpers'
+  autoload :ShallowHelpers,     'inherited_resources/shallow_helpers'
   autoload :BelongsToHelpers,   'inherited_resources/belongs_to_helpers'
   autoload :ClassMethods,       'inherited_resources/class_methods'
   autoload :DSL,                'inherited_resources/dsl'
@@ -21,7 +22,11 @@ module InheritedResources
 
   class Railtie < ::Rails::Railtie
     config.inherited_resources = InheritedResources
-    config.generators.scaffold_controller = :inherited_resources_controller
+    if config.respond_to?(:app_generators)
+      config.app_generators.scaffold_controller = :inherited_resources_controller
+    else
+      config.generators.scaffold_controller = :inherited_resources_controller
+    end
   end
 end
 
@@ -34,4 +39,4 @@ class ActionController::Base
     initialize_resources_class_accessors!
     create_resources_url_helpers!
   end
-end
+end

data/test/base_test.rb

@@ -29,34 +29,40 @@ module UserTestHelper
   end
 
   protected
-  
-    def mock_user(expectations={})
-      @mock_user ||= begin
-        user = mock(expectations.except(:errors))
-        user.stubs(:class).returns(User)
-        user.stubs(:errors).returns(expectations.fetch(:errors, {})) 
-        user
+
+  def mock_user(expectations={})
+    @mock_user ||= begin
+      user = mock(expectations.except(:errors))
+      user.stubs(:class).returns(User)
+      user.stubs(:errors).returns(expectations.fetch(:errors, {}))
+      user.singleton_class.class_eval do
+        def method_missing(symbol, *arguments, &block)
+          raise NoMethodError.new('this is expected by Array#flatten') if symbol == :to_ary
+          super
+        end
       end
+      user
     end
+  end
 end
 
 class IndexActionBaseTest < ActionController::TestCase
   include UserTestHelper
 
   def test_expose_all_users_as_instance_variable
-    User.expects(:all).returns([mock_user])
+    User.expects(:scoped).returns([mock_user])
     get :index
     assert_equal [mock_user], assigns(:users)
   end
 
   def test_apply_scopes_if_method_is_available
-    User.expects(:all).returns([mock_user])
+    User.expects(:scoped).returns([mock_user])
     get :index
     assert @controller.scopes_applied
   end
 
   def test_controller_should_render_index
-    User.stubs(:all).returns([mock_user])
+    User.stubs(:scoped).returns([mock_user])
     get :index
     assert_response :success
     assert_equal 'Index HTML', @response.body.strip
@@ -64,12 +70,18 @@ class IndexActionBaseTest < ActionController::TestCase
 
   def test_render_all_users_as_xml_when_mime_type_is_xml
     @request.accept = 'application/xml'
-    User.expects(:all).returns(mock_user)
-    mock_user.expects(:to_xml).returns('Generated XML')
+    User.expects(:scoped).returns(collection = [mock_user])
+    collection.expects(:to_xml).returns('Generated XML')
     get :index
     assert_response :success
     assert_equal 'Generated XML', @response.body
   end
+
+  def test_scoped_is_called_only_when_available
+    User.stubs(:all).returns([mock_user])
+    get :index
+    assert_equal Array, assigns(:users).class
+  end
 end
 
 class ShowActionBaseTest < ActionController::TestCase
@@ -201,6 +213,14 @@ class UpdateActionBaseTest < ActionController::TestCase
     assert_redirected_to 'http://test.host/'
   end
 
+  def test_redirect_to_the_users_list_if_show_undefined
+    @controller.class.send(:actions, :all, :except => :show)
+    User.stubs(:find).returns(mock_user(:update_attributes => true))
+    @controller.expects(:collection_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
@@ -229,7 +249,7 @@ end
 
 class DestroyActionBaseTest < ActionController::TestCase
   include UserTestHelper
-  
+
   def test_the_requested_user_is_destroyed
     User.expects(:find).with('42').returns(mock_user)
     mock_user.expects(:destroy).returns(true)