bundlebun 0.1.2.1.1.41-aarch64-linux → 0.2.0.1.2.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e535f193adea8d00d23f0252ac7ffd4c3c639ffd62cb65ac611dc503dcee609
-  data.tar.gz: 0ed548f8f0094f642fe36b3ee141887e4d1728a35f9ec4f8e7c9070672cabf0b
+  metadata.gz: bcabc6545cf36fd1d4141cbaa27184cd687679cdc9f92de8a70487098bee5385
+  data.tar.gz: 5174d4b568fc8d59e64a8d63eb8cb4268bdc543d4f3943a5c2475979df5d10dc
 SHA512:
-  metadata.gz: 6480be38a691dd5b1ae22b327f377a0f06484f6f54e7333495dda6e701c538fa151481c8154d1b60139f29eeb0be15e2734dbdd03dc58058649a04e1976de94c
-  data.tar.gz: c8d0edb8976693a4c078cb09edf561bce26805ebfe145cdb6c0dfd65e6d7c38854f621142531b60703939d0cbbde9e95cfdb1784fd9f58d798a16c5fb2f75a67
+  metadata.gz: a3a7726a9cfc26d0949a662bac38b5a5050f599ba7d7875d251e351d65c57c99a43bd296c2d89ac7a6261426c0d604da5e79e90222b914d7d8f79a35ad19dcca
+  data.tar.gz: 20e32ea42a87ec580c1afead529fb01e79b874474b366fe2d00767e07dc91951e241a0e75f96d2a6c6d4b3be9107746d1af7d43422ce8fadd38811c2a4654fce

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [0.2.0] - 2025-01-30
+
+- It is now recommended to include `gem bundlebun` after other existing frontend-related gems in your `Gemfile`. That removes the need to install one-liner initializer monkeypatches for most cases. The gem detects and loads all integrations when loaded. Alternatively, the developer can call integration monkey-patches (`Bundlebun::Integrations::Something.bun!`) directly.
+- bundlebun now adds the bundled bun executable to `PATH`, both on Unix-like and Windows environments. This improves the support for other frontend-related libraries and gems: we don't have to monkey-patch libraries _all the time_, just when we need it.
+- While there still might be some issues, I am trying to ensure proper Windows (non-WSL) support for this gem, for a plug&play experience for Windows Ruby developers.
+- The vite-ruby integration is reworked. We don't touch the existing `bin/vite` binstub anymore. Instead, we install `bin/bun-vite` that will run Vite with Bun and use it with ruby-vite's `vite.json`. We modify the existing config file, or install a sample one.
+- The `bun:install:rails` Rake task is now `bun:install:bundling-rails`, as it only activates from `bun:install` if Cssbundling or Jsbundling are detected, does not have to do a lot with Rails itself.
+- For Windows, the gem now installs a `bin/bun.cmd` binstub, as well as `bin/bun-vite.cmd` for use with vite-ruby. If the integration was already installed, but there are no Windows binstubs in sight, run `rake bun:install` again.
+- The ExecJS test is now a proper integration test, like the other integration tests.
+- bundlebun is now properly tested on Windows (Windows Server 2025 on GitHub Actions).
+
 ## [0.1.2] - 2024-12-21
 
 - Integration specs now test bundlebun + Bun against vite-ruby and cssbundling-rails + jsbundling-rails with positive real-world scenarios

data/README.md

