ruact 0.0.1

data/spec/ruact/controller_spec.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "active_support/concern"
+require "ruact/controller"
+
+module Ruact
+  RSpec.describe Controller do
+    let(:test_class) do
+      Class.new do
+        include Ruact::Controller
+
+        attr_reader :request
+
+        def initialize(fake_request)
+          @request = fake_request
+        end
+      end
+    end
+
+    # Minimal test double — `headers` + `format` needed for the methods under test.
+    # `format` must be a public struct member (not Kernel#format) so that
+    # verify_partial_doubles can stub it in #default_render tests.
+    let(:fake_request) { Struct.new(:headers, :format).new({}, nil) }
+    let(:controller)   { test_class.new(fake_request) }
+
+    describe "#rsc_manifest" do
+      it "reads from Ruact.manifest (AC#6)" do
+        test_manifest = ClientManifest.from_hash({})
+        allow(Ruact).to receive(:manifest).and_return(test_manifest)
+        expect(controller.send(:rsc_manifest)).to be test_manifest
+      end
+    end
+
+    describe "#rsc_request?" do
+      it "returns true when Accept: text/x-component" do
+        fake_request.headers["Accept"] = "text/x-component"
+        expect(controller.send(:rsc_request?)).to be true
+      end
+
+      it "returns true when Accept header includes text/x-component alongside other types" do
+        fake_request.headers["Accept"] = "text/x-component, */*"
+        expect(controller.send(:rsc_request?)).to be true
+      end
+
+      it "returns true when RSC-Request: 1 header is set" do
+        fake_request.headers["RSC-Request"] = "1"
+        expect(controller.send(:rsc_request?)).to be true
+      end
+
+      it "returns false when Accept: text/html" do
+        fake_request.headers["Accept"] = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        expect(controller.send(:rsc_request?)).to be false
+      end
+
+      it "returns false when no Accept header is set" do
+        expect(controller.send(:rsc_request?)).to be false
+      end
+    end
+
+    describe "#default_render" do
+      let(:html_format) { Class.new { def html? = true }.new }
+      let(:json_format) { Class.new { def html? = false }.new }
+
+      before do
+        allow(controller).to receive(:rsc_template_exists?).and_return(true)
+        allow(controller).to receive(:rsc_render)
+      end
+
+      it "calls rsc_render when format is HTML and template exists (AC#1)" do
+        allow(fake_request).to receive(:format).and_return(html_format)
+        controller.send(:default_render)
+        expect(controller).to have_received(:rsc_render)
+      end
+
+      it "calls rsc_render for RSC requests (text/x-component) even without html? (AC#1)" do
+        allow(fake_request).to receive(:format).and_return(json_format)
+        fake_request.headers["RSC-Request"] = "1"
+        controller.send(:default_render)
+        expect(controller).to have_received(:rsc_render)
+      end
+
+      it "does NOT call rsc_render when format is not HTML and not RSC (AC#5, AC#6 — FR26)" do
+        allow(fake_request).to receive(:format).and_return(json_format)
+        allow(controller).to receive(:rsc_render)
+        begin
+          controller.send(:default_render)
+        rescue StandardError
+          nil
+        end
+        expect(controller).not_to have_received(:rsc_render)
+      end
+
+      it "does NOT call rsc_render when no template exists" do
+        allow(controller).to receive(:rsc_template_exists?).and_return(false)
+        allow(fake_request).to receive(:format).and_return(html_format)
+        begin
+          controller.send(:default_render)
+        rescue StandardError
+          nil
+        end
+        expect(controller).not_to have_received(:rsc_render)
+      end
+    end
+
+    describe "#redirect_to" do
+      # Build a class hierarchy so `super` inside the override can call a base implementation.
+      # url_for and render must be defined for verify_partial_doubles to allow stubbing them.
+      let(:redirect_test_class) do
+        base = Class.new do
+          def redirect_to(*)
+            :super_called
+          end
+
+          def url_for(options)
+            options.is_a?(String) ? options : "/"
+          end
+
+          def render(**_opts); end
+        end
+        Class.new(base) do
+          include Ruact::Controller
+
+          attr_reader :request
+
+          def initialize(req)
+            super()
+            @request = req
+          end
+        end
+      end
+
+      let(:rsc_ctrl) do
+        redirect_test_class.new(Struct.new(:headers, :host).new({ "Accept" => "text/x-component" }, "localhost"))
+      end
+      let(:html_ctrl) do
+        redirect_test_class.new(Struct.new(:headers, :host).new({}, "localhost"))
+      end
+
+      context "when RSC request with same-origin URL (AC #1, #5)" do
+        before { allow(rsc_ctrl).to receive(:url_for).and_return("/posts/1") }
+
+        it "calls render with a Flight redirect row (not a 302)" do
+          allow(rsc_ctrl).to receive(:render)
+          rsc_ctrl.send(:redirect_to, "/posts/1")
+          expect(rsc_ctrl).to have_received(:render).with(
+            plain: "0:{\"redirectUrl\":\"/posts/1\",\"redirectType\":\"push\"}\n",
+            content_type: "text/x-component"
+          )
+        end
+
+        it "redirect row matches the flight fixture (AC #5)" do
+          rendered_plain = nil
+          allow(rsc_ctrl).to receive(:render) { |opts| rendered_plain = opts[:plain] }
+          rsc_ctrl.send(:redirect_to, "/posts/1")
+          expect(rendered_plain).to match_flight_fixture("redirect_row")
+        end
+      end
+
+      context "when RSC request with external URL (AC #3)" do
+        before { allow(rsc_ctrl).to receive(:url_for).and_return("https://external.com/page") }
+
+        it "does NOT emit a redirect row (falls back to super)" do
+          allow(rsc_ctrl).to receive(:render)
+          rsc_ctrl.send(:redirect_to, "https://external.com/page")
+          expect(rsc_ctrl).not_to have_received(:render)
+        end
+      end
+
+      context "when non-RSC request (AC #4)" do
+        before { allow(html_ctrl).to receive(:url_for).and_return("/posts/1") }
+
+        it "does NOT emit a redirect row (falls back to super)" do
+          allow(html_ctrl).to receive(:render)
+          html_ctrl.send(:redirect_to, "/posts/1")
+          expect(html_ctrl).not_to have_received(:render)
+        end
+      end
+    end
+
+    describe "#rsc_html_shell" do
+      # vite_tags requires Rails.env — stub it so we can test the shell structure.
+      before { allow(controller).to receive(:vite_tags).and_return("") }
+
+      let(:payload) { "0:[\"$\",\"div\",null,{}]\n" }
+
+      it "returns a string containing window.__FLIGHT_DATA" do
+        html = controller.send(:rsc_html_shell, payload)
+        expect(html).to include("__FLIGHT_DATA")
+      end
+
+      it "wraps the payload in an IIFE push" do
+        html = controller.send(:rsc_html_shell, payload)
+        expect(html).to include("d.push(")
+      end
+
+      it "contains a root div#root element" do
+        html = controller.send(:rsc_html_shell, payload)
+        expect(html).to include('<div id="root">')
+      end
+
+      it "escapes </script> in the payload to prevent XSS breakout" do
+        dangerous_payload = "0:\"</script><script>alert(1)</script>\"\n"
+        html = controller.send(:rsc_html_shell, dangerous_payload)
+        # The HTML must contain exactly ONE </script> — the real closing tag of the script block.
+        # If the payload's </script> leaked through, there would be more than one.
+        occurrences = html.scan("</script>")
+        count = occurrences.length
+        expect(count).to eq(1), "Expected 1 </script> (closing tag), found #{count}"
+      end
+    end
+  end
+end

