vite_ruby-roda 3.9.2.1

data/lib/vite_ruby/dev_server_proxy.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "rack/proxy"
+
+# Public: Allows to relay asset requests to the Vite development server.
+class ViteRuby::DevServerProxy < Rack::Proxy
+  HOST_WITH_PORT_REGEX = %r{^(.+?)(:\d+)/}
+  VITE_DEPENDENCY_PREFIX = "/@"
+
+  def initialize(app = nil, options = {})
+    @vite_ruby = options.delete(:vite_ruby) || ViteRuby.instance
+    options[:streaming] = false if config.mode == "test" && !options.key?(:streaming)
+    super
+  end
+
+  # Rack: Intercept asset requests and send them to the Vite server.
+  def perform_request(env)
+    if vite_should_handle?(env) && dev_server_running?
+      forward_to_vite_dev_server(env)
+      super
+    else
+      @app.call(env)
+    end
+  end
+
+private
+
+  extend Forwardable
+
+  def_delegators :@vite_ruby, :config, :dev_server_running?
+
+  def rewrite_uri_for_vite(env)
+    uri = env.fetch("REQUEST_URI") { [env["PATH_INFO"], env["QUERY_STRING"]].reject { |str| str.to_s.strip.empty? }.join("?") }
+    env["PATH_INFO"], env["QUERY_STRING"] = (env["REQUEST_URI"] = normalize_uri(uri)).split("?")
+  end
+
+  def normalize_uri(uri)
+    uri
+      .sub(HOST_WITH_PORT_REGEX, "/") # Hanami adds the host and port.
+      .sub(".ts.js", ".ts") # Hanami's javascript helper always adds the extension.
+      .sub(/\.(sass|scss|styl|stylus|less|pcss|postcss)\.css$/, '.\1') # Rails' stylesheet_link_tag always adds the extension.
+  end
+
+  def forward_to_vite_dev_server(env)
+    rewrite_uri_for_vite(env)
+    env["QUERY_STRING"] ||= ""
+    env["HTTP_HOST"] = env["HTTP_X_FORWARDED_HOST"] = config.host
+    env["HTTP_X_FORWARDED_SERVER"] = config.host_with_port
+    env["HTTP_PORT"] = env["HTTP_X_FORWARDED_PORT"] = config.port.to_s
+    env["HTTP_X_FORWARDED_PROTO"] = env["HTTP_X_FORWARDED_SCHEME"] = config.protocol
+    env["HTTPS"] = env["HTTP_X_FORWARDED_SSL"] = "off" unless config.https
+    env["SCRIPT_NAME"] = ""
+  end
+
+  def vite_should_handle?(env)
+    path = normalize_uri(env["PATH_INFO"])
+    return true if path.start_with?(vite_url_prefix) # Vite asset
+
+    true if file_in_vite_root?(path) # Fallback if Vite can serve the file
+  end
+
+  # NOTE: When using an empty 'public_output_dir', we need to rely on a
+  # filesystem check to check whether Vite should serve the request.
+  def file_in_vite_root?(path)
+    path.include?(".") && # Check for extension, avoid filesystem if possible.
+      config.vite_root_dir.join(path.start_with?("/") ? path[1..] : path).file?
+  end
+
+  # NOTE: Vite is configured to use 'public_output_dir' as the base, which can
+  # be customized by the user in development to not match any of the routes.
+  #
+  # If the path starts with that prefix, it will be redirected to Vite.
+  def vite_url_prefix
+    @vite_url_prefix ||= config.public_output_dir.empty? ? VITE_DEPENDENCY_PREFIX : "/#{config.public_output_dir}/"
+  end
+end

data/lib/vite_ruby/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Internal: Provides common functionality for errors.
+class ViteRuby::Error < StandardError
+  def message
+    super.sub(":troubleshooting:", <<~MSG)
+      Visit the Troubleshooting guide for more information:
+        https://vite-ruby.netlify.app/guide/troubleshooting.html#troubleshooting
+    MSG
+  end
+end

