RubyGems - ruact - Versions diffs - 0.0.7 → 0.0.9 - Mend

ruact 0.0.7 → 0.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (61) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +59 -1
data/docs/internal/decisions/server-functions-api.md +55 -0
data/lib/generators/ruact/install/install_generator.rb +378 -6
data/lib/generators/ruact/install/templates/AGENTS.md.tt +159 -0
data/lib/generators/ruact/install/templates/Procfile.dev.tt +3 -0
data/lib/generators/ruact/install/templates/globals.css.tt +20 -0
data/lib/generators/ruact/install/templates/initializer.rb.tt +9 -0
data/lib/generators/ruact/install/templates/package.json.tt +7 -1
data/lib/generators/ruact/install/templates/tsconfig.json.tt +18 -0
data/lib/generators/ruact/scaffold/scaffold_shadcn_preflight.rb +10 -0
data/lib/ruact/configuration.rb +73 -0
data/lib/ruact/controller/document_rendering.rb +210 -0
data/lib/ruact/controller.rb +14 -46
data/lib/ruact/doctor.rb +102 -12
data/lib/ruact/erb_preprocessor.rb +113 -0
data/lib/ruact/errors.rb +16 -0
data/lib/ruact/layout_source.rb +59 -0
data/lib/ruact/manifest_resolver.rb +2 -2
data/lib/ruact/serializable.rb +98 -6
data/lib/ruact/server.rb +163 -0
data/lib/ruact/server_functions/introspection.rb +81 -0
data/lib/ruact/server_functions.rb +26 -4
data/lib/ruact/testing/component_query.rb +113 -0
data/lib/ruact/testing/flight_extractor.rb +221 -0
data/lib/ruact/testing/flight_structure_diff.rb +267 -0
data/lib/ruact/testing/flight_wire_parser.rb +138 -0
data/lib/ruact/testing.rb +90 -0
data/lib/ruact/version.rb +1 -1
data/lib/ruact/view_helper.rb +10 -1
data/lib/ruact.rb +1 -0
data/lib/tasks/ruact.rake +55 -2
data/spec/fixtures/story_7_9_views/controller_request_spec_support/exploding_layout_demo/show.html.erb +3 -0
data/spec/fixtures/story_7_9_views/controller_request_spec_support/ghost_layout_demo/show.html.erb +3 -0
data/spec/fixtures/story_7_9_views/controller_request_spec_support/layout_demo/show.html.erb +3 -0
data/spec/fixtures/story_7_9_views/controller_request_spec_support/rootless_layout_demo/show.html.erb +3 -0
data/spec/fixtures/story_7_9_views/controller_request_spec_support/unwired_layout_demo/show.html.erb +3 -0
data/spec/fixtures/story_7_9_views/layouts/bare_host.html.erb +16 -0
data/spec/fixtures/story_7_9_views/layouts/exploding_host.html.erb +24 -0
data/spec/fixtures/story_7_9_views/layouts/rootless_host.html.erb +15 -0
data/spec/fixtures/story_7_9_views/layouts/ruact_host.html.erb +17 -0
data/spec/ruact/controller_request_spec.rb +203 -0
data/spec/ruact/doctor_spec.rb +222 -6
data/spec/ruact/erb_preprocessor_spec.rb +145 -0
data/spec/ruact/install_generator_spec.rb +727 -70
data/spec/ruact/layout_source_spec.rb +108 -0
data/spec/ruact/manifest_resolver_spec.rb +15 -0
data/spec/ruact/scaffold_generator_spec.rb +14 -0
data/spec/ruact/serializable_spec.rb +126 -0
data/spec/ruact/server_bucket_request_spec.rb +291 -0
data/spec/ruact/server_functions/introspection_spec.rb +135 -0
data/spec/ruact/tasks_json_introspection_spec.rb +141 -0
data/spec/ruact/testing/have_ruact_component_spec.rb +170 -0
data/spec/ruact/testing/no_production_load_spec.rb +41 -0
data/spec/support/flight_wire_parser.rb +12 -126
data/spec/support/matchers/flight_fixture_matcher.rb +7 -258
data/vendor/javascript/ruact-server-functions-runtime/index.d.ts +25 -0
data/vendor/javascript/ruact-server-functions-runtime/index.js +104 -7
data/vendor/javascript/ruact-server-functions-runtime/index.test.mjs +173 -0
data/vendor/javascript/vite-plugin-ruact/type-tests/auto-revalidate.test-d.ts +25 -0
metadata +30 -4

