decidim 0.4.4 → 0.5.0

data/decidim-core/app/helpers/decidim/cookies_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This module includes helpers to verify the acceptance of the cookie policy
+  module CookiesHelper
+    # Public: Returns true if the cookie policy has been accepted
+    def cookies_accepted?
+      cookies["decidim-cc"].present?
+    end
+  end
+end

data/decidim-core/app/helpers/decidim/decidim_form_helper.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A heper to expose an easy way to add authorization forms in a view.
+  module DecidimFormHelper
+    # A custom form for that injects client side validations with Abide.
+    #
+    # record - The object to build the form for.
+    # options - A Hash of options to pass to the form builder.
+    # &block - The block to execute as content of the form.
+    #
+    # Returns a String.
+    def decidim_form_for(record, options = {}, &block)
+      options[:data] ||= {}
+      options[:data].update(abide: true, "live-validate" => true, "validate-on-blur" => true)
+      form_for(record, options, &block)
+    end
+
+    # A custom helper to include an editor field without requiring a form object
+    #
+    # name - The input name
+    # value - The input value
+    # 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)
+    #
+    # Returns a rich editor to be included in a html template.
+    def editor_field_tag(name, value, options = {})
+      options[:toolbar] ||= "basic"
+      options[:lines] ||= 10
+
+      content_tag(:div, class: "editor") do
+        template = ""
+        template += label_tag(name, options[:label]) if options[:label] != false
+        template += hidden_field_tag(name, value, options)
+        template += content_tag(:div, nil, class: "editor-container", data: {
+                                  toolbar: options[:toolbar]
+                                }, style: "height: #{options[:lines]}rem")
+        template.html_safe
+      end
+    end
+
+    # A custom helper to include a translated field without requiring a form object.
+    #
+    # type        - The type of the translated input field.
+    # object_name - The object name used to identify the Foundation tabs.
+    # name        - The name of the input which will be suffixed with the corresponding locales.
+    # value       - A hash containing the value for each locale.
+    # options     - An optional hash of options.
+    #             * enable_tabs: Adds the data-tabs attribute so Foundation picks up automatically.
+    #             * tabs_id: The id to identify the Foundation tabs element.
+    #             * label: The label used for the field.
+    #
+    # Returns a Foundation tabs element with the translated input field.
+    def translated_field_tag(type, object_name, name, value = {}, options = {})
+      locales = available_locales
+
+      field_label = label_tag(name, options[:label])
+
+      if locales.count == 1
+        field_input = send(
+          type,
+          "#{name}_#{locales.first.to_s.gsub("-", "__")}"
+        )
+
+        return safe_join [field_label, field_input]
+      end
+
+      tabs_id = options[:tabs_id] || "#{object_name}-#{name}-tabs"
+      enabled_tabs = options[:enable_tabs].nil? ? true : options[:enable_tabs]
+      tabs_panels_data = enabled_tabs ? { tabs: true } : {}
+
+      label_tabs = content_tag(:div, class: "label--tabs") do
+        tabs_panels = "".html_safe
+        if options[:label] != false
+          tabs_panels = content_tag(:ul, class: "tabs tabs--lang", id: tabs_id, data: tabs_panels_data) 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.with_locale(locale) { I18n.t("name", scope: "locale") }
+                tab_content_id = "#{tabs_id}-#{name}-panel-#{index}"
+                content_tag(:a, title, href: "##{tab_content_id}")
+              end
+            end
+          end
+        end
+
+        safe_join [field_label, tabs_panels]
+      end
+
+      tabs_content = content_tag(:div, class: "tabs-content", data: { tabs_content: tabs_id }) do
+        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, "#{object_name}[#{name_with_locale(name, locale)}]", value[locale.to_s], options.merge(id: "#{tabs_id}_#{name}_#{locale}", label: false))
+          end
+        end
+      end
+
+      safe_join [label_tabs, tabs_content]
+    end
+
+    # Helper method used by `translated_field_tag`
+    def tab_element_class_for(type, index)
+      element_class = "tabs-#{type}"
+      element_class += " is-active" if index.zero?
+      element_class
+    end
+
+    # Helper method used by `translated_field_tag`
+    def name_with_locale(name, locale)
+      "#{name}_#{locale.to_s.gsub("-", "__")}"
+    end
+  end
+end

data/decidim-core/app/helpers/decidim/feature_path_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A helper to get the root path for a feature.
+  module FeaturePathHelper
+    # Returns the defined root path for a given feature.
+    #
+    # feature - the Feature we want to find the root path for.
+    #
+    # Returns a url.
+    def main_feature_path(feature)
+      feature_root_path_for(feature.manifest.engine, feature)
+    end
+
+    # Returns the defined admin root path for a given feature.
+    #
+    # feature - the Feature we want to find the root path for.
+    #
+    # Returns a url.
+    def manage_feature_path(feature)
+      feature_root_path_for(feature.manifest.admin_engine, feature)
+    end
+
+    private
+
+    def feature_root_path_for(engine, feature)
+      url_params = {
+        feature_id: feature.id,
+        participatory_process_id: feature.participatory_process.id
+      }
+
+      engine.routes.url_helpers.root_path(url_params)
+    end
+  end
+end

