decidim-core 0.27.4 → 0.28.0.rc5

data/app/helpers/decidim/application_helper.rb

@@ -14,13 +14,13 @@ module Decidim
     # text    - The String text to be truncated.
     # options - A Hash with the options to truncate the text (default: {}):
     #           :length - An Integer number with the max length of the text.
-    #           :separator - A String to append to the text when it's being
+    #           :separator - A String to append to the text when it is being
     #           truncated.
     #
     # Returns a String.
     def html_truncate(text, options = {})
       options[:max_length] = options.delete(:length) || options[:max_length]
-      options[:tail] = options.delete(:separator) || options[:tail] || "..."
+      options[:tail] = options.delete(:separator) || options[:tail] || "…"
       options[:count_tags] ||= false
       options[:count_tail] ||= false
       options[:tail_before_final_tag] = true unless options.has_key?(:tail_before_final_tag)
@@ -29,7 +29,7 @@ module Decidim
     end
 
     def present(object, presenter_class: nil)
-      presenter_class ||= resolve_presenter_class(object, presenter_class: presenter_class)
+      presenter_class ||= resolve_presenter_class(object, presenter_class:)
       presenter = presenter_class.new(object)
 
       yield(presenter) if block_given?
@@ -45,7 +45,7 @@ module Decidim
 
     # Generates a link to be added to the global Edit link so admins
     # can easily manage data without having to look for it at the admin
-    # panel when they're at a public page.
+    # panel when they are at a public page.
     #
     # link_url      - The String with the URL.
     # action        - The Symbol action to check the permissions for.
@@ -57,18 +57,18 @@ module Decidim
     # link_options[:class]  - An optional String to add as a css class to the link wrapper.
     #
     # Returns nothing.
-    def edit_link(link_url, action, subject, extra_context = {}, link_options = { class: "topbar__edit__link" })
+    def edit_link(link_url, action, subject, extra_context = {}, link_options = {})
       return unless current_user
       return unless admin_allowed_to?(action, subject, extra_context)
       return if content_for?(:edit_link)
 
-      cell_html = raw(cell("decidim/navbar_admin_link", link_url: link_url, link_options: link_options))
+      cell_html = raw(cell("decidim/navbar_admin_link", link_url:, link_options:))
       content_for(:edit_link, cell_html)
     end
 
     # Generates a second link to be added to the global admin action link so admins
     # can easily manage data without having to look for it at the admin
-    # panel when they're at a public page.
+    # panel when they are at a public page.
     #
     # link_url       - The String with the URL.
     # action         - The Symbol action to check the permissions for.
@@ -85,7 +85,7 @@ module Decidim
       return unless admin_allowed_to?(action, subject, extra_context)
       return if content_for?(:extra_admin_link)
 
-      cell_html = raw(cell("decidim/navbar_admin_link", link_url: link_url, link_options: link_options))
+      cell_html = raw(cell("decidim/navbar_admin_link", link_url:, link_options:))
       content_for(:extra_admin_link, cell_html)
     end
 
@@ -97,9 +97,9 @@ module Decidim
     # options - a Hash with options
     #
     # Renders the cell contents.
-    def cell(name, model, options = {}, &block)
-      options = { context: { current_user: current_user } }.deep_merge(options)
-      super(name, model, options, &block)
+    def cell(name, model, options = {}, &)
+      options = { context: { view_context: self, current_user: } }.deep_merge(options)
+      super(name, model, options, &)
     end
 
     # Public: Builds the URL for the step Call To Action. Takes URL params

data/app/helpers/decidim/aria_selected_link_to_helper.rb

@@ -6,7 +6,7 @@ module Decidim
   # this.
   #
   module AriaSelectedLinkToHelper
-    # Adds the `aria-selected` attribute to a link when it's pointing to the
+    # Adds the `aria-selected` attribute to a link when it is pointing to the
     # current path. The API is the same than the `link_to` one, and uses this
     # helper internally.
     #

data/app/helpers/decidim/attachments_helper.rb