data/spec/fixtures/story_7_9_views/layouts/rootless_host.html.erb ADDED Viewed

@@ -0,0 +1,15 @@
+<%# A layout that calls `ruact_js_assets` but never got the React root div.
+    The payload and the bootstrap both ship, so an assets-only readiness check
+    accepts it — and the browser boots React with nothing to mount into,
+    producing a silently blank page. %>
+<!DOCTYPE html>
+<html>
+  <head>
+    <link rel="stylesheet" href="/host-app.css" />
+    <title>Host App Title</title>
+  </head>
+  <body>
+    <%= yield %>
+    <%= ruact_js_assets %>
+  </body>
+</html>

data/spec/fixtures/story_7_9_views/layouts/ruact_host.html.erb ADDED Viewed

@@ -0,0 +1,17 @@
+<%# A MIGRATED host layout: the app owns the document. The stylesheet link is
+    the whole point — it is the thing ruact's built-in shell has no slot for,
+    so a spec asserting it appears in the response is asserting that the host
+    app's CSS actually reaches a ruact page. %>
+<!DOCTYPE html>
+<html>
+  <head>
+    <link rel="stylesheet" href="/host-app.css" />
+    <title>Host App Title</title>
+  </head>
+  <body>
+    <%= yield %>
+    <%# ruact: root %>
+    <div id="root"></div>
+    <%= ruact_js_assets %>
+  </body>
+</html>

data/spec/ruact/controller_request_spec.rb CHANGED Viewed

@@ -115,6 +115,14 @@ module ControllerRequestSpecSupport
           get  "/errors-demo/new",          to: "controller_request_spec_support/errors_demo#new"
           post "/errors-demo/create",       to: "controller_request_spec_support/errors_demo#create"
           post "/errors-demo/create_valid", to: "controller_request_spec_support/errors_demo#create_valid"
+          # The layout owns the document — a page rendered through a migrated
+          # host layout, and one through a layout that never calls
+          # `ruact_js_assets`.
+          get "/layout-demo/show",         to: "controller_request_spec_support/layout_demo#show"
+          get "/unwired-layout-demo/show", to: "controller_request_spec_support/unwired_layout_demo#show"
+          get "/exploding-layout-demo/show", to: "controller_request_spec_support/exploding_layout_demo#show"
+          get "/rootless-layout-demo/show", to: "controller_request_spec_support/rootless_layout_demo#show"
+          get "/ghost-layout-demo/show", to: "controller_request_spec_support/ghost_layout_demo#show"
         end
       end
     end
@@ -186,6 +194,73 @@ module ControllerRequestSpecSupport
     def show; end
   end
