bundlebun 0.4.0.1.3.10-aarch64-linux → 0.4.1.1.3.10-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7ed1f147baac36671fd3b93c85d38c308075c19f1ea6a0e9a063a45e2cdea64
-  data.tar.gz: bb57e8142d521d9dd06c21d4f2b675207459d42248c2e65b5d24e153134d3f60
+  metadata.gz: db70acaece97c93641cc36082ddf679909e69e1b2eb3965c19b5d9ec160445f8
+  data.tar.gz: 6a0946fbe5e68358032be2fcab29097f304aeb8d4d5ac3f683a01c08913d8791
 SHA512:
-  metadata.gz: 8a3c3500370267682096107ff1b964f501fe2e3eb7c428f788f6effda2b64eae447ebbac274deee1bb337380e43c5f19adfb1b532fbf792ae5e798cba5bbbcac
-  data.tar.gz: 1f49a6475bc39f1958ecdb69c765e5e9a754d7e05a7ef889bcb913a98f0c99d51f55d95595d1dcca56229c856d0bb8bdc2231f6f18b50d9ede5008c64cfa14d5
+  metadata.gz: 7c559c1197f9293d8c167252228470e82ce85b80738fcb2fc7b4c6210e45a9ecedd53f4009e0c476a7f4a3f65d98b342cf78d52e75399a6d3451794c875a4ced
+  data.tar.gz: 66d977514ed3fbf8f55d1b9c697f2cd605f6e1784b5ee0558d63dee5f35d1ff690a0c1d2628274e283ac5da3225d453f133d43116dcb191726ef3b436f2dd060

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.4.1] - 2026-03-08
+
+- Bun is now executed with argv-safe `exec` / `system` calls instead of flattening arguments into a single string to preserve values with spaces correctly.
+- `rake bun:install:package` and `rake bun:install:procfile` no longer crash in non-interactive environments when stdin is closed.
+
 ## [0.4.0] - 2026-02-01
 
 - `Bundlebun.system(args)` method: runs Bun as a subprocess and returns to Ruby. Returns `true` if Bun exited successfully. Use this when you need to continue executing Ruby code after Bun finishes.

data/README.md

@@ -1,13 +1,38 @@
 # bundlebun
 
-**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`.
+**bundlebun** bundles [Bun](https://bun.sh)—the all-in-one JavaScript runtime, package manager, and build tool—directly into your Ruby gem bundle. No Docker, no `curl | sh`, no Homebrew required.
+
+<div align="center">
+  <img src="https://raw.githubusercontent.com/yaroslav/bundlebun/refs/heads/main/assets/mr-bundlebun-512.png" width="256" height="256" alt="Mr. Bundlebun" title="Mr. Bundlebun">
+</div>
+
+* **Zero setup.** `bundle add bundlebun && rake bun:install` and you're done.
+* **Team-friendly.** Everyone runs the same Bun version, pinned in `Gemfile.lock`.
+* **Auto-updating.** New Bun release? bundlebun ships it automatically. Or freeze your preferred version.
+* **Integrates automatically.** Works out of the box with vite-ruby, cssbundling-rails, jsbundling-rails, and ExecJS.
+
+```sh
+bundle add bundlebun
+rake bun:install
+bin/bun --version
+```
 
 [![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">
-  <img src="https://raw.githubusercontent.com/yaroslav/bundlebun/refs/heads/main/assets/mr-bundlebun-512.png" width="256" height="256" alt="Mr. Bundlebun">
-</div>
+---
+
+## Table of Contents
+
+- [Rationale](#rationale)
+- [Install](#install)
+- [Usage](#usage)
+- [Integrations](#integrations)
+- [Versioning](#versioning)
+- [Uninstall](#uninstall)
+- [Acknowledgements](#acknowledgements)
+- [Contributing](#contributing)
+- [License](#license)
 
 ## Rationale
 
@@ -24,101 +49,53 @@ So, how about we just pack it into a Ruby gem as a binary and allow developers t
 
 **Enter bundlebun**. With a fast JavaScript runtime and a package manager included, you can even skip the build tool and use Bun itself.
 
-## Quickstart
-
-Starting with your Ruby or Rails project, no Bun or anything like that required:
-
-```sh
-bundle add bundlebun
-rake bun:install
-```
-
-and then:
-
-```sh
-> bin/bun ...
-Bun is a fast JavaScript runtime, package manager, bundler, and test runner. (1.1.38+bf2f153f5)
-
-Usage: bun <command> [...flags] [...args]
-...
-```
-
 ## Install
 
 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`. Make sure to add it _after_ your existing frontend- and build-related librares:
