dry_crud 1.7.0 → 2.0.0

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

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+# Helpers to create action links. This default implementation supports
+# regular links with an icon and a label. To change the general style
+# of action links, change the method #action_link, e.g. to generate a button.
+# The common crud actions show, edit, destroy, index and add are provided here.
+module ActionsHelper
+
+  # A generic helper method to create action links.
+  # These link could be styled to look like buttons, for example.
+  def action_link(label, icon = nil, url = {}, html_options = {})
+    add_css_class html_options, 'action btn'
+    link_to(icon ? action_icon(icon, label) : label,
+            url, html_options)
+  end
+
+  # Outputs an icon for an action with an optional label.
+  def action_icon(icon, label = nil)
+    html = content_tag(:i, '', class: "icon-#{icon}")
+    html << ' ' << label if label
+    html
+  end
+
+  # Standard show action to the given path.
+  # Uses the current +entry+ if no path is given.
+  def show_action_link(path = nil)
+    path ||= path_args(entry)
+    action_link(ti('link.show'), 'zoom-in', path)
+  end
+
+  # Standard edit action to given path.
+  # Uses the current +entry+ if no path is given.
+  def edit_action_link(path = nil)
+    path ||= path_args(entry)
+    path = path.is_a?(String) ? path : edit_polymorphic_path(path)
+    action_link(ti('link.edit'), 'pencil', path)
+  end
+
+  # Standard destroy action to the given path.
+  # Uses the current +entry+ if no path is given.
+  def destroy_action_link(path = nil)
+    path ||= path_args(entry)
+    action_link(ti('link.delete'), 'remove', path,
+                data: { confirm: ti(:confirm_delete),
+                        method: :delete })
+  end
+
+  # Standard list action to the given path.
+  # Uses the current +model_class+ if no path is given.
+  def index_action_link(path = nil, url_options = { returning: true })
+    path ||= path_args(model_class)
+    path = path.is_a?(String) ? path : polymorphic_path(path, url_options)
+    action_link(ti('link.list'), 'list', path)
+  end
+
+  # Standard add action to given path.
+  # Uses the current +model_class+ if no path is given.
+  def add_action_link(path = nil, url_options = {})
+    path ||= path_args(model_class)
+    path = path.is_a?(String) ? path : new_polymorphic_path(path, url_options)
+    action_link(ti('link.add'), 'plus', path)
+  end
+
+end

data/lib/generators/dry_crud/templates/app/helpers/crud/form_builder.rb

