react_on_rails 16.6.0 → 16.7.0.rc.0

data/lib/generators/react_on_rails/generator_messages.rb

@@ -2,13 +2,22 @@
 
 require "rainbow"
 
+require_relative "generator_messages/package_manager_detection"
+require_relative "generator_messages/ci_section"
+require_relative "generator_messages/shakapacker_status_section"
+
 module GeneratorMessages
   PRO_UPGRADE_HINT = "\n\n    💎 For RSC, streaming SSR, and 10-100x faster SSR, try React on Rails Pro:" \
                      "\n       #{Rainbow('https://reactonrails.com/docs/pro/upgrading-to-pro/').cyan.underline}".freeze
-  SUPPORTED_PACKAGE_MANAGERS = %w[npm pnpm yarn bun].freeze
+  # Package manager constants and detection helpers live in PackageManagerDetection,
+  # re-exported here for backwards compatibility (external callers use ::SUPPORTED_PACKAGE_MANAGERS).
+  SUPPORTED_PACKAGE_MANAGERS = PackageManagerDetection::SUPPORTED_PACKAGE_MANAGERS
 
-  # rubocop:disable Metrics/ClassLength
   class << self
+    include PackageManagerDetection
+    include CiSection
+    include ShakapackerStatusSection
+
     def output
       @output ||= []
     end
@@ -46,11 +55,14 @@ module GeneratorMessages
     end
 
     def helpful_message_after_installation(component_name: "HelloWorld", route: "hello_world", pro: false,
-                                           rsc: false, shakapacker_just_installed: false, landing_page: false)
+                                           rsc: false, shakapacker_just_installed: false, landing_page: false,
+                                           ci_workflow_generated: false, app_root: Dir.pwd)
       process_manager_section = build_process_manager_section
-      testing_section = build_testing_section
-      package_manager = detect_package_manager
-      shakapacker_status = build_shakapacker_status_section(shakapacker_just_installed: shakapacker_just_installed)
+      testing_section = build_testing_section(app_root: app_root)
+      ci_section = build_ci_section(app_root: app_root, ci_workflow_generated: ci_workflow_generated)
+      package_manager = detect_package_manager(app_root: app_root)
+      shakapacker_status = build_shakapacker_status_section(shakapacker_just_installed: shakapacker_just_installed,
+                                                            app_root: app_root)
       render_example = build_render_example(component_name: component_name, route: route, rsc: rsc)
       render_label = build_render_label(route: route, rsc: rsc)
       normalized_route = route.to_s.sub(%r{\A/+}, "")
@@ -99,33 +111,10 @@ module GeneratorMessages
         • Documentation: #{Rainbow('https://reactonrails.com/docs/').cyan.underline}
         • Webpack customization: #{Rainbow('https://github.com/shakacode/shakapacker#webpack-configuration').cyan.underline}
 
-        💡 TIP: Run 'bin/dev help' for development server options and troubleshooting#{testing_section}#{pro_hint}
+        💡 TIP: Run 'bin/dev help' for development server options and troubleshooting#{testing_section}#{ci_section}#{pro_hint}
       MSG
     end
 
-    # Uses relative lockfile paths resolved against Dir.pwd, so callers must invoke
-    # this while the current working directory is the target Rails app root.
-    def detect_package_manager
-      env_package_manager = ENV.fetch("REACT_ON_RAILS_PACKAGE_MANAGER", nil)&.strip&.downcase
-      return env_package_manager if supported_package_manager?(env_package_manager)
-
-      # Default to npm (Shakapacker 8.x default) - covers package-lock.json and no lockfile
-      detect_package_manager_from_lockfiles || "npm"
-    end
-
-    def detect_package_manager_from_lockfiles
-      return "yarn" if File.exist?("yarn.lock")
-      return "pnpm" if File.exist?("pnpm-lock.yaml")
-      return "bun" if File.exist?("bun.lock") || File.exist?("bun.lockb")
-      return "npm" if File.exist?("package-lock.json")
-
-      nil
-    end
-
-    def supported_package_manager?(package_manager)
-      SUPPORTED_PACKAGE_MANAGERS.include?(package_manager)
-    end
-
     private
 
     def build_render_example(component_name:, route:, rsc:)