@@ -3,14 +3,37 @@
 module Decidim
   # A Helper to render and link to resources.
   module AttachmentsHelper
+    include IconHelper
+
     # Renders a the attachments of a model that includes the
     # HasAttachments concern.
     #
     # attached_to - The model to render the attachments from.
-    #
-    # Returns nothing.
     def attachments_for(attached_to)
-      render partial: "decidim/application/attachments", locals: { attached_to: attached_to }
+      return unless attached_to.is_a?(Decidim::HasAttachments)
+
+      cell "decidim/tab_panels", attachments_tab_panel_items(attached_to)
+    end
+
+    def attachments_tab_panel_items(attached_to)
+      [
+        {
+          enabled: attached_to.photos.any?,
+          id: "images",
+          text: t("decidim.application.photos.photos"),
+          icon: resource_type_icon_key("images"),
+          method: :cell,
+          args: ["decidim/images_panel", attached_to]
+        },
+        {
+          enabled: attached_to.documents.any?,
+          id: "documents",
+          text: t("decidim.application.documents.documents"),
+          icon: resource_type_icon_key("documents"),
+          method: :cell,
+          args: ["decidim/documents_panel", attached_to]
+        }
+      ]
     end
 
     # Renders the attachment's title.

data/app/helpers/decidim/authorization_form_helper.rb

@@ -12,7 +12,7 @@ module Decidim
     # block   - A block with the content of the form.
     #
     # Returns a String.
-    def authorization_form_for(record, options = {}, &block)
+    def authorization_form_for(record, options = {}, &)
       default_options = {
         builder: AuthorizationFormBuilder,
         as: "authorization_handler",
@@ -20,7 +20,7 @@ module Decidim
       }
 
       options = default_options.merge(options)
-      decidim_form_for(record, options, &block)
+      decidim_form_for(record, options, &)
     end
   end
 end

data/app/helpers/decidim/breadcrumb_helper.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This module includes helpers to manage breadcrumb in layout
+  module BreadcrumbHelper
+    attr_reader :context_breadcrumb_items, :secondary_breadcrumb_menus, :controller_breadcrumb_items
+
+    # Public: Returns the list of breadcrumb items to be rendered in some
+    # context.
+    #
+    # context - The context (public or admin) to display the breadcrumb. It
+    #           determines the first element of the breadcrumb
+    #
+    # The items are generated as the concatenation of the following 4
+    # sections in order:
+    # * The root active item: This item comes from the main menu on each
+    #   context and is the currently active element.
+    # * context_breadcrumb_items: A list which can be implemented in
+    #   specific concerns and is used to display items like a participatory
+    #   space or a component inside a participatory space.
+    # * secondary_breadcrumb_menus: A list which can be managed from
+    #   HasBreadcrumbItems concern with the add_breadcrumb_item_from_menu
+    #   method. The list contains the identifier of a menu to insert its items
+    #   in the breadcrumb displaying the active element.
+    # * controller_breadcrumb_items: A list of additional breadrumb items
+    #   which is expected to receive its elements from controllers and contains
+    #   the last items of the breadcrumb.
+    def breadcrumb_items(context = :public)
+      @breadcrumb_items ||= [].tap do |items|
+        root_active_item = if context == :admin
+                             active_breadcrumb_item(:admin_menu_modules) || active_breadcrumb_item(:admin_menu)
+                           else
+                             active_breadcrumb_item(:menu)
+                           end
+
+        items << root_active_item if root_active_item.present?
+
+        items.append(*context_breadcrumb_items)
+
+        secondary_breadcrumb_menus&.each do |menu|
+          active_item = active_breadcrumb_item(menu)
+          items << active_item if active_item.present?
+        end
+        items.append(*controller_breadcrumb_items)
+      end
+    end
+
+    def active_breadcrumb_item(target_menu)
+      active_item = ::Decidim::MenuPresenter.new(target_menu, self).active_item
+
+      return if active_item.blank?
+
+      {
+        label: active_item.label,
+        url: active_item.url,
+        active: active_item.active?
+      }
+    end
+  end
+end

data/app/helpers/decidim/cache_helper.rb

