decidim-term_customizer 0.16.0

data/config/locales/sv.yml

@@ -0,0 +1,65 @@
+sv:
+  decidim:
+    admin:
+      actions:
+        add_multiple_translations: Add multiple
+        back: Back
+        new_translation_set: New translation set
+        new_translation: New translation
+      models:
+        translation_sets:
+          fields:
+            name: Name
+        translations:
+          fields:
+            key: Key
+            term: Term
+      titles:
+        translation_sets: Translation sets
+        translations: Translations
+    term_customizer:
+      admin:
+        add_translations:
+          index:
+            add: Add
+            search: Search
+        translation_sets:
+          constraint_fields:
+            constraint: Constraint
+            remove: Remove
+          create:
+            success: Translation set successfully created.
+            error: Error creating translation set.
+          destroy:
+            success: Translation set successfully deleted.
+          edit:
+            title: Translation set
+            save: Save
+          form:
+            add_constraint: Add constraint
+            title: Translation set
+          new:
+            create: Create
+            title: Translation sets
+          update:
+            success: Translation set successfully updated.
+            error: Error updating translation set.
+        translations:
+          create:
+            success: Translation successfully created.
+            error: Error creating translation.
+          destroy:
+            success: Translation successfully deleted.
+          edit:
+            title: Translation
+            save: Save
+          form:
+            title: Translation
+          new:
+            create: Create
+            title: Translations
+          update:
+            success: Translation successfully updated.
+            error: Error updating translation.
+      menu:
+        term_customizer: Term customizer

data/lib/decidim/term_customizer/admin.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    # This module contains all the domain logic associated to Decidim Term
+    # Customizer's admin panel.
+    module Admin
+    end
+  end
+end

data/lib/decidim/term_customizer/admin_engine.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    class AdminEngine < ::Rails::Engine
+      isolate_namespace Decidim::TermCustomizer::Admin
+
+      paths["db/migrate"] = nil
+      paths["lib/tasks"] = nil
+
+      routes do
+        resources :translation_sets, path: :sets, except: [:show] do
+          resources :translations, except: [:show]
+          resources :add_translations, only: [:index, :create] do
+            collection do
+              get :search
+            end
+          end
+        end
+
+        root to: "translation_sets#index"
+      end
+
+      initializer "decidim_term_customizer.admin_mount_routes" do
+        Decidim::Core::Engine.routes do
+          mount Decidim::TermCustomizer::AdminEngine, at: "/admin/term_customizer", as: "decidim_admin_term_customizer"
+        end
+      end
+
+      initializer "decidim_term_customizer.admin_assets" do |app|
+        app.config.assets.precompile += %w(translation_sets_admin_manifest.js)
+      end
+
+      initializer "decidim_term_customizer.admin_menu" do
+        Decidim.menu :admin_menu do |menu|
+          menu.item I18n.t("menu.term_customizer", scope: "decidim.term_customizer"),
+                    decidim_admin_term_customizer.translation_sets_path,
+                    icon_name: "text",
+                    position: 7.1,
+                    active: :inclusive,
+                    if: allowed_to?(:update, :organization, organization: current_organization)
+        end
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/engine.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    class Engine < ::Rails::Engine
+      isolate_namespace Decidim::TermCustomizer
+
+      initializer "decidim_term_customizer.setup" do
+        customizer_backend = Decidim::TermCustomizer::I18nBackend.new
+        I18n.backend = I18n::Backend::Chain.new(
+          customizer_backend,
+          I18n.backend
+        )
+
+        # Setup a controller hook to setup the term customizer before the
+        # request is processed and the translations are printed out. This is
+        # done through a notification to get access to the `current_*`
+        # environment variables within Decidim.
+        ActiveSupport::Notifications.subscribe "start_processing.action_controller" do |_name, _started, _finished, _unique_id, data|
+          env = data[:headers].env
+
+          # Create a new resolver instance within the current request scope
+          TermCustomizer.resolver = Resolver.new(
+            env["decidim.current_organization"],
+            env["decidim.current_participatory_space"],
+            env["decidim.current_component"]
+          )
+
+          # Force the backend to reload the translations for the current request
+          customizer_backend.reload!
+        end
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/i18n_backend.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "i18n/backend/base"
+require "i18n/backend/flatten"
+
+module Decidim
+  module TermCustomizer
+    class I18nBackend
+      using I18n::HashRefinements
+
+      (class << self; self; end).class_eval { public :include }
+
+      module Implementation
+        include I18n::Backend::Base
+
+        # Get available locales from the translations hash
+        def available_locales
+          Translation.available_locales
+        rescue ::ActiveRecord::StatementInvalid
+          []
+        end
+
+        def initialized?
+          !@translations.nil?
+        end
+
+        # Clean up translations hash on reload!
+        def reload!
+          @translations = nil
+          super
+        end
+
+        def translations
+          return @translations if @translations
+          return {} unless TermCustomizer.resolver
+
+          @translations = {}
+
+          TermCustomizer.resolver.translations.each do |tr|
+            keyparts = [tr.locale] + tr.key.split(".")
+            lastkey = keyparts.pop.to_sym
+
+            current = @translations
+            keyparts.each do |key|
+              current[key.to_sym] ||= {}
+              current = current[key.to_sym]
+            end
+
+            current[lastkey] = tr.value
+          end
+
+          @translations
+        end
+
+        protected
+
+        # Looks up a translation from the translations hash. Returns nil if
+        # either key is nil, or locale, scope or key do not exist as a key in
+        # the nested translations hash. Splits keys or scopes containing dots
+        # into multiple keys, i.e. <tt>currency.format</tt> is regarded the same
+        # as <tt>%w(currency format)</tt>.
+        def lookup(locale, key, scope = [], options = EMPTY_HASH)
+          keys = I18n.normalize_keys(locale, key, scope, options[:separator])
+
+          keys.inject(translations) do |result, inner_key|
+            return nil unless result.is_a?(Hash)
+
+            unless result.has_key?(inner_key)
+              inner_key = inner_key.to_s.to_sym
+              return nil unless result.has_key?(inner_key)
+            end
+            result = result[inner_key]
+            result = resolve(locale, inner_key, result, options.merge(scope: nil)) if result.is_a?(Symbol)
+            result
+          end
+        end
+      end
+
+      include Implementation
+    end
+  end
+end