@@ -160,8 +149,9 @@ module GeneratorMessages
       end
     end
 
-    def build_testing_section
-      return "" if File.exist?("spec/rails_helper.rb") || File.exist?("spec/spec_helper.rb")
+    def build_testing_section(app_root: Dir.pwd)
+      return "" if File.exist?(File.join(app_root, "spec/rails_helper.rb")) ||
+                   File.exist?(File.join(app_root, "spec/spec_helper.rb"))
 
       <<~TESTING
 
@@ -182,52 +172,5 @@ module GeneratorMessages
         "foreman"
       end
     end
-
-    def build_shakapacker_status_section(shakapacker_just_installed: false)
-      version_warning = check_shakapacker_version_warning
-      if shakapacker_just_installed
-        base = <<~SHAKAPACKER
-
-          📦 SHAKAPACKER SETUP:
-          ─────────────────────────────────────────────────────────────────────────
-          #{Rainbow('✓ Added to Gemfile automatically').green}
-          #{Rainbow('✓ Installer ran successfully').green}
-          #{Rainbow('✓ Webpack integration configured').green}
-        SHAKAPACKER
-        base.chomp + version_warning
-      elsif File.exist?("bin/shakapacker") && File.exist?("bin/shakapacker-dev-server")
-        "\n📦 #{Rainbow('Shakapacker already configured ✓').green}#{version_warning}"
-      else
-        "\n📦 #{Rainbow('Shakapacker setup may be incomplete').yellow}#{version_warning}"
-      end
-    end
-
-    def check_shakapacker_version_warning
-      return "" unless File.exist?("Gemfile.lock")
-
-      shakapacker_match = File.read("Gemfile.lock").match(/shakapacker \((\d+\.\d+\.\d+)\)/)
-      return "" unless shakapacker_match
-
-      version = shakapacker_match[1]
-      if version.split(".").first.to_i < 8
-        <<~WARNING
-
-          ⚠️  #{Rainbow('IMPORTANT: Upgrade Recommended').yellow.bold}
-          ─────────────────────────────────────────────────────────────────────────
-          You are using Shakapacker #{version}. React on Rails v15+ works best with
-          Shakapacker 8.0+ for optimal Hot Module Replacement and build performance.
-
-          To upgrade: #{Rainbow('bundle update shakapacker').cyan}
-
-          Learn more: #{Rainbow('https://github.com/shakacode/shakapacker').cyan.underline}
-        WARNING
-      else
-        ""
-      end
-    rescue StandardError
-      # If version detection fails, don't show a warning to avoid noise
-      ""
-    end
   end
-  # rubocop:enable Metrics/ClassLength
 end

data/lib/generators/react_on_rails/install_generator.rb

@@ -57,21 +57,13 @@ module ReactOnRails
       class_option :pro,
                    type: :boolean,
                    default: false,
-                   desc: "Install React on Rails Pro with Node Renderer. " \
-                         "Combined with --rsc, uses --rsc-pro mode. Default: false"
+                   desc: "Install React on Rails Pro with Node Renderer. Default: false"
 
       # --rsc
       class_option :rsc,
                    type: :boolean,
                    default: false,
-                   desc: "Install React Server Components support (includes Pro). " \
-                         "Combined with --pro, uses --rsc-pro mode. Default: false"
-
-      # --rsc-pro
-      class_option :rsc_pro,
-                   type: :boolean,
-                   default: false,
-                   desc: "Install first-class Pro RSC mode with matched Pro/RSC defaults. Default: false"
+                   desc: "Install React Server Components support (includes Pro). Default: false"
 
       # Hidden option: allows tests (and advanced users) to signal that Shakapacker
       # was just installed, triggering force-overwrite of shakapacker.yml with RoR's template.
@@ -142,6 +134,17 @@ module ReactOnRails
         SH
       ].map { |template| template.gsub("\r\n", "\n").strip }.freeze
 
+      # Exact fallback used when the scaffolded CI workflow has to supply a pnpm
+      # 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;
+      # 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"
+      private_constant :CI_PNPM_FALLBACK_VERSION
+
       # Main generator entry point
       #
       # Sets up React on Rails in a Rails application by:
@@ -163,6 +166,8 @@ module ReactOnRails
 
         if installation_prerequisites_met? || options.ignore_warnings?
           invoke_generators
