decidim-decidim_awesome 0.8.0 → 0.12.0

data/app/forms/decidim/decidim_awesome/admin/config_form.rb

@@ -7,63 +7,107 @@ module Decidim
     module Admin
       class ConfigForm < Decidim::Form
         include ActionView::Helpers::SanitizeHelper
+        include TranslatableAttributes
 
-        attribute :allow_images_in_full_editor, Boolean
-        attribute :allow_images_in_small_editor, Boolean
+        attribute :allow_images_in_editors, Boolean
+        attribute :allow_videos_in_editors, Boolean
         attribute :allow_images_in_proposals, Boolean
-        attribute :use_markdown_editor, Boolean
-        attribute :allow_images_in_markdown_editor, Boolean
         attribute :auto_save_forms, Boolean
         attribute :scoped_styles, Hash
+        attribute :scoped_admin_styles, Hash
         attribute :proposal_custom_fields, Hash
+        attribute :proposal_private_custom_fields, Hash
+        attribute :user_timezone, Boolean
+        attribute :force_authorization_after_login, Array
+        attribute :force_authorization_with_any_method, Boolean
+        translatable_attribute :force_authorization_help_text, String
         attribute :scoped_admins, Hash
-        attribute :menu, Array[MenuForm]
+        attribute :menu, [MenuForm]
         attribute :intergram_for_admins, Boolean
         attribute :intergram_for_admins_settings, IntergramForm
         attribute :intergram_for_public, Boolean
         attribute :intergram_for_public_settings, IntergramForm
+        attribute :validate_title_min_length, Integer, default: 15
+        attribute :validate_title_max_caps_percent, Integer, default: 25
+        attribute :validate_title_max_marks_together, Integer, default: 1
+        attribute :validate_title_start_with_caps, Boolean, default: true
+        attribute :validate_body_min_length, Integer, default: 15
+        attribute :validate_body_max_caps_percent, Integer, default: 25
+        attribute :validate_body_max_marks_together, Integer, default: 1
+        attribute :validate_body_start_with_caps, Boolean, default: true
+        attribute :additional_proposal_sortings, Array, default: Decidim::DecidimAwesome.possible_additional_proposal_sortings
 
-        # collect all keys anything not specified in the params (UpdateConfig command ignores it)
+        # collect all keys specified in the params (UpdateConfig command ignores everything else)
         attr_accessor :valid_keys
 
-        validate :css_syntax, if: ->(form) { form.scoped_styles.present? }
-        validate :json_syntax, if: ->(form) { form.proposal_custom_fields.present? }
+        validate :css_syntax
+        validate :json_syntax
 
+        validates :validate_title_min_length, presence: true, numericality: { greater_than_or_equal_to: 1, less_than_or_equal_to: 100 }
+        validates :validate_title_max_caps_percent, presence: true, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }
+        validates :validate_title_max_marks_together, presence: true, numericality: { greater_than_or_equal_to: 1 }
+        validates :validate_body_min_length, presence: true, numericality: { greater_than_or_equal_to: 0 }
+        validates :validate_body_max_caps_percent, presence: true, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }
+        validates :validate_body_max_marks_together, presence: true, numericality: { greater_than_or_equal_to: 1 }
+        validate :force_authorization_after_login_is_valid
         # TODO: validate non general admins are here
 
         def self.from_params(params, additional_params = {})
           instance = super(params, additional_params)
-          instance.valid_keys = params.keys.map(&:to_sym) || []
+          instance.force_authorization_after_login = instance.force_authorization_after_login.compact_blank if instance.force_authorization_after_login.present?
+          instance.valid_keys = extract_valid_keys_from_params(params)
           instance.sanitize_labels!
           instance
         end
 
+        def self.extract_valid_keys_from_params(params)
+          keys = []
+          params.each do |key, _value|
+            keys << if key.to_s.starts_with?("force_authorization_help_text_")
+                      :force_authorization_help_text if keys.exclude?(:force_authorization_help_text)
+                    else
+                      key.to_sym
+                    end
+          end
+          keys
+        end
+
+        def additional_proposal_sorting_labels
+          Decidim::DecidimAwesome.possible_additional_proposal_sortings.index_by do |sorting|
+            I18n.t(sorting, scope: "decidim.proposals.proposals.orders")
+          end
+        end
+
         def css_syntax
