decidim-core 0.26.4 → 0.27.0.rc1

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

data/lib/decidim/attributes/clean_string.rb

@@ -2,16 +2,22 @@
 
 module Decidim
   module Attributes
-    # Custom Virtus value to "standardize" the newline characters within strings
-    # that are sent through user entered forms. This strips out the carriage
-    # return characters from the strings in order to avoid validation mismatches
-    # with the string lengths between the frontend and the backend.
+    # Custom attributes value to "standardize" the newline characters within
+    # strings that are sent through user entered forms. This strips out the
+    # carriage return characters from the strings in order to avoid validation
+    # mismatches with the string lengths between the frontend and the backend.
     #
     # This type should be used with forms that have:
     # - A user input defined with the <textarea> element
     # - The input element having the `maxlength` attribute defined for it
     # - The backend having a maximum length validation for the input
-    class CleanString < Virtus::Attribute
+    class CleanString < ActiveModel::Type::Value
+      def type # :nodoc:
+        :"decidim/attributes/clean_string"
+      end
+
+      private
+
       # When using Windows or copying texts from existing documents, the text
       # can contain the carriage return characters (\r) that the front-end
       # character counter does not consider as actual characters. This happens
@@ -27,7 +33,7 @@ module Decidim
       # are included in the data that gets sent to the server. In order to fix
       # this mismatch, remove the carriage return characters from the text
       # using this attribute type.
-      def coerce(value)
+      def cast_value(value)
         return value unless value.is_a?(String)
 
         value.gsub(/\r/, "")

data/lib/decidim/attributes/hash.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Attributes
+    # Custom attributes value to represent a Hash.
+    class Hash < Decidim::Attributes::Array
+      attr_reader :key_type
+
+      def initialize(key_type: ::Symbol, value_type: ::Object, default: {})
+        @key_type = key_type
+        @value_type = value_type
+        @default = default
+      end
+
+      def type # :nodoc:
+        :hash
+      end
+
+      private
+
+      def cast_value(value)
+        value ||= default.dup
+        value = value.to_h if !value.is_a?(::Hash) && value.respond_to?(:to_h)
+
+        # This preserves backwards compatibility for non-hash values e.g. with
+        # the admin hero content block which expects the images container object
+        # as the default value when building the admin form.
+        return value unless value.is_a?(::Hash)
+
+        value.to_h do |k, v|
+          [primitive_value(k, key_type), primitive_value(v, value_type)]
+        end
+      end
+    end
+  end
+end

data/lib/decidim/attributes/integer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Attributes
+    # Custom attributes value to represent an Integer that is customized from
+    # the parent class to also convert records to their ID representations.
+    class Integer < ActiveModel::Type::Integer
+      private
+
+      def cast_value(value)
+        return cast_value(value.id) if value.respond_to?(:id)
+
+        super
+      end
+    end
+  end
+end

data/lib/decidim/attributes/localized_date.rb

@@ -2,26 +2,20 @@
 
 module Decidim
   module Attributes
-    # Custom Virtus value to parse a String representing a Date using
+    # Custom attributes value to parse a String representing a Date using
     # the app localization format.
-    class LocalizedDate < Virtus::Attribute
-      def coerce(value)
-        return value unless value.is_a?(String)
-
-        Date.strptime(value, I18n.t("date.formats.decidim_short"))
-      rescue ArgumentError
-        coerce_fallback(value)
-      end
-
+    class LocalizedDate < ActiveModel::Type::Date
       def type
-        Axiom::Types::Date
+        :"decidim/attributes/localized_date"
       end
 
       private
 
-      def coerce_fallback(value)
-        coercer.coercers[DateTime].public_send(type.coercion_method, value)
-      rescue Date::Error
+      def cast_value(value)
+        return value unless value.is_a?(String)
+
+        Date.strptime(value, I18n.t("date.formats.decidim_short"))
+      rescue ArgumentError
         nil
       end
     end

data/lib/decidim/attributes/model.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Attributes
+    # Custom attributes value to represent a Model.
+    class Model < Decidim::Attributes::Object
+      def type # :nodoc:
+        :model
+      end
+
+      private
+
+      def cast_value(value)
+        return value if value.is_a?(primitive)
+        return value if value.is_a?(Decidim::AttributeObject::Model)
+        return primitive.new(value) if value.is_a?(::Hash)
+        return primitive.new(value.to_h) if value.respond_to?(:to_h)
+        return primitive.new(value.attributes) if value.respond_to?(:attributes)
+
+        value
+      end
+    end
+  end
+end

