decidim-core 0.0.1.alpha9 → 0.0.1

data/lib/decidim/core/engine.rb

@@ -9,11 +9,10 @@ require "devise"
 require "devise-i18n"
 require "devise_invitable"
 require "jquery-rails"
-require "sass-rails"
+require "sassc-rails"
 require "turbolinks"
 require "foundation-rails"
 require "foundation_rails_helper"
-require "jbuilder"
 require "active_link_to"
 require "rectify"
 require "roadie-rails"
@@ -23,6 +22,12 @@ require "rails-i18n"
 require "date_validator"
 require "sprockets/es6"
 require "cancancan"
+require "truncato"
+require "file_validators"
+
+require "decidim/api"
+
+require "decidim/query_extensions"
 
 module Decidim
   module Core
@@ -64,6 +69,15 @@ module Decidim
           config.abilities << Abilities::Everyone
         end
       end
+
+      initializer "decidim.locales" do |app|
+        app.config.i18n.available_locales = Decidim.config.available_locales
+        app.config.i18n.fallbacks = true
+      end
+
+      initializer "decidim.query_extensions" do
+        QueryExtensions.extend!(Decidim::Api::QueryType)
+      end
     end
   end
 end

data/lib/decidim/core/version.rb

@@ -2,10 +2,19 @@
 # This holds Decidim's version and the Rails version on which it depends.
 module Decidim
   def self.version
-    "0.0.1.alpha9"
+    "0.0.1"
   end
 
   def self.rails_version
-    "~> 5.0.0"
+    ["~> 5.0.0", ">= 5.0.0.1"]
+  end
+
+  def self.add_default_gemspec_properties(spec)
+    spec.version = Decidim.version
+    spec.authors = ["Josep Jaume Rey Peroy", "Marc Riera Casals", "Oriol Gual Oliva"]
+    spec.email = ["josepjaume@gmail.com", "mrc2407@gmail.com", "oriolgual@gmail.com"]
+    spec.license = "AGPLv3"
+    spec.homepage = "https://github.com/AjuntamentdeBarcelona/decidim"
+    spec.required_ruby_version = ">= 2.3.1"
   end
 end

data/lib/decidim/feature_manifest.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+module Decidim
+  # This class handles all the logic associated to configuring a feature
+  # associated to a participatory process.
+  #
+  # It's normally not used directly but through the API exposed through
+  # `Decidim.register_feature`.
+  class FeatureManifest
+    include ActiveModel::Model
+    include Virtus.model
+
+    attribute :admin_engine, Rails::Engine
+    attribute :engine, Rails::Engine
+
+    attribute :name, Symbol
+    attribute :hooks, Hash[Symbol => Array[Proc]], default: {}
+
+    validates :name, presence: true
+
+    # Public: Registers a hook to this manifest. Hooks get fired when some
+    # lifecycle events happen, like the creation of a component or its
+    # destruction.
+    #
+    # event_name - A String or Symbol with the event name.
+    # &block     - The block to run when the hook gets triggered.
+    #
+    # Returns nothing.
+    def on(event_name, &block)
+      hooks[event_name.to_sym] ||= []
+      hooks[event_name.to_sym] << block
+    end
+
+    # Public: Runs all the hooks associated with this manifest and a particular
+    # event.
+    #
+    # event_name - A String or Symbol with the event name.
+    # context    - An optional context that will be provided to the block as a
+    #              parameter. Usually the subject of the hook, mostly the
+    #              Component.
+    #
+    # Returns nothing.
+    def run_hooks(event_name, context = nil)
+      return unless hooks[event_name]
+      hooks[event_name.to_sym].each do |hook|
+        hook.call(context)
+      end
+    end
+
+    # Semiprivate: Resets all the hooks of this manifest. Mostly useful when
+    # testing.
+    #
+    # Returns nothing.
+    def reset_hooks!
+      self.hooks = {}
+    end
+
+    # Public: A block that gets called when seeding for this feature takes place.
+    #
+    # Returns nothing.
+    def seeds(&block)
+      @seeds = block
+    end
+
+    # Public: Creates the seeds for this features in order to populate the database.
+    #
+    # Returns nothing.
+    def seed!
+      @seeds&.call
+    end
+  end
+end

data/lib/decidim/features.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Decidim
+  # This module contains all logic related to decidim's Features, the main
+  # building block to extend functionalities in a participatory process.
+  module Features
+    autoload :BaseController, "decidim/features/base_controller"
+  end
+end

data/lib/decidim/features/base_controller.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Features
+    # Controller from which all feature engines inherit from. It's in charge of
+    # setting the appropiate layout, including necessary helpers, and overall
+    # fooling the engine into thinking it's isolated.
+    class BaseController < Decidim::ApplicationController
+      layout "layouts/decidim/participatory_process"
+      include NeedsParticipatoryProcess
+      helper Decidim::TranslationsHelper
+      helper Decidim::ParticipatoryProcessHelper
+      helper_method :current_feature
+
+      skip_authorize_resource
+
+      before_action do
+        authorize! :read, current_participatory_process
+      end
+
+      private
+
+      def current_feature
+        request.env["decidim.current_feature"]
+      end
+
+      def current_participatory_process
+        request.env["decidim.current_participatory_process"]
+      end
+    end
+  end
+end

