react_on_rails 16.7.0.rc.1 → 16.7.0.rc.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c1fa8759e37cddc05c49a9824d2914bd87a2cdbb12d174d48503604b30a6c58
-  data.tar.gz: a61dd03cdd48c4d61f9a4df42ef329b44a80484e9078187e3f98765465d5ae87
+  metadata.gz: a330ac2b76a6a565ea1f64291f54d2ff5a90b39e33bb7c1929f3caa11ed8358e
+  data.tar.gz: 4d06374dfcb3c2004138c3386ed326634b03c91a27e96c4d442b0bcd5a9c39c9
 SHA512:
-  metadata.gz: f482e32ce3d43fd9814535245f094c6652d1ca40e15449cb0acbba1ae0a551e52a3aab07846a95fce9316c4067e0c519114736995145baaf3dc99838eef39261
-  data.tar.gz: 12e1670e1b1671ca36f3f4ffb426cdfb1a4a56b6a888da7d3100e6f327412a74a0714ea6a4f51e44c623c3e9941f70c742689dc47cdbd49fcf85f3d3f44ff49c
+  metadata.gz: 55392f01cd6ccad3792eac088c3f59d354131e159d22bc15dc086b17abc75ca248da294269d3e73ee25cea846af246e0d59ab2b93558ab0cf9bd9558e3ef52bf
+  data.tar.gz: c8fed4f8f74704860bff9a4784906ebcf5bab48cf7a50d9e7240a750d71c4d87dd228c55b3f0bad80edcc0c06565a20f606f8a2f1938ab8b3fa0108c52241bbf

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    react_on_rails (16.7.0.rc.1)
+    react_on_rails (16.7.0.rc.3)
       addressable
       connection_pool
       execjs (~> 2.5)
@@ -201,6 +201,10 @@ GEM
     nokogiri (1.19.2)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
+    nokogiri (1.19.2-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.19.2-x86_64-linux-gnu)
+      racc (~> 1.4)
     ostruct (0.6.1)
     package_json (0.2.0)
     parallel (1.24.0)
@@ -377,6 +381,8 @@ GEM
       sprockets (>= 3.0.0)
     sqlite3 (1.7.3)
       mini_portile2 (~> 2.8.0)
+    sqlite3 (1.7.3-arm64-darwin)
+    sqlite3 (1.7.3-x86_64-linux)
     steep (1.9.4)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
@@ -428,7 +434,9 @@ GEM
     zeitwerk (2.7.5)
 
 PLATFORMS
+  arm64-darwin
   ruby
+  x86_64-linux
 
 DEPENDENCIES
   amazing_print

data/lib/generators/react_on_rails/generator_helper.rb

@@ -84,12 +84,16 @@ module GeneratorHelper
     false
   end
 
-  # Check if React on Rails Pro gem is installed
+  # Check if React on Rails Pro gem is installed (real state — never "scheduled to be installed").
   #
   # Detection priority:
   # 1. Gem.loaded_specs - gem is loaded in current Ruby process (most reliable)
   # 2. Gemfile.lock - gem is resolved and installed
   #
+  # Use {#pro_gem_install_deferred?} for the broader "present, or will be installed by this
+  # generator run" meaning. Use {#invalidate_pro_gem_installed_cache!} after an operation
+  # that changes real state (e.g., bundle add) so the next call re-reads the lockfile.
+  #
   # @return [Boolean] true if react_on_rails_pro gem is installed
   def pro_gem_installed?
     return @pro_gem_installed if defined?(@pro_gem_installed)
@@ -97,11 +101,6 @@ module GeneratorHelper
     @pro_gem_installed = Gem.loaded_specs.key?("react_on_rails_pro") || gem_in_lockfile?("react_on_rails_pro")
   end
 
-  # TODO: CQS smell: mark_pro_gem_installed! makes pro_gem_installed? return true before install. See #3303.
-  def mark_pro_gem_installed!
-    @pro_gem_installed = true
-  end
-
   # Check if Pro features should be enabled.
   # Returns true if --pro or --rsc is set (RSC implies Pro).
   #
@@ -252,6 +251,24 @@ module GeneratorHelper
 
   private
 
+  # Clear the memoized {#pro_gem_installed?} result so the next call re-checks
+  # Gem.loaded_specs / Gemfile.lock. Call after any operation that may change real state.
+  def invalidate_pro_gem_installed_cache!
+    remove_instance_variable(:@pro_gem_installed) if defined?(@pro_gem_installed)
+  end
+
+  # True when a later step in this generator run will install the Pro gem
+  # (e.g., the Gemfile swap performed by ProGenerator). Distinct from
+  # {#pro_gem_installed?}, which only reports real present state.
+  def pro_gem_install_deferred?
+    @pro_gem_install_deferred == true
+  end
+
+  # Record that a later step in this generator run will install the Pro gem.
+  def defer_pro_gem_install!
+    @pro_gem_install_deferred = true
+  end
+
   # NOTE: only the `default:` section is inspected — same assumption as
   # rspack_configured_in_project?. Projects that set `javascript_transpiler`
   # only in per-environment sections (without a `default:` block) will not be

data/lib/generators/react_on_rails/install_generator.rb

@@ -138,11 +138,13 @@ module ReactOnRails
       # version because `pnpm/action-setup` requires one unless package.json declares
       # `packageManager`. Match the repo's own packageManager version so generated
       # CI defaults to the pnpm major this codebase tests with. Track the exact release
-      # used for this fallback at https://github.com/pnpm/pnpm/releases/tag/v9.14.2;
+      # used for this fallback at https://github.com/pnpm/pnpm/releases/tag/v10.33.4;
       # update this URL with the constant when bumping. Users who need exact
       # reproducibility should commit `packageManager` to their package.json instead.
-      # renovate: datasource=github-releases depName=pnpm/pnpm extractVersion=^v(?<version>.+)$
-      CI_PNPM_FALLBACK_VERSION = "9.14.2"
+      # Bump checklist: heading text below is spec-asserted.
+      # CONTRIBUTING.md > "Updating the pnpm Fallback Version for Scaffolded CI".
+      # renovate: datasource=github-releases depName=pnpm/pnpm extractVersion=^v(?<version>.+)$ allowedVersions=<11
+      CI_PNPM_FALLBACK_VERSION = "10.33.4"
       private_constant :CI_PNPM_FALLBACK_VERSION
 
       # Main generator entry point

data/lib/generators/react_on_rails/js_dependency_manager.rb

@@ -510,8 +510,10 @@ module ReactOnRails
       # @return [Boolean] true if successful, false otherwise
       def add_packages(packages, dev: false)
         return true if add_npm_dependencies(packages, dev: dev)
+        return true if install_packages_with_fallback(packages, dev: dev)
 
-        install_packages_with_fallback(packages, dev: dev)
+        write_versioned_package_specs_to_package_json(packages, dev: dev)
+        false
       end
 
       def install_js_dependencies
@@ -559,6 +561,29 @@ module ReactOnRails
         false
       end
 
+      # Last-resort fallback for install failures. This rewrites package.json with
+      # JSON.pretty_generate so users can rerun their package manager manually.
+      def write_versioned_package_specs_to_package_json(packages, dev:)
+        return false unless File.exist?("package.json")
+
+        versioned_packages = packages.filter_map { |package_spec| package_name_and_version_from_spec(package_spec) }
+        return false if versioned_packages.empty?
+
+        content = JSON.parse(File.read("package.json"))
+        dependency_field = dev ? "devDependencies" : "dependencies"
+        content[dependency_field] ||= {}
+
+        versioned_packages.each do |package_name, package_version|
+          content[dependency_field][package_name] = package_version
+        end
+
+        File.write("package.json", "#{JSON.pretty_generate(content)}\n")
+        true
+      rescue StandardError => e
+        GeneratorMessages.add_warning("⚠️  Could not write dependency pins to package.json: #{e.message}")
+        false
+      end
+
       def fallback_package_manager
         package_manager = GeneratorMessages.detect_package_manager(app_root: destination_root)
         return package_manager if GeneratorMessages.supported_package_manager?(package_manager)
