ruact 0.0.4 → 0.0.6

data/spec/ruact/server_functions/registry_spec.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Ruact
-  module ServerFunctions
-    RSpec.describe Registry, :story_8_0a do
-      subject(:registry) { described_class.new }
-
-      let(:posts_controller) do
-        Class.new { def self.name = "PostsController" }
-      end
-
-      let(:bar_controller) do
-        Class.new { def self.name = "BarController" }
-      end
-
-      describe "#register (Story 8.0a)" do
-        it "stores a single entry keyed by its Ruby symbol", :aggregate_failures do
-          entry = registry.register(:create_post, kind: :action, controller: posts_controller)
-
-          expect(entry).to be_a(RegistryEntry)
-          expect(entry.ruby_symbol).to eq(:create_post)
-          expect(entry.js_identifier).to eq("createPost")
-          expect(entry.kind).to eq(:action)
-          expect(entry.controller).to eq(posts_controller)
-          expect(registry.entries.keys).to eq([:create_post])
-        end
-
-        it "captures the implementation block verbatim for downstream invocation" do
-          block = -> { :pong }
-          entry = registry.register(:demo_ping, kind: :action, controller: posts_controller, &block)
-          expect(entry.block).to be(block)
-        end
-
-        it "allows registering an action and a query with the same symbol in separate registries" do
-          actions = described_class.new
-          queries = described_class.new
-          actions.register(:create_post, kind: :action, controller: posts_controller)
-          queries.register(:create_post, kind: :query, controller: posts_controller)
-          expect(actions.entries.keys).to eq([:create_post])
-          expect(queries.entries.keys).to eq([:create_post])
-        end
-
-        it "raises Ruact::ConfigurationError for SCREAMING_SNAKE symbols (Story 8.0a)" do
-          expect { registry.register(:RECALCULATE, kind: :action, controller: posts_controller) }
-            .to raise_error(Ruact::ConfigurationError) do |error|
-              expect(error.message).to include(":RECALCULATE")
-            end
-        end
-
-        it "raises Ruact::ConfigurationError on JS-identifier collision and names both " \
-           "Ruby symbols and both controllers (Story 8.0a)", :aggregate_failures do
-          registry.register(:foo_bar, kind: :action, controller: posts_controller)
-          expect { registry.register(:foo__bar, kind: :action, controller: bar_controller) }
-            .to raise_error(Ruact::ConfigurationError) do |error|
-              expect(error.message).to include(":foo_bar")
-              expect(error.message).to include(":foo__bar")
-              expect(error.message).to include("PostsController")
-              expect(error.message).to include("BarController")
-              expect(error.message).to include('"fooBar"')
-            end
-        end
-
-        it "allows re-registering the same Ruby symbol (replace semantics, dev reload)" do
-          registry.register(:create_post, kind: :action, controller: posts_controller)
-          expect do
-            registry.register(:create_post, kind: :action, controller: posts_controller)
-          end.not_to raise_error
-          expect(registry.size).to eq(1)
-        end
-
-        it "tolerates a nil controller (Rails-console registration path)" do
-          expect { registry.register(:create_post, kind: :action) }.not_to raise_error
-        end
-
-        it "rejects kinds other than :action / :query (Chunk1 Major 2026-05-13)" do
-          expect { registry.register(:create_post, kind: :wat, controller: posts_controller) }
-            .to raise_error(Ruact::ConfigurationError) do |error|
-              expect(error.message).to include(":create_post")
-              expect(error.message).to include("PostsController")
-              expect(error.message).to include(":wat")
-              expect(error.message).to include("[:action, :query]")
-            end
-        end
-
-        it "wraps NameBridge symbol-shape failures with AC7 'invalid server-function " \
-           "symbol :SYMBOL in CONTROLLER' framing (Re-run patch m5)" do
-          expect { registry.register(:RECALCULATE, kind: :action, controller: posts_controller) }
-            .to raise_error(Ruact::ConfigurationError) do |error|
-              expect(error.message).to start_with("invalid server-function symbol :RECALCULATE in PostsController")
-            end
-        end
-      end
-
-      describe "#entries (Story 8.0a)" do
-        it "returns a frozen snapshot independent of subsequent mutations" do
-          registry.register(:create_post, kind: :action, controller: posts_controller)
-          snapshot = registry.entries
-          expect(snapshot).to be_frozen
-          registry.register(:list_posts, kind: :query, controller: posts_controller)
-          expect(snapshot.keys).to eq([:create_post])
-        end
-      end
-
-      describe "#clear! (Story 8.0a)" do
-        it "wipes all entries and returns self" do
-          registry.register(:create_post, kind: :action, controller: posts_controller)
-          expect(registry.clear!).to be(registry)
-          expect(registry).to be_empty
-        end
-      end
-
-      describe "Story 8.3 — mixed controller+standalone collision", :story_8_3 do
-        let(:posts_controller_class) do
-          Class.new { def self.name = "PostsController" }
-        end
-
-        let(:standalone_create_post_module) do
-          Module.new do
-            extend Ruact::ServerAction
-
-            def self.name
-              "CreatePost"
-            end
-          end
-        end
-
-        it "raises Ruact::ConfigurationError when the same Ruby symbol is declared in a controller " \
-           "AND in a standalone module — message names BOTH hosts" do
-          registry.register(:create_post, kind: :action, controller: posts_controller_class)
-
-          expect do
-            registry.register(:create_post, kind: :action, controller: standalone_create_post_module)
-          end.to raise_error(Ruact::ConfigurationError) do |error|
-            expect(error.message).to include(":create_post")
-            expect(error.message).to include("PostsController")
-            expect(error.message).to include("CreatePost")
-            expect(error.message).to include("declared in BOTH")
-          end
-        end
-
-        it "raises Ruact::ConfigurationError when the same symbol is declared in standalone " \
-           "first, then in a controller (order-independent)" do
-          registry.register(:create_post, kind: :action, controller: standalone_create_post_module)
-
-          expect do
-            registry.register(:create_post, kind: :action, controller: posts_controller_class)
-          end.to raise_error(Ruact::ConfigurationError) do |error|
-            expect(error.message).to include("PostsController")
-            expect(error.message).to include("CreatePost")
-          end
-        end
-
-        it "describe_controller names a Module host correctly (no inspection fallback) " \
-           "when one side of the collision is a Module" do
-          registry.register(:create_post, kind: :action, controller: standalone_create_post_module)
-          another_module = Module.new do
-            extend Ruact::ServerAction
-
-            def self.name
-              "AdminCreatePost"
-            end
-          end
-
-          # Cross-bridge JS-identifier collision: two DIFFERENT Ruby symbols
-          # producing the SAME JS identifier — bridges into `js_identifier ==`
-          # branch of detect_collision!. The bridge collapses underscores,
-          # so `:create_post` and `:create__post` both → "createPost".
-          expect do
-            registry.register(:create__post, kind: :action, controller: another_module)
-          end.to raise_error(Ruact::ConfigurationError) do |error|
-            expect(error.message).to include("CreatePost")
-            expect(error.message).to include("AdminCreatePost")
-            expect(error.message).to include('"createPost"')
-          end
-        end
-      end
-
-      describe "Ruact module-level accessors (Story 8.0a)" do
-        it "returns two independent Registry singletons" do
-          expect(Ruact.action_registry).to be_a(described_class)
-          expect(Ruact.query_registry).to be_a(described_class)
-          expect(Ruact.action_registry).not_to equal(Ruact.query_registry)
-        end
-
-        it "memoizes the same instance across calls" do
-          expect(Ruact.action_registry).to equal(Ruact.action_registry)
-          expect(Ruact.query_registry).to equal(Ruact.query_registry)
-        end
-
-        it "both registries are empty at boot (Story 8.1 / 9.1 populate them)" do
-          expect(Ruact.action_registry).to be_empty
-          expect(Ruact.query_registry).to be_empty
-        end
-      end
-    end
-  end
-end

