vite_rails 1.0.8 → 2.0.0

data/lib/vite_rails/manifest.rb

@@ -1,138 +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:)
-    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?
-
-    "#{ name }.#{ extension_for_type(entry_type) }"
-  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.to_s
-    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,56 +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', ENV['RAILS_ENV']) unless args.include?('--mode') || args.include?('-m')
-    cmd += args
-    puts cmd.join(' ')
-    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
-  rescue StandardError
-    "#{ `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.2"
-  }
-}

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,72 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BuilderTest < Minitest::Test
-  def remove_files_digest_path
-    ViteRails.builder.send(:files_digest_path).tap do |path|
-      path.delete if path.exist?
-    end
-  end
-
-  def setup
-    remove_files_digest_path
-  end
-
-  def teardown
-    remove_files_digest_path
-  end
-
-  def test_custom_environment_variables
-    assert_nil ViteRails.builder.send(:vite_env)['FOO']
-    ViteRails.env['FOO'] = 'BAR'
-    assert ViteRails.builder.send(:vite_env)['FOO'] == 'BAR'
-  ensure
-    ViteRails.env = {}
-  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
-    status = OpenStruct.new(success?: true)
-
-    assert ViteRails.builder.stale?
-    Open3.stub :capture3, [:sterr, :stdout, status] do
-      ViteRails.builder.build
-      assert ViteRails.builder.fresh?
-    end
-  end
-
-  def test_freshness_on_build_fail
-    status = OpenStruct.new(success?: false)
-
-    assert ViteRails.builder.stale?
-    Open3.stub :capture3, [:sterr, :stdout, status] do
-      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_external_env_variables
-    ViteRails.env = {}
-    assert_equal ViteRails.builder.send(:vite_env)['VITE_RUBY_MODE'], 'production'
-    assert_equal ViteRails.builder.send(:vite_env)['VITE_RUBY_ROOT'], Rails.root.to_s
-
-    ENV['VITE_RUBY_MODE'] = 'foo.bar'
-    ENV['VITE_RUBY_ROOT'] = '/baz'
-
-    assert_equal ViteRails.builder.send(:vite_env)['VITE_RUBY_MODE'], 'foo.bar'
-    assert_equal ViteRails.builder.send(:vite_env)['VITE_RUBY_ROOT'], '/baz'
-  end
-end

data/test/command_test.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class CommandTest < Minitest::Test
-  def test_compile_command_returns_success_status_when_stale
-    ViteRails.builder.stub :stale?, true do
-      ViteRails.builder.stub :run_vite, true do
-        assert_equal true, ViteRails.commands.compile
-      end
-    end
-  end
-
-  def test_compile_command_returns_success_status_when_fresh
-    ViteRails.builder.stub :stale?, false do
-      ViteRails.builder.stub :run_vite, true do
-        assert_equal true, ViteRails.commands.compile
-      end
-    end
-  end
-
-  def test_compile_command_returns_failure_status_when_stale
-    ViteRails.builder.stub :stale?, true do
-      ViteRails.builder.stub :run_vite, false do
-        assert_equal false, ViteRails.commands.compile
-      end
-    end
-  end
-
-  def test_clean_command_works_with_nested_hashes_and_without_any_compiled_files
-    File.stub :delete, true do
-      assert ViteRails.commands.clean
-    end
-  end
-end

