decidim-toggle 0.1.3

data/spec/lib/decidim/toggle/javascript_config_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  module Toggle
+    describe JavascriptConfig do
+      let(:organization) { create(:organization) }
+      let(:registry_name) { :javascript_config_spec }
+      let(:registry) { SettingsTabRegistry.find(registry_name) }
+
+      def self.ensure_registry!
+        @registry_ready ||= begin
+          geo_form_class = Class.new(Decidim::Form) do
+            include ExposeAttributesToJs
+            include ModuleConfigForm
+
+            self.module_config_name = "decidim_geo"
+
+            mimic :organization
+            attribute :enabled, :boolean
+            attribute :search_bar, :boolean
+            attribute :tags, [String]
+            attribute :secret, :string
+
+            expose_to_javascript :enabled, :search_bar, :tags
+          end
+
+          other_form_class = Class.new(Decidim::Form) do
+            include ExposeAttributesToJs
+            include ModuleConfigForm
+
+            self.module_config_name = "decidim_other"
+
+            mimic :organization
+            attribute :mode, :string
+            expose_to_javascript :mode
+          end
+
+          test_registry = SettingsTabRegistry.create(:javascript_config_spec)
+          test_registry.register_form_tab(:geo, geo_form_class, Integer, module_name: :decidim_geo)
+          test_registry.register_form_tab(:other, other_form_class, Integer, module_name: :decidim_other)
+          test_registry.mark_configurations_applied!
+          true
+        end
+      end
+
+      def self.reset_registry!
+        SettingsTabRegistry.destroy(:javascript_config_spec) if SettingsTabRegistry.find(:javascript_config_spec)
+        remove_instance_variable(:@registry_ready) if instance_variable_defined?(:@registry_ready)
+        ensure_registry!
+      end
+
+      before do
+        self.class.reset_registry!
+      end
+
+      # rubocop:disable RSpec/BeforeAfterAll -- isolated registry for this file
+      after(:context) do
+        SettingsTabRegistry.destroy(:javascript_config_spec)
+      end
+      # rubocop:enable RSpec/BeforeAfterAll
+
+      it "returns an empty hash without organization" do
+        expect(described_class.for(nil, registry_name:)).to eq({})
+      end
+
+      it "builds flat dot-notation keys from exposed attributes" do
+        Decidim::Toggle.save_config!(
+          organization,
+          :decidim_geo,
+          { "enabled" => true, "search_bar" => false, "tags" => %w(a b), "secret" => "hidden" }
+        )
+        Decidim::Toggle.save_config!(organization, :decidim_other, { "mode" => "live" })
+
+        expect(described_class.for(organization, registry_name:)).to eq(
+          "decidim_geo.enabled" => true,
+          "decidim_geo.search_bar" => false,
+          "decidim_geo.tags" => %w(a b),
+          "decidim_other.mode" => "live"
+        )
+      end
+
+      it "skips forms without ExposeAttributesToJs" do
+        plain_form = Class.new(Decidim::Form) do
+          include ModuleConfigForm
+
+          self.module_config_name = "decidim_plain"
+          mimic :organization
+          attribute :enabled, :boolean
+        end
+
+        registry.register_form_tab(:plain, plain_form, Integer, module_name: :decidim_plain)
+        Decidim::Toggle.save_config!(organization, :decidim_plain, { "enabled" => true })
+
+        expect(described_class.for(organization, registry_name:)).not_to have_key("decidim_plain.enabled")
+      end
+
+      it "skips unsupported scalar types with a warning in test" do
+        expect(Rails.logger).to receive(:warn).with(/Skipping unsupported JavaScript config value/)
+
+        expect(described_class.send(:serialize_value, Object.new, nil)).to be_nil
+      end
+
+      it "stringifies nested hashes and arrays inside hash values" do
+        nested_form_class = Class.new(Decidim::Form) do
+          include ExposeAttributesToJs
+          include ModuleConfigForm
+
+          self.module_config_name = "decidim_nested"
+
+          mimic :organization
+          attribute :settings, Object
+          expose_to_javascript :settings
+        end
+
+        registry.register_form_tab(:nested, nested_form_class, Integer, module_name: :decidim_nested)
+        Decidim::Toggle.save_config!(
+          organization,
+          :decidim_nested,
+          { "settings" => { labels: %w(a b), meta: { "count" => 2 } } }
+        )
+
+        expect(described_class.for(organization, registry_name:)).to include(
+          "decidim_nested.settings" => { "labels" => %w(a b), "meta" => { "count" => 2 } }
+        )
+      end
+
+      context "with translatable attributes" do
+        def self.ensure_translatable_form!
+          @translatable_ready ||= begin
+            translatable_form_class = Class.new(Decidim::Form) do
+              include Decidim::TranslatableAttributes
+              include ExposeAttributesToJs
+              include ModuleConfigForm
+
+              self.module_config_name = "decidim_i18n"
+
+              mimic :organization
+              translatable_attribute :title, String
+              expose_to_javascript :title
+            end
+
+            SettingsTabRegistry.find(:javascript_config_spec).register_form_tab(
+              :i18n, translatable_form_class, Integer, module_name: :decidim_i18n
+            )
+            true
+          end
+        end
+
+        before do
+          self.class.ensure_translatable_form!
+          Decidim::Toggle.save_config!(
+            organization,
+            :decidim_i18n,
+            { "title" => { "en" => "Hello", "ca" => "Hola" } }
+          )
+        end
+
+        it "exposes the raw locale hash" do
+          expect(described_class.for(organization, registry_name:)["decidim_i18n.title"]).to eq(
+            "en" => "Hello",
+            "ca" => "Hola"
+          )
+        end
+      end
+    end
+  end
+end

