decidim-core 0.20.1 → 0.23.1

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "timestamps interface" do
+  describe "createdAt" do
+    let(:query) { "{ createdAt }" }
+
+    it "returns when was this query created at" do
+      expect(response["createdAt"]).to eq(model.created_at.to_time.iso8601)
+    end
+  end
+
+  describe "updatedAt" do
+    let(:query) { "{ updatedAt }" }
+
+    it "returns when was this query updated at" do
+      expect(response["updatedAt"]).to eq(model.updated_at.to_time.iso8601)
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+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: { en: "test" }) }
+
+    context "when field createdAt" do
+      let(:query) { "{ versions { createdAt } }" }
+
+      it "returns created_at field of the version to iso format" do
+        dates = response["versions"].map { |version| version["createdAt"] }
+        expect(dates).to include(*model.versions.map { |version| version.created_at.to_time.iso8601 })
+      end
+    end
+
+    context "when field id" do
+      let(:query) { "{ versions { id } }" }
+
+      it "returns ID field of the version" do
+        ids = response["versions"].map { |version| version["id"].to_i }
+        expect(ids).to include(*model.versions.map(&:id))
+      end
+    end
+
+    context "when field editor" do
+      let(:query) { "{ versions { editor { name } } }" }
+
+      it "returns editor field of the versions" do
+        editors = response["versions"].map { |version| version["editor"]["name"] if version["editor"] }
+        expect(editors).to include(*model.versions.map { |version| version.editor.name if version.respond_to? :editor })
+      end
+    end
+
+    context "when field changeset" do
+      let(:query) { "{ versions { changeset } }" }
+
+      it "returns changeset field of the versions" do
+        changesets = response["versions"].map { |version| version["changeset"] }
+        expect(changesets).to include(*model.versions.map(&:changeset))
+      end
+    end
+  end
+end

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/test/shared_examples/with_endorsable_permissions_examples.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# users of this test should delare the `subject` variable.
+shared_examples "with endorsable permissions can perform actions related to endorsable" do
+  let(:action_subject) { :endorsement }
+  let(:resource) { create :dummy_resource }
+  before do
+    context[:current_settings] = double(current_settings)
+    context[:resource] = resource
+  end
+
+  describe "endorsing" do
+    describe "when endorsing" do
+      let(:action_name) { :create }
+
+      context "when endorsements are disabled" do
+        let(:current_settings) do
+          {
+            endorsements_enabled: false,
+            endorsements_blocked: false
+          }
+        end
+
+        it { is_expected.to eq false }
+      end
+
+      context "when endorsements are blocked" do
+        let(:current_settings) do
+          {
+            endorsements_enabled: true,
+            endorsements_blocked: true
+          }
+        end
+
+        it { is_expected.to eq false }
+      end
+
+      context "when user is authorized" do
+        let(:current_settings) do
+          {
+            endorsements_enabled: true,
+            endorsements_blocked: false
+          }
+        end
+
+        it { is_expected.to eq true }
+      end
+    end
+  end
+
+  describe "unendorsing" do
+    let(:action_name) { :unendorse }
+
+    context "when endorsements are disabled" do
+      let(:current_settings) do
+        {
+          endorsements_enabled: false,
+          endorsements_blocked: false
+        }
+      end
+
+      it { is_expected.to eq false }
+    end
+
+    context "when endorsements are blocked" do
+      let(:current_settings) do
+        {
+          endorsements_enabled: true,
+          endorsements_blocked: true
+        }
+      end
+
+      it { is_expected.to eq false }
+    end
+
+    context "when user is authorized" do
+      let(:current_settings) do
+        {
+          endorsements_enabled: true,
+          endorsements_blocked: false
+        }
+      end
+
+      it { is_expected.to eq true }
+    end
+  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.20.1"
+      "0.23.1"
     end
   end
 end

data/lib/decidim/deprecations.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  #
+  # This class handles all logic regarding deprecated methods.
+  #
+  module Deprecations
+    # Define a deprecated alias for a method
+    #
+    # @param [Symbol] old_name - name of the method to deprecate
+    # @param [Symbol] replacement - name of the new method to use
+    def deprecated_alias(old_name, replacement)
+      define_method(old_name) do |*args, &block|
+        ActiveSupport::Deprecation.warn "##{old_name} deprecated (please use ##{replacement})"
+        send replacement, *args, &block
+      end
+    end
+  end
+end

data/lib/decidim/diffy_extension.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Extending Diffy gem to accomodate the needs of app/cells/decidim/diff_cell.rb
+  module DiffyExtension
+    # HtmlFormatter that returns basic html output (no inline highlighting)
+    # and does not escape HTML tags.
+    class UnescapedHtmlFormatter < Diffy::HtmlFormatter
+      # We exclude the tags `del` and `ins` so the diffy styling does not apply.
+      TAGS = (UserInputScrubber.new.tags.to_a - %w(del ins)).freeze
+
+      def to_s
+        str = wrap_lines(@diff.map { |line| wrap_line(line) })
+        ActionView::Base.new.sanitize(str, tags: TAGS)
+      end
+    end
+
+    # Adding a new method to Diffy::Format so we can pass the
+    # `:unescaped_html` option when calling Diffy::Diff#to_s.
+    Diffy::Format.module_eval do
+      def unescaped_html
+        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/endorsable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This concern contains the logic related with resources that can be endorsed.
+  # Thus, it is expected to be included into a resource that is wanted to be endorsable.
+  # This resource will have many `Decidim::Endorsement`s.
+  module Endorsable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :endorsements,
+               as: :resource,
+               dependent: :destroy,
+               counter_cache: "endorsements_count"
+
+      # Public: Check if the user has endorsed the resource.
+      # - user_group: may be nil if user is not representing any user_group.
+      #
+      # Returns Boolean.
+      def endorsed_by?(user, user_group = nil)
+        endorsements.where(author: user, user_group: user_group).any?
+      end
+    end
+  end
+end

data/lib/decidim/events.rb

@@ -8,5 +8,6 @@ module Decidim
     autoload :SimpleEvent, "decidim/events/simple_event"
     autoload :AuthorEvent, "decidim/events/author_event"
     autoload :CoauthorEvent, "decidim/events/coauthor_event"
+    autoload :UserGroupEvent, "decidim/events/user_group_event"
   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/events/user_group_event.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Events
+    # This module is used to be included in event classes inheriting from SimpleEvent
+    # whose resource has an in the "extra" options a user_group in the keyword :group.
+    #
+    # It adds the group_name, group_nickname, group_path and group_url to the i18n interpolations.
+    module UserGroupEvent
+      extend ActiveSupport::Concern
+
+      included do
+        i18n_attributes :group_name, :group_nickname, :group_path, :group_url
+
+        def group_nickname
+          group_presenter&.nickname.to_s
+        end
+
+        def group_name
+          group_presenter&.name.to_s
+        end
+
+        def group_path
+          group_presenter&.profile_path.to_s
+        end
+
+        def group_url
+          group_presenter&.profile_url.to_s
+        end
+
+        def group_presenter
+          return unless group
+
+          @group_presenter ||= Decidim::UserGroupPresenter.new(group)
+        end
+
+        def group
+          return unless extra[:group].is_a?(Decidim::UserGroup)
+
+          extra[:group]
+        end
+      end
+    end
+  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
@@ -45,7 +59,7 @@ module Decidim
             result.merge(flatten(value, new_key))
           end
         elsif object.is_a?(Array)
-          { key.to_s => object.map(&:to_s).join(", ") }
+          { key.to_s => object.compact.map(&:to_s).join(", ") }
         else
           { key.to_s => object }
         end