+Add bundlebun to your `Gemfile`, placing it _after_ your existing frontend-related gems:
 
 ```ruby
-# ...
-
 # Frontend-related gems go here
-# For example, Vite integration
 # gem "vite_rails"
 
 gem "bundlebun"
 ```
 
-and:
-
-```sh
-bundle install
-```
-
-(or just):
+Then run:
 
 ```sh
 bundle add bundlebun
-```
-
-_If you're seeing a message like `Could not find gems matching 'bundlebun' valid for all resolution platforms
-(aarch64-linux, aarch64-linux-gnu <...> )`, [check this article](https://github.com/yaroslav/bundlebun/wiki/Could-not-find-gems-matching-'bundlebun'-valid-for-all-resolution-platforms)._
-
-Next, run:
-
-```sh
 rake bun:install
 ```
 
-The task will install a binstub (`bin/bun`) that you can use to run Bun commands; try running `bin/bun` or `bin/bun --version`.
+`rake bun:install` creates a `bin/bun` binstub and auto-detects which integrations to enable. It will also offer to migrate `package.json` scripts and `Procfile` entries to use `bin/bun`.
 
-If `package.json` is present, the installer will offer to migrate your scripts to use `bin/bun` (e.g., `bun` → `bin/bun`, `npx` → `bin/bun x`). You can also run `rake bun:install:package` manually later.
+_If you're seeing a message like `Could not find gems matching 'bundlebun' valid for all resolution platforms (aarch64-linux, aarch64-linux-gnu <...> )`, [check this article](https://github.com/yaroslav/bundlebun/wiki/Could-not-find-gems-matching-'bundlebun'-valid-for-all-resolution-platforms)._
 
-Similarly, if `Procfile` or `Procfile.*` files are present, the installer will offer to migrate those as well. Run `rake bun:install:procfile` manually if needed.
-
-_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. See: _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.
+_Windows:_ `bin\bun.cmd` is created instead. If you joined a project with only the Unix binstub, run `rake bun:install` again.
 
 ## Usage
 
 ### Binstub
 
-The easiest way to interact with bundled Bun is via the binstub at `bin/bun`; it will launch the bundled version of Bun with the arguments provided:
+The easiest way to run Bun is via the `bin/bun` binstub:
 
 ```sh
-> bin/bun
-Bun is a fast JavaScript runtime, package manager, bundler, and test runner. (1.1.38+bf2f153f5)
-
-Usage: bun <command> [...flags] [...args]
-
-...
+bin/bun install
+bin/bun add postcss
+bin/bun run build
 ```
 
-### `PATH`
+### 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.
+bundlebun prepends the bundled Bun directory to your application's `PATH`. Tools that detect a `bun` executable (like vite-ruby) find it automatically—no extra configuration needed.
 
 ### 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.
+Alternatively, you can use a Rake task. The syntax is far from perfect—that's a limitation of Rake—but it's an option if you cannot install the binstub. Note the quotes around the parameters:
 
-```
+```sh
 rake bun[command]  # Run bundled Bun with parameters
 ```
 
@@ -128,160 +105,121 @@ bun outdated v1.1.38 (bf2f153f)
 ...
 ```
 
-### Ruby
-
-**Check bundlebun API: https://rubydoc.info/gems/bundlebun**.
-
-The easiest way to call Bun from Ruby is via `Bundlebun.()` (shortcut for `Bundlebun.call()`).
-
-**Note:** `Bundlebun.call` replaces the current Ruby process with Bun: it never returns.
+### Ruby API
 
 ```ruby