data/decidim-core/app/helpers/decidim/feature_reference_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Helper to print Feature references.
+  module FeatureReferenceHelper
+    # Displays the localized reference for the given feature.
+    #
+    # feature - the Feature that has the reference to display.
+    # options - An optional hash of options
+    #         * class: A string of extra css classes
+    #
+    # Returns a String.
+    def feature_reference(feature, options = {})
+      return unless feature.reference
+      @reference = feature.reference
+      "<div class='reference #{options[:class]}'>#{localized_reference}</div>".html_safe
+    end
+
+    private
+
+    def localized_reference
+      I18n.t("reference", reference: @reference, scope: "decidim.shared.reference")
+    end
+  end
+end

data/decidim-core/app/helpers/decidim/filters_helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Helper that provides a single method to create filter resource forms
+  module FiltersHelper
+    # This method wraps everything in a div with class filters and calls
+    # the form_for helper with a custom builder
+    #
+    # filter - A filter object
+    # block  - A block to be called with the form builder
+    #
+    # Returns the filter resource form wrapped in a div
+    def filter_form_for(filter)
+      content_tag :div, class: "filters" do
+        form_for filter, builder: FilterFormBuilder, url: url_for, as: :filter, method: :get, remote: true, html: { id: nil } do |form|
+          yield form
+        end
+      end
+    end
+  end
+end

data/decidim-core/app/helpers/decidim/humanize_booleans_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Helper to print booleans in a human way.
+  module HumanizeBooleansHelper
+    # Displays booleans in a human way (yes/no, supporting i18n). Supports
+    # `nil` values as `false`.
+    #
+    # boolean - a Boolean that will be displayed in a human way.
+    def humanize_boolean(boolean)
+      value = boolean ? "true" : "false"
+      I18n.t(value, scope: "booleans")
+    end
+  end
+end

data/decidim-core/app/helpers/decidim/icon_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Helpers related to icons
+  module IconHelper
+    # Public: Returns an icon given an instance of a Feature. It defaults to
+    # a question mark when no icon is found.
+    #
+    # feature - The feature to generate the icon for.
+    #
+    # Returns an HTML tag with the icon.
+    def feature_icon(feature)
+      feature_manifest_icon(feature.manifest)
+    end
+
+    # Public: Returns an icon given an instance of a Feature Manifest. It defaults to
+    # a question mark when no icon is found.
+    #
+    # feature_manifest - The feature manifest to generate the icon for.
+    #
+    # Returns an HTML tag with the icon.
+    def feature_manifest_icon(feature_manifest)
+      if feature_manifest.icon
+        external_icon feature_manifest.icon
+      else
+        icon "question-mark"
+      end
+    end
+  end
+end

data/decidim-core/app/helpers/decidim/language_chooser_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A Helper to render language names in their own language.
+  module LanguageChooserHelper
+    # Gets the name of the given locale, in that language.
+    #
+    # Example:
+    #
+    #   locale_name(:es) => "Castellano"
+    #
+    # locale - a String representing the symbol of the locale. It will usually be 2 letters.
+    #
+    # Returns a String.
+    def locale_name(locale)
+      I18n.with_locale(locale) { I18n.t("name", scope: "locale") }
+    end
+  end
+end