@@ -0,0 +1,331 @@
+# encoding: UTF-8
+
+module Crud
+  # 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.
+  #
+  # All field methods may be prefixed with +labeled_+ in order to render
+  # a standard label, required mark and an optional help block with them.
+  class FormBuilder < ActionView::Helpers::FormBuilder
+
+    REQUIRED_MARK = '<span class="required">*</span>'.html_safe
+
+    attr_reader :template
+
+    delegate :association, :column_type, :column_property, :captionize,
+             :ti, :ta, :link_to, :content_tag, :safe_join, :capture,
+             :add_css_class, :assoc_and_id_attr,
+             to: :template
+
+    ### INPUT FIELDS
+
+    # Render multiple input fields together with a label for the given
+    # attributes.
+    def labeled_input_fields(*attrs)
+      options = attrs.extract_options!
+      safe_join(attrs) { |a| labeled_input_field(a, options.clone) }
+    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.
+    def input_field(attr, html_options = {})
+      type = column_type(@object, attr)
+      custom_field_method = :"#{type}_field"
+      if type == :text
+        text_area(attr, html_options)
+      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)
+      elsif attr.to_s.include?('email')
+        email_field(attr, html_options)
+      elsif respond_to?(custom_field_method)
+        send(custom_field_method, attr, html_options)
+      else
+        text_field(attr, html_options)
+      end
+    end
+
+    # Render a number field.
+    def number_field(attr, html_options = {})
+      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)
+      html_options[:size] ||= 30
+      text_field(attr, html_options)
+    end
+
+    # Render a text_area.
+    def text_area(attr, html_options = {})
+      html_options[:rows] ||= 5
+      super(attr, html_options)
+    end
+
+    # Render a email field.
+    def email_field(attr, html_options = {})
+      html_options[:size] ||= 30
+      super(attr, html_options)
+    end
+
+    # Render an integer field.
+    def integer_field(attr, html_options = {})
+      html_options[:step] ||= 1
+      number_field(attr, html_options)
+    end
+
+    # Render a float field.
+    def float_field(attr, html_options = {})
+      html_options[:step] ||= 'any'
+      number_field(attr, html_options)
+    end
+
+    # Render a decimal field.
+    def decimal_field(attr, html_options = {})
+      html_options[:step] ||= 'any'
+      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.
+    # 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 belongs_to_field(attr, html_options = {})
+      list = association_entries(attr, html_options).to_a
+      if list.present?
+        collection_select(attr, list, :id, :to_s,
+                          select_options(attr, html_options),
+                          html_options)
+      else
+        ta(:none_available, association(@object, attr)).html_safe
+      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
+
+    # Dispatch methods starting with 'labeled_' to render a label and the
+    # corresponding input field.
+    # E.g. labeled_boolean_field(:checked, class: 'bold')
+    # To add an additional help text, use the help option.
+    # E.g. labeled_boolean_field(:checked, help: 'Some Help')
+    def method_missing(name, *args)
+      field_method = labeled_field_method?(name)
+      if field_method
+        build_labeled_field(field_method, *args)
+      else
+        super(name, *args)
+      end
+    end
+
+    # Overriden to fullfill contract with method_missing 'labeled_' methods.
+    def respond_to?(name)
+      labeled_field_method?(name).present? || super(name)
+    end
+
+    ### VARIOUS FORM ELEMENTS
+
+    # Render the error messages for the current form.
+    def error_messages
+      @template.render('shared/error_messages',
+                       errors: @object.errors,
+                       object: @object)
+    end
+
+    # Generates a help block for fields
+    def help_block(text)
+      content_tag(:p, text, class: 'help-block')
+    end
+
+    # Render a submit button and a cancel link for this form.
+    def standard_actions(submit_label = ti('button.save'), cancel_url = nil)
+      content_tag(:div, class: 'form-actions') do
+        safe_join([submit_button(submit_label), cancel_link(cancel_url)], ' ')
+      end
+    end
+
+    # Render a standard submit button with the given label.
+    def submit_button(label = ti('button.save'))
+      button(label, class: 'btn btn-primary', data: { disable_with: label })
+    end
+
+    # Render a cancel link pointing to the given url.
+    def cancel_link(url = nil)
+      url ||= cancel_url
+      link_to(ti('button.cancel'), url, class: 'cancel')
+    end
+
+    # Render a label for the given attribute with the passed field html
+    # section. 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,
+                html_options = {}, &block)
+      caption, content = extract_caption_and_content(
+                           attr, caption_or_content, content, &block)
+      add_css_class(html_options, 'controls')
+      errors = errors_on?(attr) ? ' error' : ''
+
+      content_tag(:div, class: "control-group#{errors}") do
+        label(attr, caption, class: 'control-label') +
+        content_tag(:div, content, html_options)
+      end
+    end
+
+    # Depending if the given attribute must be present, return
+    # only an initial selection prompt or a blank option, respectively.
+    def select_options(attr, options = {})
+      prompt = options.delete(:prompt)
+      blank = options.delete(:include_blank)
+      if options[:multiple]
+        {}
+      elsif prompt
+        { prompt: prompt }
+      elsif blank
+        { include_blank: blank }
+      else
+        assoc = association(@object, attr)
+        if required?(attr)
+          { prompt: ta(:please_select, assoc) }
+        else
+          { include_blank: ta(:no_entry, assoc) }
+        end
+      end
+    end
+
+    private
+
+    # 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, *macros)
+        assoc.present? && assoc.options[:polymorphic].nil?
+      else
+        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)
+      unless list
+        assoc = association(@object, attr)
+        list = @template.send(:instance_variable_get,
+                              :"@#{assoc.name.to_s.pluralize}")
+        unless list
+          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 = assoc_and_id_attr(attr)
+      validators = @object.class.validators_on(attr) +
+                   @object.class.validators_on(attr_id)
+      validators.any? do |v|
+        v.kind == :presence &&
+        !v.options.key?(:if) &&
+        !v.options.key?(:unless)
+      end
+    end
+
+    # Returns true if any errors are found on the passed attribute or its
+    # association.
+    def errors_on?(attr)
+      attr_plain, attr_id = assoc_and_id_attr(attr)
+      @object.errors.has_key?(attr_plain.to_sym) ||
+      @object.errors.has_key?(attr_id.to_sym)
+    end
+
+    # Get caption and content value from the arguments of #labeled.
+    def extract_caption_and_content(attr, caption_or_content, content, &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)
+
+      [caption_or_content, content]
+    end
+
+    # Checks if the passed name corresponds to a field method with a
+    # 'labeled_' prefix.
+    def labeled_field_method?(name)
+      prefix = 'labeled_'
+      if name.to_s.start_with?(prefix)
+        field_method = name.to_s[prefix.size..-1]
+        field_method if respond_to?(field_method)
+      end
+    end
+
+    # Renders the corresponding field together with a label, required mark and
+    # an optional help block.
+    def build_labeled_field(field_method, *args)
+      required = required?(args.first)
+      options = args.extract_options!
+      options[:required] ||= 'required' if required
+      help = options.delete(:help)
+      content = send(field_method, *(args << options))
+      content << REQUIRED_MARK if required
+      content << help_block(help) if help.present?
+      labeled(args.first, content)
+    end
+
+    # Get the cancel url for the given object considering options:
+    # 1. Use :cancel_url_new or :cancel_url_edit option, if present
+    # 2. Use :cancel_url option, if present
+    def cancel_url
+      url = @object.new_record? ? options[:cancel_url_new] :
+                                  options[:cancel_url_edit]
+      url || options[:cancel_url]
+    end
+
+  end
+end