data/spec/lib/decidim/toggle/module_config_form_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  module Toggle
+    describe ModuleConfigForm do
+      let(:form_class) do
+        Class.new(Decidim::Form) do
+          include ModuleConfigForm
+
+          self.module_config_name = "decidim_demo"
+
+          mimic :organization
+
+          attribute :enabled, :boolean
+        end
+      end
+
+      describe ".human_attribute_name" do
+        it "uses decidim_toggle.system.<module_config_name> when present" do
+          I18n.with_locale(:en) do
+            I18n.backend.store_translations(:en, {
+                                              decidim_toggle: {
+                                                system: {
+                                                  decidim_demo: {
+                                                    enabled: "Demo enabled label"
+                                                  }
+                                                }
+                                              }
+                                            })
+
+            expect(form_class.human_attribute_name(:enabled)).to eq("Demo enabled label")
+          end
+        end
+
+        it "falls back when the module key is missing" do
+          I18n.with_locale(:en) do
+            expect(form_class.human_attribute_name(:missing_attr)).to eq("Missing attr")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/decidim/toggle/module_config_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  module Toggle
+    describe Decidim::Toggle do
+      let(:organization) { create(:organization) }
+
+      after do
+        SettingsTabRegistry.destroy(:module_config_spec)
+      end
+
+      describe ".save_config!" do
+        it "creates a row and shallow-merges by default" do
+          described_class.save_config!(organization, :decidim_geo, { "enabled" => true })
+          described_class.save_config!(organization, :decidim_geo, { "foo" => "bar" })
+
+          row = OrganizationModuleConfig.find_by!(decidim_organization_id: organization.id, module_name: "decidim_geo")
+          expect(row.config).to eq("enabled" => true, "foo" => "bar")
+        end
+
+        it "replaces config when merge: false" do
+          described_class.save_config!(organization, :decidim_geo, { "a" => 1 })
+          described_class.save_config!(organization, :decidim_geo, { "b" => 2 }, merge: false)
+
+          row = OrganizationModuleConfig.find_by!(decidim_organization_id: organization.id, module_name: "decidim_geo")
+          expect(row.config).to eq("b" => 2)
+        end
+      end
+
+      describe ".config_for" do
+        let(:demo_form_class) do
+          Class.new(Decidim::Form) do
+            mimic :organization
+            attribute :enabled, :boolean
+          end
+        end
+
+        it "returns indifferent hash when no form is registered for the module" do
+          described_class.save_config!(organization, :unknown_mod, { "x" => 1 })
+          result = described_class.config_for(organization, :unknown_mod, registry_name: :module_config_spec)
+          expect(result[:x]).to eq(1)
+          expect(result["x"]).to eq(1)
+        end
+
+        it "returns a normalized hash when a tab registered module_name with a form" do
+          form_class = demo_form_class
+          SettingsTabRegistry.register(:module_config_spec) do |tabs|
+            tabs.add_tab :geo, "Geo", form: form_class, command: Integer, module_name: :decidim_geo
+          end
+
+          described_class.save_config!(organization, :decidim_geo, { "enabled" => true })
+
+          result = described_class.config_for(organization, :decidim_geo, registry_name: :module_config_spec)
+          expect(result).to be_a(ActiveSupport::HashWithIndifferentAccess)
+          expect(result[:enabled]).to be(true)
+        end
+
+        it "normalizes nil boolean to false when a form is registered" do
+          form_class = demo_form_class
+          SettingsTabRegistry.register(:module_config_spec) do |tabs|
+            tabs.add_tab :geo, "Geo", form: form_class, command: Integer, module_name: :decidim_geo
+          end
+
+          described_class.save_config!(organization, :decidim_geo, {})
+
+          result = described_class.config_for(organization, :decidim_geo, registry_name: :module_config_spec)
+          expect(result[:enabled]).to be(false)
+        end
+      end
+    end
+  end
+end

