vite_rails 1.0.8 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01d2a1c3a1fb46873e2b8057e91829a74e6c52a010941ec8abe6ca8055242b71
-  data.tar.gz: 8fbe4d912f70e84631a0131cfc884e4dd547f10105955d6fb1c877d69a22c03c
+  metadata.gz: a7036c3650b1b44c82158220474b56e26488785cefb0a99044444708d603001a
+  data.tar.gz: 8161dbb668ff8c2308de6783e1dbff81faf60b13cd87393348070a2f8b2f9c18
 SHA512:
-  metadata.gz: 2807123abe076535c1b5a918d5d6d303b137e1e8025d036692162313ed479500db1fd09ba153e355e33b1a58a9072d19c17b17dc147cd09f841cceffb8d12daa
-  data.tar.gz: 2200102393275515c8dc4ef981a9676460f27e35d48bba8c906535401aea934b5cd08fddbc19bd61bf7aaaf385c2fc7f27ca99eddca12f2ea364373fb7d2fde0
+  metadata.gz: a5ecb6327e2009b5fcf8aa91f90989264538db013dafc4b34a361e11b60a8d69bd394d6c6e5043583ff1cfe35fe5464424e26b616304ee30089c9e5a06fa2bda
+  data.tar.gz: 04124e8f3c0063b1461185fbfb665623b0c49c6ea3712952a857eb1bb00886e420ae64335609f4879377013ef7f32506ef84400af52f9a3385c90b9b5c025193

data/CHANGELOG.md

@@ -1,4 +1,8 @@
-## Vite Rails 1.0.8  (2020-01-20)
+## Vite Rails 1.0.9  (2020-01-22)
+
+- Ensure `configPath` and `publicDir` are scoped from `root`, both in Ruby and JS.
+
+## Vite Rails 1.0.8  (2020-01-21)
 
 - Change the default of `sourceCodeDir` to `app/frontend`, add instructions for folks migrating
 from a `app/javascript` structure.

data/CONTRIBUTING.md

@@ -6,7 +6,6 @@
 
 ```
 bundle install
-yarn
 ```
 
 ## Making sure your changes pass all tests

data/lib/install/template.rb

@@ -6,7 +6,7 @@ copy_file "#{ __dir__ }/config/vite.json", ViteRails.config.config_path
 copy_file "#{ __dir__ }/config/vite.config.ts", Rails.root.join('vite.config.ts')
 
 say 'Creating entrypoints directory'
-directory "#{ __dir__ }/javascript/entrypoints", ViteRails.config.source_code_dir.join(ViteRails.config.entrypoints_dir)
+directory "#{ __dir__ }/javascript/entrypoints", ViteRails.config.resolved_entrypoints_dir
 
 apply "#{ __dir__ }/binstubs.rb"
 

data/lib/tasks/vite/build.rake

@@ -13,11 +13,7 @@ end
 namespace :vite do
   desc 'Compile JavaScript packs using vite for production with digests'
   task build: [:'vite:verify_install', :environment] do
-    ViteRails.with_node_env(ENV.fetch('NODE_ENV', 'production')) do
-      ViteRails.ensure_log_goes_to_stdout do
-        ViteRails.build || exit!
-      end
-    end
+    ViteRails.build_from_rake
   end
 end
 

data/lib/tasks/vite/clean.rake

@@ -5,9 +5,7 @@ $stdout.sync = true
 namespace :vite do
   desc 'Remove old compiled vites'
   task :clean, [:keep, :age] => [:'vite:verify_install', :environment] do |_, args|
-    ViteRails.ensure_log_goes_to_stdout do
-      ViteRails.clean(keep_up_to: Integer(args.keep || 2), age_in_seconds: Integer(args.age || 3600))
-    end
+    ViteRails.clean_from_rake(args)
   end
 end
 

data/lib/tasks/vite/verify_install.rake

@@ -11,10 +11,10 @@ namespace :vite do
       WARN
       exit!
     end
-    unless ViteRails.config.config_path.exist?
-      path = ViteRails.config.config_path.relative_path_from(Pathname.new(pwd)).to_s
+    config_path = Rails.root.join(ViteRails.config.config_path)
+    unless config_path.exist?
       warn <<~WARN
