decidim-core 0.20.0 → 0.23.1.rc1

data/lib/decidim/exporters/pdf.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "wicked_pdf"
+
+module Decidim
+  module Exporters
+    # Exports a PDF using the provided hash, given a collection and a
+    # Serializer. This is an abstract class that should be inherited
+    # to create PDF exporters, with each PDF exporter class setting
+    # the desired template, layout and orientation.
+    #
+    class PDF < Exporter
+      # Public: Exports a PDF version of the collection by rendering
+      # the template into html and then converting it to PDF.
+      #
+      # Returns an ExportData instance.
+      def export
+        html = controller.render_to_string(
+          template: template,
+          layout: layout,
+          locals: locals
+        )
+
+        document = WickedPdf.new.pdf_from_string(html, orientation: orientation)
+
+        ExportData.new(document, "pdf")
+      end
+
+      # may be overwritten if needed
+      def orientation
+        "Portrait"
+      end
+
+      # implementing classes should return a valid ERB path here
+      def template
+        raise NotImplementedError
+      end
+
+      # implementing classes should return a valid ERB path here
+      def layout
+        raise NotImplementedError
+      end
+
+      # This method may be overwritten if the template needs more local variables
+      def locals
+        { collection: collection }
+      end
+
+      protected
+
+      def controller
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/decidim/file_validator_humanizer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class fetches the file validation conditions from the active record
+  # model objects which have specific validators and uploaders attached to them.
+  # This class is used to convert these validation conditions to a human
+  # readable format in the front-end and to simplify the code where these are
+  # needed from.
+  #
+  # This considers if the validation conditions and the uploader have been set
+  # directly to the record being validated or if they should be read from
+  # another object in case the PassthruValidator is in charge of the
+  # validations.
+  class FileValidatorHumanizer
+    def initialize(record, attribute)
+      @record = record
+      @attribute = attribute
+      @passthru_validator ||= record.singleton_class.validators_on(
+        attribute
+      ).find { |validator| validator.is_a?(PassthruValidator) }
+    end
+
+    def uploader
+      @uploader ||= passthru_uploader || record.send(attribute)
+    end
+
+    def messages
+      messages = []
+
+      if (file_size = max_file_size)
+        file_size_mb = (((file_size / 1024 / 1024) * 100) / 100).round
+        messages << I18n.t(
+          "max_file_size",
+          megabytes: file_size_mb,
+          scope: "decidim.forms.file_validation"
+        )
+      end
+
+      if (extensions = extension_whitelist)
+        messages << I18n.t(
+          "allowed_file_extensions",
+          extensions: extensions.join(" "),
+          scope: "decidim.forms.file_validation"
+        )
+      end
+
+      messages
+    end
+
+    def max_file_size
+      # First try if the record itself has a file size validator defined.
+      validator = record.singleton_class.validators_on(attribute).find do |v|
+        v.is_a?(::ActiveModel::Validations::FileSizeValidator)
+      end
+      if validator
+        lte = validator.options[:less_than_or_equal_to]
+        return lte if lte.is_a?(Numeric)
+        return lte.call(record) if lte.respond_to?(:call)
+      end
+      return unless passthru_validator
+
+      # If not, check for the same validator from the pass through record.
+      validator = passthru_validator.target_validators(attribute).find do |v|
+        v.is_a?(::ActiveModel::Validations::FileSizeValidator)
+      end
+      return unless validator
+
+      lte = validator.options[:less_than_or_equal_to]
+      return lte if lte.is_a?(Numeric)
+
+      lte.call(passthru_record) if lte.respond_to?(:call)
+    end
+
+    def extension_whitelist
+      return unless uploader.respond_to?(:extension_whitelist, true)
+
+      # It may be a private method in some uploaders which is why we need to use
+      # `#send`.
+      uploader.send(:extension_whitelist)
+    end
+
+    private
+
+    attr_reader :record, :attribute, :passthru_validator
+
+    def passthru_record
+      return unless passthru_validator
+
+      @passthru_record ||= passthru_validator.validation_record(record)
+    end
+
+    def passthru_uploader
+      return unless passthru_record
+
+      passthru_record.send(passthru_validator.target_attribute(attribute))
+    end
+  end
+end

data/lib/decidim/filter_form_builder.rb

@@ -8,7 +8,7 @@ module Decidim
     # Wrap the radio buttons collection in a custom fieldset.
     # It also renders the inputs inside its labels.
     def collection_radio_buttons(method, collection, value_method, label_method, options = {}, html_options = {})
-      fieldset_wrapper options[:legend_title] do
+      fieldset_wrapper(options[:legend_title], "#{method}_collection_radio_buttons_filter") do
         super(method, collection, value_method, label_method, options, html_options) do |builder|
           if block_given?
             yield builder
@@ -22,7 +22,7 @@ module Decidim
     # Wrap the check_boxes collection in a custom fieldset.
     # It also renders the inputs inside its labels.
     def collection_check_boxes(method, collection, value_method, label_method, options = {}, html_options = {})
-      fieldset_wrapper options[:legend_title] do
+      fieldset_wrapper(options[:legend_title], "#{method}_collection_check_boxes_filter") do
         super(method, collection, value_method, label_method, options, html_options) do |builder|
           if block_given?
             yield builder
@@ -33,23 +33,46 @@ module Decidim
       end
     end
 
+    # Wrap the dependant check_boxes in a custom fieldset.
+    # checked parent checks its children
+    def check_boxes_tree(method, collection, options = {})
+      fieldset_wrapper(options.delete(:legend_title), "#{method}_check_boxes_tree_filter") do
+        @template.render("decidim/shared/check_boxes_tree",
+                         form: self,
+                         attribute: method,
+                         collection: collection,
+                         check_boxes_tree_id: check_boxes_tree_id(method),
+                         hide_node: "false",
+                         options: options).html_safe
+      end
+    end
+
     # Wrap the category select in a custom fieldset.
-    def categories_select(method, collection, options = {})
-      fieldset_wrapper options[:legend_title] do
-        super(method, collection, options)
+    def categories_select(method, collection, options = {}, html_options = {})
+      fieldset_wrapper(options.delete(:legend_title), "#{method}_categories_select_filter") do
+        super(method, collection, options, html_options)
       end
     end
 
     # Wrap the areas select in a custom fieldset.
     def areas_select(method, collection, options = {})
-      fieldset_wrapper options[:legend_title] do
+      fieldset_wrapper(options[:legend_title], "#{method}_areas_select_filter") do
         super(method, collection, options)
       end
     end
 
+    # Wrap the custom select in a custom fieldset.
+    # Any *_select can be used as a custom_select; what changes is the superclass method,
+    # and this one knows which one has to be called, depending on the `name` provided.
+    def custom_select(name, method, collection, options = {})
+      fieldset_wrapper(options[:legend_title], "#{method}_#{name}_select_filter") do
+        send(:"#{name}_select", method, collection, options)
+      end
+    end
+
     # Wrap the scopes picker in a custom fieldset.
     def scopes_picker(method, options = { checkboxes_on_top: true })
-      fieldset_wrapper options[:legend_title] do
+      fieldset_wrapper(options[:legend_title], "#{method}_scopes_picker_filter") do
         super(method, options)
       end
     end
@@ -57,14 +80,18 @@ module Decidim
     private
 
     # Private: Renders a custom fieldset and execute the given block.
-    def fieldset_wrapper(legend_title)
-      @template.content_tag(:div, "", class: "filters__section") do
+    def fieldset_wrapper(legend_title, extra_class)
+      @template.content_tag(:div, "", class: "filters__section #{extra_class}") do
         @template.content_tag(:fieldset) do
-          @template.content_tag(:legend) do
-            @template.content_tag(:h6, legend_title, class: "heading6")
+          @template.content_tag(:legend, class: "mini-title") do
+            legend_title
           end + yield
         end
       end
     end
+
+    def check_boxes_tree_id(attribute)
+      "#{attribute}-#{object_id}"
+    end
   end
 end

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,30 +69,21 @@ 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)
       tabs_content = content_tag(:div, class: "tabs-content", data: { tabs_content: tabs_id }) do
         locales.each_with_index.inject("".html_safe) do |string, (locale, index)|
           tab_content_id = "#{tabs_id}-#{name}-panel-#{index}"
           string + content_tag(:div, class: tab_element_class_for("panel", index), id: tab_content_id) do
-            if options[:hashtaggable]
+            if hashtaggable
               hashtaggable_text_field(type, name, locale, options.merge(label: false))
+            elsif type.to_sym == :editor
+              send(type, name_with_locale(name, locale), options.merge(label: false, hashtaggable: hashtaggable))
             else
               send(type, name_with_locale(name, locale), options.merge(label: false))
             end