@@ -5,10 +5,10 @@ module Decidim
   # locale into account for fragment caching.
   module CacheHelper
     # See: https://git.io/J3ouj
-    def cache(name = {}, options = {}, &block)
+    def cache(name = {}, options = {}, &)
       name = Array(name) + [current_locale]
 
-      super(name, options, &block)
+      super(name, options, &)
     end
   end
 end

data/app/helpers/decidim/cells_paginate_helper.rb

@@ -8,7 +8,7 @@ module Decidim
     include Cell::ViewModel::Partial
     include Decidim::PaginateHelper
 
-    def paginate(scope, **options, &block)
+    def paginate(scope, **options, &)
       options = options.reverse_merge(views_prefix: "../views/")
       super
     end

data/app/helpers/decidim/check_boxes_tree_helper.rb

@@ -6,14 +6,16 @@ module Decidim
     # This method returns a hash with the options for the checkbox and its label
     # used in filters that uses checkboxes trees
     def check_boxes_tree_options(value, label, **options)
+      parent_id = options.delete(:parent_id) || ""
       checkbox_options = {
-        value: value,
-        label: label,
+        value:,
+        label:,
         multiple: true,
         include_hidden: false,
         label_options: {
-          "data-children-checkbox": "",
-          value: value
+          "data-children-checkbox": parent_id,
+          value:,
+          class: "filter"
         }
       }
       options.merge!(checkbox_options)
@@ -69,14 +71,14 @@ module Decidim
       end
 
       TreeNode.new(
-        TreePoint.new("", t("decidim.proposals.application_helper.filter_category_values.all")),
+        TreePoint.new("", t("decidim.core.application_helper.filter_category_values.all")),
         categories_values
       )
     end
 
     def resource_filter_scope_values(resource)
       if resource.is_a?(Scope)
-        filter_scopes_values_from([resource])
+        filter_scopes_values_from([resource], current_participatory_space)
       else
         filter_scopes_values
       end
@@ -87,9 +89,53 @@ module Decidim
 
       main_scopes = current_participatory_space.scopes.top_level
                                                .includes(:scope_type, :children)
-      filter_scopes_values_from(main_scopes)
+      filter_scopes_values_from(main_scopes, current_participatory_space)
     end
 
+    def filter_global_scopes_values
+      filter_scopes_values_from(current_organization.scopes.top_level.includes(:scope_type, :children))
+    end
+
+    def filter_areas_values
+      areas_or_types = areas_for_select(current_organization)
+
+      areas_values = if areas_or_types.first.is_a?(Decidim::Area)
+                       filter_areas(areas_or_types)
+                     else
+                       filter_areas_and_types(areas_or_types)
+                     end
+
+      TreeNode.new(
+        TreePoint.new("", t("decidim.core.application_helper.filter_area_values.all")),
+        areas_values
+      )
+    end
+
+    def filter_tree_from_array(array)
+      root_point = if array.first[0].blank?
+                     TreePoint.new(*array.shift)
+                   else
+                     TreePoint.new("", t("decidim.core.application_helper.filter_scope_values.all"))
+                   end
+      TreeNode.new(
+        root_point,
+        array.map { |values| TreePoint.new(*values) }
+      )
+    end
+
+    def flat_filter_values(*types, **options)
+      scope = options[:scope]
+      types.map do |type|
+        [type, t(type, scope:)]
+      end
+    end
+
+    def filter_text_for(translation, id: nil)
+      content_tag(:span, translation, id:).html_safe + content_tag(:span)
+    end
+
+    private
+
     def filter_scopes_values_from_parent(scope)
       scopes_values = []
       scope.children.each do |child|
@@ -99,43 +145,62 @@ module Decidim
         end
         scopes_values << TreeNode.new(
           TreePoint.new(child.id.to_s, translated_attribute(child.name, current_participatory_space.organization)),
-          scope_children_to_tree(child)
+          scope_children_to_tree(child, current_participatory_space)
         )
       end
 
       filter_tree_from(scopes_values)
     end
 
