ruact 0.0.4 → 0.0.6

data/lib/generators/ruact/install/install_generator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pathname"
 require "rails/generators"
 require "ruact"
 
@@ -13,23 +14,45 @@ module Ruact
     # 3. Injects the React root div into app/views/layouts/application.html.erb
     # 4. Creates app/javascript/components/.keep
     # 5. Creates vite.config.js (or shows manual instructions if one exists)
-    # 6. Creates app/javascript/application.jsx (or skips if one exists)
+    # 6. Creates package.json (react/react-dom/vite/@vitejs/plugin-react) so a
+    #    fresh app has JS deps to install (Story 14.6, FR101).
+    # 7. Creates Procfile.dev + bin/dev (foreman) so the single `bin/dev`
+    #    command boots BOTH Rails and the Vite dev server (Story 14.6, Epic 14
+    #    DoD — a ruact app needs both processes).
+    # 8. Runs `npm install` so JavaScript dependencies are ready (FR101);
+    #    skippable via --skip-npm.
+    #
+    # Story 14.2 (FR104) — the generator no longer writes a bootstrap entry into
+    # the user's tree. ruact's React entry is served as the virtual module
+    # `virtual:ruact/bootstrap` by the bundled Vite plugin (the generated
+    # `vite.config` input points at it), so a fresh install leaves
+    # `app/javascript/` with only the user's `components/` (plus the gitignored,
+    # typed `.ruact/server-functions.ts`).
     #
     # Run: rails generate ruact:install
-    class InstallGenerator < Rails::Generators::Base
+    class InstallGenerator < Rails::Generators::Base # rubocop:disable Metrics/ClassLength
       source_root File.expand_path("templates", __dir__)
 
       desc "Installs ruact into the current Rails application"
 
+      # Story 14.1 (FR101) — one-command install. By default the generator
+      # runs `npm install` after writing every file so a fresh app is runnable
+      # straight away. `--skip-npm` opts out (CI, or a non-npm package manager —
+      # run the manager's install manually, then `bin/dev`).
+      class_option :skip_npm,
+                   type: :boolean,
+                   default: false,
+                   desc: "Skip running npm install (for CI or non-npm package managers)"
+
       def create_initializer
         template "initializer.rb.tt", "config/initializers/ruact.rb"
       end
 
       def inject_controller_concern
         controller_file = "app/controllers/application_controller.rb"
-        return unless File.exist?(destination_root.join(controller_file))
+        return unless File.exist?(Pathname(destination_root).join(controller_file))
 
-        content = File.read(destination_root.join(controller_file))
+        content = File.read(Pathname(destination_root).join(controller_file))
         if content.include?("Ruact::Controller")
           say_status "skip", "Ruact::Controller already included in ApplicationController", :yellow
           return
@@ -42,9 +65,9 @@ module Ruact
 
       def inject_layout_shell
         layout_file = "app/views/layouts/application.html.erb"
-        return unless File.exist?(destination_root.join(layout_file))
+        return unless File.exist?(Pathname(destination_root).join(layout_file))
 
-        content = File.read(destination_root.join(layout_file))
+        content = File.read(Pathname(destination_root).join(layout_file))
         if content.include?("ruact: root")
           say_status "skip", "Rails RSC root already present in layout", :yellow
           return
@@ -58,7 +81,7 @@ module Ruact
       def create_components_directory
         empty_directory "app/javascript/components"
         create_file "app/javascript/components/.keep" unless
-          File.exist?(destination_root.join("app/javascript/components/.keep"))
+          File.exist?(Pathname(destination_root).join("app/javascript/components/.keep"))
       end
 
       # Story 8.0a — scaffold the directory the codegen writes into and add the
@@ -68,18 +91,15 @@ module Ruact
       def create_server_functions_directory
         empty_directory "app/javascript/.ruact"
         create_file "app/javascript/.ruact/.gitkeep" unless
-          File.exist?(destination_root.join("app/javascript/.ruact/.gitkeep"))
+          File.exist?(Pathname(destination_root).join("app/javascript/.ruact/.gitkeep"))
       end
 
       def append_gitignore_entries
