dry_crud 1.5.0 → 1.6.0

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

@@ -6,62 +6,71 @@
 # the user the same list as he left it.
 class ListController < ApplicationController
 
-  helper_method :model_class, :models_label, :path_args
+  helper_method :model_class, :models_label, :entries, :path_args
 
   delegate :model_class, :models_label, :to => 'self.class'
 
   hide_action :model_class, :models_label, :inheritable_root_controller
 
+  respond_to :html, :json
 
   ##############  ACTIONS  ############################################
 
   # List all entries of this model.
   #   GET /entries
   #   GET /entries.json
-  def index
-    @entries = list_entries
-    respond_with @entries
+  def index(&block)
+    respond_with(entries, &block)
   end
 
   protected
 
-  # The entries to be displayed in the current index page.
+  # 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.
   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 
+  # 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
 
-  # Convenience method to respond to various formats with the given object.
-  def respond_with(object)
-    respond_to do |format|
-      format.html { render_with_callback action_name }
-      format.json  { render :json => object }
-    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 = model_class.name.underscore
+    name = name.pluralize if plural
+    instance_variable_get(:"@#{name}")
   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 unless performed?
+  # 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
+      value.klass.name.pluralize
+    elsif value.respond_to?(:each) # Array
+      value.first.klass.name.pluralize
+    else
+      value.class.name
+    end
+    instance_variable_set(:"@#{name.underscore}", value)
   end
 
   class << self
-    # Callbacks
-    include ActiveModel::Callbacks
-   
     # The ActiveRecord class of the model.
     def model_class
       @model_class ||= controller_name.classify.constantize
@@ -72,20 +81,56 @@ class ListController < ApplicationController
       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
-    
-    # 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
+
+  # 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)
+      p options if options[:location] == :back
+      callback = "render_#{options[:template]}"
+      run_callbacks(callback) if respond_to?(:"_run_#{callback}_callbacks", true)
+
+      render_without_callbacks(*args, &block) unless performed?
+    end
+
+    protected
+
+    # 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
-  
-  define_render_callbacks :index
+
+  include Callbacks
 
   # The search functionality for the index table.
   # Extracted into an own module for convenience.
@@ -111,12 +156,12 @@ class ListController < ApplicationController
     def search_condition
       if search_support? && params[:q].present?
         terms = params[:q].split(/\s+/).collect { |t| "%#{t}%" }
-        clause = search_columns.collect do |f| 
+        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
@@ -228,7 +273,7 @@ class ListController < ApplicationController
       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
@@ -245,27 +290,27 @@ class ListController < ApplicationController
   # 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
-    
+
     protected
-    
+
     # 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 
+    # These are ActiveRecords or namespace symbols, corresponding
     # to the defined nesting attribute.
     def parents
       @parents ||= Array(nesting).collect do |p|
@@ -276,18 +321,18 @@ class ListController < ApplicationController
         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)
-      clazz.find(params["#{clazz.name.underscore}_id"])
+      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?
@@ -296,13 +341,13 @@ class ListController < ApplicationController
         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
-  
-end
+
+end

data/lib/generators/dry_crud/templates/app/helpers/crud_helper.rb

@@ -4,7 +4,7 @@
 module CrudHelper
 
   # Renders a generic form for the current entry with :default_attrs or the
-  # given attribute array, using the StandardFormBuilder. An options hash 
+  # given attribute array, using the StandardFormBuilder. An options hash
   # may be given as the last argument.
   # If a block is given, a custom form may be rendered and attrs is ignored.
   def crud_form(*attrs, &block)
@@ -12,7 +12,7 @@ module CrudHelper
     standard_form(path_args(entry), *attrs, &block)
   end
 
-  # Create a table of the @entries variable with the default or
+  # Create a table of the entries with the default or
   # the passed attributes in its columns. An options hash may be given
   # as the last argument.
   def crud_table(*attrs, &block)
@@ -42,7 +42,7 @@ module CrudHelper
   # Action link to edit inside a table.
   # A block may be given to define the link path for the row entry.
   def action_col_edit(table, &block)
-    action_col(table) do |e| 
+    action_col(table) do |e|
       path = action_path(e, &block)
       link_table_action('pencil', path.is_a?(String) ? path : edit_polymorphic_path(path))
     end
