vite_rails 1.0.8 → 1.0.9

data/lib/vite_rails/manifest.rb

@@ -31,7 +31,7 @@ class ViteRails::Manifest
   # Example:
   #   ViteRails.manifest.lookup('calendar.js')
   #   # { "file" => "/vite/assets/calendar-1016838bab065ae1e122.js", "imports" => [] }
-  def lookup(name, type:)
+  def lookup(name, type: nil)
     build if should_build?
 
     find_manifest_entry(with_file_extension(name, type))
@@ -92,7 +92,8 @@ 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.
@@ -106,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.8'
+  VERSION = '1.0.9'
 end

data/package.json

@@ -11,6 +11,6 @@
   },
   "dependencies": {
     "vite": "^2.0.0-beta.34",
-    "vite-plugin-ruby": "^1.0.2"
+    "vite-plugin-ruby": "^1.0.3"
   }
 }

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

data/test/commands_test.rb

@@ -0,0 +1,67 @@
+# 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

@@ -3,78 +3,120 @@
 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',
-    )
+  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 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
+  def assert_pathname(expected, actual)
+    assert_equal Pathname.new(expand_path("test_app/#{ expected }")), actual
   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
+  def resolve_config(mode: 'production', root: test_app_path, **attrs)
+    ViteRails::Config.resolve_config(mode: mode, root: root, **attrs)
   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
+  def setup
+    @config = resolve_config
   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
+  def test_source_code_dir
+    assert_path 'test_app/app/frontend', @config.source_code_dir
+  end
 
-    @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',
-    )
+  def test_entrypoints_dir
+    assert_path 'test_app/app/frontend/entrypoints', @config.resolved_entrypoints_dir
+  end
 
-    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
+  def test_public_dir
+    assert_path 'test_app/public', @config.public_dir
   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
+  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_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
+  def test_manifest_path
+    assert_path 'test_app/public/vite-production/manifest.json', @config.manifest_path
   end
 
-  def test_additional_paths
-    assert_equal @config.additional_paths, ['app/assets', '/etc/yarn', 'some.config.js', 'app/elm']
+  def test_build_cache_dir
+    assert_path 'test_app/tmp/cache/vite', @config.build_cache_dir
   end
 
-  def test_cache_manifest?
-    assert @config.cache_manifest?
+  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
 
-    with_rails_env('development') do
-      refute ViteRails.config.cache_manifest?
+  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('test') do
-      refute ViteRails.config.cache_manifest?
+    with_rails_env('staging') do |config|
+      refute config.auto_build
     end
   end
 
-  def test_compile?
-    refute @config.compile?
+  def test_protocol
+    assert_equal 'http', @config.protocol
+  end
 
-    with_rails_env('development') do
-      assert ViteRails.config.compile?
-    end
+  def test_host_with_port
+    assert_equal 3036, @config.port
 
-    with_rails_env('test') do
-      assert ViteRails.config.compile?
+    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

data/test/dev_server_proxy_test.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class DevServerProxyTest < ViteRails::Test
+  include Rack::Test::Methods
+
+  def app
+    # Capture all changes to the env made by the proxy.
+    capture_app = Rack::Builder.new.run(->(env) {
+      [200, { 'Content-Type' => 'application/json' }, env.to_json]
+    })
+    # Avoid actually using the proxy.
+    Rack::Proxy.define_method(:perform_request) { |env| capture_app.call(env) }
+
+    ViteRails::DevServerProxy.new(capture_app)
+  end
+
+  def test_non_asset
+    get_with_dev_server_running '/'
+    assert_not_forwarded
+  end
+
+  def test_non_vite_asset
+    get_with_dev_server_running '/example_import.js'
+    assert_not_forwarded
+  end
+
+  def test_vite_asset
+    get_with_dev_server_running '/vite-production/application.js'
+    assert_forwarded to: '/application.js'
+  end
+
+  def test_vite_client
+    get_with_dev_server_running '/@vite/client'
+    assert_forwarded to: '/@vite/client'
+  end
+
+  def test_vite_import
+    get_with_dev_server_running '/@fs//package/example/app/frontend/App.vue?import&t=1611322300214&vue&type=style&index=0&lang.css'
+    assert_forwarded to: '/@fs//package/example/app/frontend/App.vue?import&t=1611322300214&vue&type=style&index=0&lang.css'
+  end
+
+  def test_hmr_for_stylesheet
+    get_with_dev_server_running '/colored.css?t=1611322562923'
+    assert_forwarded to: '/colored.css?t=1611322562923'
+  end
+
+  def test_hmr_for_imported_entrypoint
+    get_with_dev_server_running '/colored.css?import&t=1611322562923'
+    assert_forwarded to: '/colored.css?import&t=1611322562923'
+  end
+
+  def test_entrypoint_imported_from_entrypoint
+    header 'Referer', 'http://localhost:3000/vite-production/application.js'
+    get_with_dev_server_running '/example_import.js'
+    assert_forwarded to: '/example_import.js'
+  end
+
+  def test_without_dev_server_running
+    get '/vite-production/application.js'
+    assert_not_forwarded
+
+    get '/colored.css?import&t=1611322562923'
+    assert_not_forwarded
+
+    header 'Referer', 'http://localhost:3000/vite-production/application.js'
+    get '/example_import.js'
+    assert_not_forwarded
+  end
+
+private
+
+  def get_with_dev_server_running(*args)
+    with_dev_server_running {
+      get(*args)
+    }
+  end
+
+  def assert_not_forwarded
+    assert last_response.ok?
+    env = JSON.parse(last_response.body)
+    assert_nil env['HTTP_X_FORWARDED_HOST']
+    assert_nil env['HTTP_X_FORWARDED_PORT']
+  end
+
+  def assert_forwarded(to: nil)
+    assert last_response.ok?
+    env = JSON.parse(last_response.body)
+
+    assert_equal ViteRails.config.host, env['HTTP_X_FORWARDED_HOST']
+    assert_equal ViteRails.config.port, Integer(env['HTTP_X_FORWARDED_PORT'])
+
+    return unless to
+
+    path, query = to.split('?')
+    assert_equal path, env['PATH_INFO']
+    assert_equal query, env['QUERY_STRING']
+    assert_equal to, env['REQUEST_URI']
+  end
+end