@@ -2,7 +2,7 @@
 
 **bundlebun bundles [Bun](https://bun.sh), a fast JavaScript runtime, package manager, and builder, with your Ruby and Rails applications**. No need to use Docker, devcontainers, `curl ... | sh`, or `brew`.
 
-[![Gem Version](https://badge.fury.io/rb/bundlebun.svg)](https://badge.fury.io/rb/bundlebun)
+[![GitHub Release](https://img.shields.io/github/v/release/yaroslav/bundlebun)](https://github.com/yaroslav/bundlebun/releases)
 [![Docs](https://img.shields.io/badge/yard-docs-blue.svg)](https://rubydoc.info/gems/bundlebun)
 
 <div align="center">
@@ -45,11 +45,13 @@ So, how about we just pack it into a Ruby gem as a binary and allow developers t
 
 ## Install
 
-bundlebun gem releases include a binary distribution of Bun for each supported Bun platform (macOS, Linux, Windows) and architecture.
+bundlebun gem releases include a binary distribution of Bun for each supported Bun platform (macOS, Linux, Windows) and architecture. bundlebun is tested for Unix-like environments and Windows.
 
-First, add it to your `Gemfile`:
+First, add it to your `Gemfile`. Make sure to add it _after_ your existing frontend- and build-related librares:
 
 ```ruby
+# ...
+
 gem "bundlebun"
 ```
 
@@ -92,11 +94,18 @@ The task will install a binstub (`bin/bun`) that you can use to run Bun commands
 
 You should use `bin/bun` in your scripts, including your local runners like `Procfile.dev` or `Procfile`, and `package.json`—if you had a call to `node` or `bun` in the `scripts` section there.
 
+_Windows tip:_ If you're on Windows, the `bin\bun.cmd` file will be created. If you've joined an existing project where only the Unix-like binstub exists at that location, just run `rake bun:install` again.
+
 Next, the Rake task will try to detect the integrations we need to install based on the classes and modules Rake can see in your project. We'll continue with integrations.
 
+**By default, on load, bundlebun:**
+
+- adds the path to the bundled `bun` executable to the start of your application's `PATH`. That simplifies the integration in cases where we don't really need to monkey-patch a lot of code, and we just need to make sure it "sees" our `bun` executable as available.
+- tries to detect and load all possible integrations.
+
 ### Integrations
 
-`rake bun:install` will detect already-loaded gems and run the corresponding installation tasks.
+Usually, if you've placed `gem 'bundlebun'` after your frontend-related gems in the `Gemfile`, and did `rake bun:install`, the integrations should all be working out of the box.
 
 Alternatively, you can ensure an integration is loaded and the necessary modules are patched by calling methods that look like `Bundlebun::Integration::IntegrationName.bun!`: more on that below.
 
@@ -121,36 +130,27 @@ bundle add jsbundling-rails
 bin/rails javascript:install:bun
 ```
 
-To install the bundlebun integration, run
+To make sure the bundlebun integration is installed (although the default `rake bun:install` should detect everything just fine), run
 
 ```sh
-rake bun:install:rails
+rake bun:install:bundling-rails
 ```
 
-The task makes sure a `bin/bun` binstub exists and installs an initializer/task of sorts to ensure both build-related gems use our bundled version of Bun.
-
-Alternatively, you can call the following in one of your project's rakefiles:
-
-```ruby
-Bundlebun::Integrations::Cssbundling.bun!
-Bundlebun::Integrations::Jsbundling.bun!
-```
+The task makes sure a `bin/bun` binstub exists and installs an Rake task hack of sorts to ensure both build-related gems use our bundled version of Bun.
 
 #### vite-ruby and vite-rails
 
 [vite-ruby](https://github.com/ElMassimo/vite_ruby) and [vite-rails](https://vite-ruby.netlify.app/) are gems that make Ruby and Rails integration with [Vite](https://vite.dev/), a great JavaScript build tool and platform, seamless and easy.
 
-The bundlebun integration would be installed automatically, or you can run:
+The bundlebun integration would be installed automatically with `rake bun:install`, or you can run:
 
 ```sh
 rake bun:install:vite
 ```
 
-That will make sure you have a `bin/bun` binstub.
-
-Next, we'll install a custom `bin/vite` binstub (otherwise, ruby-vite won't be able to sense bundlebun presence); the original file, if present, would be backed up to `bin/vite-backup`.
+That will make sure you have a `bin/bun` binstub. Next, we'll install a custom `bin/bun-vite` binstub to use in build scripts. The installer Rake task will create a new `vite.json` file if it does not exist yet, or force the existing one to use that binstub for building. See the [Vite Ruby configuration manual](https://vite-ruby.netlify.app/config/index.html) for details on `vite.json`.
 
-Finally, we'll put an initializer that forces vite-ruby to use bundlebun. Alternatively, you can call this yourself:
+Make sure you have `gem bundlebun` mentioned _after_ all the vite-related gems in your `Gemfile`. If you want to keep integrations to a minimum, and only enable them manually, use the following to manually turn on the bundlebun monkey-patching for vite-ruby:
 
 ```ruby
 Bundlebun::Integrations::ViteRuby.bun!
@@ -158,15 +158,11 @@ Bundlebun::Integrations::ViteRuby.bun!
 
 #### ExecJS
 
-[ExecJS](https://github.com/rails/execjs) runs JavaScript code straight from Ruby. To do so, it supports a bunch of runtimes it can launch—and get a result. The Bun runtime already exists for ExecJS; we just need to ensure it uses the bundled one.
+[ExecJS](https://github.com/rails/execjs) runs JavaScript code straight from Ruby. To do so, it supports a bunch of runtimes it can launch—and get a result. The Bun runtime support already exists for ExecJS; we just need to ensure it uses the bundled one.
 
-The bundlebun integration can be installed automatically, or you can run:
+The bundlebun integration will work automatically if bundlebun is loaded after ExecJS in the `Gemfile`.
 
-```sh
-rake bun:install:execjs
-```
-
-This will create an initializer to redefine the Bun runtime for ExecJS and force its usage to be default. Alternatively, you can call:
+Alternatively, you can load the monkey-patch manually:
 
 ```ruby
 Bundlebun::Integrations::ExecJS.bun!
@@ -199,6 +195,10 @@ Usage: bun <command> [...flags] [...args]
 
 Note that with this (or any other option to run Bun), bundlebun will return the error code `127` if the executable is not found.
 
+### `PATH`
+
+The bundlebun gem adds the directory with a binary Bun distribution to your `PATH`: prepends it there, to be exact. That helps existing tools that can detect the presence of `bun` executable to find it and work with no further setup or monkey-patching.
+
 ### Rake
 
 Alternatively, you can use a Rake task. The syntax is far from perfect, but that's a limitation of Rake. You need to add quotes around the parameters and put them into square brackets. If you cannot install the binstub, though, might be your option.
@@ -229,7 +229,7 @@ Check out the [API documentation](https://rubydoc.info/gems/bundlebun) on `Bundl
 - `Bundlebun::Runner.binary_path`: returns the full path to the bundled Bun library.
 - `Bundlebun::Runner.binary_path_exist?`: checks if that binary even exists.
 - `Bundlebun::Runner.binstub_exist?`: checks if the binstub exists.
-- `Bundlebun::Runner.binstub_or_binary_path`: returns the optimal way to run bundled Bun: a path to binstub or a full path to the binary.
+- `Bundlebun::Runner.binstub_or_binary_path`: returns the optimal way to run bundled Bun: a full path to binstub or a full path to the binary.
 
 ## Versioning
 
@@ -247,13 +247,11 @@ bundle remove bundlebun
 
 Or remove it from your `Gemfile` and run bundler.
 
-Next, remove the integrations you have in place:
+Next, remove the integrations you might have in place:
 
 - `bin/bun`
-- Delete `bin/vite` if exists or restore it from `bin/vite-backup`
+- Delete `bin/bun-vite` if exists
 - Delete `tasks/bundlebun.rake` if exists
-- Delete `config/initializers/bundlebun-vite.rb` if exists
-- Delete `config/initializers/bundlebun-execjs.rb` if exists
 - Search for `bin/bun` mentions in your code and configs
 - Search for `Bundlebun` mentions in your code.
 

data/exe/bundlebun

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-# frozen_string_literal: true
 
 # Install the gem first, then create a binstub.
 #
@@ -16,7 +15,7 @@
 #
 #   bin/bun ...
 #
-# If you're seeing this in your `bin/` directory and you're
+# If you're looking at this file in your `bin/` directory and you're
 # no longer using bundlebun, it should be safe to delete.
 begin
   require 'bundler/setup'

data/lib/bundlebun/env_path.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  # EnvPath exists to help prepend the bun binary path to the system PATH,
+  # in order to make it easier for other gems and utilities to "see" the
+  # existing bun executable without the need to monkey-patch tools that already
+  # support Bun.
+  # This approach only works when the bundlebun gem is already loaded, which
+  # is not always the case, unfortunately.
+  class EnvPath
+    class << self
+      # Returns the current system PATH.
+      #
+      # @return [String] The system PATH
+      def path
+        ENV['PATH']
+      end
+
+      # Sets the system PATH to a new value (_not_ prepends the value).
+      #
+      # @param new_path [String] The new system PATH
+      def path=(new_path)
+        ENV['PATH'] = new_path
+      end
+
+      # Prepends a new path to the system PATH.
+      # Makes sure to use different separators for different platforms.
+      #
+      # @param new_path [String] The new path to prepend
+      # @return [String] The new system PATH
+      def prepend(new_path)
+        return if new_path.nil? || new_path.empty?
+
+        path_to_check = Bundlebun::Platform.windows? ? path.downcase : path
+        check_path = Bundlebun::Platform.windows? ? new_path.downcase : new_path
+
+        self.path = "#{new_path}#{separator}#{path}" unless path_to_check.start_with?(check_path)
+        path
+      end
+
+      # The `PATH` separator for the current platform (`:` or `;`)
+      #
+      # @return [String] The separator character
+      def separator
+        return @separator if defined?(@separator)
+
+        @separator = Bundlebun::Platform.windows? ? ';' : ':'
+      end
+    end
+  end
+end

data/lib/bundlebun/integrations.rb

@@ -10,5 +10,20 @@ module Bundlebun
   #
   # See the documentation to learn about the supported integrations.
   module Integrations
+    # Loads and initializes all available integrations. See specific classes
+    # for implementation.
+    #
+    # @return [Array<Module>] List of initialized integrations
+    #
+    # @example
+    #   Bundlebun::Integrations.bun! # => [Bundlebun::Integrations::Cssbundling, ...]
+    def self.bun!
+      integration_modules = constants.map { |const| const_get(const) }
+        .select { |const| const.is_a?(Module) }
+
+      integration_modules.select do |mod|
+        mod.respond_to?(:bun!) && mod.bun!
+      end
+    end
   end
 end

data/lib/bundlebun/platform.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  # Platform contains a set of helpers to deal with platform detection.
+  # Mostly, to see if we are running on Windows.
+  class Platform
+    class << self
+      # Are we running on Windows?
+      #
+      # @return [Boolean]
+      def windows?
+        return @windows if defined?(@windows)
+
+        @windows = defined?(RbConfig) && defined?(RbConfig::CONFIG) &&
+          RbConfig::CONFIG['host_os'].match?(/mswin|mingw|cygwin/)
+      end
+    end
+  end
+end

data/lib/bundlebun/runner.rb

@@ -30,9 +30,20 @@ module Bundlebun
 
       # A relative path to binstub that bundlebun usually generates with installation Rake tasks.
       #
+      # For Windows, the binstub path will return the `bun.cmd` wrapper.
+      #
       # @return [String]
       def binstub_path
-        BINSTUB_PATH
+        Bundlebun::Platform.windows? ? "#{BINSTUB_PATH}.cmd" : BINSTUB_PATH
+      end
+
+      # A full path to binstub that bundlebun usually generates with installation Rake tasks.
+      #
+      # For Windows, that will use the `bun.cmd` wrapper.
+      #
+      # @return [String]
+      def full_binstub_path
+        File.expand_path(binstub_path)
       end
 
       # A relative directory path to the bundled Bun executable from the root of the gem.
@@ -46,7 +57,9 @@ module Bundlebun
       #
       # @return [String]
       def full_directory
-        File.expand_path("../../#{relative_directory}", __dir__)
+        return @full_directory if defined?(@full_directory)
+
+        @full_directory = File.expand_path("../../#{relative_directory}", __dir__)
       end
 
       # A full path to the bundled Bun binary we run
@@ -54,8 +67,10 @@ module Bundlebun
       #
       # @return [String]
       def binary_path
-        executable = "bun#{RUBY_PLATFORM.match?(/mingw|mswin/) ? ".exe" : ""}"
-        File.join(full_directory, executable)
+        return @binary_path if defined?(@binary_path)
+
+        executable = "bun#{Bundlebun::Platform.windows? ? ".exe" : ""}"
+        @binary_path = File.join(full_directory, executable)
       end
 
       # Does the bundled Bun binary exist?
@@ -67,12 +82,12 @@ module Bundlebun
 
       # Returns the preferred way to run Bun when bundlebun is installed.
       #
-      # If the binstub is installed (see binstub_path), use the binstub.
+      # If the binstub is installed (see binstub_path), use the full path to binstub.
       # If not, use the full binary path for the bundled executable (binary_path).
       #
       # @return [String]
       def binstub_or_binary_path
-        binstub_exist? ? binstub_path : binary_path
+        binstub_exist? ? full_binstub_path : binary_path
       end
 
       # Does the binstub exist?

data/lib/bundlebun/version.rb

@@ -8,5 +8,5 @@ module Bundlebun
   # a Bun runtime with version `1.1.38`.
   #
   # This constant always points to the "own" version of the gem.
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/lib/bundlebun.rb

@@ -43,10 +43,25 @@ module Bundlebun
       end
     end
 
-    def load_tasks # @private
+    # Prepend the path to the bundled Bun executable to `PATH`.
+    #
+    # @see Bundlebun::Runner.full_directory
+    def prepend_to_path
+      EnvPath.prepend(Runner.full_directory)
+    end
+
+    # Load included Rake tasks (like `bun:install`).
+    def load_tasks
       Dir[File.expand_path('tasks/*.rake', __dir__)].each { |task| load task }
     end
 
+    # Detect and load all integrations (monkey-patches).
+    #
+    # @see Bundlebun::Integrations
+    def load_integrations
+      Integrations.bun!
+    end
+
     def bun = 'Bun'
     alias_method :bun?, :bun
     alias_method :bun!, :bun
@@ -54,5 +69,6 @@ module Bundlebun
 end
 
 Bundlebun.loader
-
+Bundlebun.prepend_to_path
 Bundlebun.load_tasks if defined?(Rake)
+Bundlebun.load_integrations

data/lib/tasks/install.rake

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'json'
 
 namespace :bun do
   desc 'Install bundlebun: install binstub and detect frameworks'
@@ -16,20 +17,15 @@ namespace :bun do
 
     Rake::Task['bun:install:bin'].invoke
 
-    if defined?(Rails)
-      puts "Rails detected.\n\n"
-      Rake::Task['bun:install:rails'].invoke
+    if defined?(Cssbundling) || defined?(Jsbundling)
+      puts "Rails' cssbundling/jsbundling detected.\n\n"
+      Rake::Task['bun:install:bundling-rails'].invoke
     end
 
     if defined?(ViteRuby)
       puts "vite-ruby detected.\n\n"
       Rake::Task['bun:install:vite'].invoke
     end
-
-    if defined?(ExecJS)
-      puts "ExecJS detected.\n\n"
-      Rake::Task['bun:install:execjs'].invoke
-    end
   end
 
   desc 'Install bundlebun: create `bin/bun` binstub'
@@ -39,17 +35,33 @@ namespace :bun do
     source = File.expand_path('../../exe/bundlebun', __dir__)
     target_dir = 'bin'
     target = File.join(target_dir, 'bun')
+    content = File.read(source)
 
     if File.exist?(target)
       puts "#{target} already exists."
     else
       FileUtils.mkdir_p(target_dir)
-      FileUtils.cp(source, target)
+      File.write(target, content, mode: "w")
       FileUtils.chmod(0o755, target)
 
       puts "Installed binstub at #{target}."
     end
 
+    # We're using Bundler technique to generate the .cmd wrappers on
+    # Windows (as Windows cannot run files with shebangs, of course).
+    # There is no public API for generating binstubs (I wish), so that's a copy and paste.
+    # @see https://github.com/rubygems/rubygems/blob/186a4f24789e6e7fd967b290ce93ed5886ef22d8/bundler/lib/bundler/installer.rb#L137
+    if Gem.win_platform?
+      cmd_target = "#{target}.cmd"
+      if File.exist?(cmd_target)
+        puts "#{cmd_target} already exists."
+      else
+        prefix = "@ruby -x \"%~f0\" %*\n@exit /b %ERRORLEVEL%\n\n"
+        File.write(cmd_target, prefix + content, mode: "wb:UTF-8")
+        puts "Installed Windows binstub at #{cmd_target}"
+      end
+    end
+
     puts <<~MESSAGE
       Try running it directly. Or, replace existing mentions of `bun` with `bin/bun` in your `package.json`, `Procfile` or binstubs and other files.
 
@@ -58,18 +70,20 @@ namespace :bun do
     MESSAGE
   end
 
-  desc 'Install bundlebun: Rails, cssbundling-rails, jsbundling-rails integration'
-  task 'install:rails' => :install do
-    puts "Installing Rails integration...\n\n"
+  desc 'Install bundlebun: cssbundling-rails, jsbundling-rails integration'
+  task 'install:bundling-rails' => :install do
+    puts "Installing cssbundling/jsbundling Rails integration...\n\n"
 
-    assets_rake = File.expand_path('../templates/rails/bundlebun.rake', __dir__)
+    assets_rake = File.expand_path('../templates/bundling-rails/bundlebun.rake', __dir__)
     target_dir = 'lib/tasks'
     target = File.join(target_dir, 'bundlebun.rake')
 
-    if FileUtils.mkdir_p(target_dir) && FileUtils.cp(assets_rake, target)
-      puts "Installed an initializer with overrides for cssbundling-rails and jsbundling-rails at #{target}"
-    else
+    if File.exist?(target)
       puts "#{target} already exists."
+    else
+      FileUtils.mkdir_p(target_dir)
+      FileUtils.cp(assets_rake, target)
+      puts "Installed an initializer with overrides for cssbundling-rails and jsbundling-rails at #{target}"
     end
 
     puts <<~MESSAGE
@@ -97,75 +111,60 @@ namespace :bun do
   task 'install:vite' => :install do
     puts "Installing vite-ruby integration...\n\n"
 
-    binstub = File.expand_path('../templates/vite-ruby/vite', __dir__)
+    binstub = File.expand_path('../templates/vite-ruby/bun-vite', __dir__)
     target_dir = 'bin'
-    initializers_dir = 'config/initializers'
-    target = File.join(target_dir, 'vite')
-    backup = File.join(target_dir, 'vite-backup')
-    initializer = File.expand_path('../templates/vite-ruby/bundlebun-vite.rb', __dir__)
-    initializer_target = File.join(initializers_dir, 'bundlebun-vite.rb')
+    target = File.join(target_dir, 'bun-vite')
+    content = File.read(binstub)
 
-    if File.exist?(target) && File.read(target).include?('bundlebun')
-      puts "#{target} already exists."
-    elsif File.exist?(target)
-      puts "Copying #{target} to #{backup} for backup"
-      FileUtils.mv(target, backup)
+    config = File.expand_path('../templates/vite-ruby/vite.json', __dir__)
+    config_target_dir = 'config'
+    config_target = File.join(config_target_dir, 'vite.json')
 
-      FileUtils.cp(binstub, target)
-      FileUtils.chmod(0o755, target)
-      puts "Installed a vite-ruby + bundlebun binstub at #{target}"
+    if File.exist?(target)
+      puts "#{target} already exists."
     else
       FileUtils.mkdir_p(target_dir)
-      FileUtils.cp(binstub, target)
+      File.write(target, content, mode: "w")
       FileUtils.chmod(0o755, target)
       puts "Installed a vite-ruby + bundlebun binstub at #{target}"
     end
 
-    if File.directory?(initializers_dir)
-      if File.exist?(initializer_target)
-        puts "#{initializer_target} already exists."
+    # See above for notes on `.cmd`-file generation.
+    if Gem.win_platform?
+      cmd_target = "#{target}.cmd"
+      if File.exist?(cmd_target)
+        puts "#{cmd_target} already exists."
       else
-        FileUtils.cp(initializer, initializer_target)
-        puts "Installed a Rails initializer for vite-ruby at #{initializer_target}."
+        prefix = "@ruby -x \"%~f0\" %*\n@exit /b %ERRORLEVEL%\n\n"
+        File.write(cmd_target, prefix + content, mode: "wb:UTF-8")
+        puts "Installed Windows binstub at #{cmd_target}"
       end
-    else
-      puts "Directory #{initializers_dir} does not seem to exist; not installing a Rails initializer."
     end
 
-    puts <<~MESSAGE
-      We've installed a binstub for running vite-ruby with bundlebun enabled at #{target}.
-      vite-ruby should now use this patched binstub to use `bin/bun` with bundlebun as a JavaScript runtime. Additionally, we've tried to install a Rails initializer at
-      #{initializer_target} to help vite-ruby work with bundlebun.
-
-      Be sure to replace `bun` with `bin/bun` in any existing and generated build-related files such as `Procfile` or `Procfile.dev`, `package.json` and others.
+    if File.exist?(config_target)
+      puts "#{config_target} already exists."
 
-      Bun.
+      begin
+        json = JSON.parse(File.read(config_target))
+        # Injecting our binstub
+        json['all'] ||= {}
+        json['all']['viteBinPath'] = 'bin/bun-vite'
 
-    MESSAGE
-  end
-
-  desc 'Install bundlebun: ExecJS integration'
-  task 'install:execjs' => :install do
-    puts "Installing ExecJS integration...\n\n"
-
-    initializers_dir = 'config/initializers'
-    initializer = File.expand_path('../templates/execjs/bundlebun-execjs.rb', __dir__)
-    initializer_target = File.join(initializers_dir, 'bundlebun-execjs.rb')
-
-    if File.directory?(initializers_dir)
-      if File.exist?(initializer_target)
-        puts "#{initializer_target} already exists."
-      else
-        FileUtils.cp(initializer, initializer_target)
-        puts "Installed a Rails initializer for ExecJS at #{initializer_target}."
+        File.write(config_target, JSON.pretty_generate(json))
+      rescue
+        puts "Failed to parse #{config_target}, no changes made."
       end
     else
-      puts "Directory #{initializers_dir} does not seem to exist; not installing a Rails initializer."
+      FileUtils.mkdir_p(config_target_dir)
+      FileUtils.cp(config, config_target)
+      puts "Installed sample vite-ruby + bundlebun config at #{config_target}"
     end
 
     puts <<~MESSAGE
-      We've installed a Rails initializer that re-defines the Bun runtime for ExecJS and
-      sets Bun as a default runtime.
+      We've installed a binstub for running vite-ruby with bundlebun enabled at #{target}.
+      Use this binstub to force bundlebun with Vite as a JavaScript runtime. Additionally, we've installed (or updated!) a vite-ruby configuration file at #{config_target} to use that binstub.
+
+      Be sure to replace `bun` with `bin/bun` in any existing build-related files such as `Procfile` or `Procfile.dev`, `package.json` and others.
 
       Bun.
 

data/lib/templates/{rails → bundling-rails}/bundlebun.rake

@@ -1,4 +1,4 @@
-# An initializer of sorts for bundlebun's ExecJS integration.
+# An initializer of sorts for bundlebun's integration.
 # Can't go to `initializers`, does not trigger that way.
 #
 # This forces cssbundling and jsbundling to use a bundlebun'ed

data/lib/templates/vite-ruby/bun-vite

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+# This file runs the Vite executable under Bun.
+
+ENV['RAILS_ENV'] ||= ENV['RACK_ENV']
+
+require 'bundler/setup'
+require 'vite_ruby'
+require 'bundlebun'
+
+Bundlebun::Integrations::ViteRuby.bun!
+
+Bundlebun.call(['x', '--bun', 'vite', *ARGV])

data/lib/templates/vite-ruby/vite.json

@@ -0,0 +1,16 @@
+{
+  "all": {
+    "watchAdditionalPaths": [],
+    "viteBinPath": "bin/bun-vite"
+},
+  "development": {
+    "autoBuild": true,
+    "publicOutputDir": "vite-dev",
+    "port": 3036
+  },
+  "test": {
+    "autoBuild": true,
+    "publicOutputDir": "vite-test",
+    "port": 3037
+  }
+}

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bundlebun
 version: !ruby/object:Gem::Version
-  version: 0.1.2.1.1.41
+  version: 0.2.0.1.2.1
 platform: aarch64-linux
 authors:
 - Yaroslav Markin
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-21 00:00:00.000000000 Z
+date: 2025-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -24,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 'bundlebun bundles Bun, a fast JavaScript runtime, package manager, and
   builder, with your Ruby and Rails applications. No need to use Docker, devcontainers,
   `curl | sh`, or `brew`.
@@ -42,21 +55,22 @@ files:
 - README.md
 - exe/bundlebun
 - lib/bundlebun.rb
+- lib/bundlebun/env_path.rb
 - lib/bundlebun/integrations.rb
 - lib/bundlebun/integrations/cssbundling.rb
 - lib/bundlebun/integrations/execjs.rb
 - lib/bundlebun/integrations/jsbundling.rb
 - lib/bundlebun/integrations/vite_ruby.rb
+- lib/bundlebun/platform.rb
 - lib/bundlebun/runner.rb
 - lib/bundlebun/vendor/bun/LICENSE.md
 - lib/bundlebun/vendor/bun/bun
 - lib/bundlebun/version.rb
 - lib/tasks/bun.rake
 - lib/tasks/install.rake
-- lib/templates/execjs/bundlebun-execjs.rb
-- lib/templates/rails/bundlebun.rake
-- lib/templates/vite-ruby/bundlebun-vite.rb
-- lib/templates/vite-ruby/vite
+- lib/templates/bundling-rails/bundlebun.rake
+- lib/templates/vite-ruby/bun-vite
+- lib/templates/vite-ruby/vite.json
 homepage: https://github.com/yaroslav/bundlebun
 licenses:
 - MIT
@@ -81,8 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: bundlebun bundles the Bun JavaScript runtime, package manager and build tool,
   for use with Ruby and Rails

data/lib/templates/execjs/bundlebun-execjs.rb

@@ -1,9 +0,0 @@
-# An initializer for bundlebun's ExecJS integration.
-#
-# This introduces ExecJS to the bundlebun'ed version of Bun,
-# allows it to run Bun from our binstub, and also sets that
-# version of Bun as a default runtime.
-#
-# Safe to delete if you no longer use bundlebun or
-# not interested in running Bun anymore.
-Bundlebun::Integrations::ExecJS.bun!

data/lib/templates/vite-ruby/bundlebun-vite.rb

@@ -1,9 +0,0 @@
-# An initializer vite-ruby integration.
-# We need both this initializer and a custom binstub at `bin/vite`.
-#
-# This forces vite-ruby to run bundlebun'ed version of Bun as a
-# JavaScript runtime.
-#
-# Safe to delete if you no longer use bundlebun or
-# not interested in running Bun anymore.
-Bundlebun::Integrations::ViteRuby.bun!

data/lib/templates/vite-ruby/vite

@@ -1,25 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# This is a replacement for the bin/vite binstub for integration
-# with bundlebun.
-# We need to patch the binstub, otherwise there is no way to force
-# ruby-vite that is being run via `bin/vite` to use bundlebun.
-#
-# The code below is the code for the original vite-ruby binstub, with
-# the bundlebun initializer run injected.
-#
-# If you had an original `vite` binstub at this place, it should
-# be at `vite-backup`.
-
-ENV['RAILS_ENV'] ||= ENV['RACK_ENV']
-
-require 'bundler/setup'
-require 'vite_ruby'
-require 'bundlebun'
-
-cli = ViteRuby::CLI
-cli.require_framework_libraries
-Bundlebun::Integrations::ViteRuby.bun!
-
-Dry::CLI.new(cli).call