decidim-core 0.22.0 → 0.23.3

data/lib/decidim/form_builder.rb

@@ -8,6 +8,7 @@ module Decidim
   class FormBuilder < FoundationRailsHelper::FormBuilder
     include ActionView::Context
     include Decidim::TranslatableAttributes
+    include Decidim::Map::Autocomplete::FormBuilder
 
     # Public: generates a check boxes input from a collection and adds help
     # text and errors.
@@ -32,7 +33,7 @@ module Decidim
     # text and errors.
     #
     # attribute       - the name of the field
-    # collection      - the collection from which we will render the check boxes
+    # collection      - the collection from which we will render the radio buttons
     # value_attribute - a Symbol or a Proc defining how to find the value attribute
     # text_attribute  - a Symbol or a Proc defining how to find the text attribute
     # options         - a Hash with options
@@ -45,6 +46,14 @@ module Decidim
     end
     # rubocop:enable Metrics/ParameterLists
 
+    def create_language_selector(locales, tabs_id, name)
+      if Decidim.available_locales.count > 4
+        language_selector_select(locales, tabs_id, name)
+      else
+        language_tabs(locales, tabs_id, name)
+      end
+    end
+
     # Public: Generates an form field for each locale.
     #
     # type - The form field's type, like `text_area` or `text_input`
@@ -60,22 +69,10 @@ module Decidim
       label_tabs = content_tag(:div, class: "label--tabs") do
         field_label = label_i18n(name, options[:label] || label_for(name))
 
-        tabs_panels = "".html_safe
-        if options[:label] != false
-          tabs_panels = content_tag(:ul, class: "tabs tabs--lang", id: tabs_id, data: { tabs: true }) do
-            locales.each_with_index.inject("".html_safe) do |string, (locale, index)|
-              string + content_tag(:li, class: tab_element_class_for("title", index)) do
-                title = I18n.with_locale(locale) { I18n.t("name", scope: "locale") }
-                element_class = nil
-                element_class = "is-tab-error" if error?(name_with_locale(name, locale))
-                tab_content_id = sanitize_tabs_selector "#{tabs_id}-#{name}-panel-#{index}"
-                content_tag(:a, title, href: "##{tab_content_id}", class: element_class)
-              end
-            end
-          end
-        end
+        language_selector = "".html_safe
+        language_selector = create_language_selector(locales, tabs_id, name) if options[:label] != false
 
-        safe_join [field_label, tabs_panels]
+        safe_join [field_label, language_selector]
       end
 
       hashtaggable = options.delete(:hashtaggable)
@@ -284,14 +281,18 @@ module Decidim
     # options       - An optional Hash with options:
     # - multiple    - Multiple mode, to allow multiple scopes selection.
     # - label       - Show label?
-    # - checkboxes_on_top - Show checked picker values on top (default) or below the picker prompt
+    # - checkboxes_on_top - Show checked picker values on top (default) or below the picker prompt (only for multiple pickers)
+    # - namespace   - prepend a custom name to the html element's DOM id.
     #
     # Also it should receive a block that returns a Hash with :url and :text for each selected scope (and for null scope for prompt)
     #
     # Returns a String.
     def scopes_picker(attribute, options = {})
-      id = "#{@object_name}_#{attribute}"
-      id = "#{self.options[:namespace]}_#{id}" if self.options.has_key?(:namespace)
+      id = if self.options.has_key?(:namespace)
+             "#{self.options[:namespace]}_#{sanitize_for_dom_selector(@object_name)}"
+           else
+             "#{sanitize_for_dom_selector(@object_name)}_#{attribute}"
+           end
 
       picker_options = {
         id: id,
@@ -309,7 +310,7 @@ module Decidim
                                    picker_options: picker_options,
                                    prompt_params: prompt_params,
                                    scopes: scopes,
-                                   checkboxes_on_top: options[:checkboxes_on_top])
+                                   values_on_top: !options[:multiple] || options[:checkboxes_on_top])
       template += error_and_help_text(attribute, options)
       template.html_safe
     end