@@ -61,14 +61,14 @@ module CrudHelper
   # Generic action link inside a table.
   def link_table_action(icon, url, html_options = {})
     add_css_class html_options, "icon-#{icon}"
-  	link_to('', url, html_options)
+    link_to('', url, html_options)
   end
 
   # Defines a column with an action link.
   def action_col(table, &block)
-  	table.col('', :class => 'action', &block)
+    table.col('', :class => 'action', &block)
   end
-  
+
   ######## ACTION LINKS ###################################################### :nodoc:
 
   # Standard link action to the show page of a given record.
@@ -107,7 +107,7 @@ module CrudHelper
     path ||= path_args(model_class)
     link_action ti(:"link.add"), 'plus', path.is_a?(String) ? path : new_polymorphic_path(path, url_options)
   end
-  
+
   private
 
   # If a block is given, call it to get the path for the current row entry.
@@ -115,12 +115,12 @@ module CrudHelper
   def action_path(e, &block)
     block_given? ? yield(e) : path_args(e)
   end
-  
+
   # Returns default attrs for a crud table if no others are passed.
   def attrs_or_default(attrs)
-  	options = attrs.extract_options!
-  	attrs = yield if attrs.blank?
-  	attrs << options
+    options = attrs.extract_options!
+    attrs = yield if attrs.blank?
+    attrs << options
   end
 
 end

data/lib/generators/dry_crud/templates/app/helpers/list_helper.rb

@@ -3,25 +3,25 @@
 # is included in CrudController.
 module ListHelper
 
-  # Create a table of the @entries variable with the default or
+  # Create a table of the entries with the default or
   # the passed attributes in its columns. An options hash may be given
   # as the last argument.
   def list_table(*attrs, &block)
     options = attrs.extract_options!
     # only use default attrs if no attrs and no block are given
     attributes = (block_given? || attrs.present?) ? attrs : default_attrs
-    table(@entries, options) do |t|
-  	  t.sortable_attrs(*attributes)	
-  	  yield t if block_given?
+    table(entries, options) do |t|
+      t.sortable_attrs(*attributes)
+      yield t if block_given?
     end
   end
 
   # The default attributes to use in attrs, list and form partials.
   # These are all defined attributes except certain special ones like 'id' or 'position'.
-  def default_attrs	
+  def default_attrs
     attrs = model_class.column_names.collect(&:to_sym)
     attrs - [:id, :position, :password]
   end
-  
-  
+
+
 end

data/lib/generators/dry_crud/templates/app/helpers/standard_form_builder.rb

@@ -9,15 +9,14 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
 
   attr_reader :template
 
-  delegate :association, :column_type, :column_property, :captionize, 
-           :content_tag, :ta, :add_css_class, :to => :template
+  delegate :association, :column_type, :column_property, :captionize, :ta,
+           :content_tag, :safe_join, :capture, :add_css_class, :assoc_and_id_attr,
+           :to => :template
 
   # Render multiple input fields together with a label for the given attributes.
   def labeled_input_fields(*attrs)
     options = attrs.extract_options!
-    attrs.collect do |a|
-      labeled_input_field(a, options.clone)
-    end.join("\n").html_safe
+    safe_join(attrs) { |a| labeled_input_field(a, options.clone) }
   end
 
   # Render a corresponding input field for the given attribute.
@@ -27,8 +26,10 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
     type = column_type(@object, attr)
     if type == :text
       text_area(attr, html_options)
-    elsif belongs_to_association?(attr, type)
+    elsif association_kind?(attr, type, :belongs_to)
       belongs_to_field(attr, html_options)
+    elsif association_kind?(attr, type, :has_and_belongs_to_many, :has_many)
+      has_many_field(attr, html_options)
     elsif attr.to_s.include?('password')
       password_field(attr, html_options)
     else
@@ -43,11 +44,10 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
 
   # Render a number field.
   def number_field(attr, html_options = {})
-    add_css_class html_options, 'span1'
     html_options[:size] ||= 10
     super(attr, html_options)
   end
-  
+
   # Render a standard string field with column contraints.
   def string_field(attr, html_options = {})
     html_options[:maxlength] ||= column_property(@object, attr, :limit)
@@ -80,22 +80,19 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
 
   # Render a field to select a date. You might want to customize this.
   def date_field(attr, html_options = {})
-    add_css_class html_options, 'span1'
     date_select(attr, {}, html_options)
   end
 
   # Render a field to enter a time. You might want to customize this.
   def time_field(attr, html_options = {})