data/lib/vite_ruby/io.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "open3"
+
+# Public: Builds on top of Ruby I/O open3 providing a friendlier experience.
+module ViteRuby::IO
+  class << self
+    # Internal: A modified version of capture3 that can continuosly print stdout.
+    # NOTE: Streaming output provides a better UX when running bin/vite build.
+    def capture(*cmd, with_output: $stdout.method(:puts), stdin_data: "", **opts)
+      return Open3.capture3(*cmd, **opts) unless with_output
+
+      Open3.popen3(*cmd, **opts) { |stdin, stdout, stderr, wait_threads|
+        stdin << stdin_data
+        stdin.close
+        out = Thread.new { read_lines(stdout, &with_output) }
+        err = Thread.new { stderr.read }
+        [out.value, err.value.to_s, wait_threads.value]
+      }
+    end
+
+    # Internal: Reads and yield every line in the stream. Returns the full content.
+    def read_lines(io)
+      buffer = +""
+      while line = io.gets
+        buffer << line
+        yield line
+      end
+      buffer
+    end
+  end
+end

data/lib/vite_ruby/manifest.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+# Public: Registry for accessing resources managed by Vite, using a generated
+# manifest file which maps entrypoint names to file paths.
+#
+# Example:
+#   lookup_entrypoint('calendar', type: :javascript)
+#   => { "file" => "/vite/assets/calendar-1016838bab065ae1e314.js", "imports" => [] }
+#
+# NOTE: Using `"autoBuild": true` in `config/vite.json` file will trigger a build
+# on demand as needed, before performing any lookup.
+class ViteRuby::Manifest
+  def initialize(vite_ruby)
+    @vite_ruby = vite_ruby
+    @build_mutex = Mutex.new if config.auto_build
+  end
+
+  # Public: Returns the path for the specified Vite entrypoint file.
+  #
+  # Raises an error if the resource could not be found in the manifest.
+  def path_for(name, **options)
+    lookup!(name, **options).fetch("file")
+  end
+
+  # Public: Returns scripts, imported modules, and stylesheets for the specified
+  # entrypoint files.
+  def resolve_entries(*names, **options)
+    entries = names.map { |name| lookup!(name, **options) }
+    script_paths = entries.map { |entry| entry.fetch("file") }
+
+    imports = dev_server_running? ? [] : entries.flat_map { |entry| entry["imports"] }.compact
+    {
+      scripts: script_paths,
+      imports: imports.filter_map { |entry| entry.fetch("file") }.uniq,
+      stylesheets: dev_server_running? ? [] : (entries + imports).flat_map { |entry| entry["css"] }.compact.uniq,
+    }
+  end
+
+  # Public: Refreshes the cached mappings by reading the updated manifest files.
+  def refresh
+    @manifest = load_manifest
+  end
+
+  # Public: The path from where the browser can download the Vite HMR client.
+  def vite_client_src
+    prefix_asset_with_host("@vite/client") if dev_server_running?
+  end
+
+  # Public: The content of the preamble needed by the React Refresh plugin.
+  def react_refresh_preamble
+    if dev_server_running?
+      <<~REACT_REFRESH
+        <script type="module">
+          #{react_preamble_code}
+        </script>
+      REACT_REFRESH
+    end
+  end
+
+  # Public: Source script for the React Refresh plugin.
+  def react_preamble_code
+    if dev_server_running?
+      <<~REACT_PREAMBLE_CODE
+        import RefreshRuntime from '#{prefix_asset_with_host("@react-refresh")}'
+        RefreshRuntime.injectIntoGlobalHook(window)
+        window.$RefreshReg$ = () => {}
+        window.$RefreshSig$ = () => (type) => type
+        window.__vite_plugin_react_preamble_installed__ = true
+      REACT_PREAMBLE_CODE
+    end
+  end
+
+protected
+
+  # Internal: Strict version of lookup.
+  #
+  # Returns a relative path for the asset, or raises an error if not found.
+  def lookup!(name, **options)
+    lookup(name, **options) || missing_entry_error(name, **options)
+  end
+
+  # Internal: Computes the path for a given Vite asset using manifest.json.
+  #
+  # Returns a relative path, or nil if the asset is not found.
+  #
+  # Example:
+  #   manifest.lookup('calendar.js')
+  #   => { "file" => "/vite/assets/calendar-1016838bab065ae1e122.js", "imports" => [] }
+  def lookup(name, **options)
+    @build_mutex.synchronize { builder.build || (return nil) } if should_build?
+
+    find_manifest_entry resolve_entry_name(name, **options)
+  end
+
+private
+
+  # Internal: The prefix used by Vite.js to request files with an absolute path.
+  FS_PREFIX = "/@fs/"
+
+  extend Forwardable
+
+  def_delegators :@vite_ruby, :config, :builder, :dev_server_running?
+
+  # NOTE: Auto compilation is convenient when running tests, when the developer
+  # won't focus on the frontend, or when running the Vite server is not desired.
+  def should_build?
+    config.auto_build && !dev_server_running?
+  end
+
+  # Internal: Finds the specified entry in the manifest.
+  def find_manifest_entry(name)
+    if dev_server_running?
+      {"file" => prefix_vite_asset(name)}
+    else
+      manifest[name]
+    end
+  end
+
+  # Internal: The parsed data from manifest.json.
+  #
+  # NOTE: When using build-on-demand in development and testing, the manifest
+  # is reloaded automatically before each lookup, to ensure it's always fresh.
+  def manifest
+    return refresh if config.auto_build
+
+    @manifest ||= load_manifest
+  end
+
+  # Internal: Loads and merges the manifest files, resolving the asset paths.
+  def load_manifest
+    config.manifest_paths
+      .map { |path| JSON.parse(path.read) }
+      .inject({}, &:merge)
+      .tap { |manifest| resolve_references(manifest) }
+  end
+
+  # Internal: Scopes an asset to the output folder in public, as a path.
+  def prefix_vite_asset(path)
+    File.join(vite_asset_origin || "/", config.public_output_dir, path)
+  end
+
+  # Internal: Prefixes an asset with the `asset_host` for tags that do not use
+  # the framework tag helpers.
+  def prefix_asset_with_host(path)
+    File.join(vite_asset_origin || config.asset_host || "/", config.public_output_dir, path)
+  end
+
+  # Internal: The origin of assets managed by Vite.
+  def vite_asset_origin
+    config.origin if dev_server_running? && config.skip_proxy
+  end
+
+  # Internal: Resolves the paths that reference a manifest entry.
+  def resolve_references(manifest)
+    manifest.each_value do |entry|
+      entry["file"] = prefix_vite_asset(entry["file"])
+      %w[css assets].each do |key|
+        entry[key] = entry[key].map { |path| prefix_vite_asset(path) } if entry[key]
+      end
+      entry["imports"]&.map! { |name| manifest.fetch(name) }
+    end
+  end
+
+  # Internal: Resolves the manifest entry name for the specified resource.
+  def resolve_entry_name(name, type: nil)
+    return resolve_virtual_entry(name) if type == :virtual
+
+    name = with_file_extension(name.to_s, type)
+    raise ArgumentError, "Asset names can not be relative. Found: #{name}" if name.start_with?(".")
+
+    # Explicit path, relative to the source_code_dir.
+    name.sub(%r{^~/(.+)$}) { return Regexp.last_match(1) }
+
+    # Explicit path, relative to the project root.
+    name.sub(%r{^/(.+)$}) { return resolve_absolute_entry(Regexp.last_match(1)) }
+
+    # Sugar: Prefix with the entrypoints dir if the path is not nested.
+    name.include?("/") ? name : File.join(config.entrypoints_dir, name)
+  end
+
+  # Internal: Entry names in the manifest are relative to the Vite.js.
+  # During develoment, files outside the root must be requested explicitly.
+  def resolve_absolute_entry(name)
+    if dev_server_running?
+      File.join(FS_PREFIX, config.root, name)
+    else
+      config.root.join(name).relative_path_from(config.vite_root_dir).to_s
+    end
+  end
+
+  # Internal: Resolves a virtual entry by walking all the manifest keys.
+  def resolve_virtual_entry(name)
+    manifest.keys.find { |file| file.include?(name) } || name
+  end
+
+  # Internal: Adds a file extension to the file name, unless it already has one.
+  def with_file_extension(name, entry_type)
+    if File.extname(name).empty? && (ext = extension_for_type(entry_type))
+      "#{name}.#{ext}"
+    else
+      name
+    end
+  end
+
+  # Internal: Allows to receive :javascript and :stylesheet as :type in helpers.
+  def extension_for_type(entry_type)
+    case entry_type
+    when :javascript then "js"
+    when :stylesheet then "css"
+    when :typescript then "ts"
+    else entry_type
+    end
+  end
+
+  # Internal: Raises a detailed message when an entry is missing in the manifest.
+  def missing_entry_error(name, **options)
+    raise ViteRuby::MissingEntrypointError.new(
+      file_name: resolve_entry_name(name, **options),
+      last_build: builder.last_build_metadata,
+      manifest: @manifest,
+      config: config,
+    )
+  end
+end

