decidim-core 0.27.8 → 0.28.0.rc4

data/lib/decidim/filter_form_builder.rb

@@ -5,93 +5,60 @@ require "decidim/form_builder"
 module Decidim
   # This custom FormBuilder is used to create resource filter forms
   class FilterFormBuilder < FormBuilder
-    # Wrap the radio buttons collection in a custom fieldset.
-    # It also renders the inputs inside its labels.
-    def collection_radio_buttons(method, collection, value_method, label_method, options = {}, html_options = {})
-      fieldset_wrapper(options[:legend_title], "#{method}_collection_radio_buttons_filter") do
-        super(method, collection, value_method, label_method, options, html_options) do |builder|
-          if block_given?
-            yield builder
-          else
-            builder.label { builder.radio_button + builder.text }
-          end
-        end
-      end
-    end
-
-    # Wrap the check_boxes collection in a custom fieldset.
-    # It also renders the inputs inside its labels.
-    def collection_check_boxes(method, collection, value_method, label_method, options = {}, html_options = {})
-      fieldset_wrapper(options[:legend_title], "#{method}_collection_check_boxes_filter") do
-        super(method, collection, value_method, label_method, options, html_options) do |builder|
-          if block_given?
-            yield builder
-          else
-            builder.label { builder.check_box + builder.text }
-          end
-        end
-      end
-    end
+    # This method is used to generate a section of options in a filter block.
+    #
+    # @param method [Symbol] The method associated to the filter object of the form builder.
+    # @param collection [Array, Decidim::CheckBoxesTreeHelper::TreeNode] The collection
+    #        used to display the options. It can be an array of options where each options
+    #        if represented by an array containing a value and a name or a check_boxes_tree
+    #        struct as defined in Decidim::CheckBoxesTreeHelper for more complex situations
+    #        which require nested options.
+    # @param label_scope [String] The scope used to translate the title of the section.
+    # @param id [String] The id of the section. It is also used to get the translation of
+    #        the section title.
+    # @param options [Hash] Additional options. Except :type, the rest of options are passed
+    #        to the partial used to generate the section.
+    # @option options [Symbol, String] :type The type of selector to use with the collection.
+    #         It can be check_boxes, radio_buttons or check_boxes_tree (used by default when
+    #         tree struct is passed. The default selector for arrays is radio_buttons.
+    #
+    # @return [ActionView::OutputBuffer] the HTML of the generated collection filter.
+    def collection_filter(method:, collection:, label_scope:, id:, **options)
+      type = options.delete(:type) || default_form_type_for_collection(collection)
 
-    # Wrap the dependant check_boxes in a custom fieldset.
-    # checked parent checks its children
-    def check_boxes_tree(method, collection, options = {})
-      fieldset_wrapper(options.delete(:legend_title), "#{method}_check_boxes_tree_filter") do
-        @template.render("decidim/shared/check_boxes_tree",
-                         form: self,
-                         attribute: method,
-                         collection: collection,
-                         check_boxes_tree_id: check_boxes_tree_id(method),
-                         hide_node: "false",
-                         options: options).html_safe
+      case type.to_s
+      when "check_boxes", "check_box", "radio_buttons", "radio_button"
+        options.merge!(builder_type: type.to_s.pluralize)
+        type = "collection"
+      when "check_boxes_tree"
+        options.merge!(check_boxes_tree_id: check_boxes_tree_id(method))
       end
-    end
 
-    # Wrap the category select in a custom fieldset.
-    def categories_select(method, collection, options = {}, html_options = {})
-      fieldset_wrapper(options.delete(:legend_title), "#{method}_categories_select_filter") do
-        super(method, collection, options, html_options)
-      end
+      @template.render(
+        "decidim/shared/filters/#{type}",
+        **options.merge(
+          method:,
+          collection:,
+          label_scope:,
+          id:,
+          form: self
+        )
+      )
     end
 
-    # Wrap the areas select in a custom fieldset.
-    def areas_select(method, collection, options = {}, html_options = {})
-      fieldset_wrapper(options[:legend_title], "#{method}_areas_select_filter") do
-        super(method, collection, options, html_options)
-      end
-    end
-
-    # Wrap the custom select in a custom fieldset.
-    # Any *_select can be used as a custom_select; what changes is the superclass method,
-    # and this one knows which one has to be called, depending on the `name` provided.
-    def custom_select(name, method, collection, options = {})
-      fieldset_wrapper(options[:legend_title], "#{method}_#{name}_select_filter") do
-        send(:"#{name}_select", method, collection, options)
-      end
-    end
-
-    # Wrap the scopes picker in a custom fieldset.
-    def scopes_picker(method, options = { checkboxes_on_top: true })
-      fieldset_wrapper(options[:legend_title], "#{method}_scopes_picker_filter") do
-        super(method, options)
-      end
+    def dropdown_label(item, method, options = {})
+      @template.render("decidim/shared/filters/dropdown_label", **options.merge(item:, method:, form: self))
     end
 
     private
 
