decidim-core 0.31.5 → 0.32.0.rc2

data/app/mailers/decidim/reported_mailer.rb

@@ -72,7 +72,10 @@ module Decidim
     end
 
     def author_profile_url
-      @author_profile_url ||= @author.is_a?(Decidim::UserBaseEntity) && !@author.deleted? ? decidim.profile_url(@author.nickname, host: @organization.host) : nil
+      @author_profile_url ||= if @author.is_a?(Decidim::UserBaseEntity) && !@author.deleted?
+                                decidim.profile_url(@author.nickname,
+                                                    host: @organization.host)
+                              end
     end
 
     def original_language(reportable)

data/app/models/decidim/action_log.rb

@@ -262,7 +262,7 @@ module Decidim
         participatory_space_lazy.present? &&
         !resource_lazy.try(:deleted?) &&
         !resource_lazy.try(:hidden?) &&
-        (participatory_space_lazy.try(:is_transparent?) || !resource_lazy.respond_to?(:can_participate?) || resource_lazy.try(:can_participate?, user))
+        (participatory_space_lazy.try(:transparent?) || !resource_lazy.respond_to?(:can_participate?) || resource_lazy.try(:can_participate?, user))
     rescue NameError => e
       Rails.logger.warn "Failed resource for #{self.class.name}(id=#{id}): #{e.message}"
 

data/app/models/decidim/attachment.rb

@@ -158,9 +158,9 @@ module Decidim
     end
 
     def private_download_required?
-      return attached_to.private_space? if attached_to.respond_to?(:private_space?)
+      return attached_to.restricted? if attached_to.respond_to?(:restricted?)
 
-      attached_to.respond_to?(:component) && attached_to.component&.private_non_transparent_space?
+      attached_to.respond_to?(:component) && attached_to.component&.restricted_space?
     end
   end
 end

data/app/models/decidim/authorization_transfer.rb

@@ -214,7 +214,7 @@ module Decidim
     #     }
     #   }
     #
-    # @return [Hash<String => Hash<Symbol => Integer, ActiveModel::Name>>] The
+    # @return [Hash{String => Hash{Symbol => Integer, ActiveModel::Name}}] The
     #   information hash created for the transfer.
     def information
       {}.tap do |types|

data/app/models/decidim/component.rb

@@ -64,6 +64,7 @@ module Decidim
       {
         :host => organization.host,
         :component_id => id,
+        :locale => I18n.locale,
         :"#{participatory_space.underscored_name}_slug" => participatory_space.slug
       }
     end
@@ -102,22 +103,18 @@ module Decidim
     def can_participate_in_space?(user)
       return false unless published?
       return false unless participatory_space.published?
-      return true unless participatory_space.try(:private_space?)
+
+      return true unless participatory_space.respond_to?(:restricted?) && participatory_space.restricted?
       return false unless user
 
       participatory_space.can_participate?(user)
     end
     alias can_participate? can_participate_in_space?
 
-    def private_non_transparent_space?
-      return false unless participatory_space.respond_to?(:private_space?)
-      return false unless participatory_space.private_space?
+    def restricted_space?
+      return false unless participatory_space.respond_to?(:restricted?)
 
-      if participatory_space.respond_to?(:is_transparent?)
-        !participatory_space.is_transparent?
-      else
-        true
-      end
+      participatory_space.restricted?
     end
 
     # Public: Public URL for component with given share token as query parameter

data/app/models/decidim/content_block.rb

@@ -36,7 +36,7 @@ module Decidim
     # Returns an object that responds to the settings defined in the content
     # block manifest.
     def settings
-      manifest.settings.schema.new(self[:settings])
+      manifest.settings.schema.new(self[:settings], organization&.default_locale)
     end
 
     def reload(*)
@@ -123,8 +123,8 @@ module Decidim
     private
 
     def manifest_attachments
