vite_rails 1.0.4 → 1.0.9

data/lib/vite_rails/config.rb

@@ -1,14 +1,17 @@
 # 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 ViteRails::Config
   delegate :as_json, :inspect, to: :@config
 
-  def initialize(config)
-    @config = config.tap { coerce_values(config) }.freeze
+  def initialize(attrs)
+    @config = attrs.tap { |config| coerce_values(config) }.freeze
 
-    config.each_key do |option|
+    # Define getters for the configuration options.
+    CONFIGURABLE_WITH_ENV.each do |option|
       define_singleton_method(option) { @config[option] }
     end
   end
@@ -31,15 +34,25 @@ class ViteRails::Config
     public_dir.join(public_output_dir)
   end
 
+  # Public: The directory where the entries are located.
+  def resolved_entrypoints_dir
+    source_code_dir.join(entrypoints_dir)
+  end
+
 private
 
   # Internal: Coerces all the configuration values, in case they were passed
   # as environment variables which are always strings.
   def coerce_values(config)
-    coerce_booleans(config, 'auto_build', 'https')
-    coerce_paths(config, 'assets_dir', 'build_cache_dir', 'config_path', 'public_dir', 'source_code_dir', 'public_output_dir', 'root')
+    config['mode'] = config['mode'].to_s
     config['port'] = config['port'].to_i
-    config['root'] ||= Rails.root
+    coerce_booleans(config, 'auto_build', 'hide_build_console_output', 'https')
+    coerce_paths(config, 'config_path', 'public_output_dir', 'root')
+
+    # Prefix paths that are relative to the project root.
+    config.slice('build_cache_dir', 'public_dir', 'source_code_dir').each do |option, dir|
+      config[option] = config['root'].join(dir) if dir
+    end
   end
 
   # Internal: Coerces configuration options to boolean.
@@ -54,11 +67,13 @@ private
 
   class << self
     # Public: Returns the project configuration for Vite.
-    def resolve_config
-      new DEFAULT_CONFIG.merge(config_from_file).merge(config_from_env)
-    rescue Errno::ENOENT => error
-      warn "Check that your vite.json configuration file is available in the load path. #{ error.message }"
-      new DEFAULT_CONFIG.merge(config_from_env)
+    def resolve_config(attrs = {})
+      attrs = attrs.transform_keys(&:to_s)
+      mode = (attrs['mode'] ||= config_option_from_env('mode') || Rails.env.to_s).to_s
+      root = Pathname.new(attrs['root'] ||= config_option_from_env('root') || Rails.root || Dir.pwd)
+      config_path = (attrs['config_path'] ||= config_option_from_env('config_path') || DEFAULT_CONFIG.fetch('config_path'))
+      file_attrs = config_from_file(root: root, mode: mode, config_path: config_path)
+      new DEFAULT_CONFIG.merge(file_attrs).merge(config_from_env).merge(attrs)
     end
 
   private
@@ -70,7 +85,7 @@ private
 
     # Internal: Retrieves a configuration option from environment variables.
     def config_option_from_env(name)
-      ENV["#{ ViteRails::ENV_PREFIX }_#{ name.upcase }"]
+      ViteRails.env["#{ ViteRails::ENV_PREFIX }_#{ name.upcase }"]
     end
 
     # Internal: Extracts the configuration options provided as env vars.
@@ -79,20 +94,17 @@ private
         if value = config_option_from_env(key)
           env_vars[key] = value
         end
-      end.merge(mode: vite_mode)
-    end
-
-    # Internal: The mode Vite should run on.
-    def vite_mode
-      config_option_from_env('mode') || Rails.env.to_s
+      end
     end
 
     # Internal: Loads the configuration options provided in a JSON file.
-    def config_from_file
-      path = config_option_from_env('config_path') || DEFAULT_CONFIG.fetch('config_path')
-      multi_env_config = load_json(path)
+    def config_from_file(root:, mode:, config_path:)
+      multi_env_config = load_json(root.join(config_path))
       multi_env_config.fetch('all', {})
-        .merge(multi_env_config.fetch(vite_mode, {}))
+        .merge(multi_env_config.fetch(mode, {}))
+    rescue Errno::ENOENT => error
+      warn "Check that your vite.json configuration file is available in the load path. #{ error.message }"
+      {}
     end
   end
 
