shakapacker 9.3.0.beta.7 → 9.3.0

data/lib/shakapacker/dev_server.rb

@@ -1,16 +1,50 @@
+# Development server status and configuration
+#
+# Provides methods to query the status and configuration of the webpack-dev-server
+# or rspack-dev-server. This includes checking if the server is running, accessing
+# its host/port, and querying features like HMR (Hot Module Replacement).
+#
+# The dev server runs during development to provide live reloading and hot module
+# replacement. In production, the dev server is not used.
+#
+# @example Checking dev server status
+#   dev_server = Shakapacker.dev_server
+#   dev_server.running?
+#   #=> true
+#   dev_server.host_with_port
+#   #=> "localhost:3035"
+#   dev_server.hmr?
+#   #=> true
+#
+# @see Shakapacker::DevServerRunner
 class Shakapacker::DevServer
+  # Default environment variable prefix for dev server settings
   DEFAULT_ENV_PREFIX = "SHAKAPACKER_DEV_SERVER".freeze
 
   # Configure dev server connection timeout (in seconds), default: 0.1
-  # Shakapacker.dev_server.connect_timeout = 1
+  # @example
+  #   Shakapacker::DevServer.connect_timeout = 1
+  # @return [Float] the connection timeout in seconds
   cattr_accessor(:connect_timeout) { 0.1 }
 
+  # The Shakapacker configuration
+  # @return [Shakapacker::Configuration] the configuration
   attr_reader :config
 
+  # Creates a new dev server instance
+  #
+  # @param config [Shakapacker::Configuration] the Shakapacker configuration
+  # @return [Shakapacker::DevServer] the new dev server instance
   def initialize(config)
     @config = config
   end
 
+  # Returns whether the dev server is currently running
+  #
+  # Checks by attempting to open a TCP connection to the configured host and port.
+  # Returns false if the connection fails or if dev server is not configured.
+  #
+  # @return [Boolean] true if the dev server is running
   def running?
     if config.dev_server.present?
       Socket.tcp(host, port, connect_timeout: connect_timeout).close
@@ -22,14 +56,30 @@ class Shakapacker::DevServer
     false
   end
 
+  # Returns the dev server host
+  #
+  # Can be overridden via SHAKAPACKER_DEV_SERVER_HOST environment variable.
+  #
+  # @return [String] the host (e.g., "localhost", "0.0.0.0")
   def host
     fetch(:host)
   end
 
+  # Returns the dev server port
+  #
+  # Can be overridden via SHAKAPACKER_DEV_SERVER_PORT environment variable.
+  #
+  # @return [Integer] the port number (typically 3035)
   def port
     fetch(:port)
   end
 
+  # Returns the server type (http or https)
+  #
+  # Can be overridden via SHAKAPACKER_DEV_SERVER_SERVER environment variable.
+  # Validates that the value is "http" or "https", falling back to "http" if invalid.
+  #
+  # @return [String] "http" or "https"
   def server
     server_value = fetch(:server)
     server_type = server_value.is_a?(Hash) ? server_value[:type] : server_value
@@ -49,24 +99,55 @@ class Shakapacker::DevServer
     "http"
   end
 
+  # Returns the protocol for the dev server
+  #
+  # This is an alias that returns "https" if server is "https", otherwise "http".
+  #
+  # @return [String] "http" or "https"
   def protocol
     return "https" if server == "https"
 
     "http"
   end
 
+  # Returns the host and port as a single string
+  #
+  # @return [String] the host:port combination (e.g., "localhost:3035")
+  # @example
+  #   dev_server.host_with_port
+  #   #=> "localhost:3035"
   def host_with_port
     "#{host}:#{port}"
   end
 
+  # Returns whether pretty output is enabled
+  #
+  # When true, the dev server produces prettier, more readable output.
+  # Can be overridden via SHAKAPACKER_DEV_SERVER_PRETTY environment variable.
+  #
+  # @return [Boolean] true if pretty output is enabled
   def pretty?
     fetch(:pretty)
   end
 
