dry_crud 1.2.7 → 1.3.0

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

@@ -1,56 +1,72 @@
-# Extension of StandardHelper functionality to provide a set of default 
+# Extension of StandardHelper functionality to provide a set of default
 # attributes for the current model to be used in tables and forms. This helper
 # is included in CrudController.
 module CrudHelper
 
-  # Renders a generic form for the current entry with :default_attrs or the 
-  # given attribute array, using the StandardFormBuilder.
+  # Renders a generic form for the current entry with :default_attrs or the
+  # 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 = nil, options = {}, &block)
-    attrs = default_attrs - [:created_at, :updated_at] unless attrs
-    standard_form(@entry, attrs, &block)
+  def crud_form(*attrs, &block)
+    attrs = attrs_or_default(attrs) { default_attrs - [:created_at, :updated_at] }
+    standard_form(@entry, *attrs, &block)
   end
-  
-  # Create a table of the @entries variable with the default or 
-  # the passed attributes in its columns.
+
+  # Create a table of the @entries variable 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)
     if block_given?
       list_table(*attrs, &block)
-    else      
-      attrs = default_attrs if attrs.blank?
-      list_table(*attrs) do |t| 
+    else
+      attrs = attrs_or_default(attrs) { default_attrs }
+      list_table(*attrs) do |t|
          add_table_actions(t)
       end
     end
   end
-  
+
   # Adds a set of standard action link column (show, edit, destroy) to the given table.
   def add_table_actions(table)
     action_col(table) { |e| link_table_action_show(e) }
     action_col(table) { |e| link_table_action_edit(e) }
     action_col(table) { |e| link_table_action_destroy(e) }
   end
-  
+
+  # Action link to show inside a table.
   def link_table_action_show(record)
     link_table_action('show', record)
   end
-  
+
+  # Action link to edit inside a table.
   def link_table_action_edit(record)
-    link_table_action('edit', edit_polymorphic_path(record))  
+    link_table_action('edit', edit_polymorphic_path(record))
   end
-  
+
+  # Action link to destroy inside a table.
   def link_table_action_destroy(record)
-    link_table_action('delete', record, 
-                      :confirm => StandardHelper::CONFIRM_DELETE_MESSAGE, 
-                      :method => :delete)  
+    link_table_action('delete', record,
+                      :confirm => ti(:confirm_delete),
+                      :method => :delete)
   end
-  
+
+  # Generic action link inside a table.
   def link_table_action(image, url, html_options = {})
-  	link_to(action_icon(image), url, html_options) 
+  	link_to(action_icon(image), url, html_options)
   end
-  
+
+  # Defines a column with an action link.
   def action_col(table, &block)
   	table.col('', :class => 'center', &block)
   end
   
+  private
+
+  # 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
+  end
+
 end

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

@@ -1,24 +1,26 @@
-# Extension of StandardHelper functionality to provide a set of default 
+# Extension of StandardHelper functionality to provide a set of default
 # attributes for the current model to be used in tables and forms. This helper
 # is included in CrudController.
 module ListHelper
-  
-  # Create a table of the @entries variable with the default or 
-  # the passed attributes in its columns.
+
+  # Create a table of the @entries variable 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) 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	
     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

@@ -1,23 +1,22 @@
 # A form builder that automatically selects the corresponding input field
 # for ActiveRecord column types. Convenience methods for each column type allow
-# one to customize the different fields. 
+# one to customize the different fields.
 # All field methods may be prefixed with 'labeled_' in order to render
 # a standard label with them.
 class StandardFormBuilder < ActionView::Helpers::FormBuilder
-  
-  BLANK_SELECT_LABEL = 'Please select'
-  REQUIRED_MARK    = '<span class="required">*</span>'.html_safe
-  
-  attr_reader :template 
-  
-  delegate :association, :column_type, :column_property, :captionize, 
+
+  REQUIRED_MARK = '<span class="required">*</span>'.html_safe
+
+  attr_reader :template
+
+  delegate :association, :column_type, :column_property, :captionize, :ta,
            :to => :template
-  
+
   # Render multiple input fields together with a label for the given attributes.
   def labeled_input_fields(*attrs)
     attrs.collect {|a| labeled_input_field(a) }.join("\n").html_safe
   end