+  # The layout owns the document. Both controllers declare a NAMED layout
+  # instead of relying on `layouts/application`, so adding them cannot change
+  # what every other controller in this file renders (the rest have no
+  # resolvable layout and must keep getting ruact's built-in shell).
+  class LayoutDemoController < ActionController::Base
+    include Ruact::Controller
+    append_view_path File.expand_path("../fixtures/story_7_9_views", __dir__)
+    layout "ruact_host"
+    def show
+      ruact_render
+    end
+  end
+  # An unmigrated layout that RAISES if rendered (it reads an ivar a ruact
+  # action never sets). With the default config ruact must never execute it.
+  class ExplodingLayoutDemoController < ActionController::Base
+    include Ruact::Controller
+    append_view_path File.expand_path("../fixtures/story_7_9_views", __dir__)
+    layout "exploding_host"
+    def show
+      ruact_render
+    end
+  end
+  # Declares a layout that does not exist. `_default_layout` hands back the
+  # String path WITHOUT checking, so "not nil" read as resolvable and the render
+  # raised MissingTemplate instead of degrading.
+  class GhostLayoutDemoController < ActionController::Base
+    include Ruact::Controller
+    append_view_path File.expand_path("../fixtures/story_7_9_views", __dir__)
+    layout "no_such_host"
+    def show
+      ruact_render
+    end
+  end
+  # A layout that calls `ruact_js_assets` but has no root div to mount into.
+  class RootlessLayoutDemoController < ActionController::Base
+    include Ruact::Controller
+    append_view_path File.expand_path("../fixtures/story_7_9_views", __dir__)
+    layout "rootless_host"
+    def show
+      ruact_render
+    end
+  end
+  # Same page, but through a layout that never calls `ruact_js_assets` — the
+  # state every app installed before the layout owned the document is in.
+  class UnwiredLayoutDemoController < ActionController::Base
+    include Ruact::Controller
+    append_view_path File.expand_path("../fixtures/story_7_9_views", __dir__)
+    layout "bare_host"
+    def show
+      ruact_render
+    end
+  end
 end
 # Story 10.0 — write the implicit-render template at file-load time (before the
@@ -251,6 +326,134 @@ module Ruact # rubocop:disable Style/OneClassPerFile
       end
     end
+    # The bug this closes: a ruact page could not carry ANY of the host app's
+    # CSS. `ruact_render` rendered the view with `layout: false` and then wrapped
+    # the payload in a hardcoded shell whose `<head>` has no stylesheet slot, so
+    # `stylesheet_link_tag` in the app's layout never reached the browser. The
+    # generated `--shadcn` scaffold was therefore unstyled by construction, and
+    # Epic 12 (`ruact_meta` → tags in `<head>`) had no surface to write into.
+    #
+    # The opt-in is EXPLICIT (`Ruact.config.layout`). ruact used to infer
+    # readiness from the layout itself; three review rounds each found another
+    # template shape that fooled the inference, so the question is no longer
+    # asked. These examples pin both halves: nothing happens without the config,
+    # and everything happens with it.
+    describe "the layout owns the document" do
+      def configure_layout(value)
+        Ruact.configure do |c|
+          c.manifest_path = ControllerRequestSpecSupport.manifest_path
+          c.layout = value
+        end
+      end
+      # The whole backward-compatibility story, and it is now structural rather
+      # than argued: with the default config ruact never looks at, resolves, or
+      # renders a layout at all.
+      context "with the default configuration (layout = false)" do
+        it "renders the built-in shell, exactly as before the layout path existed" do
+          get "/layout-demo/show"
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to include("Rails RSC")
+          expect(last_response.body).not_to include("host-app.css")
+          expect(last_response.body).to include("DemoButton")
+        end
+        # This layout raises if it is rendered (it reads an ivar a ruact action
+        # never sets) — the shape of a real pre-migration app. Nothing may
+        # execute it.
+        it "never executes an unmigrated layout, so a working page cannot become a 500" do
+          get "/exploding-layout-demo/show"
+          expect(last_response.status).to(eq(200),
+                                          "expected the layout NOT to be rendered; got " \
+                                          "#{last_response.status} body=#{last_response.body[0, 300]}")
+          expect(last_response.body).to include("Rails RSC")
+        end
+      end
+      context "when the app opts in (layout = true)" do
+        before { configure_layout(true) }
+        it "puts the host app's stylesheet on a ruact page (the CSS could not arrive before)" do
+          get "/layout-demo/show"
+          expect(last_response.status).to(eq(200),
+                                          "expected 200, got #{last_response.status} " \
+                                          "body=#{last_response.body[0, 400]}")
+          expect(last_response.body).to include('<link rel="stylesheet" href="/host-app.css" />')
+        end
+        it "keeps the host layout's own <title> instead of ruact's placeholder" do
+          get "/layout-demo/show"
+          expect(last_response.body).to include("<title>Host App Title</title>")
+          expect(last_response.body).not_to include("Rails RSC")
+        end
+        it "still ships the Flight payload and the component, through the layout's ruact_js_assets" do
+          get "/layout-demo/show"
+          expect(last_response.body).to include("__FLIGHT_DATA")
+          expect(last_response.body).to include("DemoButton")
+        end
+        it "does not apply the layout to a Flight request (the wire shape is unchanged)" do
+          get "/layout-demo/show", {}, { "HTTP_ACCEPT" => "text/x-component" }
+          expect(last_response.headers["Content-Type"]).to include("text/x-component")
+          expect(last_response.body).not_to include("host-app.css")
+          expect(last_response.body).to include("DemoButton")
+        end
+        # Opting in and pointing ruact at a layout that cannot mount the app is
+        # a configuration error, and silence would cost a blank page.
+        it "fails loudly when the opted-in layout never calls ruact_js_assets" do
+          expect { get "/unwired-layout-demo/show" }
+            .to raise_error(Ruact::Error, /ruact_js_assets/)
+        end
+        it "fails loudly when the opted-in layout has no root div to mount into" do
+          expect { get "/rootless-layout-demo/show" }
+            .to raise_error(Ruact::Error, /root/)
+        end
+        # A controller that declares a layout which does not exist: Rails'
+        # `_default_layout` returns the String path without checking it, so
+        # "resolvable" has to mean "the template is actually there".
+        it "degrades to the shell when a declared layout does not exist" do
+          get "/ghost-layout-demo/show"
+          expect(last_response.status).to(eq(200),
+                                          "expected a degrade, got #{last_response.status} " \
+                                          "body=#{last_response.body[0, 300]}")
+          expect(last_response.body).to include("Rails RSC")
+          expect(last_response.body).to include("DemoButton")
+        end
+        # `layout false` on one controller inside an app that opted in globally
+        # is a normal Rails pattern, not a mistake — it must degrade, not raise.
+        it "degrades to the shell for a controller with no resolvable layout" do
+          get "/demo/show"
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to include("Rails RSC")
+          expect(last_response.body).to include("DemoButton")
+        end
+      end
+      context "when a named layout is configured" do
+        before { configure_layout("ruact_host") }
+        it "renders every ruact page through that layout" do
+          get "/demo/show"
+          expect(last_response.body).to include("host-app.css")
+          expect(last_response.body).to include("DemoButton")
+        end
+      end
+    end
     describe "regression guard: render context reaches ViewHelper" do
       it "ViewHelper#__ruact_component__ does NOT raise the outside-flow error" do
         # If the handoff regresses, the request returns 500 with this exact