data/lib/vite_ruby/missing_entrypoint_error.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Internal: Raised when an entry is not found in the build manifest.
+#
+# NOTE: The complexity here is justified by the improved usability of providing
+# a more specific error message depending on the situation.
+class ViteRuby::MissingEntrypointError < ViteRuby::Error
+  attr_reader :file_name, :last_build, :manifest, :config
+
+  def initialize(file_name:, last_build:, manifest:, config:)
+    @file_name, @last_build, @manifest, @config = file_name, last_build, manifest, config
+    super <<~MSG
+      Vite Ruby can't find #{file_name} in the manifests.
+
+      Possible causes:
+      #{possible_causes(last_build)}
+      :troubleshooting:
+      #{"Manifest files found:\n#{config.manifest_paths.map { |path| "  #{path.relative_path_from(config.root)}" }.join("\n")}\n" if last_build.success}
+      #{"Content in your manifests:\n#{JSON.pretty_generate(manifest)}\n" if last_build.success}
+      #{"Last build in #{config.mode} mode:\n#{last_build.to_json}\n" if last_build.success}
+    MSG
+  end
+
+  def possible_causes(last_build)
+    if last_build.success == false
+      FAILED_BUILD_CAUSES
+        .sub(":mode:", config.mode)
+        .sub(":errors:", last_build.errors.to_s.gsub(/^(?!$)/, "  "))
+    elsif config.auto_build
+      DEFAULT_CAUSES
+    else
+      DEFAULT_CAUSES + NO_AUTO_BUILD_CAUSES
+    end
+  end
+
+  FAILED_BUILD_CAUSES = <<~MSG
+      - The last build failed. Try running `bin/vite build --clear --mode=:mode:` manually and check for errors.
+
+    Errors:
+    :errors:
+  MSG
+
+  DEFAULT_CAUSES = <<-MSG
+  - The file path is incorrect.
+  - The file is not in the entrypoints directory.
+  - Some files are outside the sourceCodeDir, and have not been added to watchAdditionalPaths.
+  MSG
+
+  NO_AUTO_BUILD_CAUSES = <<-MSG
+  - You have not run `bin/vite dev` to start Vite, or the dev server is not reachable.
+  - "autoBuild" is set to `false` in your config/vite.json for this environment.
+  MSG
+end