-  
+
   # Render a standartized label.
   def label(attr, text = nil, options = {})
     if attr.is_a?(Symbol) && text.nil? && options.blank?
@@ -26,7 +25,7 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
       super(attr, text, options)
     end
   end
-  
+
   # Render a corresponding input field for the given attribute.
   # The input field is chosen based on the ActiveRecord column type.
   # Use additional html_options for the input element.
@@ -47,58 +46,68 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
       end
     end
   end
-  
+
   # Render a standard text field.
   def text_field(attr, html_options = {})
     super(attr, {:size => 30}.merge(html_options))
   end
-  
+
   # Render a standard password field.
   def password_field(attr, html_options = {})
     super(attr, {:size => 30}.merge(html_options))
   end
-  
+
   # Render a standard text area.
   def text_area(attr, html_options = {})
     super(attr, {:rows => 5, :cols => 30}.merge(html_options))
   end
-  
+
   # Render a standard string field with column contraints.
   def string_field(attr, html_options = {})
     limit = column_property(@object, attr, :limit)
     html_options = {:maxlength => limit}.merge(html_options) if limit
     text_field(attr, html_options)
   end
-  
+
   # Render a standard number field.
   def number_field(attr, html_options = {})
     super(attr, {:size => 15}.merge(html_options))
   end
-  
+
   # Render an integer field.
   def integer_field(attr, html_options = {})
     number_field(attr, html_options)
   end
-  
+
   # Render a float field.
   def float_field(attr, html_options = {})
     number_field(attr, html_options)
-  end 
-  
+  end
+
   # Render a decimal field.
   def decimal_field(attr, html_options = {})
     number_field(attr, html_options)
   end
-  
+
   # Render a boolean field.
   def boolean_field(attr, html_options = {})
     check_box(attr, html_options)
   end
-  
+
   # Render a field to select a date. You might want to customize this.
   def date_field(attr, html_options = {})
     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 = {})
+    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 = {})
+    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.
@@ -107,38 +116,45 @@ 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, :label, select_options(attr), html_options)
+      collection_select(attr, list, :id, :to_s, select_options(attr), html_options)
     else
-      '(none available)'
+      ta(:none_available, association(@object, attr))
     end
   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)
     template.labeled(label(attr), field_html, &block)
   end
+
+  # Depending if the given attribute must be present, return
+  # only an initial selection prompt or a blank option, respectively.
+  def select_options(attr)
+    assoc = association(@object, attr)
+    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 
+  # 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)
     if field_method = labeled_field_method?(name)
       labeled(args.first, send(field_method, *args) + required_mark(args.first))
-    else     
+    else
       super(name, *args)
     end
   end
-  
+
   def respond_to?(name)
     labeled_field_method?(name).present? || super(name)
   end
-  
   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)
@@ -149,41 +165,33 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
       false
     end
   end
-  
+
   # Returns the list of association entries, either from options[:list],
   # the instance variable with the pluralized association name or all
   # entries of the association klass.
   def association_entries(attr, options)
-    list = options.delete(:list) 
+    list = options.delete(:list)
     unless list
       assoc = association(@object, attr)
       list = @template.send(:instance_variable_get, :"@#{assoc.name.to_s.pluralize}")
       unless list
-        list = assoc.klass.all(:conditions => assoc.options[:conditions],
-                               :order => assoc.options[:order])
+        list = assoc.klass.where(assoc.options[:conditions]).order(assoc.options[:order])
       end
     end
     list
   end
-  
+
   # 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"]
-    validators = @object.class.validators_on(attr) + 
+    validators = @object.class.validators_on(attr) +
                  @object.class.validators_on(attr_id)
     validators.any? {|v| v.kind == :presence }
   end
-  
-  # Depending if the given attribute must be present, return
-  # only an initial selection prompt or a blank option, respectively.
-  def select_options(attr)
-    required?(attr) ? { :prompt => BLANK_SELECT_LABEL } : 
-                      { :include_blank => StandardHelper::NO_ENTRY }
-  end
-  
+
   private
-  
+
   def labeled_field_method?(name)
     prefix = 'labeled_'
     if name.to_s.start_with?(prefix)
