vite_rails 1.0.12 → 2.0.5

data/lib/vite_rails/dev_server.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-# Public: Allows to verify if a Vite development server is already running.
-class ViteRails::DevServer
-  # Public: Configure dev server connection timeout (in seconds).
-  # Example:
-  #   ViteRails.dev_server.connect_timeout = 1
-  cattr_accessor(:connect_timeout) { 0.01 }
-
-  def initialize(config)
-    @config = config
-  end
-
-  # Public: Returns true if the Vite development server is reachable.
-  def running?
-    Socket.tcp(host, port, connect_timeout: connect_timeout).close
-    true
-  rescue StandardError
-    false
-  end
-
-  delegate :host, :port, to: :@config
-end

data/lib/vite_rails/dev_server_proxy.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack/proxy'
-
-# Public: Allows to relay asset requests to the Vite development server.
-class ViteRails::DevServerProxy < Rack::Proxy
-  VITE_DEPENDENCY_PREFIX = '/@'
-
-  def initialize(app = nil, options = {})
-    @vite_rails = options.delete(:vite_rails) || ViteRails.instance
-    options[:streaming] = false if Rails.env.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(env)
-    else
-      @app.call(env)
-    end
-  end
-
-private
-
-  delegate :config, :dev_server_running?, to: :@vite_rails
-
-  def rewrite_uri_for_vite(env)
-    uri = env.fetch('REQUEST_URI') { [env['PATH_INFO'], env['QUERY_STRING']].reject(&:blank?).join('?') }
-      .sub(vite_asset_url_prefix, '/')
-    env['PATH_INFO'], env['QUERY_STRING'] = (env['REQUEST_URI'] = uri).split('?')
-  end
-
-  def forward_to_vite_dev_server(env)
-    rewrite_uri_for_vite(env)
-    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, query, referer = env['PATH_INFO'], env['QUERY_STRING'], env['HTTP_REFERER']
-    return true if path.start_with?(vite_asset_url_prefix) # Vite asset
-    return true if path.start_with?(VITE_DEPENDENCY_PREFIX) # Packages and imports
-    return true if query&.start_with?('t=') # Hot Reload for a stylesheet
-    return true if query&.start_with?('import&') # Hot Reload for an imported entrypoint
-    return true if referer && URI.parse(referer).path.start_with?(vite_asset_url_prefix) # Entry imported from another entry.
-  end
-
-  def vite_asset_url_prefix
-    @vite_asset_url_prefix ||= "/#{ config.public_output_dir }/"
-  end
-end

data/lib/vite_rails/helper.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-# Public: Allows to render HTML tags for scripts and styles processed by Vite.
-module ViteRails::Helper
-  DEFAULT_VITE_SKIP_PRELOAD_TAGS = Rails.gem_version < Gem::Version.new('5.2.0')
-
-  # Public: Returns the current Vite Rails instance.
-  def current_vite_instance
-    ViteRails.instance
-  end
-
-  # Public: Renders a script tag for vite/client to enable HMR in development.
-  def vite_client_tag
-    return unless current_vite_instance.dev_server_running?
-
-    content_tag('script', '', src: current_vite_instance.manifest.prefix_vite_asset('@vite/client'), type: 'module')
-  end
-
-  # Public: Resolves the path for the specified Vite asset.
-  #
-  # Example:
-  #   <%= vite_asset_path 'calendar.css' %> # => "/vite/assets/calendar-1016838bab065ae1e122.css"
-  def vite_asset_path(name, **options)
-    path_to_asset current_vite_instance.manifest.lookup!(name, **options).fetch('file')
-  end
-
-  # Public: Renders a <script> tag for the specified Vite entrypoints.
-  def vite_javascript_tag(*names,
-                          type: 'module',
-                          asset_type: :javascript,
-                          skip_preload_tags: DEFAULT_VITE_SKIP_PRELOAD_TAGS,
-                          skip_style_tags: false,
-                          crossorigin: 'anonymous',
-                          **options)
-    js_entries = names.map { |name| current_vite_instance.manifest.lookup!(name, type: asset_type) }
-    js_tags = javascript_include_tag(*js_entries.map { |entry| entry['file'] }, crossorigin: crossorigin, type: type, **options)
-
-    preload_entries = js_entries.flat_map { |entry| entry['imports'] }.compact.uniq
-
-    unless skip_preload_tags || current_vite_instance.dev_server_running?
-      preload_paths = preload_entries.map { |entry| entry['file'] }.compact.uniq
-      preload_tags = preload_paths.map { |path| preload_link_tag(path, crossorigin: crossorigin) }
-    end
-
-    unless skip_style_tags || current_vite_instance.dev_server_running?
-      style_paths = (js_entries + preload_entries).flat_map { |entry| entry['css'] }.compact.uniq
-      style_tags = stylesheet_link_tag(*style_paths)
-    end
-
-    safe_join [js_tags, preload_tags, style_tags]
-  end
-
-  # Public: Renders a <script> tag for the specified Vite entrypoints.
-  #
-  # NOTE: Because TypeScript is not a valid target in browsers, we only specify
-  # the ts file when running the Vite development server.
-  def vite_typescript_tag(*names, **options)
-    vite_javascript_tag(*names, asset_type: :typescript, extname: false, **options)
-  end
-
-  # Public: Renders a <link> tag for the specified Vite entrypoints.
-  def vite_stylesheet_tag(*names, **options)
-    stylesheet_link_tag(*sources_from_vite_manifest(names, type: :stylesheet), **options)
-  end
-
-private
-
-  def sources_from_vite_manifest(names, type:)
-    names.map { |name| vite_asset_path(name, type: type) }
-  end
-end

