inherited_resources 0.9.2

data/lib/inherited_resources/dumb_responder.rb

@@ -0,0 +1,20 @@
+module InheritedResources
+  # = Dumb Responder
+  #
+  # This responder discards all messages sent to him.
+  #
+  class DumbResponder
+
+    instance_methods.each do |m|
+      undef_method m unless m =~ /^(__|object_id)/
+    end
+
+    # This is like a good husband, he will just listen everything that his wife
+    # says (which is a lot) without complaining. :)
+    #
+    def method_missing(*args)
+      nil
+    end
+
+  end
+end

data/lib/inherited_resources/has_scope_helpers.rb

@@ -0,0 +1,83 @@
+module InheritedResources
+
+  # = has_scopes
+  #
+  # This module in included in your controller when has_scope is called for the
+  # first time.
+  #
+  module HasScopeHelpers
+    TRUE_VALUES = ["true", true, "1", 1] unless self.const_defined?(:TRUE_VALUES)
+
+    protected
+
+      # Overwrites apply to scope to implement default scope logic.
+      #
+      def apply_scope_to(target_object) #:nodoc:
+        @current_scopes ||= {}
+
+        self.scopes_configuration.each do |scope, options|
+          next unless apply_scope_to_action?(options)
+          key = options[:as]
+
+          if params.key?(key)
+            value, call_scope = params[key], true
+          elsif options.key?(:default)
+            value, call_scope = options[:default], true
+            value = value.call(self) if value.is_a?(Proc)
+          end
+
+          if call_scope
+            @current_scopes[key] = value
+
+            if options[:boolean]
+              target_object = target_object.send(scope) if TRUE_VALUES.include?(value)
+            else
+              target_object = target_object.send(scope, value)
+            end
+          end
+        end
+
+        target_object
+      end
+
+      # Given an options with :only and :except arrays, check if the scope
+      # can be performed in the current action.
+      #
+      def apply_scope_to_action?(options) #:nodoc:
+        return false unless applicable?(options[:if], true)
+        return false unless applicable?(options[:unless], false)
+        if options[:only].empty?
+          if options[:except].empty?
+            true
+          else
+            !options[:except].include?(action_name.to_sym)
+          end
+        else
+          options[:only].include?(action_name.to_sym)
+        end
+      end
+
+      # Evaluates the scope options :if or :unless. Returns true if the proc
+      # method, or string evals to the expected value.
+      #
+      def applicable?(string_proc_or_symbol, expected)
+        case string_proc_or_symbol
+          when String
+            eval(string_proc_or_symbol) == expected
+          when Proc
+            string_proc_or_symbol.call(self) == expected
+          when Symbol
+            send(string_proc_or_symbol) == expected
+          else
+            true
+        end
+      end
+
+      # Returns the scopes used in this action.
+      #
+      def current_scopes
+        @current_scopes || {}
+      end
+
+  end
+end

data/lib/inherited_resources/legacy/respond_to.rb

@@ -0,0 +1,156 @@
+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?
+      if response = retrieve_response_from_mimes(mimes, &block)
+        response.call
+      end
+    end
+
+    def respond_with(*resources, &block)
+      if response = retrieve_response_from_mimes([], &block)
+        options = resources.extract_options!
+        options.merge!(:default_response => response)
+        (options.delete(:responder) || responder).call(self, resources, options)
+      end
+    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
+
+    # Collects mimes and return the response for the negotiated format. Returns
+    # nil if :not_acceptable was sent to the client.
+    #
+    def retrieve_response_from_mimes(mimes, &block)
+      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 ]
+        responder.response_for(format) || proc { default_render }
+      else
+        head :not_acceptable
+        nil
+      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,200 @@
+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, :resources, :options
+
+    def initialize(controller, resources, options={})
+      @controller = controller
+      @request = controller.request
+      @format = controller.formats.first
+      @resource = resources.is_a?(Array) ? resources.last : resources
+      @resources = resources
+      @options = options
+      @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
+
+    # 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
+      default_render
+    rescue ActionView::MissingTemplate
+      if get?
+        raise
+      elsif has_errors?
+        render :action => default_action
+      else
+        redirect_to resource_location
+      end
+    end
+
+    # All others formats follow the procedure below. First we try to render a
+    # template, if the template is not available, we verify if the resource
+    # responds to :to_format and display it.
+    #
+    def to_format
+      default_render
+    rescue ActionView::MissingTemplate
+      raise 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
+
+    # Returns the resource location by retrieving it from the options or
+    # returning the resources array.
+    #
+    def resource_location
+      options[:location] || resources
+    end
+
+    # If a given response block was given, use it, otherwise call render on
+    # controller.
+    #
+    def default_render
+      @default_response.call
+    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