@@ -100,5 +112,5 @@ private
   DEFAULT_CONFIG = load_json("#{ __dir__ }/../../package/default.vite.json").freeze
 
   # Internal: Configuration options that can be provided as env vars.
-  CONFIGURABLE_WITH_ENV = (DEFAULT_CONFIG.keys + ['root']).freeze
+  CONFIGURABLE_WITH_ENV = (DEFAULT_CONFIG.keys + %w[mode root]).freeze
 end

data/lib/vite_rails/dev_server_proxy.rb

@@ -14,18 +14,8 @@ class ViteRails::DevServerProxy < Rack::Proxy
 
   # Rack: Intercept asset requests and send them to the Vite server.
   def perform_request(env)
-    if vite_should_handle?(env['REQUEST_URI']) && dev_server.running?
-      env['REQUEST_URI'] = env['REQUEST_URI']
-        .sub(vite_asset_url_prefix, '/')
-        .sub('.ts.js', '.ts') # Patch: Rails helpers always append the extension.
-      env['PATH_INFO'], env['QUERY_STRING'] = env['REQUEST_URI'].split('?')
-
-      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'] = ''
+    if vite_should_handle?(env) && dev_server_running?
+      forward_to_vite_dev_server(env)
       super(env)
     else
       @app.call(env)
@@ -34,11 +24,32 @@ class ViteRails::DevServerProxy < Rack::Proxy
 
 private
 
-  delegate :config, :dev_server, to: :@vite_rails
+  delegate :config, :dev_server_running?, to: :@vite_rails
 
-  def vite_should_handle?(url)
-    url.start_with?(vite_asset_url_prefix) || url.start_with?(VITE_DEPENDENCY_PREFIX) ||
-      url.include?('?t=') # Direct Hot Reload
+  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, '/')
+      .sub('.ts.js', '.ts') # Patch: Rails helpers always append the extension.
+    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

data/lib/vite_rails/helper.rb

@@ -2,40 +2,68 @@
 
 # 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)
+    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', **options)
-    javascript_include_tag(*sources_from_vite_manifest_entrypoints(names, type: :javascript), type: type, **options)
+  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, type: 'module', **options)
-    javascript_include_tag(*sources_from_vite_manifest_entrypoints(names, type: :typescript), type: type, **options)
+  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_entrypoints(names, type: :stylesheet), **options)
+    stylesheet_link_tag(*sources_from_vite_manifest(names, type: :stylesheet), **options)
   end
 
 private
 
-  def sources_from_vite_manifest_entrypoints(names, type:)
-    names.flat_map { |name| vite_asset_path(name, type: type) }.uniq
+  def sources_from_vite_manifest(names, type:)
+    names.map { |name| vite_asset_path(name, type: type) }
   end
 end

data/lib/vite_rails/manifest.rb

@@ -5,7 +5,7 @@
 #
 # Example:
 #   lookup_entrypoint('calendar', type: :javascript)
-#   => "/vite/assets/calendar-1016838bab065ae1e314.js"
+#   => { "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.
@@ -29,8 +29,9 @@ class ViteRails::Manifest
   # Returns a relative path, or nil if the asset is not found.
   #
   # Example:
-  #   ViteRails.manifest.lookup('calendar.js') # => "/vite/assets/calendar-1016838bab065ae1e122.js"
-  def lookup(name, type:)
+  #   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))
@@ -43,12 +44,7 @@ class ViteRails::Manifest
 
 private
 
-  delegate :config, :builder, :dev_server, to: :@vite_rails
-
-  # Public: Returns true if the Vite development server is running.
-  def dev_server_running?
-    ViteRails.run_proxy? && dev_server.running?
-  end
+  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.
@@ -59,9 +55,9 @@ private
   # Internal: Finds the specified entry in the manifest.
   def find_manifest_entry(name)
     if dev_server_running?
-      "/#{ config.public_output_dir.join(name.to_s) }"
-    elsif file = manifest.dig(name.to_s, 'file')
-      "/#{ config.public_output_dir.join(file) }"
+      { 'file' => "/#{ config.public_output_dir.join(name.to_s) }" }
+    else
+      manifest[name.to_s]
     end
   end
 
@@ -83,7 +79,10 @@ private
   # 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)
