pager-resource_controller 1.0.20080513

data/lib/resource_controller/base.rb

@@ -0,0 +1,15 @@
+module ResourceController
+  
+  # == ResourceController::Base
+  # 
+  # Inherit from this class to create your RESTful controller.  See the README for usage.
+  # 
+  class Base < ApplicationController
+    unloadable
+    
+    def self.inherited(subclass)
+      super
+      subclass.class_eval { resource_controller }
+    end
+  end
+end

data/lib/resource_controller/class_methods.rb

@@ -0,0 +1,22 @@
+module ResourceController
+  module ClassMethods
+
+    # Use this method in your controller to specify which actions you'd like it to respond to.
+    #
+    #   class PostsController < ResourceController::Base
+    #     actions :all, :except => :create
+    #   end
+    def actions(*opts)
+      config = {}
+      config.merge!(opts.pop) if opts.last.is_a?(Hash)
+
+      actions_to_remove = []
+      actions_to_remove += (ResourceController::ACTIONS - [:new_action] + [:new]) - opts unless opts.first == :all                
+      actions_to_remove += [*config[:except]] if config[:except]
+      actions_to_remove.uniq!
+
+      actions_to_remove.each { |action| undef_method(action)}
+    end
+    
+  end
+end

data/lib/resource_controller/controller.rb

@@ -0,0 +1,63 @@
+module ResourceController
+  module Controller    
+    def self.included(subclass)
+      subclass.class_eval do
+        include ResourceController::Helpers
+        include ResourceController::Actions
+        extend  ResourceController::Accessors
+        extend  ResourceController::ClassMethods
+        
+        class_reader_writer :belongs_to, *NAME_ACCESSORS
+        NAME_ACCESSORS.each { |accessor| send(accessor, controller_name.singularize.underscore) }
+
+        ACTIONS.each do |action|
+          class_scoping_reader action, FAILABLE_ACTIONS.include?(action) ? FailableActionOptions.new : ActionOptions.new
+        end
+
+        self.helper_method :object_url, :edit_object_url, :new_object_url, :collection_url, :object, :collection, 
+                             :parent, :parent_type, :parent_object, :model_name, :model, :object_path, :edit_object_path,
+                              :new_object_path, :collection_path, :hash_for_collection_path, :hash_for_object_path, 
+                                :hash_for_edit_object_path, :hash_for_new_object_path, :hash_for_collection_url, 
+                                  :hash_for_object_url, :hash_for_edit_object_url, :hash_for_new_object_url, :parent?,
+                                    :collection_url_options, :object_url_options, :new_object_url_options
+                                
+      end
+      
+      init_default_actions(subclass)
+    end
+        
+    private
+      def self.init_default_actions(klass)
+        klass.class_eval do
+          index.wants.html
+          edit.wants.html
+          new_action.wants.html
+
+          show do
+            wants.html
+
+            failure.wants.html { render :text => "Member object not found." }
+          end
+
+          create do
+            flash "Successfully created!"
+            wants.html { redirect_to object_url }
+
+            failure.wants.html { render :action => "new" }
+          end
+
+          update do
+            flash "Successfully updated!"
+            wants.html { redirect_to object_url }
+
+            failure.wants.html { render :action => "edit" }
+          end
+
+          destroy do
+            flash "Successfully removed!"
+            wants.html { redirect_to collection_url }
+          end
+        end
+      end
+  end
+end

data/lib/resource_controller/failable_action_options.rb

@@ -0,0 +1,17 @@
+module ResourceController
+  class FailableActionOptions
+    extend ResourceController::Accessors
+    
+    scoping_reader :success, :fails
+    alias_method :failure, :fails
+    
+    block_accessor :before
+    
+    def initialize
+      @success = ActionOptions.new
+      @fails   = ActionOptions.new
+    end
+    
+    delegate :flash, :after, :response, :wants, :to => :success
+  end
+end

data/lib/resource_controller/helpers.rb

@@ -0,0 +1,28 @@
+module ResourceController
+  # == ResourceController::Helpers
+  #
+  # Included in Base.
+  # 
+  # These helpers are used internally to manage objects, generate urls, and manage parent resource associations.
+  #
+  # If you want to customize certain controller behaviour, like member-object, and collection fetching, overriding these methods is all it takes.
+  #
+  # See the docs below, and the README for examples
+  #
+  # *Please Note: many of these helpers build on top of each other, and require that behaviour to be maintained, in order for other functionality to work properly.*
+  # 
+  # e.g. All fetching must be done on top of the method end_of_association_chain, or else parent resources (including polymorphic ones) won't function correctly.
+  #   
+  #   class PostsController < ResourceController::Base
+  #   private
+  #     def object
+  #       @object ||= end_of_association_chain.find_by_permalink(param)
+  #     end
+  #   end
+  module Helpers
+    include ResourceController::Helpers::Urls
+    include ResourceController::Helpers::Internal
+    include ResourceController::Helpers::Nested
+    include ResourceController::Helpers::CurrentObjects
+  end
+end