data/spec/lib/decidim/toggle/module_configuration_presenter_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  module Toggle
+    describe ModuleConfigurationPresenter do
+      let(:organization) { create(:organization) }
+
+      let(:demo_form_class) do
+        Class.new(Decidim::Form) do
+          mimic :organization
+
+          attribute :enabled, :boolean
+          attribute :tags, :array
+          attribute :meta, :hash
+        end
+      end
+
+      def build_presenter(attrs)
+        form = demo_form_class.from_params(organization: attrs).with_context(current_organization: organization)
+        described_class.new(form)
+      end
+
+      it "normalizes nil array to empty array" do
+        p = build_presenter(tags: nil)
+        expect(p.tags).to eq([])
+      end
+
+      it "normalizes nil hash to empty hash" do
+        p = build_presenter(meta: nil)
+        expect(p.meta).to eq({})
+      end
+
+      it "normalizes nil boolean to false and exposes predicate" do
+        p = build_presenter(enabled: nil)
+        expect(p.enabled).to be(false)
+        expect(p.enabled?).to be(false)
+      end
+
+      it "preserves true boolean" do
+        p = build_presenter(enabled: true)
+        expect(p.enabled).to be(true)
+        expect(p.enabled?).to be(true)
+      end
+
+      it "exports normalized attributes as a hash" do
+        p = build_presenter(enabled: nil, tags: nil, meta: nil)
+        expect(p.to_config_hash).to eq("enabled" => false, "tags" => [], "meta" => {})
+      end
+    end
+  end
+end

