decidim-core 0.15.2 → 0.16.0

data/lib/decidim/api/component_interface.rb

@@ -10,6 +10,10 @@ module Decidim
 
       field :name, !TranslatedFieldType, "The name of this component."
 
+      field :weight, !types.Int, "The weight of the component"
+
+      field :participatorySpace, !ParticipatorySpaceType, "The participatory space in which this component belongs to.", property: :participatory_space
+
       resolve_type ->(obj, _ctx) { obj.manifest.query_type.constantize }
     end
   end

data/lib/decidim/api/participatory_space_interface.rb

@@ -10,6 +10,13 @@ module Decidim
 
       field :title, !TranslatedFieldType, "The name of this participatory space."
 
+      field :type, !types.String do
+        description "The participatory space class name. i.e. Decidim::ParticipatoryProcess"
+        resolve ->(participatory_space, _args, _ctx) {
+          participatory_space.class.name
+        }
+      end
+
       field :components, types[ComponentInterface] do
         description "Lists the components this space contains."
 

data/lib/decidim/api/scopable_interface.rb

@@ -7,7 +7,7 @@ module Decidim
       name "ScopableInterface"
       description "An interface that can be used in scopable objects."
 
-      field :scope, !Decidim::Core::ScopeApiType, "The object's scope"
+      field :scope, Decidim::Core::ScopeApiType, "The object's scope"
     end
   end
 end

data/lib/decidim/coauthorable.rb

@@ -29,7 +29,7 @@ module Decidim
       # Overwrite default reload method to unset the instance variables so reloading works as expected.
       def reload(options = nil)
         remove_instance_variable(:@authors) if defined?(@authors)
-        remove_instance_variable(:@notifiable_authors) if defined?(@notifiable_authors)
+        remove_instance_variable(:@notifiable_identities) if defined?(@notifiable_identities)
         super(options)
       end
 
@@ -50,12 +50,14 @@ module Decidim
         end.compact.uniq
       end
 
-      # Returns the authors that should be notified for a coauthorable.
+      # Returns the identities that should be notified for a coauthorable.
       #
-      def notifiable_authors
-        @notifiable_authors ||= authors.flat_map do |author|
-          if author.is_a?(Decidim::User)
-            author
+      def notifiable_identities
+        @notifiable_identities ||= identities.flat_map do |identity|
+          if identity.is_a?(Decidim::User)
+            identity
+          elsif identity.is_a?(Decidim::UserGroup)
+            identity.managers
           elsif respond_to?(:component)
             component.participatory_space.admins
           end
@@ -82,6 +84,13 @@ module Decidim
         coauthorships.order(:created_at).first
       end
 
+      # Checks whether the user is the creator of the given proposal
+      #
+      # author - the author to check for authorship
+      def created_by?(author)
+        author == creator_author
+      end
+
       # Syntactic sugar to access first coauthor Author
       def creator_author
         creator.try(:author)
@@ -95,7 +104,7 @@ module Decidim
 
       # Adds a new coauthor to the list of coauthors. The coauthorship is created with
       # current object as coauthorable and `user` param as author. To set the user group
-      # use `extra_attributes` either with `user_group` or `decidim_user_group_id` keys.
+      # use `extra_attributes` with the `user_group` key.
       #
       # @param author: The new coauthor.
       # @extra_attrs: Extra

data/lib/decidim/component_manifest.rb

@@ -141,6 +141,7 @@ module Decidim
     #
     # Returns nothing.
     def exports(name, &block)
+      return unless name
       @exports ||= []
       @exports << [name, block]
       @export_manifests = nil
@@ -151,8 +152,8 @@ module Decidim
     #
     # Returns an Array<Decidim::Components::ExportManifest>.
     def export_manifests
-      @export_manifests ||= @exports.map do |(name, block)|
-        Decidim::Components::ExportManifest.new(name).tap do |manifest|
+      @export_manifests ||= Array(@exports).map do |(name, block)|
+        Decidim::Components::ExportManifest.new(name, self).tap do |manifest|
           block.call(manifest)
         end
       end

data/lib/decidim/components/export_manifest.rb

@@ -6,15 +6,26 @@ module Decidim
     # exportable in a component. It is used via the `ComponentManifest`.
     #
     class ExportManifest