+  # Returns whether Hot Module Replacement (HMR) is enabled
+  #
+  # When true, the dev server updates modules in the browser without a full
+  # page reload, preserving application state.
+  # Can be overridden via SHAKAPACKER_DEV_SERVER_HMR environment variable.
+  #
+  # @return [Boolean] true if HMR is enabled
   def hmr?
     fetch(:hmr)
   end
 
+  # Returns whether CSS inlining is enabled
+  #
+  # When true, CSS is injected inline via JavaScript instead of being loaded
+  # as separate stylesheet files. This enables HMR for CSS.
+  # Can be overridden via SHAKAPACKER_DEV_SERVER_INLINE_CSS environment variable.
+  #
+  # @return [Boolean] true if CSS should be inlined
   def inline_css?
     case fetch(:inline_css)
     when false, "false"
@@ -76,6 +157,12 @@ class Shakapacker::DevServer
     end
   end
 
+  # Returns the environment variable prefix for dev server settings
+  #
+  # Environment variables for dev server settings use this prefix (default: "SHAKAPACKER_DEV_SERVER").
+  # For example, SHAKAPACKER_DEV_SERVER_PORT sets the port.
+  #
+  # @return [String] the env var prefix (typically "SHAKAPACKER_DEV_SERVER")
   def env_prefix
     config.dev_server.fetch(:env_prefix, DEFAULT_ENV_PREFIX)
   end

data/lib/shakapacker/doctor.rb

@@ -391,7 +391,7 @@ module Shakapacker
         expected_binstubs = {
           "bin/shakapacker" => "Main Shakapacker binstub",
           "bin/shakapacker-dev-server" => "Development server binstub",
-          "bin/export-bundler-config" => "Config export binstub"
+          "bin/shakapacker-config" => "Config export binstub"
         }
 
         expected_binstubs.each do |path, description|
@@ -1013,7 +1013,7 @@ module Shakapacker
             binstubs = [
               "bin/shakapacker",
               "bin/shakapacker-dev-server",
-              "bin/export-bundler-config"
+              "bin/shakapacker-config"
             ]
 
             existing_binstubs = binstubs.select { |b| doctor.root_path.join(b).exist? }
@@ -1171,10 +1171,10 @@ module Shakapacker
             puts "  #{package_manager_install_command(package_manager)}"
             puts ""
             puts "For debugging configuration issues, export your webpack/rspack config:"
-            puts "  bin/export-bundler-config --doctor"
+            puts "  bin/shakapacker-config --doctor"
             puts "  (Exports annotated YAML configs for dev and production - best for troubleshooting)"
             puts ""
-            puts "  See 'bin/export-bundler-config --help' for more options"
+            puts "  See 'bin/shakapacker-config --help' for more options"
           end
 
           def package_manager_install_command(manager)

data/lib/shakapacker/instance.rb

@@ -1,10 +1,43 @@
 require "pathname"
 
+# Represents a single instance of Shakapacker configuration and state
+#
+# An instance encapsulates all the configuration, compilation, and manifest
+# lookup functionality for a specific Rails application. Most applications
+# will use the shared instance accessible via {Shakapacker.instance}, but
+# multiple instances can be created for testing or advanced scenarios.
+#
+# @example Using the default instance
+#   instance = Shakapacker::Instance.new
+#   instance.config.source_path
+#   instance.manifest.lookup("application.js")
+#
+# @example Creating an instance with custom paths
+#   instance = Shakapacker::Instance.new(
+#     root_path: "/path/to/app",
+#     config_path: "/custom/config.yml"
+#   )
 class Shakapacker::Instance
+  # The shared logger used by all Shakapacker instances
+  # @return [ActiveSupport::TaggedLogging] the logger
   cattr_accessor(:logger) { ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT)) }
 
-  attr_reader :root_path, :config_path
+  # The root path of the application
+  # @return [Pathname] the application root path
+  attr_reader :root_path
 
+  # The path to the Shakapacker configuration file
+  # @return [Pathname] the config file path
+  attr_reader :config_path
+
+  # Creates a new Shakapacker instance
+  #
+  # @param root_path [String, Pathname, nil] the application root path.
+  #   Defaults to Rails.root if Rails is defined, otherwise uses current directory
+  # @param config_path [String, Pathname, nil] the path to shakapacker.yml.
+  #   Can also be set via SHAKAPACKER_CONFIG environment variable.
+  #   Defaults to +config/shakapacker.yml+ within the root_path
+  # @return [Shakapacker::Instance] the new instance
   def initialize(root_path: nil, config_path: nil)
     # Use Rails.root if Rails is defined and no root_path is provided
     @root_path = root_path || (defined?(Rails) && Rails&.root) || Pathname.new(Dir.pwd)
@@ -15,10 +48,23 @@ class Shakapacker::Instance
     @config_path = Pathname.new(ENV["SHAKAPACKER_CONFIG"] || config_path || default_config_path)
   end
 
+  # Returns the current Rails environment as a StringInquirer
+  #
+  # This allows for convenient environment checking:
+  #   env.development? # => true/false
+  #   env.production?  # => true/false
+  #
+  # @return [ActiveSupport::StringInquirer] the environment
   def env
     @env ||= Shakapacker::Env.inquire self
   end
 
+  # Returns the configuration object for this instance
+  #
+  # The configuration is loaded from the shakapacker.yml file and provides
+  # access to all settings like source paths, output paths, and compilation options.
+  #
+  # @return [Shakapacker::Configuration] the configuration
   def config
     @config ||= Shakapacker::Configuration.new(
       root_path: root_path,
@@ -27,26 +73,64 @@ class Shakapacker::Instance
     )
   end
 
+  # Returns the compiler strategy for determining staleness
+  #
+  # The strategy (mtime or digest) determines how Shakapacker decides whether
+  # assets need recompilation.
+  #
+  # @return [Shakapacker::CompilerStrategy] the compiler strategy
+  # @api private
   def strategy
     @strategy ||= Shakapacker::CompilerStrategy.from_config
   end
 
+  # Returns the compiler for this instance
+  #
+  # The compiler is responsible for executing webpack/rspack to compile assets.
+  #
+  # @return [Shakapacker::Compiler] the compiler
   def compiler
     @compiler ||= Shakapacker::Compiler.new self
   end
 
+  # Returns the development server instance
+  #
+  # The dev server instance can query the status of the webpack-dev-server,
+  # including whether it's running, its host/port, and configuration.
+  #
+  # @return [Shakapacker::DevServer] the dev server
   def dev_server
     @dev_server ||= Shakapacker::DevServer.new config
   end
 
+  # Returns the manifest for looking up compiled assets
+  #
+  # The manifest reads the manifest.json file produced by webpack/rspack
+  # and provides methods to look up the compiled paths for source files.
+  #
+  # @return [Shakapacker::Manifest] the manifest
   def manifest
     @manifest ||= Shakapacker::Manifest.new self
   end
 
+  # Returns the commands instance for build operations
+  #
+  # The commands object provides methods for bootstrapping, cleaning,
+  # clobbering, and compiling assets.
+  #
+  # @return [Shakapacker::Commands] the commands
   def commands
     @commands ||= Shakapacker::Commands.new self
   end
 
+  # Returns whether CSS should be inlined by the dev server
+  #
+  # CSS inlining is enabled when:
+  # - The dev server has inline_css enabled
+  # - Hot Module Replacement (HMR) is enabled
+  # - The dev server is currently running
+  #
+  # @return [Boolean] true if CSS should be inlined
   def inlining_css?
     dev_server.inline_css? && dev_server.hmr? && dev_server.running?
   end

data/lib/shakapacker/manifest.rb

@@ -1,23 +1,70 @@
-# Singleton registry for accessing the packs path using a generated manifest.
-# This allows javascript_pack_tag, stylesheet_pack_tag, asset_pack_path to take a reference to,
-# say, "calendar.js" or "calendar.css" and turn it into "/packs/calendar-1016838bab065ae1e314.js" or
-# "/packs/calendar-1016838bab065ae1e314.css".
+# Manifest for looking up compiled asset paths
 #
-# When the configuration is set to on-demand compilation, with the `compile: true` option in
-# the shakapacker.yml file, any lookups will be preceded by a compilation if one is needed.
+# The manifest reads the +manifest.json+ file produced by webpack/rspack during
+# compilation and provides methods to look up the compiled (digested) paths for
+# source files.
+#
+# This allows view helpers like +javascript_pack_tag+, +stylesheet_pack_tag+, and
+# +asset_pack_path+ to take a reference to a source file (e.g., "calendar.js")
+# and turn it into the compiled path with digest (e.g., "/packs/calendar-1016838bab065ae1e314.js").
+#
+# == Automatic Compilation
+#
+# When the configuration has +compile: true+ in shakapacker.yml, any lookups will
+# automatically trigger compilation if the assets are stale. This is typically
+# enabled in development and disabled in production.
+#
+# == Caching
+#
+# The manifest can cache the loaded data in memory when +cache_manifest: true+ is
+# set in the configuration. This improves performance in production by avoiding
+# repeated file reads.
+#
+# @example Looking up assets
+#   manifest = Shakapacker.manifest
+#   manifest.lookup("application.js")
+#   #=> "/packs/application-abc123.js"
+#
+#   manifest.lookup!("missing.js")
+#   #=> raises Shakapacker::Manifest::MissingEntryError
+#
+# @see Shakapacker::Helper
 class Shakapacker::Manifest
+  # Raised when an asset cannot be found in the manifest
   class MissingEntryError < StandardError; end
 
   delegate :config, :compiler, :dev_server, to: :@instance
 
+  # Creates a new manifest instance
+  #
+  # @param instance [Shakapacker::Instance] the Shakapacker instance
+  # @return [Shakapacker::Manifest] the new manifest
   def initialize(instance)
     @instance = instance
   end
 
+  # Reloads the manifest data from disk
+  #
+  # Forces a fresh read of the manifest.json file, bypassing any cache.
+  # This is useful when you know the manifest has been updated.
+  #
+  # @return [Hash] the loaded manifest data
   def refresh
     @data = load
   end
 
+  # Looks up an entry point with all its chunks (split code)
+  #
+  # This method is used when you need to load all chunks for a pack that has
+  # been split via code splitting. It returns an array of asset paths for the
+  # main entry and all its dynamic imports.
+  #
+  # @param name [String] the entry point name (e.g., "application")
+  # @param pack_type [Hash] options hash with :type key (:javascript, :stylesheet, etc.)
+  # @return [Array<String>, nil] array of asset paths, or nil if not found
+  # @example
+  #   manifest.lookup_pack_with_chunks("application", type: :javascript)
+  #   #=> ["/packs/runtime-abc123.js", "/packs/application-def456.js"]
   def lookup_pack_with_chunks(name, pack_type = {})
     compile if compiling?
 
@@ -28,23 +75,50 @@ class Shakapacker::Manifest
     nil
   end
 
+  # Like {#lookup_pack_with_chunks}, but raises an error if not found
+  #
+  # @param name [String] the entry point name
+  # @param pack_type [Hash] options hash with :type key
+  # @return [Array<String>] array of asset paths
+  # @raise [MissingEntryError] if the entry point is not found in the manifest
   def lookup_pack_with_chunks!(name, pack_type = {})
     lookup_pack_with_chunks(name, pack_type) || handle_missing_entry(name, pack_type)
   end
 
-  # Computes the relative path for a given Shakapacker asset using manifest.json.
-  # If no asset is found, returns nil.
+  # Looks up the compiled path for a given asset
+  #
+  # Computes the relative path for a Shakapacker asset using the manifest.json file.
+  # If automatic compilation is enabled and the assets are stale, triggers a
+  # compilation before looking up the path.
   #
