decidim-core 0.22.0 → 0.23.0

data/lib/decidim/core/test/shared_examples/scope_helper_examples.rb

@@ -6,8 +6,17 @@ shared_examples "scope helpers" do
   let(:organization) { create(:organization) }
   let(:scopes_enabled) { true }
   let(:participatory_space_scope) { nil }
-  let(:component) { create(:component, manifest_name: "dummy", participatory_space: participatory_space) }
+  let(:component_scope) { nil }
+  let(:component) do
+    create(
+      :component,
+      manifest_name: "dummy",
+      participatory_space: participatory_space,
+      settings: { scopes_enabled: scopes_enabled, scope_id: component_scope&.id }
+    )
+  end
   let(:scope) { create(:scope, organization: organization) }
+  let(:subscope) { create(:subscope, organization: organization) }
   let(:resource) { create(:dummy_resource, component: component, scope: scope) }
 
   before do
@@ -36,12 +45,14 @@ shared_examples "scope helpers" do
 
     context "when the process has a different scope than the organization" do
       let(:participatory_space_scope) { create(:scope, organization: organization) }
+      let(:component_scope) { participatory_space_scope }
 
       it { is_expected.to be_truthy }
     end
 
     context "when the process has the same scope as the organization" do
       let(:participatory_space_scope) { scope }
+      let(:component_scope) { scope }
 
       it { is_expected.to be_falsey }
     end

data/lib/decidim/core/test/shared_examples/searchable_participatory_space_examples.rb

@@ -36,7 +36,7 @@ shared_examples "global search of participatory spaces" do
         it "updates the associated SearchableResource after published ParticipatorySpace update" do
           searchable = ::Decidim::SearchableResource.find_by(resource_type: participatory_space.class.name, resource_id: participatory_space.id)
           created_at = searchable.created_at
-          updated_title = "Brand new title"
+          updated_title = { "en" => "Brand new title" }
           participatory_space.update(title: updated_title)
 
           participatory_space.save!
@@ -44,7 +44,7 @@ shared_examples "global search of participatory spaces" do
 
           organization.available_locales.each do |locale|
             searchable = ::Decidim::SearchableResource.find_by(resource_type: participatory_space.class.name, resource_id: participatory_space.id, locale: locale)
-            expect(searchable.content_a).to eq updated_title
+            expect(searchable.content_a).to eq updated_title[locale.to_s].to_s
             expect(searchable.updated_at).to be > created_at
           end
         end

data/lib/decidim/core/test/shared_examples/searchable_results_examples.rb

@@ -12,16 +12,29 @@ shared_examples "searchable results" do
     before do
       expect(searchables).not_to be_empty
       expect(term).not_to be_empty
+    end
 
+    it "contains these searchables" do
       fill_in "term", with: term
       find("input#term").native.send_keys :enter
-    end
 
-    it "contains these searchables" do
       expect(page).to have_current_path decidim.search_path, ignore_query: true
       expect(page).to have_content(/results for the search: "#{term}"/i)
       expect(page).to have_selector(".filters__section")
       expect(page.find("#search-count .section-heading").text.to_i).to be_positive
     end
+
+    it "finds content by hashtag" do
+      if respond_to?(:hashtag)
+        fill_in "term", with: hashtag
+        find("input#term").native.send_keys :enter
+
+        expect(page.find("#search-count .section-heading").text.to_i).to be_positive
+
+        within "#results" do
+          expect(page).to have_content(hashtag)
+        end
+      end
+    end
   end
 end

data/lib/decidim/core/test/shared_examples/simple_event.rb

@@ -89,6 +89,13 @@ shared_examples_for "a simple event" do |skip_space_checks|
     end
   end
 
+  describe "safe_resource_text" do
+    it "is generated correctly" do
+      expect(subject.safe_resource_text).to be_kind_of(String)
+      expect(subject.safe_resource_text).to be_html_safe
+    end
+  end
+
   describe "notification_title" do
     it "is generated correctly" do
       expect(subject.notification_title).to be_kind_of(String)

data/lib/decidim/core/test/shared_examples/system_endorse_resource_examples.rb

@@ -12,6 +12,7 @@ shared_context "with resources to be endorsed or not" do
   # Should be overriden and create 3 extra resources in the current component
   let!(:resources) {}
 end
+
 shared_examples "Endorse resource system specs" do
   def expect_page_not_to_include_endorsements
     expect(page).to have_no_button("Endorse")

data/lib/decidim/core/test/shared_examples/traceable_interface_examples.rb

@@ -6,7 +6,7 @@ shared_examples_for "traceable interface" do
   describe "traceable", versioning: true do
     let(:version_author) { try(:author) || model.try(:creator_identity) || model.try(:normalized_author) }
 
-    before { Decidim.traceability.update!(model, version_author, title: "test") }
+    before { Decidim.traceability.update!(model, version_author, title: { en: "test" }) }
 
     context "when field createdAt" do
       let(:query) { "{ versions { createdAt } }" }

data/lib/decidim/core/test/shared_examples/uncommentable_component_examples.rb

@@ -14,7 +14,7 @@ shared_examples "an uncommentable component" do
 
     visit_component
 
-    ressources.each do |ressource|
+    resources.each do |ressource|
       expect(page).not_to have_link(resource_locator(ressource).path)
     end
   end

data/lib/decidim/core/version.rb