-      attr_reader :name
+      include ActiveModel::Model
+      include Virtus.model
+
+      attr_reader :name, :component_manifest
+
+      # An setting to choose if the collection exported by this manifest should
+      # be included in the open data export available for all users.
+      attribute :include_in_open_data, Boolean, default: false
 
       # Initializes the manifest.
       #
       # name - The name of the export artifact. It should be unique in the
       #        component.
       #
-      def initialize(name)
+      # component_manifest - The parent ComponentManifest where this export
+      #                      manifest belongs to.
+      #
+      def initialize(name, component_manifest)
         @name = name.to_sym
+        @component_manifest = component_manifest
       end
 
       # Public: Sets the collection when a block is given, or returns it if

data/lib/decidim/content_parsers/hashtag_parser.rb

@@ -2,34 +2,67 @@
 
 module Decidim
   module ContentParsers
-    # A parser that searches user mentions in content.
+    # A parser that searches hashtags in content.
     #
-    # A word starting with `#` will be considered as a possible hashtagging if
-    # they only contains letters, numbers or underscores. If the `#` is
+    # A word starting with `#` will be considered as a hashtag if
+    # it only contains letters, numbers or underscores. If the `#` is
     # followed with an underscore, then it is not considered.
     #
     # @see BaseParser Examples of how to use a content parser
     class HashtagParser < BaseParser
+      # Class used as a container for metadata
+      #
+      # @!attribute hashtags
+      #   @return [Array] an array of Decidim::Hashtag mentioned in content
       Metadata = Struct.new(:hashtags)
 
-      # Replaces found hashtags matching a name of an existing
-      # hashtag with a global id.
+      # Matches a hashtag if it starts with a letter or number
+      # and only contains letters, numbers or underscores.
+      HASHTAG_REGEX = /\B#([[:alnum:]](?:[[:alnum:]]|_)*)\b/i
+
+      # Replaces hashtags name with new or existing hashtags models global ids.
       #
-      # @return [String] the content with the hashtags replaced by a global id
+      # @return [String] the content with the hashtags replaced by global ids
       def rewrite
-        content.gsub(Decidim::Hashtag::HASHTAG_REGEX) do |match|
-          if (hashtag = Decidim::Hashtag.find_or_create_by(organization: context[:current_organization], name: Regexp.last_match[2].downcase))
-            Regexp.last_match[1] + hashtag.to_global_id.to_s
-          else
-            match
-          end
+        content.gsub(HASHTAG_REGEX) do |match|
+          hashtag(match[1..-1]).to_global_id.to_s + "/" + (extra_hashtags? ? "_" : "") + match[1..-1]
         end
       end
 
       def metadata
-        Metadata.new(
-          Decidim::Hashtag.where(organization: context[:current_organization], name: content.scan(Decidim::Hashtag::HASHTAG_REGEX).flatten)
-        )
+        Metadata.new(content_hashtags.map { |content_hashtag| hashtag(content_hashtag) }.uniq)
+      end
+
+      private
+
+      def hashtag(name)
+        hashtags[name.downcase] ||= Decidim::Hashtag.create(organization: current_organization, name: name.downcase)
+      end
+
+      def hashtags
+        @hashtags ||= Hash[
+          existing_hashtags.map do |hashtag|
+            [hashtag.name, hashtag]
+          end
+        ]
+      end
+
+      def existing_hashtags
+        @existing_hashtags ||= Decidim::Hashtag.where(organization: current_organization, name: content_hashtags.map(&:downcase))
+      end
+
+      def content_hashtags
+        @content_hashtags ||= content.scan(HASHTAG_REGEX).flatten.uniq
+      end
+
+      def current_organization
+        @current_organization ||= context[:current_organization]
+      end
+
+      def extra_hashtags?
+        return @extra_hashtags if defined?(@extra_hashtags)
+
+        @extra_hashtags = context[:extra_hashtags]
       end
     end
   end

data/lib/decidim/content_parsers/user_parser.rb

@@ -16,9 +16,9 @@ module Decidim
       #   @return [Array] an array of Decidim::User mentioned in content
       Metadata = Struct.new(:users)
 
-      # Matches a nickname if they start with a letter or number
+      # Matches a nickname if it starts with a letter or number
       # and only contains letters, numbers or underscores.
