resource_controller_views 0.6.6.views2

data/lib/resource_controller/helpers/pagination.rb

@@ -0,0 +1,13 @@
+module ResourceController
+  module Helpers
+    module Pagination
+      
+      protected
+      
+      def collection
+        end_of_association_chain.paginate(:page => params[:page], :per_page => self.class.resource_controller_options[:per_page] || params[:per_page] || 20)
+      end
+      
+    end
+  end
+end

data/lib/resource_controller/helpers/searchlogic.rb

@@ -0,0 +1,20 @@
+module ResourceController
+  module Helpers
+    module Searchlogic
+    
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :end_of_association_chain, :searchlogic
+          index.before { @search = end_of_association_chain }
+        end
+      end
+    
+      protected
+    
+      def end_of_association_chain_with_searchlogic
+        end_of_association_chain_without_searchlogic.searchlogic(params[:search])
+      end
+    
+    end
+  end
+end

data/lib/resource_controller/helpers/singleton_customizations.rb

@@ -0,0 +1,64 @@
+# Singleton Resource Helpers
+# 
+# Used internally to transform a plural RESTful controller into a singleton
+#
+module ResourceController
+  module Helpers
+    module SingletonCustomizations
+      def self.included(subclass)
+        subclass.class_eval do  
+          methods_to_undefine = [:param, :index, :collection, :load_collection, :collection_url, 
+            :collection_path, :hash_for_collection_url, :hash_for_collection_path]
+          methods_to_undefine.each { |method| undef_method(method) if method_defined? method }
+      
+          class << self
+            def singleton?
+              true
+            end
+          end
+        end
+      end
+  
+      protected
+        # Used to fetch the current object in a singleton controller.
+        #
+        # By defult this method is able to fetch the current object for resources nested with the :has_one association only. (i.e. /users/1/image # => @user.image)
+        # In other cases you should override this method and provide your custom code to fetch a singleton resource object, like using a session hash.
+        #
+        # class AccountsController < ResourceController::Singleton
+        #   private
+        #     def object
+        #       @_rc_object ||= Account.find(session[:account_id])
+        #     end
+        #   end
+        #  
+        def object
+          @_rc_object ||= parent? ? end_of_association_chain : nil
+        end
+
+        # Returns the :has_one association proxy of the parent. (i.e. /users/1/image # => @user.image)
+        #  
+        def parent_association
+          @parent_association ||= parent_current_object.send(model_name.to_sym)
+        end
+  
+        # Used internally to provide the options to smart_url in a singleton controller.
+        #  
+        def object_url_options(action_prefix = nil, alternate_object = nil)
+          [action_prefix] + namespaces + [parent_url_options, route_name.to_sym]
+        end
+  
+        # Builds the object, but doesn't save it, during the new, and create action.
+        #
+        def build_object
+          @_rc_object ||= singleton_build_object_base.send parent? ? "build_#{model_name}".to_sym : :new, object_params
+        end
+    
+        # Singleton controllers don't build off of association proxy, so we can't use end_of_association_chain here
+        #
+        def singleton_build_object_base
+          parent? ? parent_object : model
+        end
+    end
+  end
+end

data/lib/resource_controller/helpers/urls.rb