@@ -622,6 +647,13 @@ module ReactOnRails
       def version_specified?(package_spec, package_name)
         package_spec != package_name
       end
+
+      def package_name_and_version_from_spec(package_spec)
+        package_name = package_name_from_spec(package_spec)
+        return nil unless package_name && version_specified?(package_spec, package_name)
+
+        [package_name, package_spec.delete_prefix("#{package_name}@")]
+      end
     end
   end
 end

data/lib/generators/react_on_rails/pro_setup.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "generator_messages"
+require "react_on_rails/node_renderer_procfile"
 require "react_on_rails/pro_migration"
 
 module ReactOnRails
@@ -19,7 +20,9 @@ module ReactOnRails
     #
     # Including classes must also include GeneratorHelper which provides:
     # - use_pro?, use_rsc?: Feature flag helpers
-    # - pro_gem_installed?: Pro gem detection
+    # - pro_gem_installed?: Pro gem detection (real lockfile / loaded-specs state)
+    # - pro_gem_install_deferred?, defer_pro_gem_install!: deferred-install tracking
+    # - invalidate_pro_gem_installed_cache!: invalidate memoized pro_gem_installed?
     #
     # rubocop:disable Metrics/ModuleLength
     module ProSetup
@@ -45,7 +48,7 @@ module ReactOnRails
 
         create_pro_initializer
         legacy_renderer_detected = create_node_renderer
-        add_pro_to_procfile unless legacy_renderer_detected
+        add_pro_to_procfiles unless legacy_renderer_detected
         update_webpack_config_for_pro
 
         say set_color("=" * 80, :cyan)
@@ -63,7 +66,7 @@ module ReactOnRails
       #   is deferred to the Gemfile swap.
       def missing_pro_gem?(force: false)
         return false unless force || use_pro?
-        return false if pro_gem_installed?
+        return false if pro_gem_installed? || pro_gem_install_deferred?
         return false if defer_pro_gem_install_to_gemfile_swap
         return false if attempt_pro_gem_auto_install
 
@@ -126,7 +129,8 @@ module ReactOnRails
 
         # The gem is now in Gemfile/lockfile but not loaded in the current Ruby process.
         # Generator code that follows must not reference ReactOnRailsPro constants directly.
-        mark_pro_gem_installed!
+        # The lockfile changed, so the memoized pro_gem_installed? must be refreshed.
+        invalidate_pro_gem_installed_cache!
         true
       rescue StandardError => e
         say "⚠️  Failed to run bundle add: #{e.message}", :red
@@ -211,17 +215,43 @@ module ReactOnRails
         say "✅ Created #{initializer_path}", :green
       end
 
