vite_ruby-roda 3.9.2.1

data/lib/vite_ruby/cli/install.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "json"
+
+class ViteRuby::CLI::Install < Dry::CLI::Command
+  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
+
+    $stdout.sync = true
+
+    say "Creating binstub"
+    ViteRuby.commands.install_binstubs
+
+    say "Creating configuration files"
+    create_configuration_files
+
+    say "Installing sample files"
+    install_sample_files
+
+    say "Installing js dependencies"
+    install_js_dependencies
+
+    say "Adding files to .gitignore"
+    install_gitignore
+
+    say "\nVite ⚡️ Ruby successfully installed! 🎉"
+  end
+
+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}",
+    ]
+  end
+
+  # Internal: Setup for a plain Rack application.
+  def setup_app_files
+    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?"
+    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")
+  end
+
+private
+
+  extend Forwardable
+
+  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
+    }
+  end
+
+  TEMPLATES_PATH = Pathname.new(File.expand_path("../../../templates", __dir__))
+
+  def copy_template(path, to:)
+    cp TEMPLATES_PATH.join(path), to
+  end
+
+  # 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"
+    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")
+    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?
+
+    append(gitignore_file, <<~GITIGNORE)
+
+      # Vite Ruby
+      /public/vite*
+      node_modules
+      # Vite uses dotenv and suggests to ignore local-only env files. See
+      # https://vitejs.dev/guide/env-and-mode.html#env-files
+      *.local
+    GITIGNORE
+  end
+
+  # Internal: The root path for the Ruby application.
+  def root
+    @root ||= silent_warnings { config.root }
+  end
+
+  def say(*args)
+    $stdout.puts(*args)
+  end
+
+  def run_with_capture(*args, **options)
+    Dir.chdir(root) do
+      _, stderr, status = ViteRuby::IO.capture(*args, **options)
+      say(stderr) unless status.success? || stderr.empty?
+    end
+  end
+
+  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.
+  def silent_warnings
+    old_stderr = $stderr
+    $stderr = StringIO.new
+    yield
+  ensure
+    $stderr = old_stderr
+  end
+end

data/lib/vite_ruby/cli/ssr.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ViteRuby::CLI::SSR < ViteRuby::CLI::Vite
+  DEFAULT_ENV = CURRENT_ENV || "production"
+  JS_EXTENSIONS = %w[js mjs cjs]
+
+  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
+
+    ssr_entrypoint = JS_EXTENSIONS
+      .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
+
+    cmd = [
+      "node",
+      ("--inspect-brk" if inspect),
+      ("--trace-deprecation" if trace_deprecation),
+      ssr_entrypoint,
+    ]
+    Kernel.exec(*cmd.compact.map(&:to_s))
+  end
+end

data/lib/vite_ruby/cli/upgrade.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class ViteRuby::CLI::Upgrade < ViteRuby::CLI::Install
+  desc "Updates Vite Ruby related gems and npm packages."
+
+  def call(**)
+    upgrade_ruby_gems
+    upgrade_npm_packages
+  end
+
+protected
+
+  def upgrade_ruby_gems
+    say "Updating gems"
+
+    libraries = ViteRuby.framework_libraries.map { |_f, library| library.name }
+
+    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")
+  end
+end

data/lib/vite_ruby/cli/upgrade_packages.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class ViteRuby::CLI::UpgradePackages < ViteRuby::CLI::Install
+  desc "Upgrades the npm packages to the recommended versions."
+
+  def call(**)
+    say "Upgrading npm packages"
+    install_js_packages js_dependencies.join(" ")
+  end
+end

data/lib/vite_ruby/cli/version.rb

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

data/lib/vite_ruby/cli/vite.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class ViteRuby::CLI::Vite < Dry::CLI::Command
+  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(: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])
+  end
+
+  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
+
+    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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+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"]
+
+  # Internal: Allows framework-specific variants to extend the CLI.
+  def self.require_framework_libraries(path = "cli")
+    ViteRuby.framework_libraries.each do |_framework, library|
+      require [library.name.tr("-", "/").to_s, path].compact.join("/")
+    end
+  rescue LoadError
+    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")

data/lib/vite_ruby/commands.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# Public: Encapsulates common tasks, available both programatically and from the
+# CLI and Rake tasks.
+class ViteRuby::Commands
+  def initialize(vite_ruby)
+    @vite_ruby = vite_ruby
+  end
+
+  # Public: Defaults to production, and exits if the build fails.
+  def build_from_task(*args)
+    with_node_env(ENV.fetch("NODE_ENV", "production")) {
+      ensure_log_goes_to_stdout {
+        build(*args) || exit!
+      }
+    }
+  end
+
+  # Public: Builds all assets that are managed by Vite, from the entrypoints.
+  def build(*args)
+    builder.build(*args).tap { manifest.refresh }
+  end
+
+  # Public: Removes all build cache and previously compiled assets.
+  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
+
+  # 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 --delete bin`
+  end
+
+  # Internal: Checks if the npm version is 6 or lower.
+  def legacy_npm_version?
+    `npm --version`.to_i < 7 rescue false
+  end
+
+  # Internal: Checks if the yarn version is 1.x.
+  def legacy_yarn_version?
+    `yarn --version`.to_i < 2 rescue false
+  end
+
+  # Internal: Verifies if ViteRuby is properly installed.
+  def verify_install
+    unless File.exist?(config.root.join("bin/vite"))
+      warn <<~WARN
+
+        vite binstub not found.
+        Have you run `bundle binstub vite_ruby`?
+        Make sure the bin directory and bin/vite are not included in .gitignore
+      WARN
+    end
+
+    config_path = config.root.join(config.config_path)
+    unless config_path.exist?
+      warn <<~WARN
+
+        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!
+    end
+  end
+
+  # 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 "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}"
+      end
+
+      $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."
+      $stdout.puts packages_msg
+
+      ViteRuby::CompatibilityCheck.verify_plugin_version(config.root)
+    end
+  end
+
+private
+
+  extend Forwardable
+
+  def_delegators :@vite_ruby, :config, :builder, :manifest, :logger, :logger=
+
+  def with_node_env(env)
+    original = ENV["NODE_ENV"]
+    ENV["NODE_ENV"] = env
+    yield
+  ensure
+    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" })
+    yield
+  ensure
+    self.logger, $stdout.sync = old_logger, original_sync
+  end
+end

data/lib/vite_ruby/compatibility_check.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "json"
+
+# Internal: Verifies that the installed vite-plugin-ruby version is compatible
+# with the current version of vite_ruby.
+#
+# This helps to prevent more subtle runtime errors if there is a mismatch in the
+# manifest schema.
+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")
+
+      raise_unless_satisfied(requirement, ViteRuby::DEFAULT_PLUGIN_VERSION)
+    end
+
+    # Internal: Notifies the user of a possible incompatible plugin.
+    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}
+
+          You may disable this check if needed: https://vite-ruby.netlify.app/config/#skipcompatibilitycheck
+
+          You may upgrade both by running:
+
+              bundle exec vite upgrade
+        ERROR
+      end
+    end
+
+    # Internal: Returns true unless the check is performed and does not meet the
+    # requirement.
+    def compatible_plugin?(npm_req, ruby_req)
+      npm_req, ruby_req = [npm_req, ruby_req]
+        .map { |req| Gem::Requirement.new(req.sub("^", "~>")) }
+
+      current_version = npm_req.requirements.first.second
+
+      ruby_req.satisfied_by?(current_version)
+    rescue
+      true
+    end
+  end
+end

