ruact 0.0.12 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a8e7c8ef2e275bb38c837671dca78c5c2278378e95131e8e25b2f9edbb99339
-  data.tar.gz: ab0713c0bcc7effd8d77bb6f961bcda55e8a233e124fd0669bc1133642632687
+  metadata.gz: '048ef204d79fa3c03ff9ab08c43e5d9d1fc1f42c0e92c7cf7311b510bc879b0a'
+  data.tar.gz: 67fdef7b25ac3ac2ea552eed361a45a62710bf28145ae7892d0e1f46f462aa47
 SHA512:
-  metadata.gz: e301dbf4d7ee972f71d16beae5f972289542ecbedc353389dcbe6afe24b50f2393baf0445ebd152ef4da1114272a0a906805beb10921afe7944a318758ed38d6
-  data.tar.gz: b69d9e0420b5b1dd7676bfc9870592efaee6438ce6ad944c4fda0d8e3173910e9c1ac6c8165d86bed6791153f801e6b990c194c422b62e3218e6716d200f0ee4
+  metadata.gz: cd6d63eaaa47a7cde090700c44ba53fe8cf9b29d82cc05ce2f672b98b01dd83dd82cb046b109cd47a328594344b1950f21d75fee5338870a0df5be438e86843e
+  data.tar.gz: 44b2880d6879617b00adc9a8ae070a1f722e147a782592c4b527e98dbe9af42d925f45c68daca3272df28a95c7a0c89d762164bf205c9da2dbf195e142e8e88d

data/CHANGELOG.md