-        gitignore = destination_root.join(".gitignore")
+        gitignore = Pathname(destination_root).join(".gitignore")
         return unless gitignore.exist?
 
         entries = [
           "app/javascript/.ruact/server-functions.ts",
-          # Story 9.3 — the route-driven (v2) parallel inspection target is also
-          # generated output, never source.
-          "app/javascript/.ruact/server-functions.next.ts",
           "tmp/cache/ruact/"
         ]
         # Substring matches (`existing.include?(entry)`) were unsafe — they
@@ -105,13 +125,17 @@ module Ruact
       end
 
       def create_vite_config
-        vite_config_file = destination_root.join("vite.config.js")
+        vite_config_file = Pathname(destination_root).join("vite.config.js")
 
-        if vite_config_file.exist?
+        # `--force` must actually regenerate (the message below promises it). The
+        # guard skips the template ONLY when the file exists AND force was not
+        # passed; with --force we fall through to `template`, which overwrites.
+        if vite_config_file.exist? && !options[:force]
           say_status "notice", "vite.config.js already exists — add the plugin manually:", :yellow
           say "  1. At the top of vite.config.js, add:"
           say "       import ruact from '#{Ruact.vite_plugin_path}';"
           say "  2. In the plugins array, add: ruact()"
+          say "  3. Set build.rollupOptions.input to '#{Ruact.bootstrap_virtual_id}'"
           say ""
           say "  Re-run `rails generate ruact:install --force` to overwrite vite.config.js."
         else
@@ -119,23 +143,284 @@ module Ruact
         end
       end
 
-      def create_javascript_entry
-        template "application.jsx.tt", "app/javascript/application.jsx"
+      # Story 14.6 (FR101, Epic 14 DoD) — a fresh ruact app needs a package.json
+      # declaring its JavaScript dependencies (React + Vite + the React Vite
+      # plugin) so the `npm install` that Story 14.1 runs has something to
+      # resolve and `bin/dev`'s `npm run dev` (Vite) has a `dev` script. The
+      # bundled ruact Vite plugin is NOT a package.json dependency — vite.config
+      # imports it by the absolute `Ruact.vite_plugin_path` and it uses only
+      # `node:` builtins. Guarded like vite.config.js: an existing package.json
+      # is left untouched (the app may already have one) unless --force.
+      def create_package_json
+        package_json_file = Pathname(destination_root).join("package.json")
+
+        if package_json_file.exist? && !options[:force]
+          say_status "skip", "package.json already exists — ensure it has react, react-dom, " \
+                             "vite and @vitejs/plugin-react (re-run with --force to overwrite)", :yellow
+          return
+        end
+
+        template "package.json.tt", "package.json"
+      end
+
+      # Story 14.6 (Epic 14 DoD) — emit `Procfile.dev` + a foreman-based `bin/dev`
+      # so the literal `bin/dev` boots BOTH processes a ruact app needs: Rails
+      # (HTML shell + Flight + server functions) and the Vite dev server
+      # (React/HMR + the bundled ruact plugin). Without these, `bin/dev` would
+      # start only Rails and the React assets would never be served.
+      #
+      # `Procfile.dev` is guarded (skip if present unless --force) — the app may
+      # already drive its own processes through one. `bin/dev`, however, is
+      # OWNED by ruact: see `install_foreman_launcher`. `bin/dev` is made
+      # executable.
+      def create_launch_files
+        create_guarded_file "Procfile.dev", "Procfile.dev.tt"
+        install_foreman_launcher
+        # Ensure bin/dev is executable whether we just wrote it or it pre-existed
+        # (a skipped, already-foreman launcher should still be runnable).
+        chmod "bin/dev", 0o755, verbose: false if Pathname(destination_root).join("bin/dev").exist?
+      end
+
+      # Story 14.2 (FR104, AC7) — an app upgrading from the earlier layout still
+      # has app/javascript/{application.jsx,flight-client.js,ruact-router.js} on
+      # disk. The generator never deletes user files, so it prints the exact
+      # manual steps to reach the hidden-plumbing layout — otherwise the app is
+      # left half-wired, with the stale entry shadowing the virtual bootstrap.
+      # No-op on a fresh install (none of those files exist).
+      def advise_plumbing_migration
+        stale = legacy_plumbing_files
+        return if stale.empty?
+
+        say_status "notice", "earlier ruact layout detected — finish the Story 14.2 migration:", :yellow
+        say ""
+        say "  ruact's bootstrap entry + Flight runtime are now hidden behind the"
+        say "  virtual module '#{Ruact.bootstrap_virtual_id}' (served from the gem)."
+        say "  Remove these now-obsolete files so they don't shadow the virtual entry:"
+        stale.each { |f| say "    - delete #{f}" }
+        say ""
+        say "  Then set your vite.config build input to '#{Ruact.bootstrap_virtual_id}'"
+        say "  (or re-run with --force to regenerate vite.config.js), and let the"
+        say "  controller's HTML shell — or the `ruact_js_assets` view helper in your"
+        say "  layout — emit the entry <script> tags."
+        say ""
+      end
+
+      # Story 14.1 (FR101) — install JavaScript dependencies so a fresh app is
+      # runnable in one command. Runs LAST among the file-producing actions
+      # (after every file is written) so a failure here leaves the generated
+      # files in place and reported. Records the outcome in @npm_outcome so
+      # show_post_install_message can tell the truth about what happened.
+      def install_javascript_dependencies
+        if options[:skip_npm]
+          @npm_outcome = :skipped
+          say_status "skip", "npm install (--skip-npm) — install JS deps manually before bin/dev", :yellow
+          return
+        end
+
+        unless npm_on_path?
+          @npm_outcome = :unavailable
+          warn_npm_unavailable
+          return
+        end
+
+        # Thor's `run` returns false on a non-zero exit (Rails generators set
+        # exit_on_failure? = false, so a failed `npm install` does NOT raise),
+        # and nil under `--pretend` (the command is previewed, not executed).
+        # Branch so the post-install message never claims deps are installed
+        # when npm failed (AC#3) — and a `--pretend` dry run is NOT misreported
+        # as a failure (run_npm_install still prints the previewed command).
+        if run_npm_install || options[:pretend]
+          @npm_outcome = options[:pretend] ? :pretend : :installed
+        else
+          @npm_outcome = :failed
+          warn_npm_install_failed
+        end
       end
 
       def show_post_install_message
+        say "\n#{'=' * 60}\n  ruact installed successfully!\n#{'=' * 60}\n"
+
+        if @npm_outcome == :installed
+          say "JavaScript dependencies are installed."
+          say ""
+          say "Next step:"
+          say "  Start your app:  bin/dev"
+        else
+          say "JavaScript dependencies are not yet installed."
+          say ""
+          say "Next steps:"
+          say "  1. Install JS dependencies:  npm install"
+          say "  2. Start your app:           bin/dev"
+        end
+
+        say "\nThen add <MyComponent /> to any ERB view.\n"
+        say "Note: re-run this generator after updating the ruact gem to refresh"
+        say "the bundled Vite plugin path in vite.config.js."
         say ""
-        say "=" * 60
-        say "  ruact installed successfully!"
-        say "=" * 60
+      end
+
+      private
+
+      # Story 14.6 (live clean-room fix) — ruact OWNS `bin/dev`. The foreman
+      # launcher is load-bearing: it boots BOTH Rails AND the Vite dev server,
+      # and Vite is what writes `public/react-client-manifest.json`. Rails'
+      # own `rails new` writes a `bin/dev` that starts ONLY `rails server` (no
+      # Vite) — leaving that default in place makes a freshly-installed ruact
+      # app 500 on its first render: Vite never runs, the manifest is never
+      # written, and the boot-time manifest load leaves `Ruact.manifest` nil.
+      # So unlike `Procfile.dev` (guarded), `bin/dev` is OVERWRITTEN to take
+      # ownership — the same posture Story 14.3's scaffold takes over the
+      # controller.
+      #
+      # The overwrite is skipped only when the existing `bin/dev` already drives
+      # `Procfile.dev` through a process manager (our foreman launcher from a
+      # prior install, or the developer's own foreman/overmind/hivemind setup).
+      # That keeps re-running the generator idempotent (invariant 14.1 — no
+      # churn on the second run) and never clobbers a deliberate launcher, while
+      # still replacing the inert Rails default. Detection is content-based but
+      # deliberately STRICTER than a bare `include?("Procfile.dev")` (Codex R1/R2):
+      # neither a comment nor an `echo`/`printf` that merely names a foreman
+      # command may suppress the overwrite, or the Rails-default-only-
+      # `rails server` failure mode could survive. See {#foreman_launcher?}.
+      def install_foreman_launcher
+        bin_dev = Pathname(destination_root).join("bin/dev")
+
+        if bin_dev.exist? && foreman_launcher?(bin_dev.read) && !options[:force]
+          say_status "skip", "bin/dev already drives Procfile.dev (foreman launcher present)", :yellow
+          return
+        end
+
+        template "dev.tt", "bin/dev", force: true
+      end
+
+      # Procfile process managers a foreman-style `bin/dev` may exec. A launcher
+      # that INVOKES one of these against `Procfile.dev` already boots Vite (via
+      # the same Procfile.dev ruact writes), so it is ruact-compatible.
+      PROCFILE_RUNNERS = %w[foreman overmind hivemind node-foreman invoker].freeze
+      private_constant :PROCFILE_RUNNERS
+
+      # A line that INVOKES a known runner as its COMMAND — the runner is the
+      # command word, after an optional leading `exec` / `bundle exec`. Anchoring
+      # to command position (Codex R3) is what distinguishes a real launcher from
+      # a mere mention: an `echo`/`printf`, an assignment like
+      # `MSG="… foreman …"`, or a `command -v foreman` test never has the runner
+      # in command position, and the trailing shell-token boundary `(?=\s|$)`
+      # requires the runner to be a COMPLETE command word — so neither
+      # `beforeman` nor `foreman-old`/`foreman.bak` is mistaken for the real
+      # `foreman` (Codex R5). (A launcher prefixed with bare env assignments —
+      # e.g. `PORT=3000 foreman …` — does NOT match and is simply re-owned by
+      # ruact's equivalent foreman launcher; harmless, and far safer than the
+      # inverse false-positive that would let the Rails-only `bin/dev` survive.)
+      RUNNER_INVOCATION = Regexp.new(
+        '\A\s*(?:exec\s+|bundle\s+exec\s+)*' \
+        "(?:#{Regexp.union(PROCFILE_RUNNERS).source})" \
+        '(?=\s|$)'
+      )
+      private_constant :RUNNER_INVOCATION
+
+      # True when `content` actually invokes a Procfile runner against
+      # `Procfile.dev` — some non-comment line both invokes a known runner
+      # ({RUNNER_INVOCATION}) AND references `Procfile.dev`. The Rails-default
+      # `bin/dev` runs only `rails server`, invokes no runner, and is correctly
+      # taken over.
+      def foreman_launcher?(content)
+        content.each_line.any? do |line|
+          # Drop any inline shell comment (` #…`) before inspecting the line, so
+          # `Procfile.dev` named only in a trailing comment is not mistaken for a
+          # real argument (Codex R4) — e.g. `foreman --version # …Procfile.dev`.
+          code = line.strip.split(/\s+#/, 2).first.to_s
+          next false if code.empty? || code.start_with?("#")
+
+          code.match?(RUNNER_INVOCATION) && code.include?("Procfile.dev")
+        end
+      end
+
+      # Story 14.6 — write a template only when the destination does not already
+      # exist (unless --force), printing a skip notice otherwise. Keeps
+      # create_launch_files idempotent and non-clobbering.
+      def create_guarded_file(destination, template_name)
+        if Pathname(destination_root).join(destination).exist? && !options[:force]
+          say_status "skip", "#{destination} already exists (re-run with --force to overwrite)", :yellow
+          return
+        end
+
+        template template_name, destination
+      end
+
+      # Story 14.6 — a valid, lowercase npm "name" for the generated package.json,
+      # derived from the app directory. npm names must be lowercase and contain
+      # only URL-safe characters; anything else collapses to a hyphen.
+      def app_package_name
+        base = File.basename(File.expand_path(destination_root))
+        sanitized = base.downcase.gsub(/[^a-z0-9._-]/, "-").squeeze("-").gsub(/\A-+|-+\z/, "")
+        sanitized.empty? ? "ruact-app" : sanitized
+      end
+
+      # Story 14.2 (AC7) — the earlier-layout plumbing files that must be removed
+      # from the user's tree (the bootstrap entry + the per-app runtime copies).
+      # Returns the relative paths that currently exist under destination_root.
+      def legacy_plumbing_files
+        %w[
+          app/javascript/application.jsx
+          app/javascript/flight-client.js
+          app/javascript/ruact-router.js
+        ].select { |rel| File.exist?(Pathname(destination_root).join(rel)) }
+      end
+
+      # The stubbable seam (AC#6): the literal shell-out lives here, isolated
+      # so the generator spec can assert/stub it without invoking real npm or
+      # hitting the network. Runs in the app root (destination_root) so it
+      # picks up the app's package.json. Returns Thor's `run` result (truthy on
+      # success, false on a non-zero exit) — captured inside the block so the
+      # value is propagated regardless of `inside`'s return semantics.
+      def run_npm_install
+        result = nil
+        inside(destination_root) { result = run "npm install" }
+        result
+      end
+
+      # Cross-platform `npm`-on-PATH detection (AC#5). Honors PATHEXT on
+      # Windows (npm ships as npm.cmd there); on POSIX the bare `npm` is
+      # checked. Stubbed in specs to exercise both branches deterministically
+      # without depending on the CI host having Node installed.
+      def npm_on_path?
+        exts = ENV.fetch("PATHEXT", "").split(File::PATH_SEPARATOR)
+        exts = [""] if exts.empty?
+
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
+          next false if dir.empty?
+
+          exts.any? do |ext|
+            candidate = File.join(dir, "npm#{ext}")
+            File.file?(candidate) && File.executable?(candidate)
+          end
+        end
+      end
+
+      # Clear, actionable message (AC#5) when npm is unavailable — the written
+      # files are NOT rolled back; the developer is pointed at Node or the
+      # --skip-npm escape hatch. No raw Errno/NoMethodError stack trace leaks.
+      def warn_npm_unavailable
+        say_status "warn", "npm not found on PATH — skipping JavaScript dependency install", :yellow
         say ""
-        say "Next steps:"
-        say "  1. Start the Vite dev server:  npm run dev"
-        say "  2. Start Rails:                rails server"
-        say "  3. Add <MyComponent /> to any ERB view"
+        say "  ruact wrote all of its files, but could NOT install JavaScript"
+        say "  dependencies: `npm` is not available on your PATH."
+        say ""
+        say "  Install Node >= 20 (https://nodejs.org), then run `npm install`,"
+        say "  or re-run with `--skip-npm` and install JS deps with your own"
+        say "  package manager. Then start your app with `bin/dev`."
+        say ""
+      end
+
+      # Reported when `npm install` ran but exited non-zero (AC#1/#3) — the
+      # written files are kept; the developer is told to resolve the npm error
+      # and re-run, and the post-install summary will NOT claim deps installed.
+      def warn_npm_install_failed
+        say_status "warn", "npm install did not complete successfully", :yellow
         say ""
-        say "Note: Re-run this generator after updating the ruact gem"
-        say "to refresh the bundled Vite plugin path in vite.config.js."
+        say "  ruact wrote all of its files, but `npm install` reported a failure."
+        say "  Re-run `npm install` in the app root and resolve the npm error,"
+        say "  then start your app with `bin/dev`."
         say ""
       end
     end

data/lib/generators/ruact/install/templates/Procfile.dev.tt

@@ -0,0 +1,2 @@
+web: bin/rails server -p 3000
+vite: npm run dev

data/lib/generators/ruact/install/templates/dev.tt

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+# Boots the ruact development stack — both processes from Procfile.dev:
+#   web:  bin/rails server   (HTML shell + Flight stream + server functions)
+#   vite: npm run dev        (Vite dev server: React/HMR + the bundled ruact plugin)
+# A ruact app needs BOTH: Rails serves the HTML/Flight payload, Vite serves the
+# React client assets. `bin/dev` runs them together via foreman.
+
+if ! gem list foreman -i --silent; then
+  echo "Installing foreman..."
+  gem install foreman
+fi
+
+export PORT="${PORT:-3000}"
+
+exec foreman start -f Procfile.dev "$@"

data/lib/generators/ruact/install/templates/package.json.tt

@@ -0,0 +1,17 @@
+{
+  "name": "<%= app_package_name %>",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build"
+  },
+  "dependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.4",
+    "vite": "^6.0.7"
+  }
+}

