ruact 0.0.1

data/spec/ruact/html_converter_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Ruact
+  RSpec.describe HtmlConverter do
+    subject(:convert) { ->(html, registry = []) { described_class.convert(html, registry) } }
+
+    describe "text nodes" do
+      it "returns a plain string for plain text" do
+        expect(convert.call("hello")).to eq("hello")
+      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>')
+        expect(result).to be_a(Flight::ReactElement)
+        expect(result.type).to eq("div")
+        expect(result.props["className"]).to eq("box")
+        expect(result.props["children"]).to eq("hi")
+      end
+
+      it "converts `for` attribute to `htmlFor`" do
+        result = convert.call('<label for="email">Email</label>')
+        expect(result.props.keys).to include("htmlFor")
+        expect(result.props["htmlFor"]).to eq("email")
+      end
+
+      it "extracts `data-react-key` into the element key and removes it from props" do
+        result = convert.call('<article data-react-key="post-1">body</article>')
+        expect(result.key).to eq("post-1")
+        expect(result.props).not_to have_key("data-react-key")
+      end
+    end
+
+    describe "nested elements" do
+      it "produces a child ReactElement for a nested element" do
+        result = convert.call("<div><span>hello</span></div>")
+        expect(result.type).to eq("div")
+        child = result.props["children"]
+        expect(child).to be_a(Flight::ReactElement)
+        expect(child.type).to eq("span")
+      end
+
+      it "produces an array of children for multiple child elements" do
+        result = convert.call("<ul><li>a</li><li>b</li></ul>")
+        children = result.props["children"]
+        expect(children).to be_an(Array)
+        expect(children.length).to eq(2)
+        expect(children[0].type).to eq("li")
+        expect(children[1].type).to eq("li")
+      end
+    end
+
+    describe "fragment (multiple root elements)" do
+      it "returns an array for multiple sibling root elements" do
+        result = convert.call("<p>one</p><p>two</p>")
+        expect(result).to be_an(Array)
+        expect(result.length).to eq(2)
+      end
+    end
+
+    describe "client component via registry" do
+      it "replaces RSC comment placeholder with the registered ReactElement" do
+        ref      = Flight::ClientReference.new(module_id: "./LikeButton", export_name: "LikeButton")
+        registry = [{ token: "__RSC_0__", name: "LikeButton", ref: ref, props: { "postId" => 1 } }]
+        result   = convert.call("<!-- __RSC_0__ -->", registry)
+
+        expect(result).to be_a(Flight::ReactElement)
+        expect(result.type).to eq(ref)
+        expect(result.props).to eq({ "postId" => 1 })
+      end
+
+      it "wraps a client component inside a parent DOM element" do
+        ref      = Flight::ClientReference.new(module_id: "./Button", export_name: "Button")
+        registry = [{ token: "__RSC_0__", name: "Button", ref: ref, props: {} }]
+        result   = convert.call('<div class="wrapper"><!-- __RSC_0__ --></div>', registry)
+
+        expect(result.type).to eq("div")
+        child = result.props["children"]
+        expect(child).to be_a(Flight::ReactElement)
+        expect(child.type).to eq(ref)
+      end
+    end
+
+    describe "form element value handling" do
+      it "converts text input value to defaultValue (uncontrolled)" do
+        result = convert.call('<input type="text" value="hello" />')
+        expect(result.props).to have_key("defaultValue")
+        expect(result.props["defaultValue"]).to eq("hello")
+        expect(result.props).not_to have_key("value")
+      end
+
+      it "preserves value on submit inputs (controlled is correct for buttons)" do
+        result = convert.call('<input type="submit" value="Save" />')
+        expect(result.props).to have_key("value")
+        expect(result.props["value"]).to eq("Save")
+        expect(result.props).not_to have_key("defaultValue")
+      end
+
+      it "preserves value on reset inputs" do
+        result = convert.call('<input type="reset" value="Clear" />')
+        expect(result.props["value"]).to eq("Clear")
+        expect(result.props).not_to have_key("defaultValue")
+      end
+
+      it "converts textarea value to defaultValue" do
+        result = convert.call('<textarea value="content">content</textarea>')
+        expect(result.props["defaultValue"]).to eq("content")
+        expect(result.props).not_to have_key("value")
+      end
+
+      it "converts select value to defaultValue" do
+        result = convert.call('<select value="b"><option value="a">A</option><option value="b">B</option></select>')
+        expect(result.props["defaultValue"]).to eq("b")
+        expect(result.props).not_to have_key("value")
+      end
+
+      it "converts checked attribute to defaultChecked" do
+        result = convert.call('<input type="checkbox" checked="checked" />')
+        expect(result.props).to have_key("defaultChecked")
+        expect(result.props["defaultChecked"]).to eq("checked")
+        expect(result.props).not_to have_key("checked")
+      end
+    end
+
+    describe "style attribute" do
+      it "converts a CSS string to a camelCase hash" do
+        result = convert.call('<h1 style="font-size:28px;font-weight:700;margin-bottom:24px">Title</h1>')
+        expect(result.props["style"]).to eq({
+                                              "fontSize" => "28px",
+                                              "fontWeight" => "700",
+                                              "marginBottom" => "24px"
+                                            })
+      end
+
+      it "handles multi-word property values without splitting" do
+        result = convert.call('<div style="max-width:640px;margin:40px auto">x</div>')
+        expect(result.props["style"]).to eq({
+                                              "maxWidth" => "640px",
+                                              "margin" => "40px auto"
+                                            })
+      end
+    end
+  end
+end