-Bundlebun.('outdated')             # runs `bun outdated`
-Bundlebun.call(['add', 'postcss']) # runs `bun add postcss`
+Bundlebun.('install')               # exec: replaces the current Ruby process with Bun
+Bundlebun.call(['add', 'postcss'])  # same thing, array form
 ```
 
-If you need to run Bun and then continue executing your Ruby code, use `Bundlebun.system`:
+**Note:** `Bundlebun.call` (and the `()` shortcut) replaces the current process—it never returns. Use `Bundlebun.system` to run Bun and continue executing Ruby:
 
 ```ruby
 if Bundlebun.system('install')
   puts 'Dependencies installed!'
-else
-  puts 'Installation failed'
 end
 
-# Run tests and check result
 success = Bundlebun.system('test')
+# => true if Bun exited successfully, false or nil otherwise
 ```
 
-Returns `true` if Bun exited successfully, `false` or `nil` otherwise.
+See the [API documentation](https://rubydoc.info/gems/bundlebun) for full details on `Bundlebun::Runner`.
 
-Check out the [API documentation](https://rubydoc.info/gems/bundlebun) on `Bundlebun::Runner` for helper methods.
+### Instrumentation
 
-## Integrations
+When ActiveSupport is available, bundlebun emits events you can subscribe to:
 
-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.
+```ruby
+ActiveSupport::Notifications.subscribe('system.bundlebun') do |event|
+  Rails.logger.info "Bun: #{event.payload[:command]} (#{event.duration.round(1)}ms)"
+end
+```
+
+Events: `system.bundlebun` (for `Bundlebun.system`) and `exec.bundlebun` (for `Bundlebun.call`). Payload: `{ command: args }`.
+
+## Integrations
 
-Alternatively, you can ensure an integration is loaded and the necessary modules are patched by calling methods that look like `Bundlebun::Integration::IntegrationName.bun!`. See the API documentation for that.
+bundlebun auto-detects and loads integrations when you run `rake bun:install`—as long as `gem "bundlebun"` is placed _after_ the relevant gems in your `Gemfile`.
 
-#### vite-ruby and vite-rails
+### vite-ruby / 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 with `rake bun:install`, or you can run:
+The bundlebun integration is installed automatically with `rake bun:install`, or you can run it explicitly:
 
 ```sh
 rake bun:install:vite
 ```
 
-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`.
+That will make sure you have a `bin/bun` binstub. Next, it installs a custom `bin/bun-vite` binstub to use in build scripts, and creates or updates `vite.json` 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`.
 
-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:
+To enable the integration manually:
 
 ```ruby
 Bundlebun::Integrations::ViteRuby.bun!
 ```
 
-#### Ruby on Rails: cssbundling and jsbundling
+### cssbundling-rails / jsbundling-rails
 
-[cssbundling](https://github.com/rails/cssbundling-rails) and [jsbundling](https://github.com/rails/jsbundling-rails) are Rails gems that support the traditional CSS and JS building pipeline for Ruby on Rails.
+[cssbundling-rails](https://github.com/rails/cssbundling-rails) and [jsbundling-rails](https://github.com/rails/jsbundling-rails) are Rails gems that support the traditional CSS and JS building pipeline for Ruby on Rails.
 
-Be sure to check both gems for documentation on bootstrapping your frontend build pipeline (as bundlebun supports them) instead of duplicating approaches. cssbundling, for instance, includes an excellent sample build configuration for Bun.
-
-To quote their READMEs, try this for cssbundling:
+Be sure to check both gems for documentation on bootstrapping your frontend build pipeline instead of duplicating approaches here. cssbundling-rails, for instance, includes an excellent sample build configuration for Bun.
 
 ```sh
+# Bootstrap cssbundling-rails
 bundle add cssbundling-rails
 bin/rails css:install:[tailwind|bootstrap|bulma|postcss|sass]