-      @manifest_attachments ||= manifest.images.each_with_object({}) do |attachment_config, list|
-        list[attachment_config[:name]] = attachments.find_or_initialize_by(name: attachment_config[:name])
+      @manifest_attachments ||= manifest.images.to_h do |attachment_config|
+        [attachment_config[:name], attachments.find_or_initialize_by(name: attachment_config[:name])]
       end
     end
 

data/app/models/decidim/newsletter.rb

@@ -50,8 +50,8 @@ module Decidim
       extended_data["participatory_space_types"]
     end
 
-    def sent_to_private_members?
-      extended_data["send_to_private_members"]
+    def sent_to_members?
+      extended_data["send_to_members"]
     end
 
     def template

data/app/models/decidim/participatory_space/member.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatorySpace
+    # This class gives a given User access to a given private Member
+    class Member < ApplicationRecord
+      include Decidim::DownloadYourData
+      include ParticipatorySpaceUser
+      include Decidim::TranslatableResource
+
+      belongs_to :participatory_space, polymorphic: true
+
+      translatable_fields :role
+
+      delegate :email, :name, to: :user
+
+      validates :user, uniqueness: { scope: [:participatory_space_id, :participatory_space_type] }
+
+      scope :by_participatory_space, ->(participatory_space) { where(participatory_space_id: participatory_space.id, participatory_space_type: participatory_space.class.to_s) }
+      scope :published, -> { where(published: true) }
+
+      def self.user_collection(user)
+        where(decidim_user_id: user.id)
+      end
+
+      def self.member_ids_for_participatory_spaces(spaces)
+        joins(:user).where(participatory_space: spaces).distinct.pluck(:decidim_user_id)
+      end
+
+      def self.export_serializer
+        Decidim::DownloadYourDataSerializers::DownloadYourDataMemberSerializer
+      end
+
+      def self.log_presenter_class_for(_log)
+        Decidim::AdminLog::ParticipatorySpace::MemberPresenter
+      end
+
+      ransacker :invitation_sent_at do
+        Arel.sql(%{("invitation_sent_at")::text})
+      end
+
+      def self.ransackable_attributes(auth_object = nil)
+        return [] unless auth_object&.admin?
+
+        %w(name nickname email invitation_accepted_at last_sign_in_at invitation_sent_at role)
+      end
+
+      def self.ransackable_associations(_auth_object = nil)
+        %w(user)
+      end
+
+      def target_space_association = :participatory_space
+    end
+  end
+end

data/app/models/decidim/resource_link.rb

@@ -7,7 +7,7 @@ module Decidim
   # In order to group the relations between resources you need to specify a name.
   #
   # Some examples could be: proposals that have been created in a meeting or
-  # projects that are a result of merging different proposals.
+  # results that are the merge of different proposals.
   class ResourceLink < ApplicationRecord
     belongs_to :from, polymorphic: true
     belongs_to :to, polymorphic: true

data/app/models/decidim/short_link.rb

@@ -94,7 +94,7 @@ module Decidim
     #
     # @return [String] The target full URL that the short link should link to.
     def target_url
-      url_helpers.send("#{route_name}_url", **params)
+      url_helpers.send("#{route_name}_url", { locale: I18n.locale }.reverse_merge(params))
     end
 
     private

data/app/packs/src/decidim/controllers/assign_role/assign_role.test.js