data/spec/ruact/server_functions/standalone_action_spec.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-# Story 8.3 — covers `Ruact::ServerAction` extended onto a Module: AC1
-# (registration shape + no method defined on host module) and AC6 (guard-
-# rail matrix mirroring the controller-DSL path adapted to module context).
-
-require "spec_helper"
-
-RSpec.describe Ruact::ServerAction, :story_8_3 do
-  describe "AC1 — extend Ruact::ServerAction + ruact_action registers a standalone host" do
-    it "registers a standalone host in Ruact.action_registry with controller: <the Module>" do
-      mod = Module.new do
-        extend Ruact::ServerAction
-
-        def self.name
-          "AC1RegistrationModule"
-        end
-
-        ruact_action(:standalone_create_post) { |_params| { ok: true } }
-      end
-
-      entries = Ruact.action_registry.entries
-      expect(entries).to include(:standalone_create_post)
-
-      entry = entries[:standalone_create_post]
-      expect(entry).to be_a(Ruact::ServerFunctions::RegistryEntry)
-      expect(entry.kind).to eq(:action)
-      expect(entry.controller).to be(mod)
-      expect(entry.controller).to be_a(Module)
-      expect(entry.controller).not_to be_a(Class)
-      expect(entry.js_identifier).to eq("standaloneCreatePost")
-      expect(entry.block).to be_a(Proc)
-    end
-
-    it "does NOT define an instance method on the host module — the block is reachable " \
-       "only through the gem endpoint, never as a Ruby method" do
-      mod = Module.new do
-        extend Ruact::ServerAction
-
-        def self.name
-          "AC1NoMethodModule"
-        end
-
-        ruact_action(:no_method_exposed) { |_params| nil }
-      end
-
-      expect(mod.respond_to?(:no_method_exposed)).to be(false)
-      expect(mod.instance_methods).not_to include(:no_method_exposed)
-      expect(mod.singleton_methods).not_to include(:no_method_exposed)
-      # Direct dispatch attempts (someone trying to `Mod.send(:no_method_exposed)`
-      # should fail with NoMethodError) — proves the surface is endpoint-only.
-      expect { mod.send(:no_method_exposed, {}) }.to raise_error(NoMethodError)
-    end
-  end
-
-  describe "AC6 — guard-rail matrix (mirror controller-DSL adapted to module context)" do
-    let(:host) do
-      Module.new do
-        extend Ruact::ServerAction
-
-        def self.name
-          "GuardRailModule"
-        end
-      end
-    end
-
-    it "raises ArgumentError when given a String instead of a Symbol" do
-      expect do
-        host.module_eval { ruact_action("create_post") { |_p| nil } }
-      end.to raise_error(ArgumentError, /ruact_action requires a Symbol/)
-    end
-
-    it "raises ArgumentError when the block is missing" do
-      expect { host.module_eval { ruact_action(:create_post) } }
-        .to raise_error(ArgumentError, /requires a block/)
-    end
-
-    it "raises ArgumentError when the block accepts no positional argument" do
-      expect do
-        host.module_eval { ruact_action(:create_post) {} } # no positional arg
-      end.to raise_error(ArgumentError, /exactly one positional parameter/)
-    end
-
-    it "raises ArgumentError when the block accepts more than one positional argument" do
-      expect do
-        host.module_eval { ruact_action(:create_post) { |_a, _b| nil } }
-      end.to raise_error(ArgumentError, /exactly one positional parameter/)
-    end
-
-    it "raises ArgumentError when the block has a required keyword argument" do
-      block_with_kwarg = ->(_p, required:) { required }
-      expect do
-        host.module_eval { ruact_action(:create_post, &block_with_kwarg) }
-      end.to raise_error(ArgumentError, /no required keyword arguments/)
-    end
-
-    it "ACCEPTS a block with a single positional arg" do
-      expect do
-        host.module_eval { ruact_action(:create_post) { |_p| nil } }
-      end.not_to raise_error
-    end
-
-    it "ACCEPTS a block with a splat positional arg" do
-      another_host = Module.new do
-        extend Ruact::ServerAction
-
-        def self.name
-          "SplatHost"
-        end
-      end
-      expect do
-        another_host.module_eval { ruact_action(:create_post) { |*_args| nil } }
-      end.not_to raise_error
-    end
-
-    it "ACCEPTS a block with optional keyword args" do
-      another_host = Module.new do
-        extend Ruact::ServerAction
-
-        def self.name
-          "OptKwHost"
-        end
-      end
-      expect do
-        another_host.module_eval { ruact_action(:create_post) { |_p, key: nil| key } }
-      end.not_to raise_error
-    end
-
-    it "raises Ruact::ConfigurationError for a bad naming-bridge symbol (:Create_Post)" do
-      expect do
-        host.module_eval { ruact_action(:Create_Post) { |_p| nil } }
-      end.to raise_error(Ruact::ConfigurationError) do |error|
-        expect(error.message).to include(":Create_Post")
-        expect(error.message).to include("GuardRailModule")
-      end
-    end
-
-    it "raises Ruact::ConfigurationError for a JS-reserved-word target (:class → \"class\")" do
-      expect do
-        host.module_eval { ruact_action(:class) { |_p| nil } }
-      end.to raise_error(Ruact::ConfigurationError, /JS reserved word/)
-    end
-
-    it "raises Ruact::ConfigurationError for a ruact-runtime-reserved target (:revalidate)" do
-      expect do
-        host.module_eval { ruact_action(:revalidate) { |_p| nil } }
-      end.to raise_error(Ruact::ConfigurationError) do |error|
-        expect(error.message).to include("revalidate")
-      end
-    end
-
-    it "raises Ruact::ConfigurationError for the second standalone host declaring the same symbol" do
-      host.module_eval { ruact_action(:dup_symbol) { |_p| nil } }
-      second_host = Module.new do
-        extend Ruact::ServerAction
-
-        def self.name
-          "SecondHostModule"
-        end
-      end
-      expect do
-        second_host.module_eval { ruact_action(:dup_symbol) { |_p| nil } }
-      end.to raise_error(Ruact::ConfigurationError) do |error|
-        expect(error.message).to include(":dup_symbol")
-        expect(error.message).to include("GuardRailModule")
-        expect(error.message).to include("SecondHostModule")
-      end
-    end
-
-    it "does NOT have a FRAMEWORK_RESERVED_METHODS check — standalone modules can use " \
-       "names that would clobber an ActionController method (e.g., :params), since the " \
-       "module has no ActionController surface" do
-      expect do
-        Module.new do
-          extend Ruact::ServerAction
-
-          def self.name
-            "FrameworkResvHost"
-          end
-
-          ruact_action(:params) { |_p| nil }
-        end
-      end.not_to raise_error
-    end
-
-    it "Story 8.3 review R4 — rejects Class hosts at first ruact_action call with a " \
-       "documented Ruact::ConfigurationError pointing the dev to `include Ruact::Controller`" do
-      klass = Class.new do
-        extend Ruact::ServerAction
-
-        def self.name
-          "WronglyExtendedClass"
-        end
-      end
-
-      expect do
-        klass.class_eval { ruact_action(:bad_host) { |_p| nil } }
-      end.to raise_error(Ruact::ConfigurationError) do |error|
-        expect(error.message).to include("WronglyExtendedClass")
-        expect(error.message).to include("standalone HOST MODULES")
-        expect(error.message).to include("include Ruact::Controller")
-      end
-    end
-
-    it "does NOT install a method_added hook — a later `def` on the host module does not " \
-       "raise (standalone modules don't define action methods at all)" do
-      expect do
-        Module.new do
-          extend Ruact::ServerAction
-
-          def self.name
-            "MethodAddedHost"
-          end
-
-          ruact_action(:registered_action) { |_p| nil }
-
-          # A later method definition on the module would not trigger anything
-          # — the registry holds the block; the module surface is irrelevant.
-          define_method(:registered_action) { :unrelated_def }
-        end
-      end.not_to raise_error
-    end
-  end
-end

