decidim-toggle 0.1.3

data/lib/decidim/toggle/module_config.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "decidim/toggle/module_configuration_presenter"
+
+module Decidim
+  module Toggle
+    class << self
+      def normalize_module_name(name)
+        name.to_s
+      end
+
+      def config_for(organization, module_name, registry_name: :organization_settings)
+        key = normalize_module_name(module_name)
+        raw = raw_config_hash(organization, key)
+        entry = SettingsTabRegistry.find(registry_name)&.form_tab_for_module(key)
+
+        if entry && entry[:form]
+          form = build_form_from_hash(entry[:form], organization, raw)
+          ModuleConfigurationPresenter.new(form).to_config_hash.with_indifferent_access
+        else
+          raw.with_indifferent_access
+        end
+      end
+
+      def save_config!(organization, module_name, attributes, merge: true)
+        key = normalize_module_name(module_name)
+        record = OrganizationModuleConfig.find_or_initialize_by(
+          decidim_organization_id: organization.id,
+          module_name: key
+        )
+        incoming = stringify_keys(attributes)
+        record.config = merge ? (record.config || {}).stringify_keys.merge(incoming) : incoming
+        record.save!
+        record
+      end
+
+      private
+
+      def build_form_from_hash(form_class, organization, raw_hash)
+        form_class.from_params(organization: raw_hash).with_context(current_organization: organization)
+      end
+
+      def raw_config_hash(organization, module_name)
+        OrganizationModuleConfig.find_by(
+          decidim_organization_id: organization.id,
+          module_name:
+        )&.config || {}
+      end
+
+      def stringify_keys(hash)
+        hash.to_h.stringify_keys.transform_values do |v|
+          case v
+          when Hash
+            stringify_keys(v)
+          when Array
+            v.map { |e| e.is_a?(Hash) ? stringify_keys(e) : e }
+          else
+            v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/toggle/module_config_form.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    # Include in a {Decidim::Form} used with +add_tab ..., module_name:+ so +from_model(organization)+
+    # loads JSON from {OrganizationModuleConfig} and +UpdateModuleConfigCommand+ can persist it.
+    # Field labels resolve from +decidim_toggle.system.<module_config_name>+ (see integrate/labels.md).
+    #
+    #   class MyModule::AdminConfigForm < Decidim::Form
+    #     include Decidim::Toggle::ModuleConfigForm
+    #
+    #     self.module_config_name = "decidim_geo"
+    #     mimic :organization
+    #     attribute :enabled, :boolean
+    #   end
+    module ModuleConfigForm
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def human_attribute_name(attr, options = {})
+          ModuleConfigI18n.translate_label(module_config_name, attr) || super
+        end
+
+        def from_model(organization)
+          raise NotImplementedError, "#{name} must set self.module_config_name = \"...\"" if module_config_name.blank?
+
+          raw = OrganizationModuleConfig.find_by(
+            decidim_organization_id: organization.id,
+            module_name: module_config_name
+          )&.config || {}
+
+          from_params(organization: raw).with_context(current_organization: organization)
+        end
+      end
+
+      included do
+        class_attribute :module_config_name, instance_accessor: false
+      end
+    end
+  end
+end

data/lib/decidim/toggle/module_config_i18n.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    # I18n scope helpers for {ModuleConfigForm} tab fields.
+    module ModuleConfigI18n
+      module_function
+
+      def scope_for(module_name)
+        return if module_name.blank?
+
+        "decidim_toggle.system.#{module_name}"
+      end
+
+      def label_key(module_name, attribute)
+        base = scope_for(module_name)
+        return unless base
+
+        "#{base}.#{attribute}"
+      end
+
+      def helptext_key(module_name, attribute)
+        base = scope_for(module_name)
+        return unless base
+
+        "#{base}.helptext.#{attribute}"
+      end
+
+      def translate_label(module_name, attribute)
+        key = label_key(module_name, attribute)
+        return unless key && I18n.exists?(key)
+
+        I18n.t(key)
+      end
+
+      def translate_helptext(module_name, attribute)
+        key = helptext_key(module_name, attribute)
+        return unless key && I18n.exists?(key)
+
+        I18n.t(key)
+      end
+    end
+  end
+end

