decidim-core 0.26.7 → 0.26.9

data/lib/decidim/core.rb

@@ -97,6 +97,7 @@ module Decidim
   autoload :AttachmentAttributes, "decidim/attachment_attributes"
   autoload :CarrierWaveMigratorService, "decidim/carrier_wave_migrator_service"
   autoload :CommonPasswords, "decidim/common_passwords"
+  autoload :DependencyResolver, "decidim/dependency_resolver"
 
   include ActiveSupport::Configurable
   # Loads seeds from all engines.
@@ -484,7 +485,7 @@ module Decidim
   #
   # Returns an Array[ComponentManifest].
   def self.component_manifests
-    component_registry.manifests
+    component_registry.manifests.sort_by(&:name)
   end
 
   # Public: Finds all registered participatory space manifest's via the
@@ -625,4 +626,46 @@ module Decidim
   def self.register_assets_path(path)
     Rails.autoloaders.main.ignore(path) if Rails.configuration.autoloader == :zeitwerk
   end
+
+  # Checks if a particular decidim gem is installed and needed by this
+  # particular instance. Preferrably this happens through bundler by inspecting
+  # the Gemfile of the instance but when Decidim is used without bundler, this
+  # will check:
+  # 1. If the gem is globally available or not in the loaded specs, i.e. the
+  #    gems available in the gem install directory/directories.
+  # 2. If the gem has been required through `require "decidim/foo"`.
+  #
+  # Using bundler is suggested as it will provide more accurate results
+  # regarding what is actually needed. It will resolve all the gems listed in
+  # the Gemfile and also their dependencies which provides us accurate
+  # information whether a gem is needed by the instance or not.
+  #
+  # Note that using something like defined?(Decidim::Foo) will not work because
+  # the way the Decidim handles version definitions for each gem. After the gems
+  # are loaded, this would always return true because the version definition
+  # files of each module define that module which means it is available at
+  # runtime if the gem is installed in the gem load path. In some situations it
+  # can be installed there through other projects or through the command line
+  # even if the instance does not require that module or even through
+  # installing gems from git sources or from file paths.
+  #
+  # When a gem is reported as "needed" by the dependency resolver, this will
+  # also require that module ensuring its availability for the initialization
+  # code.
+  #
+  # @param mod [Symbol, String] The module name to check, e.g. `:proposals`.
+  # @return [Boolean] A boolean indicating whether the module is installed.
+  def self.module_installed?(mod)
+    return false unless Decidim::DependencyResolver.instance.needed?("decidim-#{mod}")
+
+    # The dependency may not be automatically loaded through the Gemfile if the
+    # user lists e.g. "decidim-core" and "decidim-budgets" in it. In this
+    # situation, "decidim-comments" is also needed because it is a dependency
+    # for "decidim-budgets".
+    require "decidim/#{mod}"
+
+    true
+  rescue LoadError
+    false
+  end
 end

