vite_ruby 3.3.4 → 3.10.2

data/lib/vite_ruby/cli/install.rb

@@ -1,26 +1,31 @@
 # frozen_string_literal: true
 
-require 'stringio'
+require "stringio"
+require "json"
 
 class ViteRuby::CLI::Install < Dry::CLI::Command
-  desc 'Performs the initial configuration setup to get started with Vite Ruby.'
+  desc "Performs the initial configuration setup to get started with Vite Ruby."
+
+  option(:package_manager, values: %w[npm pnpm yarn bun], aliases: %w[package-manager with], desc: "The package manager to use when installing JS dependencies.")
+
+  def call(package_manager: nil, **)
+    ENV["VITE_RUBY_PACKAGE_MANAGER"] ||= package_manager if package_manager
 
-  def call(**)
     $stdout.sync = true
 
-    say 'Creating binstub'
+    say "Creating binstub"
     ViteRuby.commands.install_binstubs
 
-    say 'Creating configuration files'
+    say "Creating configuration files"
     create_configuration_files
 
-    say 'Installing sample files'
+    say "Installing sample files"
     install_sample_files
 
-    say 'Installing js dependencies'
+    say "Installing js dependencies"
     install_js_dependencies
 
-    say 'Adding files to .gitignore'
+    say "Adding files to .gitignore"
     install_gitignore
 
     say "\nVite ⚡️ Ruby successfully installed! 🎉"
@@ -31,38 +36,38 @@ protected
   # Internal: The JS packages that should be added to the app.
   def js_dependencies
     [
-      "vite@#{ ViteRuby::DEFAULT_VITE_VERSION }",
-      "vite-plugin-ruby@#{ ViteRuby::DEFAULT_PLUGIN_VERSION }",
+      "vite@#{ViteRuby::DEFAULT_VITE_VERSION}",
+      "vite-plugin-ruby@#{ViteRuby::DEFAULT_PLUGIN_VERSION}",
     ]
   end
 
   # Internal: Setup for a plain Rack application.
   def setup_app_files
-    copy_template 'config/vite.json', to: config.config_path
+    copy_template "config/vite.json", to: config.config_path
 
-    if (rackup_file = root.join('config.ru')).exist?
-      inject_line_after_last rackup_file, 'require', 'use(ViteRuby::DevServerProxy, ssl_verify_none: true) if ViteRuby.run_proxy?'
+    if (rackup_file = root.join("config.ru")).exist?
+      inject_line_after_last rackup_file, "require", "use(ViteRuby::DevServerProxy, ssl_verify_none: true) if ViteRuby.run_proxy?"
     end
   end
 
   # Internal: Create a sample JS file and attempt to inject it in an HTML template.
   def install_sample_files
-    copy_template 'entrypoints/application.js', to: config.resolved_entrypoints_dir.join('application.js')
+    copy_template "entrypoints/application.js", to: config.resolved_entrypoints_dir.join("application.js")
   end
 
 private
 
   extend Forwardable
 
-  def_delegators 'ViteRuby', :config
+  def_delegators "ViteRuby", :config
 