data/lib/decidim/attributes/object.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Attributes
+    # Custom attributes value to represent an Object.
+    class Object < ActiveModel::Type::Value
+      attr_reader :primitive
+
+      def initialize(primitive: ::Object)
+        @primitive = primitive
+      end
+
+      def type # :nodoc:
+        :object
+      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.
+      def validate_nested?
+        return false unless primitive.is_a?(Class)
+
+        (primitive < Decidim::AttributeObject::Model) == true
+      end
+    end
+  end
+end

data/lib/decidim/attributes/symbol.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Attributes
+    # Custom attributes value to represent a Symbol.
+    class Symbol < ActiveModel::Type::Value
+      def type # :nodoc:
+        :symbol
+      end
+
+      private
+
+      def cast_value(value)
+        return value if value.is_a?(::Symbol)
+
+        value = value.to_s if !value.respond_to?(:to_sym) && value.respond_to?(:to_s)
+        return unless value.respond_to?(:to_sym)
+
+        value.to_sym
+      end
+    end
+  end
+end

data/lib/decidim/attributes/time_with_zone.rb

@@ -2,30 +2,20 @@
 
 module Decidim
   module Attributes
-    # Custom Virtus value to parse a String representing a Time using
+    # Custom attributes value to parse a String representing a Time using
     # the app TimeZone.
-    class TimeWithZone < Virtus::Attribute
-      def coerce(value)
-        return value unless value.is_a?(String)
-
-        Time.zone.strptime(value, I18n.t("time.formats.decidim_short"))
-      rescue ArgumentError
-        coerce_fallback(value)
-      end
-
+    class TimeWithZone < ActiveModel::Type::Time
       def type
-        Axiom::Types::Time
+        :"decidim/attributes/time_with_zone"
       end
 
       private
 
-      def coerce_fallback(value)
-        fallback = coercer.coercers[Time].public_send(type.coercion_method, value)
-        return Time.zone.strptime(fallback.split(".").first, "%FT%R:%S") if fallback.is_a?(String)
-        return nil unless fallback.is_a?(Time)
+      def cast_value(value)
+        return value unless value.is_a?(String)
 
-        ActiveSupport::TimeWithZone.new(fallback, Time.zone)
-      rescue ArgumentError, TypeError
+        Time.zone.strptime(value, I18n.t("time.formats.decidim_short"))
+      rescue ArgumentError
         nil
       end
     end

data/lib/decidim/attributes.rb

@@ -5,5 +5,34 @@ module Decidim
     autoload :TimeWithZone, "decidim/attributes/time_with_zone"
     autoload :LocalizedDate, "decidim/attributes/localized_date"
     autoload :CleanString, "decidim/attributes/clean_string"
+    autoload :Blob, "decidim/attributes/blob"
+    autoload :Array, "decidim/attributes/array"
+    autoload :Hash, "decidim/attributes/hash"
+    autoload :Object, "decidim/attributes/object"
+    autoload :Model, "decidim/attributes/model"
+    autoload :Symbol, "decidim/attributes/symbol"
+    autoload :Integer, "decidim/attributes/integer"
+
+    # Base types
+    ActiveModel::Type.register(:array, Decidim::Attributes::Array)
+    ActiveModel::Type.register(:hash, Decidim::Attributes::Hash)
+    ActiveModel::Type.register(:object, Decidim::Attributes::Object)
+    ActiveModel::Type.register(:model, Decidim::Attributes::Model)
+    ActiveModel::Type.register(:symbol, Decidim::Attributes::Symbol)
+
+    # Synonyms
+    ActiveModel::Type.register(:date_time, ActiveModel::Type::DateTime) # Synonym for :datetime
+
+    # Extra types
+    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/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

@@ -12,21 +12,36 @@ module Decidim
       belongs_to :author, polymorphic: true, foreign_key: "decidim_author_id", foreign_type: "decidim_author_type"
       belongs_to :user_group, foreign_key: "decidim_user_group_id", class_name: "Decidim::UserGroup", optional: true
 