data/decidim-core/app/helpers/decidim/layout_helper.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Decidim
+  # View helpers related to the layout.
+  module LayoutHelper
+    # Public: Generates a set of meta tags that generate the different favicon
+    # versions for an organization.
+    #
+    # Returns a safe String with the versions.
+    def favicon
+      return unless current_organization.favicon.present?
+
+      safe_join(Decidim::OrganizationFaviconUploader::SIZES.map do |version, size|
+        favicon_link_tag(current_organization.favicon.send(version).url, sizes: "#{size}x#{size}")
+      end)
+    end
+
+    # Outputs an SVG-based icon.
+    #
+    # name    - The String with the icon name.
+    # options - The Hash options used to customize the icon (default {}):
+    #             :width  - The Number of width in pixels (optional).
+    #             :height - The Number of height in pixels (optional).
+    #             :aria_label - The String to set as aria label (optional).
+    #             :aria_hidden - The Truthy value to enable aria_hidden (optional).
+    #             :role - The String to set as the role (optional).
+    #             :class - The String to add as a CSS class (optional).
+    #
+    # Returns a String.
+    def icon(name, options = {})
+      # Ugly hack to work around the issue of phantomjs not sending js events
+      # when clicking on a SVG element.
+      if Rails.env.test?
+        return content_tag(:span, "?", class: "icon icon--#{name}")
+      end
+
+      html_properties = {}
+
+      html_properties["width"] = options[:width]
+      html_properties["height"] = options[:height]
+      html_properties["aria-label"] = options[:aria_label]
+      html_properties["role"] = options[:role]
+      html_properties["aria-hidden"] = options[:aria_hidden]
+
+      html_properties["class"] = (["icon--#{name}"] + _icon_classes(options)).join(" ")
+
+      content_tag :svg, html_properties do
+        content_tag :use, nil, "xlink:href" => "#{asset_path("decidim/icons.svg")}#icon-#{name}"
+      end
+    end
+
+    # Outputs a SVG icon from an external file. It apparently renders an image
+    # tag, but then a JS script kicks in and replaces it with an inlined SVG
+    # version.
+    #
+    # path    - The asset's path
+    #
+    # Returns an <img /> tag with the SVG icon.
+    def external_icon(path, options = {})
+      # Ugly hack to prevent PhantomJS from freaking out with SVGs.
+      classes = _icon_classes(options) + ["external-icon"]
+      return content_tag(:span, "?", class: classes.join(" "), "data-src" => path) if Rails.env.test?
+
+      if path.split(".").last == "svg"
+        asset = Rails.application.assets_manifest.find_sources(path).first
+        asset.gsub("<svg ", "<svg class=\"#{classes.join(" ")}\" ").html_safe
+      else
+        image_tag(path, class: classes.join(" "), style: "display: none")
+      end
+    end
+
+    def _icon_classes(options = {})
+      classes = options[:remove_icon_class] ? [] : ["icon"]
+      classes += [options[:class]]
+      classes.compact
+    end
+  end
+end

data/decidim-core/app/helpers/decidim/localized_locales_helper.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A helper that converts an array of locale IDs (two-letter identifiers, e.g.
+  # `"en"`) to an array of Objects that have both the ID and their name in
+  # their own language (e.g., `"English"`).
+  #
+  # This is intended to be used in forms, when selecting the default locale
+  # form a given list, or when creating a list of radio buttons, for example.
+  #
+  # Examples:
+  #
+  #   <%= form.collection_select :default_locale, localized_locales(current_organization.available_locales), :id, :name %>
+  #
+  #   <% localized_locales(current_organization.available_locales).each do |locale| %>
+  #     <p><%= locale.name %></p>
+  #   <% end %>
+  #
+  module LocalizedLocalesHelper
+    # Converts a given array of strings to an array of Objects representing
+    # locales.
+    #
+    # collection - an Array of Strings. By default it uses all the available
+    #   locales in Decidim, but you can passa nother collection of locales (for
+    #   example, the available locales for an organization)
+    def localized_locales(collection = Decidim.available_locales)
+      klass = Class.new do
+        def initialize(locale)
+          @locale = locale
+        end
+
+        def id
+          @locale.to_s
+        end
+
+        def name
+          I18n.with_locale(@locale) { I18n.t("name", scope: "locale") }
+        end
+      end
+
+      collection.map { |locale| klass.new(locale) }
+    end
+  end
+end

data/decidim-core/app/helpers/decidim/map_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This helper include some methods for rendering resources static and dynamic maps.
+  module MapHelper
+    # Renders a link to openstreetmaps with the resource latitude and longitude.
+    # The link's content is a static map image.
+    #
+    # resource - A geolocalizable resource
+    # options - An optional hash of options (default: { zoom: 17 })
+    #           * zoom: A number to represent the zoom value of the map
+    def static_map_link(resource, options = {})
+      return unless resource.geocoded?
+
+      zoom = options[:zoom] || 17
+      latitude = resource.latitude
+      longitude = resource.longitude
+
+      map_url = "https://www.openstreetmap.org/?mlat=#{latitude}&mlon=#{longitude}#map=#{zoom}/#{latitude}/#{longitude}"
+
+      link_to map_url, target: "_blank" do
+        image_tag decidim.static_map_path(sgid: resource.to_sgid.to_s)
+      end
+    end
+
+    def dynamic_map_for(markers_data)
+      return unless Decidim.geocoder.present?
+
+      map_html_options = {
+        class: "google-map",
+        id: "map",
+        "data-markers-data" => markers_data.to_json,
+        "data-here-app-id" => Decidim.geocoder[:here_app_id],
+        "data-here-app-code" => Decidim.geocoder[:here_app_code]
+      }
+      content = capture { yield }
+      content_tag :div, class: "row column" do
+        content_tag(:div, "", map_html_options) + content
+      end
+    end
+  end
+end