data/spec/ruact/doctor_spec.rb CHANGED Viewed

@@ -23,10 +23,20 @@ RSpec.describe Ruact::Doctor do
     File.write(dir.join("application_controller.rb"), content)
   end
-  def make_layout(with_sentinel: true)
+  # `with_assets` is the second half of a migrated layout: the React root alone
+  # leaves ruact on its built-in (CSS-less) shell, so the two markers are
+  # independent inputs, not one sentinel.
+  def make_layout(with_sentinel: true, with_assets: true)
     dir = tmpdir.join("app", "views", "layouts")
     FileUtils.mkdir_p(dir)
-    content = with_sentinel ? "<%# ruact: root %>\n<div id=\"root\"></div>\n" : "<body></body>\n"
+    content =
+      if !with_sentinel
+        "<body></body>\n"
+      elsif with_assets
+        "<%# ruact: root %>\n<div id=\"root\"></div>\n<%= ruact_js_assets %>\n"
+      else
+        "<%# ruact: root %>\n<div id=\"root\"></div>\n"
+      end
     File.write(dir.join("application.html.erb"), content)
   end
@@ -131,8 +141,11 @@ RSpec.describe Ruact::Doctor do
   describe "#check_layout (AC#1, #5)" do
     subject(:doctor) { described_class.new }