data/lib/vite_ruby/missing_executable_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Internal: Raised when the Vite executable can not be found.
+class ViteRuby::MissingExecutableError < ViteRuby::Error
+  def initialize(error = nil)
+    super <<~MSG
+      ❌ The vite binary is not available. Have you installed the npm packages?
+
+      :troubleshooting:
+      #{error}
+    MSG
+  end
+end

data/lib/vite_ruby/runner.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Public: Executes Vite commands, providing conveniences for debugging.
+class ViteRuby::Runner
+  def initialize(vite_ruby)
+    @vite_ruby = vite_ruby
+  end
+
+  # Public: Executes Vite with the specified arguments.
+  def run(argv, exec: false)
+    config.within_root {
+      cmd = command_for(argv)
+      return Kernel.exec(*cmd) if exec
+
+      log_or_noop = ->(line) { logger.info("vite") { line } } unless config.hide_build_console_output
+      ViteRuby::IO.capture(*cmd, chdir: config.root, with_output: log_or_noop)
+    }
+  rescue Errno::ENOENT => error
+    raise ViteRuby::MissingExecutableError, error
+  end
+
+private
+
+  extend Forwardable
+
+  def_delegators :@vite_ruby, :config, :logger, :env
+
+  # Internal: Returns an Array with the command to run.
+  def command_for(args)
+    [config.to_env(env)].tap do |cmd|
+      exec_args, vite_args = args.partition { |arg| arg.start_with?("--node-options") }
+      cmd.push(*vite_executable(*exec_args))
+      cmd.push(*vite_args)
+      cmd.push("--mode", config.mode) unless args.include?("--mode") || args.include?("-m")
+    end
+  end
+
+  # Internal: Resolves to an executable for Vite.
+  def vite_executable(*exec_args)
+    bin_path = config.vite_bin_path
+    return [bin_path] if bin_path && File.exist?(bin_path)
+
+    x = case config.package_manager
+    when "npm" then %w[npx]
+    when "pnpm" then %w[pnpm exec]
+    when "bun" then %w[bun x --bun]
+    when "yarn" then %w[yarn]
+    else raise ArgumentError, "Unknown package manager #{config.package_manager.inspect}"
+    end
+
+    [*x, *exec_args, "vite"]
+  end
+end

