Module: GeneratorHelper

Included in:
ReactOnRails::Generators::BaseGenerator, ReactOnRails::Generators::DevTestsGenerator, ReactOnRails::Generators::InstallGenerator, ReactOnRails::Generators::ProGenerator, ReactOnRails::Generators::ReactNoReduxGenerator, ReactOnRails::Generators::ReactWithReduxGenerator, ReactOnRails::Generators::RscGenerator
Defined in:
lib/generators/react_on_rails/generator_helper.rb

Instance Method Summary collapse

Instance Method Details

#add_documentation_reference(message, source) ⇒ Object 



57
58
59
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 57

def add_documentation_reference(message, source)
  "#{message} \n#{source}"
end

#add_npm_dependencies(packages, dev: false) ⇒ Object

Safe wrapper for package_json operations



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 26

def add_npm_dependencies(packages, dev: false)
  pj = package_json
  return false unless pj

  begin
    result = if dev
               pj.manager.add(packages, type: :dev, exact: true)
             else
               pj.manager.add(packages, exact: true)
             end
    # package_json#add can return nil for successful side-effect operations.
    result != false
  rescue StandardError => e
    say_status :warning, "Could not add packages via package_json gem: #{e.message}", :yellow
    say_status :warning, "Will fall back to direct npm commands.", :yellow
    false
  end
end

#component_extension(options) ⇒ Object 



70
71
72
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 70

def component_extension(options)
  options.typescript? ? "tsx" : "jsx"
end

#destination_config_path(path) ⇒ String

Remap a config path from config/webpack/ to config/rspack/ when using rspack. Source templates always live under config/webpack/ (template names are stable); this method handles the destination remapping.

Parameters:

  • path (String) —

    relative path, e.g. “config/webpack/serverWebpackConfig.js”

Returns:

  • (String) —

    remapped path when rspack, unchanged otherwise



145
146
147
148
149
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 145

def destination_config_path(path)
  return path unless using_rspack?

  path.sub(%r{\Aconfig/webpack/}, "config/rspack/")
end

#detect_react_version ⇒ String?

Detect the installed React version from package.json Uses VERSION_PARTS_REGEX pattern from VersionChecker for consistency

Returns:

  • (String, nil) —

    React version string (e.g., “19.0.3”) or nil if not found/parseable



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 155

def detect_react_version
  pj = package_json
  return nil unless pj

  dependencies = pj.fetch("dependencies", {})
  react_version = dependencies["react"]
  return nil unless react_version

  # Skip non-version strings (workspace:*, file:, link:, http://, etc.)
  return nil if react_version.include?("/") || react_version.start_with?("workspace:")

  # Extract version using the same regex pattern as VersionChecker
  # Handles: "19.0.3", "^19.0.3", "~19.0.3", "19.0.3-beta.1", etc.
  match = react_version.match(/(\d+)\.(\d+)\.(\d+)(?:[-.]([0-9A-Za-z.-]+))?/)
  return nil unless match

  # Return the matched version (without pre-release suffix for comparison)
  "#{match[1]}.#{match[2]}.#{match[3]}"
rescue StandardError
  nil
end

#gem_in_lockfile?(gem_name) ⇒ Boolean

Check if a gem is present in Gemfile.lock Always checks the target app’s Gemfile.lock, not inherited BUNDLE_GEMFILE See: github.com/shakacode/react_on_rails/issues/2287

Parameters:

  • gem_name (String) —

    Name of the gem to check

Returns:

  • (Boolean) —

    true if the gem is in Gemfile.lock



80
81
82
83
84
85
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 80