-    context "when layout contains the React shell sentinel" do
-      before { make_layout(with_sentinel: true) }
+    context "when the layout is wired and the app opted in" do
+      before do
+        make_layout(with_sentinel: true, with_assets: true)
+        Ruact.configure { |c| c.layout = true }
+      end
       it "returns :pass" do
         status, = doctor.send(:check_layout)
@@ -140,7 +153,60 @@ RSpec.describe Ruact::Doctor do
       end
     end
-    context "when React shell sentinel is absent" do
+    # Both halves are silent when wrong, and they are DIFFERENT fixes — "add one
+    # line to the layout" versus "flip one setting" — so they report separately.
+    context "when the layout is wired but Ruact.config.layout is false" do
+      before do
+        make_layout(with_sentinel: true, with_assets: true)
+        Ruact.configure { |c| c.layout = false }
+      end
+      it "returns :warn naming the setting, not the layout" do
+        status, message, remediation = doctor.send(:check_layout)
+        expect(status).to eq(:warn)
+        expect(message).to include("config.layout is false")
+        expect(remediation).to include("config.layout = true")
+      end
+      it "does not fail the doctor run" do
+        expect(described_class::SUCCESS_STATUSES).to include(:warn)
+      end
+    end
+    context "when the layout has the React root but never calls ruact_js_assets" do
+      before do
+        make_layout(with_sentinel: true, with_assets: false)
+        Ruact.configure { |c| c.layout = true }
+      end
+      it "fails and names the helper to add" do
+        status, _message, remediation = doctor.send(:check_layout)
+        expect(status).to eq(:fail)
+        expect(remediation).to include("ruact_js_assets")
+      end
+    end
+    # The drift this shares with the runtime and the generator: a MENTION of the
+    # helper in a comment is not a call, and reporting :pass on one sent a
+    # developer looking anywhere but at the real problem.
+    context "when the layout only mentions the helper in a comment" do
+      before do
+        dir = tmpdir.join("app", "views", "layouts")
+        FileUtils.mkdir_p(dir)
+        File.write(dir.join("application.html.erb"),
+                   "<%# ruact: root %>\n<div id=\"root\"></div>\n<%# TODO: add ruact_js_assets %>\n")
+        Ruact.configure { |c| c.layout = true }
+      end
+      it "does not report it as wired" do
+        status, = doctor.send(:check_layout)
+        expect(status).to eq(:fail)
+      end
+    end
+    context "when the layout has neither the root nor the helper" do
       before { make_layout(with_sentinel: false) }
       it "returns :fail" do
@@ -148,8 +214,17 @@ RSpec.describe Ruact::Doctor do
         expect(status).to eq(:fail)
       end
-      it "message is 'React shell missing from application.html.erb'" do
+      it "names both halves, since either could be the missing one" do
         _, msg = doctor.send(:check_layout)
+        expect(msg).to include("React root").and include("ruact_js_assets")
+      end
+    end
+    context "when there is no application layout file at all" do
+      it "reports the file, not its contents" do
+        status, msg = doctor.send(:check_layout)
+        expect(status).to eq(:fail)
         expect(msg).to eq("React shell missing from application.html.erb")
       end
     end
@@ -511,6 +586,141 @@ RSpec.describe Ruact::Doctor do
     end
   end