-      scope :official_origin, lambda {
+      scope :with_official_origin, lambda {
         where(decidim_author_type: "Decidim::Organization")
       }
 
-      scope :user_group_origin, lambda {
+      scope :with_user_group_origin, lambda {
         where(decidim_author_type: "Decidim::UserBaseEntity")
           .where.not(decidim_user_group_id: nil)
       }
 
-      scope :citizens_origin, lambda {
+      scope :with_participants_origin, lambda {
         where(decidim_author_type: "Decidim::UserBaseEntity")
           .where(decidim_user_group_id: nil)
       }
 
-      validates :author, presence: true
+      scope :with_any_origin, lambda { |*origin_keys|
+        search_values = origin_keys.compact.compact_blank
+
+        conditions = [:official, :participants, :user_group].map do |key|
+          search_values.member?(key.to_s) ? try("with_#{key}_origin") : nil
+        end.compact
+        return self unless conditions.any?
+
+        scoped_query = where(id: conditions.shift)
+        conditions.each do |condition|
+          scoped_query = scoped_query.or(where(id: condition))
+        end
+
+        scoped_query
+      }
+
       validate :verified_user_group, :user_group_membership
       validate :author_belongs_to_organization
 
@@ -35,7 +50,7 @@ module Decidim
       #
       # user - the user to check for authorship
       def authored_by?(other_author)
-        other_author == author || other_author.respond_to?(:user_groups) && other_author.user_groups.include?(user_group)
+        other_author == author || (other_author.respond_to?(:user_groups) && other_author.user_groups.include?(user_group))
       end
 
       # Returns the normalized author, whether it's a user group or a user. Ideally this should be
@@ -70,7 +85,7 @@ module Decidim
       def author_belongs_to_organization
         return if !author || !organization
 
-        errors.add(:author, :invalid) unless author == organization || author.respond_to?(:organization) && author.organization == organization
+        errors.add(:author, :invalid) unless author == organization || (author.respond_to?(:organization) && author.organization == organization)
       end
     end
   end

data/lib/decidim/authorization_form_builder.rb

@@ -39,8 +39,8 @@ module Decidim
       return hidden_field(name) if name.to_s == "handler_name"
       return scopes_selector if name.to_s == "scope_id"
 
-      case type.name
-      when "Date", "Time"
+      case type
+      when :date, :datetime, :time, :"decidim/attributes/localized_date"
         date_field name
       else
         text_field name
@@ -54,24 +54,22 @@ module Decidim
     end
 
     def find_input_type(name)
-      found_attribute = object.class.attribute_set.detect do |attribute|
-        attribute.name.to_s == name
-      end
+      value_type = object.class.attribute_types[name]
 
-      raise "Could not find attribute #{name} in #{object.class.name}" unless found_attribute
+      raise "Could not find attribute #{name} in #{object.class.name}" unless value_type
 
-      found_attribute.type.primitive
+      value_type.type
     end
 
     def public_attributes
-      form_attributes.inject({}) do |all, attribute|
-        all.update(attribute.name => attribute.type.primitive)
+      form_attributes.inject({}) do |all, (name, value_type)|
+        all.update(name => value_type.type)
       end
     end
 
     def form_attributes
-      object.class.attribute_set.select do |attribute|
-        object.form_attributes.include?(attribute.name)
+      object.class.attribute_types.select do |key, _|
+        object.form_attributes.include?(key) || object.form_attributes.include?(key.to_sym)
       end
     end
   end

data/lib/decidim/carrier_wave_migrator_service.rb

@@ -85,16 +85,16 @@ module Decidim
             as_checksum = destination.blob.checksum
 
             logger.info "#{cw_checksum == as_checksum ? "[OK] Checksum identical:" : "[KO] Checksum different:"}" \
-              " Migrated Decidim::ContentBlock##{block.id} attachment #{image_config[:name]}" \
-              " from CW attribute #{image_config[:name]} to AS" \
-              " in Decidim::ContentBlockAttachment##{destination.record.id} file attribute"
+                        " Migrated Decidim::ContentBlock##{block.id} attachment #{image_config[:name]}" \
+                        " from CW attribute #{image_config[:name]} to AS" \
+                        " in Decidim::ContentBlockAttachment##{destination.record.id} file attribute"
           else
             logger.info "[SKIP] Pending migration of Decidim::ContentBlock##{block.id} attachment #{image_config[:name]}" \
-              " from CW attribute #{image_config[:name]} to AS" \
+                        " from CW attribute #{image_config[:name]} to AS" \
           end
         rescue StandardError
           logger.info "[ERROR] Exception checking Decidim::ContentBlock##{block.id} attachment #{image_config[:name]}" \
-            " from CW attribute #{image_config[:name]} to AS file attribute in a Decidim::ContentBlockAttachment instance #{$ERROR_INFO}"
+                      " from CW attribute #{image_config[:name]} to AS file attribute in a Decidim::ContentBlockAttachment instance #{$ERROR_INFO}"
         end
       end
     end
@@ -108,8 +108,8 @@ module Decidim
 
           if destination.attached?
             logger.info "[SKIP] Migrated Decidim::ContentBlock##{block.id} attachment #{image_config[:name]}" \
-              " from CW attribute #{image_config[:name]} to AS" \
-              " in Decidim::ContentBlockAttachment##{destination.record.id} file attribute"
+                        " from CW attribute #{image_config[:name]} to AS" \
+                        " in Decidim::ContentBlockAttachment##{destination.record.id} file attribute"
             next
           end
 
@@ -132,9 +132,9 @@ module Decidim
           as_checksum = destination.blob.checksum
 
           logger.info "[OK] Migrated - #{cw_checksum == as_checksum ? "[OK] Checksum identical:" : "[KO] Checksum different:"}" \
-            " Decidim::ContentBlock##{block.id} attachment #{image_config[:name]}" \
-            " from CW attribute #{image_config[:name]} to AS" \
-            " in Decidim::ContentBlockAttachment##{destination.record.id} file attribute" \
+                      " Decidim::ContentBlock##{block.id} attachment #{image_config[:name]}" \
+                      " from CW attribute #{image_config[:name]} to AS" \
+                      " in Decidim::ContentBlockAttachment##{destination.record.id} file attribute" \
 
           routes_mappings << { instance: "Decidim::ContentBlock##{block.id}",
                                attachment_origin_attribute: image_config[:name],
@@ -142,7 +142,7 @@ module Decidim
                                destination_path: Rails.application.routes.url_helpers.rails_blob_url(destination.blob, only_path: true) }
         rescue StandardError
           logger.info "[ERROR] Exception migrating Decidim::ContentBlock##{block.id} attachment #{image_config[:name]}" \
-            " from CW attribute #{image_config[:name]} to AS file attribute in a Decidim::ContentBlockAttachment instance #{$ERROR_INFO}"
+                      " from CW attribute #{image_config[:name]} to AS file attribute in a Decidim::ContentBlockAttachment instance #{$ERROR_INFO}"
         end
       end
     end
@@ -177,7 +177,7 @@ module Decidim
         as_checksum = copy.send(as_attribute).blob.checksum
 
         logger.info "[OK] Migrated - #{cw_checksum == as_checksum ? "[OK] Checksum identical:" : "[KO] Checksum different:"}" \
-          " #{klass}##{item.id} from CW attribute #{cw_attribute} to AS #{as_attribute} attribute"
+                    " #{klass}##{item.id} from CW attribute #{cw_attribute} to AS #{as_attribute} attribute"
 
         routes_mappings << {
           instance: "#{klass}##{item.id}",
@@ -208,8 +208,8 @@ module Decidim
           as_checksum = copy.send(as_attribute).blob.checksum
 
           logger.info "#{cw_checksum == as_checksum ? "[OK] Checksum identical:" : "[KO] Checksum different:"}" \
-            " Migrated #{klass}##{item.id} from CW attribute #{cw_attribute}" \
-            " to AS #{as_attribute} attribute"
+                      " Migrated #{klass}##{item.id} from CW attribute #{cw_attribute}" \
+                      " to AS #{as_attribute} attribute"
         else
           logger.info "[SKIP] Pending migration of #{klass}##{item.id} from CW attribute #{cw_attribute} to AS #{as_attribute} attribute"
         end
@@ -286,7 +286,7 @@ module Decidim
 
     def self.cw_file(attachment)
       if attachment.file.is_a?(CarrierWave::Storage::Fog::File)
-        URI.open(URI.parse(attachment.url))
+        URI.parse(attachment.url).open
       else
         File.open(attachment.file.file)
       end