-  # Example:
+  # @param name [String] the source file name (e.g., "calendar.js" or "calendar")
+  # @param pack_type [Hash] options hash with :type key (:javascript, :stylesheet, etc.).
+  #   If not specified, the extension from the name is used.
+  # @return [String, nil] the compiled asset path, or nil if not found
+  # @example
+  #   Shakapacker.manifest.lookup('calendar.js')
+  #   #=> "/packs/calendar-1016838bab065ae1e122.js"
   #
-  #   Shakapacker.manifest.lookup('calendar.js') # => "/packs/calendar-1016838bab065ae1e122.js"
+  #   Shakapacker.manifest.lookup('calendar', type: :javascript)
+  #   #=> "/packs/calendar-1016838bab065ae1e122.js"
   def lookup(name, pack_type = {})
     compile if compiling?
 
     find(full_pack_name(name, pack_type[:type]))
   end
 
-  # Like lookup, except that if no asset is found, raises a Shakapacker::Manifest::MissingEntryError.
+  # Like {#lookup}, but raises an error if the asset is not found
+  #
+  # @param name [String] the source file name
+  # @param pack_type [Hash] options hash with :type key
+  # @return [String] the compiled asset path
+  # @raise [MissingEntryError] if the asset is not found in the manifest
+  # @example
+  #   Shakapacker.manifest.lookup!('calendar.js')
+  #   #=> "/packs/calendar-1016838bab065ae1e122.js"
+  #
+  #   Shakapacker.manifest.lookup!('missing.js')
+  #   #=> raises MissingEntryError
   def lookup!(name, pack_type = {})
     lookup(name, pack_type) || handle_missing_entry(name, pack_type)
   end

data/lib/shakapacker/version.rb

@@ -1,4 +1,4 @@
 module Shakapacker
   # Change the version in package.json too, please!
-  VERSION = "9.3.0.beta.7".freeze
+  VERSION = "9.3.0".freeze
 end

data/lib/shakapacker.rb

@@ -3,22 +3,86 @@ require "active_support/core_ext/string/inquiry"
 require "active_support/logger"
 require "active_support/tagged_logging"
 
+# = Shakapacker
+#
+# Shakapacker is a Ruby gem that integrates webpack and rspack with Rails applications,
+# providing a modern asset pipeline for JavaScript, CSS, and other web assets.
+#
+# The main Shakapacker module provides singleton-style access to configuration,
+# compilation, and asset manifest functionality. Most methods delegate to a shared
+# {Shakapacker::Instance} object.
+#
+# == Basic Usage
+#
+#   # Access configuration
+#   Shakapacker.config.source_path
+#   #=> Pathname("/path/to/app/packs")
+#
+#   # Check if dev server is running
+#   Shakapacker.dev_server.running?
+#   #=> true
+#
+#   # Look up compiled assets
+#   Shakapacker.manifest.lookup("application.js")
+#   #=> "/packs/application-abc123.js"
+#
+#   # Compile assets
+#   Shakapacker.compile
+#
+# == Configuration
+#
+# Configuration is loaded from +config/shakapacker.yml+ and can be accessed via
+# {Shakapacker.config}. The configuration determines the source paths, output paths,
+# compilation settings, and dev server options.
+#
+# @see Shakapacker::Configuration
+# @see Shakapacker::Instance
 module Shakapacker
   extend self
 
+  # Default environment when RAILS_ENV is not set
   DEFAULT_ENV = "development".freeze
   # Environments that use their RAILS_ENV value for NODE_ENV
   # All other environments (production, staging, etc.) use "production" for webpack optimizations
   DEV_TEST_ENVS = %w[development test].freeze
 
+  # Sets the shared Shakapacker instance
+  #
+  # This is primarily used for testing or advanced customization scenarios.
+  # In most applications, the default instance is sufficient.
+  #
+  # @param instance [Shakapacker::Instance] the instance to use
+  # @return [Shakapacker::Instance] the instance that was set
+  # @api public
   def instance=(instance)
     @instance = instance
   end
 