-  %i[append cp inject_line_after inject_line_after_last inject_line_before replace_first_line write].each do |util|
-    define_method(util) { |*args|
-      ViteRuby::CLI::FileUtils.send(util, *args) rescue nil
+  %i[append append_unless_present cp inject_line_after inject_line_after_last inject_line_before replace_first_line write].each do |util|
+    define_method(util) { |*args, **kwargs, &block|
+      ViteRuby::CLI::FileUtils.send(util, *args, **kwargs, &block) rescue nil
     }
   end
 
-  TEMPLATES_PATH = Pathname.new(File.expand_path('../../../templates', __dir__))
+  TEMPLATES_PATH = Pathname.new(File.expand_path("../../../templates", __dir__))
 
   def copy_template(path, to:)
     cp TEMPLATES_PATH.join(path), to
@@ -70,23 +75,34 @@ private
 
   # Internal: Creates the Vite and vite-plugin-ruby configuration files.
   def create_configuration_files
-    copy_template 'config/vite.config.ts', to: root.join('vite.config.ts')
-    append root.join('Procfile.dev'), 'vite: bin/vite dev'
+    copy_template "config/vite.config.ts", to: root.join("vite.config.ts")
+    append root.join("Procfile.dev"), "vite: bin/vite dev"
     setup_app_files
     ViteRuby.reload_with(config_path: config.config_path)
   end
 
   # Internal: Installs vite and vite-plugin-ruby at the project level.
   def install_js_dependencies
-    package_json = root.join('package.json')
-    write(package_json, '{}') unless package_json.exist?
-    deps = js_dependencies.join(' ')
-    run_with_capture("#{ npm_install } -D #{ deps }", stdin_data: "\n")
+    package_json = root.join("package.json")
+    unless package_json.exist?
+      write package_json, <<~JSON
+        {
+          "private": true,
+          "type": "module"
+        }
+      JSON
+    end
+
+    if (JSON.parse(package_json.read)["type"] != "module" rescue nil)
+      FileUtils.mv root.join("vite.config.ts"), root.join("vite.config.mts"), force: true, verbose: true
+    end
+
+    install_js_packages js_dependencies.join(" ")
   end
 
   # Internal: Adds compilation output dirs to git ignore.
   def install_gitignore
-    return unless (gitignore_file = root.join('.gitignore')).exist?
+    return unless (gitignore_file = root.join(".gitignore")).exist?
 
     append(gitignore_file, <<~GITIGNORE)
 
@@ -115,12 +131,8 @@ private
     end
   end
 
-  # Internal: Support all popular package managers.
-  def npm_install
-    return 'yarn add' if root.join('yarn.lock').exist?
-    return 'pnpm install' if root.join('pnpm-lock.yaml').exist?
-
-    'npm install'
+  def install_js_packages(deps)
+    run_with_capture("#{config.package_manager} add -D #{deps}", stdin_data: "\n")
   end
 
   # Internal: Avoid printing warning about missing vite.json, we will create one.

data/lib/vite_ruby/cli/ssr.rb

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
 
 class ViteRuby::CLI::SSR < ViteRuby::CLI::Vite
-  DEFAULT_ENV = CURRENT_ENV || 'production'
+  DEFAULT_ENV = CURRENT_ENV || "production"
   JS_EXTENSIONS = %w[js mjs cjs]
 
-  desc 'Run the resulting app from building in SSR mode.'
+  desc "Run the resulting app from building in SSR mode."
   executable_options
 
   def call(mode:, inspect: false, trace_deprecation: false)
-    ViteRuby.env['VITE_RUBY_MODE'] = mode
+    ViteRuby.env["VITE_RUBY_MODE"] = mode
 
     ssr_entrypoint = JS_EXTENSIONS
-      .map { |ext| ViteRuby.config.ssr_output_dir.join("ssr.#{ ext }") }
+      .map { |ext| ViteRuby.config.ssr_output_dir.join("ssr.#{ext}") }
       .find(&:exist?)
 
-    raise ArgumentError, "No ssr entrypoint found `#{ ViteRuby.config.ssr_output_dir.relative_path_from(ViteRuby.config.root) }/ssr.{#{ JS_EXTENSIONS.join(',') }}`. Have you run bin/vite build --ssr?" unless ssr_entrypoint
+    raise ArgumentError, "No ssr entrypoint found `#{ViteRuby.config.ssr_output_dir.relative_path_from(ViteRuby.config.root)}/ssr.{#{JS_EXTENSIONS.join(",")}}`. Have you run bin/vite build --ssr?" unless ssr_entrypoint
 
     cmd = [
-      'node',
-      ('--inspect-brk' if inspect),
-      ('--trace-deprecation' if trace_deprecation),
+      "node",
+      ("--inspect-brk" if inspect),
+      ("--trace-deprecation" if trace_deprecation),
       ssr_entrypoint,
     ]
     Kernel.exec(*cmd.compact.map(&:to_s))

data/lib/vite_ruby/cli/upgrade.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class ViteRuby::CLI::Upgrade < ViteRuby::CLI::Install
-  desc 'Updates Vite Ruby related gems and npm packages.'
+  desc "Updates Vite Ruby related gems and npm packages."
 
   def call(**)
     upgrade_ruby_gems
@@ -11,15 +11,15 @@ class ViteRuby::CLI::Upgrade < ViteRuby::CLI::Install
 protected
 
   def upgrade_ruby_gems
-    say 'Updating gems'
+    say "Updating gems"
 
     libraries = ViteRuby.framework_libraries.map { |_f, library| library.name }
 
-    run_with_capture("bundle update #{ libraries.join(' ') }")
+    run_with_capture("bundle update #{libraries.join(" ")}")
   end
 
   # NOTE: Spawn a new process so that it uses the updated vite_ruby.
   def upgrade_npm_packages
-    Kernel.exec('bundle exec vite upgrade_packages')
+    Kernel.exec("bundle exec vite upgrade_packages")
   end
 end

data/lib/vite_ruby/cli/upgrade_packages.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
 class ViteRuby::CLI::UpgradePackages < ViteRuby::CLI::Install
-  desc 'Upgrades the npm packages to the recommended versions.'
+  desc "Upgrades the npm packages to the recommended versions."
 
   def call(**)
-    say 'Upgrading npm packages'
-    deps = js_dependencies.join(' ')
-    run_with_capture("#{ npm_install } -D #{ deps }")
+    say "Upgrading npm packages"
+    install_js_packages js_dependencies.join(" ")
   end
 end

data/lib/vite_ruby/cli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class ViteRuby::CLI::Version < Dry::CLI::Command
-  desc 'Print version'
+  desc "Print version"
 
   def call(**)
     ViteRuby.commands.print_info

data/lib/vite_ruby/cli/vite.rb

@@ -1,24 +1,35 @@
 # frozen_string_literal: true
 
 class ViteRuby::CLI::Vite < Dry::CLI::Command
-  CURRENT_ENV = ENV['RACK_ENV'] || ENV['RAILS_ENV']
+  CURRENT_ENV = ENV["RACK_ENV"] || ENV["RAILS_ENV"]
 
   def self.executable_options
-    option(:mode, default: self::DEFAULT_ENV, values: %w[development production test], aliases: ['m'], desc: 'The build mode for Vite')
-    option(:inspect, desc: 'Run Vite in a debugging session with node --inspect-brk', aliases: ['inspect-brk'], type: :boolean)
-    option(:trace_deprecation, desc: 'Run Vite in debugging mode with node --trace-deprecation', aliases: ['trace-deprecation'], type: :boolean)
+    option(:mode, default: self::DEFAULT_ENV, values: %w[development production test], aliases: ["m"], desc: "The build mode for Vite")
+    option(:node_options, desc: "Node options for the Vite executable", aliases: ["node-options"])
+    option(:inspect, desc: "Run Vite in a debugging session with node --inspect-brk", aliases: ["inspect-brk"], type: :boolean)
+    option(:trace_deprecation, desc: "Run Vite in debugging mode with node --trace-deprecation", aliases: ["trace-deprecation"], type: :boolean)
   end
 
   def self.shared_options
     executable_options
-    option(:debug, desc: 'Run Vite in verbose mode, printing all debugging output', aliases: ['verbose'], type: :boolean)
-    option(:clobber, desc: 'Clear cache and previous builds', type: :boolean, aliases: %w[clean clear])
+    option(:debug, desc: "Run Vite in verbose mode, printing all debugging output", aliases: ["verbose"], type: :boolean)
+    option(:clobber, desc: "Clear cache and previous builds", type: :boolean, aliases: %w[clean clear])
   end
 
-  def call(mode:, args: [], clobber: false, **boolean_opts)
-    ViteRuby.env['VITE_RUBY_MODE'] = mode
+  def call(mode:, args: [], clobber: false, node_options: nil, inspect: nil, trace_deprecation: nil, **boolean_opts)
+    ViteRuby.env["VITE_RUBY_MODE"] = mode
     ViteRuby.commands.clobber if clobber
-    boolean_opts.map { |name, value| args << "--#{ name }" if value }
+
+    node_options = [
+      node_options,
+      ("--inspect-brk" if inspect),
+      ("--trace-deprecation" if trace_deprecation),
+    ].compact.join(" ")
+
+    args << %(--node-options="#{node_options}") unless node_options.empty?
+
+    boolean_opts.map { |name, value| args << "--#{name}" if value }
+
     yield(args)
   end
 end

data/lib/vite_ruby/cli.rb

@@ -1,30 +1,30 @@
 # frozen_string_literal: true
 
-require 'dry/cli'
+require "dry/cli"
 
 # Public: Command line interface that allows to install the library, and run
 # simple commands.
 class ViteRuby::CLI
   extend Dry::CLI::Registry
 
-  register 'build', Build, aliases: ['b']
-  register 'clobber', Clobber, aliases: %w[clean clear]
-  register 'dev', Dev, aliases: %w[d serve]
-  register 'install', Install
-  register 'ssr', SSR
-  register 'version', Version, aliases: ['v', '-v', '--version', 'info']
-  register 'upgrade', Upgrade, aliases: ['update']
-  register 'upgrade_packages', UpgradePackages, aliases: ['update_packages']
+  register "build", Build, aliases: ["b"]
+  register "clobber", Clobber, aliases: %w[clean clear]
+  register "dev", Dev, aliases: %w[d serve]
+  register "install", Install
+  register "ssr", SSR
+  register "version", Version, aliases: ["v", "-v", "--version", "info"]
+  register "upgrade", Upgrade, aliases: ["update"]
+  register "upgrade_packages", UpgradePackages, aliases: ["update_packages"]
 
   # Internal: Allows framework-specific variants to extend the CLI.
-  def self.require_framework_libraries(path = 'cli')
+  def self.require_framework_libraries(path = "cli")
     ViteRuby.framework_libraries.each do |_framework, library|
-      require [library.name.tr('-', '/').to_s, path].compact.join('/')
+      require [library.name.tr("-", "/").to_s, path].compact.join("/")
     end
   rescue LoadError
-    require_framework_libraries 'installation' unless path == 'installation'
+    require_framework_libraries "installation" unless path == "installation"
   end
 end
 
 # NOTE: This allows framework-specific variants to extend the CLI.
-ViteRuby::CLI.require_framework_libraries('cli')
+ViteRuby::CLI.require_framework_libraries("cli")

data/lib/vite_ruby/commands.rb

@@ -9,7 +9,7 @@ class ViteRuby::Commands
 
   # Public: Defaults to production, and exits if the build fails.
   def build_from_task(*args)
-    with_node_env(ENV.fetch('NODE_ENV', 'production')) {
+    with_node_env(ENV.fetch("NODE_ENV", "production")) {
       ensure_log_goes_to_stdout {
         build(*args) || exit!
       }
@@ -25,44 +25,13 @@ class ViteRuby::Commands
   def clobber
     dirs = [config.build_output_dir, config.ssr_output_dir, config.build_cache_dir, config.vite_cache_dir]
     dirs.each { |dir| dir.rmtree if dir.exist? }
-    $stdout.puts "Removed vite cache and output dirs:\n\t#{ dirs.join("\n\t") }"
-  end
-
-  # Public: Receives arguments from a rake task.
-  def clean_from_task(args)
-    ensure_log_goes_to_stdout {
-      clean(keep_up_to: Integer(args.keep || 2), age_in_seconds: Integer(args.age || 3600))
-    }
-  end
-
-  # Public: Cleanup old assets in the output directory.
-  #
-  # keep_up_to - Max amount of backups to preserve.
-  # age_in_seconds - Amount of time to look back in order to preserve them.
-  #
-  # NOTE: By default keeps the last version, or 2 if created in the past hour.
-  #
-  # Examples:
-  #   To force only 1 backup to be kept: clean(1, 0)
-  #   To only keep files created within the last 10 minutes: clean(0, 600)
-  def clean(keep_up_to: 2, age_in_seconds: 3600)
-    return false unless may_clean?
-
-    versions
-      .each_with_index
-      .drop_while { |(mtime, _), index|
-        max_age = [0, Time.now - Time.at(mtime)].max
-        max_age < age_in_seconds || index < keep_up_to
-      }
-      .each do |(_, files), _|
-        clean_files(files)
-      end
-    true
+    $stdout.puts "Removed vite cache and output dirs:\n\t#{dirs.join("\n\t")}"
   end
 
   # Internal: Installs the binstub for the CLI in the appropriate path.
   def install_binstubs
-    `bundle binstub vite_ruby --path #{ config.root.join('bin') }`
+    `bundle config set bin #{config.root.join("bin")}`
+    `bundle binstub vite_ruby`
     `bundle config --delete bin`
   end
 
@@ -78,7 +47,7 @@ class ViteRuby::Commands
 
   # Internal: Verifies if ViteRuby is properly installed.
   def verify_install
-    unless File.exist?(config.root.join('bin/vite'))
+    unless File.exist?(config.root.join("bin/vite"))
       warn <<~WARN
 
         vite binstub not found.
@@ -91,7 +60,7 @@ class ViteRuby::Commands
     unless config_path.exist?
       warn <<~WARN
 
-        Configuration #{ config_path } file for vite-plugin-ruby not found.
+        Configuration #{config_path} file for vite-plugin-ruby not found.
         Make sure `bundle exec vite install` has run successfully before running dependent tasks.
       WARN
       exit!
@@ -101,23 +70,23 @@ class ViteRuby::Commands
   # Internal: Prints information about ViteRuby's environment.
   def print_info
     config.within_root do
-      $stdout.puts "bin/vite present?: #{ File.exist? 'bin/vite' }"
+      $stdout.puts "bin/vite present?: #{File.exist? "bin/vite"}"
 
-      $stdout.puts "vite_ruby: #{ ViteRuby::VERSION }"
+      $stdout.puts "vite_ruby: #{ViteRuby::VERSION}"
       ViteRuby.framework_libraries.each do |framework, library|
-        $stdout.puts "#{ library.name }: #{ library.version }"
-        $stdout.puts "#{ framework }: #{ Gem.loaded_specs[framework]&.version }"
+        $stdout.puts "#{library.name}: #{library.version}"
+        $stdout.puts "#{framework}: #{Gem.loaded_specs[framework]&.version}"
       end
 
-      $stdout.puts "node: #{ `node --version` }"
-      $stdout.puts "npm: #{ `npm --version` }"
-      $stdout.puts "yarn: #{ `yarn --version` rescue nil }"
-      $stdout.puts "pnpm: #{ `pnpm --version` rescue nil }"
-      $stdout.puts "ruby: #{ `ruby --version` }"
+      $stdout.puts "ruby: #{`ruby --version`}"
+      $stdout.puts "node: #{`node --version`}"
+
+      pkg = config.package_manager
+      $stdout.puts "#{pkg}: #{`#{pkg} --version` rescue nil}"
 
       $stdout.puts "\n"
       packages = `npm ls vite vite-plugin-ruby`
-      packages_msg = packages.include?('vite@') ? "installed packages:\n#{ packages }" : '❌ Check that vite and vite-plugin-ruby have been added as development dependencies and installed.'
+      packages_msg = packages.include?("vite@") ? "installed packages:\n#{packages}" : "❌ Check that vite and vite-plugin-ruby have been added as development dependencies and installed."
       $stdout.puts packages_msg
 
       ViteRuby::CompatibilityCheck.verify_plugin_version(config.root)
@@ -130,42 +99,19 @@ private
 
   def_delegators :@vite_ruby, :config, :builder, :manifest, :logger, :logger=
 
-  def may_clean?
-    config.build_output_dir.exist? && config.manifest_path.exist?
-  end
-
-  def clean_files(files)
-    files.select { |file| File.file?(file) }.each do |file|
-      File.delete(file)
-      logger.info("Removed #{ file }")
-    end
-  end
-
-  def versions
-    all_files = Dir.glob("#{ config.build_output_dir }/**/*")
-    entries = all_files - config.manifest_paths - current_version_files
-    entries.reject { |file| File.directory?(file) }
-      .group_by { |file| File.mtime(file).utc.to_i }
-      .sort.reverse
-  end
-
-  def current_version_files
-    Dir.glob(manifest.refresh.values.map { |value| config.build_output_dir.join("#{ value['file'] }*") })
-  end
-
   def with_node_env(env)
-    original = ENV['NODE_ENV']
-    ENV['NODE_ENV'] = env
+    original = ENV["NODE_ENV"]
+    ENV["NODE_ENV"] = env
     yield
   ensure
-    ENV['NODE_ENV'] = original
+    ENV["NODE_ENV"] = original
   end
 
   def ensure_log_goes_to_stdout
     old_logger, original_sync = logger, $stdout.sync
 
     $stdout.sync = true
-    self.logger = Logger.new($stdout, formatter: proc { |_, _, progname, msg| progname == 'vite' ? msg : "#{ msg }\n" })
+    self.logger = Logger.new($stdout, formatter: proc { |_, _, progname, msg| (progname == "vite") ? msg : "#{msg}\n" })
     yield
   ensure
     self.logger, $stdout.sync = old_logger, original_sync

data/lib/vite_ruby/compatibility_check.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 # Internal: Verifies that the installed vite-plugin-ruby version is compatible
 # with the current version of vite_ruby.
@@ -11,9 +11,9 @@ module ViteRuby::CompatibilityCheck
   class << self
     # Public: Attempt to verify that the vite-plugin-ruby version is compatible.
     def verify_plugin_version(root)
-      package = JSON.parse(root.join('package.json').read) rescue {}
-      requirement = package.dig('devDependencies', 'vite-plugin-ruby') ||
-                    package.dig('dependencies', 'vite-plugin-ruby')
+      package = JSON.parse(root.join("package.json").read) rescue {}
+      requirement = package.dig("devDependencies", "vite-plugin-ruby") ||
+        package.dig("dependencies", "vite-plugin-ruby")
 
       raise_unless_satisfied(requirement, ViteRuby::DEFAULT_PLUGIN_VERSION)
     end
@@ -22,7 +22,7 @@ module ViteRuby::CompatibilityCheck
     def raise_unless_satisfied(npm_req, ruby_req)
       unless compatible_plugin?(npm_req, ruby_req)
         raise ArgumentError, <<~ERROR
-          vite-plugin-ruby@#{ npm_req } might not be compatible with vite_ruby-#{ ViteRuby::VERSION }
+          vite-plugin-ruby@#{npm_req} might not be compatible with vite_ruby-#{ViteRuby::VERSION}
 
           You may disable this check if needed: https://vite-ruby.netlify.app/config/#skipcompatibilitycheck
 
@@ -37,12 +37,12 @@ module ViteRuby::CompatibilityCheck
     # requirement.
     def compatible_plugin?(npm_req, ruby_req)
       npm_req, ruby_req = [npm_req, ruby_req]
-        .map { |req| Gem::Requirement.new(req.sub('^', '~>')) }
+        .map { |req| Gem::Requirement.new(req.sub("^", "~>")) }
 
       current_version = npm_req.requirements.first.second
 
       ruby_req.satisfied_by?(current_version)
-    rescue StandardError
+    rescue
       true
     end
   end