-bin/rails css:build
-```
-
-and this jsbundling:
 
-```sh
+# Bootstrap jsbundling-rails
 bundle add jsbundling-rails
 bin/rails javascript:install:bun
-```
 
-To make sure the bundlebun integration is installed (although the default `rake bun:install` should detect everything just fine), run
-
-```sh
+# Ensure bundlebun integration
 rake bun:install:bundling-rails
 ```
 
-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.
-
-#### ExecJS
+### 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 support 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. It supports a number of runtimes it can launch—and get a result from. Bun runtime support already exists in ExecJS; bundlebun just ensures it uses the bundled version.
 
-The bundlebun integration will work automatically if bundlebun is loaded after ExecJS in the `Gemfile`.
-
-Alternatively, you can load the monkey-patch manually:
+Works automatically when bundlebun loads after ExecJS in your `Gemfile`. To enable manually:
 
 ```ruby
 Bundlebun::Integrations::ExecJS.bun!
 ```
 
-#### ActiveSupport::Notifications (Instrumentation)
-
-When ActiveSupport is available, bundlebun emits instrumentation events that you can subscribe to for logging or monitoring:
-
-- `system.bundlebun` for `Bundlebun.system` (calling Bun and returning to Ruby code);
-- `exec.bundlebun` for `Bundlebun.call` / `Bundlebun.exec` (binstubs and wrappers: exiting to Bun).
-
-The payload is `{ command: args }`: the arguments you passed to the method (string or array).
-
-Example subscriber:
-
-```ruby
-ActiveSupport::Notifications.subscribe('system.bundlebun') do |event|
-  Rails.logger.info "Bun: #{event.payload[:command]} (#{event.duration.round(1)}ms)"
-end
-```
-
 ## Versioning
 
-bundlebun uses the `#{bundlebun.version}.#{bun.version}` versioning scheme. Meaning: gem bundlebun version `0.1.0.1.1.38` is a distribution that includes a gem with its own code version `0.1.0` and a Bun runtime with version `1.1.38`.
+bundlebun versions follow the `#{gem.version}.#{bun.version}` scheme. For example, `0.1.0.1.1.38` = gem version `0.1.0` + Bun `1.1.38`.
 
-bundlebun is designed to automatically push new gem versions when there is a new Bun release. That said, you can lock the exact version number in your `Gemfile`, or leave the version unspecified and update it as you wish.
+New gem versions are published automatically on each Bun release. Lock to a specific Bun version in your `Gemfile`, or leave it unspecified to always get the latest.
 
 ## Uninstall
 
-To uninstall, remove the gem:
-
 ```sh
 bundle remove bundlebun
 ```
 
-Or remove it from your `Gemfile` and run bundler.
-
-Next, remove the integrations you might have in place:
+Then clean up:
 
-- `bin/bun`
-- Delete `bin/bun-vite` if exists
-- Delete `tasks/bundlebun.rake` if exists
-- Search for `bin/bun` mentions in your code and configs
-- Search for `Bundlebun` mentions in your code.
+- `bin/bun` (and `bin\bun.cmd` on Windows)
+- `bin/bun-vite` if present
+- `tasks/bundlebun.rake` if present
+- Any `bin/bun` references in scripts and configs
+- Any `Bundlebun` references in your code
 
 ## Acknowledgements
 