data/lib/vite_rails/manifest.rb

@@ -1,143 +0,0 @@
-# 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 ViteRails::Manifest
-  class MissingEntryError < StandardError
-  end
-
-  def initialize(vite_rails)
-    @vite_rails = vite_rails
-  end
-
-  # Public: Strict version of lookup.
-  #
-  # Returns a relative path for the asset, or raises an error if not found.
-  def lookup!(*args, **options)
-    lookup(*args, **options) || missing_entry_error(*args, **options)
-  end
-
-  # Public: Computes the path for a given Vite asset using manifest.json.
-  #
-  # Returns a relative path, or nil if the asset is not found.
-  #
-  # Example:
-  #   ViteRails.manifest.lookup('calendar.js')
-  #   # { "file" => "/vite/assets/calendar-1016838bab065ae1e122.js", "imports" => [] }
-  def lookup(name, type: nil)
-    build if should_build?
-
-    find_manifest_entry(with_file_extension(name, type))
-  end
-
-  # Public: Refreshes the cached mappings by reading the updated manifest files.
-  def refresh
-    @manifest = load_manifest
-  end
-
-  # Public: Scopes an asset to the output folder in public, as a path.
-  def prefix_vite_asset(path)
-    File.join("/#{ config.public_output_dir }", path)
-  end
-
-private
-
-  delegate :config, :builder, :dev_server_running?, to: :@vite_rails
-
-  # 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.to_s) }
-    else
-      manifest[name.to_s]
-    end
-  end
-
-  # Internal: Performs a Vite build.
-  def build
-    ViteRails.logger.tagged('Vite') { builder.build }
-  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
-    files = [config.manifest_path, config.assets_manifest_path].select(&:exist?)
-    files.map { |path| JSON.parse(path.read) }.inject({}, &:merge).tap(&method(:resolve_references))
-  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'])
-      entry['css'] = Array.wrap(entry['css']).map { |path| prefix_vite_asset(path) } if entry['css']
-      entry['imports']&.map! { |name| manifest.fetch(name) }
-    end
-  end
-
-  # Internal: Adds a file extension to the file name, unless it already has one.
-  def with_file_extension(name, entry_type)
-    return name unless File.extname(name.to_s).empty?
-
-    extension = extension_for_type(entry_type)
-    extension ? "#{ name }.#{ extension }" : name
-  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, type: nil, **_options)
-    file_name = with_file_extension(name, type)
-    raise ViteRails::Manifest::MissingEntryError, <<~MSG
-      Vite Rails can't find #{ file_name } in #{ config.manifest_path } or #{ config.assets_manifest_path }.
-
-      Possible causes:
-      #{ missing_entry_causes.map { |cause| "\t- #{ cause }" }.join("\n") }
-
-      Content in your manifests:
-      #{ JSON.pretty_generate(@manifest) }
-    MSG
-  end
-
-  def missing_entry_causes
-    local = config.auto_build
-    [
-      (dev_server_running? && 'Vite has not yet re-built your latest changes.'),
-      (local && !dev_server_running? && "\"autoBuild\": false in your #{ config.mode } configuration."),
-      (local && !dev_server_running? && 'The Vite development server has crashed or is no longer available.'),
-      'You have misconfigured config/vite.json file.',
-      (!local && 'Assets have not been precompiled'),
-    ].select(&:present?)
-  rescue StandardError
-    []
-  end
-end