data/lib/decidim/features/namer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Features
+    # This class automatically names features for the given organization.
+    # In order to do so, it uses the i18n keys of the feature, fallback to English,
+    # searching for the key `"decidim.features.<feature name>.name"`
+    #
+    # This is intended to be used from the feature seeds section.
+    #
+    # Examples:
+    #
+    #   Decidim::Feature.create!(
+    #     participatory_process: process,
+    #     name: Decidim::Feature::Namer.new(organization.available_locales, :my_feature_name).i18n_name
+    #     manifest_name: :my_feature_name
+    #   )
+    class Namer
+      def initialize(locales, feature_name)
+        @locales = locales
+        @feature_name = feature_name
+      end
+
+      def i18n_name
+        locales.inject({}) do |names, locale|
+          names.update(locale => I18n.t("decidim.features.#{feature_name}.name", locale: locale))
+        end
+      end
+
+      private
+
+      attr_reader :locales, :feature_name
+    end
+  end
+end

data/lib/decidim/form_builder.rb

@@ -5,6 +5,8 @@ module Decidim
   # This custom FormBuilder adds fields needed to deal with translatable fields,
   # following the conventions set on `Decidim::TranslatableAttributes`.
   class FormBuilder < FoundationRailsHelper::FormBuilder
+    include ActionView::Context
+
     # Public: Generates an form field for each locale.
     #
     # type - The form field's type, like `text_area` or `text_input`
@@ -13,18 +15,135 @@ module Decidim
     #
     # Renders form fields for each locale.
     def translated(type, name, options = {})
-      locales.map do |locale|
-        label = options[:label] || label_for(name)
-        language = locale
+      if locales.count == 1
+        return send(
+          type,
+          "#{name}_#{locales.first.to_s.gsub("-", "__")}",
+          options.merge(label: options[:label] || label_for(name))
+        )
+      end
+
+      field_label = label_i18n(name, options[:label] || label_for(name))
 
-        send(type, "#{name}_#{locale.to_s.gsub("-", "__")}", options.merge(label: "#{label} (#{language})"))
-      end.join.html_safe
+      tabs_panels = "".html_safe
+      if options[:label] != false
+        tabs_panels = content_tag(:ul, class: "tabs", id: "#{name}-tabs", data: { tabs: true }) do
+          locales.each_with_index.inject("".html_safe) do |string, (locale, index)|
+            string + content_tag(:li, class: tab_element_class_for("title", index)) do
+              title = I18n.t(locale, scope: "locales")
+              element_class = ""
+              element_class += "alert" if has_error?(name_with_locale(name, locale))
+              content_tag(:a, title, href: "##{name}-panel-#{index}", class: element_class)
+            end
+          end
+        end
+      end
+
+      tabs_content = content_tag(:div, class: "tabs-content", data: { tabs_content: "#{name}-tabs" }) do
+        locales.each_with_index.inject("".html_safe) do |string, (locale, index)|
+          string + content_tag(:div, class: tab_element_class_for("panel", index), id: "#{name}-panel-#{index}") do
+            send(type, name_with_locale(name, locale), options.merge(label: false))
+          end
+        end
+      end
+
+      safe_join [field_label, tabs_panels, tabs_content]
+    end
+
+    # Public: generates a hidden field and a container for WYSIWYG editor
+    #
+    # name - The name of the field
+    # options - The set of options to send to the field
+    #           :label   - The Boolean value to create or not the input label (optional) (default: true)
+    #           :toolbar - The String value to configure WYSIWYG toolbar. It should be 'basic' or
+    #                      or 'full' (optional) (default: 'basic')
+    #           :lines   - The Integer to indicate how many lines should editor have (optional) (default: 10)
+    #
+    # Renders a container with both hidden field and editor container
+    def editor(name, options = {})
+      options[:toolbar] ||= "basic"
+      options[:lines] ||= 10
+
+      content_tag(:div, class: "editor") do
+        template = ""
+        template += label(name) if options[:label] != false
+        template += hidden_field(name, options)
+        template += content_tag(:div, nil, class: "editor-container", data: {
+                                  toolbar: options[:toolbar]
+                                }, style: "height: #{options[:lines]}rem")
+        template += error_for(name, options) if has_error?(name)
+        template.html_safe
+      end
+    end
+
+    # Public: Generates a select field with the categories. Only leaf categories can be set as selected.
+    #
+    # name       - The name of the field (usually category_id)
+    # collection - A collection of categories.
+    # options    - An optional Hash with options:
+    # - prompt   - An optional String with the text to display as prompt.
+    # - disable_parents - A Boolean to disable parent categories. Defaults to `true`.
+    #
+    # Returns a String.
+    def categories_select(name, collection, options = {})
+      options = {
+        prompt: nil,
+        disable_parents: true
+      }.merge(options)
+
+      prompt = options[:prompt]
+      disable_parents = options[:disable_parents]
+
+      selected = object.send(name)
+      categories = categories_for_select(collection)
+      categories = [[prompt]] + categories if prompt
+      disabled = if disable_parents
+                   disabled_categories_for(collection)
+                 else
+                   []
+                 end
+
+      select(name, @template.options_for_select(categories, selected: selected, disabled: disabled))
     end
 
     private
 
