decidim-core 0.26.3 → 0.27.0.rc1

data/lib/decidim/asset_router.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Asset router provides global access to the asset routes for assets 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.
+  class AssetRouter
+    # Initializes the router.
+    #
+    # @param [ActiveStorage::Attached, ActiveStorage::Blob] The asset to route
+    #   to
+    def initialize(asset)
+      @asset = asset
+    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
+    def url(**options)
+      if asset.is_a? ActiveStorage::Attached
+        routes.rails_blob_url(asset.blob, **default_options.merge(options))
+      else
+        routes.rails_representation_url(asset, **default_options.merge(options))
+      end
+    end
+
+    private
+
+    attr_reader :asset
+
+    # Provides the route helpers depending on whether the URL is generated to
+    # the local host or an external CDN (remote).
+    #
+    # @return [Module, Decidim::EngineRouter] The correct route helpers based
+    #   on the configuration
+    def routes
+      @routes ||=
+        if remote?
+          Rails.application.routes.url_helpers
+        else
+          EngineRouter.new("main_app", {})
+        end
+    end
+
+    # Determines whether the assets call should be to a remote CDN or to the
+    # local server based on the storage options.
+    #
+    # @return [Boolean] A boolean indicating whether the assets are served
+    #   through a remote CDN
+    def remote?
+      remote_storage_options.present?
+    end
+
+    # Determines the default options to be passed to the route helper. For the
+    # remote storage, returns the remote storage options and for the local disk
+    # storage returns an empty hash.
+    #
+    # @return [Hash] The default options hash to pass to the route helper
+    def default_options
+      @default_options ||=
+        if remote?
+          remote_storage_options
+        else
+          {}
+        end
+    end
+
+    # The remote storage options when using a remote CDN. An empty hash in case
+    # using the local disk storage.
+    #
+    # @return [Hash] The remote storage options hash
+    def remote_storage_options
+      @remote_storage_options ||= {
+        host: Rails.application.secrets.dig(:storage, :cdn_host)
+      }.compact
+    end
+  end
+end

data/lib/decidim/attachment_attributes.rb

@@ -3,14 +3,14 @@
 require "active_support/concern"
 
 module Decidim
-  # A set of convenience methods to deal with attachment attributes for Virtus
+  # A set of convenience methods to deal with attachment attributes for
   # models that may set the attachment records through the original model
   # (Decidim::Attachment) or through the user submitted form data (String).
   module AttachmentAttributes
     extend ActiveSupport::Concern
 
     class_methods do
-      # Public: Mirrors Virtus' `attribute` interface to define attachment
+      # Public: Mirrors the `attribute` interface to define attachment
       # attributes for form objects.
       #
       # name - The attribute's name
@@ -20,14 +20,14 @@ module Decidim
       #
       #   attachment_attribute :photos
       #   # This will create two attributes of the following types:
-      #   #   attribute :photos, Array[String]
+      #   #   attribute :photos, Array[Integer]
       #   #   attribute :add_photos, Array
       #   # In addition, it will generate the getter method for the attribute
       #   # returning an array of the Decidim::Attachment records.
       #
       # Returns nothing.
       def attachments_attribute(name)
-        attribute name, Array[String]
+        attribute name, Array[Integer]
         attribute "add_#{name}".to_sym, Array
 
         # Define the getter method that fetches the attachment records based on
@@ -37,13 +37,13 @@ module Decidim
         define_method name do
           return instance_variable_get(variable_name) if instance_variable_defined?(variable_name)
 
