dry_crud 1.2.7 → 1.3.0

data/lib/generators/dry_crud/templates/app/controllers/list_controller.rb

@@ -1,34 +1,25 @@
 # Abstract controller providing a basic list action.
-# This action lists all entries of a certain model and provides functionality to 
-# search and sort this list. 
+# This action lists all entries of a certain model and provides functionality to
+# search and sort this list.
 # Furthermore, it remembers the last search and sort parameters. When the action
 # is called with a param returning=true, these parameters are reused to present
-# the user the same list as he left it.  
+# the user the same list as he left it.
 class ListController < ApplicationController
-    
-  include RenderInheritable 
-    
+
+  include RenderInheritable
+
   # Move this declaration to the application controller.
   helper :standard
-  
+
   helper_method :model_class, :models_label
-  
-  delegate :model_class, :models_label, :to => 'self.class'  
-  
+
+  delegate :model_class, :models_label, :to => 'self.class'
+
   hide_action :model_class, :models_label, :inheritable_root_controller
-  
-    
-  # Callbacks
-  extend ActiveModel::Callbacks  
-  
-  # Defines before callbacks for the render actions.
-  define_model_callbacks :render_index, 
-                         :only => :before,
-                         :terminator => "result == false || performed?"
-                         
-                                          
+
+
   ##############  ACTIONS  ############################################
-          
+
   # List all entries of this model.
   #   GET /entries
   #   GET /entries.xml
@@ -36,15 +27,14 @@ class ListController < ApplicationController
     @entries = list_entries
     respond_with @entries
   end
-  
-  
+
   protected
-  
+
   # The entries to be displayed in the current index page.
   def list_entries
     model_class.scoped
-  end     
-       
+  end
+
   # Convenience method to respond to various formats with the given object.
   def respond_with(object)
     respond_to do |format|
@@ -52,47 +42,61 @@ class ListController < ApplicationController
       format.xml  { render :xml => object }
     end
   end
-  
+
   # Helper method to run before_render callbacks and render the action.
   # If a callback renders or redirects, the action is not rendered.
   def render_with_callback(action)
     run_callbacks(:"render_#{action}")
-    render :action => action unless performed?
+    render action unless performed?
   end
-  
-    
+
   class << self
+    # Callbacks
+    include ActiveModel::Callbacks
+   
     # The ActiveRecord class of the model.
     def model_class
       @model_class ||= controller_name.classify.constantize
     end
-        
+
     # A human readable plural name of the model.
-    def models_label
-      @models_label ||= model_class.model_name.human.pluralize
-    end   
+    def models_label(plural = true)
+      opts = {:count => (plural ? 3 : 1)}
+      opts[:default] = model_class.model_name.human.pluralize if plural
+      model_class.model_name.human(opts)
+    end
+    
+    # Defines before callbacks for the render actions.
+    def define_render_callbacks(*actions)
+      args = actions.collect {|a| :"render_#{a}" }
+      args << {:only => :before,
+               :terminator => "result == false || performed?"}
+      define_model_callbacks *args
+    end
   end
   
+  define_render_callbacks :index
+
   # The search functionality for the index table.
   # Extracted into an own module for convenience.
   module Search
-    def self.included(controller)    
+    def self.included(controller)
       # Define an array of searchable columns in your subclassing controllers.
       controller.class_attribute :search_columns
       controller.search_columns = []
-      
+
       controller.helper_method :search_support?
-      
+
       controller.alias_method_chain :list_entries, :search
     end
-    
+
     protected
-    
+
     # Enhance the list entries with an optional search criteria
     def list_entries_with_search
       list_entries_without_search.where(search_condition)
     end
-    
+
     # Compose the search condition with a basic SQL OR query.
     def search_condition
       if search_support? && params[:q].present?
@@ -102,16 +106,16 @@ class ListController < ApplicationController
          ["(#{clause})"] + [param] * search_columns.size
       end
     end
-  
+
     # Returns true if this controller has searchable columns.
     def search_support?
       search_columns.present?
     end
-       
+
   end
-  
+
   include Search
-  
+
   # Sort functionality for the index table.
   # Extracted into an own module for convenience.
   module Sort
@@ -123,14 +127,14 @@ class ListController < ApplicationController
       # sort the displayed city names.
       controller.class_attribute :sort_mappings
       controller.sort_mappings = {}
-      
+
       controller.helper_method :sortable?
-    
+
       controller.alias_method_chain :list_entries, :sort
     end
-    
+
     protected