-      # Matches active (uncommented) Procfile.dev node-renderer lines, tolerating
-      # an optional `./` prefix that a user may have added by hand
-      # (e.g. `node ./renderer/node-renderer.js`).
-      NEW_RENDERER_COMMAND_REGEX = %r{^[ \t]*node-renderer:[^\n]*\bnode\s+\.?/?renderer/node-renderer\.js\b}
-      LEGACY_RENDERER_COMMAND_REGEX = %r{^[ \t]*node-renderer:[^\n]*\bnode\s+\.?/?client/node-renderer\.js\b}
-
+      # Matches active (uncommented) Procfile.dev node-renderer lines that
+      # both set RENDERER_PORT and launch renderer/node-renderer.js (optionally
+      # prefixed with `./`). Entries missing RENDERER_PORT are intentionally
+      # not matched here so they fall through to NODE_RENDERER_PROCESS_REGEX
+      # and surface the "Update it manually" warning, keeping the generator's
+      # accept/skip decision aligned with the doctor's RENDERER_PORT check in
+      # NodeRendererProcfile::PROCESS_WITH_RENDERER_PORT_REGEX.
+      NEW_RENDERER_COMMAND_REGEX = %r{
+        ^[ \t]*(?:node-)?renderer:
+        (?=[^\n]*\bRENDERER_PORT\b)
+        [^\n]*\bnode\s+\.?/?renderer/node-renderer\.js\b
+      }x
+      LEGACY_RENDERER_COMMAND_REGEX = %r{^[ \t]*(?:node-)?renderer:[^\n]*\bnode\s+\.?/?client/node-renderer\.js\b}
+      # Detects an existing Node Renderer process entry. The dedicated
+      # `node-renderer:` label is reserved for the Pro Node Renderer, so any
+      # entry with that label is treated as the user's renderer regardless of
+      # the command (avoiding duplicate-label appends). A bare `renderer:`
+      # label could be anything (e.g. `renderer: vite ...`), so it only counts
+      # when the command actually launches a node-renderer — otherwise the
+      # generator would emit a misleading "update it manually" warning for an
+      # unrelated process.
+      NODE_RENDERER_PROCESS_REGEX = %r{
+        ^[ \t]*(?:
+          node-renderer:
+          |
+          renderer:[^\n]*(?:
+            \bnode\s+\.?/?(?:renderer|client)/node-renderer\.js\b
+            |
+            \b(?:pnpm|npm|yarn)\s+(?:run\s+)?node-renderer\b
+          )
+        )
+      }x
       # Creates renderer/node-renderer.js unless either the new path or the legacy
       # client/node-renderer.js already exists.
       #
       # @return [Boolean] true when a legacy client/node-renderer.js was detected
-      #   (caller should skip add_pro_to_procfile to avoid pointing Procfile.dev
+      #   (caller should skip add_pro_to_procfiles to avoid pointing Procfile.dev
       #   at a file that wasn't created); false otherwise.
       def create_node_renderer
         node_renderer_path = "renderer/node-renderer.js"
@@ -236,8 +266,7 @@ module ReactOnRails
           say "ℹ️  #{legacy_node_renderer_path} detected, keeping existing renderer; " \
               "to migrate, move it to #{node_renderer_path} and update any references " \
               "(e.g. Procfile.dev, Procfile.prod, Docker CMD / command):", :yellow
-          say "      node-renderer: RENDERER_LOG_LEVEL=debug RENDERER_PORT=${RENDERER_PORT:-3800} " \
-              "node #{node_renderer_path}", :yellow
+          say "      #{node_renderer_procfile_command('Procfile.dev')}", :yellow
           warn_on_stale_legacy_procfile_entry
           return true
         end
@@ -253,34 +282,48 @@ module ReactOnRails
         false
       end
 
-      # When a legacy client/node-renderer.js is detected, add_pro_to_procfile is
-      # skipped, so surface a pointed warning if Procfile.dev still launches the
-      # legacy entry. This nudges the user to update the exact line they need to
-      # touch rather than leaving them to diff the generic migration hint against
-      # their Procfile themselves.
+      # When a legacy client/node-renderer.js is detected, add_pro_to_procfiles is
+      # skipped, so surface a pointed warning for each Procfile that still
+      # launches the legacy entry. This nudges the user to update the exact
+      # line(s) they need to touch rather than leaving them to diff the generic
+      # migration hint against their Procfiles themselves.
       def warn_on_stale_legacy_procfile_entry
-        procfile_path = File.join(destination_root, "Procfile.dev")
-        return unless File.exist?(procfile_path)
+        ReactOnRails::NodeRendererProcfile::DEFAULT_COMMANDS.each_key do |procfile|
+          procfile_path = File.join(destination_root, procfile)
+          next unless File.exist?(procfile_path)
 
-        procfile_content = File.read(procfile_path)
-        return unless procfile_content.match?(LEGACY_RENDERER_COMMAND_REGEX)
+          procfile_content = File.read(procfile_path)
+          next unless procfile_content.match?(LEGACY_RENDERER_COMMAND_REGEX)
 