+  # Returns the shared Shakapacker instance
+  #
+  # This instance is used by all module-level delegate methods. It provides
+  # access to configuration, compilation, manifest lookup, and more.
+  #
+  # @return [Shakapacker::Instance] the shared instance
+  # @api public
   def instance
     @instance ||= Shakapacker::Instance.new
   end
 
+  # Temporarily overrides NODE_ENV for the duration of the block
+  #
+  # This is useful when you need to perform operations with a specific NODE_ENV
+  # value without permanently changing the environment.
+  #
+  # @param env [String] the NODE_ENV value to use temporarily
+  # @yield the block to execute with the temporary NODE_ENV
+  # @return [Object] the return value of the block
+  # @example
+  #   Shakapacker.with_node_env("production") do
+  #     # This code runs with NODE_ENV=production
+  #     Shakapacker.compile
+  #   end
+  # @api public
   def with_node_env(env)
     original = ENV["NODE_ENV"]
     ENV["NODE_ENV"] = env
@@ -27,13 +91,32 @@ module Shakapacker
     ENV["NODE_ENV"] = original
   end
 
-  # Set NODE_ENV based on RAILS_ENV if not already set
-  # - development/test environments use their RAILS_ENV value
-  # - all other environments (production, staging, etc.) use "production" for webpack optimizations
+  # Sets NODE_ENV based on RAILS_ENV if not already set
+  #
+  # Environment mapping:
+  # - +development+ and +test+ environments use their RAILS_ENV value for NODE_ENV
+  # - All other environments (+production+, +staging+, etc.) use "production" for webpack optimizations
+  #
+  # This method is typically called automatically during Rails initialization.
+  #
+  # @return [String] the NODE_ENV value that was set
+  # @api private
   def ensure_node_env!
     ENV["NODE_ENV"] ||= DEV_TEST_ENVS.include?(ENV["RAILS_ENV"]) ? ENV["RAILS_ENV"] : "production"
   end
 
+  # Temporarily redirects Shakapacker logging to STDOUT
+  #
+  # This is useful for debugging or when you want to see compilation output
+  # in the console instead of the Rails log.
+  #
+  # @yield the block to execute with STDOUT logging
+  # @return [Object] the return value of the block
+  # @example
+  #   Shakapacker.ensure_log_goes_to_stdout do
+  #     Shakapacker.compile
+  #   end
+  # @api public
   def ensure_log_goes_to_stdout
     old_logger = Shakapacker.logger
     Shakapacker.logger = Logger.new(STDOUT)
@@ -42,8 +125,65 @@ module Shakapacker
     Shakapacker.logger = old_logger
   end
 
+  # @!method logger
+  #   Returns the logger instance used by Shakapacker
+  #   @return [Logger] the logger instance
+  #   @see Shakapacker::Instance#logger
+  # @!method logger=(logger)
+  #   Sets the logger instance used by Shakapacker
+  #   @param logger [Logger] the logger to use
+  #   @return [Logger] the logger that was set
+  #   @see Shakapacker::Instance#logger=
+  # @!method env
+  #   Returns the current Rails environment as an ActiveSupport::StringInquirer
+  #   @return [ActiveSupport::StringInquirer] the environment
+  #   @see Shakapacker::Instance#env
+  # @!method inlining_css?
+  #   Returns whether CSS inlining is enabled
+  #   @return [Boolean] true if CSS should be inlined
+  #   @see Shakapacker::Instance#inlining_css?
   delegate :logger, :logger=, :env, :inlining_css?, to: :instance