data/lib/decidim/term_customizer/resolver.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    class Resolver
+      def initialize(organization, space, component)
+        @organization = organization
+        @space = space
+        @component = component
+      end
+
+      def translations
+        @translations ||= resolve_translations_query
+      end
+
+      def constraints
+        @constraints ||= resolve_constraints_query
+      end
+
+      private
+
+      attr_reader :organization, :space, :component
+
+      def resolve_translations_query
+        query = translations_base_query
+        translations_add_constraints_query(query)
+
+        query
+      end
+
+      def translations_base_query
+        # All translations without any constraints
+        Translation.where.not(id: Translation.joins(:constraints))
+      end
+
+      def translations_add_constraints_query(query)
+        return unless constraints
+
+        query.or!(
+          Translation.where(
+            id: Translation.joins(:constraints).where(
+              decidim_term_customizer_constraints: {
+                id: constraints
+              }
+            )
+          )
+        )
+      end
+
+      def resolve_constraints_query
+        return nil unless organization
+
+        query = constraints_base_query
+        constraints_add_organization_query(query)
+        constraints_add_space_query(query)
+        constraints_add_component_query(query)
+
+        query
+      end
+
+      def constraints_base_query
+        # All constraints that are NOT attached with any organization
+        TermCustomizer::Constraint.where(organization: nil)
+      end
+
+      def constraints_add_organization_query(query)
+        return unless organization
+
+        query.or!(
+          TermCustomizer::Constraint.where(
+            organization: organization,
+            subject_type: nil,
+            subject_id: nil
+          )
+        )
+      end
+
+      def constraints_add_space_query(query)
+        return unless space
+
+        query.or!(
+          TermCustomizer::Constraint.where(
+            organization: organization,
+            subject: space
+          )
+        )
+        query.or!(
+          TermCustomizer::Constraint.where(
+            organization: organization,
+            subject_type: space.class.name,
+            subject_id: nil
+          )
+        )
+      end
+
+      def constraints_add_component_query(query)
+        return unless component
+
+        query.or!(
+          TermCustomizer::Constraint.where(
+            organization: organization,
+            subject: component
+          )
+        )
+      end
+    end
+  end
+end

data/lib/decidim/term_customizer/test/factories.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  # Create as a sequence to avoid key collisions
+  sequence :translation_key do |n|
+    "#{::Faker::Lorem.words(rand(1..3)).join(".").downcase}.tr#{n}"
+  end
+
+  factory :translation_set, class: Decidim::TermCustomizer::TranslationSet do
+    transient do
+      organization { nil }
+    end
+
+    name do
+      {
+        en: generate(:title),
+        fi: generate(:title),
+        sv: generate(:title)
+      }
+    end
+
+    after(:create) do |set, evaluator|
+      if evaluator.organization
+        set.constraints.create!(
+          organization: evaluator.organization
+        )
+      end
+    end
+  end
+
+  factory :translation, class: Decidim::TermCustomizer::Translation do
+    locale { :en }
+    key { generate(:translation_key) }
+    value { ::Faker::Lorem.words(rand(1..10)).join(" ") }
+    translation_set { create(:translation_set) }
+  end
+
+  factory :translation_set_constraint, class: Decidim::TermCustomizer::Constraint do
+    organization { create(:organization) }
+    translation_set { create(:translation_set) }
+    subject { create(:participatory_process, organization: organization) }
+  end
+end

data/lib/decidim/term_customizer/translation_directory.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module TermCustomizer
+    class TranslationDirectory
+      attr_reader :locale
+
+      def initialize(locale)
+        @locale = locale.to_sym
+      end
+
+      def backend
+        @backend ||= original_backend
+      end
+
+      def translations
+        @translations ||= TranslationStore.new(backend_translations)
+      end
+
+      def translations_search(search)
+        translations_by_key(search).merge(translations_by_term(search))
+      end
+
+      def translations_by_key(search)
+        translations.by_key(search)
+      end
+
+      def translations_by_term(search, case_sensitive: false)
+        translations.by_term(search, case_sensitive: case_sensitive)
+      end
+
+      private
+
+      def original_backend
+        if I18n.backend.class == I18n::Backend::Chain
+          return I18n.backend.backends.find do |be|
+            be.class == I18n::Backend::Simple
+          end
+        end
+
+        I18n.backend
+      end
+
+      def backend_translations
+        list = backend.translations(do_init: true)
+        list[locale]
+      end
+    end
+  end
+end