josevalim-inherited_resources 0.8.5 → 0.9.0

data/Rakefile

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'

data/VERSION

@@ -1 +1 @@
-0.8.5
+0.9.0

data/lib/inherited_resources.rb

@@ -1,9 +1,14 @@
 # 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')
+unless defined?(ActionController::Responder)
+  require File.join(File.dirname(__FILE__), 'inherited_resources', 'legacy', 'responder')
+  require File.join(File.dirname(__FILE__), 'inherited_resources', 'legacy', 'respond_to')
+end
 
-module InheritedResources; end
+module InheritedResources
+  ACTIONS = [ :index, :show, :new, :edit, :create, :update, :destroy ] unless self.const_defined?(:ACTIONS)
+end
 
 class ActionController::Base
   # If you cannot inherit from InheritedResources::Base you can call

data/lib/inherited_resources/actions.rb

@@ -1,91 +1,69 @@
 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)
+      respond_with(collection, &block)
     end
     alias :index! :index
 
     # GET /resources/1
     def show(&block)
-      respond_to(:with => resource, &block)
+      respond_with(resource, &block)
     end
     alias :show! :show
 
     # GET /resources/new
     def new(&block)
-      respond_to(:with => build_resource, &block)
+      respond_with(build_resource, &block)
     end
     alias :new! :new
 
     # GET /resources/1/edit
     def edit(&block)
-      respond_to(:with => resource, &block)
+      respond_with(resource, &block)
     end
     alias :edit! :edit
 
     # POST /resources
-    def create(&block)
+    def create(options={}, &block)
       object = build_resource
-      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
+        options[:location] ||= resource_url rescue nil
+        respond_with_dual_blocks(object, options, true, block)
       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
+        respond_with_dual_blocks(object, options, false, block)
       end
     end
     alias :create! :create
 
     # PUT /resources/1
-    def update(&block)
+    def update(options={}, &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
+        options[:location] ||= resource_url rescue nil
+        respond_with_dual_blocks(object, options, true, block)
       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
+        respond_with_dual_blocks(object, options, false, block)
       end
     end
     alias :update! :update
 
     # DELETE /resources/1
-    def destroy(&block)
-      resource.destroy
-      respond_block, redirect_block = select_block_by_arity(block)
+    def destroy(options={}, &block)
+      object = resource
+      object.destroy
 
       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
+      options[:location] ||= collection_url rescue nil
+      respond_with_dual_blocks(object, options, nil, block)
     end
     alias :destroy! :destroy
 

data/lib/inherited_resources/base.rb

@@ -20,6 +20,9 @@ module InheritedResources
         extend  InheritedResources::ClassMethods
         extend  InheritedResources::UrlHelpers
 
+        # Add at least :html mime type
+        respond_to :html
+
         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

data/lib/inherited_resources/base_helpers.rb

@@ -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_instance_name] || {}))
       end
 
       # This class allows you to set a instance variable to begin your
@@ -271,26 +271,34 @@ module InheritedResources
       #     end
       #   end
       #
-      def respond_to_with_dual_blocks(success, dual_block, options={}, &block) #:nodoc:
-        responder = ActionController::MimeResponds::Responder.new(self)
-
-        if dual_block
-          if dual_block.arity == 2
-            dumb_responder = InheritedResources::DumbResponder.new
-            if success
-              dual_block.call(responder, dumb_responder)
+      # It also calculates the response url in case a block without arity is
+      # given and returns it. Otherwise returns nil.
+      #
+      def respond_with_dual_blocks(object, options, success, given_block, &block) #:nodoc:
+        case given_block.try(:arity)
+          when 2
+            respond_with(object, options) do |responder|
+              dumb_responder = InheritedResources::DumbResponder.new
+              if success
+                given_block.call(responder, dumb_responder)
+              else
+                given_block.call(dumb_responder, responder)
+              end
+              block.try(:call, responder)
+            end
+          when 1
+            if block
+              respond_with(object, options) do |responder|
+                given_block.call(responder)
+                block.call(responder)
+              end
             else
