rc_rails 2.1.0

data/lib/resources_controller/actions.rb

@@ -0,0 +1,147 @@
+module ResourcesController
+  # standard CRUD actions, with html, js and xml responses, re-written to mnake best use of resources_cotroller.
+  # This helps if you're writing controllers that you want to share via mixin or inheritance.
+  #
+  # This module is used as the actions for the controller by default, but you can change this behaviour:
+  #  
+  #   resources_controller_for :foos, :actions_include => false               # don't include any actions
+  #   resources_controller_for :foos, :actions_include => Some::Other::Module # use this module instead
+  #
+  # == Why?
+  #
+  # The idea is to decouple the <b>model name</b> from the action code.
+  #
+  # Here's how:
+  #
+  # === finding and making new resources
+  # Instead of this:
+  #   @post = Post.find(params[:id])
+  #   @post = Post.new
+  #   @posts = Post.find(:all)
+  #
+  # do this:
+  #   self.resource = find_resource
+  #   self.resource = new_resource
+  #   self.resources = find_resources
+  #
+  # === referring to resources
+  # Instead of this:
+  #   format.xml { render :xml => @post }
+  #   format.xml { render :xml => @posts }
+  #   
+  # do this:
+  #   format.xml { render :xml => resource }
+  #   format.xml { render :xml => resources }
+  #
+  # === urls 
+  # Instead of this:
+  #   redirect_to posts_url
+  #   redirect_to new_post_url
+  #
+  # do this:
+  #   redirect_to resources_url
+  #   redirect_to new_resource_url
+  #
+  module Actions
+    # GET /events
+    # GET /events.xml
+    def index
+      self.resources = find_resources
+
+      respond_to do |format|
+        format.html # index.rhtml
+        format.js
+        format.xml  { render :xml => resources }
+      end
+    end
+
+    # GET /events/1
+    # GET /events/1.xml
+    def show
+      self.resource = find_resource
+
+      respond_to do |format|
+        format.html # show.erb.html
+        format.js
+        format.xml  { render :xml => resource }
+      end
+    end
+
+    # GET /events/new
+    def new
+      self.resource = new_resource
+
+      respond_to do |format|
+        format.html # new.html.erb
+        format.js
+        format.xml  { render :xml => resource }
+      end
+    end
+
+    # GET /events/1/edit
+    def edit
+      self.resource = find_resource
+      respond_to do |format|
+        format.html # edit.html.erb
+        format.js
+        format.xml  { render :xml => resource }
+      end
+    end
+
+    # POST /events
+    # POST /events.xml
+    def create
+      self.resource = new_resource
+      
+      respond_to do |format|
+        if resource.save
+          format.html do
+            flash[:notice] = "#{resource_name.humanize} was successfully created."
+            redirect_to resource_url
+          end
+          format.js
+          format.xml  { render :xml => resource, :status => :created, :location => resource_url }
+        else
+          format.html { render :action => "new" }
+          format.js   { render :action => "new" }
+          format.xml  { render :xml => resource.errors, :status => :unprocessable_entity }
+        end
+      end
+    end
+
+    # PUT /events/1
+    # PUT /events/1.xml
+    def update
+      self.resource = find_resource
+      
+      respond_to do |format|
+        if resource.update_attributes(params[resource_name])
+          format.html do
+            flash[:notice] = "#{resource_name.humanize} was successfully updated."
+            redirect_to resource_url
+          end
+          format.js
+          format.xml  { head :ok }
+        else
+          format.html { render :action => "edit" }
+          format.js   { render :action => "edit" }
+          format.xml  { render :xml => resource.errors, :status => :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /events/1
+    # DELETE /events/1.xml
+    def destroy
+      self.resource = destroy_resource
+      respond_to do |format|
+        format.html do
+          flash[:notice] = "#{resource_name.humanize} was successfully destroyed."
+          redirect_to resources_url
+        end
+        format.js
+        format.xml  { head :ok }
+      end
+    end
+  end
+end

data/lib/resources_controller/active_record/saved.rb

@@ -0,0 +1,15 @@
+module ResourcesController
+  module ActiveRecord
+    module Saved
+      # returns true if this record is not new, and has no errors
+      def saved?
+        !new_record? && (@errors.nil? || errors.empty?)
+      end
+      
+      # returns true if this instance has had validation (maybe via save) attempted
+      def validation_attempted?
+        !@errors.nil?
+      end
+    end
+  end
+end

data/lib/resources_controller/helper.rb

@@ -0,0 +1,123 @@
+module ResourcesController
+  # Often it won't be appropriate to re-use views, but
+  # sometimes it is.  These helper methods enable reuse by referencing whatever resource the 
+  # controller is for.
+  #
+  # ==== Example:
+  #
+  # instead of writing:
+  #  <% for event in @events %>
+  #    <%= link_to 'edit', edit_event_path(event) %>
+  #
+  # you may write:
+  #  <% for event in resources %>
+  #    <%= link_to 'edit', edit_resource_path(event) %>
+  #
+  # == Enclosing resource
+  #
+  # For controllers with enclosing resources instead of writing:
+  #  <%= link_to 'back to Forum', forum_path(@forum) %>
+  #
+  # you may write: (which will work for any enclosing path)
+  #  <%= link_to "back to #{enclosing_resource.class.name.titleize}", enclosing_resource_path %>
+  #
+  # == Enclosing named routes:
+  #
+  # In addition you can reference named routes that are 'below' the current resource
+  # by appending resource_ to that named route.
+  #
+  # ==== Example: shared polymorphic view
+  #
+  # Let's say you have a resource controller for tags, and you're writing the 
+  # taggable views.  In a view shared amongst taggables you can write
+  #
+  #  <%= link_to 'tags', resource_tags_path %>
+  #  <%= link_to 'edit tag', edit_resource_tag_path(@tag) %>
+  # 
+  # or:
+  #  <% for taggable in resources %>
+  #    <%= link_to 'tags', resource_tags_path(taggable) %>
+  #
+  module Helper
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :method_missing, :named_route_helper
+        alias_method_chain :respond_to?, :named_route_helper
+        delegate :resource_name, :resources_name, :resource, :resources, :enclosing_resource, :enclosing_resource_name, :to => :controller
+      end
+    end
+
+    # DEPRECATED: you should just be able to use <tt>form_for resource</tt>
+    #
+    # Calls form_for with the apropriate action and method for the resource
+    #
+    # resource.new_record? is used to decide between a create or update action
+    #
+    # You can optionally pass a resource object, default is to use self.resource
+    #
+    # You may also override the url by passing <tt>:url</tt>, or pass extra options
+    # to resource path url with <tt>:url_options</tt>
+    #
+    # === Example
+    # 
+    #   <% form_for_resource do |f| %>
+    #     <%= f.text_field :name %>
+    #     <%= f.submit resource.new_record? ? 'Create' : 'Update'
+    #   <% end %>
+    #
+    #   <% for attachment in resources %>
+    #     <% form_for_resource attachment, :html => {:multipart => true} %>
+    #       <%= f.file_field :uploaded_data %>
+    #       <%= f.submit 'Update' %>
+    #     <% end %>
+    #   <% end %>
+    #
+    def form_for_resource(*args, &block)
+      options = args.extract_options!
+      resource = args[0] || self.resource
+      form_for(resource_name, resource, form_for_resource_options(resource, options), &block)
+    end
+
+    # same API as form_for_resource
+    def remote_form_for_resource(*args, &block)
+      options = args.extract_options!
+      resource = args[0] || self.resource
+      remote_form_for(resource_name, resource, form_for_resource_options(resource, options), &block)
+    end
+  
+    # print the error messages for the current resource
+    def error_messages_for_resource
+      error_messages_for resource_name
+    end
+    
+    # Delegate named_route helper method to the controller.  Create the delegation
+    # to short circuit the method_missing call for future invocations.
+    def method_missing_with_named_route_helper(method, *args, &block)
+      if controller.resource_named_route_helper_method?(method)
+        self.class.send(:delegate, method, :to => :controller)
+        controller.send(method, *args)
+      else
+        method_missing_without_named_route_helper(method, *args, &block)
+      end
+    end
+
+    # delegate url help method creation to the controller
+    def respond_to_with_named_route_helper?(*args)
+      respond_to_without_named_route_helper?(*args) || controller.resource_named_route_helper_method?(args.first)
+    end
+  
+  private
+    def form_for_resource_options(resource, options)
+      options.dup.tap do |options|
+        options[:html] ||= {}
+        options[:html][:method] ||= resource.new_record? ? :post : :put
+        args = options[:url_options] ? [options.delete(:url_options)] : []
+        options[:url] ||= if resource.new_record?
+          controller.resource_specification.singleton? ? resource_path(*args) : resources_path(*args)
+        else
+          controller.resource_specification.singleton? ? resource_path(*args) : resource_path(*([resource] + args))
+        end
+      end
+    end
+  end
+end

data/lib/resources_controller/include_actions.rb

@@ -0,0 +1,37 @@
+module ResourcesController
+  # extension for any module that is used as an Actions module.
+  #
+  # After extending the module (say 'MyActions'), instead of doing this:
+  #   self.include ActionsModule
+  # do this:
+  #   ActionsModule.include_actions(self, <:only or :except options>)
+  #
+  # RC extends any actions module with this automatically, so you don't need to know about it.
+  #
+  # However, if you ahve any special behaviour in your actions module that is sensitive to
+  # :only and :except, you can define your own include_actions method on that module
+  # to effect this special behaviour.
+  module IncludeActions
+    def include_actions(controller, options = {})
+      options.assert_valid_keys(:only, :except)
+      raise ArgumentError, "you can only specify either :except or :only, not both" if options[:only] && options[:except]
+      mixin = self.clone
+      action_methods_to_remove(options).each {|a| mixin.remove_action_method(a) }
+      controller.send :include, mixin
+    end
+    
+    def remove_action_method(action)
+      undef_method action
+    end
+    
+    def action_methods_to_remove(options = {})
+      if options[:only]
+        instance_methods - Array(options[:only]).map(&:to_s)
+      elsif options[:except]
+        Array(options[:except]).map(&:to_s) & instance_methods
+      else
+        []
+      end
+    end
+  end
+end

data/lib/resources_controller/named_route_helper.rb

@@ -0,0 +1,154 @@
+module ResourcesController
+  
+  class CantMapRoute < ArgumentError #:nodoc:
+  end
+  
+  # This module provides methods are provided to aid in writing inheritable controllers.
+  #
+  # When writing an action that redirects to the list of resources, you may use *resources_url* and the controller
+  # will call the url_writer method appropriate to what the controller is a resources controller for.
+  #
+  # If the route specified requires a member argument and you don't provide it, the current resource is used.
+  #
+  # In general you may subsitute 'resource' for the current (maybe polymorphic) resource. e.g.
+  #
+  # You may also substitute 'enclosing_resource' to get urls for the enclosing resource
+  #
+  #    (in attachable/attachments where attachable is a Post)
+  #
+  #    resources_path                        # => post_attachments_path
+  #    formatted_edit_resource_path('js')    # => formatted_post_attachments_path(<current post>, <current attachment>, 'js')
+  #    resource_tags_path                    # => post_attachments_tags_paths(<current post>, <current attachment>)
+  #    resource_tags_path(foo)               # => post_attachments_tags_paths(<current post>, foo)
+  #
+  #    enclosing_resource_path               # => post_path(<current post>)
+  #    enclosing_resources_path              # => posts_path
+  #    enclosing_resource_tags_path          # => post_tags_path(<current post>)
+  #    enclosing_resource_path(2)            # => post_path(2)
+  #
+  # The enclosing_resource stuff works with deep nesting if you're into that.
+  #
+  # These methods are defined as they are used.  The ActionView Helper module delegates to the current controller to access these
+  # methods
+  module NamedRouteHelper
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :method_missing, :named_route_helper
+        alias_method_chain :respond_to?, :named_route_helper
+      end
+      base.hide_action *instance_methods
+      base.hide_action :method_missing_without_named_route_helper, :respond_to_without_named_route_helper?, :respond_to?
+    end
+
+    def method_missing_with_named_route_helper(method, *args, &block)
+      # TODO: test that methods are only defined once
+      if resource_named_route_helper_method?(method, raise_error = true) 
+        define_resource_named_route_helper_method(method)
+        send(method, *args)
+      elsif resource_named_route_helper_method_for_name_prefix?(method)
+        define_resource_named_route_helper_method_for_name_prefix(method)
+        send(method, *args)
+      else
+        method_missing_without_named_route_helper(method, *args, &block)
+      end
+    end
+
+    def respond_to_with_named_route_helper?(*args)
+      respond_to_without_named_route_helper?(*args) || resource_named_route_helper_method?(args.first)
+    end
+
+    # return true if the passed method (e.g. 'resources_path') corresponds to a defined
+    # named route helper method
+    def resource_named_route_helper_method?(resource_method, raise_error = false)
+      if resource_method.to_s =~ /_(path|url)$/ && resource_method.to_s =~ /(^|^.*_)enclosing_resource(s)?_/
+        _, route_method = *route_and_method_from_enclosing_resource_method_and_name_prefix(resource_method, name_prefix)
+      elsif resource_method.to_s =~ /_(path|url)$/ && resource_method.to_s =~ /(^|^.*_)resource(s)?_/
+        _, route_method = *route_and_method_from_resource_method_and_name_prefix(resource_method, name_prefix)
+      else
+        return false
+      end
+      respond_to_without_named_route_helper?(route_method) || (raise_error && raise_resource_url_mapping_error(resource_method, route_method))
+    end
+
+  private
+    def raise_resource_url_mapping_error(resource_method, route_method)
+      raise CantMapRoute, <<-end_str
+Tried to map :#{resource_method} to :#{route_method},
+which doesn't exist. You may not have defined the route in config/routes.rb.
+
+Or, if you have unconventianal route names or name prefixes, you may need
+to explicictly set the :route option in resources_controller_for, and set
+the :name_prefix option on your enclosing resources.
+
+Currently:
+:route is '#{route_name}'
+generated name_prefix is '#{name_prefix}'
+      end_str
+    end
+    
+    # passed something like (^|.*_)enclosing_resource(s)_.*(url|path)$, will 
+    # return the [route, route_method]  for the expanded resource
+    def route_and_method_from_enclosing_resource_method_and_name_prefix(method, name_prefix)
+      if enclosing_resource
+        enclosing_route = name_prefix.sub(/_$/,'')
+        route_method = method.to_s.sub(/enclosing_resource(s)?/) { $1 ? enclosing_route.pluralize : enclosing_route }
+        return [Rails.application.routes.named_routes.get(route_method.sub(/_(path|url)$/,'').to_sym), route_method]
+      else
+        raise NoMethodError, "Tried to map :#{method} but there is no enclosing_resource for this controller"
+      end
+    end
+    
+    # passed something like (^|.*_)resource(s)_.*(url|path)$, will 
+    # return the [route, route_method]  for the expanded resource
+    def route_and_method_from_resource_method_and_name_prefix(method, name_prefix)
+      route_method = method.to_s.sub(/resource(s)?/) { $1 ? "#{name_prefix}#{route_name.pluralize}" : "#{name_prefix}#{route_name}" }
+      return [Rails.application.routes.named_routes.get(route_method.sub(/_(path|url)$/,'').to_sym), route_method]
+    end
+    
+    # defines a method that calls the appropriate named route method, with appropraite args.
+    def define_resource_named_route_helper_method(method)
+      self.class.send :module_eval, <<-end_eval, __FILE__, __LINE__
+        def #{method}(*args)
+          send "#{method}_for_\#{name_prefix}", *args
+        end
+      end_eval
+    end
+
+    def resource_named_route_helper_method_for_name_prefix?(method)
+      method.to_s =~ /_for_.*$/ && resource_named_route_helper_method?(method.to_s.sub(/_for_.*$/,''))
+    end
+
+    def define_resource_named_route_helper_method_for_name_prefix(method)
+      resource_method = method.to_s.sub(/_for_.*$/,'')
+      name_prefix = method.to_s.sub(/^.*_for_/,'')
+      if resource_method =~ /enclosing_resource/
+        route, route_method = *route_and_method_from_enclosing_resource_method_and_name_prefix(resource_method, name_prefix)
+        required_args = (route.segment_keys - [:format]).size
+      
+        self.class.send :module_eval, <<-end_eval, __FILE__, __LINE__
+          def #{method}(*args)
+            options = args.extract_options!
+            args = args.size < #{required_args} ? enclosing_collection_resources + args : enclosing_collection_resources - [enclosing_resource] + args
+            args = args + [options] if options.size > 0
+            send :#{route_method}, *args
+          end
+        end_eval
+                
+      else
+        route, route_method = *route_and_method_from_resource_method_and_name_prefix(resource_method, name_prefix)
+        required_args = (route.segment_keys - [:format]).size
+
+        self.class.send :module_eval, <<-end_eval, __FILE__, __LINE__
+          def #{method}(*args)
+            options = args.extract_options!
+            #{"args = [resource] + args if enclosing_collection_resources.size + args.size < #{required_args}" if required_args > 0}
+            args = args + [options] if options.size > 0
+            send :#{route_method}, *(enclosing_collection_resources + args)
+          end
+        end_eval
+      end
+      
+      self.class.send :private, method
+    end
+  end
+end

data/lib/resources_controller/railtie.rb

@@ -0,0 +1,14 @@
+module ResourcesController
+  class Railtie < Rails::Railtie
+    initializer 'resources_controller' do
+      ActiveSupport.on_load(:action_controller) do
+        extend ResourcesController
+        include ResourcesController::RequestPathIntrospection
+      end
+      
+      ActiveSupport.on_load(:active_record) do
+        include ResourcesController::ActiveRecord::Saved
+      end
+    end
+  end
+end

data/lib/resources_controller/request_path_introspection.rb

@@ -0,0 +1,83 @@
+module ResourcesController
+  # included into ActionController::Base
+  #
+  # provides ability to determine what nesting segments are for a given request, and whether those segments are singletons,
+  # these methods are aware of resource specifications specified either by map_enclosing_resource.
+  module RequestPathIntrospection
+  protected
+    def request_path
+      @request_path ||= params[:resource_path] || request.path
+    end
+    
+    def nesting_request_path
+      @nesting_request_path ||= remove_namespace(remove_current_segment(request_path))
+    end
+    
+    # returns an array of hashes like {:segment => 'forum', :singleton => false}
+    def nesting_segments
+      @nesting_segments ||= segments_for_path_and_keys(nesting_request_path, param_keys)
+    end
+    
+    # returns an array of segments correspopnding to the namespace of the controller.
+    # If your controller is at a non standard location wrt it's path, you can modify this array in a before filter
+    # to help resources_controller do the right thing
+    def namespace_segments
+      unless @namespace_segments
+        namespace = controller_path.sub(%r(#{controller_name}$), '')
+        @namespace_segments = (request_path =~ %r(^/#{namespace}) ? namespace.split('/') : [])
+      end
+      @namespace_segments
+    end
+    
+    def param_keys
+      params.keys.map(&:to_s).select{|k| k[-3..-1] == '_id'}
+    end
+    
+  private
+    def remove_current_segment(path)
+      if respond_to?(:resource_specification) && resource_specification.singleton?
+        path.sub(%r(/#{current_segment}(?!.*/#{current_segment}).*$), '')
+      else
+        path.sub(%r(/#{current_segment}(?!.+/#{current_segment}).*$), '')
+      end
+    end
+    
+    def current_segment
+      respond_to?(:resource_specification) ? resource_specification.segment : controller_name
+    end
+      
+    def remove_namespace(path)
+      if namespace_segments.any?
+        path.sub(%r(^/#{namespace_segments.join('/')}), '')
+      else
+        path
+      end
+    end
+    
+    def segments_for_path_and_keys(path, keys)
+      key_segments = keys.map{|k| segment_for_key(k)}
+      path_segments = path[1..-1].to_s.split('/')
+      segments = []
+      while path_segments.any? do
+        segment = path_segments.shift
+        if key_segments.include?(segment)
+          segments << {:segment => segment, :singleton => false}
+          path_segments.shift # swallow following :id
+        else
+          segments << {:segment => segment, :singleton => true}
+        end
+      end
+      segments
+    end
+    
+    def segment_for_key(key)
+      if respond_to?(:specifications) && spec = specifications.find{|s| s.respond_to?(:key) && s.key == key.to_s}
+        spec.segment
+      elsif spec = resource_specification_map.values.find{|s| s.key == key.to_s}
+        spec.segment
+      else
+        key.to_s[0..-4].pluralize
+      end
+    end
+  end
+end

data/lib/resources_controller/resource_methods.rb

@@ -0,0 +1,32 @@
+module ResourcesController
+  # methods which communicate with the resource_service to find/create resources
+  module ResourceMethods
+  protected
+    # finds the collection of resources
+    def find_resources
+      resource_service.all
+    end
+
+    # finds the resource, using the passed id, defaults to the current params[:id]
+    def find_resource(id = nil)
+      id ||= respond_to?(:params) && params.is_a?(Hash) && params[:id]
+      resource_service.find id
+    end
+
+    # makes a new resource, if attributes are not supplied, determine them from the
+    # params hash and the current resource_class, or resource_name (the latter left in for BC)
+    def new_resource(attributes = nil, &block)
+      if attributes.blank? && respond_to?(:params) && params.is_a?(Hash)
+        resource_form_name = ActiveModel::Naming.singular(resource_class)
+        attributes = params[resource_form_name] || params[resource_name] || {}
+      end
+      resource_service.new attributes, &block
+    end
+    
+    # destroys and returns the resource, using the passed id, defaults to the current params[:id]
+    def destroy_resource(id = nil)
+      id ||= respond_to?(:params) && params.is_a?(Hash) && params[:id]
+      resource_service.destroy id
+    end
+  end
+end

data/lib/resources_controller/singleton_actions.rb

@@ -0,0 +1,21 @@
+module ResourcesController
+  module SingletonActions
+    include Actions
+    
+    undef index
+
+    # DELETE /event
+    # DELETE /event.xml
+    def destroy
+      self.resource = destroy_resource
+      respond_to do |format|
+        format.html do
+          flash[:notice] = "#{resource_name.humanize} was successfully destroyed."
+          redirect_to enclosing_resource_url if enclosing_resource
+        end
+        format.js
+        format.xml  { head :ok }
+      end
+    end
+  end
+end