data/lib/generators/ruact/install/templates/vite.config.js.tt

@@ -14,7 +14,9 @@ export default defineConfig({
     outDir: 'public/assets',
     manifest: true,
     rollupOptions: {
-      input: 'app/javascript/application.jsx',
+      // ruact's bootstrap entry is a virtual module served by the plugin above
+      // (Story 14.2) — there is no app/javascript/application.jsx to point at.
+      input: '<%= Ruact.bootstrap_virtual_id %>',
     },
   },
 

data/lib/generators/ruact/scaffold/scaffold_attribute.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+
+module Ruact
+  module Generators
+    class ScaffoldGenerator < Rails::Generators::NamedBase
+      # A single scaffold attribute (name + AR type) with the view-model helpers
+      # the templates consume. `references` columns address `<name>_id`. Lives in
+      # its own file to keep {ScaffoldGenerator} within its class-length budget;
+      # reopens the generator class so `TYPE_MAP` resolves by lexical scope.
+      class ScaffoldAttribute
+        attr_reader :name, :type
+
+        def initialize(name, type)
+          @name = name
+          @type = type
+        end
+
+        # The wire/DB column the controller params + serialized rows use.
+        def column_name
+          reference? ? "#{name}_id" : name
+        end
+
+        def ts_type
+          TYPE_MAP.fetch(type)[:ts]
+        end
+
+        def control
+          TYPE_MAP.fetch(type)[:control]
+        end
+
+        def boolean?
+          type == "boolean"
+        end
+
+        # date/datetime — the List sorts these columns by epoch time (Story 10.2b).
+        def date?
+          column_kind == :date
+        end
+
+        # The DataTable cell renderer kind (Story 10.2 AC1):
+        #   :badge   → boolean                          → Badge "Yes"/"No"
+        #   :numeric → integer/float/decimal/references → right-aligned numeric
+        #   :date    → date/datetime                    → locale-formatted
+        #   :text    → string/text                      → plain text
+        def column_kind
+          case type
+          when "boolean" then :badge
+          when "integer", "float", "decimal", "references" then :numeric
+          when "date", "datetime" then :date
+          else :text
+          end
+        end
+
+        # The shadcn Form control this attribute renders as (Story 10.3 AC1):
+        #   :input    → string                → <Input type="text">
+        #   :textarea → text                  → <Textarea>
+        #   :switch   → boolean               → <Switch>
+        #   :number   → integer/float/decimal → <Input type="number">
+        #   :date     → date                  → <Input type="date">
+        #   :datetime → datetime              → <Input type="datetime-local">
+        #   :select   → references            → <Select> of parent options
+        # The :input/:number/:date/:datetime kinds all render an <Input>; the
+        # concrete `type=` attribute comes from `html_input_type` (FormHelpers).
+        def shadcn_control
+          case type
+          when "text" then :textarea
+          when "boolean" then :switch
+          when "integer", "float", "decimal" then :number
+          when "date" then :date
+          when "datetime" then :datetime
+          when "references" then :select
+          else :input
+          end
+        end
+
+        # references only — the parent model constant (`author` → `Author`,
+        # `blog_post` → `BlogPost`), used by the controller's options loader.
+        def reference_class_name
+          name.camelize
+        end
+
+        # references only — the controller ivar / view local holding the capped
+        # parent options (`author` → `author_options`).
+        def options_ivar
+          "#{name}_options"
+        end
+
+        # references only — the camelCase prop the view passes and the Form reads
+        # (`author` → `authorOptions`, `blog_post` → `blogPostOptions`).
+        def options_prop
+          parts = name.split("_")
+          "#{(parts.first(1) + parts.drop(1).map(&:capitalize)).join}Options"
+        end
+
+        def reference?
+          type == "references"
+        end
+
+        # camelCase JS identifier for the column (`author_id` → `authorId`).
+        def js_var
+          parts = column_name.split("_")
+          (parts.first(1) + parts.drop(1).map(&:capitalize)).join
+        end
+
+        # The React `useState` setter name (`authorId` → `setAuthorId`).
+        def js_setter
+          "set#{js_var.sub(/\A./, &:upcase)}"
+        end
+      end
+    end
+  end
+end