@@ -0,0 +1,80 @@
+/* global global, jest */
+
+import { Application } from "@hotwired/stimulus";
+import AssignRoleController from "src/decidim/controllers/assign_role/controller";
+
+describe("AssignRoleController", () => {
+  let application = null;
+  let element = null;
+  let controller = null;
+
+  beforeEach(() => {
+    document.body.innerHTML = `
+      <div data-controller="assign-role" data-role="navigation"></div>
+    `;
+
+    application = Application.start();
+    application.register("assign-role", AssignRoleController);
+
+    element = document.querySelector('[data-controller="assign-role"]');
+
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        controller = application.getControllerForElementAndIdentifier(element, "assign-role");
+        resolve();
+      }, 0);
+    });
+  });
+
+  afterEach(() => {
+    application.stop();
+    document.body.innerHTML = "";
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  describe("connect", () => {
+    it("sets the role attribute after the delay", () => {
+      controller.disconnect();
+      jest.useFakeTimers();
+
+      controller.connect();
+
+      expect(element.getAttribute("role")).toBeNull();
+      jest.advanceTimersByTime(300);
+      expect(element.getAttribute("role")).toBe("navigation");
+    });
+
+    it("returns early when no data-role is provided", () => {
+      controller.disconnect();
+
+      element.dataset.role = "";
+      const setTimeoutSpy = jest.spyOn(global, "setTimeout");
+      jest.useFakeTimers();
+
+      controller.connect();
+
+      expect(element.getAttribute("role")).toBeNull();
+      expect(setTimeoutSpy).not.toHaveBeenCalled();
+      jest.advanceTimersByTime(300);
+      expect(element.getAttribute("role")).toBeNull();
+    });
+  });
+
+  describe("disconnect", () => {
+    it("clears any pending timeout", () => {
+      controller.disconnect();
+      jest.useFakeTimers();
+
+      const clearTimeoutSpy = jest.spyOn(global, "clearTimeout");
+
+      controller.connect();
+      controller.disconnect();
+
+      expect(clearTimeoutSpy).toHaveBeenCalled();
+
+      jest.advanceTimersByTime(300);
+      expect(element.getAttribute("role")).toBeNull();
+    });
+  });
+});

data/app/packs/src/decidim/controllers/assign_role/controller.js

@@ -0,0 +1,27 @@
+import { Controller } from "@hotwired/stimulus"
+
+/**
+ * This controller is used to set a role attribute for any element where is being assigned.
+ * It requires a data-role attribute with the value of the role attribute to be set.
+ * We are using to change the value "menu" of role attribute set by a11y on div dropdown-menu-account and
+ * dropdown-menu-account-mobile which are inappropriate for accessibility
+ */
+export default class extends Controller {
+  connect() {
+    const role = this.element.dataset.role
+
+    if (!role) {
+      return
+    }
+
+    this.timeoutId = setTimeout(() => {
+      this.element.setAttribute("role", role)
+    }, 300)
+  }
+
+  disconnect() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId)
+    }
+  }
+}

data/app/packs/src/decidim/controllers/main_menu/controller.js