+          add_package_json_scripts
+          add_ci_workflow
           add_bin_scripts
           add_post_install_message
         else
@@ -251,6 +256,172 @@ module ReactOnRails
         setup_js_dependencies
       end
 
+      def add_ci_workflow
+        return if options[:pretend]
+
+        ci_path = ".github/workflows/ci.yml"
+        # Generators may run non-interactively (CI, scripts), so we never want Thor's
+        # `template` to prompt on conflict. Treat any existing workflow as "skip" by
+        # default; users who want to overwrite must pass --force explicitly. --skip
+        # falls into the same path because the desired outcome is identical.
+        if File.exist?(File.join(destination_root, ci_path)) && !options[:force]
+          say_status :skip, "#{ci_path} already exists (pass --force to overwrite)", :yellow
+          return
+        end
+
+        package_json = GeneratorMessages.read_package_json(destination_root)
+        package_manager = GeneratorMessages.detect_package_manager(
+          app_root: destination_root,
+          package_json: package_json
+        )
+        # Scope the lockfile check to the detected manager: a generic "any lockfile exists" check
+        # would emit `cache: "pnpm"` in CI when only `yarn.lock` is on disk, breaking setup-node.
+        has_lockfile = GeneratorMessages.lockfile_for_manager?(package_manager, app_root: destination_root)
+        # `pnpm/action-setup@v4` requires an explicit `version:` unless package.json declares
+        # `packageManager: pnpm@...`. Only ask the question for pnpm projects — other managers
+        # never read this flag — and require a pnpm-specific declaration so an env-override to
+        # pnpm while package.json declares a different manager still gets the version pin.
+        pnpm_version_declared = package_manager == "pnpm" &&
+                                GeneratorMessages.package_manager_declared?(
+                                  app_root: destination_root,
+                                  manager: "pnpm",
+                                  package_json: package_json
+                                )
+        has_active_record = File.exist?(File.join(destination_root, "config/database.yml"))
+        has_rspec = File.exist?(File.join(destination_root, "spec/rails_helper.rb")) ||
+                    File.exist?(File.join(destination_root, "spec/spec_helper.rb"))
+        template("templates/base/base/.github/workflows/ci.yml.tt", ci_path,
+                 { package_manager: package_manager, has_lockfile: has_lockfile,
+                   pnpm_version_declared: pnpm_version_declared,
+                   pnpm_fallback_version: CI_PNPM_FALLBACK_VERSION,
+                   has_active_record: has_active_record, has_rspec: has_rspec })
+        @ci_workflow_generated = true
+      end
+
+      # NODE_ENV=production ensures Shakapacker emits a minified production bundle;
+      # without it the default is "development" which produces an unminified dev bundle
+      # and is almost never what `npm run build` is expected to do.
+      DEFAULT_PACKAGE_JSON_SCRIPTS = {
+        "build" => "NODE_ENV=production bin/shakapacker",
+        "build:test" => "RAILS_ENV=test NODE_ENV=test bin/shakapacker"
+      }.freeze
+      private_constant :DEFAULT_PACKAGE_JSON_SCRIPTS
+
+      def add_package_json_scripts
+        return if options[:pretend]
+
+        package_json_path = File.join(destination_root, "package.json")
+        return unless File.exist?(package_json_path)
+
+        original_text = File.read(package_json_path)
+        existing_scripts = JSON.parse(original_text)["scripts"] || {}
+        scripts_to_add = DEFAULT_PACKAGE_JSON_SCRIPTS.reject { |key, _| existing_scripts.key?(key) }
+
+        if scripts_to_add.empty?
+          say_status :skip, "build scripts already present in package.json", :yellow
+          return
+        end
+
+        updated_text = inject_scripts_into_package_json(original_text, scripts_to_add, existing_scripts)
+        File.write(package_json_path, updated_text)
+        say_status :append, "📝 Added build scripts (#{scripts_to_add.keys.join(', ')}) to package.json", :yellow
+      rescue JSON::ParserError => e
+        GeneratorMessages.add_warning("⚠️  Could not parse package.json to add scripts: #{e.message}")
+      rescue Errno::EACCES, Errno::ENOENT => e
+        GeneratorMessages.add_warning("⚠️  Failed to add build scripts to package.json: #{e.message}")
+      end
+
+      # Inserts new entries into the existing "scripts" object without rewriting the rest of
+      # package.json, so Prettier-formatted files only see the added lines in the diff.
+      # Falls back to a structured rewrite when the "scripts" key is absent or when the
+      # scripts object can't be located unambiguously (e.g. malformed JSON).
+      #
+      # Relies on the JSON invariant that `"scripts": {` cannot appear unescaped inside a
+      # preceding string value — in valid JSON the `"` characters are escaped as `\"`, so
+      # the regex can never falsely match a substring nested in a string literal.
+      def inject_scripts_into_package_json(original_text, scripts_to_add, existing_scripts)
+        opener = original_text.match(/"scripts"\s*:\s*\{/m)
+        return rewrite_package_json_with_scripts(original_text, scripts_to_add, existing_scripts) unless opener
+
+        inner_start = opener.end(0)
+        inner_end = find_matching_brace(original_text, inner_start)
+        return rewrite_package_json_with_scripts(original_text, scripts_to_add, existing_scripts) unless inner_end
+
+        inner = original_text[inner_start...inner_end]
+        # Detect the indent of the "scripts" key wherever it appears (any object position),
+        # not only when it's the first key. Defaults to two spaces so the closing `}` of the
+        # rebuilt scripts block lines up under "scripts" instead of being emitted at column 0.
+        object_indent = original_text[/\n([ \t]*)"scripts"/, 1] || "  "
+        entry_indent = inner[/\n([ \t]+)"/, 1] || "#{object_indent}  "
+        new_entries = scripts_to_add.map { |key, value| %(#{entry_indent}#{key.to_json}: #{value.to_json}) }
+
+        rebuilt_inner =
+          if existing_scripts.any?
+            trimmed = inner.sub(/\s*\z/, "")
+            separator = trimmed.end_with?(",") ? "" : ","
+            "#{trimmed}#{separator}\n#{new_entries.join(",\n")}\n#{object_indent}"
+          else
+            "\n#{new_entries.join(",\n")}\n#{object_indent}"
+          end
+
+        "#{original_text[0...opener.begin(0)]}\"scripts\": {#{rebuilt_inner}}#{original_text[(inner_end + 1)..]}"
+      end
+
+      # Returns the index of the `}` that closes the `{` whose body starts at `start`,
+      # or nil if the object is unterminated. Tracks brace depth while stepping through
+      # JSON string literals so `}` characters inside script values (e.g.
+      # "lint": "eslint '{src,test}/**/*.js'") do not match a non-matching brace.
+      def find_matching_brace(text, start)
+        depth = 1
+        i = start
+        while i < text.length
+          case text[i]
+          when '"'
+            i = skip_json_string(text, i)
+            return nil unless i
+          when "{"
+            depth += 1
+            i += 1
+          when "}"
+            depth -= 1
+            return i if depth.zero?
+
+            i += 1
+          else
+            i += 1
+          end
+        end
+        nil
+      end
+
+      # Given an index pointing at the opening `"` of a JSON string, returns the index
+      # just past the closing `"`. Honours `\"` and `\\` escapes. Returns nil if the
+      # string is unterminated.
+      def skip_json_string(text, start)
+        i = start + 1
+        while i < text.length
+          case text[i]
+          when "\\"
+            i += 2
+          when '"'
+            return i + 1
+          else
+            i += 1
+          end
+        end
+        nil
+      end
+
+      # Used only when the "scripts" key is missing entirely or the regex can't locate it.
+      # This path does reformat the whole file, but it's rare — a Rails package.json with
+      # no scripts key at all is unusual.
+      def rewrite_package_json_with_scripts(original_text, scripts_to_add, existing_scripts)
+        content = JSON.parse(original_text)
+        content["scripts"] = existing_scripts.merge(scripts_to_add)
+        indent = original_text[/\A\{\n(\s+)/, 1] || "  "
+        "#{JSON.pretty_generate(content, indent: indent)}\n"
+      end
+
       def ensure_jsx_in_js_compatibility
         return if options[:pretend]
         return unless using_swc?
@@ -273,6 +444,8 @@ module ReactOnRails
       # js(.coffee) are not checked by this method, but instead produce warning messages
       # and allow the build to continue
       def installation_prerequisites_met?
+        warn_if_unsupported_env_package_manager
+
         # Non-blocking: warn about dirty worktree but don't prevent installation.
         # A clean tree makes the generator diff easier to review, but blocking would
         # be too strict for a generator that creates many new files.
@@ -298,10 +471,21 @@ module ReactOnRails
         !(missing_node? || missing_package_manager? || (!has_worktree_issues && missing_pro_gem?))
       end
 
-      def missing_node?
-        node_missing = ReactOnRails::Utils.running_on_windows? ? `where node`.blank? : `which node`.blank?
+      def warn_if_unsupported_env_package_manager
+        env_value = ENV.fetch("REACT_ON_RAILS_PACKAGE_MANAGER", nil)&.strip
+        return if env_value.nil? || env_value.empty?
+        return if GeneratorMessages.supported_package_manager?(env_value.downcase)
 
-        if node_missing
+        supported = GeneratorMessages::SUPPORTED_PACKAGE_MANAGERS.join(", ")
+        GeneratorMessages.add_warning(<<~MSG.strip)
+          ⚠️  REACT_ON_RAILS_PACKAGE_MANAGER='#{env_value}' is not a supported package manager.
+          Supported values: #{supported}.
+          Falling through to package.json / lockfile / npm-default detection.
+        MSG
+      end
+
+      def missing_node?
+        unless ReactOnRails::Utils.command_available?("node")
           error = <<~MSG.strip
             🚫 Node.js is required but not found on your system.
 
@@ -409,7 +593,8 @@ module ReactOnRails
           return
         end
 
-        # Make these and only these files executable
+        # Make these and only these files executable. Use destination_root so
+        # chmod remains correct even if an earlier generator step changed Dir.pwd.
         files_to_become_executable = bin_scripts_to_chmod(template_bin_path)
         File.chmod(0o755, *files_to_become_executable)
       end
@@ -444,7 +629,7 @@ module ReactOnRails
       def bin_scripts_to_chmod(template_bin_path)
         files = Dir.children(template_bin_path).reject { |filename| filename == "dev" }
         files << "dev" unless preserve_existing_bin_dev?
-        files.map { |filename| "bin/#{filename}" }
+        files.map { |filename| File.join(destination_root, "bin/#{filename}") }
       end
 
       def default_bin_dev_route
@@ -487,9 +672,11 @@ module ReactOnRails
                                      pro: use_pro?,
                                      rsc: use_rsc?,
                                      shakapacker_just_installed: shakapacker_just_installed?,
-                                     landing_page: options.new_app? && new_app_root_route_available?
+                                     landing_page: options.new_app? && new_app_root_route_available?,
+                                     ci_workflow_generated: @ci_workflow_generated == true,
+                                     app_root: destination_root
                                    ))
-        GeneratorMessages.add_info(rsc_pro_verification_message) if use_rsc_pro_mode?
+        GeneratorMessages.add_info(rsc_verification_message) if use_rsc?
       end
 
       def shakapacker_setup_incomplete?
@@ -503,9 +690,7 @@ module ReactOnRails
         flags << "--typescript" if options.typescript?
         flags << "--rspack" if options.rspack?
 
-        if use_rsc_pro_mode?
-          flags << "--rsc-pro"
-        elsif options.rsc?
+        if options.rsc?
           flags << "--rsc"
         elsif options.pro?
           flags << "--pro"
@@ -514,7 +699,7 @@ module ReactOnRails
         ["rails generate react_on_rails:install", *flags].join(" ")
       end
 
-      def rsc_pro_verification_message
+      def rsc_verification_message
         <<~MSG
 
           🔎 RSC Pro Verification:
@@ -543,7 +728,7 @@ module ReactOnRails
       end
 
       def incomplete_installation_message
-        package_install_step = "#{GeneratorMessages.detect_package_manager} install"
+        package_install_step = "#{GeneratorMessages.detect_package_manager(app_root: destination_root)} install"
 
         <<~MSG
 
@@ -589,8 +774,7 @@ module ReactOnRails
       end
 
       def cli_exists?(command)
-        which_command = ReactOnRails::Utils.running_on_windows? ? "where" : "which"
-        system(which_command, command, out: File::NULL, err: File::NULL)
+        ReactOnRails::Utils.command_available?(command)
       end
 
       def normalize_bin_dev_content(content)
@@ -801,13 +985,19 @@ module ReactOnRails
       end
 
       def missing_package_manager?
-        package_managers = %w[npm pnpm yarn bun]
-        missing = package_managers.none? { |pm| cli_exists?(pm) }
+        selected, source = GeneratorMessages.detect_package_manager_with_source(app_root: destination_root)
+        return false if GeneratorMessages.package_manager_executable_available?(selected)
+
+        available_package_managers = GeneratorMessages::SUPPORTED_PACKAGE_MANAGERS.select do |pm|
+          pm != selected && GeneratorMessages.package_manager_executable_available?(pm)
+        end
 
-        if missing
+        if available_package_managers.empty?
           error = <<~MSG.strip
             🚫 No JavaScript package manager found on your system.
 
+            #{package_manager_source_description(selected, source)}
+
             React on Rails requires a JavaScript package manager to install dependencies.
             Please install one of the following:
 
@@ -822,7 +1012,32 @@ module ReactOnRails
           return true
         end
 
-        false
+        action_separator = %i[default env].include?(source) ? " or " : ", update the source above, or "
+        error = <<~MSG.strip
+          🚫 JavaScript package manager '#{selected}' was selected, but the command was not found.
+
+          #{package_manager_source_description(selected, source)}
+          Install '#{selected}'#{action_separator}set REACT_ON_RAILS_PACKAGE_MANAGER
+          to one of the available package managers: #{available_package_managers.join(', ')}.
+        MSG
+        GeneratorMessages.add_error(error)
+        true
+      end
+
+      def package_manager_source_description(selected, source)
+        case source
+        when :env
+          "Selected via the REACT_ON_RAILS_PACKAGE_MANAGER environment variable."
+        when :package_json
+          "Selected via the `packageManager` field in package.json."
+        when :lockfile
+          lockfile = GeneratorMessages.lockfile_filename_for(selected, app_root: destination_root)
+          lockfile ? "Selected via the #{lockfile} lockfile on disk." : "Selected via a lockfile on disk."
+        when :default
+          "Selected via the npm default fallback (no env var, packageManager field, or lockfile detected)."
+        else
+          raise ArgumentError, "Unknown package manager source: #{source.inspect}"
+        end
       end
 
       def jsx_in_js_files_present?

data/lib/generators/react_on_rails/js_dependency_manager.rb

@@ -91,16 +91,19 @@ module ReactOnRails
       ].freeze
 
       # Rspack core dependencies (only installed when --rspack flag is used)
+      # @rspack/core uses ^2.0.0-0 (with -0 prerelease suffix) to include RC/beta prereleases
+      # of 2.0.0 until the stable 2.0.0 release lands.
       RSPACK_DEPENDENCIES = %w[
-        @rspack/core@^1.0.0
+        @rspack/core@^2.0.0-0
         rspack-manifest-plugin@^5.0.0
       ].freeze
 
       # Rspack development dependencies for hot reloading
       # react-refresh is pre-1.0, so left bare (see pinning note above).
+      # @rspack/cli uses ^2.0.0-0 to match @rspack/core's prerelease range.
       RSPACK_DEV_DEPENDENCIES = %w[
-        @rspack/cli@^1.0.0
-        @rspack/plugin-react-refresh@^1.0.0
+        @rspack/cli@^2.0.0-0
+        @rspack/plugin-react-refresh@^2.0.0
         react-refresh
       ].freeze
 
@@ -557,7 +560,7 @@ module ReactOnRails
       end
 
       def fallback_package_manager
-        package_manager = GeneratorMessages.detect_package_manager
+        package_manager = GeneratorMessages.detect_package_manager(app_root: destination_root)
         return package_manager if GeneratorMessages.supported_package_manager?(package_manager)
 
         "npm"

data/lib/generators/react_on_rails/pro/USAGE

@@ -6,7 +6,7 @@ Example:
 
     This will add:
     - Pro initializer (config/initializers/react_on_rails_pro.rb)
-    - Node renderer (client/node-renderer.js)
+    - Node renderer (renderer/node-renderer.js)
     - Node renderer process to Procfile.dev
 
 Modifies: