vite_rails 1.0.9 → 2.0.1

data/lib/vite_rails/helper.rb

@@ -1,69 +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::VERSION::MAJOR <= 5 && Rails::VERSION::MINOR < 2
-
-  # 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
-    content_tag('script', '', src: '/@vite/client', type: 'module') if ViteRails.dev_server_running?
-  end
-
-  # Public: Computes the relative path for the specified given Vite asset.
-  #
-  # Example:
-  #   <%= vite_asset_path 'calendar.css' %> # => "/vite/assets/calendar-1016838bab065ae1e122.css"
-  def vite_asset_path(name, **options)
-    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)
-
-    unless skip_preload_tags || ViteRails.dev_server_running?
-      preload_paths = js_entries.flat_map { |entry| entry['imports'] }.compact.uniq
-      preload_tags = preload_paths.map { |path| preload_link_tag(path, crossorigin: crossorigin) }
-    end
-
-    unless skip_style_tags || ViteRails.dev_server_running?
-      style_paths = names.map { |name|
-        current_vite_instance.manifest.lookup(name.delete_suffix('.js'), type: :stylesheet)&.fetch('file')
-      }.compact
-      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, **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,139 +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.
-  def refresh
-    @manifest = load_manifest
-  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' => "/#{ config.public_output_dir.join(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: Returns a Hash with the entries in the manifest.json.
-  def load_manifest
-    if config.manifest_path.exist?
-      JSON.parse(config.manifest_path.read).each do |_, entry|
-        entry['file'] = within_public_output_dir(entry['file'])
-        entry['imports'] = entry['imports']&.map { |path| within_public_output_dir(path) }
-      end
-    else
-      {}
-    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: Scopes the paths in the manifest to the output folder in public.
-  def within_public_output_dir(path)
-    "/#{ config.public_output_dir.join(path) }"
-  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 dev_server_running? ? 'ts' : 'js'
-    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 }.
-
-      Possible causes:
-      #{ missing_entry_causes.map { |cause| "\t- #{ cause }" }.join("\n") }
-
-      Your manifest contains:
-      #{ 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."),
-      'You have misconfigured config/vite.json file.',
-      (!local && 'Assets have not been precompiled'),
-    ].select(&:itself)
-  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.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,16 +0,0 @@
-{
-  "name": "only-for-workflows",
-  "version": "unknown",
-  "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",
-    "lint": "npm -C package run lint",
-    "test": "npm -C package run test"
-  },
-  "dependencies": {
-    "vite": "^2.0.0-beta.34",
-    "vite-plugin-ruby": "^1.0.3"
-  }
-}

data/package/default.vite.json

