Change to kwargs syntax

Author: codez

app/controllers/crud_controller.rb

@@ -52,12 +52,12 @@ def new
   # in the given block will take precedence over the one defined here.
   #
   # Specify a :location option if you wish to do a custom redirect.
-  def create(options = {}, &block)
+  def create(**options, &block)
     model_class.transaction do
       assign_attributes
       created = with_callbacks(:create, :save) { entry.save }
       respond(created,
-              options.merge(status: :created, render_on_failure: :new),
+              **options.merge(status: :created, render_on_failure: :new),
               &block)
       raise ActiveRecord::Rollback unless created
     end
@@ -80,12 +80,12 @@ def edit; end
   # in the given block will take precedence over the one defined here.
   #
   # Specify a :location option if you wish to do a custom redirect.
-  def update(options = {}, &block)
+  def update(**options, &block)
     model_class.transaction do
       assign_attributes
       updated = with_callbacks(:update, :save) { entry.save }
       respond(updated,
-              options.merge(status: :ok, render_on_failure: :edit),
+              **options.merge(status: :ok, render_on_failure: :edit),
               &block)
       raise ActiveRecord::Rollback unless updated
     end
@@ -103,11 +103,11 @@ def update(options = {}, &block)
   # in the given block will take precedence over the one defined here.
   #
   # Specify a :location option if you wish to do a custom redirect.
-  def destroy(options = {}, &block)
+  def destroy(**options, &block)
     model_class.transaction do
       destroyed = run_callbacks(:destroy) { entry.destroy }
       respond(destroyed,
-              options.merge(status: :no_content),
+              **options.merge(status: :no_content),
               &block)
       raise ActiveRecord::Rollback unless destroyed
     end
@@ -152,39 +152,39 @@ def show_path
     path_args(entry)
   end
 
-  def respond(success, options)
+  def respond(success, **options)
     respond_to do |format|
       yield(format, success) if block_given?
       if success
-        format.html { redirect_on_success(options) }
+        format.html { redirect_on_success(**options) }
         format.json { render_success_json(options[:status]) }
       else
-        format.html { render_or_redirect_on_failure(options) }
+        format.html { render_or_redirect_on_failure(**options) }
         format.json { render_failure_json }
       end
     end
   end
 
   # If the option :render_on_failure is given, render the corresponding
   # template, otherwise redirect.
-  def render_or_redirect_on_failure(options)
+  def render_or_redirect_on_failure(**options)
     if options[:render_on_failure]
       render options[:render_on_failure]
     else
-      redirect_on_failure(options)
+      redirect_on_failure(**options)
     end
   end
 
   # Perform a redirect after a successfull operation and set a flash notice.
-  def redirect_on_success(options = {})
+  def redirect_on_success(**options)
     location = options[:location] ||
                (entry.destroyed? ? index_path : show_path)
     flash[:notice] ||= flash_message(:success)
     redirect_to location
   end
 
   # Perform a redirect after a failed operation and set a flash alert.
-  def redirect_on_failure(options = {})
+  def redirect_on_failure(**options)
     location = options[:location] ||
                request.env['HTTP_REFERER'].presence ||
                index_path

app/helpers/dry_crud/form/builder.rb

@@ -29,9 +29,8 @@ class Builder < ActionView::Helpers::FormBuilder
 
       # 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 +44,8 @@ def labeled_input_fields(*attrs)
       # * <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,18 +58,18 @@ def labeled_input_field(attr, html_options = {})
       # * <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 = {})
+      def boolean_field(attr, **html_options)
         tag.div(class: 'checkbox') do
           tag.label do
             detail = html_options.delete(:detail) || '&nbsp;'.html_safe
@@ -82,47 +81,47 @@ def boolean_field(attr, html_options = {})
       # 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 = {}|
+        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 = {})
+      def float_field(attr, **html_options)
         html_options[:step] ||= 'any'
-        number_field(attr, html_options)
+        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 = {})
+      def text_area(attr, **html_options)
         add_css_class(html_options, 'form-control')
         html_options[:rows] ||= 5
-        super(attr, html_options)
+        super(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
+      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')
           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
@@ -139,10 +138,10 @@ def belongs_to_field(attr, html_options = {})
       # 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)
+        belongs_to_field(attr, **html_options)
       end
       # rubocop:enable Naming/PredicateName
 
@@ -194,7 +193,7 @@ def cancel_link(url = nil)
 
       # 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]
@@ -238,7 +237,7 @@ def labeled(attr, content = {}, options = {}, &block)
           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
 
@@ -275,18 +274,17 @@ def labeled_field_method?(name)
 
       # 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
       # the instance variable with the pluralized association name.
       # 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)

app/helpers/dry_crud/form/control.rb

@@ -39,10 +39,10 @@ class Control
       #   (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)
@@ -100,7 +100,7 @@ def input
         @input ||= begin
           options[:required] = 'required' if required
           add_css_class(options, 'is-invalid') if errors?
-          builder.send(field_method, attr, *(args << options))
+          builder.send(field_method, attr, *args, **options)
         end
       end
 

app/helpers/dry_crud/table/actions.rb

@@ -26,40 +26,40 @@ def attr_with_show_link(attr, &block)
       # 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',
                               path,
-                              html_options.clone)
+                              **html_options.clone)
           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)
+      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)
+            table_action_link('pencil', path, **html_options.clone)
           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)
+      def destroy_action_col(**html_options, &block)
         action_col do |entry|
           path = action_path(entry, &block)
           if path
             table_action_link('remove',
                               path,
-                              html_options.merge(
+                              **html_options.merge(
                                 data: { confirm: ti(:confirm_delete),
                                         method: :delete }
                               ))
@@ -74,8 +74,8 @@ def action_col(&block)
       end
 
       # Generic action link inside a table.
-      def table_action_link(icon, url, html_options = {})
-        add_css_class(html_options, "icon icon-#{icon}")
+      def table_action_link(icon, url, **html_options)
+        add_css_class(html_options, "bi-#{icon}")
         link_to('', url, html_options)
       end
 

app/helpers/dry_crud/table/builder.rb

@@ -20,7 +20,7 @@ class Builder
                :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,16 +30,16 @@ def initialize(entries, template, options = {})
       # 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
 
       # 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,11 +55,11 @@ def attrs(*attrs)
       # 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.
@@ -98,7 +98,7 @@ def html_header
       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.