-    def filter_scopes_values_from(scopes)
+    def filter_scopes_values_from(scopes, participatory_space = nil)
       scopes_values = scopes.compact.flat_map do |scope|
         TreeNode.new(
-          TreePoint.new(scope.id.to_s, translated_attribute(scope.name, current_participatory_space.organization)),
-          scope_children_to_tree(scope)
+          TreePoint.new(scope.id.to_s, translated_attribute(scope.name)),
+          scope_children_to_tree(scope, participatory_space)
         )
       end
 
-      scopes_values.prepend(TreePoint.new("global", t("decidim.scopes.global"))) if current_participatory_space.scope.blank?
+      scopes_values.prepend(TreePoint.new("global", t("decidim.scopes.global"))) if participatory_space&.scope.blank?
 
       filter_tree_from(scopes_values)
     end
 
-    def scope_children_to_tree(scope)
-      return if scope.scope_type && scope.scope_type == current_participatory_space.try(:scope_type_max_depth)
+    def scope_children_to_tree(scope, participatory_space = nil)
+      return if participatory_space.present? && scope.scope_type && scope.scope_type == current_participatory_space.try(:scope_type_max_depth)
       return unless scope.children.any?
 
       scope.children.includes(:scope_type, :children).flat_map do |child|
         TreeNode.new(
-          TreePoint.new(child.id.to_s, translated_attribute(child.name, current_participatory_space.organization)),
-          scope_children_to_tree(child)
+          TreePoint.new(child.id.to_s, translated_attribute(child.name)),
+          scope_children_to_tree(child, participatory_space)
         )
       end
     end
 
     def filter_tree_from(scopes_values)
       TreeNode.new(
-        TreePoint.new("", t("decidim.proposals.application_helper.filter_scope_values.all")),
+        TreePoint.new("", t("decidim.core.application_helper.filter_scope_values.all")),
         scopes_values
       )
     end
+
+    def filter_areas(areas)
+      areas.map do |area|
+        TreeNode.new(
+          TreePoint.new(area.id.to_s, area.name[I18n.locale.to_s])
+        )
+      end
+    end
+
+    def filter_areas_and_types(area_types)
+      area_types.map do |area_type|
+        TreeNode.new(
+          TreePoint.new(area_type.area_ids.join("_"), area_type.name[I18n.locale.to_s]),
+          area_type.areas.map do |area|
+            TreePoint.new(area.id.to_s, area.name[I18n.locale.to_s])
+          end
+        )
+      end
+    end
   end
 end

data/app/helpers/decidim/component_path_helper.rb

@@ -36,7 +36,7 @@ module Decidim
     # Returns whether the component can be managed or not by checking if it has
     # an admin engine.
     #
-    # component - the Component we want to find if it's manageable or not.
+    # component - the Component we want to find if it is manageable or not.
     #
     # Returns a boolean matching the question.
     def can_be_managed?(component)

data/app/helpers/decidim/contextual_help_helper.rb

@@ -3,8 +3,8 @@
 module Decidim
   # Helper to print layout elements for the different help elements available on the pages.
   module ContextualHelpHelper
-    def floating_help(id, &block)
-      render partial: "decidim/shared/floating_help", locals: { content: capture(&block), id: id }
+    def floating_help(id, &)
+      render partial: "decidim/shared/floating_help", locals: { content: capture(&), id: }
     end
   end
 end

data/app/helpers/decidim/cta_button_helper.rb

@@ -5,10 +5,12 @@ module Decidim
   module CtaButtonHelper
     # Renders the Call To Action button. Link and text can be configured
     # per organization.
-    def cta_button
-      button_text = translated_attribute(current_organization.cta_button_text).presence || t("decidim.pages.home.hero.participate")
+    def cta_button_text
+      translated_attribute(current_organization.cta_button_text).presence || t("decidim.pages.home.hero.participate")
+    end
 
-      link_to button_text, cta_button_path, class: "hero-cta button expanded large button--sc", title: t("decidim.pages.home.hero.participate_title")
+    def cta_button
+      link_to cta_button_text, cta_button_path, class: "hero-cta button expanded large button--sc", title: t("decidim.pages.home.hero.participate_title")
     end
 
     # Finds the CTA button path to reuse it in other places.

