dry_crud 1.7.0 → 2.0.0

data/lib/generators/dry_crud/templates/app/controllers/crud/sortable.rb

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+
+module Crud
+  # Sort functionality for the index table.
+  # Define a default sort expression that is always appended to the
+  # current sort params with the class attribute +default_sort+.
+  module Sortable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :sort_mappings_with_indifferent_access
+      self.sort_mappings = {}
+
+      class_attribute :default_sort
+
+      helper_method :sortable?
+
+      alias_method_chain :list_entries, :sort
+    end
+
+    # Class methods for sorting.
+    module ClassMethods
+      # Define a map of (virtual) attributes to SQL order expressions.
+      # May be used for sorting table columns that do not appear directly
+      # in the database table. E.g., map city_id: 'cities.name' to
+      # sort the displayed city names.
+      def sort_mappings=(hash)
+        self.sort_mappings_with_indifferent_access =
+          hash.with_indifferent_access
+      end
+    end
+
+    private
+
+    # Enhance the list entries with an optional sort order.
+    def list_entries_with_sort
+      clause = []
+      clause << sort_expression if sortable?(params[:sort])
+      clause << default_sort
+
+      list_entries_without_sort.order(clause.compact.join(', '))
+    end
+
+    # Return the sort expression to be used in the list query.
+    def sort_expression
+      col = sort_mappings_with_indifferent_access[params[:sort]] ||
+            "#{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)
+      attr.present? && (
+      model_class.column_names.include?(attr.to_s) ||
+      sort_mappings_with_indifferent_access.include?(attr))
+    end
+  end
+end

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

@@ -1,31 +1,39 @@
+# encoding: UTF-8
+
 # Abstract controller providing basic CRUD actions.
 # This implementation mainly follows the one of the Rails scaffolding
-# controller and responses to HTML and JSON requests. Some enhancements were made to ease extendability.
-# Several protected helper methods are there to be (optionally) overriden by subclasses.
-# With the help of additional callbacks, it is possible to hook into the action procedures without
-# overriding the entire method.
+# controller and responds to HTML and JSON requests.
+#
+# Some enhancements were made to ease extendability.
+# The current model entry is available in the view as an instance variable
+# named after the +model_class+ or in the helper method +entry+.
+# Several protected helper methods are there to be (optionally) overriden by
+# subclasses.
+# With the help of additional callbacks, it is possible to hook into the action
+# procedures without overriding the entire method.
 class CrudController < ListController
 
-  delegate :model_identifier, :to => 'self.class'
+  self.responder = Crud::Responder
+
+<% if Rails.version >= '4.0' -%>
+  class_attribute :permitted_attrs
 
-  # Defines before and after callback hooks for create, update, save and destroy actions.
+<% end -%>
+  # Defines before and after callback hooks for create, update, save and
+  # destroy actions.
   define_model_callbacks :create, :update, :save, :destroy
 
   # Defines before callbacks for the render actions. A virtual callback
-  # unifiying render_new and render_edit, called render_form, is defined further down.
+  # unifiying render_new and render_edit, called render_form, is defined
+  # further down.
   define_render_callbacks :show, :new, :edit
 
   after_save :set_success_notice
   after_destroy :set_success_notice
 
   helper_method :entry, :full_entry_label
-  
-  hide_action :model_identifier, :run_callbacks
-  
-  # Simple helper object to give access to required view helper methods.
-  @@helper = Object.new.extend(ActionView::Helpers::TranslationHelper).
-                        extend(ActionView::Helpers::OutputSafetyHelper)
 
+  hide_action :run_callbacks
 
   ##############  ACTIONS  ############################################
 
@@ -40,7 +48,7 @@ class CrudController < ListController
   #   GET /entries/new
   #   GET /entries/new.json
   def new(&block)
-    assign_attributes
+    assign_attributes if params[model_identifier]
     respond_with(entry, &block)
   end
 
@@ -54,7 +62,8 @@ class CrudController < ListController
   def create(options = {}, &block)
     assign_attributes
     created = with_callbacks(:create, :save) { entry.save }
-    respond_with(entry, options.reverse_merge(:success => created), &block)
+    respond_options = options.reverse_merge(success: created)
+    respond_with(entry, respond_options, &block)
   end
 
   # Display a form to edit an exisiting entry of this model.