@@ -0,0 +1,115 @@
+import { Controller } from "@hotwired/stimulus"
+
+const OPEN_DELAY_MS = 50
+
+/**
+ * Main menu dropdown controller and traps page scroll while the menu is open.
+ *
+ * Expected markup:
+ * - The controller element has a `data-target` attribute with the menu container id.
+ * - The menu container uses `aria-hidden="true|false"` for visibility.
+ * - An optional close button exists with id `main-dropdown-summary-desktop-close`.
+ */
+export default class extends Controller {
+  connect() {
+    this.menuButton = this.element
+    this.menuContainer = document.getElementById(this.element.dataset.target)
+    this.closeButton = document.getElementById(this.element.dataset.closeButton)
+
+    if (!this.menuContainer) {
+      return;
+    }
+
+    this.handleContainerClick = this.handleContainerClick.bind(this)
+    this.handleButtonClick = this.handleButtonClick.bind(this)
+    this.handleKeydown = this.handleKeydown.bind(this)
+    this.handleCloseButtonClick = this.handleCloseButtonClick.bind(this)
+
+    this.menuButton.addEventListener("click", this.handleButtonClick)
+    this.menuContainer.addEventListener("click", this.handleContainerClick)
+
+
+    document.addEventListener("keydown", this.handleKeydown)
+    if (this.closeButton) {
+      this.closeButton.addEventListener("click", this.handleCloseButtonClick)
+    }
+  }
+
+  disconnect() {
+    if (!this.menuContainer) {
+      return;
+    }
+
+    this.menuButton.removeEventListener("click", this.handleButtonClick)
+    this.menuContainer.removeEventListener("click", this.handleContainerClick)
+    document.removeEventListener("keydown", this.handleKeydown)
+    if (this.closeButton) {
+      this.closeButton.removeEventListener("click", this.handleCloseButtonClick)
+    }
+    if (!this.isHidden()) {
+      this.closeMenu();
+    }
+  }
+
+
+  handleContainerClick(event) {
+    if (this.isHidden()) {
+      return;
+    }
+    if (event.target !== this.menuContainer) {
+      return;
+    }
+    this.closeMenu()
+  }
+
+  handleButtonClick() {
+    if (!this.isHidden()) {
+      return;
+    }
+
+    setTimeout(() => {
+      this.openMenu()
+      window.scrollTo({ top: 0, behavior: "smooth" })
+    }, OPEN_DELAY_MS)
+  }
+
+  handleKeydown(event) {
+    if (event.key !== "Escape") {
+      return;
+    }
+    if (this.isHidden()) {
+      return;
+    }
+
+    this.closeMenu()
+  }
+
+  handleCloseButtonClick() {
+    if (this.isHidden()) {
+      return;
+    }
+
+    this.closeMenu();
+  }
+
+  isHidden() {
+    return this.menuContainer.getAttribute("aria-hidden") === "true"
+  }
+
+  openMenu() {
+    if (typeof this.previousBodyOverflow === "undefined") {
+      this.previousBodyOverflow = document.body.style.overflow;
+    }
+    document.body.style.overflow = "hidden"
+    this.element.setAttribute("aria-expanded", "true")
+    this.menuContainer.setAttribute("aria-hidden", "false")
+    this.menuContainer.setAttribute("aria-modal", "true")
+  }
+
+  closeMenu() {
+    document.body.style.overflow = this.previousBodyOverflow ?? ""
+    this.element.setAttribute("aria-expanded", "false")
+    this.menuContainer.setAttribute("aria-hidden", "true")
+    this.menuContainer.removeAttribute("aria-modal")
+  }
+}

data/app/packs/src/decidim/controllers/main_menu/main_menu.test.js

