decidim-core 0.27.9 → 0.28.0.rc4

data/lib/decidim/paddable.rb

@@ -62,7 +62,7 @@ module Decidim
       # compatibilize with old versions if no salt available (less secure)
       def token
         if defined?(salt) && salt.present?
-          tokenizer = Decidim::Tokenizer.new(salt: salt)
+          tokenizer = Decidim::Tokenizer.new(salt:)
           return tokenizer.hex_digest(id)
         end
 

data/lib/decidim/participable.rb

@@ -12,23 +12,6 @@ module Decidim
                :mounted_engine, :mounted_admin_engine, :admin_extension_module, :admins_query,
                to: :class
 
-      def skip_space_slug?(method_name)
-        [
-          "edit_#{underscored_name}_path".to_sym,
-          "edit_#{underscored_name}_url".to_sym,
-          "new_#{underscored_name}_path".to_sym,
-          "new_#{underscored_name}_url".to_sym,
-          "#{underscored_name}_path".to_sym,
-          "#{underscored_name}_url".to_sym,
-          "#{underscored_name.pluralize}_path".to_sym,
-          "#{underscored_name.pluralize}_url".to_sym
-        ].include?(method_name)
-      end
-
-      def slug_param_name
-        "#{underscored_name}_slug".to_sym
-      end
-
       def mounted_params
         {
           host: organization.host,
@@ -120,7 +103,7 @@ module Decidim
       end
 
       def slug_format
-        /\A[a-zA-Z]+[a-zA-Z0-9\-]+\z/
+        /\A[a-zA-Z]+[a-zA-Z0-9-]+\z/
       end
 
       def participatory_space_manifest

data/lib/decidim/participatory_space_manifest.rb

@@ -8,7 +8,7 @@ module Decidim
   # This class handles all the logic associated to configuring a participatory
   # space, the highest level object of Decidim.
   #
-  # It's normally not used directly but through the API exposed through
+  # It is normally not used directly but through the API exposed through
   # `Decidim.register_participatory_space`.
   class ParticipatorySpaceManifest
     include ActiveModel::Model
@@ -16,9 +16,13 @@ module Decidim
 
     attribute :name, Symbol
 
-    # The ActiveRecord class name of the model we're exposing
+    # The ActiveRecord class name of the model we are exposing
     attribute :model_class_name, String
 
+    # The scope name of the content blocks associated with the participatory
+    # space
+    attribute :content_blocks_scope_name, String
+
     # The name of the named Rails route to create the url to the resource.
     # When not explicitly set, it will use the model name.
     attribute :route_name, String
@@ -39,6 +43,10 @@ module Decidim
     # probably have the form of `Decidim::<MySpace>::Permissions`.
     attribute :permissions_class_name, String, default: "Decidim::DefaultPermissions"
 
+    # The cell to use as dropdown in the breadcrumb element associated to the space.
+    # If this value is omitted or blank, no breadcrumb is displayed
+    attribute :breadcrumb_cell, String
+
     # The cell path to use to render the card of a resource.
     attribute :card, String
 
@@ -48,7 +56,7 @@ module Decidim
     attribute :stylesheet, String, default: nil
 
     # A callback that will be executed when an account is destroyed.
-    # The Proc will receive the `user` that's being destroyed.
+    # The Proc will receive the `user` that is being destroyed.
     attribute :on_destroy_account, Proc, default: nil
 
     validates :name, presence: true
@@ -133,8 +141,8 @@ module Decidim
     # block - A block that receive the components to filter out the stat.
     #
     # Returns nothing.
-    def register_stat(name, options = {}, &block)
-      stats.register(name, options, &block)
+    def register_stat(name, options = {}, &)
+      stats.register(name, options, &)
     end
 
     # Public: Registers a resource. Exposes a DSL defined by
@@ -147,8 +155,8 @@ module Decidim
     # block - A Block that will be called to set the Resource attributes.
     #
     # Returns nothing.
-    def register_resource(name, &block)
-      Decidim.register_resource(name, &block)
+    def register_resource(name, &)
+      Decidim.register_resource(name, &)
     end
 
     # Public: Registers an export artifact with a name and its properties

data/lib/decidim/participatory_space_resourceable.rb

@@ -13,7 +13,7 @@ module Decidim
   # therefore depend on a `Component`.
   #
   # The second one, `ParticipatorySpaceResourceable`, it is used for linking
-  # `ParticipatorySpaces` to each other, and therefore don't depend on a
+  # `ParticipatorySpaces` to each other, and therefore do not depend on a
   # `Component` but rather that they depend to the `Organization`.
 
   module ParticipatorySpaceResourceable
@@ -78,7 +78,7 @@ module Decidim
               from: self,
               to: resource,
               name: link_name,
-              data: data
+              data:
             )
           end
         end