data/spec/ruact/install_generator_spec.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+require "fileutils"
+require "ruact"
+
+RSpec.describe Ruact do # rubocop:disable RSpec/SpecFilePathFormat
+  describe ".vite_plugin_path" do
+    it "returns a string" do
+      expect(described_class.vite_plugin_path).to be_a(String)
+    end
+
+    it "points to an existing file (NFR15 — bundled plugin present in gem)" do
+      expect(File.exist?(described_class.vite_plugin_path)).to be true
+    end
+
+    it "points to the vite-plugin-ruact index.js" do
+      expect(described_class.vite_plugin_path).to end_with("vite-plugin-ruact/index.js")
+    end
+
+    it "contains the plugin export function" do
+      content = File.read(described_class.vite_plugin_path)
+      expect(content).to include("export default function ruact")
+    end
+  end
+
+  describe ".configure / .config" do
+    after { described_class.instance_variable_set(:@config, nil) }
+
+    it "returns a Configuration instance" do
+      expect(described_class.config).to be_a(Ruact::Configuration)
+    end
+
+    it "yields config to configure block" do
+      described_class.configure { |c| c.suspense_timeout = 10.0 }
+      expect(described_class.config.suspense_timeout).to eq(10.0)
+    end
+
+    it "returns the same instance on repeated calls (singleton)" do
+      first  = described_class.config
+      second = described_class.config
+      expect(first).to be(second)
+    end
+
+    it "has sensible defaults" do
+      config = described_class.config
+      expect(config.manifest_path).to be_nil
+      expect(config.strict_serialization).to be false
+      expect(config.suspense_timeout).to eq(5.0)
+      expect(config.vite_dev_server).to eq("http://localhost:5173")
+    end
+  end
+
+  describe "generator action helpers" do
+    # These tests exercise the core file-manipulation logic extracted from the generator
+    # using plain Ruby + tmpdir — no Rails::Generators infrastructure required.
+
+    let(:tmpdir) { Dir.mktmpdir("ruact_generator_spec") }
+
+    after { FileUtils.rm_rf(tmpdir) }
+
+    def write_file(relative_path, content)
+      full = File.join(tmpdir, relative_path)
+      FileUtils.mkdir_p(File.dirname(full))
+      File.write(full, content)
+      full
+    end
+
+    def read_file(relative_path)
+      File.read(File.join(tmpdir, relative_path))
+    end
+
+    # Reproduces inject_controller_concern logic from the generator
+    def inject_controller_concern(dest_root)
+      controller_file = File.join(dest_root, "app/controllers/application_controller.rb")
+      return :missing unless File.exist?(controller_file)
+
+      content = File.read(controller_file)
+      return :already_present if content.include?("Ruact::Controller")
+
+      modified = content.sub(
+        /^(class ApplicationController.*)\n/,
+        "\\1\n  include Ruact::Controller\n"
+      )
+      File.write(controller_file, modified)
+      :injected
+    end
+
+    # Reproduces inject_layout_shell logic from the generator
+    def inject_layout_shell(dest_root)
+      layout_file = File.join(dest_root, "app/views/layouts/application.html.erb")
+      return :missing unless File.exist?(layout_file)
+
+      content = File.read(layout_file)
+      return :already_present if content.include?("ruact: root")
+
+      modified = content.sub(
+        "  </body>",
+        "    <%# ruact: root %>\n    <div id=\"root\"></div>\n  </body>"
+      )
+      File.write(layout_file, modified)
+      :injected
+    end
+
+    describe "ApplicationController injection (AC#1, AC#3)" do
+      let(:controller_content) do
+        "class ApplicationController < ActionController::Base\nend\n"
+      end
+
+      it "injects include Ruact::Controller after the class declaration" do
+        write_file("app/controllers/application_controller.rb", controller_content)
+        result = inject_controller_concern(tmpdir)
+
+        expect(result).to eq(:injected)
+        content = read_file("app/controllers/application_controller.rb")
+        expect(content).to include("include Ruact::Controller")
+      end
+
+      it "returns :already_present on second run (idempotent, AC#3)" do
+        write_file("app/controllers/application_controller.rb",
+                   "class ApplicationController < ActionController::Base\n  include Ruact::Controller\nend\n")
+
+        result = inject_controller_concern(tmpdir)
+        expect(result).to eq(:already_present)
+      end
+
+      it "does not duplicate the include when run twice (AC#3)" do
+        write_file("app/controllers/application_controller.rb", controller_content)
+        inject_controller_concern(tmpdir)
+        inject_controller_concern(tmpdir)
+
+        content = read_file("app/controllers/application_controller.rb")
+        occurrences = content.scan("Ruact::Controller").size
+        expect(occurrences).to eq(1)
+      end
+    end
+
+    describe "Layout injection (AC#1, AC#3)" do
+      let(:layout_content) do
+        <<~HTML
+          <!DOCTYPE html>
+          <html>
+            <body>
+              <%= yield %>
+            </body>
+          </html>
+        HTML
+      end
+
+      it "injects the RSC root div before </body>" do
+        write_file("app/views/layouts/application.html.erb", layout_content)
+        result = inject_layout_shell(tmpdir)
+
+        expect(result).to eq(:injected)
+        content = read_file("app/views/layouts/application.html.erb")
+        expect(content).to include('<div id="root"></div>')
+        expect(content).to include("ruact: root")
+      end
+
+      it "returns :already_present on second run (idempotent, AC#3)" do
+        content_with_marker = layout_content.sub(
+          "  </body>",
+          "    <%# ruact: root %>\n    <div id=\"root\"></div>\n  </body>"
+        )
+        write_file("app/views/layouts/application.html.erb", content_with_marker)
+
+        result = inject_layout_shell(tmpdir)
+        expect(result).to eq(:already_present)
+      end
+
+      it "does not duplicate the root div when run twice (AC#3)" do
+        write_file("app/views/layouts/application.html.erb", layout_content)
+        inject_layout_shell(tmpdir)
+        inject_layout_shell(tmpdir)
+
+        content = read_file("app/views/layouts/application.html.erb")
+        occurrences = content.scan('<div id="root">').size
+        expect(occurrences).to eq(1)
+      end
+
+      it "places the root div before the closing </body> tag" do
+        write_file("app/views/layouts/application.html.erb", layout_content)
+        inject_layout_shell(tmpdir)
+
+        content = read_file("app/views/layouts/application.html.erb")
+        root_pos  = content.index('<div id="root">')
+        body_pos  = content.index("</body>")
+        expect(root_pos).to be < body_pos
+      end
+    end
+
+    describe "vite.config.js template (AC#2)" do
+      let(:template_path) do
+        File.expand_path(
+          "../../lib/generators/ruact/install/templates/vite.config.js.tt",
+          __dir__
+        )
+      end
+
+      it "references Ruact.vite_plugin_path in the generated content" do
+        expect(File.read(template_path)).to include("Ruact.vite_plugin_path")
+      end
+
+      it "does not reference a hardcoded npm package name" do
+        content = File.read(template_path)
+        expect(content).not_to include("from 'vite-plugin-ruact'")
+        expect(content).not_to include('from "vite-plugin-ruact"')
+      end
+    end
+  end
+end