data/spec/lib/decidim/toggle/settings_form_builder_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  module Toggle
+    describe SettingsFormBuilder do
+      include ActionView::TestCase::Behavior
+
+      it "renders fields_for_names subset" do
+        organization = create(:organization)
+        form = UpdateLocaleForm.from_model(organization)
+        template = ActionView::Base.with_empty_template_cache.new(ActionView::LookupContext.new([]), {}, nil)
+        builder = described_class.new(:organization, form, template, {})
+
+        html = builder.fields_for_names(:enable_machine_translations)
+        expect(html).to be_present
+      end
+
+      it "renders informative callouts with decidim announcement cell markup" do
+        form_class = Class.new(UpdateSecurityForm) do
+          include InformativeCallouts
+
+          info :spec_info_callout
+
+          def spec_info_callout
+            "Spec info callout"
+          end
+        end
+        form = form_class.from_params(organization: {})
+        template = ActionView::Base.with_empty_template_cache.new(ActionView::LookupContext.new([]), {}, nil)
+        allow(template).to receive(:cell) do |_name, message, options|
+          %(<div class="flash flex-col #{options[:callout_class]}">#{message}</div>).html_safe
+        end
+        builder = described_class.new(:organization, form, template, {})
+
+        html = builder.informative_callouts
+        expect(html).to include("Spec info callout")
+        expect(html).to include('class="flash flex-col info"')
+        expect(html).to include('class="decidim_toggle_informative_callout"')
+      end
+
+      it "renders i18n helptext under the field when present" do
+        organization = create(:organization)
+        form = UpdateSecurityForm.from_model(organization)
+        template = ActionView::Base.with_empty_template_cache.new(ActionView::LookupContext.new([]), {}, nil)
+        builder = described_class.new(:organization, form, template, {})
+
+        helptext = "Spec helptext for users_registration_mode"
+        model_key = form.class.model_name.i18n_key.to_s
+
+        I18n.with_locale(:en) do
+          I18n.backend.store_translations(:en, {
+                                            activemodel: {
+                                              attributes: {
+                                                "organization" => {
+                                                  helptext: {
+                                                    "users_registration_mode" => helptext
+                                                  }
+                                                },
+                                                model_key => {
+                                                  helptext: {
+                                                    "users_registration_mode" => helptext
+                                                  }
+                                                }
+                                              }
+                                            }
+                                          })
+
+          html = builder.fields_for_names(:users_registration_mode)
+          expect(html).to include(helptext)
+        end
+      end
+
+      it "disables fields when the form implements attribute_disabled?" do
+        form_class = Class.new(Decidim::Form) do
+          attribute :enabled, :boolean
+          attribute :locked, :boolean
+
+          def attribute_disabled?(attribute)
+            attribute == :locked
+          end
+        end
+        form = form_class.from_params(organization: { enabled: true, locked: false })
+        template = ActionView::Base.with_empty_template_cache.new(ActionView::LookupContext.new([]), {}, nil)
+        builder = described_class.new(:organization, form, template, {})
+
+        html = builder.all_fields
+        expect(html).to include('name="organization[enabled]"')
+        expect(html).not_to include('organization[enabled]" disabled')
+        expect(html).to include('name="organization[locked]" disabled="disabled"')
+        expect(html).to include('class="field is-disabled"')
+      end
+
+      it "renders boolean fields, text areas, and collection inputs" do
+        organization = create(:organization, secondary_hosts: %w(extra.example.org))
+        template = ActionView::Base.with_empty_template_cache.new(ActionView::LookupContext.new([]), {}, nil)
+
+        security_form = UpdateSecurityForm.from_model(organization)
+        security_builder = described_class.new(:organization, security_form, template, {})
+        security_html = security_builder.all_fields
+        expect(security_html).to include('type="checkbox"')
+        expect(security_builder.fields_for_names(:users_registration_mode)).to include('type="radio"')
+
+        name_form = UpdateNameForm.from_model(organization)
+        name_builder = described_class.new(:organization, name_form, template, {})
+        expect(name_builder.all_fields).to include("extra.example.org")
+
+        authorizations_form = UpdateAuthorizationsForm.from_model(organization)
+        authorizations_builder = described_class.new(:organization, authorizations_form, template, {})
+        expect(authorizations_builder.all_fields).to include('type="checkbox"')
+      end
+    end
+  end
+end

data/spec/requests/decidim_toggle/system/settings_tab_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe "DecidimToggle::System::SettingsTabController" do
+  let(:organization) { create(:organization) }
+  let(:admin) { create(:admin) }
+
+  before { login_as admin, scope: :admin }
+
+  describe "PATCH /decidim_toggle/system/organizations/:organization_id/settings_tab/:tab_id" do
+    let(:path) { "/decidim_toggle/system/organizations/#{organization.id}/settings_tab/security" }
+    let(:valid_params) do
+      {
+        organization: {
+          force_users_to_authenticate_before_access_organization: "1",
+          users_registration_mode: "enabled"
+        }
+      }
+    end
+
+    it "updates the tab and redirects with notice" do
+      patch path, params: valid_params
+
+      expect(response).to redirect_to(decidim_system.edit_organization_path(organization))
+      expect(flash[:notice]).to eq(I18n.t("decidim_toggle.system.organizations.form_tab.success"))
+      expect(organization.reload.force_users_to_authenticate_before_access_organization).to be(true)
+    end
+
+    it "redirects with anchor when active tab param matches a registered tab" do
+      patch path, params: valid_params.merge(decidim_toggle_active_tab: "security")
+
+      expect(response).to redirect_to(
+        decidim_system.edit_organization_path(organization, anchor: "panel-toggle-security")
+      )
+    end
+
+    it "ignores unknown active tab ids when building the redirect anchor" do
+      patch path, params: valid_params.merge(decidim_toggle_active_tab: "not-a-tab")
+
+      expect(response).to redirect_to(decidim_system.edit_organization_path(organization))
+    end
+
+    it "returns not found for unknown tab ids" do
+      patch "/decidim_toggle/system/organizations/#{organization.id}/settings_tab/unknown"
+
+      expect(response).to have_http_status(:not_found)
+    end
+
+    it "stores invalid tab data in flash when the form is invalid" do
+      patch path, params: { organization: { users_registration_mode: "not_a_mode" } }
+
+      expect(response).to redirect_to(decidim_system.edit_organization_path(organization))
+      expect(flash[:decidim_toggle_invalid_settings_tab]).to include(
+        organization_id: organization.id,
+        tab_id: "security"
+      )
+    end
+
+    it "re-renders field errors after redirect" do
+      patch path, params: { organization: { users_registration_mode: "not_a_mode" } }
+      follow_redirect!
+
+      expect(response.body).to include("form-error")
+    end
+  end
+
+  describe "PATCH name tab" do
+    let(:path) { "/decidim_toggle/system/organizations/#{organization.id}/settings_tab/name" }
+    let(:valid_params) do
+      {
+        organization: {
+          name_en: "Renamed organization",
+          host: "renamed.example.org",
+          secondary_hosts: ""
+        }
+      }
+    end
+
+    it "updates host and redirects with notice" do
+      patch path, params: valid_params
+
+      expect(response).to redirect_to(decidim_system.edit_organization_path(organization))
+      expect(flash[:notice]).to eq(I18n.t("decidim_toggle.system.organizations.form_tab.success"))
+      organization.reload
+      expect(organization.host).to eq("renamed.example.org")
+      expect(organization.name["en"]).to eq("Renamed organization")
+    end
+
+    it "stores invalid tab data in flash when host is blank" do
+      patch path, params: { organization: { name_en: "", host: "", secondary_hosts: "" } }
+
+      expect(response).to redirect_to(decidim_system.edit_organization_path(organization))
+      expect(flash[:decidim_toggle_invalid_settings_tab]).to include(
+        organization_id: organization.id,
+        tab_id: "name"
+      )
+    end
+  end
+
+  describe "PATCH language tab" do
+    let(:path) { "/decidim_toggle/system/organizations/#{organization.id}/settings_tab/language" }
+    let(:organization) { create(:organization, available_locales: %w(en ca), default_locale: "ca") }
+
+    before do
+      allow(Rails.application).to receive(:load_tasks)
+      allow(Rake::Task).to receive(:[]).and_call_original
+      allow(Rake::Task).to receive(:[]).with("decidim:locales:rebuild_search").and_return(
+        instance_double(Rake::Task, invoke: nil, reenable: nil)
+      )
+    end
+
+    it "updates available locales and default locale" do
+      patch path, params: {
+        organization: {
+          available_locales: { "en" => "1" },
+          default_locale: "en",
+          enable_machine_translations: false,
+          machine_translation_display_priority: "original"
+        }
+      }
+
+      expect(response).to redirect_to(decidim_system.edit_organization_path(organization))
+      organization.reload
+      expect(organization.available_locales).to eq(%w(en))
+      expect(organization.default_locale).to eq("en")
+    end
+
+    it "stores invalid tab data when default locale is not enabled" do
+      patch path, params: {
+        organization: {
+          available_locales: { "en" => "1" },
+          default_locale: "ca"
+        }
+      }
+
+      expect(response).to redirect_to(decidim_system.edit_organization_path(organization))
+      expect(flash[:decidim_toggle_invalid_settings_tab]).to include(
+        organization_id: organization.id,
+        tab_id: "language"
+      )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "decidim/dev"
+
+ENV["ENGINE_ROOT"] = File.dirname(__dir__)
+
+Decidim::Dev.dummy_app_path = File.expand_path(File.join(__dir__, "decidim_dummy_app"))
+
+require "decidim/dev/test/map_server"
+require "decidim/dev/test/base_spec_helper"
+
+Dir[File.expand_path("support/**/*.rb", __dir__)].each { |f| require f }

data/spec/support/decidim_factories.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "decidim/system/test/factories"

data/spec/support/devise.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.include Devise::Test::IntegrationHelpers, type: :request
+end

data/spec/system/decidim_toggle/javascript_config_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  module Toggle
+    describe "JavaScript config injection" do
+      let(:organization) { create(:organization) }
+      let(:admin) { create(:user, :confirmed, :admin, organization:) }
+
+      def self.ensure_demo_tab!
+        @demo_tab_ready ||= begin
+          demo_form_class = Class.new(Decidim::Form) do
+            include ExposeAttributesToJs
+            include ModuleConfigForm
+
+            self.module_config_name = "decidim_toggle_demo"
+
+            mimic :organization
+            attribute :enabled, :boolean
+            expose_to_javascript :enabled
+          end
+
+          SettingsTabRegistry.find(:organization_settings).register_form_tab(
+            :toggle_demo_js,
+            demo_form_class,
+            UpdateModuleConfigCommand,
+            module_name: :decidim_toggle_demo
+          )
+          true
+        end
+      end
+
+      before do
+        self.class.ensure_demo_tab!
+        Decidim::Toggle.save_config!(organization, :decidim_toggle_demo, { "enabled" => true })
+        switch_to_host(organization.host)
+      end
+
+      it "exposes window.DecidimToggle on the public site" do
+        visit decidim.root_path
+
+        expect(page.body).to include("window.DecidimToggle")
+        expect(page.body).to include('"decidim_toggle_demo.enabled":true')
+      end
+
+      it "exposes window.DecidimToggle in the admin layout" do
+        login_as admin, scope: :user
+        visit decidim_admin.root_path
+
+        expect(page.body).to include("window.DecidimToggle")
+        expect(page.body).to include('"decidim_toggle_demo.enabled":true')
+      end
+    end
+  end
+end

data/website/.gitignore

@@ -0,0 +1,4 @@
+node_modules/
+build/
+.docusaurus/
+*.log