@@ -191,5 +199,5 @@ class StandardFormBuilder < ActionView::Helpers::FormBuilder
       field_method if respond_to?(field_method)
     end
   end
-  
+
 end

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

@@ -1,36 +1,29 @@
-# A view helper to standartize often used functions like formatting, 
-# tables, forms or action links. This helper is ideally defined in the 
+# A view helper to standartize often used functions like formatting,
+# tables, forms or action links. This helper is ideally defined in the
 # ApplicationController.
 module StandardHelper
-  
-  NO_LIST_ENTRIES_MESSAGE = "No entries found"
-  NO_ENTRY                = '(none)'
-  CONFIRM_DELETE_MESSAGE  = 'Do you really want to delete this entry?'
-  
-  FLOAT_FORMAT = "%.2f"
-  TIME_FORMAT  = "%H:%M"
+
   EMPTY_STRING = " ".html_safe   # non-breaking space asserts better css styling.
-  
+
   ################  FORMATTING HELPERS  ##################################
 
   # Define an array of associations symbols in your helper that should not get automatically linked.
   #def no_assoc_links = [:city]
-  
+
   # Formats a single value
   def f(value)
     case value
       when Fixnum then number_with_delimiter(value)
-      when Float  then FLOAT_FORMAT % value
-      when Date   then value.to_s
-      when Time   then value.strftime(TIME_FORMAT)   
-      when true   then 'yes'
-      when false  then 'no'
+      when Float  then number_with_precision(value, :precision => 2)
+      when Date   then l(value)
+      when Time   then l(value, :format => :time)
+      when true   then t(:"global.yes")
+      when false  then t(:"global.no")
       when nil    then EMPTY_STRING
-    else 
-      value.respond_to?(:label) ? value.label : value.to_s
+      else value.to_s
     end
   end
-  
+
   # Formats an arbitrary attribute of the given ActiveRecord object.
   # If no specific format_{attr} method is found, formats the value as follows:
   # If the value is an associated model, renders the label of this object.
@@ -45,150 +38,190 @@ module StandardHelper
       format_type(obj, attr)
     end
   end
-  
-  
+
+
   ##############  STANDARD HTML SECTIONS  ############################
-  
-  
+
+
   # Renders an arbitrary content with the given label. Used for uniform presentation.
   def labeled(label, content = nil, &block)
     content = capture(&block) if block_given?
-    render(:partial => 'shared/labeled', 
-           :locals => { :label => label, :content => content}) 
+    render 'shared/labeled', :label => label, :content => content
   end
-  
+
   # Transform the given text into a form as used by labels or table headers.
   def captionize(text, clazz = nil)
     if clazz.respond_to?(:human_attribute_name)
       clazz.human_attribute_name(text)
     else
-      text.to_s.humanize.titleize      
+      text.to_s.humanize.titleize
     end
   end
-  
-  # Renders a list of attributes with label and value for a given object. 
+
+  # Renders a list of attributes with label and value for a given object.
   # Optionally surrounded with a div.
   def render_attrs(obj, *attrs)
-    attrs.collect do |a| 
+    attrs.collect do |a|
       labeled_attr(obj, a)
     end.join("\n").html_safe
   end
-  
+
   # Renders the formatted content of the given attribute with a label.
   def labeled_attr(obj, attr)
     labeled(captionize(attr, obj.class), format_attr(obj, attr))
   end
-  
-  # Renders a table for the given entries. One column is rendered for each attribute passed. 
+
+  # Renders a table for the given entries. One column is rendered for each attribute passed.
   # If a block is given, the columns defined therein are appended to the attribute columns.
   # If entries is empty, an appropriate message is rendered.
+  # An options hash may be given as the last argument.
   def table(entries, *attrs, &block)
     if entries.present?
-      StandardTableBuilder.table(entries, self) do |t|
+      StandardTableBuilder.table(entries, self, attrs.extract_options!) do |t|
         t.attrs(*attrs)
         yield t if block_given?
       end
     else
-      content_tag(:div, NO_LIST_ENTRIES_MESSAGE, :class => 'list')
+      content_tag(:div, ti(:no_list_entries), :class => 'list')
     end
   end