-    add_css_class html_options, 'span1'
     time_select(attr, {}, html_options)
   end
-  
+
   # Render a field to enter a date and time. You might want to customize this.
   def datetime_field(attr, html_options = {})
-    add_css_class html_options, 'span1'
     datetime_select(attr, {}, html_options)
   end
-  
+
   # Render a select element for a :belongs_to association defined by attr.
   # Use additional html_options for the select element.
   # To pass a custom element list, specify the list with the :list key or
@@ -103,24 +100,52 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
   def belongs_to_field(attr, html_options = {})
     list = association_entries(attr, html_options)
     if list.present?
-      collection_select(attr, list, :id, :to_s, select_options(attr), html_options)
+      collection_select(attr,
+                        list,
+                        :id,
+                        :to_s,
+                        html_options[:multiple] ? {} : select_options(attr),
+                        html_options)
     else
       ta(:none_available, association(@object, attr))
     end
   end
 
+  # Render a multi select element for a :has_many or :has_and_belongs_to_many
+  # association defined by attr.
+  # Use additional html_options for the select element.
+  # To pass a custom element list, specify the list with the :list key or
+  # define an instance variable with the pluralized name of the association.
+  def has_many_field(attr, html_options = {})
+    html_options[:multiple] = true
+    add_css_class(html_options, 'multiselect')
+    belongs_to_field(attr, html_options)
+  end
+
   # Renders a marker if the given attr has to be present.
   def required_mark(attr)
     required?(attr) ? REQUIRED_MARK : ''
   end
 
   # Render a label for the given attribute with the passed field html section.
-  def labeled(attr, field_html = nil, &block)
-    field_html = capture(&block) if block_given?
-    content_tag(:div, 
-                label(attr, :class => 'control-label') + 
-                content_tag(:div, field_html, :class => 'controls'), 
-                :class => 'control-group')
+  # The following parameters may be specified:
+  #   labeled(:attr) { #content }
+  #   labeled(:attr, content)
+  #   labeled(:attr, 'Caption') { #content }
+  #   labeled(:attr, 'Caption', content)
+  def labeled(attr, caption_or_content = nil, content = nil, &block)
+    if block_given?
+      content = capture(&block)
+    elsif content.nil?
+      content = caption_or_content
+      caption_or_content = nil
+    end
+    caption_or_content ||= captionize(attr, @object.class)
+
+    content_tag(:div, :class => "control-group#{' error' if @object.errors.has_key?(attr)}") do
+      label(attr, caption_or_content, :class => 'control-label') +
+      content_tag(:div, content, :class => 'controls')
+    end
   end
 
   # Depending if the given attribute must be present, return
@@ -130,7 +155,7 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
     required?(attr) ? { :prompt => ta(:please_select, assoc) } :
                       { :include_blank => ta(:no_entry, assoc) }
   end
-  
+
   # Dispatch methods starting with 'labeled_' to render a label and the corresponding
   # input field. E.g. labeled_boolean_field(:checked, :class => 'bold')
   def method_missing(name, *args)
@@ -148,11 +173,11 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
 
   protected
 
-  # Returns true if attr is a non-polymorphic belongs_to association,
-  # for which an input field may be automatically rendered.
-  def belongs_to_association?(attr, type)
+  # Returns true if attr is a non-polymorphic association.
+  # If one or more macros are given, the association must be of this kind.
+  def association_kind?(attr, type, *macros)
     if type == :integer || type.nil?
-      assoc = association(@object, attr, :belongs_to)
+      assoc = association(@object, attr, *macros)
       assoc.present? && assoc.options[:polymorphic].nil?
     else
       false
@@ -177,10 +202,13 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
   # Returns true if the given attribute must be present.
   def required?(attr)
     attr = attr.to_s
-    attr, attr_id = attr.end_with?('_id') ? [attr[0..-4], attr] : [attr, "#{attr}_id"]
+    attr, attr_id = assoc_and_id_attr(attr)
     validators = @object.class.validators_on(attr) +
                  @object.class.validators_on(attr_id)
-    validators.any? {|v| v.kind == :presence }
+    validators.any? do |v|
+      v.kind == :presence &&
+      !v.options.key?(:if) && !v.options.key?(:unless)
+    end
   end
 
   private