data/lib/decidim/toggle/module_configuration_presenter.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    # Read model around a {Decidim::Form} built from stored JSON: normalizes +nil+ for
+    # array/hash/boolean attributes so runtime code can use +enabled?+, empty collections, etc.
+    class ModuleConfigurationPresenter
+      def initialize(form)
+        @form = form
+        define_accessors!
+      end
+
+      attr_reader :form
+
+      def to_config_hash
+        @form.class.attribute_names.each_with_object({}) do |attr, hash|
+          next if attr == "id"
+
+          type = @form.class.attribute_types[attr]
+          hash[attr] = normalize(@form.public_send(attr), attr, type)
+        end
+      end
+
+      private
+
+      def define_accessors!
+        @form.class.attribute_names.each do |attr|
+          next if attr == "id"
+
+          type = @form.class.attribute_types[attr]
+
+          define_singleton_method(attr) do
+            normalize(@form.public_send(attr), attr, type)
+          end
+
+          next unless type.is_a?(ActiveModel::Type::Boolean)
+
+          define_singleton_method("#{attr}?") do
+            !!normalize(@form.public_send(attr), attr, type)
+          end
+        end
+      end
+
+      def normalize(value, _attr_name, type)
+        return value unless value.nil?
+
+        return [] if type.try(:type) == :array
+        return {} if type.try(:type) == :hash
+        return false if type.is_a?(ActiveModel::Type::Boolean)
+
+        value
+      end
+    end
+  end
+end

data/lib/decidim/toggle/organization_settings_tabs.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    # Registers default system organization settings tabs.
+    #
+    # Extension contract: the authorizations tab uses the stable identifier
+    # +:authorizations+ (vanilla Decidim: string array of verification workflow names).
+    # Another engine may register an additional +Decidim::Toggle.settings_tabs+
+    # block **after** +decidim_toggle.organization_settings_tabs+ and call
+    # +remove_tab(:authorizations)+ then +add_tab(:authorizations, ...)+ with the
+    # same identifier to replace the tab. The last +register_form_tab+ for that id
+    # wins; see {Decidim::Toggle::SettingsTabRegistry#register_form_tab}.
+    class OrganizationSettingsTabs
+      def self.register!
+        scope = "decidim_toggle.system.organizations.settings_tabs"
+        Decidim::Toggle.settings_tabs :organization_settings do |tabs|
+          tabs.add_tab :name,
+                       t("name", scope:),
+                       form: Decidim::Toggle::UpdateNameForm,
+                       command: Decidim::Toggle::UpdateNameCommand,
+                       position: 1, open: true
+
+          tabs.add_tab :omniauth,
+                       t("omniauth", scope:),
+                       form: Decidim::Toggle::UpdateOmniauthForm,
+                       command: Decidim::Toggle::UpdateOmniauthCommand,
+                       position: 2,
+                       form_layout_partial: "decidim_toggle/system/organizations/tabs/omniauth_tab"
+
+          tabs.add_tab :emails,
+                       t("emails", scope:),
+                       form: Decidim::Toggle::UpdateEmailsForm,
+                       command: Decidim::Toggle::UpdateEmailsCommand,
+                       position: 3,
+                       form_layout_partial: "decidim_toggle/system/organizations/tabs/emails_tab"
+
+          tabs.add_tab :language,
+                       t("language", scope:),
+                       form: Decidim::Toggle::UpdateLocaleForm,
+                       command: Decidim::Toggle::UpdateLocaleCommand,
+                       position: 4,
+                       form_layout_partial: "decidim_toggle/system/organizations/tabs/language_tab"
+
+          tabs.add_tab :authorizations,
+                       t("authorizations", scope:),
+                       form: Decidim::Toggle::UpdateAuthorizationsForm,
+                       command: Decidim::Toggle::UpdateAuthorizationsCommand,
+                       position: 5,
+                       form_layout_partial: "decidim_toggle/system/organizations/tabs/authorizations_tab"
+
+          tabs.add_tab :security,
+                       t("security", scope:),
+                       form: Decidim::Toggle::UpdateSecurityForm,
+                       command: Decidim::Toggle::UpdateSecurityCommand,
+                       form_layout_partial: "decidim_toggle/system/organizations/tabs/security_tab",
+                       position: 6
+
+          tabs.add_tab :other,
+                       t("file_upload", scope:),
+                       form: Decidim::Toggle::UpdateFileUploadSettingsForm,
+                       command: Decidim::Toggle::UpdateFileUploadSettingsCommand,
+                       position: 7,
+                       form_layout_partial: "decidim_toggle/system/organizations/tabs/file_upload_tab"
+        end
+      end
+    end
+  end
+end

data/lib/decidim/toggle/settings_form_builder.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    # Form builder for add_tab form tabs. Renders all form attributes via #all_fields.
+    # Form classes can define class method collection_for_<attribute> to return [[value, label], ...] for collection inputs.
+    # Loaded from the engine after +require "decidim/core"+ so +Decidim::FormBuilder+ autoload works.
+    class SettingsFormBuilder < Decidim::FormBuilder
+      CALLOUT_CLASS_BY_TYPE = {
+        info: "info",
+        warning: "warning",
+        danger: "alert"
+      }.freeze
+
+      def informative_callouts
+        return "".html_safe unless object.class.include?(InformativeCallouts)
+
+        entries = object.visible_informative_callouts
+        return "".html_safe if entries.blank?
+
+        callouts = entries.map do |entry|
+          callout = @template.cell(
+            "decidim/announcement",
+            entry.message_for(object),
+            callout_class: CALLOUT_CLASS_BY_TYPE.fetch(entry.type)
+          )
+          @template.content_tag(:div, callout, class: InformativeCallouts::WRAPPER_CLASS)
+        end
+        safe_join(callouts)
+      end
+
+      def all_fields
+        fields = attribute_names.map do |name|
+          @template.content_tag(:div, input_field(name), class: field_wrapper_classes(name))
+        end
+        safe_join(fields)
+      end
+
+      # Renders a subset of attributes (e.g. machine translation fields after a custom locale table).
+      def fields_for_names(*names)
+        names = names.flatten.map(&:to_s)
+        fields = names.filter_map do |name|
+          next unless object.class.respond_to?(:attribute_types) && object.class.attribute_types.has_key?(name)
+
+          @template.content_tag(:div, input_field(name.to_sym), class: field_wrapper_classes(name))
+        end
+        safe_join(fields)
+      end
+
+      private
+
+      def input_field(name)
+        name = name.to_sym
+        input_html =
+          if translatable_hash_attribute?(name)
+            translated_input_field(name)
+          else
+            build_input_field(name)
+          end
+
+        helptext = helptext_for_attribute(name)
+        return input_html if helptext.blank?
+
+        # Render the help text under the field label (the upstream `Decidim::FormBuilder`
+        # typically renders the label inside the field HTML returned above).
+        @template.safe_join(
+          [
+            input_html,
+            @template.content_tag(:p, helptext, class: "field-helptext")
+          ]
+        )
+      end
+
+      def build_input_field(name)
+        type = attribute_type(name)
+
+        if (collection = collection_for(name))
+          if type == :array
+            collection_check_boxes(name, collection, :first, :last) do |b|
+              @template.content_tag(:div, b.check_box(checked: Array(object.public_send(name)).include?(b.value)) + b.label { b.text })
+            end
+          else
+            collection_radio_buttons(name, collection, :first, :last) do |b|
+              @template.content_tag(:div, b.radio_button + b.label { b.text })
+            end
+          end
+        else
+          options = field_html_options_for(name)
+          case type
+          when :string
+            name.to_s == "secondary_hosts" ? text_area(name, options) : text_field(name, options)
+          when :integer then number_field(name, options)
+          when :boolean then check_box(name, options)
+          else text_field(name, options)
+          end
+        end
+      end
+
+      def field_html_options_for(name)
+        attribute_disabled?(name) ? { disabled: true } : {}
+      end
+
+      def field_wrapper_classes(name)
+        attribute_disabled?(name) ? "field is-disabled" : "field"
+      end
+
+      def attribute_disabled?(name)
+        name = name.to_sym
+        method = :"disabled_for_#{name}?"
+        return object.public_send(method) if object.respond_to?(method)
+
+        return object.attribute_disabled?(name) if object.respond_to?(:attribute_disabled?)
+
+        false
+      end
+
+      def collection_for(attribute)
+        method = :"collection_for_#{attribute}"
+        object.class.respond_to?(method) ? object.class.public_send(method) : nil
+      end
+
+      def attribute_names
+        return [] unless object.class.respond_to?(:attribute_types)
+
+        object.class.attribute_types.keys.reject do |k|
+          k.to_s == "id" || translatable_locale_field?(k.to_s)
+        end
+      end
+
+      def attribute_type(name)
+        return :string unless object.class.respond_to?(:attribute_types)
+
+        type_obj = object.class.attribute_types[name.to_s]
+        type_obj.respond_to?(:type) ? type_obj.type : :string
+      end
+
+      # translatable_attribute adds a hash (:name) plus one String per locale (:name_en, …).
+      # Decidim forms use #translated (tabs or locale select); listing locale keys duplicates the UI.
+      def translatable_hash_attribute?(base)
+        return false unless object.class.include?(Decidim::TranslatableAttributes)
+
+        type = object.class.attribute_types[base.to_s]
+        type.respond_to?(:type) && type.type == :hash
+      end
+
+      def translatable_locale_field?(key)
+        return false unless object.class.include?(Decidim::TranslatableAttributes)
+
+        Decidim.available_locales.any? do |locale|
+          suffix = locale.to_s.tr("-", "__")
+          next unless key.end_with?("_#{suffix}")
+
+          base = key.delete_suffix("_#{suffix}")
+          next if base.blank?
+
+          translatable_hash_attribute?(base)
+        end
+      end
+
+      def translated_input_field(name)
+        locale = Decidim.available_locales.first
+        locale_key = "#{name}_#{locale.to_s.tr("-", "__")}"
+        t = attribute_type(locale_key)
+        case t
+        when :"decidim/attributes/rich_text"
+          translated(:editor, name)
+        else
+          translated(:text_field, name)
+        end
+      end
+
+      def helptext_for_attribute(name)
+        attribute_name = name.to_s
+
+        if object.class.respond_to?(:module_config_name)
+          helptext = ModuleConfigI18n.translate_helptext(object.class.module_config_name, attribute_name)
+          return helptext if helptext.present?
+        end
+
+        # When a form `mimic`s another ActiveModel (e.g. organization), `model_name`
+        # is expected to match i18n keys used across Decidim.
+        candidate_model_keys = []
+        candidate_model_keys << object.class.model_name.i18n_key if object.class.respond_to?(:model_name) && object.class.model_name.respond_to?(:i18n_key)
+        candidate_model_keys << object_name if respond_to?(:object_name)
+
+        candidate_model_keys.compact!
+        candidate_model_keys.uniq!
+
+        candidate_model_keys.each do |model_key|
+          # Preferred location avoids making `activemodel.attributes.<model>.<attr>` a Hash (which can break
+          # attribute name i18n lookups for the same key).
+          helptext = I18n.t("activemodel.attributes.#{model_key}.helptext.#{attribute_name}", default: nil)
+          return helptext if helptext.present?
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/decidim/toggle/settings_tab_item.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    class SettingsTabItem
+      def initialize(identifier, label, options = {})
+        @identifier = identifier
+        @label = label
+        @form_layout_partial = options[:form_layout_partial]
+        @form_class = options[:form_class]
+        @command_class = options[:command_class]
+        @position = options[:position] || Float::INFINITY
+        @if = options[:if]
+        @open = options.fetch(:open, false)
+        @module_name = options[:module_name]
+      end
+
+      attr_reader :identifier, :label, :form_layout_partial, :form_class, :command_class, :module_name
+
+      attr_accessor :position
+
+      def form_tab?
+        form_class.present? && command_class.present?
+      end
+
+      def open?
+        @open
+      end
+
+      def visible?
+        return true if @if.nil? || @if
+
+        false
+      end
+    end
+  end
+end