@@ -1,15 +0,0 @@
-{
-  "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.builder.send(:vite_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

data/test/commands_test.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class CommandsTest < ViteRails::Test
-  def stub_builder(stale:, build_with_vite:)
-    ViteRails.builder.stub :stale?, stale do
-      ViteRails.builder.stub :build_with_vite, build_with_vite do
-        yield
-      end
-    end
-  end
-
-  def test_bootstrap
-    assert ViteRails.bootstrap
-  end
-
-  def test_build_returns_success_status_when_stale
-    stub_builder(stale: true, build_with_vite: true) {
-      assert_equal true, ViteRails.build
-      assert_equal true, ViteRails.build_from_rake
-    }
-  end
-
-  def test_build_returns_success_status_when_fresh
-    stub_builder(stale: false, build_with_vite: true) {
-      assert_equal true, ViteRails.build
-      assert_equal true, ViteRails.build_from_rake
-    }
-  end
-
-  def test_build_returns_failure_status_when_stale
-    stub_builder(stale: true, build_with_vite: false) {
-      assert_equal false, ViteRails.build
-    }
-  end
-
-  def test_clean
-    with_rails_env('test') { |config|
-      manifest = config.build_output_dir.join('manifest.json')
-
-      # Should not clean, the manifest does not exist.
-      config.build_output_dir.mkdir unless config.build_output_dir.exist?
-      refute ViteRails.clean
-
-      # Should not clean, the file is recent.
-      manifest.write('{}')
-      assert ViteRails.clean_from_rake(OpenStruct.new)
-      assert manifest.exist?
-
-      # Should clean if we remove age restrictions.
-      assert ViteRails.clean(keep_up_to: 0, age_in_seconds: 0)
-      assert config.build_output_dir.exist?
-      refute manifest.exist?
-    }
-  end
-
-  def test_clobber
-    with_rails_env('test') { |config|
-      config.build_output_dir.mkdir unless config.build_output_dir.exist?
-      config.build_output_dir.join('manifest.json').write('{}')
-      assert config.build_output_dir.exist?
-      ViteRails.clobber
-      refute config.build_output_dir.exist?
-    }
-  end
-end

data/test/configuration_test.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ConfigurationTest < ViteRails::Test
-  def expand_path(path)
-    File.expand_path(Pathname.new(__dir__).join(path).to_s)
-  end
-
-  def assert_path(expected, actual)
-    assert_equal expand_path(expected), actual.to_s
-  end
-
-  def assert_pathname(expected, actual)
-    assert_equal Pathname.new(expand_path("test_app/#{ expected }")), actual
-  end
-
-  def resolve_config(mode: 'production', root: test_app_path, **attrs)
-    ViteRails::Config.resolve_config(mode: mode, root: root, **attrs)
-  end
-
-  def setup
-    @config = resolve_config
-  end
-
-  def test_source_code_dir
-    assert_path 'test_app/app/frontend', @config.source_code_dir
-  end
-
-  def test_entrypoints_dir
-    assert_path 'test_app/app/frontend/entrypoints', @config.resolved_entrypoints_dir
-  end
-
-  def test_public_dir
-    assert_path 'test_app/public', @config.public_dir
-  end
-
-  def test_build_output_dir
-    assert_path 'test_app/public/vite-production', @config.build_output_dir
-
-    @config = resolve_config(config_path: 'config/vite_public_dir.json')
-    assert_path 'public/vite', @config.build_output_dir
-  end
-
-  def test_manifest_path
-    assert_path 'test_app/public/vite-production/manifest.json', @config.manifest_path
-  end
-
-  def test_build_cache_dir
-    assert_path 'test_app/tmp/cache/vite', @config.build_cache_dir
-  end
-
-  def test_watch_additional_paths
-    assert_equal [], @config.watch_additional_paths
-    @config = resolve_config(config_path: 'config/vite_additional_paths.json')
-    assert_equal ['config/*'], @config.watch_additional_paths
-  end
-
-  def test_auto_build
-    refute @config.auto_build
-
-    with_rails_env('development') do |config|
-      assert config.auto_build
-    end
-
-    with_rails_env('test') do |config|
-      assert config.auto_build
-    end
-
-    with_rails_env('staging') do |config|
-      refute config.auto_build
-    end
-  end
-
-  def test_protocol
-    assert_equal 'http', @config.protocol
-  end
-
-  def test_host_with_port
-    assert_equal 3036, @config.port
-
-    with_rails_env('development') do |config|
-      assert_equal 3535, config.port
-      assert_equal 'localhost:3535', config.host_with_port
-    end
-  end
-
-  def test_environment_vars
-    ViteRails.env = {
-      'VITE_RUBY_AUTO_BUILD' => 'true',
-      'VITE_RUBY_HOST' => 'example.com',
-      'VITE_RUBY_PORT' => '1920',
-      'VITE_RUBY_HTTPS' => 'true',
-      'VITE_RUBY_CONFIG_PATH' => 'config/vite_additional_paths.json',
-      'VITE_RUBY_BUILD_CACHE_DIR' => 'tmp/vitebuild',
-      'VITE_RUBY_PUBLIC_DIR' => 'pb',
-      'VITE_RUBY_PUBLIC_OUTPUT_DIR' => 'ft',
-      'VITE_RUBY_ASSETS_DIR' => 'as',
-      'VITE_RUBY_SOURCE_CODE_DIR' => 'app',
-      'VITE_RUBY_ENTRYPOINTS_DIR' => 'frontend/entrypoints',
-      'VITE_RUBY_HIDE_BUILD_CONSOLE_OUTPUT' => 'true',
-    }
-    @config = resolve_config
-    assert_equal true, @config.auto_build
-    assert_equal 'example.com', @config.host
-    assert_equal 1920, @config.port
-    assert_equal true, @config.https
-    assert_equal 'https', @config.protocol
-    assert_equal Pathname.new('config/vite_additional_paths.json'), @config.config_path
-    assert_pathname 'tmp/vitebuild', @config.build_cache_dir
-    assert_pathname 'pb', @config.public_dir
-    assert_equal Pathname.new('ft'), @config.public_output_dir
-    assert_pathname 'pb/ft', @config.build_output_dir
-    assert_equal 'as', @config.assets_dir
-    assert_pathname 'app', @config.source_code_dir
-    assert_equal 'frontend/entrypoints', @config.entrypoints_dir
-    assert_pathname 'app/frontend/entrypoints', @config.resolved_entrypoints_dir
-    assert_equal true, @config.hide_build_console_output
-  ensure
-    ViteRails.env = {}
-  end
-end