emmanuel-inherited_resources 0.9.1

data/lib/inherited_resources/class_methods.rb

@@ -0,0 +1,334 @@
+module InheritedResources
+  module ClassMethods
+
+    protected
+
+      # Used to overwrite the default assumptions InheritedResources do. Whenever
+      # this method is called, it should be on the top of your controller, since
+      # almost other methods depends on the values given to <<tt>>defaults</tt>.
+      #
+      # == Options
+      #
+      # * <tt>:resource_class</tt> - The resource class which by default is guessed
+      #                              by the controller name. Defaults to Project in
+      #                              ProjectsController.
+      #
+      # * <tt>:collection_name</tt> - The name of the collection instance variable which
+      #                               is set on the index action. Defaults to :projects in
+      #                               ProjectsController.
+      #
+      # * <tt>:instance_name</tt> - The name of the singular instance variable which
+      #                             is set on all actions besides index action. Defaults to
+      #                             :project in ProjectsController.
+      #
+      # * <tt>:route_collection_name</tt> - The name of the collection route. Defaults to :collection_name.
+      #
+      # * <tt>:route_instance_name</tt> - The name of the singular route. Defaults to :instance_name.
+      #
+      # * <tt>:route_prefix</tt> - The route prefix which is automically set in namespaced
+      #                            controllers. Default to :admin on Admin::ProjectsController.
+      #
+      # * <tt>:singleton</tt> - Tells if this controller is singleton or not.
+      #
+      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)
+
+        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)
+
+        acts_as_singleton! if options.delete(:singleton)
+
+        config = self.resources_configuration[:self]
+        config[:route_prefix] = options.delete(:route_prefix) if options.key?(:route_prefix)
+
+        options.each do |key, value|
+          config[key] = value.to_sym
+        end
+
+        create_resources_url_helpers!
+      end
+
+      # Defines wich actions to keep from the inherited controller.
+      # Syntax is borrowed from resource_controller.
+      #
+      #   actions :index, :show, :edit
+      #   actions :all, :except => :index
+      #
+      def actions(*actions_to_keep)
+        raise ArgumentError, 'Wrong number of arguments. You have to provide which actions you want to keep.' if actions_to_keep.empty?
+
+        options = actions_to_keep.extract_options!
+        actions_to_keep.map!{ |a| a.to_s }
+
+        actions_to_remove = Array(options[:except])
+        actions_to_remove.map!{ |a| a.to_s }
+
+        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|
+          undef_method action, "#{action}!"
+        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>: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, :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])
+          self.scopes_configuration[scope][:boolean] = options[:boolean] if options.key?(:boolean)
+          self.scopes_configuration[scope][:default] = options[:default] if options.key?(:default)
+        end
+      end
+
+      # Defines that this controller belongs to another resource.
+      #
+      #   belongs_to :projects
+      #
+      # == Options
+      #
+      # * <tt>:parent_class</tt> - Allows you to specify what is the parent class.
+      #
+      #     belongs_to :project, :parent_class => AdminProject
+      #
+      # * <tt>:class_name</tt> - Also allows you to specify the parent class, but you should
+      #                          give a string. Added for ActiveRecord belongs to compatibility.
+      #
+      # * <tt>:instance_name</tt> - The instance variable name. By default is the name of the association.
+      #
+      #     belongs_to :project, :instance_name => :my_project
+      #
+      # * <tt>:finder</tt> - Specifies which method should be called to instantiate the parent.
+      #
+      #     belongs_to :project, :finder => :find_by_title!
+      #
+      #   This will make your projects be instantiated as:
+      #
+      #     Project.find_by_title!(params[:project_id])
+      #
+      #   Instead of:
+      #
+      #     Project.find(params[:project_id])
+      #
+      # * <tt>:param</tt> - Allows you to specify params key to retrieve the id.
+      #                     Default is :association_id, which in this case is :project_id.
+      #
+      # * <tt>:route_name</tt> - Allows you to specify what is the route name in your url
+      #                          helper. By default is association name.
+      #
+      # * <tt>:collection_name</tt> - Tell how to retrieve the next collection. Let's
+      #                               suppose you have Tasks which belongs to Projects
+      #                               which belongs to companies. This will do somewhere
+      #                               down the road:
+      #
+      #      @company.projects
+      #
+      #   But if you want to retrieve instead:
+      #
+      #      @company.admin_projects
+      #
+      #   You supply the collection name.
+      #
+      # * <tt>:polymorphic</tt> - Tell the association is polymorphic.
+      #
+      # * <tt>:singleton</tt> - Tell it's a singleton association.
+      #
+      # * <tt>:optional</tt> - Tell the association is optional (it's a special
+      #                        type of polymorphic association)
+      #
+      def belongs_to(*symbols, &block)
+        options = symbols.extract_options!
+
+        options.symbolize_keys!
+        options.assert_valid_keys(:class_name, :parent_class, :instance_name, :param,
+                                  :finder, :route_name, :collection_name, :singleton,
+                                  :polymorphic, :optional)
+
+        optional    = options.delete(:optional)
+        singleton   = options.delete(:singleton)
+        polymorphic = options.delete(:polymorphic)
+        finder      = options.delete(:finder)
+
+        include BelongsToHelpers if self.parents_symbols.empty?
+
+        acts_as_singleton!   if singleton
+        acts_as_polymorphic! if polymorphic || optional
+
+        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?
+
+        symbols.each do |symbol|
+          symbol = symbol.to_sym
+
+          if polymorphic || optional
+            self.parents_symbols << :polymorphic unless self.parents_symbols.include?(:polymorphic)
+            self.resources_configuration[:polymorphic][:symbols]   << symbol
+            self.resources_configuration[:polymorphic][:optional] ||= optional
+          else
+            self.parents_symbols << symbol
+          end
+
+          config = self.resources_configuration[symbol] = {}
+          config[:parent_class]    = options.delete(:parent_class)
+          config[:parent_class]  ||= (options.delete(:class_name) || symbol).to_s.classify.constantize rescue nil
+          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[:route_name]      = options.delete(:route_name) || symbol
+          config[:finder]          = finder || :find
+        end
+
+        if block_given?
+          class_eval(&block)
+        else
+          create_resources_url_helpers!
+        end
+      end
+      alias :nested_belongs_to :belongs_to
+
+      # A quick method to declare polymorphic belongs to.
+      #
+      def polymorphic_belongs_to(*symbols, &block)
+        options = symbols.extract_options!
+        options.merge!(:polymorphic => true)
+        belongs_to(*symbols << options, &block)
+      end
+
+      # A quick method to declare singleton belongs to.
+      #
+      def singleton_belongs_to(*symbols, &block)
+        options = symbols.extract_options!
+        options.merge!(:singleton => true)
+        belongs_to(*symbols << options, &block)
+      end
+
+      # A quick method to declare optional belongs to.
+      #
+      def optional_belongs_to(*symbols, &block)
+        options = symbols.extract_options!
+        options.merge!(:optional => true)
+        belongs_to(*symbols << options, &block)
+      end
+
+    private
+
+      def acts_as_singleton! #:nodoc:
+        unless self.resources_configuration[:self][:singleton]
+          self.resources_configuration[:self][:singleton] = true
+          include SingletonHelpers
+          actions :all, :except => :index
+        end
+      end
+
+      def acts_as_polymorphic! #:nodoc:
+        unless self.parents_symbols.include?(:polymorphic)
+          include PolymorphicHelpers
+          helper_method :parent, :parent_type, :parent_class, :parent?
+        end
+      end
+
+      # Initialize resources class accessors and set their default values.
+      #
+      def initialize_resources_class_accessors! #:nodoc:
+        # Initialize resource class
+        self.resource_class = begin
+          self.controller_name.classify.constantize
+        rescue NameError
+          nil
+        end
+
+        # Initialize resources configuration hash
+        self.resources_configuration ||= {}
+        config = self.resources_configuration[:self] = {}
+        config[:collection_name] = self.controller_name.to_sym
+        config[:instance_name]   = self.controller_name.singularize.to_sym
+
+        config[:route_collection_name] = config[:collection_name]
+        config[:route_instance_name]   = config[:instance_name]
+
+        # Deal with namespaced controllers
+        namespaces = self.controller_path.split('/')[0..-2]
+        config[:route_prefix] = namespaces.join('_') unless namespaces.empty?
+
+        # Initialize polymorphic, singleton, scopes and belongs_to parameters
+        self.parents_symbols      ||= []
+        self.scopes_configuration ||= {}
+        self.resources_configuration[:polymorphic] ||= { :symbols => [], :optional => false }
+      end
+
+      # Hook called on inheritance.
+      #
+      def inherited(base) #:nodoc:
+        super(base)
+        base.send :initialize_resources_class_accessors!
+        base.send :create_resources_url_helpers!
+      end
+
+  end
+end

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 =~ /^__/
+    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,65 @@
+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:
+        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
+
+      # 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,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