decidim-core 0.22.0 → 0.23.3

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+shared_examples_for "a scopable resource" do
+  before do
+    current_component.update!(settings: { scopes_enabled: true, scope_id: parent_scope.id })
+  end
+
+  context "when the scope exists" do
+    it { expect(form.scope).to be_kind_of(Decidim::Scope) }
+  end
+
+  context "when the scope does not exist" do
+    let(:scope_id) { 3456 }
+
+    it { expect(form.scope).to eq(nil) }
+  end
+
+  context "when the scope is from another organization" do
+    let(:scope_id) { create(:scope).id }
+
+    it { expect(form.scope).to eq(nil) }
+  end
+
+  context "when the component has a scope" do
+    context "when the scope is descendant from component scope" do
+      let(:scope) { create(:scope, organization: organization, parent: parent_scope) }
+
+      it { expect(form.scope).to eq(scope) }
+    end
+
+    context "when the scope is not descendant from component scope" do
+      let(:another_scope) { create(:scope, organization: organization) }
+      let(:scope) { create(:subscope, parent: another_scope) }
+      let(:scope_id) { scope.id }
+
+      it { expect(form.scope).to eq(scope) }
+
+      it "makes the form invalid" do
+        expect(form).to be_invalid
+      end
+    end
+  end
+end

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.3"
     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

@@ -59,28 +59,42 @@ module Decidim
 
       # Caches the path for the given resource.
       def resource_path
-        @resource_path ||= resource_locator.path
+        @resource_path ||= begin
+          if resource&.respond_to?(:polymorphic_resource_path)
+            resource.polymorphic_resource_path(resource_url_params)
+          else
+            resource_locator.path(resource_url_params)
+          end
+        end
       end
 
       # Caches the URL for the given resource.
       def resource_url
-        @resource_url ||= resource_locator.url
+        @resource_url ||= begin
+          if resource&.respond_to?(:polymorphic_resource_url)
+            resource.polymorphic_resource_url(resource_url_params)
+          else
+            resource_locator.url(resource_url_params)
+          end
+        end
       end
 
       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
@@ -97,6 +111,10 @@ module Decidim
         resource.try(:participatory_space)
       end
 
+      def resource_url_params
+        {}
+      end
+
       attr_reader :event_name, :resource, :user, :user_role, :extra
     end
   end

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