react_on_rails 16.1.2 → 16.2.0

data/rakelib/shakapacker_examples.rake

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+# Defines tasks related to generating example apps using the gem's generator.
+# Allows us to create and test apps generated using a wide range of options.
+#
+# Also see example_type.rb
+
+require "yaml"
+require "rails/version"
+require "pathname"
+require "json"
+
+require_relative "example_type"
+require_relative "task_helpers"
+
+namespace :shakapacker_examples do # rubocop:disable Metrics/BlockLength
+  include ReactOnRails::TaskHelpers
+
+  # Updates React-related dependencies to a specific version
+  def update_react_dependencies(deps, react_version)
+    return unless deps
+
+    deps["react"] = react_version
+    deps["react-dom"] = react_version
+  end
+
+  # Updates Shakapacker to minimum supported version in either dependencies or devDependencies
+  def update_shakapacker_dependency(deps, dev_deps)
+    if dev_deps&.key?("shakapacker")
+      dev_deps["shakapacker"] = ExampleType::MINIMUM_SHAKAPACKER_VERSION
+    elsif deps&.key?("shakapacker")
+      deps["shakapacker"] = ExampleType::MINIMUM_SHAKAPACKER_VERSION
+    end
+  end
+
+  # Updates dependencies in package.json to use specific React version
+  def update_package_json_for_react_version(package_json_path, react_version)
+    return unless File.exist?(package_json_path)
+
+    begin
+      package_json = JSON.parse(File.read(package_json_path))
+    rescue JSON::ParserError => e
+      puts "  ERROR: Failed to parse #{package_json_path}: #{e.message}"
+      raise
+    end
+
+    deps = package_json["dependencies"]
+    dev_deps = package_json["devDependencies"]
+
+    update_react_dependencies(deps, react_version)
+    # Shakapacker 8.2.0 requires webpack-assets-manifest ^5.x (v6.x uses ESM and breaks)
+    # Always add this explicitly since the transitive dependency from shakapacker may be v6.x
+    dev_deps["webpack-assets-manifest"] = "^5.0.6" if dev_deps
+    # Shakapacker 8.2.0 requires babel-loader to be explicitly installed as a devDependency
+    # (in 9.x this requirement was relaxed or the package structure changed)
+    dev_deps["babel-loader"] = "^9.1.3" if dev_deps
+    # @babel/plugin-transform-runtime is required by the default babel config but not
+    # automatically included as a dependency in older Shakapacker versions
+    dev_deps["@babel/plugin-transform-runtime"] = "^7.24.0" if dev_deps
+    update_shakapacker_dependency(deps, dev_deps)
+
+    # Add npm overrides to force specific React version, preventing yalc-linked
+    # react-on-rails from pulling in React 19 as a transitive dependency
+    package_json["overrides"] = {
+      "react" => react_version,
+      "react-dom" => react_version
+    }
+
+    File.write(package_json_path, "#{JSON.pretty_generate(package_json)}\n")
+  end
+
+  # Updates Gemfile to pin shakapacker to minimum version
+  # (must match the npm package version exactly)
+  def update_gemfile_versions(gemfile_path)
+    return unless File.exist?(gemfile_path)
+
+    gemfile_content = File.read(gemfile_path)
+    # Replace any shakapacker gem line with exact version pin
+    # Handle both single-line: gem 'shakapacker', '>= 8.2.0'
+    # And multi-line declarations:
+    #   gem 'shakapacker',
+    #       '>= 8.2.0'
+    gemfile_content = gemfile_content.gsub(
+      /gem ['"]shakapacker['"][^\n]*(?:\n\s+[^g\n][^\n]*)*$/m,
+      "gem 'shakapacker', '#{ExampleType::MINIMUM_SHAKAPACKER_VERSION}'"
+    )
+    File.write(gemfile_path, gemfile_content)
+  end
+
+  # Updates package.json and Gemfile to use specific React version for compatibility testing
+  def apply_react_version(dir, react_version)
+    update_package_json_for_react_version(File.join(dir, "package.json"), react_version)
+    update_gemfile_versions(File.join(dir, "Gemfile"))
+
+    puts "  Updated package.json for compatibility testing:"
+    puts "    React: #{react_version}"
+    puts "    Shakapacker: #{ExampleType::MINIMUM_SHAKAPACKER_VERSION}"
+  end
+
+  # Define tasks for each example type
+  ExampleType.all[:shakapacker_examples].each do |example_type| # rubocop:disable Metrics/BlockLength
+    relative_gem_root = Pathname(gem_root).relative_path_from(Pathname(example_type.dir))
+    # CLOBBER
+    desc "Clobbers (deletes) #{example_type.name_pretty}"
+    task example_type.clobber_task_name_short do
+      rm_rf(example_type.dir)
+    end
+
+    # GENERATE
+    desc "Generates #{example_type.name_pretty}"
+    task example_type.gen_task_name_short => example_type.clobber_task_name do
+      puts "Running shakapacker_examples:#{example_type.gen_task_name_short}"
+      mkdir_p(example_type.dir)
+      sh_in_dir(examples_dir, "rails new #{example_type.name} #{example_type.rails_options} --skip-javascript")
+      sh_in_dir(example_type.dir, "touch .gitignore")
+      sh_in_dir(example_type.dir,
+                "echo \"gem 'react_on_rails', path: '#{relative_gem_root}'\" >> #{example_type.gemfile}")
+      # Pin to 9.4.0 to ensure gem and npm package versions match
+      # (shakapacker 9.5.0 gem was released but npm package version detection has issues)
+      sh_in_dir(example_type.dir, "echo \"gem 'shakapacker', '9.4.0'\" >> #{example_type.gemfile}")
+      bundle_install_in(example_type.dir)
+      sh_in_dir(example_type.dir, "rake shakapacker:install")
+      # Skip validation when running generators on example apps during development.
+      # The generator validates that certain config options exist in the initializer,
+      # but during example generation, we're often testing against the current gem
+      # codebase which may have new config options not yet in the released version.
+      # This allows examples to be generated without validation errors while still
+      # testing the generator functionality.
+      generator_commands = example_type.generator_shell_commands.map do |cmd|
+        "REACT_ON_RAILS_SKIP_VALIDATION=true #{cmd}"
+      end
+      sh_in_dir(example_type.dir, generator_commands)
+      # Re-run bundle install since dev_tests generator adds rspec-rails and coveralls to Gemfile
+      bundle_install_in(example_type.dir)
+
+      # Apply specific React version for compatibility testing examples
+      if example_type.pinned_react_version?
+        apply_react_version(example_type.dir, example_type.react_version_string)
+        # Re-run bundle install since Gemfile was updated with pinned shakapacker version
+        bundle_install_in(example_type.dir)
+        # Run npm install BEFORE shakapacker:binstubs to ensure the npm shakapacker version
+        # matches the gem version. The binstubs task loads the Rails environment which
+        # validates version matching between gem and npm package.
+        # Use --legacy-peer-deps to avoid peer dependency conflicts when yalc-linked
+        # react-on-rails expects newer React versions
+        sh_in_dir(example_type.dir, "npm install --legacy-peer-deps")
+        # Regenerate Shakapacker binstubs after downgrading from 9.x to 8.2.x
+        # The binstub format may differ between major versions
+        unbundled_sh_in_dir(example_type.dir, "bundle exec rake shakapacker:binstubs")
+      else
+        sh_in_dir(example_type.dir, "npm install")
+      end
+      # Generate the component packs after running the generator to ensure all
+      # auto-bundled components have corresponding pack files created.
+      # Use unbundled_sh_in_dir to ensure we're using the generated app's Gemfile
+      # and gem versions, not the parent workspace's bundle context.
+      unbundled_sh_in_dir(example_type.dir, "bundle exec rake react_on_rails:generate_packs")
+    end
+  end
+
+  desc "Clobbers (deletes) all example apps"
+  task :clobber do
+    rm_rf(examples_dir)
+  end
+
+  desc "Generates all example apps"
+  task gen_all: ExampleType.all[:shakapacker_examples].map(&:gen_task_name)
+end
+
+desc "Generates all example apps. Run `rake -D examples` to see all available options"
+task shakapacker_examples: ["shakapacker_examples:gen_all"]

data/rakelib/task_helpers.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "English"
+
+module ReactOnRails
+  module TaskHelpers
+    # Returns the root folder of the monorepo
+    def monorepo_root
+      File.expand_path("../..", __dir__)
+    end
+
+    # Returns the root folder of the react_on_rails gem
+    def gem_root
+      File.join(monorepo_root, "react_on_rails")
+    end
+
+    # Returns the folder where examples are located
+    def examples_dir
+      File.join(monorepo_root, "gen-examples", "examples")
+    end
+
+    def dummy_app_dir
+      File.join(gem_root, "spec/dummy")
+    end
+
+    # Executes a string or an array of strings in a shell in the given directory in an unbundled environment
+    def sh_in_dir(dir, *shell_commands)
+      shell_commands.flatten.each { |shell_command| sh %(cd #{dir} && #{shell_command.strip}) }
+    end
+
+    # Executes a string or an array of strings in a shell in the given directory
+    def unbundled_sh_in_dir(dir, *shell_commands)
+      Dir.chdir(dir) do
+        # Without `with_unbundled_env`, running bundle in the child directories won't correctly
+        # update the Gemfile.lock
+        Bundler.with_unbundled_env do
+          shell_commands.flatten.each do |shell_command|
+            sh(shell_command.strip)
+          end
+        end
+      end
+    end
+
+    def bundle_install_in(dir)
+      required_version = detect_bundler_ruby_version(dir)
+
+      if required_version && required_version != RUBY_VERSION
+        puts "  Switching Ruby version: #{RUBY_VERSION} → #{required_version}"
+        # Run version switch and bundle install in the same shell context
+        bundle_install_with_ruby_version(dir, required_version)
+      else
+        unbundled_sh_in_dir(dir, "bundle install")
+      end
+    end
+
+    private
+
+    # Runs bundle install with the specified Ruby version in the same shell context
+    def bundle_install_with_ruby_version(dir, version)
+      version_manager = ENV.fetch("RUBY_VERSION_MANAGER", "rvm")
+
+      command = case version_manager
+                when "rvm"
+                  "rvm #{version} do bundle install"
+                when "rbenv"
+                  "RBENV_VERSION=#{version} bundle install"
+                when "asdf"
+                  "asdf shell ruby #{version} && bundle install"
+                else
+                  # TODO: add support for chruby
+                  puts "  ⚠️  Unknown RUBY_VERSION_MANAGER: #{version_manager}"
+                  puts "  Supported values: rvm, rbenv, asdf"
+                  raise "Ruby version #{version} required. Current: #{RUBY_VERSION}"
+                end
+
+      unbundled_sh_in_dir(dir, command)
+    rescue StandardError => e
+      puts "  ⚠️  Failed to switch Ruby version and run bundle install: #{e.message}"
+      puts "  Please manually switch to Ruby #{version} and try again"
+      raise
+    end
+
+    # Detects the required Ruby version using Bundler
+    def detect_bundler_ruby_version(dir)
+      output = nil
+      exit_status = nil
+
+      # Run in unbundled environment to avoid conflicts with parent Bundler context
+      Bundler.with_unbundled_env do
+        Dir.chdir(dir) do
+          output = `bundle platform --ruby 2>&1`
+          exit_status = $CHILD_STATUS.exitstatus
+        end
+      end
+
+      unless exit_status.zero?
+        puts "  ⚠️  Failed to detect Ruby version in #{dir}"
+        puts "  Error: #{output.strip}" unless output.strip.empty?
+        return nil
+      end
+
+      # Parse "ruby 3.3.7" or "ruby 3.3.7-rc1" or "ruby 3.4.0-preview1"
+      # Regex matches: digits.dots followed by optional -prerelease
+      match = output.strip.match(/ruby\s+([\d.]+(?:-[a-zA-Z0-9.]+)?)/)
+      match ? match[1] : nil
+    rescue StandardError => e
+      puts "  ⚠️  Error detecting Ruby version: #{e.message}"
+      nil
+    end
+
+    public
+
+    def bundle_install_in_no_turbolinks(dir)
+      sh_in_dir(dir, "DISABLE_TURBOLINKS=TRUE bundle install")
+    end
+
+    # Runs bundle exec using that directory's Gemfile
+    def bundle_exec(dir: nil, args: nil, env_vars: "")
+      sh_in_dir(dir, "#{env_vars} bundle exec #{args}")
+    end
+
+    def generators_source_dir
+      File.join(gem_root, "lib/generators/react_on_rails")
+    end
+
+    def symbolize_keys(hash)
+      hash.each_with_object({}) do |(key, value), new_hash|
+        new_key = key.is_a?(String) ? key.to_sym : key
+        new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
+        new_hash[new_key] = new_value
+      end
+    end
+  end
+end

data/rakelib/update_changelog.rake

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "English"
+require "bundler"
+require_relative "task_helpers"
+
+CLAUDE_CODE_TIP = <<~TIP
+  ┌─────────────────────────────────────────────────────────────────────────────┐
+  │ TIP: This task only adds version headers and links, not changelog entries. │
+  │ For full automation, run /update-changelog in Claude Code.                 │
+  │                                                                             │
+  │ After running this task, manually add entries under the new header:        │
+  │   #### Fixed / #### Added / #### Changed / etc.                            │
+  └─────────────────────────────────────────────────────────────────────────────┘
+TIP
+
+# Update the compare links at the bottom of the changelog
+# version: version string without 'v' prefix (e.g., "16.2.0.beta.20")
+# anchor: markdown anchor (e.g., "[16.2.0.beta.20]")
+def update_changelog_links(changelog, version, anchor)
+  compare_link_prefix = "https://github.com/shakacode/react_on_rails/compare"
+  match_data = %r{#{compare_link_prefix}/(?<prev_version>.*)\.\.\.master}.match(changelog)
+  return unless match_data
+
+  prev_version = match_data[:prev_version]
+  new_unreleased_link = "#{compare_link_prefix}/#{version}...master"
+  new_version_link = "#{anchor}: #{compare_link_prefix}/#{prev_version}...#{version}"
+  changelog.sub!(match_data[0], "#{new_unreleased_link}\n#{new_version_link}")
+end
+
+# Insert version header into changelog, returns true if successful
+def insert_version_header(changelog, anchor, tag_date)
+  # Try inserting right after ### [Unreleased] first
+  return true if changelog.sub!("### [Unreleased]", "### [Unreleased]\n\n### #{anchor} - #{tag_date}")
+
+  # Fallback: insert after "Changes since the last non-beta release."
+  return true if changelog.sub!("Changes since the last non-beta release.", "\\0\n\n### #{anchor} - #{tag_date}")
+
+  false
+end
+
+desc "Updates CHANGELOG.md inserting headers for the new version (headers only, not content).
+Argument: Git tag. Defaults to the latest tag.
+TIP: Use /update-changelog in Claude Code for full automation."
+
+task :update_changelog, %i[tag] do |_, args|
+  puts CLAUDE_CODE_TIP
+
+  # Git tags use 'v' prefix (e.g., v16.2.0), but CHANGELOG uses versions without it
+  git_tag = args[:tag] || `git describe --tags --abbrev=0`.strip
+  changelog_version = git_tag.delete_prefix("v")
+  anchor = "[#{changelog_version}]"
+  changelog = File.read("CHANGELOG.md")
+
+  if changelog.include?(anchor)
+    puts "Tag #{git_tag} is already documented in CHANGELOG.md"
+    next
+  end
+
+  tag_date = `git show -s --format=%cs #{git_tag} 2>&1`.split("\n").last&.strip
+  abort("Failed to find tag #{git_tag}") unless $CHILD_STATUS.success? && tag_date
+
+  unless insert_version_header(changelog, anchor, tag_date)
+    abort("Failed to insert version header: could not find '### [Unreleased]' " \
+          "or 'Changes since the last non-beta release.' in CHANGELOG.md")
+  end
+
+  update_changelog_links(changelog, changelog_version, anchor)
+
+  File.write("CHANGELOG.md", changelog)
+  puts "Updated CHANGELOG.md with version header for #{git_tag}"
+  puts "NOTE: You still need to write the changelog entries manually."
+end

data/react_on_rails.gemspec

@@ -16,9 +16,10 @@ Gem::Specification.new do |s|
   s.homepage      = "https://github.com/shakacode/react_on_rails"
   s.license       = "MIT"
 
-  s.files = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(docs|test|spec|features|gen-examples|tmp|node_modules|node_package|coverage|rakelib|script)/}) ||
-      f.match(%r{^(jest\.config\.js|book\.json|package\.json|package-scripts\.yml|yarn\.lock|\..*)})
+  s.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(spec|tmp)/})
+    end
   end
   s.bindir        = "exe"
   s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }

data/sig/README.md

@@ -0,0 +1,52 @@
+# RBS Type Signatures
+
+This directory contains RBS (Ruby Signature) type definitions for the React on Rails gem.
+
+## What is RBS?
+
+RBS is Ruby's official type signature language. It provides type information for Ruby code, enabling:
+
+- Better IDE support and autocomplete
+- Static type checking with tools like Steep
+- Improved documentation
+- Early detection of type-related bugs
+
+## Structure
+
+The signatures are organized to mirror the `lib/` directory structure:
+
+- `react_on_rails.rbs` - Main module and core classes
+- `react_on_rails/configuration.rbs` - Configuration class types
+- `react_on_rails/helper.rbs` - View helper method signatures
+- `react_on_rails/server_rendering_pool.rbs` - Server rendering types
+- `react_on_rails/utils.rbs` - Utility method signatures
+- And more...
+
+## Validation
+
+To validate the RBS signatures:
+
+```bash
+bundle exec rake rbs:validate
+```
+
+Or directly:
+
+```bash
+bundle exec rbs -I sig validate
+```
+
+To list all RBS files:
+
+```bash
+bundle exec rake rbs:list
+```
+
+## Development
+
+When adding new public methods or classes to the gem, please also add corresponding RBS signatures.
+
+For more information about RBS:
+
+- [RBS Documentation](https://github.com/ruby/rbs)
+- [RBS Syntax Guide](https://github.com/ruby/rbs/blob/master/docs/syntax.md)

data/sig/react_on_rails/configuration.rbs

@@ -0,0 +1,96 @@
+module ReactOnRails
+  class Configuration
+    attr_accessor node_modules_location: String?
+    attr_accessor server_bundle_js_file: String
+    attr_accessor prerender: bool
+    attr_accessor replay_console: bool
+    attr_accessor trace: bool
+    attr_accessor development_mode: bool
+    attr_accessor logging_on_server: bool
+    attr_accessor server_renderer_pool_size: Integer
+    attr_accessor server_renderer_timeout: Integer
+    attr_accessor skip_display_none: bool?
+    attr_accessor raise_on_prerender_error: bool
+    attr_accessor generated_assets_dirs: Array[String]?
+    attr_accessor generated_assets_dir: String
+    attr_accessor components_subdirectory: String?
+    attr_accessor webpack_generated_files: Array[String]
+    attr_accessor rendering_extension: String?
+    attr_accessor build_test_command: String
+    attr_accessor build_production_command: String
+    attr_accessor i18n_dir: String?
+    attr_accessor i18n_yml_dir: String?
+    attr_accessor i18n_output_format: Symbol?
+    attr_accessor i18n_yml_safe_load_options: Hash[Symbol, untyped]?
+    attr_accessor defer_generated_component_packs: bool
+    attr_accessor server_render_method: String?
+    attr_accessor random_dom_id: bool
+    attr_accessor auto_load_bundle: bool
+    attr_accessor same_bundle_for_client_and_server: bool
+    attr_accessor rendering_props_extension: String?
+    attr_accessor make_generated_server_bundle_the_entrypoint: bool
+    attr_accessor generated_component_packs_loading_strategy: Symbol?
+    attr_accessor immediate_hydration: bool
+    attr_accessor component_registry_timeout: Integer
+    attr_accessor server_bundle_output_path: String?
+    attr_accessor enforce_private_server_bundles: bool
+
+    def initialize: (
+      ?node_modules_location: String?,
+      ?server_bundle_js_file: String?,
+      ?prerender: bool?,
+      ?replay_console: bool?,
+      ?make_generated_server_bundle_the_entrypoint: bool?,
+      ?trace: bool?,
+      ?development_mode: bool?,
+      ?defer_generated_component_packs: bool?,
+      ?logging_on_server: bool?,
+      ?server_renderer_pool_size: Integer?,
+      ?server_renderer_timeout: Integer?,
+      ?raise_on_prerender_error: bool?,
+      ?skip_display_none: bool?,
+      ?generated_assets_dirs: Array[String]?,
+      ?generated_assets_dir: String?,
+      ?webpack_generated_files: Array[String]?,
+      ?rendering_extension: String?,
+      ?build_test_command: String?,
+      ?build_production_command: String?,
+      ?generated_component_packs_loading_strategy: Symbol?,
+      ?same_bundle_for_client_and_server: bool?,
+      ?i18n_dir: String?,
+      ?i18n_yml_dir: String?,
+      ?i18n_output_format: Symbol?,
+      ?i18n_yml_safe_load_options: Hash[Symbol, untyped]?,
+      ?random_dom_id: bool?,
+      ?server_render_method: String?,
+      ?rendering_props_extension: String?,
+      ?components_subdirectory: String?,
+      ?auto_load_bundle: bool?,
+      ?immediate_hydration: bool?,
+      ?component_registry_timeout: Integer?,
+      ?server_bundle_output_path: String?,
+      ?enforce_private_server_bundles: bool?
+    ) -> void
+
+    def setup_config_values: () -> void
+
+    private
+
+    def check_component_registry_timeout: () -> void
+    def validate_generated_component_packs_loading_strategy: () -> void
+    def validate_enforce_private_server_bundles: () -> void
+    def check_minimum_shakapacker_version: () -> void
+    def check_autobundling_requirements: () -> void
+    def adjust_precompile_task: () -> void
+    def error_if_using_packer_and_generated_assets_dir_not_match_public_output_path: () -> void
+    def check_server_render_method_is_only_execjs: () -> void
+    def configure_generated_assets_dirs_deprecation: () -> void
+    def ensure_webpack_generated_files_exists: () -> void
+    def configure_skip_display_none_deprecation: () -> void
+    def raise_missing_components_subdirectory: () -> void
+    def compile_command_conflict_message: () -> String
+    def rsc_bundle_js_file: () -> String?
+    def react_client_manifest_file: () -> String?
+    def react_server_client_manifest_file: () -> String?
+  end
+end

data/sig/react_on_rails/controller.rbs

@@ -0,0 +1,15 @@
+module ReactOnRails
+  module Controller
+    # Type alias for ActiveSupport::SafeBuffer (html_safe strings)
+    type safe_buffer = String
+
+    def redux_store: (
+      String store_name,
+      ?props: Hash[Symbol, untyped] | String,
+      ?immediate_hydration: bool
+    ) -> void
+
+    # Returns html_safe string (ActiveSupport::SafeBuffer)
+    def redux_store_hydration_data: () -> safe_buffer
+  end
+end

data/sig/react_on_rails/dev/file_manager.rbs

@@ -0,0 +1,15 @@
+module ReactOnRails
+  module Dev
+    class FileManager
+      def self.cleanup_stale_files: () -> bool
+
+      private
+
+      def self.cleanup_overmind_sockets: () -> bool
+      def self.cleanup_rails_pid_file: () -> bool
+      def self.overmind_running?: () -> bool
+      def self.process_running?: (Integer) -> bool
+      def self.remove_file_if_exists: (String, String) -> bool
+    end
+  end
+end

data/sig/react_on_rails/dev/pack_generator.rbs

@@ -0,0 +1,19 @@
+module ReactOnRails
+  module Dev
+    class PackGenerator
+      def self.generate: (?verbose: bool) -> void
+
+      private
+
+      def self.run_pack_generation: (?silent: bool, ?verbose: bool) -> bool
+      def self.should_run_directly?: () -> bool
+      def self.rails_available?: () -> bool
+      def self.run_rake_task_directly: (?silent: bool) -> bool
+      def self.load_rake_tasks: () -> void
+      def self.prepare_rake_task: () -> untyped
+      def self.capture_output: (bool) { () -> bool } -> bool
+      def self.handle_rake_error: (Exception, bool) -> void
+      def self.run_via_bundle_exec: (?silent: bool, ?verbose: bool) -> (bool | nil)
+    end
+  end
+end

data/sig/react_on_rails/dev/process_manager.rbs

@@ -0,0 +1,22 @@
+module ReactOnRails
+  module Dev
+    class ProcessManager
+      VERSION_CHECK_TIMEOUT: Integer
+
+      def self.installed?: (String) -> bool
+      def self.ensure_procfile: (String) -> void
+      def self.run_with_process_manager: (String) -> void
+
+      private
+
+      def self.installed_in_current_context?: (String) -> bool
+      def self.version_flags_for: (String) -> Array[String]
+      def self.run_process_if_available: (String, Array[String]) -> (bool | nil)
+      def self.run_process_outside_bundle: (String, Array[String]) -> bool
+      def self.process_available_in_system?: (String) -> bool
+      def self.with_unbundled_context: () { () -> untyped } -> untyped
+      def self.show_process_manager_installation_help: () -> void
+      def self.valid_procfile_path?: (String) -> bool
+    end
+  end
+end

data/sig/react_on_rails/dev/server_manager.rbs

@@ -0,0 +1,39 @@
+module ReactOnRails
+  module Dev
+    class ServerManager
+      type mode = :development | :production_like | :static | :hmr
+
+      def self.start: (mode, String?, ?verbose: bool, ?route: String?, ?rails_env: String?) -> void
+      def self.kill_processes: () -> void
+      def self.development_processes: () -> Hash[String, String]
+      def self.kill_running_processes: () -> bool
+      def self.find_process_pids: (String) -> Array[Integer]
+      def self.terminate_processes: (Array[Integer]) -> void
+      def self.kill_port_processes: (Array[Integer]) -> bool
+      def self.find_port_pids: (Integer) -> Array[Integer]
+      def self.cleanup_socket_files: () -> bool
+      def self.print_kill_summary: (bool) -> void
+      def self.show_help: () -> void
+      def self.run_from_command_line: (?Array[String]) -> void
+
+      private
+
+      def self.help_usage: () -> String
+      def self.help_commands: () -> String
+      def self.help_options: () -> String
+      def self.help_customization: () -> String
+      def self.help_mode_details: () -> String
+      def self.help_troubleshooting: () -> String
+      def self.run_production_like: (?_verbose: bool, ?route: String?, ?rails_env: String?) -> void
+      def self.run_static_development: (String, ?verbose: bool, ?route: String?) -> void
+      def self.run_development: (String, ?verbose: bool, ?route: String?) -> void
+      def self.print_server_info: (String, Array[String], ?Integer, ?route: String?) -> void
+      def self.print_procfile_info: (String, ?route: String?) -> void
+      def self.procfile_port: (String) -> Integer
+      def self.box_border: (Integer) -> String
+      def self.box_bottom: (Integer) -> String
+      def self.box_empty_line: (Integer) -> String
+      def self.format_box_line: (String, Integer) -> String
+    end
+  end
+end