decidim 0.4.4 → 0.5.0

data/decidim-core/lib/decidim/has_attachments.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the features needed when you want a model to be able to create
+  # links from it to another resource.
+  module HasAttachments
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :attachments,
+               class_name: "Decidim::Attachment",
+               dependent: :destroy,
+               inverse_of: :attached_to,
+               as: :attached_to
+
+      # All the attachments that are photos for this process.
+      #
+      # Returns an Array<Attachment>
+      def photos
+        @photos ||= attachments.select(&:photo?)
+      end
+
+      # All the attachments that are documents for this process.
+      #
+      # Returns an Array<Attachment>
+      def documents
+        @documents ||= attachments.select(&:document?)
+      end
+    end
+  end
+end

data/decidim-core/lib/decidim/has_category.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the features needed when you want a model to have a category.
+  module HasCategory
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :categorization, as: :categorizable
+      has_one :category, through: :categorization
+
+      validate :category_belongs_to_organization
+
+      private
+
+      def category_belongs_to_organization
+        return unless category
+        errors.add(:category, :invalid) unless feature.categories.where(id: category.id).exists?
+      end
+    end
+  end
+end

data/decidim-core/lib/decidim/has_feature.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "decidim/feature_validator"
+
+module Decidim
+  # A concern with the features needed when you want a model to have a feature.
+  module HasFeature
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :feature, foreign_key: "decidim_feature_id", class_name: "Decidim::Feature"
+      has_one :organization, through: :feature
+    end
+
+    class_methods do
+      def feature_manifest_name(manifest_name)
+        validates :feature, feature: { manifest: manifest_name || name.demodulize.pluralize.downcase }
+      end
+    end
+  end
+end

data/decidim-core/lib/decidim/has_reference.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the features needed when you want a model to have a
+  # reference.
+  module HasReference
+    extend ActiveSupport::Concern
+
+    included do
+      after_commit :store_reference
+
+      validates :reference, presence: true, on: :update
+
+      def reference
+        self[:reference] || calculate_reference
+      end
+
+      private
+
+      # Public: Calculates a unique reference for the model using the function
+      # provided by configuration
+      #
+      # Returns a String.
+      def calculate_reference
+        return unless feature
+        Decidim.resource_reference_generator.call(self, feature)
+      end
+
+      # Internal: Sets the unique reference to the model.
+      #
+      # Returns nothing.
+      def store_reference
+        self[:reference] ||= calculate_reference
+        save if changed?
+      end
+    end
+  end
+end

data/decidim-core/lib/decidim/has_scope.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the features needed when you want a model to have a scope.
+  module HasScope
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :scope,
+                 foreign_key: "decidim_scope_id",
+                 class_name: "Decidim::Scope",
+                 optional: true
+      validate :scope_belongs_to_organization
+
+      private
+
+      def scope_belongs_to_organization
+        return if !scope || !feature
+        errors.add(:scope, :invalid) unless feature.scopes.where(id: scope.id).exists?
+      end
+    end
+  end
+end

data/decidim-core/lib/decidim/has_settings.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module HasSettings
+    extend ActiveSupport::Concern
+
+    included do
+      after_initialize :default_values
+    end
+
+    def settings
+      settings_schema(:global).new(self[:settings]["global"])
+    end
+
+    def settings=(data)
+      self[:settings]["global"] = serialize_settings(settings_schema(:global), data)
+    end
+
+    def default_step_settings
+      settings_schema(:step).new(self[:settings]["default_step"])
+    end
+
+    def default_step_settings=(data)
+      self[:settings]["default_step"] = serialize_settings(settings_schema(:step), data)
+    end
+
+    def step_settings
+      participatory_process.steps.each_with_object({}) do |step, result|
+        result[step.id.to_s] = settings_schema(:step).new(self[:settings].dig("steps", step.id.to_s))
+      end
+    end
+
+    def step_settings=(data)
+      self[:settings]["steps"] = data.each_with_object({}) do |(key, value), result|
+        result[key.to_s] = serialize_settings(settings_schema(:step), value)
+      end
+    end
+
+    def active_step_settings
+      active_step = participatory_process.active_step
+      return default_step_settings unless active_step
+
+      step_settings.fetch(active_step.id.to_s)
+    end
+
+    private
+
+    def serialize_settings(schema, value)
+      if value.respond_to?(:attributes)
+        value.attributes
+      else
+        schema.new(value)
+      end
+    end
+
+    def settings_schema(name)
+      manifest.settings(name.to_sym).schema
+    end
+
+    def default_values
+      self[:settings] ||= {}
+    end
+  end
+end

data/decidim-core/lib/decidim/i18n_exceptions.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+unless Rails.env.production?
+  module I18n
+    class JustRaiseExceptionHandler < ExceptionHandler
+      def call(exception, locale, key, options)
+        if exception.is_a?(MissingTranslationData) || exception.is_a?(MissingTranslation)
+          raise exception.to_exception
+        end
+
+        super
+      end
+    end
+  end
+
+  I18n.exception_handler = I18n::JustRaiseExceptionHandler.new
+end