data/test/configuration_test.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ConfigurationTest < ViteRails::Test
-  def setup
-    @config = ViteRails::Configuration.new(
-      root_path: Pathname.new(File.expand_path('test_app', __dir__)),
-      config_path: Pathname.new(File.expand_path('./test_app/config/vite.yml', __dir__)),
-      env: 'production',
-    )
-  end
-
-  def test_source_path
-    source_path = File.expand_path File.join(File.dirname(__FILE__), 'test_app/app/javascript').to_s
-    assert_equal source_path, @config.source_path.to_s
-  end
-
-  def test_source_entry_path
-    source_entry_path = File.expand_path File.join(File.dirname(__FILE__), 'test_app/app/javascript', 'packs').to_s
-    assert_equal @config.source_entry_path.to_s, source_entry_path
-  end
-
-  def test_public_root_path
-    public_root_path = File.expand_path File.join(File.dirname(__FILE__), 'test_app/public').to_s
-    assert_equal @config.public_path.to_s, public_root_path
-  end
-
-  def test_public_output_path
-    public_output_path = File.expand_path File.join(File.dirname(__FILE__), 'test_app/public/packs').to_s
-    assert_equal @config.public_output_path.to_s, public_output_path
-
-    @config = ViteRails::Configuration.new(
-      root_path: @config.root_path,
-      config_path: Pathname.new(File.expand_path('./test_app/config/vite_public_root.yml', __dir__)),
-      env: 'production',
-    )
-
-    public_output_path = File.expand_path File.join(File.dirname(__FILE__), 'public/packs').to_s
-    assert_equal @config.public_output_path.to_s, public_output_path
-  end
-
-  def test_public_manifest_path
-    public_manifest_path = File.expand_path File.join(File.dirname(__FILE__), 'test_app/public/packs', 'manifest.json').to_s
-    assert_equal @config.public_manifest_path.to_s, public_manifest_path
-  end
-
-  def test_cache_path
-    cache_path = File.expand_path File.join(File.dirname(__FILE__), 'test_app/tmp/cache/vite').to_s
-    assert_equal @config.cache_path.to_s, cache_path
-  end
-
-  def test_additional_paths
-    assert_equal @config.additional_paths, ['app/assets', '/etc/yarn', 'some.config.js', 'app/elm']
-  end
-
-  def test_cache_manifest?
-    assert @config.cache_manifest?
-
-    with_rails_env('development') do
-      refute ViteRails.config.cache_manifest?
-    end
-
-    with_rails_env('test') do
-      refute ViteRails.config.cache_manifest?
-    end
-  end
-
-  def test_compile?
-    refute @config.compile?
-
-    with_rails_env('development') do
-      assert ViteRails.config.compile?
-    end
-
-    with_rails_env('test') do
-      assert ViteRails.config.compile?
-    end
-  end
-end

data/test/dev_server_runner_test.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class DevServerRunnerTest < ViteRails::Test
-  def setup
-    @original_node_env, ENV['NODE_ENV'] = ENV['NODE_ENV'], 'development'
-    @original_rails_env, ENV['RAILS_ENV'] = ENV['RAILS_ENV'], 'development'
-  end
-
-  def teardown
-    ENV['NODE_ENV'] = @original_node_env
-    ENV['RAILS_ENV'] = @original_rails_env
-  end
-
-  def test_run_cmd_via_node_modules
-    cmd = ["#{ test_app_path }/node_modules/.bin/vite", '--mode', 'development']
-
-    verify_command(cmd, use_node_modules: true)
-  end
-
-  def test_run_cmd_via_yarn
-    cmd = ['yarn', 'vite', '--mode', 'development']
-
-    verify_command(cmd, use_node_modules: false)
-  end
-
-  def test_run_cmd_argv
-    cmd = ["#{ test_app_path }/node_modules/.bin/vite", '--quiet', '--mode', 'development']
-
-    verify_command(cmd, argv: ['--quiet'])
-  end
-
-  def test_run_cmd_argv_with_https
-    cmd = ["#{ test_app_path }/node_modules/.bin/vite", '--https', '--mode', 'development']
-
-    dev_server = ViteRails::DevServer.new({})
-    def dev_server.host
-      'localhost'
-    end
-
-    def dev_server.port
-      '3035'
-    end
-
-    def dev_server.pretty?
-      false
-    end
-
-    def dev_server.https?
-      true
-    end
-    ViteRails::DevServer.stub(:new, dev_server) do
-      verify_command(cmd, argv: ['--https'])
-    end
-  end
-
-private
-
-  def test_app_path
-    File.expand_path('test_app', __dir__)
-  end
-
-  def verify_command(cmd, use_node_modules: true, argv: [])
-    cwd = Dir.pwd
-    Dir.chdir(test_app_path)
-
-    klass = ViteRails::Runner
-    instance = klass.new(argv)
-    mock = Minitest::Mock.new
-    mock.expect(:call, nil, [ViteRails.env, *cmd])
-
-    klass.stub(:new, instance) do
-      instance.stub(:executable_exists?, use_node_modules) do
-        Kernel.stub(:exec, mock) { ViteRails.run(argv) }
-      end
-    end
-
-    mock.verify
-  ensure
-    Dir.chdir(cwd)
-  end
-end