data/lib/decidim/dependency_resolver.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+module Decidim
+  # The dependency resolver provides information about the Decidim module
+  # dependencies. For instance, it can be used to check if a particular Decidim
+  # module is needed by the instance or not.
+  #
+  # This is a singleton utility in order to make it perform better when it is
+  # called from different places throughout the application.
+  #
+  # @example Checking whether a module is needed by the instance
+  #   Decidim::DependencyResolver.instance.needed?("decidim-proposals")
+  class DependencyResolver
+    include Singleton
+
+    def initialize
+      @cache = []
+    end
+
+    # Finds a gem specification for the gem with the name provided as the
+    # argument.
+    #
+    # When bundler is available, searches whether the gem is listed in the
+    # Gemfile or required as a dependency for one of the gems in the Gemfile or
+    # their dependencies.
+    #
+    # When bundler is not available, gets the gem specification from the loaded
+    # specs which means any gems available in the gem install folder.
+    #
+    # @param gem [String] The name for the gem to be looked up.
+    # @return [Gem::Specification, nil] Returns the gem specification for the
+    #   given gem name. The specification implements the necessary methods for
+    #   the other checks. In both cases returns nil if the gem is not found.
+    def lookup(gem)
+      # In case the lookup method is called with a spec definition, return the
+      # definition itself.
+      return gem unless gem.is_a?(String)
+
+      if bundler?
+        lookup = Lookup.new
+        return lookup.spec(gem) if cache.include?(gem)
+
+        # Keep a local cache of the already processed gems in order to avoid
+        # double lookups.
+        lookup.find(Bundler.definition.dependencies, gem) do |dependency|
+          if potential_module?(dependency.name)
+            cache_miss = cache.exclude?(dependency.name)
+            cache << dependency.name if cache_miss
+            cache_miss
+          else
+            false
+          end
+        end
+      else
+        return unless potential_module?(gem)
+
+        Gem.loaded_specs[gem]
+      end
+    end
+
+    # Resolves the main load file path for module defined by the gem
+    # specification.
+    #
+    # @param spec [Bundler::LazySpecification, Gem::Specification, String] The
+    #   gem specification to test or the name of the gem.
+    # @return [String] A string pointing the path to the module's main load
+    #   file.
+    def module_path(spec)
+      spec = lookup(spec)
+      return unless spec
+
+      "#{spec.full_gem_path}/lib/#{spec.name.gsub("-", "/")}.rb"
+    end
+
+    # Resolves whether the module for the gem specification defines the main
+    # load file.
+    #
+    # @param spec [Bundler::LazySpecification, Gem::Specification, String] The
+    #   gem specification to test or the name of the gem.
+    # @return [Boolean] A boolean indicating if the gem defined by the spec is
+    #   available for loading.
+    def available?(spec)
+      path = module_path(spec)
+      return false unless path
+
+      File.exist?(path)
+    end
+
+    # Checks if the module for the gem speficiation has been loaded through
+    # `require "decidim/foo"`.
+    #
+    # @param spec [Bundler::LazySpecification, Gem::Specification, String] The
+    #   gem specification to test or the name of the gem.
+    # @return [Boolean] A boolean indicating if the gem defined by the spec is
+    #   loaded.
+    def loaded?(spec)
+      return false unless available?(spec)
+
+      $LOADED_FEATURES.include?(module_path(spec))
+    end
+
+    # Resolves whether the target gem is needed or not, i.e. does it need to be
+    # loaded.
+    #
+    # When bundler is available, the dependencies are resolved based on the
+    # modules defined in the Gemfile which means that the gem is always needed
+    # when it is reported as available by the resolver (i.e. defined as a
+    # dependency in the Gemfile itself or one of those gems depend on it).
+    #
+    # When bundler is not available, this will check whether the Decidim module
+    # provided by the gem has been already required/loaded or not. In this
+    # situation, it is impossible to know whether the implementer has intended
+    # the gem to be used or not, so we assume in these situations implementers
+    # will load all the gems they want before running any initializers. This
+    # means that the `require "decidim/foo"` statements have to be listed for
+    # all modules before the initialization process.
+    #
+    # @param spec [Bundler::LazySpecification, Gem::Specification, String] The
+    #   gem specification to test or the name of the gem.
+    # @return [Boolean] A boolean indicating if the gem defined by the spec is
+    #   needed.
+    def needed?(spec)
+      spec = lookup(spec)
+      return false unless spec
+
+      if bundler?
+        available?(spec)
+      else
+        loaded?(spec)
+      end
+    end
+
+    private
+
+    attr_accessor :cache
+
+    # Reports whether bundler is available.
+    #
+    # @return [Boolean] A boolean indicating if bundler is available or not.
+    def bundler?
+      defined?(Bundler)
+    end
+
+    # Only match the decidim gems. Skip the decidim-dev gem because it has
+    # "decidim" as a runtime dependency which would cause all the default
+    # gems to be always reported as available.
+    #
+    # @return [Boolean] A boolean indicating if the given gem name is a
+    #   potential Decidim module to be processed.
+    def potential_module?(name)
+      name != "decidim-dev" && name =~ /decidim(-.*)?/
+    end
+
+    # The lookup class takes care of the individual recursive lookups over a
+    # dependency tree.
+    class Lookup
+      # @param debug [Boolean] A boolean indicating if the debug mode is enabled
+      #   or not. False by default.
+      def initialize(debug: false)
+        @current_level = 0
+        return unless debug
+
+        formatter = proc do |_severity, _datetime, _progname, msg|
+          "#{msg}\n"
+        end
+        @logger = Logger.new($stdout, formatter: formatter)
+        logger.debug!
+      end
+
+      # Iterates recursively through the runtime dependencies array and their
+      # sub-dependencies to find whether the provided gem is included. This
+      # always iterates through the whole dependency tree even when the gem is
+      # already found in order not to process the same dependencies multiple
+      # times and to make the cache work correctly when calling this.
+      #
+      # @param dependencies [Array] An array of the dependencies to iterate
+      #   through.
+      # @param gem [String] The name of the gem to find.
+      # @yield [dependency] Yields each dependency to be processed to the
+      #   provided block to check if that dependency needs to be processed or
+      #   not.
+      # @yieldparam [Gem::Dependency] The runtime dependency being processed.
+      # @yieldreturn [Boolean] A boolean indicating whether this dependency
+      #   needs to be processed or not. True indicates it needs to be processed
+      #   and false indicates processing is not needed.
+      # @return [Bundler::LazySpecification, nil] The specification for the gem
+      #   or nil when it is not found.
+      def find(dependencies, gem, &block)
+        found = nil
+        dependencies.each do |dependency|
+          next unless process?(dependency, &block)
+
+          spec = spec(dependency.name)
+          next unless spec # E.g. the "bundler" gem is not in the locked gems
+
+          log(dependency)
+
+          found ||= spec if spec.name == gem
+
+          @current_level += 1
+          # Do not se the found value directly here because otherwise the
+          # recursive call would not be made if the target gem is already found.
+          sub_spec = find(spec.dependencies, gem, &block)
+          @current_level -= 1
+          found ||= sub_spec
+        end
+
+        found
+      end
+
+      # Finds a gem specification from the locked gems of the instance.
+      #
+      # Note that this does not resolve if the module is needed or not. This may
+      # also return the gem specification even when it is not listed in the
+      # Gemfile, e.g. when the Decidim gems are installed through git.
+      #
+      # @param name [String] The name of the gem to find.
+      # @return [Gem::Specification, nil] The specification for the gem
+      #   or nil if the gem is not listed in the locked gems or nil when the
+      #   returned spec is not installed in the current gem environment.
+      def spec(name)
+        sp = Bundler.definition.locked_gems.specs.find { |s| s.name == name }
+
+        # Fetching the gem through Gem.loaded_specs ensures we are not returning
+        # a lazy specification which does not respond to `#full_gem_path` which
+        # is needed for the resolver.
+        return Gem.loaded_specs[sp.name] if sp
+
+        nil
+      end
+
+      private
+
+      attr_reader :logger, :current_level
+
+      # Decides whether a dependency needs to be processed, i.e. compared
+      # whether it is the gem to be found.
+      #
+      # @param dependency [Gem::Dependency] The dependency being processed.
+      # @yield [dependency] Yields each dependency to be processed to the
+      #   provided block to check if that dependency needs to be processed or
+      #   not.
+      # @yieldparam [Gem::Dependency] The runtime dependency being processed.
+      # @yieldreturn [Boolean] A boolean indicating whether this dependency
+      #   needs to be processed or not. True indicates it needs to be processed
+      #   and false indicates processing is not needed.
+      # @return [Boolean] A boolean indicating whether the dependency needs to
+      #   be processed, i.e. compared whether it is the gem to be found.
+      def process?(dependency)
+        return false unless dependency.type == :runtime
+        return true unless block_given?
+
+        yield(dependency)
+      end
+
+      # Writes a log message for the given dependency at the current level of
+      # processing. When debugging is enabled, will produce the following kind
+      # of log output indicating the lookup tree.
+      #
+      # @example
+      #   decidim-admin
+      #   --decidim-core
+      #   ----decidim-api
+      #   decidim-assemblies
+      #   decidim-blogs
+      #   --decidim-comments
+      #
+      # @param dependency [Gem::Dependency] The dependency to be logged at the
+      #   current level of processing.
+      # @return [Boolean] A boolean indicating whether logging happened or not.
+      def log(dependency)
+        return false unless logger
+
+        logger.debug("#{"--" * current_level}#{dependency.name}")
+      end
+    end
+  end
+end

