dry_crud 6.0.0 → 8.0.0

data/app/controllers/list_controller.rb

@@ -7,7 +7,6 @@
 # Furthermore, it remembers the last search and sort parameters after the
 # user returns from a displayed or edited entry.
 class ListController < ApplicationController
-
   include DryCrud::GenericModel
   prepend DryCrud::Nestable
   include DryCrud::RenderCallbacks
@@ -32,7 +31,7 @@ class ListController < ApplicationController
   # Helper method to access the entries to be displayed in the current index
   # page in an uniform way.
   def entries
-    model_ivar_get(true) || model_ivar_set(list_entries)
+    model_ivar_get(plural: true) || model_ivar_set(list_entries)
   end
 
   # The base relation used to filter the entries.
@@ -48,5 +47,4 @@ class ListController < ApplicationController
   # Include these modules after the #list_entries method is defined.
   include DryCrud::Searchable
   include DryCrud::Sortable
-
 end

data/app/helpers/actions_helper.rb

@@ -3,19 +3,18 @@
 # 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 btn-light'
+    add_css_class html_options, "action btn btn-light"
     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(:span, '', class: "icon icon-#{icon}")
-    html << ' ' << label if label
+    html = tag.i("", class: "bi-#{icon}")
+    html << " " << label if label
     html
   end
 
@@ -23,40 +22,39 @@ module ActionsHelper
   # 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)
+    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)
+    path = edit_polymorphic_path(path) unless path.is_a?(String)
+    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 })
+    action_link(ti("link.delete"), "trash", path,
+                data: { 'turbo-confirm': ti(:confirm_delete),
+                        'turbo-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)
+    path = polymorphic_path(path, url_options) unless path.is_a?(String)
+    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)
+    path = new_polymorphic_path(path, url_options) unless path.is_a?(String)
+    action_link(ti("link.add"), "plus", path)
   end
-
 end

data/app/helpers/dry_crud/form/builder.rb

@@ -1,6 +1,5 @@
 module DryCrud
   module Form
-
     # 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.
@@ -14,14 +13,13 @@ module DryCrud
     # See the Control class for how to customize the html rendered for a
     # single input field.
     class Builder < ActionView::Helpers::FormBuilder
-
       class_attribute :control_class
       self.control_class = Control
 
       attr_reader :template
 
       delegate :association, :column_type, :column_property, :captionize,
-               :ti, :ta, :link_to, :content_tag, :safe_join, :capture,
+               :ti, :ta, :link_to, :tag, :safe_join, :capture,
                :add_css_class, :assoc_and_id_attr,
                to: :template
 
@@ -29,9 +27,8 @@ module DryCrud
 
       # Render multiple input controls 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.dup) }
+      def labeled_input_fields(*attrs, **options)
+        safe_join(attrs) { |a| labeled_input_field(a, **options.dup) }
       end
 
       # Render a corresponding input control and label for the given attribute.
@@ -45,8 +42,8 @@ module DryCrud
       # * <tt>:field_method</tt> - Different method to create the input field.
       #
       # Use additional html_options for the input element.
-      def labeled_input_field(attr, html_options = {})
-        control_class.new(self, attr, html_options).render_labeled
+      def labeled_input_field(attr, **html_options)
+        control_class.new(self, attr, **html_options).render_labeled
       end
 
       # Render a corresponding input control for the given attribute.
@@ -59,22 +56,22 @@ module DryCrud
       # * <tt>:field_method</tt> - Different method to create the input field.
       #
       # Use additional html_options for the input element.
-      def input_field(attr, html_options = {})
-        control_class.new(self, attr, html_options).render_content
+      def input_field(attr, **html_options)
+        control_class.new(self, attr, **html_options).render_content
       end
 
       # Render a standard string field with column contraints.
-      def string_field(attr, html_options = {})
+      def string_field(attr, **html_options)
         html_options[:maxlength] ||= column_property(@object, attr, :limit)
-        text_field(attr, html_options)
+        text_field(attr, **html_options)
       end
 
       # Render a boolean field.
-      def boolean_field(attr, html_options = {})
-        content_tag(:div, class: 'checkbox') do
-          content_tag(:label) do
-            detail = html_options.delete(:detail) || '&nbsp;'.html_safe
-            safe_join([check_box(attr, html_options), ' ', detail])
+      def boolean_field(attr, **html_options)
+        tag.div(class: "checkbox") do
+          tag.label do
+            detail = html_options.delete(:detail) || "&nbsp;".html_safe
+            safe_join([ check_box(attr, html_options), " ", detail ])
           end
         end
       end
@@ -82,33 +79,33 @@ module DryCrud
       # Add form-control class to all input fields.
       %w[text_field password_field email_field
          number_field date_field time_field datetime_field].each do |method|
-        define_method(method) do |attr, html_options = {}|
-          add_css_class(html_options, 'form-control')
+        define_method(method) do |attr, **html_options|
+          add_css_class(html_options, "form-control")
           super(attr, html_options)
         end
       end
 
-      def integer_field(attr, html_options = {})
+      def integer_field(attr, **html_options)
         html_options[:step] ||= 1
-        number_field(attr, html_options)
+        number_field(attr, **html_options)
       end
 
-      def float_field(attr, html_options = {})
-        html_options[:step] ||= 'any'
-        number_field(attr, html_options)
+      def float_field(attr, **html_options)
+        html_options[:step] ||= "any"
+        number_field(attr, **html_options)
       end
 
-      def decimal_field(attr, html_options = {})
+      def decimal_field(attr, **html_options)
         html_options[:step] ||=
           (10**-column_property(object, attr, :scale)).to_f
-        number_field(attr, html_options)
+        number_field(attr, **html_options)
       end
 
       # Customize the standard text area to have 5 rows by default.
-      def text_area(attr, html_options = {})
-        add_css_class(html_options, 'form-control')
+      def text_area(attr, **html_options)
+        add_css_class(html_options, "form-control")
         html_options[:rows] ||= 5
-        super(attr, html_options)
+        super
       end
 
       # Render a select element for a :belongs_to association defined by attr.
@@ -116,13 +113,13 @@ module DryCrud
       # 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
+      def belongs_to_field(attr, **html_options)
+        list = association_entries(attr, **html_options).to_a
         if list.present?
-          add_css_class(html_options, 'form-control')
+          add_css_class(html_options, "form-control")
           collection_select(attr, list, :id, :to_s,
-                            select_options(attr, html_options),
-                            html_options)
+                            select_options(attr, **html_options),
+                            **html_options)
         else
           # rubocop:disable Rails/OutputSafety
           none = ta(:none_available, association(@object, attr)).html_safe