@@ -404,11 +405,12 @@ module Decidim
     def upload(attribute, options = {})
       self.multipart = true
       options[:optional] = options[:optional].nil? ? true : options[:optional]
-      alt_text = label_for(attribute)
+      label_text = options[:label] || label_for(attribute)
+      alt_text = label_text
 
       file = object.send attribute
       template = ""
-      template += label(attribute, label_for(attribute) + required_for_attribute(attribute))
+      template += label(attribute, label_text + required_for_attribute(attribute))
       template += upload_help(attribute, options)
       template += @template.file_field @object_name, attribute
 
@@ -450,47 +452,23 @@ module Decidim
     # rubocop:enable Metrics/PerceivedComplexity
 
     def upload_help(attribute, _options = {})
-      file = object.send attribute
+      humanizer = FileValidatorHumanizer.new(object, attribute)
 
-      content_tag(:div, class: "help-text") do
-        file_size_validator = object.singleton_class.validators_on(
-          attribute
-        ).find { |validator| validator.is_a?(::ActiveModel::Validations::FileSizeValidator) }
-        if file_size_validator
-          lte = file_size_validator.options[:less_than_or_equal_to]
-          max_file_size = lte.call(nil) if lte && lte.lambda?
+      help_scope = begin
+        if humanizer.uploader.is_a?(Decidim::ImageUploader)
+          "decidim.forms.file_help.image"
+        else
+          "decidim.forms.file_help.file"
         end
+      end
 
-        help_scope = begin
-          if file.is_a?(Decidim::ImageUploader)
-            "decidim.forms.file_help.image"
-          else
-            "decidim.forms.file_help.file"
-          end
-        end
+      content_tag(:div, class: "help-text") do
         help_messages = %w(message_1 message_2)
 
         inner = "<p>#{I18n.t("explanation", scope: help_scope)}</p>".html_safe
         inner + content_tag(:ul) do
           messages = help_messages.each.map { |msg| I18n.t(msg, scope: help_scope) }
-
-          if max_file_size
-            file_size_mb = (((max_file_size / 1024 / 1024) * 100) / 100).round
-            messages << I18n.t(
-              "max_file_size",
-              megabytes: file_size_mb,
-              scope: "decidim.forms.file_validation"
-            )
-          end
-
-          if file.respond_to?(:extension_whitelist, true)
-            allowed_extensions = file.send(:extension_whitelist)
-            messages << I18n.t(
-              "allowed_file_extensions",
-              extensions: allowed_extensions.join(" "),
-              scope: "decidim.forms.file_validation"
-            )
-          end
+          messages += humanizer.messages
 
           messages.map { |msg| content_tag(:li, msg) }.join("\n").html_safe
         end.html_safe
@@ -653,7 +631,7 @@ module Decidim
     def find_validator(attribute, klass)
       return unless object.respond_to?(:_validators)
 
-      object._validators[attribute].find { |validator| validator.class == klass }
+      object._validators[attribute.to_sym].find { |validator| validator.class == klass }
     end
 
     # Private: Override method from FoundationRailsHelper to render the text of the
@@ -818,6 +796,10 @@ module Decidim
       id.tr("[", "-").tr("]", "-")
     end
 
