dry_crud 1.7.0 → 2.0.0

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

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+
+# Defines forms to edit models. The helper methods come in different
+# granularities:
+# * #plain_form - A form using Crud::FormBuilder.
+# * #standard_form - A #plain_form for a given object and attributes with error
+#   messages and save and cancel buttons.
+# * #crud_form - A #standard_form for the current +entry+, with the given
+#   attributes or default.
+module FormHelper
+
+  # Renders a form using Crud::FormBuilder.
+  def plain_form(object, options = {}, &block)
+    options[:html] ||= {}
+    add_css_class(options[:html], 'form-horizontal')
+    options[:builder] ||= Crud::FormBuilder
+    options[:cancel_url] ||= polymorphic_path(object, returning: true)
+
+    form_for(object, options, &block)
+  end
+
+  # Renders a standard form for the given entry and attributes.
+  # The form is rendered with a basic save and cancel button.
+  # If a block is given, custom input fields may be rendered and attrs is
+  # ignored. Before the input fields, the error messages are rendered,
+  # if present. An options hash may be given as the last argument.
+  def standard_form(object, *attrs, &block)
+    plain_form(object, attrs.extract_options!) do |form|
+      content = form.error_messages
+
+      if block_given?
+        content << capture(form, &block)
+      else
+        content << form.labeled_input_fields(*attrs)
+      end
+
+      content << form.standard_actions
+      content.html_safe
+    end
+  end
+
+  # Renders a crud form for the current entry with default_crud_attrs or the
+  # given attribute array. 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)
+    options = attrs.extract_options!
+    attrs = default_crud_attrs - [:created_at, :updated_at] if attrs.blank?
+    attrs << options
+    standard_form(path_args(entry), *attrs, &block)
+  end
+
+end

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

@@ -0,0 +1,164 @@
+# encoding: UTF-8
+
+# Provides uniform formatting of basic data types, based on Ruby class (#f)
+# or database column type (#format_attr). If other helpers define methods
+# with names like 'format_{class}_{attr}', these methods are used for
+# formatting.
+#
+# Futher helpers standartize the layout of multiple attributes (#render_attrs),
+# values with labels (#labeled) and simple lists.
+module FormatHelper
+
+  # Formats a basic value based on its Ruby class.
+  def f(value)
+    case value
+    when Float, BigDecimal then
+      number_with_precision(value, precision: t('number.format.precision'),
+                                   delimiter: t('number.format.delimiter'))
+    when Date   then l(value)
+    when Time   then "#{l(value.to_date)} #{l(value, format: :time)}"
+    when true   then t('global.yes')
+    when false  then t('global.no')
+    when nil    then UtilityHelper::EMPTY_STRING
+    else value.to_s
+    end
+  end
+
+  # Formats an arbitrary attribute of the given ActiveRecord object.
+  # If no specific format_{class}_{attr} or format_{attr} method is found,
+  # formats the value as follows:
+  # If the value is an associated model, renders the label of this object.
+  # Otherwise, calls format_type.
+  def format_attr(obj, attr)
+    format_with_helper(obj, attr) ||
+    format_association(obj, attr) ||
+    format_type(obj, attr)
+  end
+
+  # Renders a simple unordered list, which will
+  # simply render all passed items or yield them
+  # to your block.
+  def simple_list(items, ul_options = {}, &block)
+    content_tag_nested(:ul, items, ul_options) do |item|
+      content_tag(:li, block_given? ? yield(item) : f(item))
+    end
+  end
+
+  # Renders a list of attributes with label and value for a given object.
+  # Optionally surrounded with a div.
+  def render_attrs(obj, *attrs)
+    content_tag_nested(:dl, attrs, class: 'dl-horizontal') do |a|
+      labeled_attr(obj, a)
+    end
+  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 an arbitrary content with the given label. Used for uniform
+  # presentation.
+  def labeled(label, content = nil, &block)
+    content = capture(&block) if block_given?
+    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)
+    text = text.to_s
+    if clazz.respond_to?(:human_attribute_name)
+      text_without_id = text.end_with?('_ids') ? text[0..-5].pluralize : text
+      clazz.human_attribute_name(text_without_id)
+    else
+      text.humanize.titleize
+    end
+  end
+
+  private
+
+  # Checks whether a format_{class}_{attr} or format_{attr} helper method is
+  # defined and calls it if is.
+  def format_with_helper(obj, attr)
+    class_name = obj.class.name.underscore.gsub('/', '_')
+    format_type_attr_method = :"format_#{class_name}_#{attr}"
+    format_attr_method = :"format_#{attr}"
+
+    if respond_to?(format_type_attr_method)
+      send(format_type_attr_method, obj)
+    elsif respond_to?(format_attr_method)
+      send(format_attr_method, obj)
+    else
+      false
+    end
+  end
+
+  # Checks whether the given attr is an association of obj and formats it
+  # accordingly if it is.
+  def format_association(obj, attr)
+    belongs_to = association(obj, attr, :belongs_to)
+    has_many = association(obj, attr, :has_many, :has_and_belongs_to_many)
+    if belongs_to
+      format_belongs_to(obj, belongs_to)
+    elsif has_many
+      format_has_many(obj, has_many)
+    else
+      false
+    end
+  end
+
+  # Formats an arbitrary attribute of the given object depending on its data
+  # type. For Active Records, take the defined data type into account for
+  # special types that have no own object class.
+  def format_type(obj, attr)
+    val = obj.send(attr)
+    return UtilityHelper::EMPTY_STRING if val.blank?
+
+    case column_type(obj, attr)
+    when :time    then l(val, format: :time)
+    when :date    then f(val.to_date)
+    when :datetime, :timestamp then f(val.time)
+    when :text    then simple_format(h(val))
+    when :decimal then
+      number_with_precision(val.to_s.to_f,
+                            precision: column_property(obj, attr, :scale),
+                            delimiter: t('number.format.delimiter'))
+    else f(val)
+    end
+  end
+
+  # Formats an ActiveRecord +belongs_to+ association
+  def format_belongs_to(obj, assoc)
+    val = obj.send(assoc.name)
+    if val
+      assoc_link(assoc, val)
+    else
+      ta(:no_entry, assoc)
+    end
+  end
+
+  # Formats an ActiveRecord +has_and_belongs_to_many+ or
+  # +has_many+ association.
+  def format_has_many(obj, assoc)
+    values = obj.send(assoc.name)
+    if values.size == 1
+      assoc_link(assoc, values.first)
+    elsif values.present?
+      simple_list(values) { |val| assoc_link(assoc, val) }
+    else
+      ta(:no_entry, assoc)
+    end
+  end
+
+  # Renders a link to the given association entry.
+  def assoc_link(assoc, val)
+    link_to_unless(no_assoc_link?(assoc, val), val.to_s, val)
+  end
+
+  # Returns true if no link should be created when formatting the given
+  # association.
+  def no_assoc_link?(assoc, val)
+    !respond_to?("#{val.class.model_name.singular_route_key}_path".to_sym)
+  end
+
+end

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

@@ -0,0 +1,85 @@
+# encoding: UTF-8
+
+# Translation helpers extending the Rails +translate+ helper to support
+# translation inheritance over the controller class hierarchy.
+module I18nHelper
+
+  # Translates the passed key by looking it up over 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 = {})
+    partial = @virtual_path ? @virtual_path.gsub(/.*\/_?/, '') : nil
+    defaults = inheritable_translation_defaults(key, partial)
+    variables[:default] ||= defaults
+    t(defaults.shift, variables)
+  end
+
+  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 = {})
+    if assoc
+      variables[:default] ||= [association_klass_key(assoc, key).to_sym,
+                               :"global.associations.#{key}"]
+      t(association_owner_key(assoc, key), variables)
+    else
+      t("global.associations.#{key}", variables)
+    end
+  end
+
+  alias_method :ta, :translate_association
+
+  private
+
+  # General translation key based on the klass of the association.
+  def association_klass_key(assoc, key)
+    k = 'activerecord.associations.'
+    k << assoc.klass.model_name.singular
+    k << '.'
+    k << key.to_s
+  end
+
+  # Specific translation key based on the owner model and the name
+  # of the association.
+  def association_owner_key(assoc, key)
+    k = 'activerecord.associations.models.'
+    k << assoc.active_record.model_name.singular
+    k << '.'
+    k << assoc.name.to_s
+    k << '.'
+    k << key.to_s
+  end
+
+  def inheritable_translation_defaults(key, partial)
+    defaults = []
+    current = controller.class
+    while current < ActionController::Base
+      folder = current.controller_path
+      if folder.present?
+        append_controller_translation_keys(defaults, folder, partial, key)
+      end
+      current = current.superclass
+    end
+    defaults << :"global.#{key}"
+  end
+
+  def append_controller_translation_keys(defaults, folder, partial, key)
+    defaults << :"#{folder}.#{partial}.#{key}" if partial
+    defaults << :"#{folder}.#{action_name}.#{key}"
+    defaults << :"#{folder}.global.#{key}"
+  end
+
+end

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

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+# Defines tables to display a list of entries. The helper methods come in
+# different granularities:
+# * #plain_table - A basic table for the given entries and attributes using
+#   the Crud::TableBuilder.
+# * #list_table - A sortable #plain_table for the current +entries+, with the
+#   given attributes or default.
+# * #crud_table - A sortable #plain_table for the current +entries+, with the
+#   given attributes or default and the standard crud action links.
+module TableHelper
+
+  # 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 plain_table(entries, *attrs, &block)
+    options = attrs.extract_options!
+    add_css_class(options, 'table')
+    Crud::TableBuilder.table(entries, self, options) do |t|
+      t.attrs(*attrs)
+      yield t if block_given?
+    end
+  end
+
+  # Renders a #plain_table for the given entries.
+  # If entries is empty, an appropriate message is rendered.
+  def plain_table_or_message(entries, *attrs, &block)
+    entries.to_a # force evaluation of relations
+    if entries.present?
+      plain_table(entries, *attrs, &block)
+    else
+      content_tag(:div, ti(:no_list_entries), class: 'table')
+    end
+  end
+
+  # 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)
+    attrs, options = explode_attrs_with_options(attrs, &block)
+    plain_table_or_message(entries, options) do |t|
+      t.sortable_attrs(*attrs)
+      yield t if block_given?
+    end
+  end
+
+  # Create a table of the current +entries+ with the default or the passed
+  # attributes in its columns. Edit and destroy actions are added to each row.
+  # If attrs are present, the first column will link to the show
+  # action. Edit and destroy actions are appended to the end of each row.
+  # If a block is given, the column defined there will be inserted
+  # between the given attributes and the actions.
+  # An options hash for the table builder may be given as the last argument.
+  def crud_table(*attrs, &block)
+    attrs, options = explode_attrs_with_options(attrs, &block)
+    first = attrs.shift
+    plain_table_or_message(entries, options) do |t|
+       t.attr_with_show_link(first) if first
+       t.sortable_attrs(*attrs)
+       yield t if block_given?
+       standard_table_actions(t)
+    end
+  end
+
+  # Adds standard action link columns (edit, destroy) to the given table.
+  def standard_table_actions(table)
+    table.edit_action_col
+    table.destroy_action_col
+  end
+
+  private
+
+  def explode_attrs_with_options(attrs, &block)
+    options = attrs.extract_options!
+    if !block_given? && attrs.blank?
+      attrs = default_crud_attrs
+    end
+    [attrs, options]
+  end
+
+end

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

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+
+# View helpers for basic functions used in various other helpers.
+module UtilityHelper
+
+  EMPTY_STRING = ' '.html_safe   # non-breaking space asserts better css.
+
+  # Render a content tag with the collected contents rendered
+  # by &block for each item in collection.
+  def content_tag_nested(tag, collection, options = {}, &block)
+    content_tag(tag, safe_join(collection, &block), options)
+  end
+
+  # Overridden method that takes a block that is executed for each item in
+  # array before appending the results.
+  def safe_join(array, sep = $OUTPUT_FIELD_SEPARATOR, &block)
+    super(block_given? ? array.map(&block) : array, sep)
+  end
+
+  # Returns the css class for the given flash level.
+  def flash_class(level)
+    case level
+    when :notice then 'success'
+    when :alert then 'error'
+    else level.to_s
+    end
+  end
+
+  # Adds a class to the given options, even if there are already classes.
+  def add_css_class(options, classes)
+    if options[:class]
+      options[:class] += ' ' + classes if classes
+    else
+      options[:class] = classes
+    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_crud_attrs
+    attrs = model_class.column_names.map(&:to_sym)
+    attrs - [:id, :position, :password]
+  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
+
+  # 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 found.
+  def association(obj, attr, *macros)
+    if obj.class.respond_to?(:reflect_on_association)
+      name = assoc_and_id_attr(attr).first.to_sym
+      assoc = obj.class.reflect_on_association(name)
+      assoc if assoc && (macros.blank? || macros.include?(assoc.macro))
+    end
+  end
+
+  # Returns the name of the attr and it's corresponding field
+  def assoc_and_id_attr(attr)
+    attr = attr.to_s
+    if attr.end_with?('_id')
+      [attr[0..-4], attr]
+    elsif attr.end_with?('_ids')
+      [attr[0..-5].pluralize, attr]
+    else
+      [attr, "#{attr}_id"]
+    end
+  end
+
+end