@@ -131,7 +128,7 @@ module DryCrud
         end
       end
 
-      # rubocop:disable PredicateName
+      # rubocop:disable Naming/PredicateName
 
       # Render a multi select element for a :has_many or
       # :has_and_belongs_to_many association defined by attr.
@@ -139,63 +136,62 @@ module DryCrud
       # 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 = {})
+      def has_many_field(attr, **html_options)
         html_options[:multiple] = true
-        add_css_class(html_options, 'multiselect')
-        belongs_to_field(attr, html_options)
+        add_css_class(html_options, "multiselect")
+        belongs_to_field(attr, **html_options)
       end
-      # rubocop:enable PredicateName
+      # rubocop:enable Naming/PredicateName
 
       ### VARIOUS FORM ELEMENTS
 
       # Render the error messages for the current form.
       def error_messages
-        @template.render('shared/error_messages',
+        @template.render("shared/error_messages",
                          errors: @object.errors,
                          object: @object)
       end
 
       # Renders the given content with an addon.
       def with_addon(content, addon)
-        content_tag(:div, class: 'input-group') do
-          html = content_tag(:span, addon, class: 'input-group-text')
-          content + content_tag(:div, html, class: 'input-group-append')
+        tag.div(class: "input-group") do
+          content + tag.span(addon, class: "input-group-text")
         end
       end
 
       # Renders a static text where otherwise form inputs appear.
       def static_text(text)
-        content_tag(:p, text, class: 'form-control-static')
+        tag.p(text, class: "form-control-static")
       end
 
       # Generates a help block for fields
       def help_block(text)
-        content_tag(:p, text, class: 'help-block')
+        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: 'col-md-offset-2 col-md-8') do
-          safe_join([submit_button(submit_label),
-                     cancel_link(cancel_url)],
-                    ' ')
+      def standard_actions(submit_label = ti("button.save"), cancel_url = nil)
+        tag.div(class: "col-md-offset-2 col-md-8") 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 })
+      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')
+        link_to(ti("button.cancel"), url, class: "cancel")
       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 = {})
+      def select_options(attr, **options)
         prompt = options.delete(:prompt)
         blank = options.delete(:include_blank)
         if options[:multiple]
@@ -239,7 +235,7 @@ module DryCrud
           options = content
           content = capture(&block)
         end
