inherited_resources 0.9.5 → 1.0.pre

data/lib/inherited_resources/belongs_to_helpers.rb

@@ -56,6 +56,14 @@ module InheritedResources
       def parent?
         true
       end
+      
+      def parent
+        @parent ||= association_chain[-1]
+      end
+      
+      def parent_type
+        parent.class.name.underscore.to_sym
+      end
 
     private
 

data/lib/inherited_resources/blank_slate.rb

@@ -0,0 +1,12 @@
+module InheritedResources
+  # An object from BlankSlate simply discards all messages sent to it.
+  class BlankSlate
+    instance_methods.each do |m|
+      undef_method m unless m =~ /^(__|object_id)/
+    end
+
+    def method_missing(*args)
+      nil
+    end
+  end
+end

data/lib/inherited_resources/class_methods.rb

@@ -71,86 +71,6 @@ module InheritedResources
         end
       end
 
-      # Detects params from url and apply as scopes to your classes.
-      #
-      # Your model:
-      #
-      #   class Graduation < ActiveRecord::Base
-      #     named_scope :featured, :conditions => { :featured => true }
-      #     named_scope :by_degree, proc {|degree| { :conditions => { :degree => degree } } }
-      #   end
-      #
-      # Your controller:
-      #
-      #   class GraduationsController < InheritedResources::Base
-      #     has_scope :featured, :boolean => true, :only => :index
-      #     has_scope :by_degree, :only => :index
-      #   end
-      #
-      # Then for each request:
-      #
-      #   /graduations
-      #   #=> acts like a normal request
-      #
-      #   /graduations?featured=true
-      #   #=> calls the named scope and bring featured graduations
-      #
-      #   /graduations?featured=true&by_degree=phd
-      #   #=> brings featured graduations with phd degree
-      #
-      # You can retrieve the current scopes in use with <tt>current_scopes</tt>
-      # method. In the last case, it would return: { :featured => "true", :by_degree => "phd" }
-      #
-      # == Options
-      #
-      # * <tt>:boolean</tt> - When set to true, call the scope only when the param is true or 1,
-      #                       and does not send the value as argument.
-      #
-      # * <tt>:only</tt> - In which actions the scope is applied. By default is :all.
-      #
-      # * <tt>:except</tt> - In which actions the scope is not applied. By default is :none.
-      #
-      # * <tt>:as</tt> - The key in the params hash expected to find the scope.
-      #                  Defaults to the scope name.
-      #
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
-      #                  if the scope should apply
-      #
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
-      #                      if the scope should NOT apply.
-      #
-      # * <tt>:default</tt> - Default value for the scope. Whenever supplied the scope
-      #                       is always called. This is useful to add easy pagination.
-      #
-      def has_scope(*scopes)
-        options = scopes.extract_options!
-
-        options.symbolize_keys!
-        options.assert_valid_keys(:boolean, :key, :only, :except,
-                                  :if, :unless, :default, :as)
-
-        if options[:key]
-          ActiveSupport::Deprecation.warn "has_scope :key is deprecated, use :as instead"
-          options[:as] ||= options[:key]
-        end
-
-        if self.scopes_configuration.empty?
-          include HasScopeHelpers
-          helper_method :current_scopes
-        end
-
-        scopes.each do |scope|
-          self.scopes_configuration[scope]         ||= {}
-          self.scopes_configuration[scope][:as]      = options[:as] || scope
-          self.scopes_configuration[scope][:only]    = Array(options[:only])
-          self.scopes_configuration[scope][:except]  = Array(options[:except])
-
-          [:if, :unless, :boolean, :default].each do |opt|
-            self.scopes_configuration[scope][opt] = options[opt] if options.key?(opt)
-          end
-        end
-      end
-
       # Defines that this controller belongs to another resource.
       #
       #   belongs_to :projects
@@ -239,8 +159,13 @@ module InheritedResources
           end
 
           config = self.resources_configuration[symbol] = {}
-          config[:parent_class]    = options.delete(:parent_class)
-          config[:parent_class]  ||= (options.delete(:class_name) || symbol).to_s.pluralize.classify.constantize rescue nil
+
+          config[:parent_class] = options.delete(:parent_class) || begin
+            (options.delete(:class_name) || symbol).to_s.pluralize.classify.constantize
+          rescue NameError
+            nil
+          end
+
           config[:collection_name] = options.delete(:collection_name) || symbol.to_s.pluralize.to_sym
           config[:instance_name]   = options.delete(:instance_name) || symbol
           config[:param]           = options.delete(:param) || :"#{symbol}_id"
@@ -321,8 +246,7 @@ module InheritedResources
         config[:route_prefix] = namespaces.join('_') unless namespaces.empty?
 
         # Initialize polymorphic, singleton, scopes and belongs_to parameters
-        self.parents_symbols      ||= []
-        self.scopes_configuration ||= {}
+        self.parents_symbols ||= []
         self.resources_configuration[:polymorphic] ||= { :symbols => [], :optional => false }
       end
 