-bundlebun gem downloads contain binary distributions of Bun available directly from https://github.com/oven-sh/bun/releases.
-
-[Bun](https://bun.sh) was created by Jarred Sumner [@jarred-sumner](https://github.com/jarred-sumner) & co. and is distributed under MIT. Check their [LICENSE](https://github.com/oven-sh/bun/blob/main/LICENSE.md).
+Bun binaries are sourced directly from [oven-sh/bun releases](https://github.com/oven-sh/bun/releases). [Bun](https://bun.sh) was created by Jarred Sumner ([@jarred-sumner](https://github.com/jarred-sumner)) and distributed under MIT.
 
-Big thanks to Jason Meller [@terracatta](https://github.com/terracatta) for his work on integrating Bun into the Ruby on Rails ecosystem: jsbundling-rails support, cssbundling-rails support with a proper build configuration, turbo-rails and stimulus-rails support, ExecJS support. See this [Pull Request](https://github.com/rails/rails/pull/49241).
+Big thanks to Jason Meller ([@terracatta](https://github.com/terracatta)) for his work on Bun's Ruby on Rails ecosystem integration—jsbundling-rails, cssbundling-rails, turbo-rails, stimulus-rails, and ExecJS support—in [this Pull Request](https://github.com/rails/rails/pull/49241).
 
 ## Contributing
 
-Make sure you have up-to-date Ruby. Run `bin/setup` to install the nesessary gems, install [lefthook](https://github.com/evilmartians/lefthook) and run `rake bundlebun:download` to fetch a local version of Bun for tests.
+Make sure you have up-to-date Ruby. Run `bin/setup` to install gems, install [lefthook](https://github.com/evilmartians/lefthook), and run `rake bundlebun:download` to fetch a local Bun build for tests.
 
-`rake rspec` to check if all tests pass.
-
-Open an issue or a PR.
+Run `rake rspec` to check tests. Open an issue or a PR.
 
 ## License
 
-The gem is available as open source under the terms of the MIT License.
-
-See [LICENSE.txt](LICENSE.txt).
+The gem is available as open source under the terms of the MIT License. See [LICENSE.txt](LICENSE.txt).

data/lib/bundlebun/runner.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'shellwords'
+
 module Bundlebun
   # {Runner} is the class that bundlebun uses to run the bundled Bun executable.
   #
@@ -194,7 +196,7 @@ module Bundlebun
     def exec
       check_executable!
       instrument('exec.bundlebun')
-      Kernel.exec(command)
+      Kernel.exec(*command)
     end
 
     # Replaces the current Ruby process with Bun. Alias for {#exec}.
@@ -228,7 +230,7 @@ module Bundlebun
     def system
       check_executable!
       instrument('system.bundlebun') do
-        Kernel.system(command)
+        Kernel.system(*command)
       end
     end
 
@@ -255,7 +257,18 @@ module Bundlebun
     end
 
     def command
-      [self.class.binary_path, *arguments].join(' ').strip
+      [self.class.binary_path, *command_arguments]
+    end
+
+    def command_arguments
+      case arguments
+      when Array
+        arguments.flatten.compact.map(&:to_s)
+      when nil
+        []
+      else
+        Shellwords.split(arguments.to_s)
+      end
     end
   end
 end

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.4.0'
+  VERSION = '0.4.1'
 end

data/lib/tasks/install.rake

@@ -242,7 +242,7 @@ namespace :bun do
     print "Apply these changes? [Y/n] "
     answer = $stdin.gets&.strip&.downcase
 
-    if answer.empty? || answer == 'y' || answer == 'yes'
+    if answer.nil? || answer.empty? || answer == 'y' || answer == 'yes'
       changes.each do |change|
         package['scripts'][change[:name]] = change[:new]
       end
@@ -294,7 +294,7 @@ namespace :bun do
       print "Apply these changes? [Y/n] "
       answer = $stdin.gets&.strip&.downcase
 
-      if answer.empty? || answer == 'y' || answer == 'yes'
+      if answer.nil? || answer.empty? || answer == 'y' || answer == 'yes'
         File.write(procfile, new_content)
         puts "Updated #{procfile} successfully.\n\n"
       else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bundlebun
 version: !ruby/object:Gem::Version
-  version: 0.4.0.1.3.10
+  version: 0.4.1.1.3.10
 platform: aarch64-linux
 authors:
 - Yaroslav Markin
@@ -87,7 +87,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/yaroslav/bundlebun
   source_code_uri: https://github.com/yaroslav/bundlebun
-  changelog_uri: https://github.com/yaroslav/bundlebun/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/yaroslav/bundlebun/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/yaroslav/bundlebun/issues
   documentation_uri: https://rubydoc.info/gems/bundlebun
   rbs_source: sig