-      MENTION_REGEX = /(^|\s)@([a-zA-Z0-9]\w*)/
+      MENTION_REGEX = /\B@([a-zA-Z0-9]\w*)\b/
 
       # Replaces found mentions matching a nickname of an existing
       # user in the current organization with a global id. Other
@@ -28,19 +28,35 @@ module Decidim
       # @return [String] the content with the valid mentions replaced by a global id
       def rewrite
         content.gsub(MENTION_REGEX) do |match|
-          if (user = Decidim::User.find_by(nickname: Regexp.last_match[2], organization: context[:current_organization]))
-            Regexp.last_match[1] + user.to_global_id.to_s
-          else
-            match
-          end
+          users[match[1..-1]]&.to_global_id&.to_s || match
         end
       end
 
       # (see BaseParser#metadata)
       def metadata
-        Metadata.new(
-          Decidim::User.where(nickname: content.scan(MENTION_REGEX).flatten, organization: context[:current_organization])
-        )
+        Metadata.new(existing_users)
+      end
+
+      private
+
+      def users
+        @users ||= Hash[
+          existing_users.map do |user|
+            [user.nickname, user]
+          end
+        ]
+      end
+
+      def existing_users
+        @existing_users ||= Decidim::User.where(organization: current_organization, nickname: content_nicknames)
+      end
+
+      def content_nicknames
+        @content_nicknames ||= content.scan(MENTION_REGEX).flatten.uniq
+      end
+
+      def current_organization
+        @current_organization ||= context[:current_organization]
       end
     end
   end

data/lib/decidim/content_renderers/hashtag_renderer.rb

@@ -10,43 +10,66 @@ module Decidim
     # @see BaseRenderer Examples of how to use a content renderer
     class HashtagRenderer < BaseRenderer
       # Matches a global id representing a Decidim::Hashtag
-      GLOBAL_ID_REGEX = %r{gid:\/\/[\w-]*\/Decidim::Hashtag\/(\d+)}
+      GLOBAL_ID_REGEX = %r{gid:\/\/[\w-]*\/Decidim::Hashtag\/(\d+)\/?(_?)([[:alnum:]](?:[[:alnum:]]|_)*)?\b}
 
       # Replaces found Global IDs matching an existing hashtag with
       # a link to their detail page. The Global IDs representing an
       # invalid Decidim::Hashtag are replaced with an empty string.
       #
+      # links - should render hashtags as links?
+      # extras - should include extra hashtags?
+      #
       # @return [String] the content ready to display (contains HTML)
-      def render
+      def render(links: true, extras: true)
         content.gsub(GLOBAL_ID_REGEX) do |hashtag_gid|
-          begin
-            hashtag = GlobalID::Locator.locate(hashtag_gid)
-            Decidim::HashtagPresenter.new(hashtag).display_hashtag
-          rescue ActiveRecord::RecordNotFound => _ex
-            ""
+          id, extra, cased_name = hashtag_gid.scan(GLOBAL_ID_REGEX).flatten
+          hashtag = hashtags[id.to_i]
+
+          next "" if hashtag.nil? || (!extras && extra.present?)
+
+          presenter = Decidim::HashtagPresenter.new(hashtag, cased_name: cased_name)
+
+          if links
+            presenter.display_hashtag
+          else
+            presenter.display_hashtag_name
           end
         end
       end
 
-      def render_without_link
-        if content.is_a?(Hash)
-          content.each_with_object({}) do |(locale, string), parsed_content|
-            parsed_content[locale] = replace_hashtag_gid_with_hashtag_name(string)
-          end
-        else
-          replace_hashtag_gid_with_hashtag_name(content)
-        end
+      # Returns all the extra hashtags found in the content
+      def extra_hashtags
+        @extra_hashtags ||= existing_hashtags.select { |hashtag| content_extra_hashtags_ids.member?(hashtag.id) }
       end
 