-    
+
     # Enhance the list entries with an optional sort order.
     def list_entries_with_sort
       if params[:sort].present? && sortable?(params[:sort])
@@ -139,73 +143,85 @@ class ListController < ApplicationController
         list_entries_without_sort
       end
     end
-    
+
     # Return the sort expression to be used in the list query.
     def sort_expression
-      col = sort_mappings[params[:sort].to_sym] || 
+      col = sort_mappings[params[:sort].to_sym] ||
             "#{model_class.table_name}.#{params[:sort]}"
       "#{col} #{sort_dir}"
     end
-    
+
     # The sort direction, either 'asc' or 'desc'.
     def sort_dir
       params[:sort_dir] == 'desc' ? 'desc' : 'asc'
     end
-    
+
     # Returns true if the passed attribute is sortable.
     def sortable?(attr)
-      model_class.column_names.include?(attr.to_s) || 
+      model_class.column_names.include?(attr.to_s) ||
       sort_mappings.include?(attr.to_sym)
     end
   end
-  
+
   include Sort
-  
+
   # Remembers certain params of the index action in order to return
   # to the same list after an entry was viewed or edited.
   # If the index is called with a param :returning, the remembered params
   # will be re-used.
   # Extracted into an own module for convenience.
   module Memory
-  
+
     # Adds the :remember_params class attribute and a before filter to the index action.
-    def self.included(controller)     
+    def self.included(controller)
       # Define a list of param keys that should be remembered for the list action.
       controller.class_attribute :remember_params
       controller.remember_params = [:q, :sort, :sort_dir]
-      
+
       controller.before_filter :handle_remember_params, :only => [:index]
     end
-    
+
     private
-    
+
     # Store and restore the corresponding params.
     def handle_remember_params
       remembered = remembered_params
+
+      restore_params_on_return(remembered)
+      store_current_params(remembered)
+      clear_void_params(remembered)
+    end
+
+    def restore_params_on_return(remembered)
       if params[:returning]
-        # restore params
         remember_params.each {|p| params[p] ||= remembered[p] }
       end
-      
-      # store current params
-      remember_params.each do |p| 
+    end
+
+    def store_current_params(remembered)
+      remember_params.each do |p|
         remembered[p] = params[p].presence
         remembered.delete(p) if remembered[p].nil?
       end
-      
-      # clear void params
-      session[:list_params].delete(request.path) if remembered.blank?
     end
-    
+
+    def clear_void_params(remembered)
+      session[:list_params].delete(remember_key) if remembered.blank?
+    end
+
     # Get the params stored in the session.
-    # Params are stored by request path to play nice when a controller
-    # is used in different routes.
     def remembered_params
       session[:list_params] ||= {}
-      session[:list_params][request.path] ||= {}
+      session[:list_params][remember_key] ||= {}
+    end
+    
+    # Params are stored by request path to play nice when a controller
+    # is used in different routes.
+    def remember_key
+       request.path
     end
   end
-  
+
   include Memory
-  
+
 end

data/lib/generators/dry_crud/templates/app/controllers/render_inheritable.rb

@@ -2,55 +2,56 @@
 # If no view file is found for the current controller, the corresponding file
 # is looked up in its superclass hierarchy. This module must only be
 # included in the root controller of the desired lookup hierarchy.
-# 
+#
 # By default, this module only supports direct inheritance over one level. By overriding
 # the method lookup_path, you may define a custom lookup path. By providing an object
 # for the 'with' parameter, this path may even be dynamic.
 module RenderInheritable
-  
+
   # Add inheritable_root_path method to including controller.
   def self.included(controller_class)
     controller_class.send(:extend, ClassMethods)
-    
+
     controller_class.send(:class_variable_set, :@@inheritable_root_controller, controller_class)
     controller_class.cattr_reader :inheritable_root_controller
-  end    
-  
+  end
+
   # Performs a lookup for the given filename and returns the most specific
   # folder that contains the file.
   def find_inheritable_template_folder(name, partial = false)
     self.class.find_inheritable_template_folder(view_context, name, partial, formats, template_lookup_param)
   end
-  
+
   # Override this method to specify a dynamic parameter used in the lookup path.
   # For the default inheritance lookup, this parameter is not needed.
   def template_lookup_param
     nil
   end
-  
+
   module ClassMethods
+  
     # Performs a lookup for the given filename and returns the most specific
     # folder that contains the file.
-    def find_inheritable_template_folder(view_context, name, partial, formats, param = nil)  
+    def find_inheritable_template_folder(view_context, name, partial, formats, param = nil)
       find_inheritable_template_folder_cached(view_context, name, partial, formats, param) do
         find_inheritable_artifact(param) do |folder|
           view_context.template_exists?(name, folder, partial)
         end
       end
     end
-    
+
     # Performs a lookup for a controller and returns the name of the most specific one found.
     # This method is primarly usefull when given a 'param' argument that is used
-    # in a custom #template_lookup_path. In this case, no controller class would need to 
+    # in a custom #template_lookup_path. In this case, no controller class would need to
     # exist to render templates from corresponding view folders.
     def inheritable_controller(param = nil)
       descendants = inheritable_root_controller.descendants
       c = find_inheritable_artifact(param) do |folder|
-      	descendants.any? { |s| s.controller_path == folder }
+        descendants.any? { |s| s.controller_path == folder }
       end
       c || inheritable_root_controller.controller_path
     end
-    
+
     # Runs through the lookup path and yields each folder to the passed block.
     # If the block returns true, this folder is returned and no further lookup
     # happens. If no folder is found, the nil is returned.
@@ -58,14 +59,14 @@ module RenderInheritable
       template_lookup_path(param).each { |folder| return folder if yield(folder) }
       nil
     end
-    
+
     # An array of controller names / folders, ordered from most specific to most general.
-    # May be dynamic dependening on the passed 'param' argument. 
+    # May be dynamic dependening on the passed 'param' argument.
     # You may override this method in an own controller to customize the lookup path.
     def template_lookup_path(param = nil)
       inheritance_lookup_path
     end
-    
+
     # The inheritance path of controllers that is used as default lookup path.
     def inheritance_lookup_path
       path = [self]
@@ -74,8 +75,8 @@ module RenderInheritable
       end
       path.collect(&:controller_path)
     end
-    
-    # Override view context class to includes the render inheritable modules.
+
+    # Override view context class to include the render inheritable modules.
     def view_context_class
       @view_context_class ||= begin
         Class.new(super) do
@@ -83,46 +84,46 @@ module RenderInheritable
         end
       end
     end
-    
+
     private
-    
+
     # Performs a lookup for a template folder using the cache.
     def find_inheritable_template_folder_cached(view_context, name, partial, formats, param = nil)
       prefix = inheritable_cache_get(formats, name, partial, param)
       return prefix if prefix
-      
+
       prefix = yield
-      
+
       if prefix
         template = view_context.find_template_without_lookup(name, prefix, partial)
         inheritable_cache_set(template.formats, name, partial, param, prefix)
       end
       prefix
     end
-    
+
     # A simple template lookup cache for each controller.
     def inheritable_cache #:nodoc:
       # do not store keys on each access, only return default structure
-      @inheritable_cache ||= Hash.new do |h1, k1| 
-        Hash.new do |h2, k2| 
-          Hash.new do |h3, k3| 
-            Hash.new 
+      @inheritable_cache ||= Hash.new do |h1, k1|
+        Hash.new do |h2, k2|
+          Hash.new do |h3, k3|
+            Hash.new
           end
         end
       end
     end
-    
+
     # Gets the prefix from the cache. Returns nil if it's not there yet.
     def inheritable_cache_get(formats, name, partial, param)
       prefixes = formats.collect { |format| inheritable_cache[format.to_sym][partial][name][param] }
       prefixes.compact!
       prefixes.empty? ?  nil : prefixes.first
     end
-    
+
     # Stores the found prefix in the cache.
     def inheritable_cache_set(formats, name, partial, param, prefix)
       formats.each do |format|
-        # assign hash default values to respective key 
+        # assign hash default values to respective key
         inheritable_cache[format.to_sym] = hf = inheritable_cache[format.to_sym]
         hf[partial] = hp = hf[partial]
         hp[name] = hn = hp[name]
@@ -130,15 +131,15 @@ module RenderInheritable
         hn[param] = prefix
       end
     end
-    
+
   end
-  
+
   # Extend ActionView so templates are looked up on a find_template call.
   module View
     def self.included(base)
       base.send :alias_method_chain, :find_template, :lookup
     end
-    
+
     # Perform a template lookup if the prefix corresponds to the current controller's path.
     def find_template_with_lookup(name, prefix = nil, partial = false)
       if prefix == controller_path
@@ -148,5 +149,5 @@ module RenderInheritable
       find_template_without_lookup(name, prefix, partial)
     end
   end
-  
+
 end