data/decidim-core/lib/decidim/manifest_registry.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Decidim
+  #
+  # Takes care of holding and serving globally registered manifests.
+  #
+  class ManifestRegistry
+    def initialize(entity)
+      @entity = entity
+    end
+
+    def register(name)
+      manifest = manifest_class.new(name: name.to_sym)
+      yield(manifest)
+      manifest.validate!
+      manifests << manifest
+    end
+
+    def manifests
+      @manifests ||= Set.new
+    end
+
+    def find(name)
+      manifests.find { |manifest| manifest.name == name }
+    end
+
+    def resource_manifests
+      @resource_manifests ||= manifests.flat_map(&:resource_manifests)
+    end
+
+    def find_resource_manifest(resource_name_or_klass)
+      resource_manifests.find do |manifest|
+        manifest.model_class == resource_name_or_klass || manifest.name.to_s == resource_name_or_klass.to_s
+      end
+    end
+
+    private
+
+    def manifest_class
+      case @entity
+      when :features then FeatureManifest
+      end
+    end
+  end
+end

data/decidim-core/lib/decidim/menu.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Decidim
+  #
+  # This class handles all logic regarding registering menus
+  #
+  class Menu
+    def initialize(name)
+      @name = name
+      @items = []
+    end
+
+    #
+    # Evaluates the registered configurations for this menu in a view context
+    #
+    def build_for(context)
+      registry.configurations.each do |configuration|
+        context.instance_exec(self, &configuration)
+      end
+    end
+
+    # Public: Registers a new item for the menu
+    #
+    # @param label [String, Symbol] A compulsory label for the menu item
+    # @param url [String, Symbol] The URL this item will link to
+    # @param options [Hash] The options for the menu item
+    #
+    # @option options [Float] :position
+    #         The lower the position, the earlier in the menu the item will
+    #         be displayed.  Default: Float::INFINITY
+    #
+    # @option options [Symbol, Proc] :if
+    #         Decides whether the menu item will be displayed. Evaluated on
+    #         each request.
+    #
+    # @example
+    #
+    #   menu.item "My Resource", "/resources"
+    #   menu.item I18n.t("menu.meetings"), decidim_meetings.root_path
+    #   menu.item current_user.username, decidim.profile_path
+    #   menu.item "Gestor de Procesos", "/processes", active: :exact
+    #   menu.item "Gestor de Procesos", "/processes", if: admin?
+    #
+    def item(label, url, options = {})
+      @items << MenuItem.new(label, url, options)
+    end
+
+    #
+    # The weighted list of items in the menu
+    #
+    def items
+      @items.select(&:visible?).sort_by(&:position)
+    end
+
+    private
+
+    def registry
+      @registry ||= MenuRegistry.find(@name)
+    end
+  end
+end

data/decidim-core/lib/decidim/menu_item.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  #
+  # This class handles all logic regarding menu items
+  #
+  class MenuItem
+    # Builds a new menu item
+    #
+    # @param label [String, Symbol] A compulsory label for the menu item
+    # @param url [String, Symbol] The URL this item will link to
+    # @param options [Hash] The options for the menu item
+    #
+    def initialize(label, url, options = {})
+      @label = label
+      @url = url
+      @position = options[:position] || Float::INFINITY
+      @if = options[:if]
+      @active = options[:active]
+      @icon_name = options[:icon_name]
+    end
+
+    attr_reader :label, :url, :position, :active, :icon_name
+
+    def visible?
+      return true if @if.nil? || @if
+
+      false
+    end
+  end
+end

data/decidim-core/lib/decidim/menu_registry.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Decidim
+  #
+  # This class handles all logic regarding registering menus
+  #
+  class MenuRegistry
+    class << self
+      #
+      # Finds a menu by name or creates it if it doesn't exist. Optionally,
+      # registers a MenuItem DSL block for the menu.
+      #
+      # @param name [Symbol] Name of the menu
+      # @param &block [Menu] Registration body of the menu. It's stored to be
+      #                      evaluated at rendering time
+      #
+      def register(name, &block)
+        menu = find(name) || create(name)
+
+        menu.configurations << block
+
+        menu
+      end
+
+      #
+      # Finds a menu by name
+      #
+      # @param name [Symbol] The name of the menu
+      #
+      def find(name)
+        all[name]
+      end
+
+      #
+      # Creates an empty named menu
+      #
+      # @param name [Symbol] The name of the menu
+      #
+      def create(name)
+        all[name] = new
+      end
+
+      #
+      # Destroys a named menu
+      #
+      # @param name [Symbol] The name of the menu
+      #
+      def destroy(name)
+        all[name] = nil
+      end
+
+      private
+
+      def all
+        @all ||= {}
+      end
+    end
+
+    attr_reader :configurations
+
+    def initialize
+      @configurations = []
+    end
+  end
+end