@@ -0,0 +1,185 @@
+/* global jest */
+import { Application } from "@hotwired/stimulus"
+import MainMenuController from "src/decidim/controllers/main_menu/controller"
+
+describe("MainMenuController", () => {
+  let application = null
+  let controller = null
+  let menuButton = null
+  let menuContainer = null
+  let closeButton = null
+
+  const buildDom = () => {
+    document.body.innerHTML = `
+      <button
+        data-controller="main-menu"
+        data-target="main-menu-container"
+        data-close-button="main-menu-close"
+        aria-expanded="false"
+      >
+        Menu
+      </button>
+      <div id="main-menu-container" aria-hidden="true">
+        <div id="main-menu-item"></div>
+      </div>
+      <button id="main-menu-close">Close</button>
+    `
+  }
+
+  const startController = () => new Promise((resolve) => {
+    setTimeout(() => {
+      controller = application.getControllerForElementAndIdentifier(menuButton, "main-menu")
+      resolve()
+    }, 0)
+  })
+
+  beforeEach(() => {
+    application = Application.start()
+    application.register("main-menu", MainMenuController)
+    buildDom()
+
+    menuButton = document.querySelector('[data-controller="main-menu"]')
+    menuContainer = document.getElementById("main-menu-container")
+    closeButton = document.getElementById("main-menu-close")
+
+    jest.spyOn(window, "scrollTo").mockImplementation(() => {})
+
+    return startController()
+  })
+
+  afterEach(() => {
+    application.stop()
+    document.body.innerHTML = ""
+    jest.useRealTimers()
+    jest.restoreAllMocks()
+  })
+
+  describe("connect", () => {
+    it("binds expected event listeners", () => {
+      const buttonSpy = jest.spyOn(menuButton, "addEventListener")
+      const documentSpy = jest.spyOn(document, "addEventListener")
+      const closeSpy = jest.spyOn(closeButton, "addEventListener")
+
+      controller.disconnect()
+      controller.connect()
+
+      expect(buttonSpy).toHaveBeenCalledWith("click", controller.handleButtonClick)
+      expect(documentSpy).toHaveBeenCalledWith("keydown", controller.handleKeydown)
+      expect(closeSpy).toHaveBeenCalledWith("click", controller.handleCloseButtonClick)
+    })
+
+    it("returns early when menu container is missing", async () => {
+      document.body.innerHTML = `
+        <button data-controller="main-menu" data-target="missing-menu"></button>
+      `
+
+      application.stop()
+      application = Application.start()
+      application.register("main-menu", MainMenuController)
+
+      const missingButton = document.querySelector('[data-controller="main-menu"]')
+      const missingController = await new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(application.getControllerForElementAndIdentifier(missingButton, "main-menu"))
+        }, 0)
+      })
+
+      expect(missingController.menuContainer).toBeNull()
+      expect(() => missingController.disconnect()).not.toThrow()
+    })
+  })
+
+  describe("handleButtonClick", () => {
+    it("opens the menu after the delay and scrolls to top", () => {
+      jest.useFakeTimers()
+      document.body.style.overflow = "scroll"
+
+      controller.handleButtonClick()
+      jest.advanceTimersByTime(50)
+
+      expect(menuButton.getAttribute("aria-expanded")).toBe("true")
+      expect(menuContainer.getAttribute("aria-hidden")).toBe("false")
+      expect(document.body.style.overflow).toBe("hidden")
+      expect(window.scrollTo).toHaveBeenCalledWith({ top: 0, behavior: "smooth" })
+    })
+
+    it("does nothing when menu is already open", () => {
+      jest.useFakeTimers()
+      controller.openMenu()
+
+      controller.handleButtonClick()
+      jest.advanceTimersByTime(50)
+
+      expect(window.scrollTo).not.toHaveBeenCalled()
+      expect(menuContainer.getAttribute("aria-hidden")).toBe("false")
+    })
+  })
+
+  describe("handleKeydown", () => {
+    it("closes the menu on Escape", () => {
+      document.body.style.overflow = "scroll"
+      controller.openMenu()
+
+      controller.handleKeydown({ key: "Escape" })
+
+      expect(menuButton.getAttribute("aria-expanded")).toBe("false")
+      expect(menuContainer.getAttribute("aria-hidden")).toBe("true")
+      expect(document.body.style.overflow).toBe("scroll")
+    })
+
+    it("ignores non-escape keys", () => {
+      controller.openMenu()
+
+      controller.handleKeydown({ key: "Enter" })
+
+      expect(menuContainer.getAttribute("aria-hidden")).toBe("false")
+    })
+  })
+
+  describe("handleContainerClick", () => {
+    it("closes the menu when clicking the container", () => {
+      controller.openMenu()
+
+      controller.handleContainerClick({ target: menuContainer })
+
+      expect(menuContainer.getAttribute("aria-hidden")).toBe("true")
+    })
+
+    it("does not close the menu when clicking inside the container", () => {
+      const childItem = document.getElementById("main-menu-item")
+      controller.openMenu()
+
+      controller.handleContainerClick({ target: childItem })
+
+      expect(menuContainer.getAttribute("aria-hidden")).toBe("false")
+    })
+  })
+
+  describe("handleCloseButtonClick", () => {
+    it("closes the menu when open", () => {
+      controller.openMenu()
+
+      controller.handleCloseButtonClick()
+
+      expect(menuContainer.getAttribute("aria-hidden")).toBe("true")
+    })
+  })
+
+  describe("disconnect", () => {
+    it("removes listeners and closes the menu if open", () => {
+      const buttonSpy = jest.spyOn(menuButton, "removeEventListener")
+      const documentSpy = jest.spyOn(document, "removeEventListener")
+      const closeSpy = jest.spyOn(closeButton, "removeEventListener")
+
+      document.body.style.overflow = "scroll"
+      controller.openMenu()
+      controller.disconnect()
+
+      expect(buttonSpy).toHaveBeenCalledWith("click", controller.handleButtonClick)
+      expect(documentSpy).toHaveBeenCalledWith("keydown", controller.handleKeydown)
+      expect(closeSpy).toHaveBeenCalledWith("click", controller.handleCloseButtonClick)
+      expect(menuContainer.getAttribute("aria-hidden")).toBe("true")
+      expect(document.body.style.overflow).toBe("scroll")
+    })
+  })
+})