data/lib/decidim/endorsable.rb

@@ -21,7 +21,7 @@ module Decidim
         if user_group
           endorsements.where(user_group: user_group).any?
         else
-          endorsements.where(author: user, user_group: nil).any?
+          endorsements.where(author: user, user_group: 0).any?
         end
       end
     end

data/lib/decidim/exporters.rb

@@ -9,6 +9,11 @@ module Decidim
     autoload :PDF, "decidim/exporters/pdf"
     autoload :ExportData, "decidim/exporters/export_data"
 
+    # Lock the export formats to one of the available exporters
+    EXPORT_FORMATS = [:JSON, :CSV, :Excel, :PDF, :FormPDF].freeze
+
+    class UnknownFormatError < StandardError; end
+
     # Necessary for the i18n normalizer to locate strings not directly invoked in views:
 
     # i18n-tasks-use t('decidim.admin.exports.formats.JSON')
@@ -19,7 +24,11 @@ module Decidim
     #
     # format - The exporter format as a string. i.e "CSV"
     def self.find_exporter(format)
-      const_get(format)
+      raise UnknownFormatError unless format.respond_to?(:to_sym)
+      raise UnknownFormatError unless EXPORT_FORMATS.include?(format.to_sym)
+      raise UnknownFormatError unless const_defined?(format.to_sym)
+
+      const_get(format.to_sym)
     end
   end
 end