@@ -95,7 +95,7 @@ module Decidim
     end
 
     def translated_one_locale(type, name, locale, options = {})
-      return hashtaggable_text_field(type, name, locale, options.merge(value: options[:value])) if options[:hashtaggable]
+      return hashtaggable_text_field(type, name, locale, options) if options.delete(:hashtaggable)
 
       send(
         type,
@@ -112,6 +112,8 @@ module Decidim
     #
     # Renders form fields for each locale.
     def hashtaggable_text_field(type, name, locale, options = {})
+      options[:hashtaggable] = true if type.to_sym == :editor
+
       content_tag(:div, class: "hashtags__container") do
         if options[:value]
           send(type, name_with_locale(name, locale), options.merge(label: options[:label], value: options[:value][locale]))
@@ -175,18 +177,23 @@ module Decidim
     #
     # Renders a container with both hidden field and editor container
     def editor(name, options = {})
-      options[:toolbar] ||= "basic"
-      options[:lines] ||= 10
       options[:disabled] ||= false
-
-      content_tag(:div, class: "editor #{"hashtags__container" if options[:hashtaggable]}") do
+      toolbar = options.delete(:toolbar) || "basic"
+      lines = options.delete(:lines) || 10
+      label_text = options[:label].to_s
+      label_text = label_for(name) if label_text.blank?
+      options.delete(:required)
+      hashtaggable = options.delete(:hashtaggable)
+      hidden_options = extract_validations(name, options).merge(options)
+
+      content_tag(:div, class: "editor #{"hashtags__container" if hashtaggable}") do
         template = ""
-        template += label(name, options[:label].to_s || name) if options[:label] != false
-        template += hidden_field(name, options)
-        template += content_tag(:div, nil, class: "editor-container #{"js-hashtags" if options[:hashtaggable]}", data: {
-                                  toolbar: options[:toolbar],
+        template += label(name, label_text + required_for_attribute(name)) if options.fetch(:label, true)
+        template += hidden_field(name, hidden_options)
+        template += content_tag(:div, nil, class: "editor-container #{"js-hashtags" if hashtaggable}", data: {
+                                  toolbar: toolbar,
                                   disabled: options[:disabled]
-                                }, style: "height: #{options[:lines]}rem")
+                                }, style: "height: #{lines}rem")
         template += error_for(name, options) if error?(name)
         template.html_safe
       end
@@ -199,9 +206,10 @@ module Decidim
     # options    - An optional Hash with options:
     # - prompt   - An optional String with the text to display as prompt.
     # - disable_parents - A Boolean to disable parent categories. Defaults to `true`.
+    # html_options - HTML options for the select
     #
     # Returns a String.
-    def categories_select(name, collection, options = {})
+    def categories_select(name, collection, options = {}, html_options = {})
       options = {
         disable_parents: true
       }.merge(options)
@@ -209,13 +217,14 @@ module Decidim
       disable_parents = options[:disable_parents]
 
       selected = object.send(name)
+      selected = selected.first if selected.is_a?(Array) && selected.length > 1
       categories = categories_for_select(collection)
       disabled = if disable_parents
                    disabled_categories_for(collection)
                  else
                    []
                  end
-      html_options = {}
+
       select(name, @template.options_for_select(categories, selected: selected, disabled: disabled), options, html_options)
     end
 
@@ -226,7 +235,7 @@ module Decidim
     #              If it's areas, we sort the selectable options alphabetically.
     #
     # Returns a String.
-    def areas_select(name, collection, options = {})
+    def areas_select(name, collection, options = {}, html_options = {})
       selectables = if collection.first.is_a?(Decidim::Area)
                       assemblies = collection
                                    .map { |a| [a.name[I18n.locale.to_s], a.id] }
@@ -247,7 +256,23 @@ module Decidim
                       )
                     end
 
-      select(name, selectables, options)
+      select(name, selectables, options, html_options)
+    end
+
+    # Public: Generates a select field for resource types.
+    #
+    # name       - The name of the field (usually resource_type)
+    # collection - A collection of resource types.
+    #              The options are sorted alphabetically.
+    #
+    # Returns a String.
+    def resources_select(name, collection, options = {})
+      resources =
+        collection
+        .map { |r| [I18n.t(r.split("::").last.underscore, scope: "decidim.components.component_order_selector.order"), r] }
+        .sort
+
+      select(name, @template.options_for_select(resources, selected: options[:selected]), options)
     end
 
     # Public: Generates a picker field for scope selection.