data/lib/inherited_resources/legacy/respond_to.rb

@@ -2,6 +2,16 @@ module ActionController #:nodoc:
   class Base #:nodoc:
     attr_accessor :formats
 
+    class_inheritable_accessor :mimes_for_respond_to, :responder, :instance_writer => false
+
+    self.responder = ActionController::Responder
+    self.mimes_for_respond_to = ActiveSupport::OrderedHash.new
+
+    if defined?(ApplicationController)
+      ApplicationController.responder ||= ActionController::Responder
+      ApplicationController.mimes_for_respond_to ||= ActiveSupport::OrderedHash.new
+    end
+
     # Defines mimes that are rendered by default when invoking respond_with.
     #
     # Examples:
@@ -25,6 +35,7 @@ module ActionController #:nodoc:
     #
     def self.respond_to(*mimes)
       options = mimes.extract_options!
+      clear_respond_to unless mimes_for_respond_to
 
       only_actions   = Array(options.delete(:only))
       except_actions = Array(options.delete(:except))
@@ -38,19 +49,10 @@ module ActionController #:nodoc:
     end
 
     # Clear all mimes in respond_to.
-    #
     def self.clear_respond_to
       write_inheritable_attribute(:mimes_for_respond_to, ActiveSupport::OrderedHash.new)
     end
 
-    class_inheritable_reader :mimes_for_respond_to
-    clear_respond_to
-
-    # If ApplicationController is already defined around here, we have to set
-    # mimes_for_respond_to hash as well.
-    #
-    ApplicationController.clear_respond_to if defined?(ApplicationController)
-
     def respond_to(*mimes, &block)
       raise ArgumentError, "respond_to takes either types or a block, never both" if mimes.any? && block_given?
       if response = retrieve_response_from_mimes(mimes, &block)
@@ -66,10 +68,6 @@ module ActionController #:nodoc:
       end
     end
 
-    def responder
-      ActionController::Responder
-    end
-
   protected
 
     # Collect mimes declared in the class method respond_to valid for the

data/lib/inherited_resources/legacy/responder.rb

@@ -14,12 +14,11 @@ module ActionController #:nodoc:
   #
   # When a request comes, for example with format :xml, three steps happen:
   #
-  #   1) respond_with searches for a template at people/index.xml;
+  #   1) responder searches for a template at people/index.xml;
   #
-  #   2) if the template is not available, it will create a responder, passing
-  #      the controller and the resource and invoke :to_xml on it;
+  #   2) if the template is not available, it will invoke :to_xml in the given resource;
   #
-  #   3) if the responder does not respond_to :to_xml, call to_format on it.
+  #   3) if the responder does not respond_to :to_xml, call :to_format on it.
   #
   # === Builtin HTTP verb semantics
   #
@@ -81,6 +80,11 @@ module ActionController #:nodoc:
   class Responder
     attr_reader :controller, :request, :format, :resource, :resources, :options
 
+    ACTIONS_FOR_VERBS = {
+      :post => :new,
+      :put => :edit
+    }
+
     def initialize(controller, resources, options={})
       @controller = controller
       @request = controller.request
@@ -88,22 +92,29 @@ module ActionController #:nodoc:
       @resource = resources.is_a?(Array) ? resources.last : resources
       @resources = resources
       @options = options
+      @action = options.delete(:action)
       @default_response = options.delete(:default_response)
     end
 
     delegate :head, :render, :redirect_to,   :to => :controller
     delegate :get?, :post?, :put?, :delete?, :to => :request
 
-    # Undefine :to_json since it's defined on Object
-    undef_method :to_json
+    # Undefine :to_json and :to_yaml since it's defined on Object
+    undef_method(:to_json) if method_defined?(:to_json)
+    undef_method(:to_yaml) if method_defined?(:to_yaml)
 
     # Initializes a new responder an invoke the proper format. If the format is
     # not defined, call to_format.
     #
     def self.call(*args)
-      responder = new(*args)
-      method = :"to_#{responder.format}"
-      responder.respond_to?(method) ? responder.send(method) : responder.to_format
+      new(*args).respond
+    end
+
+    # Main entry point for responder responsible to dispatch to the proper format.
+    #
+    def respond
+      method = :"to_#{format}"
+      respond_to?(method) ? send(method) : to_format
     end
 
     # HTML format does not render the resource, it always attempt to render a
@@ -111,14 +122,8 @@ module ActionController #:nodoc:
     #
     def to_html
       default_render
-    rescue ActionView::MissingTemplate
-      if get?
-        raise
-      elsif has_errors?
-        render :action => default_action
-      else
-        redirect_to resource_location
-      end
+    rescue ActionView::MissingTemplate => e
+      navigation_behavior(e)
     end
 
     # All others formats follow the procedure below. First we try to render a
@@ -127,9 +132,26 @@ module ActionController #:nodoc:
     #
     def to_format
       default_render
-    rescue ActionView::MissingTemplate
+    rescue ActionView::MissingTemplate => e
       raise unless resourceful?