-        GeneratorMessages.add_warning(<<~MSG.strip)
-          ⚠️  Procfile.dev still launches the legacy client/node-renderer.js.
-          After migrating the renderer file, update that line to:
-            node-renderer: RENDERER_LOG_LEVEL=debug RENDERER_PORT=${RENDERER_PORT:-3800} node renderer/node-renderer.js
-        MSG
+          GeneratorMessages.add_warning(<<~MSG.strip)
+            ⚠️  #{procfile} still launches the legacy client/node-renderer.js.
+            After migrating the renderer file, update that line to:
+              #{node_renderer_procfile_command(procfile)}
+          MSG
+        end
       end
 
-      def add_pro_to_procfile
-        procfile_path = File.join(destination_root, "Procfile.dev")
+      def node_renderer_procfile_command(procfile)
+        ReactOnRails::NodeRendererProcfile.command_for(procfile)
+      end
+
+      def add_pro_to_procfiles
+        ReactOnRails::NodeRendererProcfile::DEFAULT_COMMANDS.each do |procfile, command|
+          add_node_renderer_to_procfile(procfile, command, warn_if_missing: procfile == "Procfile.dev")
+        end
+      end
+
+      def add_node_renderer_to_procfile(procfile, command, warn_if_missing:)
+        procfile_path = File.join(destination_root, procfile)
 
         unless File.exist?(procfile_path)
+          return unless warn_if_missing
+
           GeneratorMessages.add_warning(<<~MSG.strip)
-            ⚠️  Procfile.dev not found. Skipping Node Renderer process addition.
+            ⚠️  #{procfile} not found. Skipping Node Renderer process addition.
 
             You'll need to add the Node Renderer to your process manager manually:
-              node-renderer: RENDERER_LOG_LEVEL=debug RENDERER_PORT=${RENDERER_PORT:-3800} node renderer/node-renderer.js
+              #{command}
           MSG
           return
         end
@@ -288,29 +331,28 @@ module ReactOnRails
         procfile_content = File.read(procfile_path)
 
         if procfile_content.match?(NEW_RENDERER_COMMAND_REGEX)
-          say "ℹ️  Node Renderer already in Procfile.dev, skipping", :yellow
+          say "ℹ️  Node Renderer already in #{procfile}, skipping", :yellow
           return
         end
 
-        if procfile_content.match?(/^[ \t]*node-renderer:/)
-          say "⚠️  Procfile.dev has a node-renderer: entry that doesn't reference " \
+        if procfile_content.match?(NODE_RENDERER_PROCESS_REGEX)
+          say "⚠️  #{procfile} has a renderer entry that doesn't reference " \
               "renderer/node-renderer.js. Update it manually to:", :yellow
-          say "      node-renderer: RENDERER_LOG_LEVEL=debug RENDERER_PORT=${RENDERER_PORT:-3800} " \
-              "node renderer/node-renderer.js", :yellow
+          say "      #{command}", :yellow
           return
         end
 
-        say "📝 Adding Node Renderer to Procfile.dev...", :yellow
+        say "📝 Adding Node Renderer to #{procfile}...", :yellow
 
         node_renderer_line = <<~PROCFILE
 
           # React on Rails Pro - Node Renderer for SSR
-          node-renderer: RENDERER_LOG_LEVEL=debug RENDERER_PORT=${RENDERER_PORT:-3800} node renderer/node-renderer.js
+          #{command}
         PROCFILE
 
-        append_to_file("Procfile.dev", node_renderer_line)
+        append_to_file(procfile, node_renderer_line)
 
-        say "✅ Added Node Renderer to Procfile.dev", :green
+        say "✅ Added Node Renderer to #{procfile}", :green
       end
 
       # Update webpack configs to enable Pro settings.
@@ -542,7 +584,7 @@ module ReactOnRails
       def defer_pro_gem_install_to_gemfile_swap
         return false unless base_react_on_rails_gem_in_gemfile?
 
-        mark_pro_gem_installed!
+        defer_pro_gem_install!
         true
       end