data/lib/vite_ruby/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class ViteRuby
+  VERSION = "3.9.2.1"
+
+  # Internal: Versions used by default when running `vite install`.
+  DEFAULT_VITE_VERSION = "^6.2.6"
+  DEFAULT_PLUGIN_VERSION = "^5.1.1"
+end

data/lib/vite_ruby.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "logger"
+require "forwardable"
+require "pathname"
+require "socket"
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/install")
+loader.ignore("#{__dir__}/tasks")
+loader.ignore("#{__dir__}/exe")
+loader.inflector.inflect("cli" => "CLI")
+loader.inflector.inflect("ssr" => "SSR")
+loader.inflector.inflect("io" => "IO")
+loader.setup
+
+class ViteRuby
+  # Internal: Prefix used for environment variables that modify the configuration.
+  ENV_PREFIX = "VITE_RUBY"
+
+  # Internal: Companion libraries for Vite Ruby, and their target framework.
+  COMPANION_LIBRARIES = {
+    "vite_rails" => "rails",
+    "vite_hanami" => "hanami",
+    "vite_padrino" => "padrino",
+    "jekyll-vite" => "jekyll",
+    "vite_rails_legacy" => "rails",
+    "vite_plugin_legacy" => "rack",
+    "roda-vite" => "roda",
+  }
+
+  class << self
+    extend Forwardable
+
+    def_delegators :instance, :config, :configure, :commands, :digest, :env, :run, :run_proxy?
+    def_delegators :config, :mode
+
+    def instance
+      @instance ||= new
+    end
+
+    # Internal: Refreshes the manifest.
+    def bootstrap
+      instance.manifest.refresh
+    end
+
+    # Internal: Loads all available rake tasks.
+    def install_tasks
+      load File.expand_path("tasks/vite.rake", __dir__)
+    end
+
+    # Internal: Creates a new instance with the specified options.
+    def reload_with(**config_options)
+      @instance = new(**config_options)
+    end
+
+    # Internal: Detects if the application has installed a framework-specific
+    # variant of Vite Ruby.
+    def framework_libraries
+      COMPANION_LIBRARIES.filter_map { |name, framework|
+        if library = Gem.loaded_specs[name]
+          [framework, library]
+        end
+      }
+    end
+  end
+
+  attr_writer :logger
+
+  def initialize(**config_options)
+    @config_options = config_options
+  end
+
+  def logger
+    @logger ||= Logger.new($stdout)
+  end
+
+  # Public: Returns a digest of all the watched files, allowing to detect
+  # changes. Useful to perform version checks in single-page applications.
+  def digest
+    builder.send(:watched_files_digest)
+  end
+
+  # Public: Returns true if the Vite development server is currently running.
+  # NOTE: Checks only once every second since every lookup calls this method.
+  def dev_server_running?
+    return false unless run_proxy?
+    return @running if defined?(@running) && Time.now - @running_checked_at < 1
+
+    begin
+      Socket.tcp(config.host, config.port, connect_timeout: config.dev_server_connect_timeout).close
+      @running = true
+    rescue
+      @running = false
+    ensure
+      @running_checked_at = Time.now
+    end
+  end
+
+  # Public: Additional environment variables to pass to Vite.
+  #
+  # Example:
+  #   ViteRuby.env['VITE_RUBY_CONFIG_PATH'] = 'config/alternate_vite.json'
+  def env
+    @env ||= ENV.select { |key, _| key.start_with?(ENV_PREFIX) }
+  end
+
+  # Public: The proxy for assets should only run in development mode.
+  def run_proxy?
+    config.mode == "development" || (config.mode == "test" && !ENV["CI"])
+  rescue => error
+    logger.error("Failed to check mode for Vite: #{error.message}")
+    false
+  end
+
+  # Internal: Executes the vite binary.
+  def run(argv, **options)
+    (@runner ||= ViteRuby::Runner.new(self)).run(argv, **options)
+  end
+
+  # Public: Keeps track of watched files and triggers builds as needed.
+  def builder
+    @builder ||= ViteRuby::Builder.new(self)
+  end
+
+  # Internal: Helper to run commands related with Vite.
+  def commands
+    @commands ||= ViteRuby::Commands.new(self)
+  end
+
+  # Public: Current instance configuration for Vite.
+  def config
+    unless defined?(@config)
+      configure
+      @config.load_ruby_config
+    end
+
+    @config
+  end
+
+  # Public: Allows overriding the configuration for this instance.
+  def configure(**options)
+    @config = ViteRuby::Config.resolve_config(**@config_options, **options)
+  end
+
+  # Public: Enables looking up assets managed by Vite using name and type.
+  def manifest
+    @manifest ||= ViteRuby::Manifest.new(self)
+  end
+end
+
+require "vite_ruby/version"

data/templates/config/vite.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vite'
+import RubyPlugin from 'vite-plugin-ruby'
+
+export default defineConfig({
+  plugins: [
+    RubyPlugin(),
+  ],
+})

data/templates/config/vite.json

@@ -0,0 +1,16 @@
+{
+  "all": {
+    "sourceCodeDir": "frontend",
+    "watchAdditionalPaths": []
+  },
+  "development": {
+    "autoBuild": true,
+    "publicOutputDir": "vite-dev",
+    "port": 3036
+  },
+  "test": {
+    "autoBuild": true,
+    "publicOutputDir": "vite-test",
+    "port": 3037
+  }
+}

data/templates/entrypoints/application.js

@@ -0,0 +1,8 @@
+// To see this message, follow the instructions for your Ruby framework.
+//
+// When using a plain API, perhaps it's better to generate an HTML entrypoint
+// and link to the scripts and stylesheets, and let Vite transform it.
+console.log('Vite ⚡️ Ruby')
+
+// Example: Import a stylesheet in <sourceCodeDir>/index.css
+// import '~/index.css'