data/app/helpers/decidim/date_range_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Helper to format date ranges
+  module DateRangeHelper
+    def format_date_range(start_date, end_date)
+      return if [start_date, end_date].any?(&:blank?)
+
+      format = [start_date.year, end_date.year].any? { |year| year != Date.current.year } ? :decidim_short_with_month_name_short : :decidim_with_month_name_short
+      if start_date.to_date == end_date.to_date && start_date.to_time == end_date.to_time
+        l(start_date.to_date, format:)
+      elsif start_date.to_date == end_date.to_date
+        "#{l(start_date.to_date, format:)} #{l(start_date, format: :time_of_day)} → #{l(end_date, format: :time_of_day)}".html_safe
+      else
+        "#{l(start_date.to_date, format:)} → #{l(end_date.to_date, format:)}".html_safe
+      end
+    end
+  end
+end

data/app/helpers/decidim/decidim_form_helper.rb

@@ -10,12 +10,12 @@ module Decidim
     # &block - The block to execute as content of the form.
     #
     # Returns a String.
-    def decidim_form_for(record, options = {}, &block)
+    def decidim_form_for(record, options = {}, &)
       options[:data] ||= {}
       options[:data].update(abide: true, "live-validate" => true, "validate-on-blur" => true)
 
       options[:html] ||= {}
-      options[:html].update(novalidate: true)
+      options[:html].update(novalidate: true) unless options[:html].has_key?(:novalidate)
 
       # Generally called by form_for but we need the :url option generated
       # already before that.
@@ -31,7 +31,7 @@ module Decidim
 
       output = ""
       output += base_error_messages(record).to_s
-      output += form_for(record, options, &block).to_s
+      output += form_for(record, options, &).to_s
 
       output.html_safe
     end
@@ -75,7 +75,7 @@ module Decidim
       picker_options = {
         id: id || sanitize_to_id(name),
         class: "picker-single",
-        name: name
+        name:
       }
 
       prompt_params = yield(nil)
@@ -84,9 +84,9 @@ module Decidim
 
       template = ""
       template += render("decidim/scopes/scopes_picker_input",
-                         picker_options: picker_options,
-                         prompt_params: prompt_params,
-                         scopes: scopes,
+                         picker_options:,
+                         prompt_params:,
+                         scopes:,
                          values_on_top: true)
       template.html_safe
     end
@@ -201,7 +201,7 @@ module Decidim
     #
     # Returns an HTML-safe String.
     def form_required_explanation
-      content_tag(:div, class: "help-text help-text-form-required-fields") do
+      content_tag(:div, class: "help-text") do
         I18n.t("forms.required_explanation")
       end
     end
@@ -210,7 +210,7 @@ module Decidim
       return unless record.respond_to?(:errors)
       return unless record.errors[:base].any?
 
-      alert_box(record.errors.full_messages_for(:base).join(","), "alert", false)
+      alert_box(record.errors.full_messages_for(:base).join(","), :alert, false)
     end
 
     # Handle which collection to pass to Decidim::FilterFormBuilder.areas_select
@@ -220,5 +220,20 @@ module Decidim
 
       organization.area_types
     end
+
+    def ordered_scopes_descendants(root = nil)
+      root = try(:current_participatory_space)&.scope if root == false
+      if root.present?
+        root.descendants
+      else
+        current_organization.scopes
+      end.sort { |a, b| a.part_of.reverse <=> b.part_of.reverse }
+    end
+
+    def ordered_scopes_descendants_for_select(root = nil)
+      ordered_scopes_descendants(root).map do |scope|
+        [" #{"&nbsp;" * 4 * (scope.part_of.count - 1)} #{translated_attribute(scope.name)}".html_safe, scope&.id]
+      end
+    end
   end
 end

data/app/helpers/decidim/endorsable_helper.rb