data/lib/decidim/participatory_space_user.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module ParticipatorySpaceUser
+    extend ActiveSupport::Concern
+
+    ROLES = %w(admin collaborator moderator valuator).freeze
+
+    included do
+      validate :user_and_space_same_organization
+
+      belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User", optional: true
+
+      ransacker :name do
+        Arel.sql(%{("decidim_users"."name")::text})
+      end
+
+      ransacker :nickname do
+        Arel.sql(%{("decidim_users"."nickname")::text})
+      end
+
+      ransacker :email do
+        Arel.sql(%{("decidim_users"."email")::text})
+      end
+
+      ransacker :invitation_accepted_at do
+        Arel.sql(%{("decidim_users"."invitation_accepted_at")::text})
+      end
+
+      ransacker :last_sign_in_at do
+        Arel.sql(%{("decidim_users"."last_sign_in_at")::text})
+      end
+
+      def target_space_association
+        raise "Not implemented"
+      end
+
+      private
+
+      # Private: check if the process and the user have the same organization
+      def user_and_space_same_organization
+        return if !send(target_space_association) || !user
+
+        errors.add(target_space_association, :invalid) unless user.organization == send(target_space_association).organization
+      end
+    end
+  end
+end

data/lib/decidim/processes_file_locally.rb

@@ -4,7 +4,7 @@ require "active_support/concern"
 
 module Decidim
   # A concern to help when the file needs to be available locally.
-  # For example, we need to download file first if it's in AWS S3 bucket
+  # For example, we need to download file first if it is in AWS S3 bucket
   # or somewhere else than locally in the server.
   module ProcessesFileLocally
     extend ActiveSupport::Concern

data/lib/decidim/publicable.rb

@@ -46,8 +46,6 @@ module Decidim
       update!(published_at: nil)
     end
 
-    def previously_published?
-      respond_to?(:versions) && versions.where(event: "update").where("object ->> 'published_at' IS NOT NULL").any?
-    end
+    def previously_published? = respond_to?(:versions) && versions.where(event: "update").where("object ->> 'published_at' IS NOT NULL").any?
   end
 end

data/lib/decidim/query.rb

@@ -51,8 +51,8 @@ module Decidim
 
     delegate :first, to: :cached_query
 
-    def each(&block)
-      cached_query.each(&block)
+    def each(&)
+      cached_query.each(&)
     end
 
     def exists?

data/lib/decidim/query_extensions.rb

@@ -14,8 +14,8 @@ module Decidim
                  [Decidim::ParticipatoryProcesses::ParticipatoryProcessType],
                  null: true,
                  description: "Lists all participatory_processes" do
-        argument :filter, Decidim::ParticipatoryProcesses::ParticipatoryProcessInputFilter, "This argument let's you filter the results", required: false
-        argument :order, Decidim::ParticipatoryProcesses::ParticipatoryProcessInputSort, "This argument let's you order the results", required: false
+        argument :filter, Decidim::ParticipatoryProcesses::ParticipatoryProcessInputFilter, "This argument lets you filter the results", required: false
+        argument :order, Decidim::ParticipatoryProcesses::ParticipatoryProcessInputSort, "This argument lets you order the results", required: false
       end
 
       type.field :participatory_process,
@@ -64,16 +64,16 @@ module Decidim
 
     def participatory_processes(filter: {}, order: {})
       manifest = Decidim.participatory_space_manifests.select { |m| m.name == :participatory_processes }.first