+    def sanitize_for_dom_selector(name)
+      name.to_s.parameterize.underscore
+    end
+
     def extension_whitelist_help(extension_whitelist)
       content_tag :p, class: "extensions-help help-text" do
         safe_join([
@@ -872,5 +854,35 @@ module Decidim
 
       content_tag(:span, prefix + input + postfix, class: "row collapse")
     end
+
+    def language_selector_select(locales, tabs_id, name)
+      content_tag(:div) do
+        content_tag(:select, id: tabs_id, class: "language-change") do
+          locales.each_with_index.inject("".html_safe) do |string, (locale, index)|
+            title = if error?(name_with_locale(name, locale))
+                      I18n.with_locale(locale) { I18n.t("name_with_error", scope: "locale") }
+                    else
+                      I18n.with_locale(locale) { I18n.t("name", scope: "locale") }
+                    end
+            tab_content_id = sanitize_tabs_selector "#{tabs_id}-#{name}-panel-#{index}"
+            string + content_tag(:option, title, value: "##{tab_content_id}")
+          end
+        end
+      end
+    end
+
+    def language_tabs(locales, tabs_id, name)
+      content_tag(:ul, class: "tabs tabs--lang", id: tabs_id, data: { tabs: true }) do
+        locales.each_with_index.inject("".html_safe) do |string, (locale, index)|
+          string + content_tag(:li, class: tab_element_class_for("title", index)) do
+            title = I18n.with_locale(locale) { I18n.t("name", scope: "locale") }
+            element_class = nil
+            element_class = "is-tab-error" if error?(name_with_locale(name, locale))
+            tab_content_id = sanitize_tabs_selector "#{tabs_id}-#{name}-panel-#{index}"
+            content_tag(:a, title, href: "##{tab_content_id}", class: element_class)
+          end
+        end
+      end
+    end
   end
 end

data/lib/decidim/geocodable.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "geocoder/stores/active_record"
+
+module Decidim
+  # This concern overrides some of the Active Record functionality injected by
+  # the Geocoder gem in order to pass the geocoding searches through Decidim's
+  # own API which configures the geocoder correctly for each search. This is
+  # used when the `model.geocode` and `model.reverse_geocode` methods are called
+  # for the Active Record models.
+  #
+  # NOTE: This module is automatically loaded for all active record models in
+  #       the "decidim.geocoding_extensions" initializer. It does not need to be
+  #       included separately into any models.
+  module Geocodable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Avoid double loading Geocoder::Store::ActiveRecord since it's already
+      # loaded by this concern (below in the included block).
+      def geocoder_init(options)
+        @geocoder_options = {} unless defined?(@geocoder_options)
+        @geocoder_options.merge! options
+      end
+    end
+
+    included do
+      include Geocoder::Store::ActiveRecord
+
+      private
+
+      def do_lookup(_reverse = false)
+        RecordGeocoder.with_record(self) do
+          super
+        end
+      end
+    end
+
+    module RecordGeocoder
+      def self.with_record(record)
+        @record = record
+        yield
+      ensure
+        @record = nil
+      end
+
+      def self.utility
+        return if @record.blank?
+        return unless Decidim::Map.available?(:geocoding)
+        return unless @record.respond_to?(:organization)
+
+        Decidim::Map.geocoding(organization: @record.organization)
+      end
+
+      def self.search(query, options = {})
+        if (util = utility)
+          util.search(query, options.compact)
+        else
+          Geocoder.search(query, options)
+        end
+      end
+
+      # Make the calculation functions work within the geocoded record, e.g.
+      # `distance_to`.
+      module Calculations
+        extend Geocoder::Calculations
+      end
+    end
+
+    # Change the `Geocoder` module reference under the Geocoder::Store::Base
+    # module which initiates the geocoding searches. This allows passing the
+    # geocoding queries through Decidim's own API that configures the geocoder
+    # correctly for each query.
+    #
+    # Overrides this call with the method defined above:
+    # https://git.io/JJEpq
+    ::Geocoder::Store::Base.const_set(:Geocoder, RecordGeocoder)
+  end
+end

data/lib/decidim/has_attachments.rb

@@ -43,5 +43,15 @@ module Decidim
         documents.reject(&:attachment_collection_id?)
       end
     end
+
+    # Attachment context for the file uploaders checks (e.g. which kind of files
+    # the user is allowed to upload in this context).
+    #
+    # Override this in the model class if it is for a different context.
+    #
+    # Returns a Symbol.
+    def attachment_context
+      :participant
+    end
   end
 end

data/lib/decidim/has_private_users.rb

@@ -37,7 +37,7 @@ module Decidim
         return true unless private_space?
         return false unless user
 
-        users.include?(user)
+        participatory_space_private_users.exists?(decidim_user_id: user.id)
       end
 
       def self.public_spaces

data/lib/decidim/has_upload_validations.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module HasUploadValidations
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def validates_upload(attribute, options = {})
+        max_size = options[:max_size] || ->(record) { record.maximum_upload_size }
+
+        validates(
+          attribute,
+          file_size: { less_than_or_equal_to: max_size },
+          uploader_content_type: true
+        )
+      end
+
+      def validates_avatar(attribute = :avatar)
+        validates_upload(
+          attribute,
+          max_size: ->(record) { record.maximum_avatar_size }
+        )
+      end
+    end
+
+    def maximum_upload_size
+      Decidim.organization_settings(organization).upload_maximum_file_size
+    end
+
+    def maximum_avatar_size
+      Decidim.organization_settings(organization).upload_maximum_file_size_avatar
+    end
+  end
+end

data/lib/decidim/map.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+# Decidim configuration.
+module Decidim
+  # A module containing the map functionality for Decidim.
+  module Map
+    autoload :Autocomplete, "decidim/map/autocomplete"
+    autoload :DynamicMap, "decidim/map/dynamic_map"
+    autoload :Geocoding, "decidim/map/geocoding"
+    autoload :Provider, "decidim/map/provider"
+    autoload :StaticMap, "decidim/map/static_map"
+    autoload :Utility, "decidim/map/utility"
+    autoload :Frontend, "decidim/map/frontend"
+
+    # Public: Returns a boolean indicating whether the mapping functionality has
+    # been configured.
+    #
+    # @return [Boolean] A boolean indicating whether the mapping functionality
+    #   has been configured.
+    def self.configured?
+      configuration.present?
+    end
+
+    # Public: Returns a boolean indicating if the category of mapping services
+    # is available for this instance that the provided key represents.
+    #
+    # @param *categories [Symbol] The utility category key to check the
+    #   availability for.
+    # @return [Boolean] A boolean indicating if the category of mapping services
+    #   is available.
+    def self.available?(*categories)
+      categories.all? { |category| utility_class(category).present? }
+    end
+
+    # Public: Returns the full maps configuration hash.
+    #
+    # @return [Hash] The full map functionality configuration hash.
+    def self.configuration
+      Decidim.maps
+    end
+
+    # Public: Creates a new instance of the correct mapping utility class for
+    # the category specified by the key argument.
+    #
+    # @param category [Symbol] The utility category key for the utility to be
+    #   created.
+    # @param options [Hash] The options for the utility constructor method.
+    # @return [Decidim::Map::Utility] A new instance of the mapping utility.
+    def self.utility(category, options)
+      return unless (klass = utility_class(category))
+
+      config = utility_configuration(category)
+      options[:config] = config.except(:provider)
+      klass.new(options)
+    end
+
+    # Public: Returns the utility class module namespace for each category of
+    # map utilities. The configured utility class (through Decidim.maps) is
+    # should be under these namespaces.
+    #
+    # @return [Hash<Symbol, Module>] The modules within which the utility
+    #   classes should be defined in.
+    def self.utility_modules
+      @utility_modules ||= {}
+    end
+
+    # Public: Registers a new category of map modules.
+    #
+    # @param category [Symbol] The key for the category.
+    # @param mod [Module] The module to be assigned for the category.
+    # @return [Module] The module which was assigned for the category.
+    def self.register_category(category, mod)
+      @utility_modules ||= {}
+      @utility_modules[category] = mod
+
+      # Dynamically define the category method.
+      module_eval %{
+        def self.#{category}(options)
+          utility(:#{category}, options)
+        end
+      }, __FILE__, __LINE__ - 4
+
+      mod
+    end
+
+    # Public: Unregisters the given category of map modules. Mostly used for
+    # testing but there can be also actual use cases for this.
+    #
+    # @param category [Symbol] The key for the category.
+    # @return [Module, nil] The module which was previously assigned for the
+    #   category or nil if no module was previously assigned for it.
+    def self.unregister_category(category)
+      return unless @utility_modules
+
+      mod = @utility_modules.delete(category)
+      @utility_configuration.delete(category) if @utility_configuration
+      singleton_class.instance_eval do
+        undef_method(category) if method_defined?(category)
+      end
+      mod
+    end
+
+    # Public: Sets and returns the utility specific configuration hash which
+    # contains the prepared configuration objects for each category of
+    # utilities.
+    #
+    # For example, given the following configuration:
+    #   Decidim.configure do |config|
+    #     config.maps = {
+    #       provider: :osm,
+    #       api_key: "apikey",
+    #       global_conf: "value",
+    #       dynamic: {
+    #         tile_layer: {
+    #           url: "https://tiles.example.org/{z}/{x}/{y}.png?{foo}",
+    #           foo: "bar"
+    #         }
+    #       },
+    #       static: {
+    #         url: "https://staticmap.example.org/"
+    #       },
+    #       geocoding: {
+    #         provider: :alternative,
+    #         api_key: "gc_apikey",
+    #         host: "https://nominatim.example.org/"
+    #       }
+    #     }
+    #   end
+    #
+    # This would result in the following kind of configuration hash returned
+    # by this method:
+    #   {
+    #     dynamic: {
+    #       provider: :osm,
+    #       api_key: "apikey",
+    #       global_conf: "value",
+    #       tile_layer: {
+    #         url: "https://tiles.example.org/{z}/{x}/{y}.png?{foo}",
+    #         foo: "bar"
+    #       }
+    #     }
+    #     static: {
+    #       provider: :osm,
+    #       api_key: "apikey",
+    #       global_conf: "value",
+    #       url: "https://staticmap.example.org/"
+    #     }
+    #     geocoding: {
+    #       provider: :alternative,
+    #       api_key: "gc_apikey",
+    #       global_conf: "value",
+    #       host: "https://nominatim.example.org/"
+    #     }
+    #   }
+    #
+    # @param category [Symbol, nil] The key of the utility category for which to
+    #   fetch the configuration for. When nil, returns the whole configuration
+    #   hash.
+    # @return [Hash] The configuration hash.
+    def self.utility_configuration(category = nil)
+      @utility_configuration ||= {}.tap do |config|
+        break {} unless configuration
+
+        global_config = configuration.except(*utility_modules.keys)
+        utility_modules.keys.each do |key|
+          utility_config = configuration.fetch(key, {})
+          next if utility_config == false
+
+          unless utility_config.is_a?(Hash)
+            config[key] = global_config
+            next
+          end
+
+          config[key] = global_config.merge(utility_config)
+        end
+      end
+      return @utility_configuration[category] if category
+
+      @utility_configuration
+    end
+
+    # Public: Resets the utility configuration to its initial state so that it
+    # is reloaded when utility_configuration is called the next time. It should
+    # not be necessary to call this ever but it is useful for the tests as the
+    # configurations can change.
+    #
+    # @return [nil]
+    def self.reset_utility_configuration!
+      @utility_configuration = nil
+    end
+
+    # Public: Returns the full utility class name in the correct module
+    # namespace for the given utility category. For example, if the provider
+    # :osm is configured for the :dynamic utilities, the utility class returned
+    # by this method is `Decidim::Map::Provider::DynamicMap::Osm`.
+    #
+    # @param category [Symbol] The category of utilities. E.g. `:dynamic`.
+    # @return [Class] The configured mapping service provider key.
+    def self.utility_class(category)
+      return unless (ns = utility_modules[category])
+
+      config = utility_configuration(category)
+      return if config.blank?
+      return unless (key = config[:provider])
+
+      # Define the last part of the class name from the category provider's key,
+      # e.g. by turning `:osm` to "Osm" or `:some_service` to "SomeService".
+      subclass_name = key.to_s.camelize
+      return unless ns.const_defined?(subclass_name)
+
+      ns.const_get(subclass_name)
+    end
+  end
+end