-    # Private: Renders a custom fieldset and execute the given block.
-    def fieldset_wrapper(legend_title, extra_class)
-      @template.content_tag(:div, "", class: "filters__section #{extra_class}") do
-        @template.content_tag(:fieldset) do
-          @template.content_tag(:legend, class: "mini-title") do
-            legend_title
-          end + yield
-        end
-      end
+    def check_boxes_tree_id(method)
+      method
     end
 
-    def check_boxes_tree_id(attribute)
-      "#{attribute}-#{object_id}"
+    def default_form_type_for_collection(collection)
+      return "radio_buttons" if collection.is_a?(Array)
+      return "check_boxes_tree" if collection.is_a?(Decidim::CheckBoxesTreeHelper::TreeNode)
     end
   end
 end

data/lib/decidim/fingerprintable.rb

@@ -17,7 +17,7 @@ module Decidim
       #
       # fields - An `Array` of `symbols` specifying the fields that will be part of
       #          the fingerprint generation.
-      # block  - (optional) When provided, it's given an instance of the model as a
+      # block  - (optional) When provided, it is given an instance of the model as a
       #          parameter so the fingerprint can be generated in runtime.
       #
       # Returns nothing.

data/lib/decidim/form_builder.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "foundation_rails_helper/form_builder"
-require_relative "../../app/helpers/decidim/sanitize_helper"
 
 module Decidim
   # This custom FormBuilder adds fields needed to deal with translatable fields,
@@ -10,7 +9,6 @@ module Decidim
     include ActionView::Context
     include Decidim::TranslatableAttributes
     include Decidim::Map::Autocomplete::FormBuilder
-    include Decidim::SanitizeHelper
 
     # Public: generates a check boxes input from a collection and adds help
     # text and errors.
@@ -27,7 +25,7 @@ module Decidim
     # Renders a collection of check boxes.
     # rubocop:disable Metrics/ParameterLists
     def collection_check_boxes(attribute, collection, value_attribute, text_attribute, options = {}, html_options = {})
-      super + error_and_help_text(attribute, options)
+      error_and_help_text(attribute, options) + super
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -44,7 +42,7 @@ module Decidim
     # Renders a collection of radio buttons.
     # rubocop:disable Metrics/ParameterLists
     def collection_radio_buttons(attribute, collection, value_attribute, text_attribute, options = {}, html_options = {})
-      super + error_and_help_text(attribute, options)
+      error_and_help_text(attribute, options) + super
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -56,9 +54,9 @@ module Decidim
       end
     end
 
-    # Public: Generates an form field for each locale.
+    # Public: Generates a form field for each locale.
     #
-    # type - The form field's type, like `text_area` or `text_input`
+    # type - The form field's type, like `text_area` or `text_field`
     # name - The name of the field
     # options - The set of options to send to the field
     #
@@ -85,7 +83,7 @@ module Decidim
             if hashtaggable
               hashtaggable_text_field(type, name, locale, options.merge(label: false))
             elsif type.to_sym == :editor
-              send(type, name_with_locale(name, locale), options.merge(label: false, hashtaggable: hashtaggable))
+              send(type, name_with_locale(name, locale), options.merge(label: false, hashtaggable:))
             else
               send(type, name_with_locale(name, locale), options.merge(label: false))
             end
@@ -99,6 +97,7 @@ module Decidim
     def password_field(attribute, options = {})
       field attribute, options do |opts|
         opts[:autocomplete] ||= :off
+        opts[:class] ||= "input-group-field"
         method(__method__).super_method.super_method.call(attribute, opts)
       end
     end
@@ -114,9 +113,9 @@ module Decidim
     end
 
     # Public: Generates a field for hashtaggable type.
-    # type - The form field's type, like `text_area` or `text_input`
+    # type - The form field's type, like `text_area` or `text_field`
     # name - The name of the field
-    # handlers - The social handlers to be created
+    # locale - The locale to be created
     # options - The set of options to send to the field
     #
     # Renders form fields for each locale.