@@ -4,7 +4,7 @@ module Decidim
   # This holds the decidim-core version.
   module Core
     def self.version
-      "0.22.0"
+      "0.23.0"
     end
   end
 end

data/lib/decidim/diffy_extension.rb

@@ -22,5 +22,26 @@ module Decidim
         UnescapedHtmlFormatter.new(self, options).to_s
       end
     end
+
+    # The private "split" method SplitDiff needs to be overriden to take into
+    # account the new :unescaped_html format, and the fact that the tags
+    # <ins> <del> are not there anymore
+    Diffy::SplitDiff.module_eval do
+      private
+
+      def split
+        return [split_left, split_right] unless @format == :unescaped_html
+
+        [unescaped_split_left, unescaped_split_right]
+      end
+
+      def unescaped_split_left
+        @diff.gsub(%r{<li class="ins">([\s\S]*?)<\/li>}, "")
+      end
+
+      def unescaped_split_right
+        @diff.gsub(%r{<li class="del">([\s\S]*?)<\/li>}, "")
+      end
+    end
   end
 end

data/lib/decidim/events/base_event.rb

@@ -69,18 +69,20 @@ module Decidim
 
       def resource_text; end
 
+      def safe_resource_text
+        translated_attribute(resource_text).to_s.html_safe
+      end
+
       def resource_title
         return unless resource
 
-        if resource.is_a?(Decidim::Hashtaggable)
-          translated_title = translated_attribute(resource.title)
-          renderer = Decidim::ContentRenderers::HashtagRenderer.new(translated_title)
-          renderer.render(links: false).html_safe
-        elsif resource.respond_to?(:title)
-          translated_attribute(resource.title)
-        elsif resource.respond_to?(:name)
-          translated_attribute(resource.name)
-        end
+        title = if resource.respond_to?(:title)
+                  translated_attribute(resource.title)
+                elsif resource.respond_to?(:name)
+                  translated_attribute(resource.name)
+                end
+
+        Decidim::ContentProcessor.render_without_format(title, links: false).html_safe
       end
 
       private

data/lib/decidim/exporters.rb

@@ -6,8 +6,15 @@ module Decidim
     autoload :JSON, "decidim/exporters/json"
     autoload :CSV, "decidim/exporters/csv"
     autoload :Excel, "decidim/exporters/excel"
+    autoload :PDF, "decidim/exporters/pdf"
     autoload :ExportData, "decidim/exporters/export_data"
 
+    # Necessary for the i18n normalizer to locate strings not directly invoked in views:
+
+    # i18n-tasks-use t('decidim.admin.exports.formats.JSON')
+    # i18n-tasks-use t('decidim.admin.exports.formats.CSV')
+    # i18n-tasks-use t('decidim.admin.exports.formats.Excel')
+
     # Get the exporter class constant from the format as a string.
     #
     # format - The exporter format as a string. i.e "CSV"

data/lib/decidim/exporters/csv.rb

@@ -18,12 +18,26 @@ module Decidim
       def export(col_sep = Decidim.default_csv_col_sep)
         data = ::CSV.generate(headers: headers, write_headers: true, col_sep: col_sep) do |csv|
           processed_collection.each do |resource|
-            csv << headers.map { |header| resource[header] }
+            csv << headers.map { |header| custom_sanitize(resource[header]) }
           end
         end
         ExportData.new(data, "csv")
       end
 
+      protected
+
+      def custom_sanitize(value)
+        # rubocop:disable Style/AndOr
+        return value unless value.instance_of?(String) and invalid_first_chars.include?(value.first)
+
+        # rubocop:enable Style/AndOr
+        value.dup.prepend("'")
+      end
+
+      def invalid_first_chars
+        %w(= + - @)
+      end
+
       private
 
       def headers

data/lib/decidim/exporters/excel.rb

@@ -36,7 +36,7 @@ module Decidim
         end
 
         processed_collection.each_with_index do |resource, index|
-          sheet.row(index + 1).replace(headers.map { |header| resource[header] })
+          sheet.row(index + 1).replace(headers.map { |header| custom_sanitize(resource[header]) })
         end
 
         output = StringIO.new

data/lib/decidim/exporters/export_manifest.rb

@@ -71,6 +71,35 @@ module Decidim
       def serializer(serializer = nil)
         @serializer ||= serializer || Decidim::Exporters::Serializer
       end
+
+      DEFAULT_FORMATS = %w(CSV JSON Excel).freeze
+
+      # Public: Sets the available formats if an argument is provided and
+      # loads the required exporters, returns the array with the default available
+      # formats otherwise.
+      #
+      # The formats array is used to define which exporters are available
+      # in the component. Each member of the array is a string with the name
+      # of the exporter class that will instantiated when needed.
+      #
+      # formats - The array containing the available formats.
+      #
+      # Returns the stored formats if previously stored, or
+      # the default formats array.
+      def formats(formats = nil)
+        load_exporters(formats)
+        @formats ||= formats || DEFAULT_FORMATS
+      end
+
+      private
+
+      # Private: Loads the given exporters when formats argument is provided.
+      #
+      # formats - The array containing the formats for which to load exporters.
+      #
+      def load_exporters(formats)
+        formats&.each { |f| require "decidim/exporters/#{f.underscore}" }
+      end
     end
   end
 end

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/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
@@ -450,47 +451,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 +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
@@ -818,6 +795,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 +853,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