@@ -73,7 +82,8 @@ class CrudController < ListController
   def update(options = {}, &block)
     assign_attributes
     updated = with_callbacks(:update, :save) { entry.save }
-    respond_with(entry, options.reverse_merge(:success => updated), &block)
+    respond_options = options.reverse_merge(success: updated)
+    respond_with(entry, respond_options, &block)
   end
 
   # Destroy an existing entry of this model.
@@ -85,9 +95,14 @@ class CrudController < ListController
   #   DELETE /entries/1.json
   def destroy(options = {}, &block)
     destroyed = run_callbacks(:destroy) { entry.destroy }
-    flash[:alert] ||= error_messages.presence || flash_message(:failure) if !destroyed && request.format == :html
-    location = !destroyed && request.env["HTTP_REFERER"].presence || index_url
-    respond_with(entry, options.reverse_merge(:success => destroyed, :location => location), &block)
+    unless destroyed
+      set_failure_notice
+      location = request.env['HTTP_REFERER'].presence
+    end
+    location ||= index_url
+    respond_options = options.reverse_merge(success: destroyed,
+                                            location: location)
+    respond_with(entry, respond_options, &block)
   end
 
   private
@@ -114,24 +129,40 @@ class CrudController < ListController
     entry.attributes = model_params
   end
 
-  # A label for the current entry, including the model name.
-  def full_entry_label
-    "#{models_label(false)} <i>#{ERB::Util.h(entry)}</i>".html_safe
+  # The form params for this model.
+  def model_params
+<% if Rails.version < '4.0' -%>
+    params[model_identifier]
+<% else -%>
+    params.require(model_identifier).permit(permitted_attrs)
+<% end -%><%# > fixing rdoc -%>
   end
 
-  # Url of the index page to return to
+  # Url of the index page to return to.
   def index_url
-    polymorphic_url(path_args(model_class), :returning => true)
+    polymorphic_url(path_args(model_class), returning: true)
   end
 
-  private
+  # A label for the current entry, including the model name.
+  def full_entry_label
+    "#{models_label(false)} <i>#{ERB::Util.h(entry)}</i>".html_safe
+  end
 
   # Set a success flash notice when we got a HTML request.
   def set_success_notice
-    flash[:notice] ||= flash_message(:success) if request.format == :html
+    if request.format == :html
+      flash[:notice] ||= flash_message(:success)
+    end
+  end
+
+  # Set a failure flash notice when we got a HTML request.
+  def set_failure_notice
+    if request.format == :html
+      flash[:alert] ||= error_messages.presence || flash_message(:failure)
+    end
   end
 
-  # Get an I18n flash message, considering _html keys as well.
+  # Get an I18n flash message.
   # Uses the key {controller_name}.{action_name}.flash.{state}
   # or crud.{action_name}.flash.{state} as fallback.
   def flash_message(state)
@@ -140,56 +171,22 @@ class CrudController < ListController
             :"#{controller_name}.#{scope}",
             :"crud.#{scope}_html",
             :"crud.#{scope}"]
-    @@helper.t(keys.shift, :model => full_entry_label, :default => keys)
+    I18n.t(keys.shift, model: full_entry_label, default: keys).html_safe
   end
-  
+
   # Html safe error messages of the current entry.
   def error_messages
-    @@helper.safe_join(entry.errors.full_messages, '<br/>'.html_safe)
-  end
-  
-  # The form params for this model.
-  def model_params
-    params[model_identifier]
+    escaped = entry.errors.full_messages.map { |m| ERB::Util.html_escape(m) }
+    escaped.join('<br/>').html_safe
   end
 
-
   class << self
-    # The identifier of the model used for form parameters.
-    # I.e., the symbol of the underscored model name.
-    def model_identifier
-      @model_identifier ||= model_class.model_name.param_key
-    end
-
-    # Convenience callback to apply a callback on both form actions (new and edit).
+    # Convenience callback to apply a callback on both form actions
+    # (new and edit).
     def before_render_form(*methods)
-      before_render_new *methods
-      before_render_edit *methods
+      before_render_new(*methods)
+      before_render_edit(*methods)
     end
   end
 