data/spec/ruact/railtie_spec.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "pathname"
+require "logger"
+require "socket"
+
+# The Rails stub is provided by spec/support/rails_stub.rb.
+# We explicitly require the railtie here (was skipped in ruact.rb because
+# Rails was not defined when that file loaded).
+require "ruact/railtie"
+
+RSpec.describe Ruact::Railtie do
+  let(:missing_path) { Pathname.new("/nonexistent/path/react-client-manifest.json") }
+  let(:fake_logger) { instance_double(Logger, warn: nil, info: nil) }
+
+  before do
+    Rails.logger = fake_logger
+  end
+
+  describe ".detect_streaming_mode! (AC#1–3)" do
+    after { Ruact.streaming_mode = nil }
+
+    context "when Puma is defined" do
+      before do
+        puma = Module.new { const_set(:Server, Class.new) }
+        stub_const("Puma", puma)
+      end
+
+      it "sets streaming_mode to :enabled" do
+        described_class.detect_streaming_mode!
+        expect(Ruact.streaming_mode).to eq(:enabled)
+      end
+
+      it "logs streaming: enabled (Puma detected)" do
+        described_class.detect_streaming_mode!
+        expect(fake_logger).to have_received(:info)
+          .with(a_string_including("streaming: enabled (Puma detected)"))
+      end
+    end
+
+    context "when Unicorn is defined" do
+      before { stub_const("Unicorn", Module.new) }
+
+      it "sets streaming_mode to :buffered" do
+        described_class.detect_streaming_mode!
+        expect(Ruact.streaming_mode).to eq(:buffered)
+      end
+
+      it "logs streaming: buffered (Unicorn detected)" do
+        described_class.detect_streaming_mode!
+        expect(fake_logger).to have_received(:info)
+          .with(a_string_including("streaming: buffered (Unicorn detected)"))
+      end
+    end
+
+    context "when PhusionPassenger is defined" do
+      before { stub_const("PhusionPassenger", Module.new) }
+
+      it "sets streaming_mode to :buffered" do
+        described_class.detect_streaming_mode!
+        expect(Ruact.streaming_mode).to eq(:buffered)
+      end
+
+      it "logs streaming: buffered (Passenger detected)" do
+        described_class.detect_streaming_mode!
+        expect(fake_logger).to have_received(:info)
+          .with(a_string_including("streaming: buffered (Passenger detected)"))
+      end
+    end
+
+    context "when no recognized server constant is defined" do
+      it "sets streaming_mode to :buffered" do
+        described_class.detect_streaming_mode!
+        expect(Ruact.streaming_mode).to eq(:buffered)
+      end
+
+      it "logs server unknown — defaulting to safe mode" do
+        described_class.detect_streaming_mode!
+        expect(fake_logger).to have_received(:info)
+          .with(a_string_including("server unknown — defaulting to safe mode"))
+      end
+    end
+  end
+
+  describe ".check_manifest!" do
+    context "with missing manifest in development (AC#5, #7)" do
+      before do
+        Rails.env = ActiveSupport::StringInquirer.new("development")
+      end
+
+      it "does not raise" do
+        expect { described_class.check_manifest!(missing_path) }.not_to raise_error
+      end
+
+      it "logs a [ruact] prefixed warning" do
+        described_class.check_manifest!(missing_path)
+        expect(fake_logger).to have_received(:warn)
+          .with(a_string_starting_with("[ruact]"))
+      end
+
+      it "includes the manifest path in the warning" do
+        described_class.check_manifest!(missing_path)
+        expect(fake_logger).to have_received(:warn)
+          .with(a_string_including(missing_path.to_s))
+      end
+    end
+
+    context "with missing manifest in production (AC#6)" do
+      before do
+        Rails.env = ActiveSupport::StringInquirer.new("production")
+      end
+
+      it "raises ManifestError" do
+        expect { described_class.check_manifest!(missing_path) }
+          .to raise_error(Ruact::ManifestError)
+      end
+
+      it "error message contains 'run vite build before deploying'" do
+        expect { described_class.check_manifest!(missing_path) }
+          .to raise_error(Ruact::ManifestError, /run vite build before deploying/)
+      end
+    end
+  end
+
+  describe ".check_vite!" do
+    context "when Vite is running (AC#4)" do
+      before do
+        allow(TCPSocket).to receive(:new).and_return(instance_double(TCPSocket, close: nil))
+      end
+
+      it "does not log a warning" do
+        described_class.check_vite!
+        expect(fake_logger).not_to have_received(:warn)
+      end
+    end
+
+    context "when Vite is not running (AC#4)" do
+      before do
+        allow(TCPSocket).to receive(:new).and_raise(Errno::ECONNREFUSED)
+      end
+
+      it "logs a [ruact] prefixed warning" do
+        described_class.check_vite!
+        expect(fake_logger).to have_received(:warn)
+          .with(a_string_starting_with("[ruact]"))
+      end
+
+      it "mentions Vite and port 5173" do
+        described_class.check_vite!
+        expect(fake_logger).to have_received(:warn)
+          .with(a_string_including("localhost:5173"))
+      end
+    end
+  end
+end