data/lib/resource_controller/helpers/current_objects.rb

@@ -0,0 +1,69 @@
+module ResourceController::Helpers::CurrentObjects
+  protected
+    # Used internally to return the model for your resource.  
+    #
+    def model
+      model_name.to_s.camelize.constantize
+    end
+
+  
+    # Used to fetch the collection for the index method
+    #
+    # In order to customize the way the collection is fetched, to add something like pagination, for example, override this method.
+    #
+    def collection
+      end_of_association_chain.find(:all)
+    end
+    
+    # Returns the current param.
+    # 
+    # Defaults to params[:id].
+    #
+    # Override this method if you'd like to use an alternate param name.
+    #
+    def param
+      params[:id]
+    end
+  
+    # Used to fetch the current member object in all of the singular methods that operate on an existing member.
+    #
+    # Override this method if you'd like to fetch your objects in some alternate way, like using a permalink.
+    #
+    # class PostsController < ResourceController::Base
+    #   private
+    #     def object
+    #       @object ||= end_of_association_chain.find_by_permalink(param)
+    #     end
+    #   end
+    #
+    def object
+      @object ||= end_of_association_chain.find(param) unless param.nil?
+      @object
+    end
+    
+    # Used internally to load the member object in to an instance variable @#{model_name} (i.e. @post)
+    #
+    def load_object
+      instance_variable_set "@#{parent_type}", parent_object if parent?
+      instance_variable_set "@#{object_name}", object
+    end
+    
+    # Used internally to load the collection in to an instance variable @#{model_name.pluralize} (i.e. @posts)
+    #
+    def load_collection
+      instance_variable_set "@#{parent_type}", parent_object if parent?
+      instance_variable_set "@#{object_name.to_s.pluralize}", collection
+    end
+  
+    # Returns the form params.  Defaults to params[model_name] (i.e. params["post"])
+    #
+    def object_params
+      params["#{object_name}"]
+    end
+    
+    # Builds the object, but doesn't save it, during the new, and create action.
+    #
+    def build_object
+      @object ||= end_of_association_chain.send parent? ? :build : :new, object_params
+    end
+end

data/lib/resource_controller/helpers/internal.rb

@@ -0,0 +1,59 @@
+# Internal action lifecycle management.
+# 
+# All of these methods are used internally to execute the options, set by the user in ActionOptions and FailableActionOptions
+#
+module ResourceController::Helpers::Internal
+  protected
+    # Used to actually pass the responses along to the controller's respond_to method.
+    #
+    def response_for(action)
+      respond_to do |wants|
+        options_for(action).response.each do |method, block|
+          if block.nil?
+            wants.send(method)
+          else
+            wants.send(method) { instance_eval(&block) }
+          end
+        end
+      end
+    end
+  
+    # Calls the after callbacks for the action, if one is present.
+    #
+    def after(action)
+      invoke_callbacks *options_for(action).after
+    end
+  
+    # Calls the before block for the action, if one is present.
+    #
+    def before(action)
+      invoke_callbacks *self.class.send(action).before
+    end
+    
+    # Sets the flash for the action, if it is present.
+    #
+    def set_flash(action)
+      flash[:notice] = options_for(action).flash if options_for(action).flash
+    end
+    
+    # Returns the options for an action, which is a symbol.
+    #
+    # Manages splitting things like :create_fails.
+    #
+    def options_for(action)
+      action = action == :new_action ? [action] : "#{action}".split('_').map(&:to_sym)
+      options = self.class.send(action.first)
+      options = options.send(action.last == :fails ? :fails : :success) if ResourceController::FAILABLE_ACTIONS.include? action.first
+    
+      options
+    end
+    
+    def invoke_callbacks(*callbacks)
+      unless callbacks.empty?
+        callbacks.select { |callback| callback.is_a? Symbol }.each { |symbol| send(symbol) }
+      
+        block = callbacks.detect { |callback| callback.is_a? Proc }
+        instance_eval &block unless block.nil?
+      end
+    end 
+end

data/lib/resource_controller/helpers/nested.rb

@@ -0,0 +1,45 @@
+# Nested and Polymorphic Resource Helpers
+#
+module ResourceController::Helpers::Nested
+  protected
+    # Returns the relevant association proxy of the parent. (i.e. /posts/1/comments # => @post.comments)
+    #
+    def parent_association
+      @parent_association ||= parent_object.send(model_name.to_s.pluralize.to_sym)
+    end
+    
+    # Returns the type of the current parent
+    #
+    def parent_type
+      @parent_type ||= [*belongs_to].find { |parent| !params["#{parent}_id".to_sym].nil? }
+    end
+    
+    # Returns true/false based on whether or not a parent is present.
+    #
+    def parent?
+      !parent_type.nil?
+    end
+    
+    # Returns the current parent param, if there is a parent. (i.e. params[:post_id])
+    def parent_param
+      params["#{parent_type}_id".to_sym]
+    end
+    
+    # Like the model method, but for a parent relationship.
+    # 
+    def parent_model
+      parent_type.to_s.camelize.constantize
+    end
+    
+    # Returns the current parent object if a parent object is present.
+    #
+    def parent_object
+      parent? ? parent_model.find(parent_param) : nil
+    end
+    
+    # If there is a parent, returns the relevant association proxy.  Otherwise returns model.
+    #
+    def end_of_association_chain
+      parent? ? parent_association : model
+    end
+end