data/lib/decidim/form_builder.rb

@@ -174,7 +174,6 @@ module Decidim
     #                      or 'full' (optional) (default: 'basic')
     #           :lines - The Integer to indicate how many lines should editor have (optional) (default: 10)
     #           :disabled - Whether the editor should be disabled
-    #           :editor_images - Allow attached images (optional) (default: false)
     #
     # Renders a container with both hidden field and editor container
     def editor(name, options = {})
@@ -192,9 +191,12 @@ module Decidim
         template += label(name, label_text + required_for_attribute(name)) if options.fetch(:label, true)
         template += hidden_field(name, hidden_options)
         template += content_tag(:div, nil, class: "editor-container #{"js-hashtags" if hashtaggable}", data: {
-          toolbar: toolbar,
-          disabled: options[:disabled]
-        }.merge(editor_images_options(options)), style: "height: #{lines}rem")
+                                  toolbar: toolbar,
+                                  disabled: options[:disabled],
+                                  editor_images: true,
+                                  upload_images_path: Decidim::Core::Engine.routes.url_helpers.editor_images_path,
+                                  drag_and_drop_help_text: I18n.t("drag_and_drop_help", scope: "decidim.editor_images")
+                                }, style: "height: #{lines}rem")
         template += error_for(name, options) if error?(name)
         template.html_safe
       end
@@ -908,14 +910,5 @@ module Decidim
         end
       end
     end
-
-    def editor_images_options(options)
-      return {} unless options[:editor_images]
-
-      {
-        upload_images_path: Decidim::Core::Engine.routes.url_helpers.editor_images_path,
-        drag_and_drop_help_text: I18n.t("drag_and_drop_help", scope: "decidim.editor_images")
-      }
-    end
   end
 end

data/lib/tasks/upgrade/decidim_deduplicate_endorsements.rake

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+namespace :decidim do
+  namespace :upgrade do
+    desc "Remove duplicated endorsements"
+    task fix_duplicate_endorsements: :environment do
+      logger = Logger.new($stdout)
+      logger.info("Removing duplicate endorsements...")
+      has_count = 0
+
+      columns = [:resource_type, :resource_id, :decidim_author_type, :decidim_author_id, :decidim_user_group_id]
+
+      get_duplicates(columns).each do |issue|
+        while row_count(issue) > 1
+          find_next(issue)&.destroy
+          has_count += 1
+          logger.info("Removed duplicate endorsement for #{issue.resource_type} #{issue.resource_id}")
+        end
+      end
+
+      logger.info("Patch remaining endorsements.")
+      Decidim::Endorsement.where(decidim_user_group_id: nil).update(decidim_user_group_id: 0)
+      logger.info("Process terminated, #{has_count} endorsements have been removed.")
+      logger.info("Done")
+    end
+
+    private
+
+    def get_duplicates(*columns)
+      Decidim::Endorsement.select("#{columns.join(",")}, COUNT(*)").group(columns).having("COUNT(*) > 1")
+    end
+
+    def row_count(issue)
+      Decidim::Endorsement.where(
+        resource_type: issue.resource_type,
+        resource_id: issue.resource_id,
+        decidim_author_type: issue.decidim_author_type,
+        decidim_author_id: issue.decidim_author_id,
+        decidim_user_group_id: issue.decidim_user_group_id
+      ).count
+    end
+
+    def find_next(issue)
+      Decidim::Endorsement.find_by(
+        resource_type: issue.resource_type,
+        resource_id: issue.resource_id,
+        decidim_author_type: issue.decidim_author_type,
+        decidim_author_id: issue.decidim_author_id,
+        decidim_user_group_id: issue.decidim_user_group_id
+      )
+    end
+  end
+end

data/lib/tasks/upgrade/decidim_user_moderation.rake

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+namespace :decidim do
+  namespace :upgrade do
+    namespace :moderation do
+      desc "Add all blocked users to global moderation panel"
+      task fix_blocked_user_panel: :environment do
+        Decidim::UserBlock.find_each do |blocked_user|
+          Decidim::UserModeration.where(user: blocked_user.user).first_or_create!
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: decidim-core
 version: !ruby/object:Gem::Version
-  version: 0.26.7
+  version: 0.26.9
 platform: ruby
 authors:
 - Josep Jaume Rey Peroy
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-11 00:00:00.000000000 Z
+date: 2023-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_link_to
@@ -754,28 +754,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.26.7
+        version: 0.26.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.26.7
+        version: 0.26.9
 - !ruby/object:Gem::Dependency
   name: decidim-dev
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.26.7
+        version: 0.26.9
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.26.7
+        version: 0.26.9
 description: Adds core features so other engines can hook into the framework.
 email:
 - josepjaume@gmail.com
@@ -1940,6 +1940,7 @@ files:
 - app/views/layouts/decidim/widget.html.erb
 - config/assets.rb
 - config/brakeman.ignore
+- config/environment.rb
 - config/initializers/active_support.rb
 - config/initializers/browser.rb
 - config/initializers/carrierwave.rb
@@ -2014,9 +2015,11 @@ files:
 - config/locales/sk.yml
 - config/locales/sl.yml
 - config/locales/so-SO.yml
+- config/locales/sq-AL.yml
 - config/locales/sr-CS.yml
 - config/locales/sv.yml
 - config/locales/sw-KE.yml
+- config/locales/th-TH.yml
 - config/locales/ti-ER.yml
 - config/locales/tr-TR.yml
 - config/locales/uk.yml
@@ -2221,6 +2224,7 @@ files:
 - db/migrate/20210629172525_fix_blocked_user_names_in_action_log.rb
 - db/migrate/20210730112319_create_decidim_editor_images.rb
 - db/migrate/20211126183540_add_timestamps_to_content_blocks.rb
+- db/migrate/20231027142329_change_default_value_for_decidim_endorsements.rb
 - db/seeds.rb
 - db/seeds/homepage_image.jpg
 - lib/decidim/action_authorization.rb
@@ -2436,6 +2440,7 @@ files:
 - lib/decidim/data_portability_serializers/data_portability_user_group_serializer.rb
 - lib/decidim/data_portability_serializers/data_portability_user_serializer.rb
 - lib/decidim/db/common-passwords.txt
+- lib/decidim/dependency_resolver.rb
 - lib/decidim/deprecations.rb
 - lib/decidim/diffy_extension.rb
 - lib/decidim/endorsable.rb
@@ -2577,7 +2582,9 @@ files:
 - lib/tasks/decidim_open_data_tasks.rake
 - lib/tasks/decidim_tasks.rake
 - lib/tasks/decidim_webpacker_tasks.rake
+- lib/tasks/upgrade/decidim_deduplicate_endorsements.rake
 - lib/tasks/upgrade/decidim_moderation_tasks.rake
+- lib/tasks/upgrade/decidim_user_moderation.rake
 homepage: https://github.com/decidim/decidim
 licenses:
 - AGPL-3.0