@@ -7,6 +7,62 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.14] - 2026-10-02
+
+### Fixed
+
+- **Scaffolding a second resource stopped the app from booting.** Every `rails generate ruact:scaffold` wrote a query with a method named `search`. Query names share one namespace: each name gets one `GET /q/<name>` route and one export of `@/.ruact/server-functions`. So the second resource drew `ruact_query_search` again, and Rails refused to load the routes with "Invalid route name, already in use: 'ruact_query_search'", a route the app never wrote. The scaffold now names the method after the resource: `PostsQuery#search_posts`, served at `GET /q/searchPosts` and imported as `searchPosts`. Two query classes that define the same method — or one query class mounted twice — now raise `Ruact::ConfigurationError` naming the query, the path and the fix. The new name can meet one thing the bare `search` could not: a custom collection action named `search` on the same controller (`post :search, on: :collection`) also derives `searchPosts`, and boot stops with ruact's name-collision error, which points to `ruact_function_name` to rename one. Apps scaffolded before this release keep their `search` and work as they are. The first scaffold of a *new* resource in such an app no longer collides with it.
+
+- **`rails generate ruact:install --shadcn` on an app that already had ruact installed left Tailwind out, then said the setup was in place.** That is the order Getting Started gives: install ruact first, add shadcn later. On the second run `package.json` and `Procfile.dev` already existed, so the generator skipped both. Tailwind was never declared and the `css` process was never added. `npx shadcn@latest init` then stopped with "No Tailwind CSS configuration found", right after the generator had printed that the prerequisites were in place. Under `--shadcn` the generator now adds what is missing to both files: the Tailwind `devDependencies` and the `build:css` script in `package.json`, the `css` process in `Procfile.dev`. It keeps every version and script you already declare; `package.json` is rewritten as 2-space JSON when something is added. When it cannot complete the setup, it says the setup is not in place and names what to do: a `package.json` it cannot parse, a Tailwind older than 4, or a `Procfile.dev` that already runs a `css` process or another Tailwind watcher — such as tailwindcss-rails' `bin/rails tailwindcss:watch`, which compiles its own entry rather than the `globals.css` shadcn writes its theme into. Without `--force`, `rails destroy ruact:install --shadcn` leaves an existing `package.json` in place.
+
+- **Under `--shadcn`, `bin/dev` stopped as soon as it started when no terminal was attached.** The `css` process ran `@tailwindcss/cli --watch`, which stops watching and exits 0 when its input closes. Foreman then stops Rails and Vite as well. A coding agent, CI, Docker or an IDE task runner starts `bin/dev` without a terminal, so the app was gone before its first request, with no error in the output. The process now runs with `--watch=always`. To fix an app generated before this release, change `--watch` to `--watch=always` on the `css:` line of `Procfile.dev`.
+
+- **The `ruact:scaffold --shadcn` pre-flight printed `npx shadcn@latest init` without `--base radix`.** The current shadcn defaults to Base UI, but the components the scaffold generates import Radix. An app set up from that message got components whose imports do not resolve. The message now prints `--base radix`, as the install generator already did.
+
+- **Two generator messages linked to pages that do not exist.** The unknown-attribute-type error and the shadcn version warning pointed at a documentation path inside this repository, where no such file exists. They now link to ruact.dev.
+
+### Changed
+
+- **The scaffold's list prop is named after the resource.** `<CommentList posts={rows} />` was a leftover from the reference app the templates came from, and every resource got a `posts` prop. It is now `<CommentList comments={rows} />`, `<BlogPostList blogPosts={rows} />`, and so on. Inside the component the prop is bound to a fixed local, so a model whose plural is one of the List's own names (`Row`) or one a module cannot declare (`Argument`) still compiles. A `Post` scaffold's view is unchanged.
+
+- **shadcn 4 is in the default `shadcn_compatible_versions`** (now `[1, 2, 4]`). It is the current major, so every app that followed the setup steps saw `ruact:scaffold --shadcn` warn that its shadcn was not tested. shadcn 4 was run end to end with this release: `init --base radix`, the full `add` list, `ruact:scaffold --shadcn`, and the form, table and delete dialog checked in a browser.
+
+## [0.0.13] - 2026-09-27
+
+### Added
+
+- **A development warning when a Turbo form gets a ruact page back.** A form on a Turbo page that posts to a ruact action is fetched by Turbo; Turbo does not show the ruact page that answers (a `422` with validation errors, say): it reloads the form's page, drops the answer or pastes the document into its own, depending on the status. In development and test ruact now logs a `[ruact]` warning naming the action, the request and the fix: `data-turbo="false"` on that form, so the browser submits it and shows the answer.
+
+### Fixed
+
+- **`render :new, status: :unprocessable_entity` answered 500 on a ruact page.** The Rails idiom for a failed save rendered the template outside ruact, and its first client component raised `__ruact_component__ called outside a ruact_render flow`, with no hint of the fix. A `render` whose template is a ruact page of the same controller — `render :new`, `render "new"`, `render action:`, `render template: "posts/new"` — now goes through ruact, with its `status:`, `locals:`, `location:`, `variant:`, `locale:` and `assigns:` — when that `.html.erb` (or a locale/variant of it) is the template Rails would pick for the request, so a `.json` URL or a `format.json` branch still renders the JSON template. Every other `render` (other renderers, another folder's template, an action outside `ruact_pages`, an option ruact does not take such as wicked_pdf's `pdf:` or a stray `alert:`) is Rails' own, as before — and when that leaves a client component outside ruact, the error names the option. `ruact_render` takes `status:` too. A client component in a template Rails renders on its own now raises an error naming the component, the template and the call that renders it through ruact. The client router renders a Flight `422` in place — the errors are the page, not a failed request — and keeps the form's URL; any other failing status is still an error.
+
+- **`respond_with` (the `responders` gem, Devise's controllers) raised `NoMethodError: private method 'redirect_to'` in a controller with `Ruact::Controller`.** ruact's `redirect_to` override was private, and `responders` calls `controller.redirect_to` from outside. It is public now, as Rails' own is — and so is the new `render` override.
+
+- **A server-function call's validation errors were lost on `redirect_to`.** An action called from React that registers `ruact_errors(@post)` and then `redirect_to`s answers `{"$redirect": …}`; the page the runtime navigated to was documented to receive those errors, and never did, in any include order. They now ride the flash to it (a same-origin redirect; a redirect to another origin carries none).
+
+- **Clicking from a ruact page to an ordinary Rails page did nothing.** The ruact router intercepts every same-origin link and asked for a ruact response; an ordinary Rails action answered with HTML the router could not render, so the click went nowhere — no page, no URL change, no error. Now the server tells the router, before running anything, when a route is not a ruact page, and the browser loads it normally. A form that posts to such a page is submitted by the browser the same way, so the action runs once and its response — a validation error included — is what you see. `Ruact::NavigationBoundary::Middleware` does this; remove it with `config.middleware.delete Ruact::NavigationBoundary::Middleware` if you need to.
+
+- **Turbo and ruact stopped trampling each other.** After one round trip between a Turbo page and a ruact page, Turbo's links could go dead, a ruact page could render blank, or the address bar could show one page while the screen showed another. Every page ruact renders now carries `<meta name="turbo-visit-control" content="reload">`, so Turbo loads it in full instead of swapping it into its own document, and each document keeps its own router. It also carries `<meta name="turbo-prefetch" content="false">`: in a layout that loads Turbo 8, hovering a link on a ruact page no longer makes Turbo fetch — and run — the destination for a click it will never handle.
+
+- **Styling from an npm component worked in development and disappeared in production.** A `"use client"` component that imports CSS — its own, or one a package ships, like a date picker's — produces a separate stylesheet that Vite builds, digest-stamps and serves. Nothing linked it. The page came back with the script tag and no `<link>`, so the component rendered unstyled: in the case that surfaced this ([#63](https://github.com/luizcg/ruact/issues/63)), a date picker collapsed into a column of overlapping numbers. Development hid it completely, because the Vite dev server injects that CSS through JavaScript.
+
+  A new `<head>` helper, `ruact_head_assets`, links those stylesheets — above your own, so your CSS loads last and wins ties. It emits nothing while the Vite dev server is running. The layout ruact now ships calls it for you, and so does the built-in shell (`config.layout = false`), which still carries none of *your* stylesheets. `rails ruact:doctor` fails when a build emits component CSS that the layout rendering your pages never links, and names that layout.
+
+- **The generated `--shadcn` `tsconfig.json` had no types for a CSS import.** A client component importing a stylesheet for its side effect had nothing to resolve against. It now declares `vite/client`. If you keep your own `tsconfig.json`, add `"types": ["vite/client"]` to it.
+
+### Changed
+
+- **Installing ruact no longer turns your whole app into ruact pages.** `rails generate ruact:install` used to add `include Ruact::Controller` to `ApplicationController`, and from then on every action with an `.html.erb` rendered through ruact — install it into an existing app to try one screen and the other eighty were converted too, Turbo Frames included. Now the install changes no controller: a page renders through ruact when its controller has `include Ruact::Controller`, and `ruact_pages only: %i[show]` (or `except:`) narrows that to some actions — an action declared there counts even when it renders another action's template. The navigation boundary reads the same declaration, so a form posting to an action left out of `ruact_pages` is submitted by the browser like any Rails form — and it is plain Rails in how it shows validation errors, too. A name in `ruact_pages only:` that is neither a method nor a template of the controller declaring it raises `Ruact::ConfigurationError` — a typo does not quietly make a page plain Rails. `rails generate ruact:scaffold` adds the include to the controllers it generates.
+
+  To make every page a ruact page, as before, run `rails generate ruact:install --app`: it puts the include on `ApplicationController` and renders through your own layout. **Apps already installed keep their include** — re-running the install says the app is in whole-app mode and how to leave it, and removes nothing. `rails ruact:doctor` now reports which mode the app is in, and in whole-app mode how many templates render through ruact.
+
+- **New installs render ruact pages through a layout the gem ships, and no longer edit yours.** `rails generate ruact:install` used to write the React root and `ruact_js_assets` into `app/views/layouts/application.html.erb`. It now writes `config.layout = "ruact"`: ruact pages render through `layouts/ruact`, which comes with the gem and links CSRF, CSP, your client components' CSS and then the stylesheets you name in the new `config.layout_stylesheets` (`[:app]` under Propshaft 0.9+; the install writes `["application"]` on Sprockets or an older Propshaft, and `[]` with neither). Your layouts are not touched.
+
+  Because it is a named layout, it applies to every ruact page whatever a controller declares with `layout` (`layout false` included), and its `<title>` is your app's name on every page. What that layout does **not** bring is the rest of your own layout's `<head>` — favicons, fonts, analytics, meta tags other gems write — or your app's JavaScript. If a ruact page needs those, `rails generate ruact:layout` copies the layout into `app/views/layouts/ruact.html.erb`, where it is yours to change and wins over the gem's with no setting. Or set `config.layout = true` to keep rendering through your own layout, as before.
+
+  **Existing installs are not changed**: re-running the install leaves a `config.layout` you already have alone. On an app that renders through its own layout, the install now prints any of the three lines that layout is missing — `ruact_head_assets` is the new one — instead of writing them.
+
 ## [0.0.12] - 2026-09-09
 
 ### Added
@@ -320,7 +376,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **CI matrix** — GitHub Actions: RSpec across Ruby 3.2 × 3.3 × Rails 7.0 × 7.1 × 7.2 × 8.0; RuboCop; YARD docs; memory benchmark; E2E system tests against React 19.0.0 and 19.x (Capybara + Cuprite); non-blocking React@next job with auto-issue on failure.
 - **E2E test app** — `e2e/` Rails app (no DB, in-memory Post model) with full CRUD system tests validating the complete request cycle.
 
-[Unreleased]: https://github.com/luizcg/ruact/compare/v0.0.12...HEAD
+[Unreleased]: https://github.com/luizcg/ruact/compare/v0.0.14...HEAD
+[0.0.14]: https://github.com/luizcg/ruact/releases/tag/v0.0.14
+[0.0.13]: https://github.com/luizcg/ruact/releases/tag/v0.0.13
 [0.0.12]: https://github.com/luizcg/ruact/releases/tag/v0.0.12
 [0.0.11]: https://github.com/luizcg/ruact/releases/tag/v0.0.11
 [0.0.10]: https://github.com/luizcg/ruact/releases/tag/v0.0.10

data/README.md

@@ -22,14 +22,14 @@ rails new myapp --skip-javascript && cd myapp
 # 2. Add the gem
 bundle add ruact
 
-# 3. Write the config, the layout wiring and an AGENTS.md — then run npm install
+# 3. Write the config and an AGENTS.md (no layout of yours is edited) — then run npm install
 rails generate ruact:install
 
 # 4. Rails + Vite, one command
 bin/dev
 ```
 
-That is the whole install. The [Getting Started guide](https://ruact.dev/docs/getting-started) picks it up from here — first component, first scaffold, `ruact:doctor`. Already have an app? Start at step 2, then read [Progressive migration](https://ruact.dev/docs/guides/progressive-migration) — ruact renders one action at a time and leaves the rest of your views alone.
+That is the whole install. The [Getting Started guide](https://ruact.dev/docs/getting-started) picks it up from here — first component, first scaffold, `ruact:doctor`. Already have an app? Start at step 2, then read [Progressive migration](https://ruact.dev/docs/guides/progressive-migration) — ruact renders only the controllers you include it in and leaves the rest of your views alone.
 
 ## How it works
 
@@ -98,7 +98,7 @@ Every item below is shipped in this gem at v0.0.11:
 - **Signed record references** — `Ruact.signed_global_id(record, for:, expires_in:)` out, `Ruact.locate_signed(token, for:)` back in; a tampered token is a `400`, not a lookup. [Docs](https://ruact.dev/docs/api/server-actions)
 - **Client-side navigation** — link interception, scroll restoration and redirect-after-POST, derived from your Rails routes. [Docs](https://ruact.dev/docs/concepts/navigation)
 - **A CRUD generator** — `rails generate ruact:scaffold Post title:string body:text` delegates the model, migration and route to Rails' own `resource` generator, then adds the ruact layer. Plain semantic HTML by default; `--shadcn` opts into the Tailwind/shadcn path. It does not run migrations — `rails db:migrate` is still yours. [Docs](https://ruact.dev/docs/api/scaffold)
-- **`bin/rails ruact:doctor`** — eight checks over the manifest, Vite, the layout and streaming; exits `1` when one fails. [Docs](https://ruact.dev/docs/api/ruact-doctor)
+- **`bin/rails ruact:doctor`** — nine checks over the manifest, Vite, the layout, the client-component CSS and streaming; exits `1` when one fails. [Docs](https://ruact.dev/docs/api/ruact-doctor)
 - **One runtime dependency** — `nokogiri`. Rails itself is not a declared dependency of this gem.
 
 ## AI tools and coding agents
@@ -136,7 +136,7 @@ Everything lives at [ruact.dev](https://ruact.dev):
 - [Getting Started](https://ruact.dev/docs/getting-started) — from `rails new` to a rendered component
 - [Why ruact?](https://ruact.dev/docs/why-ruact) — where it sits next to Hotwire and Inertia
 - [Server functions & queries](https://ruact.dev/docs/api/server-actions) — the full request/response contract
-- [Progressive migration](https://ruact.dev/docs/guides/progressive-migration) — adopting it one action at a time
+- [Progressive migration](https://ruact.dev/docs/guides/progressive-migration) — adopting it one controller at a time
 - [Testing](https://ruact.dev/docs/guides/testing) — render assertions on the server side
 - [Changelog](CHANGELOG.md) — also published at [ruact.dev/docs/changelog](https://ruact.dev/docs/changelog)