+      api_behavior(e)
+    end
 
+  protected
+
+    # This is the common behavior for "navigation" requests, like :html, :iphone and so forth.
+    def navigation_behavior(error)
+      if get?
+        raise error
+      elsif has_errors? && default_action
+        render :action => default_action
+      else
+        redirect_to resource_location
+      end
+    end
+
+    # This is the common behavior for "API" requests, like :xml and :json.
+    def api_behavior(error)
       if get?
         display resource
       elsif has_errors?
@@ -141,8 +163,6 @@ module ActionController #:nodoc:
       end
     end
 
-  protected
-
     # Checks whether the resource responds to the current format or not.
     #
     def resourceful?
@@ -181,7 +201,7 @@ module ActionController #:nodoc:
     #   render :xml => @user, :status => :created
     #
     def display(resource, given_options={})
-      render given_options.merge!(options).merge!(format => resource)
+      controller.send :render, given_options.merge!(options).merge!(format => resource)
     end
 
     # Check if the resource has errors or not.
@@ -194,7 +214,7 @@ module ActionController #:nodoc:
     # the verb is post.
     #
     def default_action
-      request.post? ? :new : :edit
+      @action ||= ACTIONS_FOR_VERBS[request.method]
     end
   end
-end
+end

data/lib/inherited_resources/locales/en.yml

@@ -0,0 +1,10 @@
+en:
+  flash:
+    actions:
+      create:
+        notice: '{{resource_name}} was successfully created.'
+      update:
+        notice: '{{resource_name}} was successfully updated.'
+      destroy:
+        notice: '{{resource_name}} was successfully destroyed.'
+        alert: '{{resource_name}} could not be destroyed.'

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/version.rb

@@ -1,3 +1,3 @@
 module InheritedResources
-  VERSION = '0.9.5'.freeze
+  VERSION = '1.0.pre'.freeze
 end

data/test/aliases_test.rb

@@ -104,7 +104,7 @@ class AliasesTest < ActionController::TestCase
   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))
+    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
@@ -132,8 +132,13 @@ class AliasesTest < ActionController::TestCase
   end
 
   protected
-    def mock_student(stubs={})
-      @mock_student ||= mock(stubs)
+    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/base_test.rb

@@ -9,6 +9,14 @@ end
 
 class UsersController < AccountsController
   respond_to :html, :xml
+  attr_reader :scopes_applied
+
+protected
+
+  def apply_scopes(object)
+    @scopes_applied = true
+    object
+  end
 end
 
 module UserTestHelper
@@ -16,11 +24,18 @@ module UserTestHelper
     @controller          = UsersController.new
     @controller.request  = @request  = ActionController::TestRequest.new
     @controller.response = @response = ActionController::TestResponse.new
+    @controller.stubs(:user_url).returns("/")
   end
 
   protected
-    def mock_user(stubs={})
-      @mock_user ||= mock(stubs)
+  
+    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
+      end
     end
 end
 
@@ -33,6 +48,12 @@ class IndexActionBaseTest < ActionController::TestCase
     assert_equal [mock_user], assigns(:users)
   end
 
+  def test_apply_scopes_if_method_is_available
+    User.expects(:find).with(:all).returns([mock_user])
+    get :index
+    assert @controller.scopes_applied
+  end
+
   def test_controller_should_render_index
     User.stubs(:find).returns([mock_user])
     get :index
@@ -210,9 +231,9 @@ class DestroyActionBaseTest < ActionController::TestCase
   end
 
   def test_show_flash_message_when_cannot_be_deleted
-    User.stubs(:find).returns(mock_user(:destroy => false))
+    User.stubs(:find).returns(mock_user(:destroy => false, :errors => { :fail => true }))
     delete :destroy
-    assert_equal flash[:error], 'User could not be destroyed.'
+    assert_equal flash[:alert], 'User could not be destroyed.'
   end
 
   def test_redirects_to_users_list

data/test/class_methods_test.rb

@@ -18,11 +18,6 @@ class Dean
   def self.human_name; 'Dean'; end
 end
 
-class SchoolsController < InheritedResources::Base
-  has_scope :by_city
-  has_scope :featured, :boolean => true, :only => :index, :as => :by_featured
-end
-
 class DeansController < InheritedResources::Base
   belongs_to :school
 end
@@ -134,17 +129,4 @@ class BelongsToErrorsTest < ActiveSupport::TestCase
   ensure
     DeansController.send(:parents_symbols=, [:school])
   end
-end
-
-class HasScopeClassMethods < ActiveSupport::TestCase
-  def test_scope_configuration_is_stored_as_hashes
-    config = SchoolsController.send(:scopes_configuration)
-
-    assert config.key?(:by_city)
-    assert config.key?(:featured)
-
-    assert_equal config[:by_city], { :as => :by_city, :only => [], :except => [] }
-    assert_equal config[:featured], { :as => :by_featured, :only => [ :index ], :except => [], :boolean => true }
-  end
-end
-
+end