@@ -256,14 +281,21 @@ 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 = 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: "#{@object_name}_#{attribute}",
+        id: id,
         class: "picker-#{options[:multiple] ? "multiple" : "single"}",
         name: "#{@object_name}[#{attribute}]"
       }
@@ -273,12 +305,12 @@ module Decidim
       prompt_params = yield(nil)
       scopes = selected_scopes(attribute).map { |scope| [scope, yield(scope)] }
       template = ""
-      template += label(attribute, label_for(attribute) + required_for_attribute(attribute)) unless options[:label] == false
+      template += "<label>#{label_for(attribute) + required_for_attribute(attribute)}</label>" unless options[:label] == false
       template += @template.render("decidim/scopes/scopes_picker_input",
                                    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
@@ -304,6 +336,7 @@ module Decidim
         name: options[:name] || "#{@object_name}[#{attribute}]"
       }
       picker_options[:class] += " is-invalid-input" if error?(attribute)
+      picker_options[:class] += " picker-autosort" if options[:autosort]
 
       items = object.send(attribute).collect { |item| [item, yield(item)] }
 
@@ -367,22 +400,29 @@ module Decidim
     # attribute    - The String name of the attribute to buidl the field.
     # options      - A Hash with options to build the field.
     #              * optional: Whether the file can be optional or not.
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
     def upload(attribute, options = {})
       self.multipart = true
       options[:optional] = options[:optional].nil? ? true : options[:optional]
+      alt_text = label_for(attribute)
 
       file = object.send attribute
       template = ""
       template += label(attribute, label_for(attribute) + required_for_attribute(attribute))
+      template += upload_help(attribute, options)
       template += @template.file_field @object_name, attribute
 
+      template += extension_whitelist_help(options[:extension_whitelist]) if options[:extension_whitelist].present?
+      template += image_dimensions_help(options[:dimensions_info]) if options[:dimensions_info].present?
+
       if file_is_image?(file)
         template += if file.present?
                       @template.content_tag :label, I18n.t("current_image", scope: "decidim.forms")
                     else
                       @template.content_tag :label, I18n.t("default_image", scope: "decidim.forms")
                     end
-        template += @template.link_to @template.image_tag(file.url), file.url, target: "_blank", rel: "noopener"
+        template += @template.link_to @template.image_tag(file.url, alt: alt_text), file.url, target: "_blank", rel: "noopener"
       elsif file_is_present?(file)
         template += @template.label_tag I18n.t("current_file", scope: "decidim.forms")
         template += @template.link_to file.file.filename, file.url, target: "_blank", rel: "noopener"
@@ -407,6 +447,32 @@ module Decidim
 
       template.html_safe
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def upload_help(attribute, _options = {})
+      humanizer = FileValidatorHumanizer.new(object, attribute)
+
+      help_scope = begin
+        if humanizer.uploader.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) }
+          messages += humanizer.messages
+
+          messages.map { |msg| content_tag(:li, msg) }.join("\n").html_safe
+        end.html_safe
+      end
+    end
 
     # Public: Returns the translated name for the given attribute.
     #
@@ -427,6 +493,19 @@ module Decidim
       end
     end
 
+    # Discard the pattern attribute which is not allowed for textarea elements.
+    def text_area(attribute, options = {})
+      field(attribute, options) do |opts|
+        opts.delete(:pattern)
+        @template.send(
+          :text_area,
+          @object_name,
+          attribute,
+          objectify_options(opts)
+        )
+      end
+    end
+
     private
 
     # Private: Override from FoundationRailsHelper in order to render
@@ -490,6 +569,7 @@ module Decidim
       validation_options = {}
       validation_options[:pattern] = "^(.|[\n\r]){#{min_length},#{max_length}}$" if min_length.to_i.positive? || max_length.to_i.positive?
       validation_options[:required] = options[:required] || attribute_required?(attribute)
+      validation_options[:minlength] ||= min_length if min_length.to_i.positive?
       validation_options[:maxlength] ||= max_length if max_length.to_i.positive?
       validation_options
     end
@@ -528,9 +608,17 @@ module Decidim
     # Returns an Integer or Nil.
     def length_for_attribute(attribute, type)
       length_validator = find_validator(attribute, ActiveModel::Validations::LengthValidator)