@@ -0,0 +1,132 @@
+# 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
+  module Helpers
+    module 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_current_object.first)
+          end
+      
+          define_method("#{type}object_path") do |*alternate_object|
+            smart_path *object_url_options(symbol, alternate_current_object.first)
+          end
+      
+          define_method("hash_for_#{type}object_url") do |*alternate_object|
+            hash_for_smart_url *object_url_options(symbol, alternate_current_object.first)
+          end
+      
+          define_method("hash_for_#{type}object_path") do |*alternate_object|
+            hash_for_smart_path *object_url_options(symbol, alternate_current_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
+          if parent?
+            parent_singleton? ? parent_type.to_sym : [parent_type.to_sym, parent_object]
+          else
+            nil
+          end
+        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(&:underscore).map(&:to_sym)
+        end
+    end
+  end
+end

data/lib/resource_controller/helpers/views.rb

@@ -0,0 +1,21 @@
+module ResourceController
+  module Helpers
+    module Views
+      
+      protected
+
+      # True if the named partial is found without falling back to the scaffold_root.
+      def has_own_partial?(name)
+        view_paths.find_template("_#{name}", default_template_format) != nil
+      rescue ActionView::MissingTemplate
+        return false
+      end
+
+      # Returns the options hash passed to the resource_controller declaration.
+      def resource_controller_options
+        self.class.resource_controller_options
+      end
+    
+    end
+  end
+end

data/lib/resource_controller/partials.rb

@@ -0,0 +1,25 @@
+module ResourceController
+  module Partials
+    
+    def self.included(base)
+      base.module_eval do
+        alias_method_chain :_pick_partial_template, :scaffold
+      end
+    end
+    
+    def _pick_partial_template_with_scaffold(partial_path) #:nodoc:
+      _pick_partial_template_without_scaffold(partial_path)
+    rescue ActionView::MissingTemplate
+      Rails.logger.debug("[DynamicScaffold] Using scaffold partial #{partial_path}")
+      
+      raise "Attempting to call a resource_controller_views partial from a controller which isn't resource_controller enabled." if !controller.respond_to?(:resource_controller_options)
+      raise if controller.nil? || controller.resource_controller_options[:scaffold_root].blank?
+      
+      scaffold_paths = view_paths.class.new
+      scaffold_paths.unshift(controller.resource_controller_options[:scaffold_root] || "app/views/scaffold")
+      scaffold_paths.find_template("_#{partial_path}", self.template_format)
+    end
+  end
+end
+
+ActionView::Partials.send(:include, ResourceController::Partials)

data/lib/resource_controller/response_collector.rb

@@ -0,0 +1,27 @@
+module ResourceController
+  class ResponseCollector
+    
+    attr_reader :responses
+    
+    delegate :clear, :to => :responses
+    
+    def initialize
+      @responses = []
+    end
+    
+    def method_missing(method_name, &block)
+      @responses.delete self[method_name]
+      @responses << [method_name, block || nil]
+    end
+    
+    def [](symbol)
+      @responses.find { |method, block| method == symbol }
+    end
+    
+    def dup
+      returning ResponseCollector.new do |duplicate|
+        duplicate.instance_variable_set(:@responses, responses.dup)
+      end
+    end
+  end
+end

data/lib/resource_controller/singleton.rb

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

data/lib/resource_controller/views.rb

@@ -0,0 +1,19 @@
+
+module ResourceController
+  module Views
+    
+    private
+    
+    # Use dynamic scaffold fallback if a template can't be found in the view paths.
+    def default_template(action_name = self.action_name)
+      view_paths.find_template(default_template_name(action_name), default_template_format)
+    rescue ActionView::MissingTemplate
+      raise if controller.resource_controller_options[:scaffold_root].blank?
+      action_name = "index" if action_name.blank?
+      
+      scaffold_paths = view_paths.class.new
+      scaffold_paths.unshift(controller.resource_controller_options[:scaffold_root])
+      scaffold_paths.find_template(action_name, default_template_format)
+    end
+  end
+end

data/lib/urligence.rb

@@ -0,0 +1,50 @@
+module Urligence
+  def smart_url(*objects)
+    urligence(*objects.push(:url))
+  end
+  
+  def smart_path(*objects)
+    urligence(*objects.push(:path))
+  end
+  
+  def hash_for_smart_url(*objects)
+    urligence(*objects.unshift(:hash_for).push(:url).push({:type => :hash}))
+  end
+  
+  def hash_for_smart_path(*objects)
+    urligence(*objects.unshift(:hash_for).push(:path).push({:type => :hash}))
+  end
+  
+  def urligence(*objects)
+    config = {}
+    config.merge!(objects.pop) if objects.last.is_a?(Hash)
+    
+    objects.reject! { |object| current_object.nil? }
+    
+    url_fragments = objects.collect do |obj|
+      if obj.is_a? Symbol
+        obj
+      elsif obj.is_a? Array
+        obj.first
+      else
+        obj.class.name.underscore.to_sym
+      end
+    end
+    
+    unless config[:type] == :hash
+      send url_fragments.join("_"), *objects.flatten.select { |obj| !obj.is_a? Symbol }
+    else
+      params = {}
+      unparsed_params = objects.select { |obj| !obj.is_a? Symbol }
+      unparsed_params.each_with_index do |obj, i|
+        unless i == (unparsed_params.length-1)
+          params.merge!((obj.is_a? Array) ? {"#{obj.first}_id".to_sym => obj[1].to_param} : {"#{obj.class.name.underscore}_id".to_sym => obj.to_param})
+        else
+          params.merge!((obj.is_a? Array) ? {:id => obj[1].to_param} : {:id => obj.to_param})
+        end
+      end
+      
+      send url_fragments.join("_"), params
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,6 @@
+ActionController::Base.class_eval do
+  include Urligence
+  helper_method :smart_url
+  
+  extend ResourceController::ActionControllerExtension
+end

data/test/Rakefile

@@ -0,0 +1,10 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require(File.join(File.dirname(__FILE__), 'config', 'boot'))
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'tasks/rails'

data/test/app/controllers/accounts_controller.rb

@@ -0,0 +1,6 @@
+class AccountsController < ResourceController::Singleton
+  protected
+    def object
+      Account.find(:first)
+    end
+end

data/test/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class ApplicationController < ActionController::Base
+end

data/test/app/controllers/cms/options_controller.rb

@@ -0,0 +1,3 @@
+class Cms::OptionsController < ResourceController::Base
+  belongs_to :product
+end

data/test/app/controllers/cms/personnel_controller.rb

@@ -0,0 +1,2 @@
+class Cms::PersonnelController < ResourceController::Base
+end