-      Decidim::Core::ParticipatorySpaceListBase.new(manifest: manifest).call(object, { filter: filter, order: order }, context)
+      Decidim::Core::ParticipatorySpaceListBase.new(manifest:).call(object, { filter:, order: }, context)
     end
 
     def participatory_process(id: nil, slug: nil)
       manifest = Decidim.participatory_space_manifests.select { |m| m.name == :participatory_processes }.first
-      Decidim::Core::ParticipatorySpaceFinderBase.new(manifest: manifest).call(object, { id: id, slug: slug }, context)
+      Decidim::Core::ParticipatorySpaceFinderBase.new(manifest:).call(object, { id:, slug: }, context)
     end
 
     def component(id: {})
-      component = Decidim::Component.published.find_by(id: id)
+      component = Decidim::Component.published.find_by(id:)
       component&.organization == context[:current_organization] ? component : nil
     end
 
@@ -113,11 +113,11 @@ module Decidim
     end
 
     def user(id: nil, nickname: nil)
-      Core::UserEntityFinder.new.call(object, { id: id, nickname: nickname }, context)
+      Core::UserEntityFinder.new.call(object, { id:, nickname: }, context)
     end
 
     def users(filter: {}, order: {})
-      Core::UserEntityList.new.call(object, { filter: filter, order: order }, context)
+      Core::UserEntityList.new.call(object, { filter:, order: }, context)
     end
   end
 end

data/lib/decidim/reminder_manifest.rb

@@ -4,7 +4,7 @@ module Decidim
   # This class acts as a manifest for reminders.
   #
   # This manifest is a simple object that holds and stores reminder
-  # and it's generator class.
+  # and it is generator class.
   class ReminderManifest
     include ActiveModel::Model
     include Decidim::AttributeObject::Model
@@ -55,11 +55,11 @@ module Decidim
       end
     end
 
-    def message(key, context = nil, **extra, &block)
+    def message(key, context = nil, **extra, &)
       extra = context if extra.empty? && context.is_a?(Hash)
 
       if block_given?
-        messages.set(key, &block)
+        messages.set(key, &)
       else
         messages.render(key, context, **extra)
       end

data/lib/decidim/reminder_registry.rb

@@ -4,7 +4,7 @@ module Decidim
   # This class acts as a registry for reminders. Each reminder needs a name,
   # and a generator class, that will be used for generating the actual sendable reminders.
   # Reminder times could be used to define intervals between reminders, so that user
-  # isn't reminded too often. In addition, you can register form and command classes
+  # is not reminded too often. In addition, you can register form and command classes
   # for additional features, such as order reminders can be sent manually from the admin panel.
   # Notice that if you implement admin panel functionality, you should add 118n messages too.
   #
@@ -32,7 +32,7 @@ module Decidim
       if reminder_exists?(reminder_name)
         raise(
           ReminderAlreadyRegistered,
-          "There's a reminder already registered with the name `:#{reminder_name}`, must be unique"
+          "There is a reminder already registered with the name `:#{reminder_name}`, must be unique"
         )
       end
 

data/lib/decidim/reportable.rb

@@ -15,11 +15,25 @@ module Decidim
       scope :hidden, -> { left_outer_joins(:moderation).where.not(Decidim::Moderation.arel_table[:hidden_at].eq nil) }
       scope :not_hidden, -> { left_outer_joins(:moderation).where(Decidim::Moderation.arel_table[:hidden_at].eq nil) }
 
+      # Public: Check if the supplied user can administrate the resource
+      #
+      # Returns Boolean
+      def can_be_administered_by?(user)
+        return false if user.blank?
+        return true if user.admin?
+        return false if participatory_space.respond_to?(:user_roles) && participatory_space.user_roles(:valuator).where(user:).any?
+
+        [
+          participatory_space.moderators.exists?(id: user.id),
+          participatory_space.admins.exists?(id: user.id)
+        ].any?
+      end
+
       # Public: Check if the user has reported the reportable.
       #
       # Returns Boolean.
       def reported_by?(user)