-        Configuration #{ path } file for vite-plugin-ruby not found.
+        Configuration #{ config_path } file for vite-plugin-ruby not found.
         Make sure vite:install has run successfully before running dependent tasks.
       WARN
       exit!

data/lib/vite_rails.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'active_support'
-require 'active_support/core_ext/class/attribute_accessors'
+require 'rails'
+require 'active_support/all'
 
 require 'zeitwerk'
 loader = Zeitwerk::Loader.for_gem
@@ -13,18 +13,10 @@ class ViteRails
   # Internal: Prefix used for environment variables that modify the configuration.
   ENV_PREFIX = 'VITE_RUBY'
 
-  # Public: Additional environment variables to pass to Vite.
-  #
-  # Example:
-  #   ViteRails.env['VITE_RUBY_CONFIG_PATH'] = 'config/alternate_vite.json'
-  cattr_accessor(:env) { ENV.select { |key, _| key.start_with?(ENV_PREFIX) } }
-
-  cattr_accessor(:logger) { ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT)) }
-
   class << self
     delegate :config, :builder, :manifest, :commands, :dev_server, :dev_server_running?, to: :instance
     delegate :mode, to: :config
-    delegate :bootstrap, :clean, :clobber, :build, to: :commands
+    delegate :bootstrap, :clean, :clean_from_rake, :clobber, :build, :build_from_rake, to: :commands
 
     attr_writer :instance
 
@@ -45,23 +37,20 @@ class ViteRails
       false
     end
 
-    def with_node_env(env)
-      original = ENV['NODE_ENV']
-      ENV['NODE_ENV'] = env
-      yield
-    ensure
-      ENV['NODE_ENV'] = original
-    end
-
-    def ensure_log_goes_to_stdout
-      old_logger = ViteRails.logger
-      ViteRails.logger = ActiveSupport::Logger.new(STDOUT)
-      yield
-    ensure
-      ViteRails.logger = old_logger
+    # Internal: Allows to obtain any env variables for configuration options.
+    def load_env_variables
+      ENV.select { |key, _| key.start_with?(ENV_PREFIX) }
     end
   end
 
+  # Public: Additional environment variables to pass to Vite.
+  #
+  # Example:
+  #   ViteRails.env['VITE_RUBY_CONFIG_PATH'] = 'config/alternate_vite.json'
+  cattr_accessor(:env) { load_env_variables }
+
+  cattr_accessor(:logger) { ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT)) }
+
   # Public: Returns true if the Vite development server is running.
   def dev_server_running?
     ViteRails.run_proxy? && dev_server.running?

data/lib/vite_rails/builder.rb

@@ -67,9 +67,18 @@ private
   def build_with_vite
     logger.info 'Building with Vite ⚡️'
 
-    stdout, stderr, status = Open3.capture3(vite_env,
-      "#{ which_ruby } ./bin/vite build --mode #{ config.mode }", chdir: File.expand_path(config.root))
+    command = "#{ which_ruby } ./bin/vite build --mode #{ config.mode }"
+    stdout, stderr, status = Open3.capture3(vite_env, command, chdir: File.expand_path(config.root))
 
+    log_build_result(stdout, stderr, status)
+
+    status.success?
+  end
+
+  # Internal: Outputs the build results.
+  #
+  # NOTE: By default it also outputs the manifest entries.
+  def log_build_result(stdout, stderr, status)
     if status.success?
       logger.info "Build with Vite complete: #{ config.build_output_dir }"
       logger.error(stderr.to_s) unless stderr.empty?
@@ -78,8 +87,6 @@ private
       non_empty_streams = [stdout, stderr].delete_if(&:empty?)
       logger.error "Build with Vite failed:\n#{ non_empty_streams.join("\n\n") }"
     end
-
-    status.success?
   end
 
   # Internal: Used to prefix the bin/vite executable file.

data/lib/vite_rails/commands.rb

@@ -11,6 +11,15 @@ class ViteRails::Commands
     manifest.refresh
   end
 