-              dual_block.call(dumb_responder, responder)
+              respond_with(object, options, &given_block)
             end
           else
-            dual_block.call(responder)
-          end
-
-          # Try to respond with the block given
-          responder.respond_except_any
+            options[:location] = given_block.call if given_block
+            respond_with(object, options, &block)
         end
-
-        respond_to(options.merge!(:responder => responder, :prioritize => :html), &block) unless performed?
       end
 
       # Hook to apply scopes. By default returns only the target_object given.
@@ -307,23 +315,5 @@ module InheritedResources
         []
       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.
-      #
-      def select_block_by_arity(block) #:nodoc
-        if block
-          case block.arity
-            when 2, 1
-              [block, nil]
-            when 0, -1
-              [nil, block]
-            else
-              raise ScriptError, "InheritedResources does not know how to handle blocks with arity #{block.arity}"
-          end
-        else
-          [nil, nil]
-        end
-      end
-
   end
 end

data/lib/inherited_resources/class_methods.rb

@@ -68,7 +68,7 @@ module InheritedResources
         actions_to_remove = Array(options[:except])
         actions_to_remove.map!{ |a| a.to_s }
 
-        actions_to_remove += RESOURCES_ACTIONS.map{|a| a.to_s } - actions_to_keep unless actions_to_keep.first == 'all'
+        actions_to_remove += ACTIONS.map{ |a| a.to_s } - actions_to_keep unless actions_to_keep.first == 'all'
         actions_to_remove.uniq!
 
         (instance_methods & actions_to_remove).each do |action|
@@ -108,18 +108,18 @@ module InheritedResources
       #
       # == Options
       #
-      # * <tt>:boolean</tt> - When set to true, call the scope only when the params is true or 1,
+      # * <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 each actions the scope is applied. By default is :all.
+      # * <tt>:only</tt> - In which actions the scope is applied. By default is :all.
       #
-      # * <tt>:except</tt> - In each actions the scope is not applied. By default is :none.
+      # * <tt>:except</tt> - In which actions the scope is not applied. By default is :none.
       #
       # * <tt>:key</tt> - The key in the params hash expected to find the scope.
       #                   Defaults to the scope name.
       #
       # * <tt>:default</tt> - Default value for the scope. Whenever supplied the scope
-      #                       is always called. This is useful to add easy pagination!
+      #                       is always called. This is useful to add easy pagination.
       #
       def has_scope(*scopes)
         options = scopes.extract_options!
@@ -208,6 +208,7 @@ module InheritedResources
         optional    = options.delete(:optional)
         singleton   = options.delete(:singleton)
         polymorphic = options.delete(:polymorphic)
+        finder      = options.delete(:finder)
 
         include BelongsToHelpers if self.parents_symbols.empty?
 
@@ -234,8 +235,8 @@ module InheritedResources
           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"
-          config[:finder]          = options.delete(:finder) || :find
           config[:route_name]      = options.delete(:route_name) || symbol
+          config[:finder]          = finder || :find
         end
 
         if block_given?

data/lib/inherited_resources/legacy/respond_to.rb