-          scoped_styles.each do |key, code|
-            next unless code
+          styles = {}
+          styles.merge!(scoped_styles: scoped_styles.values) if scoped_styles.present?
+          styles.merge!(scoped_admin_styles: scoped_admin_styles.values) if scoped_admin_styles.present?
+          styles.each do |key, values|
+            next if values.blank?
 
-            SassC::Engine.new(code).render
+            values.each { |code| SassC::Engine.new(code).render }
           rescue SassC::SyntaxError => e
-            errors.add(:scoped_styles, I18n.t("config.form.errors.incorrect_css", key: key, scope: "decidim.decidim_awesome.admin"))
+            errors.add(key, I18n.t("config.form.errors.incorrect_css", key:, scope: "decidim.decidim_awesome.admin"))
             errors.add(key.to_sym, e.message)
           end
         end
 
         def json_syntax
-          proposal_custom_fields.each do |key, code|
-            next unless code
+          fields = {}
+          fields.merge!(proposal_custom_fields: proposal_custom_fields.values) if proposal_custom_fields.present?
+          fields.merge!(proposal_private_custom_fields: proposal_private_custom_fields.values) if proposal_private_custom_fields.present?
+          fields.each do |key, values|
+            next if values.blank?
 
-            JSON.parse(code)
-          rescue JSON::ParserError => e
-            errors.add(:scoped_styles, I18n.t("config.form.errors.incorrect_json", key: key, scope: "decidim.decidim_awesome.admin"))
+            values.each { |code| JSON.parse(code) }
+          rescue JSON::JSONError => e
+            errors.add(key, I18n.t("config.form.errors.incorrect_json", key:, scope: "decidim.decidim_awesome.admin"))
             errors.add(key.to_sym, e.message)
           end
         end
 
         # formBuilder has a bug and do not sanitize text if users copy/paste text with format in the label input
         def sanitize_labels!
-          return unless proposal_custom_fields
-
           proposal_custom_fields.transform_values! do |code|
             next unless code
 
@@ -76,6 +120,30 @@ module Decidim
           rescue JSON::ParserError
             code
           end
+
+          proposal_private_custom_fields.transform_values! do |code|
+            next unless code
+
+            json = JSON.parse(code)
+            json.map! do |item|
+              item["label"] = strip_tags(item["label"])
+              item
+            end
+            JSON.generate(json)
+          rescue JSON::ParserError
+            code
+          end
+        end
+
+        private
+
+        def force_authorization_after_login_is_valid
+          return if force_authorization_after_login.blank?
+
+          invalid = force_authorization_after_login - (current_organization.available_authorizations & Decidim.authorization_workflows.map(&:name))
+          return if invalid.empty?
+
+          errors.add(:force_authorization_after_login, :invalid)
         end
       end
     end

data/app/forms/decidim/decidim_awesome/admin/custom_redirect_form.rb

@@ -18,14 +18,14 @@ module Decidim
             sanitize_url(origin),
             {
               destination: sanitize_url(destination, strip_host: false),
-              active: active,
-              pass_query: pass_query
+              active:,
+              pass_query:
             }
           ]
         end
 
         def sanitize_url(url, strip_host: true)