+    def categories_for_select(scope)
+      sorted_main_categories = scope.first_class.includes(:subcategories).sort_by do |category|
+        category.name[I18n.locale.to_s]
+      end
+
+      sorted_main_categories.flat_map do |category|
+        parent = [[category.name[I18n.locale.to_s], category.id]]
+
+        sorted_subcategories = category.subcategories.sort_by do |subcategory|
+          subcategory.name[I18n.locale.to_s]
+        end
+
+        sorted_subcategories.each do |subcategory|
+          parent << ["- #{subcategory.name[I18n.locale.to_s]}", subcategory.id]
+        end
+
+        parent
+      end
+    end
+
+    def disabled_categories_for(scope)
+      scope.first_class.joins(:subcategories).pluck(:id)
+    end
+
+    def tab_element_class_for(type, index)
+      element_class = "tabs-#{type}"
+      element_class += " is-active" if index.zero?
+      element_class
+    end
+
     def locales
-      I18n.available_locales
+      @locales ||= if @template.respond_to?(:available_locales)
+                     Set.new([@template.current_locale] + @template.available_locales).to_a
+                   else
+                     Decidim.available_locales
+                   end
     end
 
     def label_for(attribute)
@@ -34,5 +153,20 @@ module Decidim
         attribute.to_s.humanize
       end
     end
+
+    def name_with_locale(name, locale)
+      "#{name}_#{locale.to_s.gsub("-", "__")}"
+    end
+
+    def label_i18n(attribute, text = nil, options = {})
+      errored = has_error?(attribute) || locales.any? { |locale| has_error?(name_with_locale(attribute, locale)) }
+
+      if errored
+        options[:class] ||= ""
+        options[:class] += " is-invalid-label"
+      end
+
+      label(attribute, (text || "").html_safe, options)
+    end
   end
 end

data/lib/decidim/page_finder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Decidim
+  # A custom implementation for HighVoltage so we can correctly find which page
+  # to render. We need this because we allow rendering pages with content from
+  # the database (with Decidim::Page) but also fallback to a template if it
+  # exists.
+  class PageFinder < HighVoltage::PageFinder
+    DECIDIM_PAGE_TEMPLATE = "decidim_page"
+
+    # Initializes the finder.
+    #
+    # page_id - A String with the id or slug of the page to render.
+    # organization - A Decidim::Organization to look for pages in.
+    def initialize(page_id, organization)
+      @page_id = page_id
+      @organization = organization
+    end
+
+    # Finds a Decidim::Page by slug.
+    #
+    # Returns a Decidim::Page or nil.
+    def page
+      @page ||= organization.static_pages.where(slug: page_id).first
+    end
+
+    private
+
+    attr_reader :organization
+
+    # Overwrite HighVoltage::PageFinder method to return a specific template
+    # when we need to render a Decidim::Page.
+    #
+    # Returns a String.
+    def clean_path
+      return super unless page.present?
+
+      DECIDIM_PAGE_TEMPLATE
+    end
+
+    # Overwrite HighVoltage::PageFinder method to not allow rendering the
+    # template used to render Decidim::Pages without a page.
+    #
+    # Returns a Boolean.
+    def invalid_page_id?(id)
+      super || id == DECIDIM_PAGE_TEMPLATE
+    end
+  end
+end

data/lib/decidim/query_extensions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Decidim
+  # This module's job is to extend the API with custom fields related to
+  # decidim-core.
+  module QueryExtensions
+    # Public: Extends a type with `decidim-core`'s fields.
+    #
+    # type - A GraphQL::BaseType to extend.
+    #
+    # Returns nothing.
+    def self.extend!(type)
+      type.define do
+        field :processes do
+          type !types[ProcessType]
+          description "Lists all processes."
+
+          resolve ->(_obj, _args, ctx) {
+            OrganizationParticipatoryProcesses.new(ctx[:current_organization])
+          }
+        end
+
+        field :currentUser do
+          type UserType
+          description "Return's information about the logged in user"
+
+          resolve ->(_obj, _args, ctx) {
+            ctx[:current_user]
+          }
+        end
+      end
+    end
+  end
+end