-      def replace_hashtag_gid_with_hashtag_name(content)
-        content.gsub(GLOBAL_ID_REGEX) do |hashtag_gid|
-          begin
-            hashtag = GlobalID::Locator.locate(hashtag_gid)
-            Decidim::HashtagPresenter.new(hashtag).display_hashtag_name
-          rescue ActiveRecord::RecordNotFound => _ex
-            ""
+      private
+
+      def hashtags
+        @hashtags ||= Hash[
+          existing_hashtags.map do |hashtag|
+            [hashtag.id, hashtag]
           end
-        end
+        ]
+      end
+
+      def existing_hashtags
+        @existing_hashtags ||= Decidim::Hashtag.where(id: content_hashtags_ids)
+      end
+
+      def content_hashtags_ids
+        @content_hashtags_ids ||= ids_from_matches(content_matches)
+      end
+
+      def content_extra_hashtags_ids
+        @content_extra_hashtags_ids ||= ids_from_matches(content_matches.select { |match| match[1].present? })
+      end
+
+      def content_matches
+        @content_matches ||= content.scan(GLOBAL_ID_REGEX)
+      end
+
+      def ids_from_matches(matches)
+        matches.map(&:first).map(&:to_i).uniq
       end
     end
   end

data/lib/decidim/core.rb

@@ -52,6 +52,8 @@ module Decidim
   autoload :ContentBlockManifest, "decidim/content_block_manifest"
   autoload :MetricRegistry, "decidim/metric_registry"
   autoload :MetricManifest, "decidim/metric_manifest"
+  autoload :MetricOperation, "decidim/metric_operation"
+  autoload :MetricOperationManifest, "decidim/metric_operation_manifest"
   autoload :NewsletterEncryptor, "decidim/newsletter_encryptor"
   autoload :Searchable, "decidim/searchable"
   autoload :SearchResourceFieldsMapper, "decidim/search_resource_fields_mapper"
@@ -65,9 +67,13 @@ module Decidim
   autoload :DataPortabilitySerializers, "decidim/data_portability_serializers"
   autoload :DataPortabilityFileReader, "decidim/data_portability_file_reader"
   autoload :DataPortabilityFileZipper, "decidim/data_portability_file_zipper"
+  autoload :Amendable, "decidim/amendable"
   autoload :Gamification, "decidim/gamification"
   autoload :Hashtag, "decidim/hashtag"
   autoload :Hashtaggable, "decidim/hashtaggable"
+  autoload :Paddable, "decidim/paddable"
+  autoload :OpenDataExporter, "decidim/open_data_exporter"
+
   include ActiveSupport::Configurable
   # Loads seeds from all engines.
   def self.seed!
@@ -82,7 +88,20 @@ module Decidim
       railtie.load_seed
     end
 
-    participatory_space_manifests.each(&:seed!)
+    participatory_space_manifests.each do |manifest|
+      manifest.seed!
+
+      Organization.all.each do |organization|
+        ContextualHelpSection.set_content(
+          organization,
+          manifest.name,
+          Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+            Decidim::Faker::Localized.sentence(15)
+          end
+        )
+      end
+    end
+
     Gamification.badges.each do |badge|
       puts "Setting random values for the \"#{badge.name}\" badge..."
       User.all.find_each do |user|
@@ -220,12 +239,18 @@ module Decidim
     2.days
   end
 
+  # Exposes a configuration option: an object to configure Etherpad
+  config_accessor :etherpad
+
   # A base path for the uploads. If set, make sure it ends in a slash.
   # Uploads will be set to `<base_path>/uploads/`. This can be useful if you
   # want to use the same uploads place for both staging and production
   # environments, but in different folders.
   config_accessor :base_uploads_path
 
+  # Exposes a configuration option: an object to deliver SMS codes to users.
+  config_accessor :sms_gateway_service
+
   # Public: Registers a global engine. This method is intended to be used
   # by component engines that also offer unscoped functionality
   #
@@ -299,6 +324,14 @@ module Decidim
     resource_registry.register(name, &block)
   end
 
+  # Public: Finds all registered resource manifests via the `register_component`
+  # method.
+  #
+  # Returns an Array[ResourceManifest].
+  def self.resource_manifests
+    resource_registry.manifests
+  end
+
   # Public: Finds all registered component manifest's via the `register_component`
   # method.
   #
@@ -388,8 +421,13 @@ module Decidim
     @traceability ||= Traceability.new
   end
 
-  # Public: Stores an instance of ContentBlockRegistry
+  # Public: Stores an instance of MetricRegistry
   def self.metrics_registry
     @metrics_registry ||= MetricRegistry.new
   end
+
+  # Public: Stores an instance of MetricOperation
+  def self.metrics_operation
+    @metrics_operation ||= MetricOperation.new
+  end
 end