@@ -132,9 +131,9 @@ module Decidim
       end
     end
 
-    # Public: Generates an form field for each social.
+    # Public: Generates a form field for each social.
     #
-    # type - The form field's type, like `text_area` or `text_input`
+    # type - The form field's type, like `text_area` or `text_field`
     # name - The name of the field
     # handlers - The social handlers to be created
     # options - The set of options to send to the field
@@ -182,6 +181,7 @@ module Decidim
     #           :toolbar - The String value to configure WYSIWYG toolbar. It should be 'basic' or
     #                      or 'full' (optional) (default: 'basic')
     #           :lines - The Integer to indicate how many lines should editor have (optional) (default: 10)
+    #           :help_text - The help text to display
     #           :disabled - Whether the editor should be disabled
     #
     # Renders a container with both hidden field and editor container
@@ -192,22 +192,35 @@ module Decidim
       label_text = options[:label].to_s
       label_text = label_for(name) if label_text.blank?
       options.delete(:required)
-      hashtaggable = options.delete(:hashtaggable)
+      help_text = options.delete(:help_text)
+      editor_image = Decidim::EditorImage.new
+      editor_options = editor_options(editor_image, options)
       hidden_options = extract_validations(name, options).merge(options)
-      sanitized_value = sanitize_editor_value(object.send(name))
 
-      content_tag(:div, class: "editor #{"hashtags__container" if hashtaggable}") do
+      @template.append_stylesheet_pack_tag "decidim_editor"
+      @template.append_javascript_pack_tag "decidim_editor", defer: false
+
+      content_tag(
+        :div,
+        class: "editor #{"hashtags__container" if editor_options[:editor]["class"].include?("js-hashtags")}",
+        id: "#{sanitize_for_dom_selector(@object_name)}_#{sanitize_for_dom_selector(name)}"
+      ) do
         template = ""
-        template += label(name, label_text + required_for_attribute(name)) if options.fetch(:label, true)
-        template += hidden_field(name, hidden_options.merge(value: sanitized_value))
-        template += content_tag(:div, nil, class: "editor-container #{"js-hashtags" if hashtaggable}", data: {
-                                  toolbar: toolbar,
-                                  disabled: options[:disabled],
-                                  editor_images: true,
-                                  upload_images_path: Decidim::Core::Engine.routes.url_helpers.editor_images_path,
-                                  drag_and_drop_help_text: I18n.t("drag_and_drop_help", scope: "decidim.editor_images")
-                                }, style: "height: #{lines}rem")
+        template += label(name, label_text + required_for_attribute(name), for: nil) if options.fetch(:label, true)
+        template += hidden_field(name, hidden_options.merge(id: nil))
+        template += content_tag(:span, help_text, class: "help-text") if help_text
+        template += content_tag(
+          :div,
+          nil,
+          class: editor_options[:editor].delete("class").join(" "),
+          data: {
+            toolbar:,
+            disabled: options[:disabled],
+            options: editor_options[:editor]
+          }
+        ) { content_tag(:div, nil, class: "editor-input", style: "height: #{lines}rem") }
         template += error_for(name, options) if error?(name)
+        template += editor_upload(editor_image, editor_options[:upload])
         template.html_safe
       end
     end
@@ -238,14 +251,14 @@ module Decidim
                    []
                  end
 
-      select(name, @template.options_for_select(categories, selected: selected, disabled: disabled), options, html_options)
+      select(name, @template.options_for_select(categories, selected:, disabled:), options, html_options)
     end
 
     # Public: Generates a select field for areas.
     #
     # name       - The name of the field (usually area_id)
     # collection - A collection of areas or area_types.
-    #              If it's areas, we sort the selectable options alphabetically.
+    #              If it is areas, we sort the selectable options alphabetically.
     #
     # Returns a String.
     def areas_select(name, collection, options = {}, html_options = {})
@@ -308,7 +321,7 @@ module Decidim
            end
 
       picker_options = {
-        id: id,
+        id:,
         class: "picker-#{options[:multiple] ? "multiple" : "single"}",
         name: "#{@object_name}[#{attribute}]"
       }
@@ -320,10 +333,9 @@ module Decidim
       template = ""
       template += "<label>#{label_for(attribute) + required_for_attribute(attribute)}</label>" unless options[:label] == false
       template += @template.render("decidim/scopes/scopes_picker_input",
-                                   values_options: { delete_button: true, class: "label primary" },
-                                   picker_options: picker_options,
-                                   prompt_params: prompt_params,
-                                   scopes: scopes,
+                                   picker_options:,
+                                   prompt_params:,
+                                   scopes:,
                                    values_on_top: !options[:multiple] || options[:checkboxes_on_top])
       template += error_and_help_text(attribute, options)
       template.html_safe