-        control = control_class.new(self, attr, options)
+        control = control_class.new(self, attr, **options)
         control.render_labeled(content)
       end
 
@@ -267,19 +263,18 @@ module DryCrud
       # Checks if the passed name corresponds to a field method with a
       # 'labeled_' prefix.
       def labeled_field_method?(name)
-        prefix = 'labeled_'
+        prefix = "labeled_"
         if name.to_s.start_with?(prefix)
-          field_method = name.to_s[prefix.size..-1]
+          field_method = name.to_s[prefix.size..]
           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)
-        options = args.extract_options!
+      def build_labeled_field(field_method, *args, **options)
         options[:field_method] = field_method
-        control_class.new(self, *(args << options)).render_labeled
+        control_class.new(self, *args, **options).render_labeled
       end
 
       # Returns the list of association entries, either from options[:list] or
@@ -287,7 +282,7 @@ module DryCrud
       # Otherwise, if the association defines a #options_list or #list scope,
       # this is used to load the entries.
       # As a last resort, all entries from the association class are returned.
-      def association_entries(attr, options)
+      def association_entries(attr, **options)
         list = options.delete(:list)
         unless list
           assoc = association(@object, attr)
@@ -324,7 +319,6 @@ module DryCrud
           options[:cancel_url_edit] || options[:cancel_url]
         end
       end
-
     end
   end
 end

data/app/helpers/dry_crud/form/control.rb

@@ -1,18 +1,16 @@
 module DryCrud
   module Form
-
     # Internal class to handle the rendering of a single form control,
     # consisting of a label, input field, addon, help text or
     # required mark.
     class Control
-
       attr_reader :builder, :attr, :args, :options, :addon, :help
 
-      delegate :content_tag, :object,
+      delegate :tag, :object, :add_css_class,
                to: :builder
 
       # Html displayed to mark an input as required.
-      REQUIRED_MARK = '*'.freeze
+      REQUIRED_MARK = "*".freeze
 
       # Number of default input field span columns depending
       # on the #field_method.
@@ -39,10 +37,10 @@ module DryCrud
       #   (The value for this option usually is 'required').
       #
       # All the other options will go to the field_method.
-      def initialize(builder, attr, *args)
+      def initialize(builder, attr, *args, **options)
         @builder = builder
         @attr = attr
-        @options = args.extract_options!
+        @options = options
         @args = args
 
         @addon = options.delete(:addon)
@@ -70,11 +68,9 @@ module DryCrud
 
       # Create the HTML markup for any labeled content.
       def labeled
-        errors = errors? ? ' has-error' : ''
-
-        content_tag(:div, class: "form-group#{errors}") do
-          builder.label(attr, caption, class: 'col-md-2 control-label') +
-            content_tag(:div, content, class: "col-md-#{span}")
+        tag.div(class: "row mb-3") do
+          builder.label(attr, caption, class: "col-md-2 col-form-label") +
+            tag.div(content, class: "col-md-#{span}")
         end
       end
 
@@ -100,8 +96,9 @@ module DryCrud
       # depending on the attribute.
       def input
         @input ||= begin
-          options[:required] = 'required' if required
-          builder.send(field_method, attr, *(args << options))
+          options[:required] = "required" if required
+          add_css_class(options, "is-invalid") if errors?
+          builder.send(field_method, attr, *args, **options)
         end
       end
 
@@ -137,7 +134,6 @@ module DryCrud
 
       # Defines the field method to use based on the attribute
       # type, association or name.
-      # rubocop:disable PerceivedComplexity
       def detect_field_method
         if type == :text
           :text_area
@@ -145,9 +141,9 @@ module DryCrud
           :belongs_to_field
         elsif association_kind?(:has_and_belongs_to_many, :has_many)
           :has_many_field
-        elsif attr.to_s.include?('password')
+        elsif attr.to_s.include?("password")
           :password_field
-        elsif attr.to_s.include?('email')
+        elsif attr.to_s.include?("email")
           :email_field
         elsif builder.respond_to?(:"#{type}_field")
           :"#{type}_field"
@@ -155,7 +151,6 @@ module DryCrud
           :text_field
         end
       end
-      # rubocop:enable PerceivedComplexity
 
       # The column type of the attribute.
       def type
@@ -173,8 +168,6 @@ module DryCrud
           false
         end
       end
-
     end
-
   end
 end

data/app/helpers/dry_crud/table/actions.rb