+      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
@@ -93,7 +92,13 @@ private
   def with_file_extension(name, entry_type)
     return name unless File.extname(name.to_s).empty?
 
-    "#{ name }.#{ extension_for_type(entry_type) }"
+    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.
@@ -102,7 +107,7 @@ private
     when :javascript then 'js'
     when :stylesheet then 'css'
     when :typescript then dev_server_running? ? 'ts' : 'js'
-    else entry_type.to_s
+    else entry_type
     end
   end
 

data/lib/vite_rails/runner.rb

@@ -31,9 +31,8 @@ private
     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')
+    args.append('--mode', ViteRails.mode) 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
 
@@ -49,8 +48,6 @@ private
 
   # 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"
+    ENV["#{ ViteRails::ENV_PREFIX }_VITE_BIN_PATH"] || `yarn bin vite`.chomp.presence || "#{ `npm bin`.chomp }/vite"
   end
 end

data/lib/vite_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class ViteRails
-  VERSION = '1.0.4'
+  VERSION = '1.0.9'
 end

data/package.json

@@ -2,27 +2,15 @@
   "name": "only-for-workflows",
   "version": "unknown",
   "scripts": {
-    "test": "jest",
-    "lint": "eslint package/"
+    "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.30",
-    "vite-plugin-ruby": "1.0.0"
-  },
-  "devDependencies": {
-    "@vitejs/plugin-vue": "^1.0.6",
-    "eslint": "^7.16.0",
-    "eslint-config-airbnb": "^18.2.0",
-    "eslint-config-prettier": "^7.1.0",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-jsx-a11y": "^6.3.1",
-    "eslint-plugin-react": "^7.21.4",
-    "jest": "^26.5.3"
-  },
-  "jest": {
-    "testRegex": "(/__tests__/.*|(\\.|/))\\.jsx?$",
-    "roots": [
-      "<rootDir>/package"
-    ]
+    "vite": "^2.0.0-beta.34",
+    "vite-plugin-ruby": "^1.0.3"
   }
 }

data/package/default.vite.json

@@ -6,7 +6,7 @@
   "configPath": "config/vite.json",
   "publicDir": "public",
   "entrypointsDir": "entrypoints",
-  "sourceCodeDir": "app/javascript",
+  "sourceCodeDir": "app/frontend",
   "host": "localhost",
   "https": null,
   "port": 3036,

data/test/builder_test.rb

@@ -2,27 +2,26 @@
 
 require 'test_helper'
 
-class BuilderTest < Minitest::Test
-  def remove_files_digest_path
+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 setup
-    remove_files_digest_path
+  def teardown
+    setup
   end
 
-  def teardown
-    remove_files_digest_path
+  def vite_env
+    ViteRails.builder.send(:vite_env)
   end
 
   def test_custom_environment_variables
-    assert_nil ViteRails.builder.send(:vite_env)['FOO']
+    assert_nil vite_env['FOO']
     ViteRails.env['FOO'] = 'BAR'
-    assert ViteRails.builder.send(:vite_env)['FOO'] == 'BAR'
-  ensure
-    ViteRails.env = {}
+    assert vite_env['FOO'] == 'BAR'
   end
 
   def test_freshness
@@ -35,21 +34,19 @@ class BuilderTest < Minitest::Test
   end
 
   def test_freshness_on_build_success
-    status = OpenStruct.new(success?: true)
-
     assert ViteRails.builder.stale?
+    status = OpenStruct.new(success?: true)
     Open3.stub :capture3, [:sterr, :stdout, status] do
-      ViteRails.builder.build
+      assert ViteRails.builder.build
       assert ViteRails.builder.fresh?
     end
   end
 
   def test_freshness_on_build_fail
-    status = OpenStruct.new(success?: false)
-
     assert ViteRails.builder.stale?
+    status = OpenStruct.new(success?: false)
     Open3.stub :capture3, [:sterr, :stdout, status] do
-      ViteRails.builder.build
+      assert !ViteRails.builder.build
       assert ViteRails.builder.fresh?
     end
   end
@@ -58,15 +55,23 @@ class BuilderTest < Minitest::Test
     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
-    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
+    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'
-
-    assert_equal ViteRails.builder.send(:vite_env)['VITE_RUBY_MODE'], 'foo.bar'
-    assert_equal ViteRails.builder.send(:vite_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