-  
+
   # Renders a generic form for all given attributes using StandardFormBuilder.
   # Before the input fields, the error messages are rendered, if present.
   # The form is rendered with a basic save button.
   # If a block is given, custom input fields may be rendered and attrs is ignored.
-  def standard_form(object, attrs = [], options = {}, &block)
-    form_for(object, {:builder => StandardFormBuilder}.merge(options)) do |form|
-      content = render(:partial => 'shared/error_messages', 
-                       :locals => {:errors => object.errors})
-      
-      content << if block_given? 
-        capture(form, &block) 
+  # An options hash may be given as the last argument.
+  def standard_form(object, *attrs, &block)
+    form_for(object, {:builder => StandardFormBuilder}.merge(attrs.extract_options!)) do |form|
+      content = render('shared/error_messages', :errors => object.errors, :object => object)
+
+      content << if block_given?
+        capture(form, &block)
       else
         form.labeled_input_fields(*attrs)
       end
-      
-      content << labeled(nil, form.submit("Save") + cancel_link(object))
+
+      content << labeled(nil, form.submit(ti(:"button.save")) + cancel_link(object))
       content.html_safe
     end
   end
-  
+
   def cancel_link(object)
-    link_to("Cancel", polymorphic_path(object), :class => 'cancel')
+    link_to(ti(:"button.cancel"), polymorphic_path(object), :class => 'cancel')
   end
-  
+
   # Alternate table row
   def tr_alt(cycle_name = 'row_class', &block)
     content_tag(:tr, :class => cycle("even", "odd", :name => cycle_name), &block)
   end
   
+  # Renders a div with clear:both style.
   def clear
     content_tag(:div, '', :class => 'clear')
   end
- 
-  
+
+
   ######## ACTION LINKS ###################################################### :nodoc:
-  
+
   # Standard link action to the show page of a given record.
   def link_action_show(record)
-    link_action 'Show', 'show', record
+    link_action ti(:"link.show"), 'show', record
   end
-  
+
   # Standard link action to the edit page of a given record.
   def link_action_edit(record)
-    link_action 'Edit', 'edit', edit_polymorphic_path(record)
+    link_action ti(:"link.edit"), 'edit', edit_polymorphic_path(record)
   end
-  
+
   # Standard link action to the destroy action of a given record.
   def link_action_destroy(record)
-    link_action 'Delete', 'delete', record, 
-                :confirm => CONFIRM_DELETE_MESSAGE, 
+    link_action ti(:"link.delete"), 'delete', record,
+                :confirm => ti(:confirm_delete),
                 :method => :delete
   end
-  
+
   # Standard link action to the list page.
   def link_action_index(url_options = {:action => 'index', :returning => true})
-    link_action 'List', 'list', url_options
+    link_action ti(:"link.list"), 'list', url_options
   end
-  
+
   # Standard link action to the new page.
   def link_action_add(url_options = {:action => 'new'})
-    link_action 'Add', 'add', url_options
+    link_action ti(:"link.add"), 'add', url_options
   end
-  
+
   # A generic helper method to create action links.
   # These link could be styled to look like buttons, for example.
   def link_action(label, icon = nil, url = {}, html_options = {})
