decidim-core 0.13.1 → 0.14.1

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

@@ -4,6 +4,16 @@ require "spec_helper"
 
 shared_examples_for "authorable interface" do
   describe "author" do
+    describe "when author is not present" do
+      before do
+        model.update(author: author)
+      end
+
+      it "does not include the author" do
+        expect(response["author"]).to be_nil
+      end
+    end
+
     describe "with a regular user" do
       let(:author) { create(:user, organization: model.participatory_space.organization) }
       let(:query) { "{ author { name } }" }

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

@@ -72,6 +72,7 @@ shared_examples_for "coauthorable" do
           expect(coauthorable.authored_by?(creator_author)).to be(false)
         end
       end
+
       context "when the checked user is one of the coauthors" do
         before do
           other_authors.each { |author| coauthorable.authors << author }
@@ -92,6 +93,7 @@ shared_examples_for "coauthorable" do
         it "returns an empty list" do
         end
       end
+
       context "when there are many coauthors of both types" do
         before do
           other_authors.each { |author| coauthorable.authors << author }
@@ -99,6 +101,7 @@ shared_examples_for "coauthorable" do
             Decidim::Coauthorship.create(author: user_group.memberships.first.user, user_group: user_group, coauthorable: coauthorable)
           end
         end
+
         it "returns an array of identities" do
           identities = [creator_author]
           identities += other_authors

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+shared_examples "editable content for admins" do
+  describe "edit link" do
+    before do
+      relogin_as user
+      visit current_path
+    end
+
+    context "when I'm an admin user" do
+      let(:user) { create(:user, :admin, :confirmed, organization: organization) }
+
+      it "has a link to edit the content at the admin" do
+        within ".topbar" do
+          expect(page).to have_link("Edit", href: /admin/)
+        end
+      end
+    end
+
+    context "when I'm a regular user" do
+      let(:user) { create(:user, :confirmed, organization: organization) }
+
+      it "does not have a link to edit the content at the admin" do
+        within ".topbar" do
+          expect(page).not_to have_link("Edit")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "has space in m-cell" do
+  context "when rendering with show_space flag" do
+    # expects the cell to be invoked with a :show_space context flag that takes this value.
+    let(:show_space) { true }
+
+    it "renders the space where the model belongs to" do
+      expect(cell_html).to have_selector(".card__top .card__content.text-small")
+      expect(cell_html).to have_content(translated(model.component.participatory_space.title, locale: :en))
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ shared_examples_for "publicable" do
   let(:factory_name) { described_class.name.demodulize.underscore.to_sym }
 
   let!(:published) do
-    create(factory_name, published_at: Time.zone.now)
+    create(factory_name, published_at: Time.current)
   end
 
   let!(:unpublished) do

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+shared_examples_for "decidim module task loading" do |decidim_module|
+  let(:railties) do
+    Rails.application.railties
+  end
+
+  let(:railties_that_load_tasks) do
+    railties.select { |r| r.railtie_name.match?(decidim_module) && !r.paths["lib/tasks"].to_a.empty? }
+  end
+
+  it "loads tasks just under one railtie" do
+    expect(railties_that_load_tasks.size).to eq(1)
+  end
+end

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

@@ -13,6 +13,7 @@ shared_examples "scope helpers" do
   before do
     allow(helper).to receive(:current_participatory_space).and_return(participatory_space)
   end
+
   let(:helper) do
     Class.new.tap do |v|
       v.extend(Decidim::ScopesHelper)

data/lib/decidim/core/version.rb

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

data/lib/decidim/events/base_event.rb

@@ -73,7 +73,7 @@ module Decidim
       def notifiable?
         return false if resource.is_a?(Decidim::Publicable) && !resource.published?
         return false if participatory_space.is_a?(Decidim::Publicable) && !participatory_space&.published?
-        return false unless component&.published?
+        return false if component && !component.published?
 
         return false if participatory_space.is_a?(Decidim::Participable) && !participatory_space.can_participate?(user)
 