data/spec/ruact/doctor_spec.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+require "fileutils"
+require "socket"
+
+# The Rails stub (including Rails.root) is provided by spec/support/rails_stub.rb.
+require "ruact/doctor"
+
+RSpec.describe Ruact::Doctor do
+  let(:tmpdir) { Pathname.new(Dir.mktmpdir) }
+
+  before { Rails.root = tmpdir }
+  after  { FileUtils.rm_rf(tmpdir) }
+
+  # --- helpers ---
+
+  def make_controller(with_include: true)
+    dir = tmpdir.join("app", "controllers")
+    FileUtils.mkdir_p(dir)
+    content = with_include ? "include Ruact::Controller\n" : "class ApplicationController\nend\n"
+    File.write(dir.join("application_controller.rb"), content)
+  end
+
+  def make_layout(with_sentinel: 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"
+    File.write(dir.join("application.html.erb"), content)
+  end
+
+  def make_manifest
+    dir = tmpdir.join("public")
+    FileUtils.mkdir_p(dir)
+    File.write(dir.join("react-client-manifest.json"), "{}")
+  end
+
+  # --- check_manifest ---
+
+  describe "#check_manifest (AC#1, #2)" do
+    subject(:doctor) { described_class.new }
+
+    context "when manifest file exists" do
+      before { make_manifest }
+
+      it "returns :pass" do
+        status, = doctor.send(:check_manifest)
+        expect(status).to eq(:pass)
+      end
+
+      it "message includes 'Manifest found at'" do
+        _, msg = doctor.send(:check_manifest)
+        expect(msg).to include("Manifest found at")
+      end
+    end
+
+    context "when manifest file is missing" do
+      it "returns :fail" do
+        status, = doctor.send(:check_manifest)
+        expect(status).to eq(:fail)
+      end
+
+      it "message is 'Manifest not found — run vite build'" do
+        _, msg = doctor.send(:check_manifest)
+        expect(msg).to eq("Manifest not found — run vite build")
+      end
+    end
+  end
+
+  # --- check_vite ---
+
+  describe "#check_vite (AC#1, #3)" do
+    subject(:doctor) { described_class.new }
+
+    context "when Vite is accessible" do
+      before { allow(TCPSocket).to receive(:new).and_return(instance_double(TCPSocket, close: nil)) }
+
+      it "returns :pass" do
+        status, = doctor.send(:check_vite)
+        expect(status).to eq(:pass)
+      end
+    end
+
+    context "when Vite is not accessible" do
+      before { allow(TCPSocket).to receive(:new).and_raise(Errno::ECONNREFUSED) }
+
+      it "returns :fail" do
+        status, = doctor.send(:check_vite)
+        expect(status).to eq(:fail)
+      end
+
+      it "message is 'Vite not accessible at localhost:5173 — run npm run dev'" do
+        _, msg = doctor.send(:check_vite)
+        expect(msg).to eq("Vite not accessible at localhost:5173 — run npm run dev")
+      end
+    end
+  end
+
+  # --- check_controller ---
+
+  describe "#check_controller (AC#1, #4)" do
+    subject(:doctor) { described_class.new }
+
+    context "when ApplicationController includes Ruact::Controller" do
+      before { make_controller(with_include: true) }
+
+      it "returns :pass" do
+        status, = doctor.send(:check_controller)
+        expect(status).to eq(:pass)
+      end
+    end
+
+    context "when Ruact::Controller is not included" do
+      before { make_controller(with_include: false) }
+
+      it "returns :fail" do
+        status, = doctor.send(:check_controller)
+        expect(status).to eq(:fail)
+      end
+
+      it "message is 'Ruact::Controller not included in ApplicationController'" do
+        _, msg = doctor.send(:check_controller)
+        expect(msg).to eq("Ruact::Controller not included in ApplicationController")
+      end
+    end
+  end
+
+  # --- check_layout ---
+
+  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) }
+
+      it "returns :pass" do
+        status, = doctor.send(:check_layout)
+        expect(status).to eq(:pass)
+      end
+    end
+
+    context "when React shell sentinel is absent" do
+      before { make_layout(with_sentinel: false) }
+
+      it "returns :fail" do
+        status, = doctor.send(:check_layout)
+        expect(status).to eq(:fail)
+      end
+
+      it "message is 'React shell missing from application.html.erb'" do
+        _, msg = doctor.send(:check_layout)
+        expect(msg).to eq("React shell missing from application.html.erb")
+      end
+    end
+  end
+
+  # --- check_streaming ---
+
+  describe "#check_streaming (AC#5)" do
+    subject(:doctor) { described_class.new }
+
+    after { Ruact.streaming_mode = nil }
+
+    it "always returns :pass" do
+      status, = doctor.send(:check_streaming)
+      expect(status).to eq(:pass)
+    end
+
+    context "when streaming_mode is :enabled (AC#1, #5)" do
+      before do
+        Ruact.streaming_mode = :enabled
+        stub_const("Puma", Module.new)
+      end
+
+      it "message includes 'enabled' and 'Puma'" do
+        _, msg = doctor.send(:check_streaming)
+        expect(msg).to include("enabled").and include("Puma")
+      end
+    end
+
+    context "when streaming_mode is :buffered with no known server (AC#3, #5)" do
+      before { Ruact.streaming_mode = :buffered }
+
+      it "message includes 'buffered'" do
+        _, msg = doctor.send(:check_streaming)
+        expect(msg).to include("buffered")
+      end
+    end
+
+    context "when streaming_mode is nil (not yet detected)" do
+      before { Ruact.streaming_mode = nil }
+
+      it "defaults to buffered in the message" do
+        _, msg = doctor.send(:check_streaming)
+        expect(msg).to include("buffered")
+      end
+    end
+  end
+
+  # --- run / .run ---
+
+  describe ".run / #run (AC#1, #7)" 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
+
+    context "when all checks pass" do
+      it "returns true" do
+        expect(described_class.run).to be true
+      end
+
+      it "does not print the fix hint" do
+        expect { described_class.run }.not_to output(/rails generate/).to_stdout
+      end
+    end
+
+    context "when any check fails" do
+      before { allow(TCPSocket).to receive(:new).and_raise(Errno::ECONNREFUSED) }
+
+      it "returns false" do
+        expect(described_class.run).to be false
+      end
+
+      it "prints the fix hint" do
+        expect { described_class.run }
+          .to output(/Run rails generate ruact:install to fix configuration issues/).to_stdout
+      end
+    end
+  end
+end