+  # Public: Defaults to production, and exits if the build fails.
+  def build_from_rake
+    with_node_env(ENV.fetch('NODE_ENV', 'production')) {
+      ensure_log_goes_to_stdout {
+        build || exit!
+      }
+    }
+  end
+
   # Public: Builds all assets that are managed by Vite, from the entrypoints.
   def build
     builder.build.tap { manifest.refresh }
@@ -22,6 +31,13 @@ class ViteRails::Commands
     config.build_cache_dir.rmtree if config.build_cache_dir.exist?
   end
 
+  # Public: Receives arguments from a rake task.
+  def clean_from_rake(args)
+    ensure_log_goes_to_stdout {
+      clean(keep_up_to: Integer(args.keep || 2), age_in_seconds: Integer(args.age || 3600))
+    }
+  end
+
   # Public: Cleanup old assets in the output directory.
   #
   # keep_up_to - Max amount of backups to preserve.
@@ -33,21 +49,16 @@ class ViteRails::Commands
   #   To force only 1 backup to be kept: clean(1, 0)
   #   To only keep files created within the last 10 minutes: clean(0, 600)
   def clean(keep_up_to: 2, age_in_seconds: 3600)
-    return false unless config.build_output_dir.exist? && config.manifest_path.exist?
+    return false unless may_clean?
 
-    versions.sort.reverse
+    versions
       .each_with_index
       .drop_while { |(mtime, _), index|
         max_age = [0, Time.now - Time.at(mtime)].max
         max_age < age_in_seconds || index < keep_up_to
       }
-      .each do |(_, files), _index|
-        files.each do |file|
-          next unless File.file?(file)
-
-          File.delete(file)
-          logger.info("Removed #{ file }")
-        end
+      .each do |(_, files), _|
+        clean_files(files)
       end
     true
   end
@@ -56,13 +67,42 @@ private
 
   delegate :config, :builder, :manifest, :logger, to: :@vite_rails
 
+  def may_clean?
+    config.build_output_dir.exist? && config.manifest_path.exist?
+  end
+
+  def clean_files(files)
+    files.select { |file| File.file?(file) }.each do |file|
+      File.delete(file)
+      logger.info("Removed #{ file }")
+    end
+  end
+
   def versions
     all_files = Dir.glob("#{ config.build_output_dir }/**/*")
     entries = all_files - [config.manifest_path] - current_version_files
-    entries.reject { |file| File.directory?(file) }.group_by { |file| File.mtime(file).utc.to_i }
+    entries.reject { |file| File.directory?(file) }
+      .group_by { |file| File.mtime(file).utc.to_i }
+      .sort.reverse
   end
 
   def current_version_files
     Dir.glob(manifest.refresh.values.map { |value| config.build_output_dir.join("#{ value['file'] }*") })
   end
+
+  def with_node_env(env)
+    original = ENV['NODE_ENV']
+    ENV['NODE_ENV'] = env
+    yield
+  ensure
+    ENV['NODE_ENV'] = original
+  end
+
+  def ensure_log_goes_to_stdout
+    old_logger = ViteRails.logger
+    ViteRails.logger = ActiveSupport::Logger.new(STDOUT)
+    yield
+  ensure
+    ViteRails.logger = old_logger
+  end
 end

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'], env['HTTP_REFERER']) && 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,13 +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, referer)
-    return true if url.start_with?(vite_asset_url_prefix) # Vite Asset
-    return true if url.start_with?(VITE_DEPENDENCY_PREFIX) # Vite Package Asset
-    return true if url.include?('?t=') # Hot Reload
-    return true if referer && URI.parse(referer).path.start_with?(vite_asset_url_prefix) # Entry Imported from another Entry.
+  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

@@ -31,7 +31,7 @@ module ViteRails::Helper
                           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'] }, type: type, crossorigin: crossorigin, **options)
+    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
@@ -39,7 +39,9 @@ module ViteRails::Helper
     end
 
     unless skip_style_tags || ViteRails.dev_server_running?
-      style_paths = names.map { |name| current_vite_instance.manifest.lookup(name, type: :stylesheet)&.fetch('file') }.compact
+      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