@@ -356,8 +368,8 @@ module Decidim
 
       template = ""
       template += label(attribute, label_for(attribute) + required_for_attribute(attribute)) unless options[:label] == false
-      template += @template.render("decidim/widgets/data_picker", picker_options: picker_options, prompt_params: prompt_params, items: items)
       template += error_and_help_text(attribute, options)
+      template += @template.render("decidim/widgets/data_picker", picker_options:, prompt_params:, items:)
       template.html_safe
     end
 
@@ -366,53 +378,10 @@ module Decidim
       custom_label(attribute, options[:label], options[:label_options], field_before_label: true) do
         options.delete(:label)
         options.delete(:label_options)
-        @template.check_box(@object_name, attribute, objectify_options(options), checked_value, unchecked_value)
+        @template.check_box(@object_name, attribute, objectify_options(options.except(:help_text)), checked_value, unchecked_value)
       end + error_and_help_text(attribute, options)
     end
 
-    # Public: Override so the date fields are rendered using foundation
-    # datepicker library
-    def date_field(attribute, options = {})
-      value = object.send(attribute)
-      data = { datepicker: "" }
-      data[:startdate] = I18n.l(value, format: :decidim_short) if value.present? && value.is_a?(Date)
-      datepicker_format = ruby_format_to_datepicker(I18n.t("date.formats.decidim_short"))
-      data[:"date-format"] = datepicker_format
-
-      template = text_field(
-        attribute,
-        options.merge(data: data)
-      )
-      help_text = I18n.t("decidim.datepicker.help_text", datepicker_format: datepicker_format)
-      template += error_and_help_text(attribute, options.merge(help_text: help_text))
-      template.html_safe
-    end
-
-    # Public: Generates a timepicker field using foundation
-    # datepicker library
-    def datetime_field(attribute, options = {})
-      value = object.send(attribute)
-      data = { datepicker: "", timepicker: "" }
-      if value.present?
-        case value
-        when ActiveSupport::TimeWithZone
-          data[:startdate] = I18n.l(value, format: :decidim_short)
-        when Time, DateTime
-          data[:startdate] = I18n.l(value.in_time_zone(Time.zone), format: :decidim_short)
-        end
-      end
-      datepicker_format = ruby_format_to_datepicker(I18n.t("time.formats.decidim_short"))
-      data[:"date-format"] = datepicker_format
-
-      template = text_field(
-        attribute,
-        options.merge(data: data)
-      )
-      help_text = I18n.t("decidim.datepicker.help_text", datepicker_format: datepicker_format)
-      template += content_tag(:span, help_text, class: "help-text")
-      template.html_safe
-    end
-
     # Public: Generates a file upload field for Decidim::Attachment type of attachment.
     # It is similar to upload method, but it changes some options so that attachment can
     # have title and different upload validations.