data/spec/ruact/erb_preprocessor_hook_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Ruact
+  RSpec.describe ErbPreprocessorHook do
+    # Minimal stand-in for ActionView::Template::Handlers::ERB:
+    # base implementation just returns source unchanged so we can inspect the
+    # transformed version that the hook passes to super.
+    let(:handler_class) do
+      klass = Class.new do
+        def call(_template, source)
+          source
+        end
+      end
+      klass.prepend(described_class)
+      klass
+    end
+
+    let(:handler) { handler_class.new }
+    let(:fake_template) { Object.new }
+
+    describe "#call" do
+      it "applies ErbPreprocessor.transform to source before calling super" do
+        source = "<LikeButton postId={1} />"
+        result = handler.call(fake_template, source)
+        expect(result).to include("__rsc_component__")
+        expect(result).to include('"LikeButton"')
+        expect(result).not_to include("<LikeButton")
+      end
+
+      it "passes source unchanged when no PascalCase tags present (fast-path)" do
+        source = "<div class=\"hello\"><p>No RSC here</p></div>"
+        result = handler.call(fake_template, source)
+        expect(result).to eq(source)
+      end
+
+      it "processes multiple components in a single template" do
+        source = "<NavBar /><LikeButton postId={1} />"
+        result = handler.call(fake_template, source)
+        expect(result).to include('"NavBar"')
+        expect(result).to include('"LikeButton"')
+      end
+
+      it "transforms Suspense tags correctly" do
+        source = "<Suspense fallback=\"Loading\"><PostCard /></Suspense>"
+        result = handler.call(fake_template, source)
+        expect(result).to include("__rsc_component__")
+      end
+    end
+  end
+end