@@ -1,12 +1,10 @@
 module DryCrud
   module Table
-
     # 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
@@ -26,13 +24,13 @@ module DryCrud
       # 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)
+      def show_action_col(**html_options, &block)
         action_col do |entry|
           path = action_path(entry, &block)
           if path
-            table_action_link('zoom-in',
+            table_action_link("zoom-in",
                               path,
-                              html_options.clone)
+                              **html_options.clone)
           end
         end
       end
@@ -40,12 +38,12 @@ module DryCrud
       # 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)
+      def edit_action_col(**html_options, &block)
         action_col do |entry|
           path = action_path(entry, &block)
           if path
-            path = path.is_a?(String) ? path : edit_polymorphic_path(path)
-            table_action_link('pencil', path, html_options.clone)
+            path = edit_polymorphic_path(path) unless path.is_a?(String)
+            table_action_link("pencil", path, **html_options.clone)
           end
         end
       end
@@ -53,16 +51,15 @@ module DryCrud
       # 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)
+      def destroy_action_col(**html_options, &block)
         action_col do |entry|
           path = action_path(entry, &block)
           if path
-            table_action_link('remove',
+            table_action_link("trash",
                               path,
-                              html_options.merge(
-                                data: { confirm: ti(:confirm_delete),
-                                        method: :delete }
-                              ))
+                              **html_options,
+                              data: { 'turbo-confirm': ti(:confirm_delete),
+                                      'turbo-method': :delete })
           end
         end
       end
@@ -70,13 +67,13 @@ module DryCrud
       # 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)
+        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-#{icon}")
-        link_to('', url, html_options)
+      def table_action_link(icon, url, **html_options)
+        add_css_class(html_options, "bi-#{icon}")
+        link_to("", url, html_options)
       end
 
       private
@@ -86,8 +83,6 @@ module DryCrud
       def action_path(entry)
         block_given? ? yield(entry) : path_args(entry)
       end
-
     end
-
   end
 end

data/app/helpers/dry_crud/table/builder.rb

@@ -1,6 +1,5 @@
 module DryCrud
   module Table
-
     # A simple helper to easily define tables listing several rows of the same
     # data type.
     #
@@ -10,17 +9,16 @@ module DryCrud
     #     t.attrs :name, :city
     #   end
     class Builder
-
       include Sorting
       include Actions
 
       attr_reader :entries, :cols, :options, :template
 
-      delegate :content_tag, :format_attr, :column_type, :association, :dom_id,
+      delegate :tag, :format_attr, :column_type, :association, :dom_id,
                :captionize, :add_css_class, :content_tag_nested,
                to: :template
 
-      def initialize(entries, template, options = {})
+      def initialize(entries, template, **options)
         @entries = entries
         @template = template
         @options = options
@@ -30,8 +28,8 @@ module DryCrud
       # 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)
+      def self.table(entries, template, **options)
+        t = new(entries, template, **options)
         yield t
         t.to_html
       end
@@ -39,7 +37,7 @@ module DryCrud
       # 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)
+      def col(header = "", **html_options, &block)
         @cols << Col.new(header, html_options, @template, block)
       end
 
@@ -55,17 +53,17 @@ module DryCrud
       # 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(attr, header = nil, html_options = {}, &block)
+      def attr(attr, header = nil, **html_options, &block)
         header ||= attr_header(attr)
         block ||= ->(e) { format_attr(e, attr) }
         add_css_class(html_options, align_class(attr))
-        col(header, html_options, &block)
+        col(header, **html_options, &block)
       end
 
       # Renders the table as HTML.
       def to_html
-        content_tag :table, options do
-          content_tag(:thead, html_header) +
+        tag.table(**options) do
+          tag.thead(html_header) +
             content_tag_nested(:tbody, entries) { |e| html_row(e) }
         end
       end
@@ -76,9 +74,9 @@ module DryCrud
         entry = entries.present? ? entry_class.new : nil
         case column_type(entry, attr)
         when :integer, :float, :decimal
-          'right' unless association(entry, attr, :belongs_to)
+          "right" unless association(entry, attr, :belongs_to)
         when :boolean
-          'center'
+          "center"
         end
       end
 
@@ -98,7 +96,7 @@ module DryCrud
       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) }
+        content_tag_nested(:tr, cols, **attrs) { |c| c.html_cell(entry) }
       end
 
       # Determines the class of the table entries.
@@ -110,7 +108,6 @@ module DryCrud
           entries.first.class
         end
       end
-
     end
   end
 end