@@ -90,6 +90,7 @@ module Decidim
       end
 
       def participatory_space
+        return resource if resource.is_a?(Decidim::ParticipatorySpaceResourceable)
         component&.participatory_space
       end
 

data/lib/decidim/form_builder.rb

@@ -71,7 +71,13 @@ module Decidim
         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
-            send(type, name_with_locale(name, locale), options.merge(label: false))
+            if options[:hashtaggable]
+              content_tag(:div, class: "hashtags__container") do
+                send(type, name_with_locale(name, locale), options.merge(label: false))
+              end
+            else
+              send(type, name_with_locale(name, locale), options.merge(label: false))
+            end
           end
         end
       end
@@ -137,11 +143,11 @@ module Decidim
       options[:lines] ||= 10
       options[:disabled] ||= false
 
-      content_tag(:div, class: "editor") do
+      content_tag(:div, class: "editor #{"hashtags__container" if options[: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", data: {
+        template += content_tag(:div, nil, class: "editor-container #{"js-hashtags" if options[:hashtaggable]}", data: {
                                   toolbar: options[:toolbar],
                                   disabled: options[:disabled]
                                 }, style: "height: #{options[:lines]}rem")

data/lib/decidim/friendly_dates.rb

@@ -10,7 +10,7 @@ module Decidim
 
     # Returns the creation date in a friendly relative format.
     def friendly_created_at
-      current_datetime = Time.zone.now
+      current_datetime = Time.current
 
       if created_at > current_datetime.beginning_of_day
         I18n.l(created_at, format: :time_of_day)

data/lib/decidim/gamification.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Gamification
+    autoload :Badge, "decidim/gamification/badge"
+    autoload :BadgeRegistry, "decidim/gamification/badge_registry"
+    autoload :BadgeStatus, "decidim/gamification/badge_status"
+    autoload :BadgeScorer, "decidim/gamification/badge_scorer"
+    autoload :BaseEvent, "decidim/gamification/base_event"
+    autoload :BadgeEarnedEvent, "decidim/gamification/badge_earned_event"
+    autoload :LevelUpEvent, "decidim/gamification/level_up_event"
+
+    # Public: Returns a the status of a badge given a user and a badge name.
+    #
+    # Returns a `BadgeStatus` instance.
+    def self.status_for(user, badge_name)
+      BadgeStatus.new(user, find_badge(badge_name))
+    end
+
+    # Public: Increments the score of a user for a badge.
+    #
+    # user       - A User for whom to increase the score.
+    # badge_name - The name of the badge for which to increase the score.
+    # amount     - (Optional) The amount to increase. Defaults to 1.
+    #
+    # Returns nothing.
+    def self.increment_score(user, badge_name, amount = 1)
+      BadgeScorer.new(user, find_badge(badge_name)).increment(amount)
+    end
+
+    # Public: Decrement the score of a user for a badge.
+    #
+    # user       - A User for whom to increase the score.
+    # badge_name - The name of the badge for which to increase the score.
+    # amount     - (Optional) The amount to decrease. Defaults to 1.
+    #
+    # Returns nothing.
+    def self.decrement_score(user, badge_name, amount = 1)
+      BadgeScorer.new(user, find_badge(badge_name)).decrement(amount)
+    end
+
+    # Public: Sets the score of a user for a badge.
+    #
+    # user       - A User for whom to set the score.
+    # badge_name - The name of the badge for which to increase the score.
+    # score      - The score to set.
+    #
+    # Returns nothing.
+    def self.set_score(user, badge_name, score)
+      BadgeScorer.new(user, find_badge(badge_name)).set(score)
+    end
+
+    # Semi-private: The BadgeRegistry to register global badges to.
+    def self.badge_registry
+      @badge_registry ||= Decidim::Gamification::BadgeRegistry.new
+    end
+
+    # Public: Returns all available badges.
+    #
+    # Returns an Array<Badge>
+    def self.badges
+      badge_registry.all
+    end
+
+    # Public: Finds a Badge given a name.
+    #
+    # Returns a Badge if found, nil otherwise.
+    def self.find_badge(name)
+      badge_registry.find(name)
+    end
+
+    # Public: Registers a new Badge.
+    #
+    # Example:
+    #
+    #     Decidim.register_badge(:foo) do |badge|
+    #       badge.levels = [1, 10, 50]
+    #     end
+    #
+    # Returns nothing if registered successfully, raises an exception
+    # otherwise.
+    def self.register_badge(name, &block)
+      badge_registry.register(name, &block)
+    end
+
+    # Public: Resets all the badge scores using each of the badges'
+    # reset methods (if available). This is useful if the badges ever get
+    # inconsistent.
+    #
+    # users - The Array of Users to reset the score.
+    #
+    # Returns nothing.
+    def self.reset_badges(users = nil)
+      users ||= User.all
+
+      badges.each do |badge|
+        Rails.logger.info "Resetting #{badge.name}..."
+
+        if badge.reset
+          users.find_each do |user|
+            set_score(user, badge.name, badge.reset.call(user))
+          end
+        else
+          Rails.logger.info "Badge can't be reset since it doesn't have a reset method."
+        end
+      end
+    end
+  end
+end

data/lib/decidim/gamification/badge.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Gamification
+    # This class represents an abstract badge. Instances of this class can define
+    # different badge types with different rules such as gaining new levels, etc.
+    class Badge
+      include Virtus.model
+      include ActiveModel::Validations
+
+      # The name of the badge.
+      attribute :name, String
+
+      # An array of scores needed to reach a new level. For example, the array
+      # [1, 5, 10] represents 1 point to get to Level 1, 5 points to get to level 2,
+      # 10 points to get to level 3.
+      attribute :levels, Array, default: []
+
+      # (Optional) you can set a lambda in order to be able to reset the score of a
+      # badge if the progress gets lost somehow. The lambda receives a user as an
+      # argument.
+      #
+      # It might not be possible sometimes, so it's fine to leave it empty.
+      attribute :reset, Proc
+
+      validates :name, :levels, presence: true
+      validates :levels, empty: false
+
+      validate do
+        errors.add(:levels, "level thresholds should be ordered") if levels.sort != levels
+        errors.add(:levels, "level thresholds should be positive") unless levels.all?(&:positive?)
+        errors.add(:levels, "level thresholds should be unique") unless levels.uniq == levels
+      end
+
+      # Public: Returns the level for this badge given a score.
+      #
+      # Returns an Integer with the level.
+      def level_of(score)
+        levels.each_with_index do |threshold, index|
+          return index if threshold > score
+        end
+
+        levels.length
+      end
+
+      # Public: Returns an image for this badge.
+      #
+      # Returns a String with the image.
+      def image
+        ActionController::Base.helpers.asset_path("decidim/gamification/badges/#{name}.svg")
+      end
+    end
+  end
+end

data/lib/decidim/gamification/badge_earned_event.rb

@@ -0,0 +1,9 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Gamification
+    # This event is sent when a badge is earned for the first time.
+    class BadgeEarnedEvent < BaseEvent
+    end
+  end
+end

data/lib/decidim/gamification/badge_registry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Gamification
+    # This class represents a repository of badges. New badges can be
+    # registered thanks to its DSL and will be validated prior to being
+    # inserted.
+    #
+    class BadgeRegistry
+      # Public: Initializes the badge registry.
+      def initialize
+        @badges = {}
+      end
+
+      # Public: Returns all the registered badges.
+      #
+      # Returns Array<Badge>.
+      def all
+        @badges.values
+      end
+
+      # Public: Finds a badge given its name.
+      #
+      # name - The name of the badge to find.
+      #
+      # Returns a Badge if found or nil otherwise.
+      def find(name)
+        @badges[name.to_s]
+      end
+
+      # Public: Registers a new badge.
+      #
+      # name   - The name of the badge to register.
+      # &block - A block that gets the new badge as argument.
+      #
+      # Example:
+      #     register(:fake){ |badge| badge.levels = [1, 3, 10] }
+      #
+      # Returns a Badge when registered successfully, raises an exception
+      # otherwise.
+      def register(name, &block)
+        name = name.to_s
+
+        badge = Badge.new(name: name).tap do |object|
+          object.instance_eval(&block)
+        end
+
+        badge.validate!
+
+        @badges[name] = badge
+      end
+
+      # Public: Unregisters a previously registered badge.
+      #
+      # name - The name of the badge to unregister.
+      #
+      # Returns the deleted Badge if found, nil otherwise.
+      def unregister(name)
+        @badges.delete(name.to_s)
+      end
+    end
+  end
+end

data/lib/decidim/gamification/badge_scorer.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Gamification
+    # This class is responsible of updating scores given a user and a badge. Will
+    # also trigger any side-effects such as notifications.
+    class BadgeScorer
+      # Public: Initializes the class.
+      #
+      # user  - The user for which to update scores.
+      # badge - The `Badge` to update.
+      #
+      def initialize(user, badge)
+        @user = user
+        @badge = badge
+      end
+
+      # Public: Increments the score for the user and badge.
+      #
+      # amount - Amount to increment. Defaults to 1.
+      #
+      # Returns a `BadgeScore`.
+      def increment(amount = 1)
+        raise InvalidAmountException unless amount.positive?
+
+        with_level_tracking do
+          BadgeScore.find_or_create_by(
+            user: @user,
+            badge_name: @badge.name
+          ).increment(:value, amount).save!
+        end
+      end
+
+      # Public: Decrements the score for the user and badge.
+      #
+      # amount - Amount to decrement. Defaults to 1.
+      #
+      # Returns a `BadgeScore`.
+      def decrement(amount = 1)
+        raise InvalidAmountException unless amount.positive?
+
+        with_level_tracking do
+          badge_score = BadgeScore.find_by(
+            user: @user,
+            badge_name: @badge.name
+          )
+
+          next if badge_score.blank?
+
+          badge_score.decrement(:value, amount)
+          badge_score.value = 0 if badge_score.value.negative?
+          badge_score.save!
+        end
+      end
+
+      # Public: Sets the score for the user and badge.
+      #
+      # score - Score to set.
+      #
+      # Returns a `BadgeScore`.
+      def set(score)
+        raise NegativeScoreException if score.negative?
+
+        with_level_tracking do
+          BadgeScore.find_or_create_by(
+            user_id: @user.id,
+            badge_name: @badge.name
+          ).update!(value: score)
+        end
+      end
+
+      private
+
+      class NegativeScoreException < StandardError; end
+      class InvalidAmountException < StandardError; end
+
+      def with_level_tracking
+        previous_level = BadgeStatus.new(@user, @badge).level
+
+        yield
+
+        current_status = BadgeStatus.new(@user, @badge)
+        send_notification(previous_level, current_status.level)
+        current_status
+      end
+
+      def send_notification(previous_level, current_level)
+        return unless current_level > previous_level
+
+        if previous_level.zero?
+          publish_event(name: "decidim.events.gamification.badge_earned",
+                        klass: BadgeEarnedEvent,
+                        previous_level: previous_level,
+                        current_level: current_level)
+        else
+          publish_event(name: "decidim.events.gamification.level_up",
+                        klass: LevelUpEvent,
+                        previous_level: previous_level,
+                        current_level: current_level)
+        end
+      end
+
+      def publish_event(name:, klass:, previous_level:, current_level:)
+        Decidim::EventsManager.publish(
+          event: name,
+          event_class: klass,
+          resource: @user,
+          recipient_ids: [@user.id],
+          extra: {
+            badge_name: @badge.name.to_s,
+            previous_level: previous_level,
+            current_level: current_level
+          }
+        )
+      end
+    end
+  end
+end