-        reports.where(user: user).any?
+        reports.where(user:).any?
       end
 
       # Public: Checks if the reportable is hidden or not.

data/lib/decidim/resource_manifest.rb

@@ -4,7 +4,7 @@ module Decidim
   # Components inside a component can expose different Resources, these resources
   # will be used to be linked between each other and other possible components.
   #
-  # This class sets a scheme to expose these resources. It shouldn't be
+  # This class sets a scheme to expose these resources. It should not be
   # used directly, you should use `register_resource` inside a component.
   #
   # Example:
@@ -23,9 +23,12 @@ module Decidim
     # The parent component manifest
     attribute :component_manifest, Decidim::ComponentManifest
 
-    # The ActiveRecord class name of the model we're exposing
+    # The ActiveRecord class name of the model we are exposing
     attribute :model_class_name, String
 
+    # The scope name of the content blocks associated with the resource
+    attribute :content_blocks_scope_name, String
+
     # The name of the named Rails route to create the url to the resource.
     # When not explicitly set, it will use the model name.
     attribute :route_name, String
@@ -49,7 +52,7 @@ module Decidim
     # An example would be `vote` on a specific proposal, or `join` on a meeting.
     #
     # A resource can expose as many actions as it wants and the admin panel will
-    # generate a UI to handle them. There's a set of controller helpers available
+    # generate a UI to handle them. There is a set of controller helpers available
     # as well that allows checking for those permissions.
     attribute :actions, Array[String]
 

data/lib/decidim/resourceable.rb

@@ -37,7 +37,7 @@ module Decidim
       #
       # Returns an ActiveRecord::Relation.
       def linked_resources(resource_name, link_name, component_published: true)
-        scope = sibling_scope(resource_name, component_published: component_published)
+        scope = sibling_scope(resource_name, component_published:)
 
         from = scope
                .joins(:resource_links_from)
@@ -91,7 +91,7 @@ module Decidim
                 from: self,
                 to: resource,
                 name: link_name,
-                data: data
+                data:
               )
             end
           end
@@ -154,7 +154,7 @@ module Decidim
       #
       # Returns an Array of Strings.
       def linked_classes_for(component)
-        scope = where(component: component)
+        scope = where(component:)
 
         from = scope
                .joins(:resource_links_from)
@@ -165,8 +165,8 @@ module Decidim
              .where(decidim_resource_links: { to_type: name })
 
         ResourceLink
-          .where(from: from)
-          .or(ResourceLink.where(to: to))
+          .where(from:)
+          .or(ResourceLink.where(to:))
           .pluck(:from_type, :to_type)
           .flatten
           .uniq

data/lib/decidim/scopable.rb

@@ -52,7 +52,7 @@ module Decidim
 
     # Gets the children scopes of the object's scope.
     #
-    # If it's global, returns the organization's top scopes.
+    # If it is global, returns the organization's top scopes.
     #
     # Returns an ActiveRecord::Relation.
     def subscopes

data/lib/decidim/searchable.rb

@@ -7,8 +7,8 @@ module Decidim
   # A concern with the features needed when you want a model to be searchable.
   #
   # A Searchable should include this concern and declare its `searchable_fields`.
-  # You'll also need to define it as `searchable` in its resource manifest,
-  # otherwise it won't appear as possible results.
+  # You will also need to define it as `searchable` in its resource manifest,
+  # otherwise it will not appear as possible results.
   #
   # The indexing of Searchables is managed through:
   # - after_create callback configurable via `index_on_create`.
@@ -35,13 +35,26 @@ module Decidim
     end
 
     def self.searchable_resources_of_type_component
-      searchable_resources.select { |r| r.constantize.ancestors.include?(Decidim::HasComponent) }
+      searchable_resources
+        .select { |r| r.constantize.ancestors.include?(Decidim::Searchable) }
+        .reject { |r| searchable_resources_of_type_comment.keys.include?(r) }
+        .reject { |r| searchable_resources_of_type_participant.keys.include?(r) }
+        .reject { |r| searchable_resources_of_type_participatory_space.keys.include?(r) }
     end
 
     def self.searchable_resources_of_type_comment
       searchable_resources.select { |r| r == "Decidim::Comments::Comment" }
     end
 