+  # --- JSON introspection (Story 15.3, FR107, AC1 + AC3 + AC4) ---
+  describe "#as_json (machine-readable report)", :story_15_3 do
+    subject(:doctor) { described_class.new }
+    context "when all checks pass" do
+      before do
+        make_manifest
+        make_controller(with_include: true)
+        make_layout(with_sentinel: true)
+        allow(TCPSocket).to receive(:new).and_return(instance_double(TCPSocket, close: nil))
+      end
+      it "returns a document that round-trips through JSON.parse", :aggregate_failures do
+        report = doctor.as_json
+        reparsed = JSON.parse(JSON.generate(report))
+        expect(reparsed).to eq(report)
+      end
+      it "gates the document with the EXPERIMENTAL schema_version (0)" do
+        expect(doctor.as_json["schema_version"]).to eq(0)
+        expect(doctor.as_json["schema_version"]).to eq(Ruact::Doctor::SCHEMA_VERSION)
+      end
+      it "carries every check with name/status/message/remediation keys", :aggregate_failures do
+        checks = doctor.as_json["checks"]
+        expect(checks.map { |c| c["name"] }).to eq(described_class::CHECKS.map(&:to_s))
+        checks.each do |check|
+          expect(check.keys).to contain_exactly("name", "status", "message", "remediation")
+          expect(check["status"]).to be_a(String)
+          expect(check["message"]).to be_a(String)
+        end
+      end
+      it "reports top-level status 'pass' and exits-zero semantics" do
+        expect(doctor.as_json["status"]).to eq("pass")
+      end
+      it "emits NO prose to stdout (JSON mode is the document only)" do
+        expect { doctor.as_json }.not_to output.to_stdout
+      end
+    end
+    context "when a check fails" do
+      before do
+        make_controller(with_include: true)
+        make_layout(with_sentinel: true)
+        allow(TCPSocket).to receive(:new).and_return(instance_double(TCPSocket, close: nil))
+        # manifest is missing → check_manifest fails
+      end
+      it "reports top-level status 'fail' (non-zero exit semantics)" do
+        expect(doctor.as_json["status"]).to eq("fail")
+      end
+      it "carries the separate machine-readable remediation for the failing check" do
+        manifest = doctor.as_json["checks"].find { |c| c["name"] == "manifest" }
+        expect(manifest["status"]).to eq("fail")
+        expect(manifest["remediation"]).to eq("Run vite build (or bin/dev) to generate the client manifest.")
+      end
+    end
+    context "when a check warns (Rack::Deflater mounted)" do
+      before do
+        make_manifest
+        make_controller(with_include: true)
+        make_layout(with_sentinel: true)
+        allow(TCPSocket).to receive(:new).and_return(instance_double(TCPSocket, close: nil))
+        app = Struct.new(:middleware).new([Struct.new(:name).new("Rack::Deflater")])
+        allow(Rails).to receive(:application).and_return(app)
+      end
+      it "keeps status 'pass' — a :warn does not fail — but exposes the warn check" do
+        report = doctor.as_json
+        expect(report["status"]).to eq("pass")
+        flight = report["checks"].find { |c| c["name"] == "flight_middleware" }
+        expect(flight["status"]).to eq("warn")
+        expect(flight["remediation"]).to include("Exclude text/x-component from compression")
+      end
+    end
+    it "keeps the message byte-identical to the human tuple (remediation is separate)" do
+      _status, human_message = doctor.send(:check_manifest)
+      json_message = doctor.as_json["checks"].find { |c| c["name"] == "manifest" }["message"]
+      expect(json_message).to eq(human_message)
+    end
+  end
+  describe "#results / #passed? (shared compute, Story 15.3)", :story_15_3 do
+    subject(:doctor) { described_class.new }
+    before do
+      make_manifest
+      make_controller(with_include: true)
+      make_layout(with_sentinel: true)
+      allow(TCPSocket).to receive(:new).and_return(instance_double(TCPSocket, close: nil))
+    end
+    it "returns one tuple per check, index-aligned with CHECKS" do
+      expect(doctor.results.length).to eq(described_class::CHECKS.length)
+    end
+    it "passed? is true when all checks pass/warn" do
+      expect(doctor.passed?).to be true
+    end
+    it "runs each check exactly once (as_json does not double-run check_vite's socket)" do
+      # check_vite opens a socket via TCPSocket.new; a single as_json must open it
+      # exactly once — proving #results is computed once, not per consumer.
+      doctor.as_json
+      expect(TCPSocket).to have_received(:new).once
+    end
+  end
+  describe "#run stays byte-identical after the #results refactor (Story 15.3, AC4a)", :story_15_3 do
+    subject(:doctor) { described_class.new }
+    before do
+      make_manifest
+      make_controller(with_include: true)
+      make_layout(with_sentinel: true)
+      allow(TCPSocket).to receive(:new).and_return(instance_double(TCPSocket, close: nil))
+    end
+    it "prints exactly the header + one format_result line per check (no JSON/prose leak), returns true" do
+      # Reconstruct the expected output from the SAME format_result the human
+      # path uses — proves #run still emits header + one glyph line per check
+      # (the optional 3rd remediation element is ignored) and nothing else.
+      lines = doctor.results.map { |status, message| doctor.send(:format_result, status, message) }.join("\n")
+      expected = "[ruact] Health check\n#{lines}\n"
+      expect { expect(doctor.run).to be true }.to output(expected).to_stdout
+    end
+  end
   describe "Rake task definition (Story 5.12)", :story_5_12 do
     # Loads gem/lib/tasks/ruact.rake into a fresh Rake::Application so the
     # task table is isolated from any other spec that may have loaded tasks.