@@ -424,7 +393,7 @@ module Decidim
       object_attachment = object.attachment.present?
       record = object_attachment ? object.attachment : object
       options = {
-        titled: true,
+        titled: options[:multiple],
         resource_class: "Decidim::Attachment",
         show_current: false,
         max_file_size: max_file_size(record, :file),
@@ -467,16 +436,16 @@ module Decidim
       help_messages = options[:help] || upload_help(object, attribute, options)
 
       options = {
-        attribute: attribute,
+        attribute:,
         resource_name: @object_name,
         resource_class: options[:resource_class]&.to_s || resource_class(attribute),
         required: false,
         titled: false,
         show_current: true,
-        max_file_size: max_file_size,
+        max_file_size:,
         help: help_messages,
         label: label_for(attribute),
-        button_label: button_label,
+        button_label:,
         button_edit_label: I18n.t("decidim.forms.upload.labels.replace")
       }.merge(options)
 
@@ -569,11 +538,11 @@ module Decidim
     # html_options - An optional Hash with options to pass to the html element.
     #
     # Returns a String
-    def field(attribute, options, html_options = nil, &block)
+    def field(attribute, options, html_options = nil, &)
       label = options.delete(:label)
       label_options = options.delete(:label_options) || {}
       custom_label(attribute, label, { required: options[:required] }.merge(label_options)) do
-        field_with_validations(attribute, options, html_options, &block)
+        field_with_validations(attribute, options, html_options, &)
       end
     end
 
@@ -603,8 +572,8 @@ module Decidim
       content += abide_error_element(attribute) if class_options[:pattern] || class_options[:required]
       content = content.html_safe
 
-      html = wrap_prefix_and_postfix(content, prefix, postfix)
-      html + error_and_help_text(attribute, options.merge(help_text: help_text))
+      html = error_and_help_text(attribute, options.merge(help_text:))
+      html + wrap_prefix_and_postfix(content, prefix, postfix)
     end
 
     # rubocop: disable Metrics/CyclomaticComplexity
@@ -693,7 +662,7 @@ module Decidim
     # Private: Override method from FoundationRailsHelper to render the text of the
     # label before the input, instead of after.
     #
-    # attribute - The String name of the attribute we're build the label.
+    # attribute - The String name of the attribute we are build the label.
     # text      - The String text to use as label.
     # options   - A Hash to build the label.
     #
@@ -727,7 +696,7 @@ module Decidim
     # rubocop:enable Metrics/PerceivedComplexity
     # rubocop:enable Metrics/CyclomaticComplexity
 
-    # Private: Builds a span to be shown when there's a validation error in a field.
+    # Private: Builds a span to be shown when there is a validation error in a field.
     # It looks for the text that will be the content in a similar way `human_attribute_name`
     # does it.
     #
@@ -817,7 +786,7 @@ module Decidim
       screenreader_title = content_tag(
         :span,
         I18n.t("required", scope: "forms"),
-        class: "show-for-sr"
+        class: "sr-only"
       )
       content_tag(
         :span,
@@ -863,18 +832,31 @@ module Decidim
     end
 
     def image_dimensions_help(dimensions_info)
-      dimensions_info.map do |_version, info|
+      sorted_info = dimensions_info.values.sort do |infoa, infob|
+        texta, textb = [infoa[:processor], infob[:processor]].map do |processor|
+          I18n.t("processors.#{processor}", scope: "decidim.forms.images", dimensions: "")
+        end
+        widtha, heighta = infoa[:dimensions]
+        widthb, heightb = infob[:dimensions]
+
+        [
+          texta <=> textb,
+          widtha <=> widthb,
+          heighta <=> heightb
+        ].find { |cmp| !cmp.zero? } || 0
+      end
+      sorted_info.map do |info|
         dimensions = I18n.t("dimensions", scope: "decidim.forms.images", width: info[:dimensions].first, height: info[:dimensions].last)
         I18n.t(
           "processors.#{info[:processor]}",
           scope: "decidim.forms.images",
-          dimensions: dimensions
+          dimensions:
         ).html_safe
       end
     end
 
     # Private: Creates a tag from the given options for the field prefix and
-    # suffix. Overridden from Foundation Rails helper to make the generated HTML
+    # suffix. Overridden from FoundationRailsHelper to make the generated HTML
     # valid since these elements are printed within <label> elements and <div>'s
     # are not allowed there.
     def tag_from_options(name, options)
@@ -886,7 +868,7 @@ module Decidim
     end
 
     # Private: Wraps the prefix and postfix for the field. Overridden from
-    # Foundation Rails helper to make the generated HTML valid since these
+    # FoundationRailsHelper to make the generated HTML valid since these
     # elements are printed within <label> elements and <div>'s are not allowed
     # there.
     def wrap_prefix_and_postfix(block, prefix_options, postfix_options)
@@ -945,13 +927,63 @@ module Decidim
       object.class
     end
 
-    # Private: Sanitize editor values to prevent malformed values being display in the
-    # WYSIWYG editor
-    #
-    def sanitize_editor_value(value)
-      sanitized_value = decidim_sanitize_editor_admin(value)
+    # Private: creates the options to pass to the view editor and its attached
+    # upload modal.
+    def editor_options(editor_image, options)
+      upload_options = options.delete(:image_upload) || {}
+      upload_options[:modal_id] ||= "upload_#{SecureRandom.uuid}"
+
+      hashtaggable = options.delete(:hashtaggable)
+      mentionable = options.delete(:mentionable)
+      emojiable = options.delete(:emojiable)
+
+      editor_classes = ["editor-container"]
+      editor_classes << "js-hashtags" if hashtaggable
+      editor_classes << "js-mentions" if mentionable
+      editor_classes << "js-emojis" if emojiable
+
+      editor_options = {
+        class: editor_classes,
+        context: options.delete(:context) || "admin",
+        content_types: {
+          image: editor_image.attached_uploader(:file).content_type_allowlist
+        },
+        upload_images_path: Decidim::Core::Engine.routes.url_helpers.editor_images_path,
+        drag_and_drop_help_text: I18n.t("drag_and_drop_help", scope: "decidim.editor_images"),
+        upload_dialog_selector: "##{upload_options[:modal_id]}"
+      }.transform_keys { |key| key.to_s.camelize(:lower) }
+
+      { editor: editor_options, upload: upload_options }
+    end
+
+    # Private: creates an upload modal for the editor that we use to dynamically
+    # upload the images to the editor.
+    def editor_upload(editor_image, options = {})
+      upload_options = {
+        titled: true,
+        modal_only: true,
+        resource_class: "Decidim::EditorImage",
+        show_current: false,
+        max_file_size: max_file_size(editor_image, :file),
+        label: I18n.t("decidim.forms.upload.labels.add_image"),
+        button_edit_label: I18n.t("decidim.forms.upload.labels.edit_image")
+      }.merge(options || {})
+
+      if upload_options[:help].blank?
+        # Upload help uses extension allowlist from the options so we need to call this AFTER setting the defaults.
+        upload_options[:help] = upload_help(
+          editor_image,
+          :file,
+          help_i18n_scope: "decidim.forms.file_help.image"
+        )
+      end
+
+      field = nil
+      @template.form_for(editor_image, url: "") do |form|
+        field = capture { form.upload(:file, upload_options) }
+      end
 
-      sanitized_value == %(<div class="ql-editor-display"></div>) ? "" : sanitized_value
+      field
     end
   end
 end

data/lib/decidim/gamification/badge.rb

@@ -23,7 +23,7 @@ module Decidim
       # badge if the progress gets lost somehow. The lambda receives a user as an
       # argument.
       #
-      # It might not be possible sometimes, so it's fine to leave it empty.
+      # It might not be possible sometimes, so it is fine to leave it empty.
       attribute :reset, Proc
 
       validates :name, :levels, presence: true
@@ -50,7 +50,7 @@ module Decidim
       end
 
       def description(organization_name = nil)
-        I18n.t("description", organization_name: organization_name, scope: translation_scope)
+        I18n.t("description", organization_name:, scope: translation_scope)
       end
 
       def conditions
@@ -60,9 +60,9 @@ module Decidim
       def score_descriptions(score)
         {
           unearned_own: I18n.t("unearned_own", scope: translation_scope),
-          description_own: I18n.t("description_own", score: score, scope: translation_scope),
+          description_own: I18n.t("description_own", score:, scope: translation_scope),
           unearned_another: I18n.t("unearned_another", scope: translation_scope),
-          description_another: I18n.t("description_another", score: score, scope: translation_scope)
+          description_another: I18n.t("description_another", score:, scope: translation_scope)
         }
       end
 

data/lib/decidim/gamification/badge_earned_event.rb

@@ -1,4 +1,4 @@
-# frozen-string_literal: true
+# frozen_string_literal: true
 
 module Decidim
   module Gamification

data/lib/decidim/gamification/badge_registry.rb

@@ -38,11 +38,11 @@ module Decidim
       #
       # Returns a Badge when registered successfully, raises an exception
       # otherwise.
-      def register(name, &block)
+      def register(name, &)
         name = name.to_s
 
-        badge = Badge.new(name: name).tap do |object|
-          object.instance_eval(&block)
+        badge = Badge.new(name:).tap do |object|
+          object.instance_eval(&)
         end
 
         badge.validate!

data/lib/decidim/gamification/badge_scorer.rb

@@ -94,13 +94,13 @@ module Decidim
         if previous_level.zero?
           publish_event(name: "decidim.events.gamification.badge_earned",
                         klass: BadgeEarnedEvent,
-                        previous_level: previous_level,
-                        current_level: current_level)
+                        previous_level:,
+                        current_level:)
         else
           publish_event(name: "decidim.events.gamification.level_up",
                         klass: LevelUpEvent,
-                        previous_level: previous_level,
-                        current_level: current_level)
+                        previous_level:,
+                        current_level:)
         end
       end
 
@@ -112,8 +112,8 @@ module Decidim
           affected_users: recipients,
           extra: {
             badge_name: @badge.name.to_s,
-            previous_level: previous_level,
-            current_level: current_level
+            previous_level:,
+            current_level:
           }
         )
       end