+
+  # @!method config
+  #   Returns the Shakapacker configuration object
+  #   @return [Shakapacker::Configuration] the configuration
+  #   @see Shakapacker::Instance#config
+  # @!method compiler
+  #   Returns the compiler instance for compiling assets
+  #   @return [Shakapacker::Compiler] the compiler
+  #   @see Shakapacker::Instance#compiler
+  # @!method manifest
+  #   Returns the manifest instance for looking up compiled assets
+  #   @return [Shakapacker::Manifest] the manifest
+  #   @see Shakapacker::Instance#manifest
+  # @!method commands
+  #   Returns the commands instance for build operations
+  #   @return [Shakapacker::Commands] the commands object
+  #   @see Shakapacker::Instance#commands
+  # @!method dev_server
+  #   Returns the dev server instance for querying server status
+  #   @return [Shakapacker::DevServer] the dev server
+  #   @see Shakapacker::Instance#dev_server
   delegate :config, :compiler, :manifest, :commands, :dev_server, to: :instance
+
+  # @!method bootstrap
+  #   Creates the default configuration files and directory structure
+  #   @return [void]
+  #   @see Shakapacker::Commands#bootstrap
+  # @!method clean(count = nil, age = nil)
+  #   Removes old compiled packs, keeping the most recent versions
+  #   @param count [Integer, nil] number of versions to keep per entry
+  #   @param age [Integer, nil] maximum age in seconds for packs to keep
+  #   @return [void]
+  #   @see Shakapacker::Commands#clean
+  # @!method clobber
+  #   Removes all compiled packs
+  #   @return [void]
+  #   @see Shakapacker::Commands#clobber
+  # @!method compile
+  #   Compiles all webpack/rspack packs
+  #   @return [Boolean] true if compilation succeeded
+  #   @see Shakapacker::Commands#compile
   delegate :bootstrap, :clean, :clobber, :compile, to: :commands
 end
 

data/lib/tasks/shakapacker/doctor.rake

@@ -11,7 +11,7 @@ namespace :shakapacker do
     • Required and optional npm dependencies
     • JavaScript transpiler (Babel, SWC, esbuild) configuration
     • CSS, CSS Modules, and stylesheet preprocessor setup
-    • Binstubs presence (shakapacker, shakapacker-dev-server, export-bundler-config)
+    • Binstubs presence (shakapacker, shakapacker-dev-server, shakapacker-config)
     • Version consistency between gem and npm package
     • Legacy Webpacker file detection
 

data/lib/tasks/shakapacker/export_bundler_config.rake

@@ -42,18 +42,18 @@ namespace :shakapacker do
     Note: When using 'rake', you must use '--' to separate rake options from task arguments.
           Example: rake shakapacker:export_bundler_config -- --doctor
 
-    The task automatically falls back to the gem version if bin/export-bundler-config
+    The task automatically falls back to the gem version if bin/shakapacker-config
     binstub is not installed. To install all binstubs, run: rails shakapacker:binstubs
   DESC
   task :export_bundler_config do
     # Try to use the binstub if it exists, otherwise use the gem's version
-    bin_path = Rails.root.join("bin/export-bundler-config")
+    bin_path = Rails.root.join("bin/shakapacker-config")
 
     unless File.exist?(bin_path)
       # Binstub not installed, use the gem's version directly
-      gem_bin_path = File.expand_path("../../install/bin/export-bundler-config", __dir__)
+      gem_bin_path = File.expand_path("../../install/bin/shakapacker-config", __dir__)
 
-      $stderr.puts "Note: bin/export-bundler-config binstub not found."
+      $stderr.puts "Note: bin/shakapacker-config binstub not found."
       $stderr.puts "Using gem version directly. To install the binstub, run: rake shakapacker:binstubs"
       $stderr.puts ""
 

data/package/config.ts

@@ -55,7 +55,6 @@ if (existsSync(configPath)) {
     const envAppConfig = appYmlObject[railsEnv]
 
     if (!envAppConfig) {
-      /* eslint no-console:0 */
       console.warn(
         `[SHAKAPACKER WARNING] Environment '${railsEnv}' not found in ${configPath}\n` +
           `Available environments: ${Object.keys(appYmlObject).join(", ")}\n` +