data/lib/generators/dry_crud/templates/app/helpers/crud/table_builder.rb

@@ -0,0 +1,280 @@
+# encoding: UTF-8
+
+module Crud
+  # A simple helper to easily define tables listing several rows of the same
+  # data type.
+  #
+  # Example Usage:
+  #   Crud::TableBuilder.table(entries, template) do |t|
+  #     t.col('My Header', class: 'css') {|e| link_to 'Show', e }
+  #     t.attrs :name, :city
+  #   end
+  class TableBuilder
+    attr_reader :entries, :cols, :options, :template
+
+    delegate :content_tag, :format_attr, :column_type, :association, :dom_id,
+             :captionize, :add_css_class, :content_tag_nested,
+             to: :template
+
+    def initialize(entries, template, options = {})
+      @entries = entries
+      @template = template
+      @options = options
+      @cols = []
+    end
+
+    # Convenience method to directly generate a table. Renders a row for each
+    # entry in entries. Takes a block that gets the table object as parameter
+    # for configuration. Returns the generated html for the table.
+    def self.table(entries, template, options = {})
+      t = new(entries, template, options)
+      yield t
+      t.to_html
+    end
+
+    # Define a column for the table with the given header, the html_options
+    # used for each td and a block rendering the contents of a cell for the
+    # current entry. The columns appear in the order they are defined.
+    def col(header = '', html_options = {}, &block)
+      @cols << Col.new(header, html_options, @template, block)
+    end
+
+    # Convenience method to add one or more attribute columns.
+    # The attribute name will become the header, the cells will contain
+    # the formatted attribute value for the current entry.
+    def attrs(*attrs)
+      attrs.each do |a|
+        attr(a)
+      end
+    end
+
+    # Define a column for the given attribute and an optional header.
+    # If no header is given, the attribute name is used. The cell will
+    # contain the formatted attribute value for the current entry.
+    def attr(a, header = nil, html_options = {}, &block)
+      header ||= attr_header(a)
+      block ||= ->(e) { format_attr(e, a) }
+      add_css_class(html_options, align_class(a))
+      col(header, html_options, &block)
+    end
+
+    # Renders the table as HTML.
+    def to_html
+      content_tag :table, options do
+        content_tag(:thead, html_header) +
+        content_tag_nested(:tbody, entries) { |e| html_row(e) }
+      end
+    end
+
+    # Returns css classes used for alignment of the cell data.
+    # Based on the column type of the attribute.
+    def align_class(attr)
+      entry = entries.present? ? entry_class.new : nil
+      case column_type(entry, attr)
+      when :integer, :float, :decimal
+        'right' unless association(entry, attr, :belongs_to)
+      when :boolean
+        'center'
+      end
+    end
+
+    # Creates a header string for the given attr.
+    def attr_header(attr)
+      captionize(attr, entry_class)
+    end
+
+    private
+
+    # Renders the header row of the table.
+    def html_header
+      content_tag_nested(:tr, cols) { |c| c.html_header }
+    end
+
+    # Renders a table row for the given entry.
+    def html_row(entry)
+      attrs = {}
+      attrs[:id] = dom_id(entry) if entry.respond_to?(:to_key)
+      content_tag_nested(:tr, cols, attrs) { |c| c.html_cell(entry) }
+    end
+
+    # Determines the class of the table entries.
+    # All entries should be of the same type.
+    def entry_class
+      if entries.respond_to?(:klass)
+        entries.klass
+      else
+        entries.first.class
+      end
+    end
+
+    # Helper class to store column information.
+    class Col < Struct.new(:header, :html_options, :template, :block) #:nodoc:
+
+      delegate :content_tag, :capture, to: :template
+
+      # Runs the Col block for the given entry.
+      def content(entry)
+        entry.nil? ? '' : capture(entry, &block)
+      end
+
+      # Renders the header cell of the Col.
+      def html_header
+        content_tag(:th, header, html_options)
+      end
+
+      # Renders a table cell for the given entry.
+      def html_cell(entry)
+        content_tag(:td, content(entry), html_options)
+      end
+
+    end
+
+    # Provides headers with sort links. Expects a method :sortable?(attr)
+    # in the template/controller to tell if an attribute is sortable or not.
+    # Extracted into an own module for convenience.
+    module Sorting
+      # Create a header with sort links and a mark for the current sort
+      # direction.
+      def sort_header(attr, label = nil)
+        label ||= attr_header(attr)
+        template.link_to(label, sort_params(attr)) + current_mark(attr)
+      end
+
+      # Same as :attrs, except that it renders a sort link in the header
+      # if an attr is sortable.
+      def sortable_attrs(*attrs)
+        attrs.each { |a| sortable_attr(a) }
+      end
+
+      # Renders a sort link header, otherwise similar to :attr.
+      def sortable_attr(a, header = nil, &block)
+        if template.sortable?(a)
+          attr(a, sort_header(a, header), &block)
+        else
+          attr(a, header, &block)
+        end
+      end
+
+      private
+
+      # Request params for the sort link.
+      def sort_params(attr)
+        params.merge({ sort: attr, sort_dir: sort_dir(attr) })
+      end
+
+      # The sort mark, if any, for the given attribute.
+      def current_mark(attr)
+        if current_sort?(attr)
+          (sort_dir(attr) == 'asc' ? ' &uarr;' : ' &darr;').html_safe
+        else
+          ''
+        end
+      end
+
+      # Returns true if the given attribute is the current sort column.
+      def current_sort?(attr)
+        params[:sort] == attr.to_s
+      end
+
+      # The sort direction to use in the sort link for the given attribute.
+      def sort_dir(attr)
+        current_sort?(attr) && params[:sort_dir] == 'asc' ? 'desc' : 'asc'
+      end
+
+      # Delegate to template.
+      def params
+        template.params
+      end
+    end
+
+    include Sorting
+
+    # Adds action columns to the table builder.
+    # Predefined actions are available for show, edit and destroy.
+    # Additionally, a special col type to define cells linked to the show page
+    # of the row entry is provided.
+    module Actions
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :link_to, :path_args, :edit_polymorphic_path, :ti,
+                 to: :template
+      end
+
+      # Renders the passed attr with a link to the show action for
+      # the current entry.
+      # A block may be given to define the link path for the row entry.
+      def attr_with_show_link(attr, &block)
+        sortable_attr(attr) do |e|
+          link_to(format_attr(e, attr), action_path(e, &block))
+        end
+      end
+
+      # Action column to show the row entry.
+      # A block may be given to define the link path for the row entry.
+      # If the block returns nil, no link is rendered.
+      def show_action_col(html_options = {}, &block)
+        action_col do |e|
+          path = action_path(e, &block)
+          if path
+            table_action_link('zoom-in',
+                              path,
+                              html_options)
+          end
+        end
+      end
+
+      # Action column to edit the row entry.
+      # A block may be given to define the link path for the row entry.
+      # If the block returns nil, no link is rendered.
+      def edit_action_col(html_options = {}, &block)
+        action_col do |e|
+          path = action_path(e, &block)
+          if path
+            path = path.is_a?(String) ? path : edit_polymorphic_path(path)
+            table_action_link('pencil', path, html_options)
+          end
+        end
+      end
+
+      # Action column to destroy the row entry.
+      # A block may be given to define the link path for the row entry.
+      # If the block returns nil, no link is rendered.
+      def destroy_action_col(html_options = {}, &block)
+        action_col do |e|
+          path = action_path(e, &block)
+          if path
+            table_action_link('remove',
+                              path,
+                              html_options.merge(
+                                data: { confirm: ti(:confirm_delete),
+                                        method: :delete }))
+          end
+        end
+      end
+
+      # Action column inside a table. No header.
+      # The cell content should be defined in the passed block.
+      def action_col(&block)
+        col('', class: 'action', &block)
+      end
+
+      # Generic action link inside a table.
+      def table_action_link(icon, url, html_options = {})
+        add_css_class(html_options, "icon-#{icon}")
+        link_to('', url, html_options)
+      end
+
+      private
+
+      # If a block is given, call it to get the path for the current row entry.
+      # Otherwise, return the standard path args.
+      def action_path(e, &block)
+        block_given? ? yield(e) : path_args(e)
+      end
+    end
+
+    include Actions
+
+  end
+end