data/lib/vite_rails/runner.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-# Public: Executes Vite commands, providing conveniences for debugging.
-class ViteRails::Runner
-  def initialize(argv)
-    detect_unsupported_switches!(argv)
-    @argv = argv
-  end
-
-  # Public: Executes Vite with the specified arguments.
-  def run
-    execute_command(@argv.clone)
-  end
-
-private
-
-  UNSUPPORTED_SWITCHES = %w[--host --port --https --root -r --config -c]
-  private_constant :UNSUPPORTED_SWITCHES
-
-  # Internal: Allows to prevent configuration mistakes by ensuring the Rails app
-  # and vite-plugin-ruby are using the same configuration for the dev server.
-  def detect_unsupported_switches!(args)
-    return unless (unsupported = UNSUPPORTED_SWITCHES & args).any?
-
-    $stdout.puts "Please set the following switches in your vite.json instead: #{ unsupported }."
-    exit!
-  end
-
-  # Internal: Executes the command with the specified arguments.
-  def execute_command(args)
-    cmd = vite_executable
-    cmd.prepend('node', '--inspect-brk') if args.include?('--debug')
-    cmd.prepend('node', '--trace-deprecation') if args.delete('--trace-deprecation')
-    args.append('--mode', ViteRails.mode) unless args.include?('--mode') || args.include?('-m')
-    cmd += args
-    Dir.chdir(File.expand_path('.', Dir.pwd)) { Kernel.exec(ViteRails.config.to_env, *cmd) }
-  end
-
-  # Internal: Resolves to an executable for Vite.
-  def vite_executable
-    executable_exists?(path = vite_bin_path) ? [path] : %w[yarn vite]
-  end
-
-  # Internal: Only so that we can easily cover both paths in tests
-  def executable_exists?(path)
-    File.exist?(path)
-  end
-
-  # Internal: Returns a path where a Vite executable should be found.
-  def vite_bin_path
-    ENV["#{ ViteRails::ENV_PREFIX }_VITE_BIN_PATH"] || `yarn bin vite`.chomp.presence || "#{ `npm bin`.chomp }/vite"
-  end
-end

data/package.json

@@ -1,19 +0,0 @@
-{
-  "name": "only-for-workflows",
-  "version": "unknown",
-  "license": "MIT",
-  "scripts": {
-    "docs": "npm -C docs run docs",
-    "docs:build": "npm -C docs run docs:build",
-    "docs:search": "npm -C docs run docs:search",
-    "docs:lint": "npm -C docs run lint",
-    "build": "rm -rf package/dist && npm -C package run prerelease",
-    "release": "rm -rf package/dist && npm -C package run release",
-    "lint": "npm -C package run lint",
-    "test": "npm -C package run test"
-  },
-  "dependencies": {
-    "vite": "^2.0.0-beta.56",
-    "vite-plugin-ruby": "^1.0.6"
-  }
-}

data/package/default.vite.json

@@ -1,16 +0,0 @@
-{
-  "assetHost": null,
-  "assetsDir": "assets",
-  "autoBuild": false,
-  "buildCacheDir": "tmp/cache/vite",
-  "publicOutputDir": "vite",
-  "configPath": "config/vite.json",
-  "publicDir": "public",
-  "entrypointsDir": "entrypoints",
-  "sourceCodeDir": "app/frontend",
-  "host": "localhost",
-  "https": null,
-  "port": 3036,
-  "hideBuildConsoleOutput": false,
-  "watchAdditionalPaths": []
-}

data/test/builder_test.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BuilderTest < ViteRails::Test
-  def setup
-    refresh_config
-    ViteRails.builder.send(:files_digest_path).tap do |path|
-      path.delete if path.exist?
-    end
-  end
-
-  def teardown
-    setup
-  end
-
-  def vite_env
-    ViteRails.config.to_env
-  end
-
-  def test_custom_environment_variables
-    assert_nil vite_env['FOO']
-    ViteRails.env['FOO'] = 'BAR'
-    assert vite_env['FOO'] == 'BAR'
-  end
-
-  def test_freshness
-    assert ViteRails.builder.stale?
-    assert !ViteRails.builder.fresh?
-  end
-
-  def test_build
-    assert !ViteRails.builder.build
-  end
-
-  def test_freshness_on_build_success
-    assert ViteRails.builder.stale?
-    status = OpenStruct.new(success?: true)
-    Open3.stub :capture3, [:sterr, :stdout, status] do
-      assert ViteRails.builder.build
-      assert ViteRails.builder.fresh?
-    end
-  end
-
-  def test_freshness_on_build_fail
-    assert ViteRails.builder.stale?
-    status = OpenStruct.new(success?: false)
-    Open3.stub :capture3, [:sterr, :stdout, status] do
-      assert !ViteRails.builder.build
-      assert ViteRails.builder.fresh?
-    end
-  end
-
-  def test_files_digest_path
-    assert_equal ViteRails.builder.send(:files_digest_path).basename.to_s, "last-compilation-digest-#{ ViteRails.config.mode }"
-  end
-
-  def test_watched_files_digest
-    previous_digest = ViteRails.builder.send(:watched_files_digest)
-    refresh_config
-    assert_equal previous_digest, ViteRails.builder.send(:watched_files_digest)
-  end
-
-  def test_external_env_variables
-    assert_equal 'production', vite_env['VITE_RUBY_MODE']
-    assert_equal Rails.root.to_s, vite_env['VITE_RUBY_ROOT']
-
-    ENV['VITE_RUBY_MODE'] = 'foo.bar'
-    ENV['VITE_RUBY_ROOT'] = '/baz'
-    refresh_config
-    assert_equal 'foo.bar', vite_env['VITE_RUBY_MODE']
-    assert_equal '/baz', vite_env['VITE_RUBY_ROOT']
-  ensure
-    ENV.delete('VITE_RUBY_MODE')
-    ENV.delete('VITE_RUBY_ROOT')
-  end
-end