-          url = url.strip.downcase
+          url = url.strip
           parsed = Addressable::URI.parse(url)
           url = parsed.path if strip_host && parsed.host == current_organization.host
           url = "/#{url}" unless url.match?(%r{^https?://|^/})

data/app/forms/decidim/decidim_awesome/admin/intergram_form.rb

@@ -13,6 +13,10 @@ module Decidim
         attribute :intro_message, String
         attribute :auto_response, String
         attribute :auto_no_response, String
+
+        def color
+          super || current_organization.colors["secondary"] || "#E91E63"
+        end
       end
     end
   end

data/app/forms/decidim/decidim_awesome/admin/menu_form.rb

@@ -5,7 +5,7 @@ module Decidim
     module Admin
       class MenuForm < Decidim::Form
         include Decidim::TranslatableAttributes
-        VISIBILITY_STATES = %w(default hidden logged non_logged).freeze
+        VISIBILITY_STATES = %w(default hidden logged non_logged verified_user).freeze
 
         translatable_attribute :raw_label, String
         attribute :url, String
@@ -27,10 +27,10 @@ module Decidim
         def to_params
           {
             label: raw_label,
-            position: position,
-            url: url,
-            target: target,
-            visibility: visibility
+            position:,
+            url:,
+            target:,
+            visibility:
           }
         end
       end

data/app/helpers/concerns/decidim/decidim_awesome/amendments_helper_override.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module AmendmentsHelperOverride
+      extend ActiveSupport::Concern
+
+      included do
+        # original method
+        alias_method :decidim_amendments_form_field_for, :amendments_form_field_for
+
+        # override with custom fields if scope applies
+        def amendments_form_field_for(attribute, form, original_resource)
+          custom_fields, custom_private_fields = awesome_custom_fields(attribute, form)
+          content = if custom_fields.blank?
+                      decidim_amendments_form_field_for(attribute, form, original_resource)
+                    else
+                      render_amendment_custom_fields_override(custom_fields, attribute, form, original_resource)
+                    end
+          if custom_private_fields.present?
+            content = content_tag("div", content)
+            content += content_tag("div", render_amendment_custom_fields_override(custom_private_fields, :private_body, form, original_resource))
+          end
+          content
+        end
+
+        private
+
+        def render_amendment_custom_fields_override(custom_fields, attribute, form, original_resource)
+          # ensure decidim_editor is available as it is only required if the original FormBuilder is called
+          append_stylesheet_pack_tag "decidim_editor"
+          append_javascript_pack_tag "decidim_editor", defer: false
+
+          custom_fields.translate!
+          body = amendments_form_fields_value(original_resource, attribute)
+          custom_fields.apply_xml(body) if body.present?
+          # TODO: find a way to add errors as form is not the parent form
+          # form.object.errors.add(attribute, custom_fields.errors) if custom_fields.errors
+
+          editor_image = Decidim::EditorImage.new
+          editor_options = form.send(:editor_options, editor_image, { context: "participant", lines: 10 })
+          editor_upload = form.send(:editor_upload, editor_image, editor_options[:upload])
+          render partial: "decidim/decidim_awesome/custom_fields/form_render", locals: { spec: custom_fields.to_json, editor_options:, editor_upload:, form:, name: attribute }
+        end
+
+        # Amendments don't use a URL specifying participatory space and component
+        # context for awesome config constraints must be obtained from the resource
+        def awesome_custom_fields(attribute, _form)
+          return unless attribute == :body
+
+          component = amendable.try(:component)
+          return unless component
+          return if component.settings.participatory_texts_enabled?
+
+          awesome_config = Decidim::DecidimAwesome::Config.new(component.organization)
+          awesome_config.context_from_component(component)
+
+          pub = awesome_config.collect_sub_configs_values("proposal_custom_field")
+          priv = awesome_config.collect_sub_configs_values("proposal_private_custom_field")
+          [pub.presence && Decidim::DecidimAwesome::CustomFields.new(pub), priv.presence && Decidim::DecidimAwesome::CustomFields.new(priv)]
+        end
+      end
+    end
+  end
+end

data/app/helpers/concerns/decidim/decidim_awesome/breadcrumb_helper_override.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module BreadcrumbHelperOverride
+      extend ActiveSupport::Concern
+
+      included do
+        def active_breadcrumb_item(target_menu)
+          active_item = ::Decidim::MenuPresenter.new(target_menu, self).active_item_for_breadcrumb
+
+          return if active_item.blank?
+
+          {
+            label: active_item.label,
+            url: active_item.url,
+            active: active_item.active?
+          }
+        end
+      end
+    end
+  end
+end

data/app/helpers/concerns/decidim/decidim_awesome/proposals/application_helper_override.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Proposals
+      module ApplicationHelperOverride
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method :decidim_text_editor_for_proposal_body, :text_editor_for_proposal_body
+          alias_method :decidim_render_proposal_body, :render_proposal_body
+
+          # If the content is safe, HTML tags are sanitized, otherwise, they are stripped.
+          def render_proposal_body(proposal)
+            if awesome_proposal_custom_fields.present? || awesome_config[:allow_images_in_editors]
+              content = present(proposal).body(links: true, strip_tags: false)
+              sanitized = decidim_sanitize_editor_admin(content, {})
+              Decidim::ContentProcessor.render_without_format(sanitized).html_safe
+            else
+              decidim_render_proposal_body(proposal)
+            end
+          end
+
+          # replace normal method to draw the editor
+          def text_editor_for_proposal_body(form)
+            custom_fields = awesome_proposal_custom_fields_for(:body)
+            custom_private_fields = awesome_proposal_custom_fields_for(:private_body)
+
+            content = if custom_fields.empty?
+                        decidim_text_editor_for_proposal_body(form)
+                      else
+                        render_proposal_custom_fields_override(custom_fields, form, :body)
+                      end
+
+            unless custom_private_fields.empty?
+              content = content_tag("div", content)
+              content += content_tag("div", render_proposal_custom_fields_override(custom_private_fields, form, :private_body))
+            end
+            content
+          end
+
+          # replace admin method to draw the editor (multi lang)
+          def admin_editor_for_proposal_body(form)
+            custom_fields = awesome_proposal_custom_fields_for(:body)
+
+            return if custom_fields.empty?
+
+            locales = form.send(:locales)
+            return render_proposal_custom_fields_override(custom_fields, form, "body_#{locales.first}", locales.first) if locales.length == 1
+
+            tabs_id = form.send(:sanitize_tabs_selector, form.options[:tabs_id] || "#{form.object_name}-body-tabs")
+
+            label_tabs = form.content_tag(:div, class: "label--tabs") do
+              language_selector = "".html_safe
+              language_selector = form.create_language_selector(locales, tabs_id, "body") if form.options[:label] != false
+
+              safe_join [content_tag("label"), language_selector]
+            end
+
+            tabs_content = form.content_tag(:div, class: "tabs-content", data: { tabs_content: tabs_id }) do
+              locales.each_with_index.inject("".html_safe) do |string, (locale, index)|
+                tab_content_id = "#{tabs_id}-body-panel-#{index}"
+                string + content_tag(:div, class: form.send(:tab_element_class_for, "panel", index), id: tab_content_id, "aria-hidden": index.zero? ? "false" : "true") do
+                  render_proposal_custom_fields_override(custom_fields, form, "body_#{locale}", locale)
+                end
+              end
+            end
+
+            safe_join [label_tabs, tabs_content]
+          end
+
+          def render_proposal_custom_fields_override(custom_fields, form, name, locale = nil)
+            # ensure decidim_editor is available as it is only required if the original FormBuilder is called
+            append_stylesheet_pack_tag "decidim_editor"
+            append_javascript_pack_tag "decidim_editor", defer: false
+
+            custom_fields.translate!
+
+            body = if name == :private_body
+                     if form_presenter.proposal.private_body.is_a?(Hash) && locale.present?
+                       form_presenter.private_body(extras: false, all_locales: locale.present?).with_indifferent_access[locale]
+                     else
+                       form_presenter.private_body(extras: false)
+                     end
+                   elsif form_presenter.proposal.body.is_a?(Hash) && locale.present?
+                     form_presenter.body(extras: false, all_locales: locale.present?).with_indifferent_access[locale]
+                   else
+                     form_presenter.body(extras: false)
+                   end
+
+            custom_fields.apply_xml(body) if body.present?
+            form.object.errors.add(name, custom_fields.errors) if custom_fields.errors
+            editor_image = Decidim::EditorImage.new
+            editor_options = form.send(:editor_options, editor_image, { context: "participant", lines: 10 })
+            editor_upload = form.send(:editor_upload, editor_image, editor_options[:upload])
+            render partial: "decidim/decidim_awesome/custom_fields/form_render", locals: { spec: custom_fields.to_json, editor_options:, editor_upload:, form:, name: }
+          end
+
+          def awesome_proposal_custom_fields_for(name)
+            if name == :private_body
+              Decidim::DecidimAwesome::CustomFields.new(awesome_proposal_private_custom_fields)
+            else
+              Decidim::DecidimAwesome::CustomFields.new(awesome_proposal_custom_fields)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/decidim_awesome/admin/config_constraints_helpers.rb

@@ -8,36 +8,19 @@ module Decidim
 
         include Decidim::TranslatableAttributes
 
-        def check(status)
-          content_tag(:span, icon(status ? "check" : "x", class: "icon", aria_label: status, role: "img"), class: "text-#{status ? "success" : "alert"}")
-        end
+        delegate :menus, :config_enabled?, to: "Decidim::DecidimAwesome::Menu"
 
-        def menus
-          @menus ||= {
-            editors: config_enabled?([:allow_images_in_full_editor, :allow_images_in_small_editor, :use_markdown_editor, :allow_images_in_markdown_editor]),
-            proposals: config_enabled?(:allow_images_in_proposals),
-            surveys: config_enabled?(:auto_save_forms),
-            styles: config_enabled?(:scoped_styles),
-            proposal_custom_fields: config_enabled?(:proposal_custom_fields),
-            admins: config_enabled?(:scoped_admins),
-            menu_hacks: config_enabled?(:menu),
-            custom_redirects: config_enabled?(:custom_redirects),
-            livechat: config_enabled?([:intergram_for_admins, :intergram_for_public])
-          }
+        def check(status)
+          content_tag(:span, icon(status ? "check-line" : "close-line", class: "inline-block", aria_label: status, role: "img"), class: "fill-#{status ? "success" : "alert"}")
         end
 
         # returns only non :disabled vars in config
         def enabled_configs(vars)
-          vars.filter do |var|
-            config_enabled? var
+          vars.filter do |conf|
+            config_enabled?(conf)
           end
         end
 
-        # ensure boolean value
-        def config_enabled?(var)
-          DecidimAwesome.enabled?(var) ? true : false
-        end
-
         def participatory_space_manifests
           manifests = OTHER_MANIFESTS.index_with { |m| I18n.t("decidim.decidim_awesome.admin.config.#{m}") }
           Decidim.participatory_space_manifests.pluck(:name).each do |name|
@@ -49,28 +32,28 @@ module Decidim
         def component_manifests(space = nil)
           return {} if OTHER_MANIFESTS.include?(space)
 
-          Decidim.component_manifests.pluck(:name).map do |name|
+          Decidim.component_manifests.pluck(:name).to_h do |name|
             [name.to_sym, I18n.t("decidim.components.#{name}.name")]
-          end.to_h
+          end
         end
 
         def participatory_spaces_list(manifest)
           space = model_for_manifest(manifest)
           return {} if space.blank?
 
-          space.where(organization: current_organization).map do |item|
+          space.where(organization: current_organization).to_h do |item|
             [item.try(:slug) || item.id.to_s, translated_attribute(item.title)]
-          end.to_h
+          end
         end
 
         def components_list(manifest, slug)
           space = model_for_manifest(manifest)
           return {} unless space&.column_names&.include? "slug"
 
-          components = Component.where(participatory_space: space.find_by(slug: slug))
-          components.map do |item|
+          components = Component.where(participatory_space: space.find_by(slug:))
+          components.to_h do |item|
             [item.id, "#{item.id}: #{translated_attribute(item.name)}"]
-          end.to_h
+          end
         end
 
         def translate_constraint_value(constraint, key)

data/app/helpers/decidim/decidim_awesome/admin/system_checker_helpers.rb

@@ -16,6 +16,10 @@ module Decidim
           SystemChecker.to_h
         end
 
+        def exists?(spec, file)
+          SystemChecker.exists?(spec, file)
+        end
+
         def valid?(spec, file)
           SystemChecker.valid?(spec, file)
         end

data/app/helpers/decidim/decidim_awesome/map_helper.rb

@@ -11,47 +11,47 @@ module Decidim
 
       # rubocop:disable Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity:
-      def awesome_map_for(components, &block)
+      def awesome_map_for(components, &)
         return unless map_utility_dynamic
 
-        map = awesome_builder.map_element({ class: "google-map", id: "awesome-map-container" }, &block)
-        help = content_tag(:div, class: "map__help") do
-          sr_content = content_tag(:p, t("screen_reader_explanation", scope: "decidim.map.dynamic"), class: "show-for-sr")
-
-          sr_content
+        map = awesome_builder.map_element({ class: "dynamic-map", id: "awesome-map-container" }, &)
+        help = content_tag(:div, class: "map__skip-container") do
+          content_tag(:p, t("screen_reader_explanation", scope: "decidim.map.dynamic"), class: "sr-only")
         end
 
         html_options = {
-          "class" => "awesome-map",
-          "id" => "awesome-map",
-          "data-components" => components.map do |component|
-                                 {
-                                   id: component.id,
-                                   type: component.manifest.name,
-                                   name: translated_attribute(component.name),
-                                   url: Decidim::EngineRouter.main_proxy(component).root_path,
-                                   amendments: component.manifest.name == :proposals ? Decidim::Proposals::Proposal.where(component: component).only_emendations.count : 0
-                                 }
-                               end.to_json,
-          "data-hide-controls" => settings_source.try(:hide_controls),
-          "data-collapsed" => global_settings.collapse,
-          "data-truncate" => global_settings.truncate || 255,
-          "data-map-center" => global_settings.map_center,
-          "data-map-zoom" => global_settings.map_zoom || 8,
-          "data-menu-merge-components" => global_settings.menu_merge_components,
-          "data-menu-amendments" => global_settings.menu_amendments,
-          "data-menu-meetings" => global_settings.menu_meetings,
-          "data-menu-categories" => global_settings.menu_categories,
-          "data-menu-hashtags" => global_settings.menu_hashtags,
-          "data-show-not-answered" => step_settings&.show_not_answered,
-          "data-show-accepted" => step_settings&.show_accepted,
-          "data-show-withdrawn" => step_settings&.show_withdrawn,
-          "data-show-evaluating" => step_settings&.show_evaluating,
-          "data-show-rejected" => step_settings&.show_rejected
+          class: "awesome-map",
+          id: "awesome-map",
+          data: {
+            "components" => components.map do |component|
+                              {
+                                id: component.id,
+                                type: component.manifest.name,
+                                name: translated_attribute(component.name),
+                                url: Decidim::EngineRouter.main_proxy(component).root_path,
+                                amendments: component.manifest.name == :proposals ? Decidim::Proposals::Proposal.where(component:).only_emendations.count : 0
+                              }
+                            end.to_json,
+            "hide-controls" => settings_source.try(:hide_controls),
+            "collapsed" => global_settings.collapse,
+            "truncate" => global_settings.truncate || 255,
+            "map-center" => global_settings.map_center,
+            "map-zoom" => global_settings.map_zoom || 8,
+            "menu-merge-components" => global_settings.menu_merge_components,
+            "menu-amendments" => global_settings.menu_amendments,
+            "menu-meetings" => global_settings.menu_meetings,
+            "menu-categories" => global_settings.menu_categories,
+            "menu-hashtags" => global_settings.menu_hashtags,
+            "show-not-answered" => step_settings&.show_not_answered,
+            "show-accepted" => step_settings&.show_accepted,
+            "show-withdrawn" => step_settings&.show_withdrawn,
+            "show-evaluating" => step_settings&.show_evaluating,
+            "show-rejected" => step_settings&.show_rejected
+          }
         }
 
         content_tag(:div, html_options) do
-          content_tag :div, class: "row column" do
+          content_tag :div, class: "w-full" do
             help + map
           end
         end
@@ -71,7 +71,6 @@ module Decidim
         try(:current_component) || self
       end
 
-      # rubocop:disable Rails/HelperInstanceVariable
       def current_categories(categories)
         return @current_categories if @current_categories
 
@@ -97,23 +96,12 @@ module Decidim
         }
         builder = map_utility_dynamic.create_builder(self, options)
 
-        # We need awesome map listeners before initialize the official map
-        unless snippets.any?(:awesome_map)
-          snippets.add(:awesome_map, javascript_pack_tag("decidim_decidim_awesome_map", defer: false))
-          snippets.add(:awesome_map, stylesheet_pack_tag("decidim_decidim_awesome_map"))
-          snippets.add(:head, snippets.for(:awesome_map))
-        end
-
-        unless snippets.any?(:map)
-          snippets.add(:map, builder.stylesheet_snippets)
-          snippets.add(:map, builder.javascript_snippets)
-          snippets.add(:head, snippets.for(:map))
-        end
+        append_stylesheet_pack_tag("decidim_decidim_awesome_map")
+        append_javascript_pack_tag("decidim_decidim_awesome_map")
 
         builder
       end
 
-      # rubocop:disable Style/FormatStringToken
       def append_category(category)
         @h += @golden_ratio_conjugate
         @h %= 1
@@ -126,18 +114,16 @@ module Decidim
           color: format("#%02x%02x%02x", r, g, b)
         )
       end
-      # rubocop:enable Style/FormatStringToken
-      # rubocop:enable Rails/HelperInstanceVariable
 
       # HSV values in [0..1[
       # returns [r, g, b] values from 0 to 255
       # rubocop:disable Naming/MethodParameterName
       def hsv_to_rgb(h, s, v)
         h_i = (h * 6).to_i
-        f = h * 6 - h_i
+        f = (h * 6) - h_i
         p = v * (1 - s)
-        q = v * (1 - f * s)
-        t = v * (1 - (1 - f) * s)
+        q = v * (1 - (f * s))
+        t = v * (1 - ((1 - f) * s))
         if h_i.zero?
           r = v
           g = t