-      return unless length_validator
+      return length_validator.options[type] if length_validator
+
+      length_validator = find_validator(attribute, ProposalLengthValidator)
+      if length_validator
+        length = length_validator.options[type]
+        return length.call(object) if length.respond_to?(:call)
 
-      length_validator.options[type]
+        return length
+      end
+
+      nil
     end
 
     # Private: Finds a validator.
@@ -542,7 +630,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
@@ -663,9 +751,20 @@ module Decidim
 
     def required_for_attribute(attribute)
       if attribute_required?(attribute)
-        return content_tag(:abbr, "*", title: I18n.t("required", scope: "forms"),
-                                       data: { tooltip: true, disable_hover: false }, 'aria-haspopup': true,
-                                       class: "label-required").html_safe
+        visible_title = content_tag(:span, "*", "aria-hidden": true)
+        screenreader_title = content_tag(
+          :span,
+          I18n.t("required", scope: "forms"),
+          class: "show-for-sr"
+        )
+        return content_tag(
+          :span,
+          visible_title + screenreader_title,
+          title: I18n.t("required", scope: "forms"),
+          data: { tooltip: true, disable_hover: false, keep_on_hover: true },
+          "aria-haspopup": true,
+          class: "label-required"
+        ).html_safe
       end
       "".html_safe
     end
@@ -679,6 +778,15 @@ module Decidim
       selected
     end
 
+    # Private: Returns the help text and error tags at the end of the field.
+    # Modified to change the tag to a valid HTML tag inside the <label> element.
+    def error_and_help_text(attribute, options = {})
+      html = ""
+      html += content_tag(:span, options[:help_text], class: "help-text") if options[:help_text]
+      html += error_for(attribute, options) || ""
+      html.html_safe
+    end
+
     def ruby_format_to_datepicker(ruby_date_format)
       ruby_date_format.gsub("%d", "dd").gsub("%m", "mm").gsub("%Y", "yyyy").gsub("%H", "hh").gsub("%M", "ii")
     end
@@ -686,5 +794,94 @@ module Decidim
     def sanitize_tabs_selector(id)
       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([
+                    content_tag(:span, I18n.t("extension_whitelist", scope: "decidim.forms.files")),
+                    " ",
+                    safe_join(extension_whitelist.map { |ext| content_tag(:b, ext) }, ", ")
+                  ])
+      end
+    end
+
+    def image_dimensions_help(dimensions_info)
+      content_tag :p, class: "image-dimensions-help help-text" do
+        safe_join([
+                    content_tag(:span, I18n.t("dimensions_info", scope: "decidim.forms.images")),
+                    " ",
+                    content_tag(:span) do
+                      safe_join(dimensions_info.map do |_version, info|
+                        processor = @template.content_tag(:span, I18n.t("processors.#{info[:processor]}", scope: "decidim.forms.images"))
+                        dimensions = @template.content_tag(:b, I18n.t("dimensions", scope: "decidim.forms.images", width: info[:dimensions].first, height: info[:dimensions].last))
+                        safe_join([processor, "  ", dimensions, ". ".html_safe])
+                      end)
+                    end
+                  ])
+      end
+    end
+
+    # Private: Creates a tag from the given options for the field prefix and
+    # suffix. Overridden from Foundation Rails helper to make the generated HTML
+    # valid since these elements are printed within <label> elements and <div>'s
+    # are not allowed there.
+    def tag_from_options(name, options)
+      return "".html_safe unless options && options[:value].present?
+
+      content_tag(:span,
+                  content_tag(:span, options[:value], class: name),
+                  class: column_classes(options).to_s)
+    end
+
+    # Private: Wraps the prefix and postfix for the field. Overridden from
+    # Foundation Rails helper to make the generated HTML valid since these
+    # elements are printed within <label> elements and <div>'s are not allowed
+    # there.
+    def wrap_prefix_and_postfix(block, prefix_options, postfix_options)
+      prefix = tag_from_options("prefix", prefix_options)
+      postfix = tag_from_options("postfix", postfix_options)
+
+      input_size = calculate_input_size(prefix_options, postfix_options)
+      klass = column_classes(input_size.marshal_dump).to_s
+      input = content_tag(:span, block, class: klass)
+
+      return block unless input_size.changed?
+
+      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