data/spec/ruact/erb_preprocessor_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Ruact
+  RSpec.describe ErbPreprocessor do
+    subject(:transform) { ->(source) { described_class.transform(source) } }
+
+    describe "self-closing tags" do
+      it "transforms a self-closing tag with no props" do
+        expect(transform.call("<Button />")).to eq(%(<%= __rsc_component__("Button", {}) %>))
+      end
+
+      it "transforms a self-closing tag with props" do
+        result = transform.call("<LikeButton postId={@post.id} initialCount={5} />")
+        expect(result).to eq(%(<%= __rsc_component__("LikeButton", { "postId" => @post.id, "initialCount" => 5 }) %>))
+      end
+    end
+
+    describe "opening tags" do
+      it "transforms an opening tag with props" do
+        result = transform.call("<Dialog open={true}>")
+        expect(result).to eq(%(<%= __rsc_component__("Dialog", { "open" => true }) %>))
+      end
+    end
+
+    describe "passthrough (no transformation)" do
+      it "does not touch lowercase HTML tags" do
+        source = '<div class="foo"><span>hello</span></div>'
+        expect(transform.call(source)).to eq(source)
+      end
+
+      it "does not touch ERB tags" do
+        source = "<%= @post.title %>"
+        expect(transform.call(source)).to eq(source)
+      end
+    end
+
+    describe "complex prop expressions" do
+      it "handles nested braces in a prop value" do
+        result = transform.call("<Select options={Category.all.map { |c| c.id }} />")
+        expect(result).to eq(%(<%= __rsc_component__("Select", { "options" => Category.all.map { |c| c.id } }) %>))
+      end
+    end
+
+    describe "error handling" do
+      it "raises PreprocessorError with line number and snippet for unclosed brace (AC#3)" do
+        source = "<LikeButton postId={@post.id />"
+        expect { transform.call(source) }
+          .to raise_error(PreprocessorError, /unclosed brace/)
+        expect { transform.call(source) }
+          .to raise_error(PreprocessorError, /line 1/)
+        expect { transform.call(source) }
+          .to raise_error(PreprocessorError, /LikeButton/)
+      end
+
+      it "includes the correct line number for an error on line 3" do
+        source = "line1\nline2\n<Bad prop={unclosed />"
+        expect { transform.call(source) }
+          .to raise_error(PreprocessorError, /line 3/)
+      end
+    end
+
+    describe "multiple components" do
+      it "transforms multiple components in the same string" do
+        source = '<Button /> and <Badge label={"hello"} />'
+        result = transform.call(source)
+        expect(result).to match(/__rsc_component__\("Button"/)
+        expect(result).to match(/__rsc_component__\("Badge"/)
+        expect(result).to match(/"hello"/)
+      end
+    end
+
+    describe "mixed content" do
+      it "preserves surrounding HTML while transforming components" do
+        source = <<~ERB
+          <div class="container">
+            <h1>Hello</h1>
+            <LikeButton postId={1} />
+          </div>
+        ERB
+        result = transform.call(source)
+        expect(result).to match(/<div class="container">/)
+        expect(result).to match(%r{<h1>Hello</h1>})
+        expect(result).to match(/__rsc_component__\("LikeButton"/)
+      end
+    end
+  end
+end

data/spec/ruact/errors_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Ruact
+  RSpec.describe "Error classes" do
+    describe "Ruact::Error" do
+      it "is a subclass of StandardError" do
+        expect(Error.ancestors).to include(StandardError)
+      end
+    end
+
+    describe "Ruact::ManifestError" do
+      it "is a subclass of Ruact::Error" do
+        expect(ManifestError.ancestors).to include(Error)
+      end
+
+      it "can be raised and rescued as Ruact::Error" do
+        expect { raise ManifestError, "test" }.to raise_error(Error)
+      end
+    end
+
+    describe "Ruact::SerializationError" do
+      it "is a subclass of Ruact::Error" do
+        expect(SerializationError.ancestors).to include(Error)
+      end
+
+      it "can be raised and rescued as Ruact::Error" do
+        expect { raise SerializationError, "test" }.to raise_error(Error)
+      end
+    end
+
+    describe "Ruact::PreprocessorError" do
+      it "is a subclass of Ruact::Error" do
+        expect(PreprocessorError.ancestors).to include(Error)
+      end
+
+      it "can be raised and rescued as Ruact::Error" do
+        expect { raise PreprocessorError, "test" }.to raise_error(Error)
+      end
+    end
+  end
+end