-          original = instance_variable_get("@#{name}")
-          return original unless original.is_a?(Array)
+          original = @attributes[name.to_s].value_before_type_cast
+          return original if original && !original.is_a?(Array)
 
           instance_variable_set(
             variable_name,
-            original.map do |attachment|
-              if attachment.is_a?(String) || attachment.is_a?(Integer)
+            super().map do |attachment|
+              if attachment.is_a?(Integer)
                 Decidim::Attachment.find_by(id: attachment)
               else
                 attachment

data/lib/decidim/attribute_object/form.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Decidim
+  module AttributeObject
+    # This is the main Form class that provides the functionality for all core
+    # forms that take in user input from the user interface forms and converts
+    # the inputs to expected formats.
+    #
+    # This replaces the Rectify::Form classes in Decidim which used to provide
+    # similar functionality. The API provided by this class is largely
+    # compatible with `Rectify::Form`.
+    class Form
+      include Decidim::AttributeObject::Model
+      include ActiveModel::Validations
+
+      attr_reader :context
+
+      def self.mimic(model_name)
+        @model_name = model_name.to_s.underscore.to_sym
+      end
+
+      def self.mimicked_model_name
+        @model_name || infer_model_name
+      end
+
+      def self.infer_model_name
+        return :form unless name
+
+        class_name = name.split("::").last
+        return :form if class_name == "Form"
+
+        class_name.chomp("Form").underscore.to_sym
+      end
+
+      # Converts the mimicked name to ActiveModel naming.
+      def self.model_name
+        ActiveModel::Name.new(self, nil, mimicked_model_name.to_s)
+      end
+
+      def self.from_model(model)
+        form_attributes = attribute_types.keys.each_with_object({}) do |key, attrs|
+          next unless model.respond_to?(key)
+
+          value = model.send(key)
+          attrs[key] =
+            case value
+            when ActiveStorage::Attached::One
+              value.attachment.try(:blob)
+            when ActiveStorage::Attached::Many
+              value.attachments.map(&:blob)
+            else
+              value
+            end
+        end
+
+        form = new(form_attributes)
+        form.map_model(model)
+
+        form
+      end
+
+      def self.from_params(params, additional_params = {})
+        params_hash = hash_from(params)
+        mimicked_params = ensure_hash(params_hash[mimicked_model_name])
+
+        attributes_hash = params_hash.merge(mimicked_params).merge(additional_params)
+
+        new(attributes_hash)
+      end
+
+      def self.hash_from(params)
+        params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
+        params.with_indifferent_access
+      end
+
+      def self.ensure_hash(object)
+        if object.is_a?(Hash)
+          object
+        else
+          {}
+        end
+      end
+
+      def persisted?
+        id.present? && id.to_i.positive?
+      end
+
+      def to_key
+        [id]
+      end
+
+      # Required for the active model naming to work correctly to form the HTML
+      # class attributes for the form elements (e.g. edit_account instead
+      # of edit_account_form).
+      def to_model
+        self
+      end
+
+      def to_param
+        id.to_s
+      end
+
+      # Use the map_model method within the form implementations to map any
+      # custom form-specific attributes from the model to the form.
+      def map_model(_model); end
+
+      def with_context(new_context)
+        @context = if new_context.is_a?(Hash)
+                     OpenStruct.new(new_context)
+                   else
+                     new_context
+                   end
+
+        attributes.each do |_name, value|
+          case value
+          when Array
+            value.each do |v|
+              next unless v.respond_to?(:with_context)
+
+              v.with_context(context)
+            end
+          else
+            next unless value.respond_to?(:with_context)
+
+            value.with_context(context)
+          end
+        end
+
+        self
+      end
+
+      # Although we are running the nested attributes validations through the
+      # NestedValidator, we still need to check for the errors in the nested
+      # attributes after the main validations are run in case the main
+      # validations are adding errors to some of the nested attributes.
+      #
+      # An example of such form is the Decidim::Budgets::Admin::ComponentForm
+      # which adds errors to the sub-attribute "settings" during its own
+      # validations. Because these errors are not added to the main form object,
+      # the main form object would be interpreted as valid without checking the
+      # sub-attribute validations.
+      #
+      # This preserves the backwards compatibility with Rectify::Form which
+      # did the validations in this order and fails the main record validation
+      # in case one of the nested attributes is not valid. This is needed e.g.
+      # for the customized component validations (e.g. Budgets component form).
+      def valid?(_context = nil)
+        super && self.class.attribute_types.none? do |name, type|
+          value = public_send(name)
+
+          if value.is_a?(Decidim::AttributeObject::Model) || (type.respond_to?(:validate_nested?) && type.validate_nested?)
+            _value_has_errors?(value)
+          else
+            false
+          end
+        end
+      end
+
+      private
+
+      def _value_has_errors?(value)
+        if value.is_a?(Array)
+          value.any? { |v| _value_has_errors?(v) }
+        elsif value.is_a?(Hash)
+          _value_has_errors?(value.values)
+        elsif value.respond_to?(:errors)
+          value.errors.any?
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/decidim/attribute_object/model.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+# Make sure the custom attributes are defined
+require "decidim/attributes"
+
+module Decidim
+  module AttributeObject
+    # This provides a dummy model implementation for replacing the Virtus models
+    # using ActiveModel. This class is a lightweight version of
+    # `ActiveModel::Model` with the `ActiveModel::Attributes` module and its
+    # overridden methods.
+    #
+    # The main purpose of this class is to provide a backwards compatible API
+    # for defining classes that hold attributes, such as the form classes.
+    #
+    # Usage:
+    #   Replace all instances of `Virtus.model` with `Decidim::AttributeObject::Model`.
+    module Model
+      extend ActiveSupport::Concern
+
+      include ActiveModel::AttributeAssignment
+      include ActiveModel::Attributes
+      include Decidim::AttributeObject::TypeMap
+
+      included do
+        extend ActiveModel::Naming
+        extend ActiveModel::Translation
+
+        # Default attributes for all models
+        attribute :id
+      end
+
+      class_methods do
+        def attribute(name, type = ActiveModel::Type::Value.new, **options)
+          typedef = AttributeObject.types.resolve(type, **options)
+
+          super(name, typedef[:type], **typedef[:options])
+
+          # Create the boolean method alias with the question mark at the end
+          # which is used in some places. This was a default behavior of
+          # Virtus but not a feature in ActiveModel::Attributes.
+          alias_method :"#{name}?", name if typedef[:type] == :boolean
+
+          # Add the nested validation in case validations module is loaded and
+          # the type reports it needs nested validations.
+          return unless include?(ActiveModel::Validations)
+
+          # The nested validator should be only added for those attributes that
+          # inherit from the AttributeObject::Model type. Otherwise this would
+          # be also added e.g. for ActiveRecord objects which would cause
+          # unexpected validation errors.
+          finaltype = attribute_types[name.to_s]
+          return unless finaltype.respond_to?(:validate_nested?)
+          return unless finaltype.validate_nested?
+
+          validates_with(
+            Decidim::AttributeObject::NestedValidator,
+            _merge_attributes([name])
+          )
+        end
+      end
+
+      def initialize(attributes = {})
+        # Parentheses needed not to pass the arguments.
+        super()
+
+        return unless attributes
+
+        # Make sure the attributes is a hash
+        base_attributes =
+          if attributes.is_a?(Hash)
+            attributes
+          else
+            attributes.to_h
+          end
+
+        # Only pass the existing attribute keys to assign_attributes
+        # The regular expression matching makes sure we also include the "multi"
+        # parameters, such as date fields passed from the view which are
+        # formatted as date(1i), date(2i), date(3i). These are converted to
+        # hashes below which are handled by the ActiveModel::Attributes types,
+        # such as :date.
+        correct_attributes = {}.tap do |attrs|
+          base_attributes.each do |k, v|
+            # Handle "multi" parameter attributes, such as date(1i), date(2i),
+            # date(3i). This converts these three attributes to a single hash
+            # attribute formatted as:
+            #   { "date" => { 1 => ..., 2 => ..., 3 => ...  } }
+            mp = k.to_s.match(/(.*)\(([0-9]+i)\)$/)
+            if mp
+              next unless attribute_names.include?(mp[1])
+
+              attrs[mp[1]] ||= {}
+              attrs[mp[1]][mp[2].to_i] = v
+            else
+              next unless attribute_names.include?(k.to_s)
+
+              attrs[k] = v
+            end
+          end
+        end
+
+        assign_attributes(correct_attributes)
+      end
+
+      # This provides backwards compatibility for accessing the attributes
+      # through symbols by calling `obj.attributes[:key]` or
+      # `obj.attributes.slice(:key1, :key2)`. In the legacy Virtus models, this
+      # returned a hash with symbol keys.
+      #
+      # Deprecated:
+      # Attributes access through symbols is deprecated and may be removed in
+      # future versions. Please refactor all your attributes calls to access the
+      # attributes through string keys.
+      def attributes
+        super.with_indifferent_access
+      end
+
+      # Convenience method for accessing the attributes through
+      # model[:attr_name] which is used in multiple places across the code.
+      def [](attribute_name)
+        public_send(attribute_name) if respond_to?(attribute_name)
+      end
+
+      # Convenience method for settings the attributes through
+      # model[:attr_name] = "foo" which is used in some places across the code.
+      def []=(attribute_name, value)
+        public_send("#{attribute_name}=", value) if respond_to?("#{attribute_name}=")
+      end
+
+      # Convenience method used in initiatives
+      def attributes_with_values
+        to_h.compact
+      end
+
+      def to_h
+        hash = attributes.to_h.symbolize_keys
+        hash.delete(:id) if hash.has_key?(:id) && hash[:id].blank?
+
+        hash
+      end
+
+      # The to_hash alias is needed for the as_json call which calls this method
+      # if defined.
+      alias to_hash to_h
+    end
+  end
+end

data/lib/decidim/attribute_object/nested_validator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module AttributeObject
+    class NestedValidator < ActiveModel::EachValidator # :nodoc:
+      def validate_each(record, attribute, value)
+        value = value.values if value.is_a?(Hash)
+        return unless Array(value).reject { |r| valid_object?(r) }.any?
+
+        record.errors.add(attribute, :invalid, **options.merge(value: value))
+      end
+
+      private
+
+      def valid_object?(record)
+        return true unless record.respond_to?(:valid?)
+
+        record.valid?
+      end
+    end
+  end
+end

data/lib/decidim/attribute_object/type_map.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  module AttributeObject
+    # Backwards compatibility for legacy types. Provides accessors for the
+    # legacy Virtus type classes that are mapped to ActiveModel types.
+    module TypeMap
+      # rubocop:disable Naming/ConstantName
+      Boolean = :boolean
+      Decimal = :decimal
+      # rubocop:enable Naming/ConstantName
+    end
+  end
+end

data/lib/decidim/attribute_object/type_resolver.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Make sure the custom attributes are defined
+require "decidim/attributes"
+
+module Decidim
+  module AttributeObject
+    # This resolves the ActiveModel::Attributes types from the Decidim's own
+    # type definitions format inspired by Virtus.
+    class TypeResolver
+      def resolve(type, **options)
+        case type
+        when Symbol, ActiveModel::Type::Value
+          {
+            type: type,
+            options: options
+          }
+        when Class
+          resolve_class(type, **options)
+        when Hash
+          resolve_hash(type, **options)
+        when Array
+          resolve_array(type, **options)
+        else
+          resolve_default(type, **options)
+        end
+      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 }
+      end
+
+      private
+
+      def resolve_class(type, **options)
+        if type.include?(Decidim::AttributeObject::Model) || type <= ActiveRecord::Base
+          {
+            type: :model,
+            options: options.merge(primitive: type)
+          }
+        elsif type == Hash
+          resolve_hash({ Symbol => Object }, **options)
+        elsif type == Array
+          resolve_array(Array[Object], **options)
+        else
+          resolve_default(type, **options)
+        end
+      end
+
+      def resolve_hash(type, **options)
+        key_type = type.keys.first || Symbol
+        val_type = type.values.first || Object
+        options[:default] ||= {}
+
+        {
+          type: :hash,
+          options: options.merge(key_type: key_type, value_type: val_type)
+        }
+      end
+
+      def resolve_array(type, **options)
+        options[:default] ||= []
+
+        {
+          type: :array,
+          options: options.merge(value_type: type.first)
+        }
+      end
+
+      def resolve_default(type, **options)
+        type_symbol = type.to_s.underscore.to_sym
+
+        if exists?(type_symbol)
+          # Off the bat, this handles the basic types from:
+          # https://github.com/rails/rails/tree/main/activemodel/lib/active_model/type
+          {
+            type: type_symbol,
+            options: options
+          }
+        else
+          {
+            type: :object,
+            options: options.merge(primitive: type)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/decidim/attribute_object.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This module provides functionality to create objects with attributes that
+  # are not attached to any database objects and have type coercions for the
+  # types of their objects. This is a similar concept as Virtus used to provide
+  # for the core objects, such as Forms and manifest classes. The programming
+  # API is backwards compatible with Virtus on most parts.
+  module AttributeObject
+    autoload :Form, "decidim/attribute_object/form"
+    autoload :Model, "decidim/attribute_object/model"
+    autoload :NestedValidator, "decidim/attribute_object/nested_validator"
+    autoload :TypeMap, "decidim/attribute_object/type_map"
+    autoload :TypeResolver, "decidim/attribute_object/type_resolver"
+
+    def self.types
+      @types ||= TypeResolver.new
+    end
+
+    def self.type(type, **options)
+      typedef = types.resolve(type, **options)
+
+      ActiveModel::Type.lookup(typedef[:type], **typedef[:options])
+    end
+  end
+end

data/lib/decidim/attributes/array.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Attributes
+    # Custom attributes value to represent an Array.
+    class Array < ActiveModel::Type::Value
+      attr_reader :value_type, :default
+
+      def initialize(value_type: ::Object, default: [])
+        @value_type = value_type
+        @default = default
+      end
+
+      def type # :nodoc:
+        :array
+      end
+
+      # The value would not be cast in case it is nil by default. We also want
+      # to cast the nil values to the default values.
+      def cast(value)
+        cast_value(value)
+      end
+
+      # The nested validator should be only added for those attributes that
+      # inherit from the AttributeObject::Model type. Otherwise this would be
+      # also added e.g. for ActiveRecord objects which would cause unexpected
+      # validation errors.
+      #
+      # The hash type inherits from the array type, so this covers both cases.
+      def validate_nested?
+        return false unless value_type.is_a?(Class)
+
+        (value_type < Decidim::AttributeObject::Model) == true
+      end
+
+      private
+
+      def cast_value(value)
+        value ||= default.dup
+
+        if value.is_a?(::Hash)
+          value = value.values
+        elsif !value.is_a?(::Array)
+          value =
+            if value.respond_to?(:to_a)
+              value.to_a
+            else
+              [value]
+            end
+        end
+
+        value.map { |v| primitive_value(v, value_type) }
+      end
+
+      def primitive_value(value, type)
+        return type.cast(value) if type.is_a?(ActiveModel::Type::Value)
+
+        Decidim::AttributeObject.type(type).cast(value)
+      end
+    end
+  end
+end

data/lib/decidim/attributes/blob.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Attributes
+    # Custom attributes value to make conversion from signed id (String) to ActiveStorage::Blob easier.
+    class Blob < ActiveModel::Type::Value
+      def type
+        :"decidim/attributes/blob"
+      end
+
+      private
+
+      def cast_value(value)
+        return value unless value.is_a?(String)
+
+        ActiveStorage::Blob.find_signed(value)
+      end
+    end
+  end
+end