data/app/packs/src/decidim/datepicker/generate_datepicker.js

@@ -46,13 +46,6 @@ export default function generateDatePicker(input, row, formats) {
   closeCalendar.setAttribute("class", "datepicker__close-calendar button button__transparent-secondary button__xs");
   closeCalendar.setAttribute("type", "button");
 
-  const pickCalendar = document.createElement("button");
-  pickCalendar.innerText = i18n.select;
-  pickCalendar.setAttribute("class", "datepicker__pick-calendar button button__secondary button__xs");
-  pickCalendar.setAttribute("disabled", true);
-  pickCalendar.setAttribute("type", "button");
-
-  datePickerContainer.appendChild(pickCalendar);
   datePickerContainer.appendChild(closeCalendar);
 
   dateColumn.appendChild(datePickerContainer);
@@ -103,15 +96,10 @@ export default function generateDatePicker(input, row, formats) {
   let pickedDate = null;
 
   datePicker.addEventListener("selectDate", (event) => {
-    pickCalendar.removeAttribute("disabled");
     pickedDate = event.detail;
-  });
-
-  pickCalendar.addEventListener("click", (event) => {
-    event.preventDefault();
+    prevDate = pickedDate;
 
     date.value = displayDate(datePicker.value, formats);
-    prevDate = pickedDate;
     if (input.type === "date") {
       input.value = `${pickedDate}`;
     } else if (input.type === "datetime-local") {

data/app/packs/src/decidim/editor/common/suggestion.js

@@ -183,7 +183,7 @@ export const createSuggestionRenderer = (node, { itemConverter } = {}) => () =>
 export const createNodeView = (self) => {
   return ({ node }) => {
     const dom = document.createElement("span");
-    dom.textContent = self.options.renderLabel({ options: self.options, node });
+    dom.textContent = self.options.renderText({ options: self.options, node });
 
     const { id, label } = node.attrs;
     dom.dataset.suggestion = node.type.name;

data/app/packs/src/decidim/editor/extensions/decidim_kit/index.js

@@ -43,7 +43,10 @@ export default Extension.create({
         heading: false,
         bold: false,
         orderedList: false,
-        codeBlock: false
+        codeBlock: false,
+        link: false,
+        underline: false,
+        trailingNode: false
       }),
       CharacterCount.configure(this.options.characterCount),
       Link.configure({ openOnClick: false, ...this.options.link }),

data/app/packs/src/decidim/editor/extensions/image/index.js

@@ -210,13 +210,16 @@ export default Image.extend({
             return true;
           },
 
-          handleDoubleClick() {
-            if (!editor.isActive("image")) {
-              return false;
+          handleDoubleClick(view, pos) {
+            const { state } = view;
+            const node = state.doc.nodeAt(pos);
+
+            if (node && node.type.name === "image") {
+              editor.chain().focus().imageDialog().run();
+              return true;
             }
 
-            editor.chain().focus().imageDialog().run();
-            return true;
+            return false;
           },
 
           handleDOMEvents: {