data/spec/ruact/server_functions/standalone_context_spec.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-# Story 8.3 — `Ruact::ServerFunctions::StandaloneContext`: AC3 surface
-# (exposes params/request/session/cookies/headers; render/redirect_to/head
-# raise NoMethodError; current_user memoizes + falls back to env key +
-# raises CurrentUserNotConfiguredError when neither path produces a value).
-
-require "spec_helper"
-require "action_controller"
-require "action_dispatch"
-
-module Ruact
-  module ServerFunctions
-    RSpec.describe StandaloneContext, :story_8_3 do
-      let(:env) { {} }
-      let(:request) do
-        ActionDispatch::Request.new(env.merge(
-                                      "REQUEST_METHOD" => "POST",
-                                      "rack.input" => StringIO.new("")
-                                    ))
-      end
-      let(:params) { ActionController::Parameters.new("title" => "Hello") }
-      let(:context) { described_class.new(params: params, request: request) }
-
-      describe "exposed surface (AC3)" do
-        it "exposes params (the action-call args, as ActionController::Parameters)" do
-          expect(context.params).to be_a(ActionController::Parameters)
-          expect(context.params[:title]).to eq("Hello")
-        end
-
-        it "exposes the live request" do
-          expect(context.request).to be(request)
-        end
-
-        it "exposes headers via request.headers" do
-          expect(context.headers).to be(request.headers)
-        end
-      end
-
-      describe "blocked surface — render / redirect_to / head (AC3)" do
-        it "render raises NoMethodError with the documented hint" do
-          expect { context.render(json: { ok: true }) }
-            .to raise_error(NoMethodError, /does not expose `render`/)
-        end
-
-        it "redirect_to raises NoMethodError with the documented hint" do
-          expect { context.redirect_to("/login") }
-            .to raise_error(NoMethodError, /does not expose `redirect_to`/)
-        end
-
-        it "head raises NoMethodError with the documented hint" do
-          expect { context.head(:no_content) }
-            .to raise_error(NoMethodError, /does not expose `head`/)
-        end
-      end
-
-      describe "current_user resolver path (AC3)" do
-        around do |example|
-          Ruact.instance_variable_set(:@config, nil)
-          Ruact.instance_variable_set(:@configured_at_least_once, false)
-          example.run
-        ensure
-          Ruact.instance_variable_set(:@config, nil)
-          Ruact.instance_variable_set(:@configured_at_least_once, false)
-        end
-
-        before do
-          # Silence the warn-on-reconfigure noise.
-          allow(Rails).to receive(:logger).and_return(Logger.new(IO::NULL))
-        end
-
-        it "raises Ruact::CurrentUserNotConfiguredError when no resolver is configured AND no env key is set" do
-          expect { context.current_user }.to raise_error(Ruact::CurrentUserNotConfiguredError) do |err|
-            expect(err.message).to include("Ruact.current_user requires Ruact.config.current_user_resolver")
-            expect(err.message).to include("Devise")
-            expect(err.message).to include("hand-rolled session")
-          end
-        end
-
-        it "returns the configured resolver's value, passing request.env to the lambda" do
-          user = Struct.new(:id).new(42)
-          Ruact.configure do |c|
-            c.current_user_resolver = lambda { |env_arg|
-              expect(env_arg).to be(request.env)
-              user
-            }
-          end
-          expect(context.current_user).to be(user)
-        end
-
-        it "memoizes current_user across multiple calls (resolver invoked once)" do
-          call_count = 0
-          Ruact.configure do |c|
-            c.current_user_resolver = lambda { |_env|
-              call_count += 1
-              :user
-            }
-          end
-          context.current_user
-          context.current_user
-          context.current_user
-          expect(call_count).to eq(1)
-        end
-
-        it "prefers an upstream-set request.env['ruact.current_user'] over the resolver" do
-          env["ruact.current_user"] = :upstream_user
-          resolver_called = false
-          Ruact.configure do |c|
-            c.current_user_resolver = lambda { |_env|
-              resolver_called = true
-              :resolver_user
-            }
-          end
-          expect(context.current_user).to eq(:upstream_user)
-          expect(resolver_called).to be(false)
-        end
-
-        it "falls back to the resolver when the env key is absent (not just nil)" do
-          # Pitfall: env.key? differs from env.fetch — a `nil` value should still
-          # prefer the env path. Verify by setting nil explicitly.
-          env["ruact.current_user"] = nil
-          Ruact.configure do |c|
-            c.current_user_resolver = ->(_env) { :resolver_user }
-          end
-          expect(context.current_user).to be_nil
-        end
-      end
-
-      describe "__ruact_current_user_read? (Pitfall #4 dev warning flag)" do
-        it "is false when the block never reads current_user" do
-          expect(context.__ruact_current_user_read?).to be(false)
-        end
-
-        it "flips to true when the block reads current_user" do
-          Ruact.configure { |c| c.current_user_resolver = ->(_env) { :u } }
-          context.current_user
-          expect(context.__ruact_current_user_read?).to be(true)
-        end
-      end
-    end
-  end
-end