@@ -0,0 +1,151 @@
+module ActionController #:nodoc:
+  class Base #:nodoc:
+    attr_accessor :formats
+
+    # Defines mimes that are rendered by default when invoking respond_with.
+    #
+    # Examples:
+    #
+    #   respond_to :html, :xml, :json
+    #
+    # All actions on your controller will respond to :html, :xml and :json.
+    #
+    # But if you want to specify it based on your actions, you can use only and
+    # except:
+    #
+    #   respond_to :html
+    #   respond_to :xml, :json, :except => [ :edit ]
+    #
+    # The definition above explicits that all actions respond to :html. And all
+    # actions except :edit respond to :xml and :json.
+    #
+    # You can specify also only parameters:
+    #
+    #   respond_to :rjs, :only => :create
+    #
+    def self.respond_to(*mimes)
+      options = mimes.extract_options!
+
+      only_actions   = Array(options.delete(:only))
+      except_actions = Array(options.delete(:except))
+
+      mimes.each do |mime|
+        mime = mime.to_sym
+        mimes_for_respond_to[mime]          = {}
+        mimes_for_respond_to[mime][:only]   = only_actions   unless only_actions.empty?
+        mimes_for_respond_to[mime][:except] = except_actions unless except_actions.empty?
+      end
+    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?
+
+      responder = ActionController::MimeResponds::Responder.new(self)
+      mimes = collect_mimes_from_class_level if mimes.empty?
+      mimes.each { |mime| responder.send(mime) }
+      block.call(responder) if block_given?
+
+      if format = responder.negotiate_mime
+        self.response.template.template_format = format.to_sym
+        self.response.content_type = format.to_s
+        self.formats = [ format.to_sym ]
+
+        if response = responder.response_for(format)
+          response.call
+        else
+          default_render
+        end
+      else
+        head :not_acceptable
+      end
+    end
+
+    def respond_with(*resources, &block)
+      respond_to(&block)
+    rescue ActionView::MissingTemplate
+      options = resources.extract_options!
+      (options.delete(:responder) || responder).call(self, resources, options)
+    end
+
+    def responder
+      ActionController::Responder
+    end
+
+  protected
+
+    # Collect mimes declared in the class method respond_to valid for the
+    # current action.
+    #
+    def collect_mimes_from_class_level #:nodoc:
+      action = action_name.to_sym
+
+      mimes_for_respond_to.keys.select do |mime|
+        config = mimes_for_respond_to[mime]
+
+        if config[:except]
+          !config[:except].include?(action)
+        elsif config[:only]
+          config[:only].include?(action)
+        else
+          true
+        end
+      end
+    end
+  end
+
+  module MimeResponds
+    class Responder #:nodoc:
+      attr_reader :order
+
+      def any(*args, &block)
+        if args.any?
+          args.each { |type| send(type, &block) }
+        else
+          custom(Mime::ALL, &block)
+        end
+      end
+      alias :all :any
+
+      def custom(mime_type, &block)
+        mime_type = mime_type.is_a?(Mime::Type) ? mime_type : Mime::Type.lookup(mime_type.to_s)
+        @order << mime_type
+        @responses[mime_type] ||= block
+      end
+
+      def response_for(mime)
+        @responses[mime] || @responses[Mime::ALL]
+      end
+
+      def negotiate_mime
+        @mime_type_priority.each do |priority|
+          if priority == Mime::ALL
+            return @order.first
+          elsif @order.include?(priority)
+            return priority
+          end
+        end
+
+        if @order.include?(Mime::ALL)
+          return Mime::SET.first if @mime_type_priority.first == Mime::ALL
+          return @mime_type_priority.first
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/inherited_resources/legacy/responder.rb