@@ -5,7 +5,7 @@ module Decidim
   module EndorsableHelper
     # Invokes the decidim/endorsement_buttons cell.
     def endorsement_buttons_cell(resource)
-      cell("decidim/endorsement_buttons", resource)
+      cell("decidim/endorsement_block", resource)
     end
 
     # Invokes the decidim/endorsers_list cell.
@@ -85,8 +85,8 @@ module Decidim
       end
       http_method = selected ? :delete : :post
       render partial: "decidim/endorsements/identity", locals:
-      { identity: presenter, selected: selected,
-        http_method: http_method,
+      { identity: presenter, selected:,
+        http_method:,
         create_url: path_to_create_endorsement(resource, user_group),
         destroy_url: path_to_destroy_endorsement(resource, user_group) }
     end

data/app/helpers/decidim/filters_helper.rb

@@ -3,6 +3,8 @@
 module Decidim
   # Helper that provides a single method to create filter resource forms
   module FiltersHelper
+    include IconHelper
+
     # This method wraps everything in a div with class filters and calls
     # the form_for helper with a custom builder
     #
@@ -13,23 +15,20 @@ module Decidim
     #
     # Returns the filter resource form wrapped in a div
     def filter_form_for(filter, url = url_for, html_options = {})
-      content_tag :div, class: "filters" do
-        form_for(
-          filter,
-          namespace: filter_form_namespace,
-          builder: FilterFormBuilder,
-          url: url,
-          as: :filter,
-          method: :get,
-          remote: true,
-          html: { id: nil }.merge(html_options)
-        ) do |form|
-          # Cannot use `concat()` here because it's not available in cells
-          inner = []
-          inner << hidden_field_tag("per_page", params[:per_page], id: nil) if params[:per_page]
-          inner << capture { yield form }
-          inner.join.html_safe
-        end
+      form_for(
+        filter,
+        namespace: filter_form_namespace,
+        builder: FilterFormBuilder,
+        url:,
+        as: :filter,
+        method: :get,
+        remote: true,
+        html: { id: nil }.merge(html_options)
+      ) do |form|
+        inner = []
+        inner << hidden_field_tag("per_page", params[:per_page], id: nil) if params[:per_page]
+        inner << capture { yield form }
+        inner.join.html_safe
       end
     end
 

data/app/helpers/decidim/followable_helper.rb

@@ -4,8 +4,11 @@ module Decidim
   # A Helper for views with Followable resources.
   module FollowableHelper
     # Invokes the decidim/shared/follow_button partial.
-    def follow_button_for(model, large = nil)
-      controller.view_context.render partial: "decidim/shared/follow_button", locals: { followable: model, large: large }
+    def follow_button_for(model, large = nil, opts = {})
+      controller.view_context.render(
+        partial: "decidim/shared/follow_button",
+        locals: { followable: model, large:, opts: opts.slice(:button_classes, :text_classes, :icon_classes) }
+      )
     end
   end
 end

data/app/helpers/decidim/icon_helper.rb

@@ -41,16 +41,33 @@ module Decidim
     # Returns an HTML tag with the icon.
     def resource_icon(resource, options = {})
       if resource.instance_of?(Decidim::Comments::Comment)
-        icon "comment-square", options
+        icon "chat-1-line", options
       elsif resource.respond_to?(:component) && resource.component.present?
         component_icon(resource.component, options)
       elsif resource.respond_to?(:manifest) && resource.manifest.present?
         manifest_icon(resource.manifest, options)
       elsif resource.is_a?(Decidim::User)
-        icon "person", options
+        icon "user-line", options
       else
-        icon "bell", options
+        icon "notification-3-line", options
       end
     end
+
+    def resource_type_icon(resource_type, options = {})
+      icon resource_type_icon_key(resource_type), options
+    end
+
+    def resource_type_icon_key(resource_type)
+      return resource_type.to_s if Decidim.icons.all[resource_type.to_s]
+
+      "other"
+    end
+
+    def text_with_resource_icon(resource_name, text)
+      output = ""
+      output += resource_type_icon resource_name
+      output += content_tag :span, text
+      output.html_safe
+    end
   end
 end