ruact 0.0.4 → 0.0.6

data/spec/ruact/erb_preprocessor_spec.rb

@@ -85,5 +85,132 @@ module Ruact
         expect(result).to match(/__ruact_component__\("LikeButton"/)
       end
     end
+
+    # Bugfix (Sprint Change Proposal 2026-06-16 §4.5): `<Suspense delay="2.5">`
+    # used to be ignored — the preprocessor never carried the attribute, so the
+    # SuspenseElement always took its default delay. It now forwards an optional
+    # `delay` as `data-ruact-delay` on the emitted <ruact-suspense> element.
+    describe "Suspense delay attribute" do
+      it "forwards delay to the ruact-suspense element as data-ruact-delay" do
+        result = transform.call(%(<Suspense fallback="loading" delay="2.5"><Spinner /></Suspense>))
+        expect(result).to include(%(data-ruact-delay="2.5"))
+        expect(result).to include(%(data-ruact-fallback="loading"))
+        expect(result).to include("</ruact-suspense>")
+      end
+
+      it "omits data-ruact-delay when no delay attribute is present" do
+        result = transform.call(%(<Suspense fallback="loading"><Spinner /></Suspense>))
+        expect(result).to include(%(data-ruact-fallback="loading"))
+        expect(result).not_to include("data-ruact-delay")
+      end
+
+      it "extracts delay regardless of attribute order" do
+        result = transform.call(%(<Suspense delay="0.75" fallback="wait"><X /></Suspense>))
+        expect(result).to include(%(data-ruact-delay="0.75"))
+        expect(result).to include(%(data-ruact-fallback="wait"))
+      end
+
+      it "accepts a single-quoted delay attribute" do
+        result = transform.call(%(<Suspense fallback='loading' delay='1.5'><X /></Suspense>))
+        expect(result).to include(%(data-ruact-delay="1.5"))
+      end
+    end
+
+    # Story 13.5 (FR100) — preprocess-time component-contract validation, wired
+    # through an injectable registry seam (a stub responding to +contract_for+).
+    describe "component contract validation", :story_13_5 do
+      # A minimal stub registry: maps component name → contract Hash (or nil).
+      def registry_for(contracts)
+        Class.new do
+          def initialize(contracts) = (@contracts = contracts)
+          def contract_for(name, **) = @contracts[name]
+        end.new(contracts)
+      end
+
+      let(:contract) do
+        { "props" => { "postId" => "required", "initialCount" => "optional" } }
+      end
+      let(:registry) { registry_for("LikeButton" => contract) }
+
+      def run(source, identifier: "app/views/posts/show.html.erb")
+        described_class.transform(source, identifier: identifier, registry: registry)
+      end
+
+      it "raises on a missing required prop, naming component + file:line + fix (AC#1, AC#3)" do
+        expect { run("<LikeButton initialCount={5} />") }
+          .to raise_error(ComponentContractError) do |e|
+            expect(e.message).to include("LikeButton")
+            expect(e.message).to include("app/views/posts/show.html.erb:1")
+            expect(e.message).to include("postId")
+            expect(e.message).to include("add the required prop")
+          end
+      end
+
+      it "raises on an unknown prop with a did-you-mean suggestion (AC#3)" do
+        expect { run("<LikeButton postId={1} postID={2} />") }
+          .to raise_error(ComponentContractError, /did you mean "postId"\?/)
+      end
+
+      it "computes the correct line for a call site lower in the template" do
+        source = "line1\nline2\n<LikeButton initialCount={5} />"
+        expect { run(source) }.to raise_error(ComponentContractError, /show\.html\.erb:3/)
+      end
+
+      it "passes a valid call and emits the normal placeholder (AC#1)" do
+        result = run("<LikeButton postId={@post.id} initialCount={5} />")
+        expect(result)
+          .to eq(%(<%= __ruact_component__("LikeButton", { "postId" => @post.id, "initialCount" => 5 }) %>))
+      end
+
+      it "does NOT re-wrap the contract error with the generic line/snippet tail" do
+        expect { run("<LikeButton initialCount={5} />") }
+          .to raise_error(ComponentContractError) { |e| expect(e.message).not_to match(/at line \d+:/) }
+      end
+
+      # AC#2 — opt-in / byte-identity: a component with no contract entry is
+      # validated NOT AT ALL and emits the exact same placeholder as pre-13.5.
+      describe "opt-in fail-open (AC#2)" do
+        it "emits byte-identical output for a contract-less component" do
+          source = "<NavBar foo={1} bar={2} />"
+          with_contract    = run(source) # registry has NO "NavBar" entry → fail open
+          without_registry = described_class.transform(source, registry: nil)
+          expected = %(<%= __ruact_component__("NavBar", { "foo" => 1, "bar" => 2 }) %>)
+          expect(with_contract).to eq(expected)
+          expect(without_registry).to eq(expected)
+        end
+
+        it "never consults the registry for a no-tag source (fast path)" do
+          spy_registry = registry_for({})
+          allow(spy_registry).to receive(:contract_for).and_call_original
+          result = described_class.transform("<div><p>plain</p></div>", registry: spy_registry)
+          expect(result).to eq("<div><p>plain</p></div>")
+          expect(spy_registry).not_to have_received(:contract_for)
+        end
+
+        # Codex review (Patch 2) — the DEFAULT registry (`Ruact.manifest`) must
+        # not even be read when the source has no component tags.
+        it "never reads Ruact.manifest for a no-tag source (default registry)" do
+          allow(Ruact).to receive(:manifest)
+          described_class.transform("<div><p>plain</p></div>")
+          expect(Ruact).not_to have_received(:manifest)
+        end
+      end
+
+      describe "slots (AC#5)" do
+        let(:contract) do
+          { "props" => { "title" => "required" }, "slots" => { "header" => "required" } }
+        end
+        let(:registry) { registry_for("Card" => contract) }
+
+        it "raises when a required slot attribute is omitted at the call site" do
+          expect { run("<Card title={@t} />") }
+            .to raise_error(ComponentContractError, /missing required slot.*header/m)
+        end
+
+        it "passes when the declared slot is supplied as an attribute" do
+          expect { run("<Card title={@t} header={@h} />") }.not_to raise_error
+        end
+      end
+    end
   end
 end

data/spec/ruact/errors_spec.rb

@@ -60,25 +60,6 @@ module Ruact
       end
     end
 
-    describe "Ruact::CurrentUserNotConfiguredError", :story_8_3 do
-      it "is a subclass of Ruact::Error" do
-        expect(CurrentUserNotConfiguredError.ancestors).to include(Error)
-      end
-
-      it "carries a default message that names BOTH Devise and hand-rolled-session worked examples" do
-        message = CurrentUserNotConfiguredError.new.message
-        expect(message).to include("Ruact.current_user requires Ruact.config.current_user_resolver to be set")
-        expect(message).to include("Devise")
-        expect(message).to include("env['warden']")
-        expect(message).to include("hand-rolled session")
-        expect(message).to include("rack.session")
-      end
-
-      it "accepts a custom message" do
-        expect(CurrentUserNotConfiguredError.new("explicit").message).to eq("explicit")
-      end
-    end
-
     describe "Ruact::UploadTooLargeError", :story_8_5 do
       it "is a subclass of Ruact::Error (so Story 8.4 rescue_from StandardError catches it)" do
         expect(UploadTooLargeError.ancestors).to include(Error)
@@ -108,31 +89,5 @@ module Ruact
           .to raise_error(StandardError)
       end
     end
-
-    describe "Ruact::ActionError", :story_8_3 do
-      it "is a subclass of Ruact::Error" do
-        expect(ActionError.ancestors).to include(Error)
-      end
-
-      it "carries status + body so the dispatcher can render without `render` access" do
-        error = ActionError.new(status: 422, body: { error: "invalid" })
-        expect(error.status).to eq(422)
-        expect(error.body).to eq(error: "invalid")
-      end
-
-      it "accepts a Symbol status" do
-        error = ActionError.new(status: :unprocessable_entity, body: nil)
-        expect(error.status).to eq(:unprocessable_entity)
-        expect(error.body).to be_nil
-      end
-
-      it "synthesises a legible message when none is given" do
-        expect(ActionError.new(status: 401, body: nil).message).to include("status=401")
-      end
-
-      it "honours an explicit custom message" do
-        expect(ActionError.new(status: 500, body: {}, message: "explicit").message).to eq("explicit")
-      end
-    end
   end
 end

data/spec/ruact/html_converter_spec.rb

@@ -12,6 +12,56 @@ module Ruact
       end
     end
 
+    # Bugfix (Sprint Change Proposal 2026-06-16 §4.5): the ERB `delay` attribute
+    # is carried as `data-ruact-delay` and must reach SuspenseElement#delay; an
+    # absent, blank, or unparseable value falls back to the element's default.
+    describe "Suspense element conversion (delay)" do
+      let(:default_delay) do
+        Ruact::Flight::SuspenseElement.new(fallback: nil, children: "x").delay
+      end
+
+      it "parses data-ruact-delay into SuspenseElement#delay as a Float" do
+        html = %(<ruact-suspense data-ruact-fallback="loading" data-ruact-delay="2.5"><p>content</p></ruact-suspense>)
+        result = convert.call(html)
+        expect(result).to be_a(Ruact::Flight::SuspenseElement)
+        expect(result.delay).to eq(2.5)
+      end
+
+      it "falls back to the default delay when the attribute is absent" do
+        html = %(<ruact-suspense data-ruact-fallback="loading"><p>content</p></ruact-suspense>)
+        result = convert.call(html)
+        expect(result).to be_a(Ruact::Flight::SuspenseElement)
+        expect(result.delay).to eq(default_delay)
+      end
+
+      it "falls back to the default delay when the attribute is unparseable" do
+        html = %(<ruact-suspense data-ruact-fallback="loading" data-ruact-delay="soon"><p>content</p></ruact-suspense>)
+        expect(convert.call(html).delay).to eq(default_delay)
+      end
+
+      it "falls back to the default delay when the attribute is blank" do
+        html = %(<ruact-suspense data-ruact-fallback="loading" data-ruact-delay=""><p>content</p></ruact-suspense>)
+        expect(convert.call(html).delay).to eq(default_delay)
+      end
+
+      it "treats delay=\"0\" as an explicit zero delay, not absent" do
+        html = %(<ruact-suspense data-ruact-fallback="loading" data-ruact-delay="0"><p>content</p></ruact-suspense>)
+        expect(convert.call(html).delay).to eq(0.0)
+      end
+
+      it "parses a delay value with surrounding whitespace" do
+        html = %(<ruact-suspense data-ruact-fallback="loading" data-ruact-delay=" 2.5 "><p>content</p></ruact-suspense>)
+        expect(convert.call(html).delay).to eq(2.5)
+      end
+
+      it "falls back to the default delay when the value overflows to a non-finite Float" do
+        # Float("1e309") => Infinity (Float() does not raise on overflow); a
+        # non-finite delay must not reach the renderer's sleep (RangeError).
+        html = %(<ruact-suspense data-ruact-fallback="loading" data-ruact-delay="1e309"><p>content</p></ruact-suspense>)
+        expect(convert.call(html).delay).to eq(default_delay)
+      end
+    end
+
     describe "single DOM element" do
       it "converts a div with class and text child" do
         result = convert.call('<div class="box">hi</div>')