@@ -0,0 +1,181 @@
+module ActionController #:nodoc:
+  # Responder is responsible to expose a resource for different mime requests,
+  # usually depending on the HTTP verb. The responder is triggered when
+  # respond_with is called. The simplest case to study is a GET request:
+  #
+  #   class PeopleController < ApplicationController
+  #     respond_to :html, :xml, :json
+  #
+  #     def index
+  #       @people = Person.find(:all)
+  #       respond_with(@people)
+  #     end
+  #   end
+  #
+  # When a request comes, for example with format :xml, three steps happen:
+  #
+  #   1) respond_with 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;
+  #
+  #   3) if the responder does not respond_to :to_xml, call to_format on it.
+  #
+  # === Builtin HTTP verb semantics
+  #
+  # Rails default responder holds semantics for each HTTP verb. Depending on the
+  # content type, verb and the resource status, it will behave differently.
+  #
+  # Using Rails default responder, a POST request for creating an object could
+  # be written as:
+  #
+  #   def create
+  #     @user = User.new(params[:user])
+  #     flash[:notice] = 'User was successfully created.' if @user.save
+  #     respond_with(@user)
+  #   end
+  #
+  # Which is exactly the same as:
+  #
+  #   def create
+  #     @user = User.new(params[:user])
+  #
+  #     respond_to do |format|
+  #       if @user.save
+  #         flash[:notice] = 'User was successfully created.'
+  #         format.html { redirect_to(@user) }
+  #         format.xml { render :xml => @user, :status => :created, :location => @user }
+  #       else
+  #         format.html { render :action => "new" }
+  #         format.xml { render :xml => @user.errors, :status => :unprocessable_entity }
+  #       end
+  #     end
+  #   end
+  #
+  # The same happens for PUT and DELETE requests.
+  #
+  # === Nested resources
+  #
+  # You can given nested resource as you do in form_for and polymorphic_url.
+  # Consider the project has many tasks example. The create action for
+  # TasksController would be like:
+  #
+  #   def create
+  #     @project = Project.find(params[:project_id])
+  #     @task = @project.comments.build(params[:task])
+  #     flash[:notice] = 'Task was successfully created.' if @task.save
+  #     respond_with(@project, @task)
+  #   end
+  #
+  # Giving an array of resources, you ensure that the responder will redirect to
+  # project_task_url instead of task_url.
+  #
+  # Namespaced and singleton resources requires a symbol to be given, as in
+  # polymorphic urls. If a project has one manager which has many tasks, it
+  # should be invoked as:
+  #
+  #   respond_with(@project, :manager, @task)
+  #
+  # Check polymorphic_url documentation for more examples.
+  #
+  class Responder
+    attr_reader :controller, :request, :format, :resource, :resource_location, :options
+
+    def initialize(controller, resources, options={})
+      @controller = controller
+      @request = controller.request
+      @format = controller.formats.first
+      @resource = resources.is_a?(Array) ? resources.last : resources
+      @resource_location = options[:location] || resources
+      @options = options
+    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
+
+    # 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
+    end
+
+    # HTML format does not render the resource, it always attempt to render a
+    # template.
+    #
+    def to_html
+      if get?
+        render
+      elsif has_errors?
+        render :action => default_action
+      else
+        redirect_to resource_location
+      end
+    end
+
+    # All others formats try to render the resource given instead. For this
+    # purpose a helper called display as a shortcut to render a resource with
+    # the current format.
+    #
+    def to_format
+      return render unless resourceful?
+
+      if get?
+        display resource
+      elsif has_errors?
+        display resource.errors, :status => :unprocessable_entity
+      elsif post?
+        display resource, :status => :created, :location => resource_location
+      else
+        head :ok
+      end
+    end
+
+  protected
+
+    # Checks whether the resource responds to the current format or not.
+    #
+    def resourceful?
+      resource.respond_to?(:"to_#{format}")
+    end
+
+    # display is just a shortcut to render a resource with the current format.
+    #
+    #   display @user, :status => :ok
+    #
+    # For xml request is equivalent to:
+    #
+    #   render :xml => @user, :status => :ok
+    #
+    # Options sent by the user are also used:
+    #
+    #   respond_with(@user, :status => :created)
+    #   display(@user, :status => :ok)
+    #
+    # Results in:
+    #
+    #   render :xml => @user, :status => :created
+    #
+    def display(resource, given_options={})
+      render given_options.merge!(options).merge!(format => resource)
+    end
+
+    # Check if the resource has errors or not.
+    #
+    def has_errors?
+      resource.respond_to?(:errors) && !resource.errors.empty?
+    end
+
+    # By default, render the :edit action for html requests with failure, unless
+    # the verb is post.
+    #
+    def default_action
+      request.post? ? :new : :edit
+    end
+  end
+end