data/lib/resource_controller/helpers/urls.rb

@@ -0,0 +1,124 @@
+# Thanks to Urligence, you get some free url helpers.
+# 
+# No matter what your controller looks like...
+# 
+#   [edit_|new_]object_url # is the equivalent of saying [edit_|new_]post_url(@post)
+#   [edit_|new_]object_url(some_other_object) # allows you to specify an object, but still maintain any paths or namespaces that are present
+# 
+#   collection_url # is like saying posts_url
+# 
+# Url helpers are especially useful when working with polymorphic controllers.
+# 
+#   # /posts/1/comments
+#   object_url #=> /posts/1/comments/#{@comment.to_param}
+#   object_url(comment) #=> /posts/1/comments/#{comment.to_param}
+#   edit_object_url #=> /posts/1/comments/#{@comment.to_param}/edit
+#   collection_url #=> /posts/1/comments
+# 
+#   # /products/1/comments
+#   object_url #=> /products/1/comments/#{@comment.to_param}
+#   object_url(comment) #=> /products/1/comments/#{comment.to_param}
+#   edit_object_url #=> /products/1/comments/#{@comment.to_param}/edit
+#   collection_url #=> /products/1/comments
+# 
+#   # /comments
+#   object_url #=> /comments/#{@comment.to_param}
+#   object_url(comment) #=> /comments/#{comment.to_param}
+#   edit_object_url #=> /comments/#{@comment.to_param}/edit
+#   collection_url #=> /comments
+# 
+# Or with namespaced, nested controllers...
+# 
+#   # /admin/products/1/options
+#   object_url #=> /admin/products/1/options/#{@option.to_param}
+#   object_url(option) #=> /admin/products/1/options/#{option.to_param}
+#   edit_object_url #=> /admin/products/1/options/#{@option.to_param}/edit
+#   collection_url #=> /admin/products/1/options
+# 
+# You get the idea.  Everything is automagical!  All parameters are inferred.
+#
+module ResourceController::Helpers::Urls
+  protected
+    ['', 'edit_'].each do |type|
+      symbol = type.blank? ? nil : type.gsub(/_/, '').to_sym
+      
+      define_method("#{type}object_url") do |*alternate_object|
+        smart_url *object_url_options(symbol, alternate_object.first)
+      end
+      
+      define_method("#{type}object_path") do |*alternate_object|
+        smart_path *object_url_options(symbol, alternate_object.first)
+      end
+      
+      define_method("hash_for_#{type}object_url") do |*alternate_object|
+        hash_for_smart_url *object_url_options(symbol, alternate_object.first)
+      end
+      
+      define_method("hash_for_#{type}object_path") do |*alternate_object|
+        hash_for_smart_path *object_url_options(symbol, alternate_object.first)
+      end
+    end
+    
+    def new_object_url
+      smart_url *new_object_url_options
+    end
+    
+    def new_object_path
+      smart_path *new_object_url_options
+    end
+    
+    def hash_for_new_object_url
+      hash_for_smart_url *new_object_url_options
+    end
+    
+    def hash_for_new_object_path
+      hash_for_smart_path *new_object_url_options
+    end
+    
+    def collection_url
+      smart_url *collection_url_options
+    end
+    
+    def collection_path
+      smart_path *collection_url_options
+    end
+    
+    def hash_for_collection_url
+      hash_for_smart_url *collection_url_options
+    end
+    
+    def hash_for_collection_path
+      hash_for_smart_path *collection_url_options
+    end
+    
+    # Used internally to provide the options to smart_url from Urligence.
+    #
+    def collection_url_options
+      namespaces + [parent_url_options, route_name.to_s.pluralize.to_sym]
+    end
+    
+    # Used internally to provide the options to smart_url from Urligence.
+    #
+    def object_url_options(action_prefix = nil, alternate_object = nil)
+      [action_prefix] + namespaces + [parent_url_options, [route_name.to_sym, alternate_object || object]]
+    end
+    
+    # Used internally to provide the options to smart_url from Urligence.
+    #
+    def new_object_url_options
+      [:new] + namespaces + [parent_url_options, route_name.to_sym]
+    end
+    
+    def parent_url_options
+      parent? ? [parent_type.to_sym, parent_object] : nil
+    end
+    
+    # Returns all of the current namespaces of the current controller, symbolized, in array form.
+    #
+    def namespaces
+      names = self.class.name.split("::")
+      names.pop
+      
+      names.map(&:downcase).map(&:to_sym)
+    end
+end