data/lib/vite_ruby/config.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "json"
+
+# Public: Allows to resolve configuration sourced from `config/vite.json` and
+# environment variables, combining them with the default options.
+class ViteRuby::Config
+  def origin
+    "#{protocol}://#{host_with_port}"
+  end
+
+  def protocol
+    https ? "https" : "http"
+  end
+
+  def host_with_port
+    "#{host}:#{port}"
+  end
+
+  # Internal: Path to the manifest files generated by Vite and vite-plugin-ruby.
+  def known_manifest_paths
+    [
+      # NOTE: Generated by Vite when `manifest: true`, which vite-plugin-ruby enables.
+      build_output_dir.join(".vite/manifest.json"),
+
+      # NOTE: Path where vite-plugin-ruby outputs the assets manifest file.
+      build_output_dir.join(".vite/manifest-assets.json"),
+    ]
+  end
+
+  # Internal: Path to the manifest files generated by Vite and vite-plugin-ruby.
+  def manifest_paths
+    known_manifest_paths.select(&:exist?)
+  end
+
+  # Public: The directory where Vite will store the built assets.
+  def build_output_dir
+    root.join(public_dir, public_output_dir)
+  end
+
+  # Public: The directory where the entries are located.
+  def resolved_entrypoints_dir
+    vite_root_dir.join(entrypoints_dir)
+  end
+
+  # Internal: The directory where Vite stores its processing cache.
+  def vite_cache_dir
+    root.join("node_modules/.vite")
+  end
+
+  # Public: The directory that Vite uses as root.
+  def vite_root_dir
+    root.join(source_code_dir)
+  end
+
+  # Public: Loads an optional config/vite.rb file that can modify ViteRuby.env
+  def load_ruby_config
+    rb_config_path = File.expand_path(config_path.sub(/.json$/, ".rb"), root)
+    load rb_config_path if File.exist?(rb_config_path)
+  end
+
+  # Public: Sets additional environment variables for vite-plugin-ruby.
+  def to_env(env_vars = ViteRuby.env)
+    CONFIGURABLE_WITH_ENV.each_with_object({}) do |option, env|
+      unless (value = @config[option]).nil?
+        env["#{ViteRuby::ENV_PREFIX}_#{option.upcase}"] = value.to_s
+      end
+    end.merge(env_vars)
+  end
+
+  # Internal: Files and directories that should be watched for changes.
+  def watched_paths
+    [
+      *(watch_additional_paths + additional_entrypoints).reject { |dir|
+        dir.start_with?("~/") || dir.start_with?(source_code_dir)
+      },
+      "#{source_code_dir}/**/*",
+      config_path.sub(/.json$/, ".{rb,json}"),
+      *DEFAULT_WATCHED_PATHS,
+    ].freeze
+  end
+
+  # Internal: Changes the current directory to the root dir.
+  def within_root(&block)
+    Dir.chdir(File.expand_path(root), &block)
+  end
+
+private
+
+  # Internal: Coerces all the configuration values, in case they were passed
+  # as environment variables which are always strings.
+  def coerce_values(config)
+    config["mode"] = config["mode"].to_s
+    config["port"] = config["port"].to_i
+    config["root"] = root = Pathname.new(config["root"])
+    config["build_cache_dir"] = root.join(config["build_cache_dir"])
+    config["ssr_output_dir"] = root.join(config["ssr_output_dir"])
+    coerce_booleans(config, "auto_build", "hide_build_console_output", "https", "skip_compatibility_check", "skip_proxy")
+    config["package_manager"] ||= detect_package_manager(root)
+  end
+
+  # Internal: Coerces configuration options to boolean.
+  def coerce_booleans(config, *names)
+    truthy = [true, "true"]
+    names.each { |name| config[name] = truthy.include?(config[name]) }
+  end
+
+  def detect_package_manager(root)
+    return "npm" if root.join("package-lock.json").exist?
+    return "pnpm" if root.join("pnpm-lock.yaml").exist?
+    return "bun" if root.join("bun.lockb").exist? || root.join("bun.lock").exist?
+    return "yarn" if root.join("yarn.lock").exist?
+
+    "npm"
+  end
+
+  def initialize(attrs)
+    @config = attrs.tap { |config| coerce_values(config) }.freeze
+    ViteRuby::CompatibilityCheck.verify_plugin_version(root) unless skip_compatibility_check
+  end
+
+  class << self
+    private :new
+
+    # Public: Returns the project configuration for Vite.
+    def resolve_config(**attrs)
+      config = config_defaults.merge(attrs.transform_keys(&:to_s))
+      file_path = File.join(config["root"], config["config_path"])
+      file_config = config_from_file(file_path, mode: config["mode"])
+      new DEFAULT_CONFIG.merge(file_config).merge(config_from_env).merge(config)
+    end
+
+  private
+
+    # Internal: Converts camelCase to snake_case.
+    SNAKE_CASE = ->(camel_cased_word) {
+      camel_cased_word.to_s.gsub("::", "/")
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr("-", "_")
+        .downcase
+    }
+
+    # Internal: Default values for a Ruby application.
+    def config_defaults(asset_host: nil, mode: ENV.fetch("RACK_ENV", "development"), root: Dir.pwd)
+      {
+        "asset_host" => option_from_env("asset_host") || asset_host,
+        "config_path" => option_from_env("config_path") || DEFAULT_CONFIG.fetch("config_path"),
+        "mode" => option_from_env("mode") || mode,
+        "root" => option_from_env("root") || root,
+      }.select { |_, value| value }
+    end
+
+    # Internal: Used to load a JSON file from the specified path.
+    def load_json(path)
+      JSON.parse(File.read(File.expand_path(path))).each do |_env, config|
+        config.transform_keys!(&SNAKE_CASE) if config.is_a?(Hash)
+      end.tap do |config|
+        config.transform_keys!(&SNAKE_CASE)
+      end
+    end
+
+    # Internal: Retrieves a configuration option from environment variables.
+    def option_from_env(name)
+      ViteRuby.env["#{ViteRuby::ENV_PREFIX}_#{name.upcase}"]
+    end
+
+    # Internal: Extracts the configuration options provided as env vars.
+    def config_from_env
+      CONFIGURABLE_WITH_ENV.each_with_object({}) do |option, env_vars|
+        if value = option_from_env(option)
+          env_vars[option] = value
+        end
+      end
+    end
+
+    # Internal: Loads the configuration options provided in a JSON file.
+    def config_from_file(path, mode:)
+      multi_env_config = load_json(path)
+      multi_env_config.fetch("all", {})
+        .merge(multi_env_config.fetch(mode, {}))
+    rescue Errno::ENOENT => error
+      $stderr << "Check that your vite.json configuration file is available in the load path:\n\n\t#{error.message}\n\n"
+      {}
+    end
+  end
+
+  # Internal: Shared configuration with the Vite plugin for Ruby.
+  DEFAULT_CONFIG = load_json("#{__dir__}/../../default.vite.json").freeze
+
+  # Internal: Configuration options that can not be provided as env vars.
+  NOT_CONFIGURABLE_WITH_ENV = %w[additional_entrypoints watch_additional_paths].freeze
+
+  # Internal: Configuration options that can be provided as env vars.
+  CONFIGURABLE_WITH_ENV = (DEFAULT_CONFIG.keys + %w[mode root] - NOT_CONFIGURABLE_WITH_ENV).freeze
+
+  # Internal: If any of these files is modified the build won't be skipped.
+  DEFAULT_WATCHED_PATHS = %w[
+    bun.lockb
+    package-lock.json
+    package.json
+    pnpm-lock.yaml
+    postcss.config.js
+    tailwind.config.js
+    vite.config.js
+    vite.config.mjs
+    vite.config.mts
+    vite.config.ts
+    windi.config.ts
+    yarn.lock
+  ].freeze
+
+public
+
+  # Define getters for the configuration options.
+  (CONFIGURABLE_WITH_ENV + NOT_CONFIGURABLE_WITH_ENV).each do |option|
+    define_method(option) { @config[option] }
+  end
+end