+    def self.searchable_resources_by_type
+      [
+        searchable_resources_of_type_participant,
+        searchable_resources_of_type_participatory_space,
+        searchable_resources_of_type_component,
+        searchable_resources_of_type_comment
+      ]
+    end
+
     included do
       # Always access to this association scoping by_organization
       clazz = self
@@ -125,8 +138,8 @@ module Decidim
         content_c = I18n.transliterate(contents[:C] || "")
         content_d = I18n.transliterate(contents[:D] || "")
         {
-          content_a: content_a, content_b: content_b, content_c: content_c, content_d: content_d,
-          locale: locale,
+          content_a:, content_b:, content_c:, content_d:,
+          locale:,
           datetime: fields[:datetime],
           decidim_scope_id: fields[:decidim_scope_id],
           decidim_participatory_space_id: fields[:decidim_participatory_space_id],

data/lib/decidim/seeds.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "faker"
+require "decidim/faker/internet"
+require "decidim/faker/localized"
+
+module Decidim
+  # Base class to be inherited from the different modules' seeds classes
+  class Seeds
+    protected
+
+    def organization
+      @organization ||= Decidim::Organization.first
+    end
+
+    def admin_user
+      @admin_user ||= Decidim::User.find_by(organization:, email: "admin@example.org")
+    end
+
+    def random_scope(participatory_space:)
+      if participatory_space.scope
+        scopes = participatory_space.scope.descendants
+        global = participatory_space.scope
+      else
+        scopes = participatory_space.organization.scopes
+        global = nil
+      end
+
+      ::Faker::Boolean.boolean(true_ratio: 0.5) ? global : scopes.sample
+    end
+
+    def seeds_root = File.join(__dir__, "..", "..", "db", "seeds")
+
+    def hero_image = create_blob!(seeds_file: "city.jpeg", filename: "hero_image.jpeg", content_type: "image/jpeg")
+
+    def banner_image = create_blob!(seeds_file: "city2.jpeg", filename: "banner_image.jpeg", content_type: "image/jpeg")
+
+    def create_attachments!(attached_to:)
+      attachment_collection = create_attachment_collection(collection_for: attached_to)
+      create_attachment(attached_to:, filename: "Exampledocument.pdf", attachment_collection:)
+      create_attachment(attached_to:, filename: "city.jpeg")
+      create_attachment(attached_to:, filename: "Exampledocument.pdf")
+    end
+
+    def create_attachment(attached_to:, filename:, attachment_collection: nil)
+      content_type = {
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        pdf: "application/pdf"
+      }[filename.split(".")[1].to_sym]
+
+      Decidim::Attachment.create!(
+        title: Decidim::Faker::Localized.sentence(word_count: 2),
+        description: Decidim::Faker::Localized.sentence(word_count: 5),
+        attachment_collection:,
+        attached_to:,
+        content_type:,
+        file: create_blob!(seeds_file: filename, filename:, content_type:) # Keep after attached_to
+      )
+    end
+
+    def create_attachment_collection(collection_for:)
+      Decidim::AttachmentCollection.create!(
+        name: Decidim::Faker::Localized.word,
+        description: Decidim::Faker::Localized.sentence(word_count: 5),
+        collection_for:
+      )
+    end
+
+    def create_blob!(seeds_file:, filename:, content_type:)
+      ActiveStorage::Blob.create_and_upload!(
+        io: File.open(File.join(seeds_root, seeds_file)),
+        filename:,
+        content_type:,
+        metadata: nil
+      )
+    end
+
+    def create_category!(participatory_space:)
+      Decidim::Category.create!(
+        name: Decidim::Faker::Localized.sentence(word_count: 5),
+        description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+          Decidim::Faker::Localized.paragraph(sentence_count: 3)
+        end,
+        participatory_space:
+      )
+    end
+
+    def seed_components_manifests!(participatory_space:)
+      Decidim.component_manifests.each do |manifest|
+        manifest.seed!(participatory_space.reload)
+      end
+    end
+  end
+end

data/lib/decidim/settings_manifest.rb

@@ -82,7 +82,7 @@ module Decidim
     end
 
     # Semi-private: Attributes are an abstraction used by SettingsManifest
-    # to encapsulate behavior related to each individual settings field. Shouldn't
+    # to encapsulate behavior related to each individual settings field. Should not
     # be used from the outside.
     class Attribute
       include Decidim::AttributeObject::Model
@@ -92,6 +92,7 @@ module Decidim
         boolean: { klass: Boolean, default: false },
         integer: { klass: Integer, default: 0 },
         string: { klass: String, default: nil },
+        float: { klass: Float, default: nil },
         text: { klass: String, default: nil },
         array: { klass: Array, default: [] },
         enum: { klass: String, default: nil },
@@ -105,7 +106,7 @@ module Decidim
       attribute :preview
       attribute :default
       attribute :translated, Boolean, default: false
-      attribute :editor, Boolean, default: false
+      attribute :editor
       attribute :required, Boolean, default: false
       attribute :required_for_authorization, Boolean, default: false
       attribute :readonly
@@ -129,6 +130,12 @@ module Decidim
       def readonly?(context)
         readonly&.call(context)
       end
+
+      def editor?(context)
+        return editor.call(context) if editor.respond_to?(:call)
+
+        editor
+      end
     end
   end
 end

data/lib/decidim/social_share_service_manifest.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class represents an abstract social network to be used for sharing URLs
+  # Serves as a replacement for our usage of the social-share-button gem
+  class SocialShareServiceManifest
+    include Decidim::AttributeObject::Model
+    include ActiveModel::Validations
+
+    attribute :name, String
+    attribute :icon, String
+    attribute :share_uri, String
+    attribute :icon_color, String
+    attribute :optional_params, Array
+
+    validates :name, presence: true
+    validates :icon, presence: true
+    validates :icon_color, presence: false
+    validates :share_uri, presence: true, format: { with: /%{url}/ }
+
+    # Format a given URL to be shareable
+    # All the services gives us a controller that accepts different get parameters. As this
+    # parameters are used in an URL we need to escape them
+    #
+    # @param title [String] the title of the resource that we want to share
+    # @param args [Hash] all the parameters that will be added on the url
+    # @return [String, nil] The formatted URL or nil when some or one of the
+    #   required parameters is missing
+    def formatted_share_uri(title, args)
+      formatted_args = escape_args(args.compact)
+      format(full_share_uri(formatted_args.keys), title: url_escape(title), **formatted_args)
+    rescue KeyError
+      # This happens when all the arguments needed for the `format()` call are
+      # not provided in the `formatted_args` array. E.g. the URL of the page
+      # can be nil in some dummy views during the tests when they do not define
+      # the meta URL, i.e. `add_decidim_meta_tags` has not been called in these
+      # views or it has been called with an empty URL.
+      nil
+    end
+
+    # Path of the icon file
+    #
+    # @return [String]
+    def icon_path
+      ActionController::Base.helpers.asset_pack_path("media/images/#{icon}")
+    end
+
+    private
+
+    # Add optional parameters to a share_uri
+    # This is initially developed for Twitter, as they allow sending a Hashtag and Via as parameters
+    #
+    # @param keys [Array<Symbol>] all the parameters that this service support
+    # @return [String] the share uri with the parameters and optional parameters
+    def full_share_uri(keys)
+      return share_uri if optional_params.empty?
+
+      share_uri + (optional_params.map(&:to_sym) & keys).map { |k| "&#{k}=%{#{k}}" }.join
+    end
+
+    # Escape the values of a hash so it has characters compatible with URLs
+    #
+    # @param args [Hash] the hash with the values to be escaped
+    # @return [Hash]
+    def escape_args(args)
+      args.transform_values { |v| url_escape(v) }
+    end
+
+    # Escape a string so it has characters compatible with URLs
+    #
+    # @param string [String]  the string to be escaped
+    # @return [String]
+    def url_escape(string)
+      CGI.escape(string)
+    end
+  end
+end