decidim-core 0.28.6 → 0.29.0.rc1

data/lib/decidim/asset_router/storage.rb

@@ -6,23 +6,6 @@ module Decidim
     # saved through ActiveStorage. This handles the different cases for routing
     # to the remote routes when using an assets CDN or to local routes when
     # using the local disk storage driver.
-    #
-    # Note that when the assets are stored in a remote storage service, such as
-    # Amazon S3, Google Cloud Storage or Azure Storage, this generates the asset
-    # URL directly to the storage service itself bypassing the Rails server and
-    # saving CPU time from serving the asset redirect requests. This causes a
-    # significant performance improvement on pages that display a lot of images.
-    # It will also produce a less significant performance improvement when using
-    # the local disk storage because in this situation, the images are served
-    # using one request instead of two when served directly from the storage
-    # service rather than through the asset redirect URL.
-    #
-    # When implementing changes to the logic, please keep the remote storage
-    # options and performance implications in mind because the specs for this
-    # utility do not cover the remote storage options because the extra
-    # configuration needed to test, the service itself needed for testing and
-    # the extra dependency overhead for adding these remote storage gems when
-    # they are not needed.
     class Storage
       # Initializes the router.
       #
@@ -30,36 +13,25 @@ module Decidim
       #   to
       def initialize(asset)
         @asset = asset
-        @blob =
-          case asset
-          when ActiveStorage::Blob
-            asset
-          else
-            asset&.blob
-          end
       end
 
       # Generates the correct URL to the asset with the provided options.
       #
       # @param options The options for the URL that are the normal route options
       #   Rails route helpers accept
-      # @return [String] The URL of the asset
       def url(**options)
-        case asset
-        when ActiveStorage::Attached
-          ensure_current_host(asset.record, **options)
-          blob_url(**options)
-        when ActiveStorage::Blob
-          blob_url(**options)
-        else # ActiveStorage::VariantWithRecord, ActiveStorage::Variant
-          ensure_current_host(nil, **options)
+        if asset.is_a? ActiveStorage::Attached
+          routes.rails_blob_url(asset.blob, **default_options.merge(options))
+        elsif asset.is_a? ActiveStorage::Blob
+          routes.rails_blob_url(asset, **default_options.merge(options))
+        else
           representation_url(**options)
         end
       end
 
       private
 
-      attr_reader :asset, :blob
+      attr_reader :asset
 
       # Provides the route helpers depending on whether the URL is generated to
       # the local host or an external CDN (remote).
@@ -108,199 +80,24 @@ module Decidim
         }.compact
       end
 
-      # Most of the times the current host should be set through the controller
-      # already when the logic below is unnecessary. This logic is needed e.g.
-      # for serializers where the request context is not available.
-      #
-      # @param record The record for which to check the organization
-      # @param opts Options for building the URL
-      # @return [void]
-      def ensure_current_host(record, **opts)
-        return if asset_url_available?
-
-        options = remote? ? remote_storage_options : routes.default_url_options
-        options = options.merge(opts)
-
-        if opts[:host].blank? && record.present?
-          organization = organization_for(record)
-          options[:host] = organization.host if organization
-        end
-
-        uri =
-          if options[:protocol] == "https" || options[:scheme] == "https"
-            URI::HTTPS.build(options)
-          else
-            URI::HTTP.build(options)
-          end
-
-        ActiveStorage::Current.host = uri.to_s
-      end
-
-      # Determines the organization for the passed record.
-      #
-      # @param record The record for which to fetch the organization
-      # @return [Decidim::Organization, nil] The organization for the record or
-      #   `nil` if the organization cannot be determined
-      def organization_for(record)
-        if record.is_a?(Decidim::Organization)
-          record
-        elsif record.respond_to?(:organization)
-          record.organization
-        end
-      end
-
-      # Returns the URL for the given blob object.
-      #
-      # @param blob The blob object
-      # @param options Options for building the URL
-      # @return [String, nil] The URL to the blob object or `nil` if the blob is
-      #   not defined.
-      def blob_url(**options)
-        return unless blob
-
-        if options[:only_path] || remote? || !asset_url_available?
-          routes.rails_blob_url(blob, **default_options.merge(options))
-        else
-          blob.url(**options)
-        end
-      end
-
-      # Returns a representation URL for the asset either directly through the
-      # storage service or through the Rails representation URL in case the
-      # path URL is requested or if the asset variant has not been processed yet
-      # and is not therefore yet stored at the storage service.
-      #
-      # @return [String] The representation URL for the image variant
-      def representation_url(**options)
-        return rails_representation_url(**options) if options[:only_path] || remote?
-
-        representation_url = variant_url(**options)
-        return representation_url if representation_url.present?
-
-        # In case the representation has not been processed yet, it may not have
-        # a representation URL yet and it therefore needs to be served through
-        # the local representation URL for the first time (or until it has been
-        # processed).
-        if options[:host]
-          rails_representation_url(**options)
-        else
-          representation_url(**options.merge(only_path: true))
-        end
-      end
-
-      # Returns the local Rails representation URL meaning that the asset will
-      # be served through the service itself. This may be necessary if the asset
-      # variant (e.g. a thumbnail) has not been processed yet because the
-      # variant representation has not been requested before.
-      #
-      # Due to performance reasons it is advised to avoid requesting the assets
-      # through the Rails representation URLs when possible because that causes
-      # a lot of requests to the Rails backend and slowness to the service under
-      # heavy loads.
-      #
       # Converts the variation URLs last part to the correct file extension in