data/lib/decidim/toggle/settings_tab_registry.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    class DuplicateTabRegistrationError < StandardError; end
+
+    class SettingsTabRegistry
+      class << self
+        def register(name, &block)
+          registry = find(name) || create(name)
+          registry.configurations << block
+          registry
+        end
+
+        def find(name)
+          all[name.to_sym]
+        end
+
+        def create(name)
+          all[name.to_sym] = new(name)
+        end
+
+        def destroy(name)
+          all[name.to_sym] = nil
+        end
+
+        private
+
+        def all
+          @all ||= {}
+        end
+      end
+
+      attr_reader :configurations, :form_tabs, :module_configs, :registry_name
+
+      def initialize(name)
+        @registry_name = name.to_sym
+        @configurations = []
+        @form_tabs = {}
+        @module_configs = {}
+        @tab_to_module_name = {}
+        @configurations_applied = false
+      end
+
+      def mark_configurations_applied!
+        @configurations_applied = true
+      end
+
+      # Runs registered +settings_tabs+ blocks so +register_form_tab+ / +module_configs+ are populated
+      # (e.g. for {Decidim::Toggle.config_for} before any HTTP request builds tabs).
+      def ensure_configurations_applied!
+        return if @configurations_applied
+
+        ctx = Object.new
+        ctx.define_singleton_method(:t) { |key, **kw| I18n.t(key, **kw) }
+        SettingsTabs.new(@registry_name).build_for(ctx)
+      end
+
+      # Last registration for a given +identifier+ wins (used when an extension replaces a tab).
+      # When +module_name+ is set, last registration for that module name wins (same as tab id).
+      def register_form_tab(identifier, form_class, command_class, module_name: nil)
+        tid = identifier.to_sym
+        if (previous = @tab_to_module_name[tid])
+          @module_configs.delete(previous)
+        end
+
+        if duplicate_tab_registration?(tid, form_class, command_class)
+          raise DuplicateTabRegistrationError,
+                "Tab :#{tid} is already registered with form #{@form_tabs[tid][:form]} " \
+                "and command #{@form_tabs[tid][:command]}; attempted #{form_class} / #{command_class}"
+        end
+
+        @form_tabs[tid] = { form: form_class, command: command_class }
+        if module_name.blank?
+          @tab_to_module_name.delete(tid)
+          return
+        end
+
+        key = module_name.to_s
+        @module_configs[key] = {
+          form: form_class,
+          command: command_class,
+          tab_identifier: tid
+        }
+        @tab_to_module_name[tid] = key
+      end
+
+      def form_tab(identifier)
+        form_tabs[identifier.to_sym]
+      end
+
+      # @return [Hash, nil] +:form+, +:command+, +:tab_identifier+ when an +add_tab+ registered this +module_name+
+      def form_tab_for_module(module_name)
+        ensure_configurations_applied!
+        module_configs[module_name.to_s]
+      end
+
+      private
+
+      def duplicate_tab_registration?(tid, form_class, command_class)
+        return false unless Rails.env.development? || Rails.env.test?
+        return false unless @form_tabs[tid]
+
+        existing = @form_tabs[tid]
+        existing[:form] != form_class || existing[:command] != command_class
+      end
+    end
+  end
+end