def gem_in_lockfile?(gem_name)
  File.file?("Gemfile.lock") &&
    File.foreach("Gemfile.lock").any? { |line| line.match?(/^\s{4}#{Regexp.escape(gem_name)}\s\(/) }
rescue StandardError
  false
end

#mark_pro_gem_installed! ⇒ Object

TODO: CQS smell: mark_pro_gem_installed! makes pro_gem_installed? return true before install. See #3303.



101
102
103
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 101

def mark_pro_gem_installed!
  @pro_gem_installed = true
end

#package_json ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 6

def package_json
  # Lazy load package_json gem only when actually needed for dependency management

  require "package_json" unless defined?(PackageJson)
  @package_json ||= PackageJson.read
rescue LoadError
  unless @package_json_unavailable_warned
    say_status :warning, "package_json gem not available. This is expected before Shakapacker installation.", :yellow
    say_status :warning, "Dependencies will be installed using the default package manager after Shakapacker setup.",
               :yellow
    @package_json_unavailable_warned = true
  end
  nil
rescue StandardError => e
  say_status :warning, "Could not read package.json: #{e.message}", :yellow
  say_status :warning, "This is normal before Shakapacker creates the package.json file.", :yellow
  nil
end

#print_generator_messages ⇒ Object 



61
62
63
64
65
66
67
68
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 61

def print_generator_messages
  # GeneratorMessages stores pre-colored strings, so we strip ANSI manually for --no-color output.
  no_color = !shell.is_a?(Thor::Shell::Color)
  GeneratorMessages.messages.each do |message|
    say(no_color ? message.to_s.gsub(/\e\[[0-9;]*m/, "") : message)
    say "" # Blank line after each message for readability
  end
end

#pro_gem_installed? ⇒ Boolean

Check if React on Rails Pro gem is installed

Detection priority:

  1. Gem.loaded_specs - gem is loaded in current Ruby process (most reliable)

  2. Gemfile.lock - gem is resolved and installed

Returns:

  • (Boolean) —

    true if react_on_rails_pro gem is installed



94
95
96
97
98
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 94

def pro_gem_installed?
  return @pro_gem_installed if defined?(@pro_gem_installed)

  @pro_gem_installed = Gem.loaded_specs.key?("react_on_rails_pro") || gem_in_lockfile?("react_on_rails_pro")
end

#resolve_server_client_or_both_path ⇒ String?

Resolve the path to ServerClientOrBoth.js, handling the legacy name. Old installs may still use generateWebpackConfigs.js; this renames it and updates references in environment configs so downstream transforms can rely on the canonical name.

Returns:

  • (String, nil) —

    relative config path, or nil if neither file exists



233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 233

def resolve_server_client_or_both_path
  new_path = destination_config_path("config/webpack/ServerClientOrBoth.js")
  old_path = destination_config_path("config/webpack/generateWebpackConfigs.js")
  full_new = File.join(destination_root, new_path)
  full_old = File.join(destination_root, old_path)

  if File.exist?(full_new)
    new_path
  elsif File.exist?(full_old)
    FileUtils.mv(full_old, full_new)
    %w[development.js production.js test.js].each do |env_file|
      env_path = destination_config_path("config/webpack/#{env_file}")
      if File.exist?(File.join(destination_root, env_path))
        gsub_file(env_path, /generateWebpackConfigs/, "ServerClientOrBoth")
      end
    end
    new_path
  end
end

#root_route_present?(routes_path = File.join(destination_root, "config/routes.rb")) ⇒ Boolean

Detect whether config/routes.rb defines any non-commented root route.

Parameters:

  • routes_path (String) (defaults to: File.join(destination_root, "config/routes.rb")) —

    absolute path to routes.rb

Returns:

  • (Boolean) —

    true when a root route exists



49
50
51
52
53
54
55
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 49

def root_route_present?(routes_path = File.join(destination_root, "config/routes.rb"))
  return false unless File.file?(routes_path)

  File.foreach(routes_path).any? do |line|
    !line.match?(/^\s*#/) && line.match?(/^\s*root\b/)
  end
end

#shakapacker_version_9_or_higher? ⇒ Boolean

Note:

Default behavior: Returns true when Shakapacker is not yet installed Rationale: During fresh installations, we optimistically assume users will install the latest Shakapacker version. This ensures new projects get best-practice configs. If users later install an older version, the generated webpack config includes fallback logic (e.g., ‘config.privateOutputPath || hardcodedPath`) that prevents breakage, and validation warnings guide them to fix any misconfigurations.

Check if Shakapacker 9.0 or higher is available Returns true if Shakapacker >= 9.0, false otherwise

This method is used during code generation to determine which configuration patterns to use in generated files (e.g., config.privateOutputPath vs hardcoded paths).

Returns:

  • (Boolean) —

    true if Shakapacker 9.0+ is available or likely to be installed



191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 191

def shakapacker_version_9_or_higher?
  return @shakapacker_version_9_or_higher if defined?(@shakapacker_version_9_or_higher)

  @shakapacker_version_9_or_higher = begin
    # If Shakapacker is not available yet (fresh install), default to true
    # since we're likely installing the latest version
    return true unless defined?(ReactOnRails::PackerUtils)

    ReactOnRails::PackerUtils.shakapacker_version_requirement_met?("9.0.0")
  rescue StandardError
    # If we can't determine version, assume latest
    true
  end
end

#use_pro? ⇒ Boolean

Check if Pro features should be enabled. Returns true if –pro or –rsc is set (RSC implies Pro).

Returns:

  • (Boolean) —

    true if Pro setup should be included



109
110
111
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 109

def use_pro?
  options[:pro] || options[:rsc]
end

#use_rsc? ⇒ Boolean

Check if RSC (React Server Components) should be enabled. Returns true if –rsc is set.

Returns:

  • (Boolean) —

    true if RSC setup should be included



117
118
119
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 117

def use_rsc?
  options[:rsc]
end

#using_rspack? ⇒ Boolean

Determine if the project is using rspack as the bundler.

Detection priority:

  1. Explicit –rspack option (most reliable during fresh installs)

  2. config/shakapacker.yml assets_bundler setting (for standalone generators like ‘rails g react_on_rails:rsc` on an existing rspack project)

Returns:

  • (Boolean) —

    true if rspack is the configured bundler



129
130
131
132
133
134
135
136
137
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 129

def using_rspack?
  return @using_rspack if defined?(@using_rspack)

  # options.key?(:rspack) is true when the generator declares --rspack (e.g. InstallGenerator),
  # false when it does not (e.g. RscGenerator, ProGenerator). Using .key? rather than .nil?
  # check on the value makes the intent explicit and avoids relying on Thor returning nil for
  # undeclared options.
  @using_rspack = options.key?(:rspack) ? options[:rspack] : rspack_configured_in_project?
end

#using_swc? ⇒ Boolean

Note:

This method is used to determine whether to install SWC dependencies (@swc/core, swc-loader) instead of Babel dependencies during generation.

Note:

Caching: The result is memoized for the lifetime of the generator instance. If shakapacker.yml changes during generator execution (unlikely), the cached value will not update. This is acceptable since generators run quickly.

Check if SWC is configured as the JavaScript transpiler in shakapacker.yml

Detection logic:

  1. If shakapacker.yml exists and specifies javascript_transpiler: parse it

  2. For Shakapacker 9.3.0+, SWC is the default if not specified

  3. Returns true for fresh installations (SWC is recommended default)

Returns:

  • (Boolean) —

    true if SWC is configured or should be used by default



221
222
223
224
225
 
# File 'lib/generators/react_on_rails/generator_helper.rb', line 221

def using_swc?
  return @using_swc if defined?(@using_swc)

  @using_swc = detect_swc_configuration
end