-      # case the variation has a different format than the original image. The
-      # conversion needs to be only done for the Rails representation URLs
-      # because once the image is stored at the storage service, it already has
-      # the correct file extension.
+      # case the variation has a different format than the original image.
       #
-      # @param options The options for building the URL
-      # @return [String, nil] The converted representation URL or `nil` if the
-      #   asset is not defined.
-      def rails_representation_url(**options)
-        return unless asset
-
+      # @return [String] The converted representation URL
+      def representation_url(**options)
         representation_url = routes.rails_representation_url(asset, **default_options.merge(options))
-
         variation = asset.try(:variation)
         return representation_url unless variation
 
         format = variation.try(:format)
         return representation_url unless format
-        return unless blob
 
-        original_ext = File.extname(blob.filename.to_s)
+        original_ext = File.extname(asset.blob.filename.to_s)
         return representation_url if original_ext == ".#{format}"
 
-        basename = File.basename(blob.filename.to_s, original_ext)
+        basename = File.basename(asset.blob.filename.to_s, original_ext)
         representation_url.sub(/#{basename}\.#{original_ext.tr(".", "")}$/, "#{basename}.#{format}")
       end
-
-      # Fetches the image variant's URL at the storage service if the variant
-      # has already been processed and is stored at the storage service. If the
-      # variant has not been processed yet, returns `nil` in which case the
-      # variant has to be served through the service's own representation URL
-      # causing it to be processed and stored at the storage service.
-      #
-      # @param options The options for building the URL
-      # @return [String, nil] The variant URL at the storage service or `nil` if
-      #   the variant has not been processed yet and does not yet exist at the
-      #   storage service or `nil` when the asset is not defined
-      def variant_url(**options)
-        return unless asset
-        return unless asset_url_available?
-        return unless asset_exist?
-
-        case asset
-        when ActiveStorage::VariantWithRecord
-          # This is used when `ActiveStorage.track_variants` is enabled through
-          # `config.active_storage.track_variants`. In case the variant has not
-          # been processed yet, the `#url` method would return nil.
-          #
-          # Note that if the `asset.processed?` returns `true`, the variant
-          # record has been created in the database but it does not mean that
-          # it has been uploaded to the storage service yet. Likely a bug in
-          # ActiveStorage but to be sure that the asset is uploaded to the
-          # storage service, we also check that.
-          asset.url(**options) if asset.processed?
-        else # ActiveStorage::Variant
-          # Check whether the variant exists at the storage service before
-          # returning its URL. Otherwise the URL would be returned even when the
-          # variant is not yet processed causing 404 errors for the images on
-          # the page.
-          #
-          # Note that the `ActiveStorage::Variant#url` method only accepts
-          # certain keyword arguments where as the other objects allow any
-          # keyword arguments.
-          possible_kwargs = asset.method(:url).parameters.select { |p| p[0] == :key }.map { |p| p[1] }
-          asset.url(**options.slice(*possible_kwargs))
-        end
-      end
-
-      # Determines if the asset exists at the storage service.
-      #
-      # @return [Boolean] A boolean answering the question "does this asset
-      # exist at the storage service?".
-      def asset_exist?
-        return false if asset.key.blank?
-
-        blob.service.exist?(asset.key)
-      end
-
-      # Determines if the current host is required to build the asset URL.
-      #
-      # @return [Boolean] A boolean indicating if the current host is required
-      #   to build the asset URL.
-      def current_host_required?
-        return false unless blob
-        return false unless defined?(ActiveStorage::Service::DiskService)
-
-        blob.service.is_a?(ActiveStorage::Service::DiskService)
-      end
-
-      # Determines if the asset URL can be generated.
-      #
-      # @return [Boolean] A boolean indicating if the asset URL can be
-      #   generated.
-      def asset_url_available?
-        # If the service is an external service, the URL can be generated
-        # regardless of the current host being set.
-        return true unless current_host_required?
-
-        # For the disk service, the URL can be only generated if the current
-        # host has been set.
-        ActiveStorage::Current.host.present?
-      end
     end
   end
 end

data/lib/decidim/assets/tailwind/instance.rb

@@ -21,7 +21,7 @@ module Decidim
           decidim_gems = Bundler.load.specs.select { |spec| spec.name =~ /^decidim-/ }.map(&:full_gem_path)
           content_directories = decidim_gems.push(".")
 
-          # The variable expected by tailwind is a Javascript array of strings
+          # The variable expected by tailwind is a JavaScript array of strings
           # The directory globbing with the star is done in Ruby because it was causing an infinite loop
           # when processed by Tailwind
           content_directories_as_array_of_strings = content_directories.map { |content_directory| "'#{content_directory}'" }.join(",")

data/lib/decidim/assets/tailwind/tailwind.config.js.erb

@@ -36,9 +36,9 @@ module.exports = {
       primary: withOpacity("--primary-rgb"),
       secondary: withOpacity("--secondary-rgb"),
       tertiary: withOpacity("--tertiary-rgb"),
-      success: withOpacity("--success-rgb"),
-      alert: withOpacity("--alert-rgb"),
-      warning: withOpacity("--warning-rgb"),
+      success: "#28A745",
+      alert: "#ED1C24",
+      warning: "#FFB703",
       black: "#020203",
       gray: {
         DEFAULT: "#6B7280CC", // 80% opacity
@@ -74,6 +74,11 @@ module.exports = {
       "3xl": ["32px", "40px"],
       "4xl": ["36px", "45px"],
       "5xl": ["48px", "60px"]
+    },
+    extend: {
+      transitionProperty: {
+        'top': 'top',
+      }
     }
   },
   plugins: [require("@tailwindcss/typography")]

data/lib/decidim/attribute_object/model.rb

@@ -31,8 +31,8 @@ module Decidim
       end
 
       class_methods do
-        def attribute(name, type = ActiveModel::Type::Value.new, **options)
-          typedef = AttributeObject.types.resolve(type, **options)
+        def attribute(name, type = ActiveModel::Type::Value.new, **)
+          typedef = AttributeObject.types.resolve(type, **)
 
           super(name, typedef[:type], **typedef[:options])
 

data/lib/decidim/attribute_object/type_resolver.rb

@@ -27,9 +27,7 @@ module Decidim
       end
 
       def exists?(type)
-        # This needs to be changed after upgrade to Rails 7.0 as follows:
-        # ActiveModel::Type.registry.send(:registrations).has_key?(type)
-        ActiveModel::Type.registry.send(:registrations).any? { |t| t.send(:name) == type }
+        ActiveModel::Type.registry.send(:registrations).has_key?(type)
       end
 
       private

data/lib/decidim/attribute_object.rb

@@ -17,8 +17,8 @@ module Decidim
       @types ||= TypeResolver.new
     end
 
-    def self.type(type, **options)
-      typedef = types.resolve(type, **options)
+    def self.type(type, **)
+      typedef = types.resolve(type, **)
 
       ActiveModel::Type.lookup(typedef[:type], **typedef[:options])
     end

data/lib/decidim/attributes/time_with_zone.rb

@@ -5,15 +5,6 @@ module Decidim
     # Custom attributes value to parse a String representing a Time using
     # the app TimeZone.
     class TimeWithZone < ActiveModel::Type::DateTime
-      # Date format: 2020-06-20T, 2020-06-20, 20/06/2020T or 20/06/2020
-      # Time format: 10:20, 10:20:30 or 10:20:30.123456
-      ISO_DATETIME_WITHOUT_TIMEZONE = %r{
-        \A
-        ((\d{4})-(\d\d)-(\d\d)|(\d\d)/(\d\d)/(\d{4}))(?:T|\s)
-        (\d\d):(\d\d)(:(\d\d)(?:\.(\d{1,6})\d*)?)?
-        \z
-      }x
-
       def type
         :"decidim/attributes/time_with_zone"
       end
@@ -23,17 +14,12 @@ module Decidim
       def cast_value(value)
         return value unless value.is_a?(String)
 
-        if Date._iso8601(value).present?
-          Time.zone.iso8601(value)
-        else
-          Time.zone.strptime(value, I18n.t("time.formats.decidim_short"))
-        end
+        Time.zone.strptime(value, I18n.t("time.formats.decidim_short"))
       rescue ArgumentError
         fallback = super
         return fallback unless fallback.is_a?(Time)
-        return Time.zone.parse(fallback.strftime("%F %T")) if ISO_DATETIME_WITHOUT_TIMEZONE.match?(value)
 
-        ActiveSupport::TimeWithZone.new(fallback, Time.zone)
+        Time.zone.parse(fallback.strftime("%F %T"))
       end
     end
   end

data/lib/decidim/attributes.rb

@@ -5,7 +5,6 @@ module Decidim
     autoload :TimeWithZone, "decidim/attributes/time_with_zone"
     autoload :LocalizedDate, "decidim/attributes/localized_date"
     autoload :CleanString, "decidim/attributes/clean_string"
-    autoload :RichText, "decidim/attributes/rich_text"
     autoload :Blob, "decidim/attributes/blob"
     autoload :Array, "decidim/attributes/array"
     autoload :Hash, "decidim/attributes/hash"
@@ -28,13 +27,8 @@ module Decidim
     ActiveModel::Type.register(:"decidim/attributes/time_with_zone", Decidim::Attributes::TimeWithZone)
     ActiveModel::Type.register(:"decidim/attributes/localized_date", Decidim::Attributes::LocalizedDate)
     ActiveModel::Type.register(:"decidim/attributes/clean_string", Decidim::Attributes::CleanString)
-    ActiveModel::Type.register(:"decidim/attributes/rich_text", Decidim::Attributes::RichText)
     ActiveModel::Type.register(:"decidim/attributes/blob", Decidim::Attributes::Blob)
 
-    # Overrides
-    # The overrides deletion can be omitted after upgrade to Rails 7.0 (delete this after upgrade)
-    ActiveModel::Type.registry.send(:registrations).delete_if { |r| r.send(:name) == :integer }
-
     ActiveModel::Type.register(:integer, Decidim::Attributes::Integer)
   end
 end

data/lib/decidim/authorable.rb

@@ -7,6 +7,7 @@ module Decidim
   # this latest case the Coauthorable concern should be used instead of Authorable.
   module Authorable
     extend ActiveSupport::Concern
+    include Decidim::TranslatableAttributes
 
     included do
       belongs_to :author, polymorphic: true, foreign_key: "decidim_author_id", foreign_type: "decidim_author_type"
@@ -68,6 +69,10 @@ module Decidim
         decidim_author_type == Decidim::Organization.name
       end
 
+      def author_name
+        translated_attribute(normalized_author.name)
+      end
+
       private
 
       def verified_user_group

data/lib/decidim/command.rb

@@ -10,10 +10,10 @@ module Decidim
     include ::Wisper::Publisher
     delegate :locale, to: :I18n
 
-    def self.call(*args, **kwargs, &)
+    def self.call(*, **, &)
       event_recorder = Decidim::EventRecorder.new
 
-      command = new(*args, **kwargs)
+      command = new(*, **)
       command.subscribe(event_recorder)
       command.evaluate(&) if block_given?
       command.call

data/lib/decidim/commands/create_resource.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Commands
+    class CreateResource < ::Decidim::Command
+      include Decidim::Commands::ResourceHandler
+
+      # Initializes the command.
+      # @param form [Decidim::Form] the form object to create the resource.
+      def initialize(form)
+        @form = form
+      end
+
+      # Creates the result if valid.
+      #
+      # Broadcasts :ok if successful, :invalid otherwise.
+      def call
+        return broadcast(:invalid) if invalid?
+
+        perform!
+        broadcast(:ok, resource)
+      rescue ActiveRecord::RecordInvalid
+        add_file_attribute_errors!
+        broadcast(:invalid)
+      rescue Decidim::Commands::HookError
+        broadcast(:invalid)
+      end
+
+      protected
+
+      # @usage
+      #  create_resource - Will create the resource, raising any validation errors.
+      def create_resource
+        @resource = Decidim.traceability.send(create_method, resource_class, current_user, attributes, **extra_params)
+        @resource.persisted? ? resource : raise(ActiveRecord::RecordInvalid, resource)
+      end
+
+      attr_reader :form, :resource
+
+      delegate :current_user, to: :form
+
+      def create_method
+        has_file_attributes? ? :create : :create!
+      end
+
+      # Useful for running any code that you may want to execute before creating the resource.
+      def run_before_hooks; end
+
+      # Useful for running any code that you may want to execute after creating the resource.
+      def run_after_hooks; end
+
+      private
+
+      def perform!
+        transaction do
+          run_before_hooks
+          create_resource
+          run_after_hooks
+        end
+      end
+    end
+  end
+end

data/lib/decidim/commands/destroy_resource.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Commands
+    class DestroyResource < ::Decidim::Command
+      # Initializes the command.
+      #
+      # @param resource [ActiveRecord::Base] the resource to destroy.
+      # @param current_user [Decidim::User] the current user.
+      def initialize(resource, current_user)
+        @resource = resource
+        @current_user = current_user
+      end
+
+      # Destroys the result.
+      #
+      # Broadcasts :ok if successful, :invalid otherwise.
+      def call
+        return broadcast(:invalid) if invalid?
+
+        run_before_hooks
+        destroy_resource
+        run_after_hooks
+
+        broadcast(:ok, resource)
+      rescue Decidim::Commands::HookError, StandardError
+        broadcast(:invalid)
+      end
+
+      protected
+
+      attr_reader :resource, :current_user
+
+      def invalid? = false
+
+      def destroy_resource
+        Decidim.traceability.perform_action!(
+          :delete,
+          resource,
+          current_user,
+          **extra_params
+        ) do
+          resource.destroy!
+        end
+      end
+
+      # Any extra params that you want to pass to the traceability service.
+      #
+      # @usage
+      #  def extra_params = { "visibility" => "all"}
+      #  def extra_params = { "visibility" => "public-only" }
+      #  def extra_params = { "visibility" => "admin-only" }
+      #  def extra_params
+      #    {
+      #      resource: {
+      #        title: resource.title
+      #      },
+      #      participatory_space: {
+      #        title: resource.participatory_space.title
+      #      }
+      #    }
+      #  end
+      #
+      # @return [Hash] a hash with the extra params.
+      def extra_params = {}
+
+      # Useful for running any code that you may want to execute before deleting the resource.
+      def run_before_hooks; end
+
+      # Useful for running any code that you may want to execute after deleting the resource.
+      def run_after_hooks; end
+    end
+  end
+end

data/lib/decidim/commands/hook_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Commands
+    class HookError < StandardError
+    end
+  end
+end

data/lib/decidim/commands/resource_handler.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Commands
+    module ResourceHandler
+      extend ActiveSupport::Concern
+
+      included do
+        include ::Decidim::AttachmentAttributesMethods
+
+        protected
+
+        attr_reader :form
+
+        def resource_class = raise "#{self.class.name} needs to implement #{__method__}"
+
+        # Hydrates the attributes from the form object that you need to update/create the resource.
+        #
+        # @return [Hash] a hash with the attributes.
+        def attributes
+          @attributes ||= {}.merge(form_attribute_values).merge(file_attribute_values)
+        end
+
+        def form_attribute_values
+          raise "You need to define the list of attributes to be fetched from form object fetch_form_attributes" unless defined?(:form_attributes)
+
+          form_attributes.index_with do |field|
+            form.send(field)
+          end
+        end
+
+        def file_attribute_values
+          return {} unless defined?(:file_attributes)
+
+          attachment_attributes(*file_attributes)
+        end
+
+        def has_file_attributes?
+          file_attributes.any?
+        end
+
+        def add_file_attribute_errors!
+          file_attributes.each do |field|
+            form.errors.add(field, resource.errors.messages_for(field)&.first) if resource.errors.include? field
+          end
+        end
+
+        # Any extra params that you want to pass to the traceability service.
+        #
+        # @usage
+        #  def extra_params = { "visibility" => "all"}
+        #  def extra_params = { "visibility" => "public-only" }
+        #  def extra_params = { "visibility" => "admin-only" }
+        #  def extra_params
+        #    {
+        #      resource: {
+        #        title: resource.title
+        #      },
+        #      participatory_space: {
+        #        title: resource.participatory_space.title
+        #      }
+        #    }
+        #  end
+        # @return [Hash] a hash with the extra params.
+        def extra_params = {}
+
+        delegate :invalid?, to: :form
+
+        class_attribute :form_attributes
+        self.form_attributes = []
+
+        class_attribute :file_attributes
+        self.file_attributes = []
+
+        def self.fetch_form_attributes(*fields)
+          self.form_attributes += Array(fields)
+        end
+
+        def self.fetch_file_attributes(*fields)
+          self.file_attributes += Array(fields)
+        end
+      end
+    end
+  end
+end