data/lib/decidim/toggle/settings_tabs.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Toggle
+    #
+    # Builds a list of settings tabs from registered configurations (same pattern as Decidim::Menu).
+    #
+    class SettingsTabs
+      def initialize(name)
+        @name = name
+        @items = []
+        @removed_items = []
+      end
+
+      def build_for(context, **options)
+        raise "Settings tabs #{@name} is not registered" if registry.blank?
+
+        registry.configurations.each do |configuration|
+          context.instance_exec(self, **options, &configuration)
+        end
+        registry.mark_configurations_applied!
+      end
+
+      # Tab with form + command: common layout renders form.all_fields and submits to generic controller.
+      # @param identifier [Symbol] Tab id
+      # @param label [String] Tab button label
+      # @param form [Class] Decidim::Form subclass (must respond to .from_model(organization))
+      # @param command [Class] Decidim::Command that receives (organization, form)
+      # @param options [Hash] :position, :if, :open,
+      #                        :form_layout_partial (optional full tab layout partial)
+      def add_tab(identifier, label, form:, **options)
+        command = options.fetch(:command)
+        options = { position: (1 + @items.length) }.merge(options)
+
+        module_name = options[:module_name]
+        registry.register_form_tab(identifier, form, command, module_name:)
+        @items << SettingsTabItem.new(identifier, label, options.merge(form_class: form, command_class: command))
+      end
+
+      def remove_tab(identifier)
+        @removed_items << identifier
+      end
+
+      def items
+        @items.reject! { |item| @removed_items.include?(item.identifier) }
+        @items.select(&:visible?).sort_by(&:position)
+      end
+
+      private
+
+      def registry
+        @registry ||= SettingsTabRegistry.find(@name)
+      end
+    end
+  end
+end