-  # Custom Responder that handles the controller's path_args. 
-  # An additional :success option is used to handle action callback chain halts.
-  class Responder < ActionController::Responder
-
-    def initialize(controller, resources, options = {})
-      super(controller, with_path_args(resources, controller), options)
-    end
-
-    private
-
-    # Check whether the resource has errors. Additionally checks the :success option.
-    def has_errors?
-      options[:success] == false || super
-    end
-
-    # Wraps the resources with the path_args for correct nesting.
-    def with_path_args(resources, controller)
-      resources.size == 1 ? Array(controller.send(:path_args, resources.first)) : resources
-    end
-
-  end
-
-  self.responder = Responder
-
 end

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

@@ -1,16 +1,23 @@
+# encoding: UTF-8
+
 # 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.
-# 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 loaded model entries are available in the view as an instance variable
+# named after the +model_class+ or by the helper method +entries+.
+#
+# The +index+ 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 after the
+# user returns from a displayed or edited entry.
 class ListController < ApplicationController
 
-  helper_method :model_class, :models_label, :entries, :path_args
+  include Crud::GenericModel
+  include Crud::Nestable
+  include Crud::Rememberable
+  include Crud::RenderCallbacks
 
-  delegate :model_class, :models_label, :to => 'self.class'
+  define_render_callbacks :index
 
-  hide_action :model_class, :models_label, :inheritable_root_controller
+  helper_method :entries
 
   respond_to :html, :json
 
@@ -25,332 +32,22 @@ class ListController < ApplicationController
 
   private
 
-  # Helper method to access the entries to be displayed in the current index page in an uniform way.
+  # Helper method to access the entries to be displayed in the current index
+  # page in an uniform way.
   def entries
     get_model_ivar(true) || set_model_ivar(list_entries)
   end
 
   # The base relation used to filter the entries.
-  # This method may be adapted as long it returns an ActiveRecord::Relation.
+  # This method may be adapted as long it returns an
+  # <tt>ActiveRecord::Relation</tt>.
+  # Some of the modules included extend this method.
   def list_entries
     model_scope
   end
 
-  # The scope where model entries will be listed and created.
-  # This is mainly used for nested models to provide the
-  # required context.
-  def model_scope
-    model_class.scoped
-  end
-
-  # The path arguments to link to the given entry.
-  # If the controller is nested, this provides the required context.
-  def path_args(last)
-    last
-  end
-
-  # Get the instance variable named after the model_class.
-  # If the collection variable is required, pass true as the second argument.
-  def get_model_ivar(plural = false)
-    name = ivar_name(model_class)
-    name = name.pluralize if plural
-    instance_variable_get(:"@#{name}")
-  end
-
-  # Sets an instance variable with the underscored class name if the given value.
-  # If the value is a collection, sets the plural name.
-  def set_model_ivar(value)
-    name = if value.respond_to?(:klass) # ActiveRecord::Relation
-      ivar_name(value.klass).pluralize
-    elsif value.respond_to?(:each) # Array
-      ivar_name(value.first.klass).pluralize
-    else
-      ivar_name(value.class)
-    end
-    instance_variable_set(:"@#{name}", value)
-  end
-  
-  def ivar_name(klass) 
-    klass.model_name.param_key
-  end
-
-  class << self
-    # 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(plural = true)
-      opts = {:count => (plural ? 3 : 1)}
-      opts[:default] = model_class.model_name.human.titleize
-      opts[:default] = opts[:default].pluralize if plural
-
-      model_class.model_name.human(opts)
-    end
-
-  end
-
-  # Provide before_render callbacks.
-  module Callbacks
-
-    def self.included(controller)
-      controller.extend ActiveModel::Callbacks
-      controller.extend ClassMethods
-      controller.alias_method_chain :render, :callbacks
-
-      controller.define_render_callbacks :index
-    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_callbacks(*args, &block)
-      options = _normalize_render(*args, &block)
-      callback = "render_#{options[:template]}"
-      run_callbacks(callback) if respond_to?(:"_run_#{callback}_callbacks", true)
-
-      render_without_callbacks(*args, &block) unless performed?
-    end
-
-    private
-
-    # Helper method the run the given block in between the before and after
-    # callbacks of the given kinds.
-    def with_callbacks(*kinds, &block)
-      kinds.reverse.inject(block) do |b, kind|
-        lambda { run_callbacks(kind, &b) }
-      end.call
-    end
-
-    module ClassMethods
-      # 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
-  end
-
-  include Callbacks
-
-  # The search functionality for the index table.
-  # Extracted into an own module for convenience.
-  module Search
-    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
-
-    private
-
-    # 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?
-        terms = params[:q].split(/\s+/).collect { |t| "%#{t}%" }
-        clause = search_columns.collect do |f|
-          col = f.to_s.include?('.') ? f : "#{model_class.table_name}.#{f}"
-          "#{col} LIKE ?"
-        end.join(" OR ")
-        clause = terms.collect {|t| "(#{clause})" }.join(" AND ")
-
-         ["(#{clause})"] + terms.collect {|t| [t] * search_columns.size }.flatten
-      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
-    # Adds a :sort_mappings class attribute.
-    def self.included(controller)
-      # Define a map of (virtual) attributes to SQL order expressions.
-      # May be used for sorting table columns that do not appear directly
-      # in the database table. E.g., map :city_id => 'cities.name' to
-      # 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
-
-    private
-
-    # Enhance the list entries with an optional sort order.
-    def list_entries_with_sort
-      if params[:sort].present? && sortable?(params[:sort])
-        list_entries_without_sort.reorder(sort_expression)
-      else
-        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] ||
-            "#{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) ||
-      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)
-      # 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, :page]
-
-      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]
-        remember_params.each {|p| params[p] ||= remembered[p] }
-      end
-    end
-
-    def store_current_params(remembered)
-      remember_params.each do |p|
-        remembered[p] = params[p].presence
-        remembered.delete(p) if remembered[p].nil?
-      end
-    end
-
-    def clear_void_params(remembered)
-      session[:list_params].delete(remember_key) if remembered.blank?
-    end
-
-    # Get the params stored in the session.
-    def remembered_params
-      session[:list_params] ||= {}
-      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
-
-  # Provides functionality to nest controllers/resources.
-  # If a controller is nested, the parent classes and namespaces
-  # may be defined as an array in the :nesting class attribute.
-  # For example, a cities controller, nested in country and a admin
-  # namespace, may define this attribute as follows:
-  #   self.nesting = :admin, Country
-  module Nesting
-
-    # Adds the :nesting class attribute and parent helper methods
-    # to the including controller.
-    def self.included(controller)
-      controller.class_attribute :nesting
-
-      controller.helper_method :parent, :parents
-
-      controller.alias_method_chain :model_scope, :nesting
-      controller.alias_method_chain :path_args, :nesting
-    end
-
-    private
-
-    # Returns the direct parent ActiveRecord of the current request, if any.
-    def parent
-      parents.select {|p| p.is_a?(ActiveRecord::Base) }.last
-    end
-
-    # Returns the parent entries of the current request, if any.
-    # These are ActiveRecords or namespace symbols, corresponding
-    # to the defined nesting attribute.
-    def parents
-      @parents ||= Array(nesting).collect do |p|
-        if p.is_a?(Class) && p < ActiveRecord::Base
-          parent_entry(p)
-        else
-          p
-        end
-      end
-    end
-
-    # Loads the parent entry for the given ActiveRecord class.
-    # By default, performs a find with the class_name_id param.
-    def parent_entry(clazz)
-      set_model_ivar(clazz.find(params["#{clazz.name.underscore}_id"]))
-    end
-
-    # An array of objects used in url_for and related functions.
-    def path_args_with_nesting(last)
-      parents + [last]
-    end
-
-    # Uses the parent entry (if any) to constrain the model scope.
-    def model_scope_with_nesting
-      if parent.present?
-        parent_scope
-      else
-        model_scope_without_nesting
-      end
-    end
-
-    # The model scope for the current parent resource.
-    def parent_scope
-      parent.send(model_class.name.underscore.pluralize)
-    end
-  end
-
-  include Nesting
+  # Include these modules after the #list_entries method is defined.
+  include Crud::Searchable
+  include Crud::Sortable
 
 end