-    link_to(icon ? action_icon(icon, label) : label, 
-            url, 
+    link_to(icon ? action_icon(icon, label) : label,
+            url,
             {:class => 'action'}.merge(html_options))
   end
-  
+
+  # Outputs an icon for an action with an optional label.
   def action_icon(icon, label = nil)
-    html = image_tag("actions/#{icon}.png", :size => '16x16') 
+    html = image_tag("actions/#{icon}.png", :size => '16x16')
     html << ' ' << label if label
     html
   end
-  
-  protected
-  
-  # Helper methods that are not directly called from templates.
-  
-  # Formats an active record association
-  def format_assoc(obj, assoc)
-    if assoc_val = obj.send(assoc.name)
-      link_to_unless(no_assoc_link?(assoc, assoc_val), assoc_val.label, assoc_val)
+
+  # Translates the passed key by looking it up over the template lookup path
+  # (i.e., usually the controller hierarchy). The key is searched in the following
+  # order:
+  #  - {controller}.{current_partial}.{key}
+  #  - {controller}.{current_action}.{key}
+  #  - {controller}.global.{key}
+  #  - {parent_controller}.{current_partial}.{key}
+  #  - {parent_controller}.{current_action}.{key}
+  #  - {parent_controller}.global.{key}
+  #  - ...
+  #  - global.{key}
+  def translate_inheritable(key, variables = {})
+    defaults = []
+    if controller.class.respond_to?(:template_lookup_path)
+      partial = @_virtual_path ? @_virtual_path.gsub(%r{.*/_?}, "") : nil
+      controller.class.template_lookup_path.each do |folder|
+        defaults << :"#{folder}.#{partial}.#{key}" if partial
+        defaults << :"#{folder}.#{action_name}.#{key}"
+        defaults << :"#{folder}.global.#{key}"
+      end
     else
-      NO_ENTRY
+      defaults << :"#{controller_name}.#{action_name}.#{key}"
+      defaults << :"#{controller_name}.global.#{key}"
     end
+    defaults << :"global.#{key}"
+    
+    variables[:default] ||= defaults
+    t(defaults.shift, variables)
   end
   
-  # Returns true if no link should be created when formatting the given association.
-  def no_assoc_link?(assoc, val)
-    (respond_to?(:no_assoc_links) && no_assoc_links.to_a.include?(assoc.name.to_sym)) || 
-    !respond_to?("#{val.class.name.underscore}_path".to_sym)
+  alias_method :ti, :translate_inheritable
+
+  # Translates the passed key for an active record association. This helper is used
+  # for rendering association dependent keys in forms like :no_entry, :none_available or 
+  # :please_select.
+  # The key is looked up in the following order:
+  #  - activerecord.associations.models.{model_name}.{association_name}.{key}
+  #  - activerecord.associations.{association_model_name}.{key}
+  #  - global.associations.{key}
+  def translate_association(key, assoc = nil, variables = {})
+    primary = if assoc
+      variables[:default] ||= [:"activerecord.associations.#{assoc.klass.name.underscore}.#{key}",
+                               :"global.associations.#{key}"]
+      :"activerecord.associations.models.#{assoc.active_record.name.underscore}.#{assoc.name}.#{key}"
+    else
+      :"global.associations.#{key}"
+    end
+    t(primary, variables)
   end
   
+  alias_method :ta, :translate_association
+  
+  
+  protected
+
+  # Helper methods that are not directly called from templates.
+
   # Formats an arbitrary attribute of the given object depending on its data type.
   # For ActiveRecords, take the defined data type into account for special types
   # that have no own object class.
@@ -204,24 +237,39 @@ module StandardHelper
       else f(val)
     end
   end
-  
+
   # Returns the ActiveRecord column type or nil.
   def column_type(obj, attr)
     column_property(obj, attr, :type)
   end
-  
+
   # Returns an ActiveRecord column property for the passed attr or nil
   def column_property(obj, attr, property)
     if obj.respond_to?(:column_for_attribute)
       column = obj.column_for_attribute(attr)
       column.try(property)
-    end  
+    end
   end
-  
+
+  # Formats an active record association
+  def format_assoc(obj, assoc)
+    if assoc_val = obj.send(assoc.name)
+      link_to_unless(no_assoc_link?(assoc, assoc_val), assoc_val, assoc_val)
+    else
+      ta(:no_entry, assoc)
+    end
+  end
+
+  # Returns true if no link should be created when formatting the given association.
+  def no_assoc_link?(assoc, val)
+    (respond_to?(:no_assoc_links) && no_assoc_links.to_a.include?(assoc.name.to_sym)) ||
+    !respond_to?("#{val.class.name.underscore}_path".to_sym)
+  end
+
   # Returns the association proxy for the given attribute. The attr parameter
   # may be the _id column or the association name. If a macro (e.g. :belongs_to)
   # is given, the association must be of this type, otherwise, any association
-  # is returned. Returns nil if no association (or not of the given macro) was 
+  # is returned. Returns nil if no association (or not of the given macro) was
   # found.
   def association(obj, attr, macro = nil)
     if obj.class.respond_to?(:reflect_on_association)
@@ -230,5 +278,5 @@ module StandardHelper
       assoc if assoc && (macro.nil? || assoc.macro == macro)
     end
   end
-  
+
 end