@@ -549,5 +759,11 @@ RSpec.describe Ruact::Doctor do
       # actions is a list of Procs; just assert at least one is attached
       expect(task.actions).not_to be_empty
     end
+    it "defines Rake::Task['ruact:routes'] with an action (Story 15.3)", :story_15_3 do
+      task = rake_app.lookup("ruact:routes")
+      expect(task).not_to be_nil
+      expect(task.actions).not_to be_empty
+    end
   end
 end

data/spec/ruact/erb_preprocessor_spec.rb CHANGED Viewed

@@ -116,6 +116,151 @@ module Ruact
       end
     end
+    # Story 15.2 (FR106) — children inside a PascalCase component tag (a matching
+    # closing tag) fail LOUDLY at preprocess time instead of degrading silently.
+    describe "loud children error (FR106)", :story_15_2 do
+      def run(source, identifier: nil)
+        described_class.transform(source, identifier: identifier)
+      end
+      it "raises on `<Card>Hello</Card>` naming component + fix (AC#1)" do
+        expect { run("<Card>Hello</Card>") }
+          .to raise_error(ChildrenNotSupportedError) do |e|
+            expect(e.message).to include("Card")
+            expect(e.message).to include("children are not supported")
+            expect(e.message).to include("pass content as a prop")
+            expect(e.message).to include("<Card content={...} />")
+          end
+      end
+      it "is a Ruact::PreprocessorError (AC#1 — subclass IS-A base)" do
+        expect { run("<Card>Hello</Card>") }.to raise_error(Ruact::PreprocessorError)
+      end
+      it "raises on an empty pair `<Card></Card>` (AC#1)" do
+        expect { run("<Card></Card>") }.to raise_error(ChildrenNotSupportedError, /Card/)
+      end
+      it "raises on multi-line children (AC#1)" do
+        source = "<Card>\n  <p>hi</p>\n</Card>"
+        expect { run(source) }.to raise_error(ChildrenNotSupportedError, /children are not supported/)
+      end
+      it "raises on a paired tag that also holds a nested component" do
+        expect { run("<Card><Button /></Card>") }
+          .to raise_error(ChildrenNotSupportedError, /<Card>/)
+      end
+      it "names the supplied identifier and the correct line for a non-first-line pair (AC#4)" do
+        source = "line1\nline2\n<Card>Hello</Card>"
+        expect { run(source, identifier: "app/views/posts/show.html.erb") }
+          .to raise_error(ChildrenNotSupportedError) do |e|
+            expect(e.message).to include("app/views/posts/show.html.erb:3")
+          end
+      end
+      it "reports the opening tag's line, honoring attributes on the opening tag" do
+        expect { run("<Card variant={:wide}>x</Card>", identifier: "t.erb") }
+          .to raise_error(ChildrenNotSupportedError, /t\.erb:1/)
+      end
+      # Regression (Codex Round 1, Patch 1): a MULTI-LINE Suspense opening tag
+      # must not shift the reported line — the `<Card>` below is physically on
+      # line 5 and must report :5 (Suspense is masked newline-for-newline).
+      it "reports the exact source line even after a multi-line Suspense opening" do
+        source = <<~ERB
+          <Suspense
+            fallback="loading"
+            delay="2.5">
+          </Suspense>
+          <Card>Hello</Card>
+        ERB
+        expect { run(source, identifier: "t.erb") }
+          .to raise_error(ChildrenNotSupportedError, /t\.erb:5/)
+      end
+      # Regression (Codex Round 2, Patch 1): a `</Dialog>` living inside an ERB
+      # island (Ruby string/comment) must NOT be mistaken for a real component
+      # closing tag — a valid bare `<Dialog open={true}>` stays valid.
+      it "does not false-pair a bare opening with a `</Tag>` inside an ERB island" do
+        source = %(<Dialog open={true}>\n<% x = "</Dialog>" %>)
+        expect { run(source) }.not_to raise_error
+      end
+      it "still fires when the closing tag is real ERB body, not inside `<% %>`" do
+        expect { run("<Card><%= @body %></Card>") }
+          .to raise_error(ChildrenNotSupportedError, /Card/)
+      end
+      # Regression (Codex Round 2, Patch 2): many bare non-self-closing openings
+      # with no close must stay linear (single-pass stack scan) and silent (D3).
+      it "stays silent and does not blow up on many bare unclosed openings" do
+        source = "<Dialog open={true}>\n" * 5000
+        expect { run(source) }.not_to raise_error
+      end
+      # Regression (Codex Round 3, Patch 1): stray/unmatched PascalCase closing
+      # tags (no preceding matching open) are literal text — never an error — and
+      # must stay linear (per-name O(1) lookup, no `rindex`). Correctness pin;
+      # perf verified live, not timed here (avoids a flaky benchmark spec).
+      it "does not raise on stray closing tags with no matching opening" do
+        source = "</Card>\n" * 5000
+        expect { run(source) }.not_to raise_error
+      end
+      it "still raises when a real opening precedes the stray closes" do
+        source = "<Card>x</Card>\n#{'</Card>' * 100}"
+        expect { run(source) }.to raise_error(ChildrenNotSupportedError, /Card/)
+      end
+      # AC#2 regression — the loud error must NOT fire on any valid pattern.
+      describe "does NOT fire on valid patterns (AC#2 byte-identical)" do
+        it "self-closing tag, no props" do
+          expect { run("<Button />") }.not_to raise_error
+        end
+        it "self-closing tag with props" do
+          expect { run("<LikeButton postId={@post.id} />") }.not_to raise_error
+        end
+        it "bare non-self-closing opening tag with NO closing tag (`<Dialog open={true}>`)" do
+          expect { run("<Dialog open={true}>") }.not_to raise_error
+        end
+        it "nested-brace prop value" do
+          expect { run("<Select options={Category.all.map { |c| c.id }} />") }.not_to raise_error
+        end
+        it "multiple self-closing components" do
+          expect { run('<Button /> and <Badge label={"hello"} />') }.not_to raise_error
+        end
+        it "mixed HTML around a self-closing component" do
+          source = %(<div class="container">\n  <h1>Hi</h1>\n  <LikeButton postId={1} />\n</div>)
+          expect { run(source) }.not_to raise_error
+        end
+        it "emits byte-identical output for `<Dialog open={true}>`" do
+          expect(run("<Dialog open={true}>"))
+            .to eq(%(<%= __ruact_component__("Dialog", { "open" => true }) %>))
+        end
+      end
+      # AC#3 — Suspense children are the ONE legitimate paired PascalCase tag and
+      # must never trip the error (normalized to <ruact-suspense> in Step 1).
+      describe "Suspense children never trip the error (AC#3)" do
+        it "does not raise for `<Suspense><Spinner /></Suspense>`" do
+          expect { run(%(<Suspense fallback="loading"><Spinner /></Suspense>)) }.not_to raise_error
+        end
+        it "normalizes Suspense to <ruact-suspense> exactly as today" do
+          result = run(%(<Suspense fallback="loading"><Spinner /></Suspense>))
+          expect(result).to include(%(data-ruact-fallback="loading"))
+          expect(result).to include("</ruact-suspense>")
+        end
+      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