bundlebun 0.1.0.1.1.38-x64-mingw-ucrt

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 658d1e09a376e7d6b2d94db58182c3dba921f2d4a3cecef60e43934dfc2dfe86
+  data.tar.gz: bbba581871392a38c26a0b8ab372d677f8636f512db7dae9a632ee2a0319117c
+SHA512:
+  metadata.gz: f9249088e9cc5ca370abaa0938e608f78686951ffa7bac755872cd646efdfc0335bbdcab8d20ac9a63a4fe40e5d61ea74fe10a6d9f5ca0e3905ca2ed456c09a8
+  data.tar.gz: aa0fb56c2e36f3b67ecd9800cc099d7989247dc6646e7f9642074c601fa3da9853e73cf2b934cc6adff8a5db602a8c9f8ffd331a1eabb18eb17a931ba2ad4175

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-12-15
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,98 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Yaroslav Markin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+Bun is licensed under the MIT License (https://github.com/oven-sh/bun/blob/main/LICENSE.md)
+
+Bun itself is MIT-licensed.
+
+## JavaScriptCore
+
+Bun statically links JavaScriptCore (and WebKit) which is LGPL-2 licensed. WebCore files from WebKit are also licensed under LGPL2. Per LGPL2:
+
+> (1) If you statically link against an LGPL’d library, you must also provide your application in an object (not necessarily source) format, so that a user has the opportunity to modify the library and relink the application.
+
+You can find the patched version of WebKit used by Bun here: <https://github.com/oven-sh/webkit>. If you would like to relink Bun with changes:
+
+- `git submodule update --init --recursive`
+- `make jsc`
+- `zig build`
+
+This compiles JavaScriptCore, compiles Bun’s `.cpp` bindings for JavaScriptCore (which are the object files using JavaScriptCore) and outputs a new `bun` binary with your changes.
+
+## Linked libraries
+
+Bun statically links these libraries:
+
+| Library | License |
+|---------|---------|
+| [`boringssl`](https://boringssl.googlesource.com/boringssl/) | [several licenses](https://boringssl.googlesource.com/boringssl/+/refs/heads/master/LICENSE) |
+| [`brotli`](https://github.com/google/brotli) | MIT |
+| [`libarchive`](https://github.com/libarchive/libarchive) | [several licenses](https://github.com/libarchive/libarchive/blob/master/COPYING) |
+| [`lol-html`](https://github.com/cloudflare/lol-html/tree/master/c-api) | BSD 3-Clause |
+| [`mimalloc`](https://github.com/microsoft/mimalloc) | MIT |
+| [`picohttp`](https://github.com/h2o/picohttpparser) | dual-licensed under the Perl License or the MIT License |
+| [`zstd`](https://github.com/facebook/zstd) | dual-licensed under the BSD License or GPLv2 license |
+| [`simdutf`](https://github.com/simdutf/simdutf) | Apache 2.0 |
+| [`tinycc`](https://github.com/tinycc/tinycc) | LGPL v2.1 |
+| [`uSockets`](https://github.com/uNetworking/uSockets) | Apache 2.0 |
+| [`zlib-cloudflare`](https://github.com/cloudflare/zlib) | zlib |
+| [`c-ares`](https://github.com/c-ares/c-ares) | MIT licensed |
+| [`libicu`](https://github.com/unicode-org/icu) 72 | [license here](https://github.com/unicode-org/icu/blob/main/icu4c/LICENSE) |
+| [`libbase64`](https://github.com/aklomp/base64/blob/master/LICENSE) | BSD 2-Clause |
+| [`libuv`](https://github.com/libuv/libuv) (on Windows) | MIT |
+| [`libdeflate`](https://github.com/ebiggers/libdeflate) | MIT |
+| A fork of [`uWebsockets`](https://github.com/jarred-sumner/uwebsockets) | Apache 2.0 licensed |
+| Parts of [Tigerbeetle's IO code](https://github.com/tigerbeetle/tigerbeetle/blob/532c8b70b9142c17e07737ab6d3da68d7500cbca/src/io/windows.zig#L1) | Apache 2.0 licensed |
+
+## Polyfills
+
+For compatibility reasons, the following packages are embedded into Bun's binary and injected if imported.
+
+| Package | License |
+|---------|---------|
+| [`assert`](https://npmjs.com/package/assert) | MIT |
+| [`browserify-zlib`](https://npmjs.com/package/browserify-zlib) | MIT |
+| [`buffer`](https://npmjs.com/package/buffer) | MIT |
+| [`constants-browserify`](https://npmjs.com/package/constants-browserify) | MIT |
+| [`crypto-browserify`](https://npmjs.com/package/crypto-browserify) | MIT |
+| [`domain-browser`](https://npmjs.com/package/domain-browser) | MIT |
+| [`events`](https://npmjs.com/package/events) | MIT |
+| [`https-browserify`](https://npmjs.com/package/https-browserify) | MIT |
+| [`os-browserify`](https://npmjs.com/package/os-browserify) | MIT |
+| [`path-browserify`](https://npmjs.com/package/path-browserify) | MIT |
+| [`process`](https://npmjs.com/package/process) | MIT |
+| [`punycode`](https://npmjs.com/package/punycode) | MIT |
+| [`querystring-es3`](https://npmjs.com/package/querystring-es3) | MIT |
+| [`stream-browserify`](https://npmjs.com/package/stream-browserify) | MIT |
+| [`stream-http`](https://npmjs.com/package/stream-http) | MIT |
+| [`string_decoder`](https://npmjs.com/package/string_decoder) | MIT |
+| [`timers-browserify`](https://npmjs.com/package/timers-browserify) | MIT |
+| [`tty-browserify`](https://npmjs.com/package/tty-browserify) | MIT |
+| [`url`](https://npmjs.com/package/url) | MIT |
+| [`util`](https://npmjs.com/package/util) | MIT |
+| [`vm-browserify`](https://npmjs.com/package/vm-browserify) | MIT |
+
+## Additional credits
+
+- Bun's JS transpiler, CSS lexer, and Node.js module resolver source code is a Zig port of [@evanw](https://github.com/evanw)’s [esbuild](https://github.com/evanw/esbuild) project.
+- Credit to [@kipply](https://github.com/kipply) for the name "Bun"!

data/README.md

@@ -0,0 +1,241 @@
+# 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`.
+
+## Quickstart
+
+Within your Ruby or Rails project:
+
+```sh
+bundle add bundlebun
+rake bun:install
+```
+
+and then
+
+```sh
+bin/bun ...
+```
+
+## Rationale
+
+**Modern frontend setup is needlessly complex** and may involve a lot of setup and maintenance. Developers need _at the very least_ a JavaScript runtime (typically, Node.js), a package manager (could be npm, yarn, or pnpm), and a build tool (Vite, Webpack, esbuild, Parcel—dozens of them).
+
+- One way forward is to dockerize development environments, creating unnecessary headaches for the development team—both frontend and backend engineers, especially if the team is not that large and the project is not that complex.
+- Another is to declare front-ops bankruptcy and pursue the "no-build" route.
+
+**What if we can simplify?** **Bun** is a **JavaScript runtime**, optimized for speed and developer experience. Bun is _also_ a fast JavaScript **package manager**. Bun is _also_ a **build tool**. Bun is also distributed as a single executable file.
+
+But Bun still requires [some installation](https://bun.sh/docs/installation), and we need to ensure everyone in the team uses the same version.
+
+How about we just pack it into a Ruby gem as a binary and allow developers to stay updated—every time a new Bun version is out—or freeze their desired version within their Ruby project. There are no setups, large READMEs with instructions, and no enforcing the Docker workflow.
+
+**Meet bundlebun**. With fast JavaScript runtime and a package manager included you can even skip on the build tool and use Bun itself.
+
+## Install
+
+bundlebun gem releases include a binary distribution of Bun for each supported Bun platform (macOS, Linux, Windows) and architectures.
+
+First, add it to your `Gemfile`:
+
+```ruby
+gem "bundlebun"
+```
+
+and
+
+```sh
+bundle install
+```
+
+or just
+
+```sh
+bundle add bundlebun
+```
+
+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`.
+
+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.
+
+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 follow with integrations:
+
+### Integrations
+
+Running `rake bun:install` tries to detect already-loaded gems and run the corresponding installation tasks.
+
+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.
+
+#### Ruby on Rails: cssbundling and jsbundling
+
+[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.
+
+Be sure to check both gems on documentation for bootstrapping your frontend build pipeline, as bundlebun supports them instead of duplicating approaches. cssbundling, for instance, includes an excellent sample build configuration for Bun.
+
+The bundlebun integration would be installed automatically, or you can run
+
+```sh
+rake bun:install:rails
+```
+
+manually. The task ensures a `bin/bun` binstub and installs an initializer/task of sorts to ensure both build-related gems use our bundled version of Bun.
+
+Alternatively, you can call
+
+```ruby
+Bundlebun::Integrations::Cssbundling.bun!
+Bundlebun::Integrations::Jsbundling.bun!
+```
+
+in one of your project's rakefiles.
+
+#### 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
+
+```sh
+rake bun:install:vite
+```
+
+That will ensure that 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`.
+
+Finally, we'll put an initializer that forces vite-ruby to use bundlebun. Alternatively, you can call
+
+```ruby
+Bundlebun::Integrations::ViteRuby.bun!
+```
+
+yourself.
+
+#### ExecJS
+
+[ExecJS](https://github.com/rails/execjs) runs JavaScript code straight from Ruby. For that, it supports a bunch of runtimes it could launch—and get a result. The Bun runtime already exists for ExecJS, and we just need to ensure it uses the bundled one.
+
+The bundlebun integration would be installed automatically, or you can run
+
+```sh
+rake bun:install:execjs
+```
+
+That would create an initializer that would redefine the Bun runtime for ExecJS and force its usage to be the default. Alternatively, you can call
+
+```ruby
+Bundlebun::Integrations::ExecJS.bun!
+```
+
+### Notes on `gem install`
+
+bundlebun is designed to be used with Bundler: installed in specific projects, and launched via `bin/bun` or integrations.
+
+If you install the gem globally, you _won't see the `bun` executable_ as a wrapper for a bundled Bun runtime; instead, it would be called `bundlebun`. This is done to avoid possible conflicts in your `$PATH` with a "real" Bun runtime you might have installed: if Ruby gem-generated binstubs are in that path before your Bun runtime, you won't easily run it. And that is bundlebun is not greedy with the `bun` executable name.
+
+If you wish to run Bun runtime globally using this gem, a simple symlink or a wrapper script will do, but the gem won't act destructively.
+
+## 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:
+
+```sh
+> bin/bun
+Bun is a fast JavaScript runtime, package manager, bundler, and test runner. (1.1.38+bf2f153f5)
+
+Usage: bun <command> [...flags] [...args]
+
+...
+```
+
+### Return codes
+
+Note that with this or any other option to run Bun, bundlebun will return the error code `127` if the executable is not found.
+
+### 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.
+
+```
+rake bun[command]  # Run bundled Bun with parameters
+```
+
+```sh
+> rake "bun[outdated]"
+bun outdated v1.1.38 (bf2f153f)
+...
+```
+
+### Ruby
+
+The easiest way to call Bun from Ruby would be `Bundlebun.call`:
+
+```ruby
+Bundlebun.call("outdated")
+Bundlebun.call(["add", "postcss"])
+```
+
+Check out the RDoc documentation for `Bundlebun::Runner` for helper methods. Some of the most useful ones:
+
+- `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.
+
+## 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 is supposed to automatically push new gem versions when there is a new Bun release.
+
+You can lock the exact version number in your `Gemfile`, or leave the version unspecified and update it as you wish.
+
+## Uninstall
+
+To uninstall, remove the gem:
+
+```sh
+bundle remove bundlebun
+```
+
+Or remove it from your `Gemfile`.
+
+Next, remove the integrations you have in place:
+
+- `bin/bun`
+- Delete `bin/vite` if exists or restore it from `bin/vite-backup`
+- 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.
+
+## 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 Jarred Sumner [@jarred-sumner](https://github.com/jarred-sumner) and co. and is distributed under MIT. Check their [LICENSE](https://github.com/oven-sh/bun/blob/main/LICENSE.md).
+
+Big thanks to Jason Meller [@terracatta](https://github.com/terracatta) for his work on integrating Bun into the 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).
+
+## Contributing
+
+Make sure you have up-to-date Ruby. Run `bundle install`. Run `rake bundlebun:download` to fetch a local version of Bun for tests. `rake rspec` to check if all tests pass.
+
+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).

data/exe/bundlebun

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Install the gem first, then create a binstub.
+#
+# Add to your Gemfile:
+#
+#   gem 'bundlebun'
+#
+# Then:
+#
+#   bundle install
+#   rake bun:install
+#
+# And then:
+#
+#   bin/bun ...
+#
+# If you're seeing this in your `bin/` directory and you're
+# no longer using bundlebun, it should be safe to delete.
+begin
+  require 'bundler/setup'
+rescue LoadError
+  # Continue without bundler if not available
+end
+require 'bundlebun'
+
+Bundlebun::Runner.call(ARGV)

data/lib/bundlebun/integrations/cssbundling.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  module Integrations
+    # A Bundlebun integration for cssbundling-rails[https://github.com/rails/cssbundling-rails].
+    #
+    # It's hard to override those methods on the fly, and a Rails initializer in the
+    # target project also does not seem to work, so we have to create a dummy task
+    # in the actual Rails project, and patch the helper module Tasks from there.
+    #
+    # When installed, makes it run a bundled Bun runtime for packing tasks.
+    #
+    # See: https://github.com/rails/cssbundling-rails/blob/main/lib/tasks/cssbundling/build.rake
+    module Cssbundling
+      # Patches the existing module.
+      #
+      # Call this after everything is loaded and required.
+      # For a Rails application, a good place is... not an initializer,
+      # but some code that can be run in a Rake task. Like a custom Rake task
+      # in <tt>lib/tasks</tt>.
+      #
+      # See the documentation for more info on installation Rake tasks.
+      def self.bun!
+        return unless defined?(::Cssbundling::Tasks)
+
+        ::Cssbundling::Tasks.prepend(self::Tasks)
+      end
+
+      module Tasks # :nodoc:
+        extend self
+
+        def install_command
+          "#{Bundlebun::Runner.binstub_or_binary_path} install"
+        end
+
+        def build_command
+          "#{Bundlebun::Runner.binstub_or_binary_path} run --bun build:css"
+        end
+      end
+    end
+  end
+end

data/lib/bundlebun/integrations/execjs.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  module Integrations
+    # An integration for execjs[https://github.com/rails/execjs].
+    #
+    # Runtimes in ExecJS are declared like this: https://github.com/rails/execjs/blob/master/lib/execjs/runtimes.rb
+    # We will redefine the Bun one, changing its command.
+    #
+    # Then, we will automatically set the bundlebun-ed Bun as the default runtime.
+    module ExecJS
+      # Patches the existing module to use bundlebun-ed Bun in place of an
+      # already existing, spported Bun runtime: we replace it with a bundled version.
+      #
+      # Additionally, sets it asa default ExecJS runtime.
+      #
+      # Call this after everything is loaded and required.
+      # For a Rails application, a good place is an initializer.
+      #
+      # See the documentation for more info on installation Rake tasks.
+      def self.bun!
+        return unless defined?(::ExecJS::Runtimes)
+
+        # Remove the existing Bun constant if it exists
+        ::ExecJS::Runtimes.send(:remove_const, :Bun) if ::ExecJS::Runtimes.const_defined?(:Bun)
+
+        # Define new Bun runtime with our custom command
+        bun_runtime = ::ExecJS::Runtimes.const_set(:Bun,
+          ::ExecJS::ExternalRuntime.new(
+            name: "Bun.sh",
+            command: [Bundlebun::Runner.binstub_or_binary_path],
+            runner_path: ::ExecJS.root + "/support/bun_runner.js",
+            encoding: "UTF-8"
+          ))
+
+        # Set the runtime
+        ::ExecJS.runtime = bun_runtime
+      end
+    end
+  end
+end

data/lib/bundlebun/integrations/jsbundling.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  module Integrations
+    # A Bundlebun integration for jsbundling-rails[https://github.com/rails/jsbundling-rails].
+    #
+    # It's hard to override those methods on the fly, and a Rails initializer in the
+    # target project also does not seem to work, so we have to create a dummy task
+    # in the actual Rails project, and patch the helper module Tasks from there.
+    #
+    # When installed, makes it run a bundled Bun runtime for packing tasks.
+    #
+    # See: https://github.com/rails/jsbundling-rails/blob/main/lib/tasks/jsbundling/build.rake
+    module Jsbundling
+      # Patches the existing module.
+      #
+      # Call this after everything is loaded and required.
+      # For a Rails application, a good place is... not an initializer,
+      # but some code that can be run in a Rake task. Like a custom Rake task
+      # in <tt>lib/tasks</tt>.
+      #
+      # See the documentation for more info on installation Rake tasks.
+      def self.bun!
+        return unless defined?(::Jsbundling::Tasks)
+
+        ::Jsbundling::Tasks.prepend(self::Tasks)
+      end
+
+      module Tasks # :nodoc:
+        extend self
+
+        def install_command
+          "#{Bundlebun::Runner.binstub_or_binary_path} install"
+        end
+
+        def build_command
+          "#{Bundlebun::Runner.binstub_or_binary_path} run --bun build"
+        end
+      end
+    end
+  end
+end

data/lib/bundlebun/integrations/vite_ruby.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  module Integrations
+    # An integration for vite-ruby[https://github.com/ElMassimo/vite_ruby] and vite-rails[https://vite-ruby.netlify.app/].
+    #
+    # For that, we would need both to replace the vite binstub (as <tt>bin/vite</tt>
+    # exists by itself and does not really initialize this gem if it is installed),
+    # and redefine the RunnerExtensions for ViteRuby by calling this patch from
+    # a Rails initializer.
+    # This way, a typical <tt>bin/dev</tt> would work, as well as integration tests.
+    module ViteRuby
+      # Patches the existing module.
+      #
+      # Call this after everything is loaded and required.
+      # For a Rails application, a good place is an initializer.
+      #
+      # See the documentation for more info on installation Rake tasks.
+      def self.bun!
+        return unless defined?(::ViteRuby::Runner)
+
+        ::ViteRuby::Runner.prepend(self::RunnerExtensions)
+      end
+
+      module RunnerExtensions # :nodoc:
+        # Internal: Resolves to an executable for Vite.
+        #
+        # We're overloading this to use with bundlebun.
+        def vite_executable(*exec_args)
+          # Should still allow a custom bin path/binstub
+          bin_path = config.vite_bin_path
+          return [bin_path] if bin_path && File.exist?(bin_path)
+
+          # Would be cleaner is to check `if config.package_manager == 'bun'`,
+          # but seems redundant since we're already bundling Bun,
+          # and putting `bun` as a package manager in their vite.json is just
+          # another step for the developer to do.
+          [bun_binstub_path, 'x --bun', *exec_args, 'vite']
+        end
+
+        # Use our binstub if it is installed in the project,
+        # otherwise just use the binary included with the gem.
+        def bun_binstub_path
+          Bundlebun::Runner.binstub_or_binary_path
+        end
+      end
+    end
+  end
+end

data/lib/bundlebun/integrations.rb

@@ -0,0 +1,16 @@
+module Bundlebun
+  # Bundlebun includes several integrations for frontend-related gems and frameworks.
+  #
+  # Usuall, you would need to run a provided Rake task (see the list at <tt>rake -T bun</tt>)
+  # to install any initializers or binstubs you might need.
+  # Then, the provided files will help you to initialise (patch) the code.
+  #
+  # Typically, to call an integration / patch the loaded code, you would need to call
+  # the <tt>bun!</tt> method, like:
+  #
+  #   Bundlebun::Integrations::Foobar.bun!
+  #
+  # See the documentation to learn about the supported integrations.
+  module Integrations
+  end
+end

data/lib/bundlebun/runner.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  # Runner is the class that bundlebun uses to run the bundled Bun executable.
+  #
+  # See Bundlebun.
+  class Runner
+    BINSTUB_PATH = 'bin/bun' # :nodoc:
+    RELATIVE_DIRECTORY = 'lib/bundlebun/vendor/bun' # :nodoc:
+
+    class << self
+      # Runs the Bun runtime with parameters (can be String or Array of strings).
+      #
+      # See Bundlebun::Runner.new, Bundlebun::Runner.call.
+      #
+      # Example:
+      #
+      #   Bundlebun.call('--version')
+      #   Bundlebun.call(['add', 'postcss'])
+      #
+      # Returns error status <tt>127</tt> if the executable does not exist.
+      def call(...)
+        new(...).call
+      end
+
+      # A relative path to binstub bundlebun usually generates with installation Rake tasks.
+      def binstub_path
+        BINSTUB_PATH
+      end
+
+      # A relative directory path to the bundled Bun executable from the root of the gem.
+      def relative_directory
+        RELATIVE_DIRECTORY
+      end
+
+      # A full directory path to the bundled Bun executable from the root of the gem.
+      def full_directory
+        File.expand_path("../../#{relative_directory}", __dir__)
+      end
+
+      # A full path to the bundled Bun binary we run.
+      def binary_path
+        executable = "bun#{RUBY_PLATFORM.match?(/mingw|mswin/) ? ".exe" : ""}"
+        File.join(full_directory, executable)
+      end
+
+      # Does the bundled Bun binary exist?
+      def binary_path_exist?
+        File.exist?(binary_path)
+      end
+
+      # Returns the preferred way to run Bun when bundlebun is installed.
+      #
+      # If the binstub is installed (see binstub_path), use the binstub.
+      # If not, use the full binary path for the bundled executable (binary_path).
+      def binstub_or_binary_path
+        binstub_exist? ? binstub_path : binary_path
+      end
+
+      # Does the binstub exist?
+      def binstub_exist?
+        File.exist?(binstub_path)
+      end
+    end
+
+    # Intialize the runner with arguments to run the Bun runtime later via call.
+    #
+    # Arguments can be a String or an Array of strings.
+    #
+    # Example:
+    #
+    #   Bundlebun::Runner.new('--version')
+    #   Bundlebun::Runner.new(['install', 'postcss'])
+    #
+    # Returns error status <tt>127</tt> if the executable does not exist.
+    def initialize(arguments = '')
+      @arguments = arguments
+    end
+
+    # Runs the Bun executable with previously specified arguments.
+    #
+    # Returns error status <tt>127</tt> if the executable does not exist.
+    #
+    # Example:
+    #
+    #   r = Bundlebun::Runner.new('--version')
+    #   r.call!
+    #
+    # Check other methods of Bundlebun::Runner to see how we determine what to run exactly.
+    def call
+      check_executable!
+      exec(command)
+    end
+
+    private
+
+    attr_reader :arguments
+
+    def check_executable!
+      return if self.class.binary_path_exist?
+
+      Kernel.warn "Unable to run Bun: executable not found at #{self.class.binary_path}"
+      Kernel.exit 127
+    end
+
+    def command
+      [self.class.binary_path, *arguments].join(' ').strip
+    end
+  end
+end

data/lib/bundlebun/vendor/bun/LICENSE.md

@@ -0,0 +1,73 @@
+Bun itself is MIT-licensed.
+
+## JavaScriptCore
+
+Bun statically links JavaScriptCore (and WebKit) which is LGPL-2 licensed. WebCore files from WebKit are also licensed under LGPL2. Per LGPL2:
+
+> (1) If you statically link against an LGPL’d library, you must also provide your application in an object (not necessarily source) format, so that a user has the opportunity to modify the library and relink the application.
+
+You can find the patched version of WebKit used by Bun here: <https://github.com/oven-sh/webkit>. If you would like to relink Bun with changes:
+
+- `git submodule update --init --recursive`
+- `make jsc`
+- `zig build`
+
+This compiles JavaScriptCore, compiles Bun’s `.cpp` bindings for JavaScriptCore (which are the object files using JavaScriptCore) and outputs a new `bun` binary with your changes.
+
+## Linked libraries
+
+Bun statically links these libraries:
+
+| Library                                                                                                                                          | License                                                                                      |
+| ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
+| [`boringssl`](https://boringssl.googlesource.com/boringssl/)                                                                                     | [several licenses](https://boringssl.googlesource.com/boringssl/+/refs/heads/master/LICENSE) |
+| [`brotli`](https://github.com/google/brotli)                                                                                                     | MIT                                                                                          |
+| [`libarchive`](https://github.com/libarchive/libarchive)                                                                                         | [several licenses](https://github.com/libarchive/libarchive/blob/master/COPYING)             |
+| [`lol-html`](https://github.com/cloudflare/lol-html/tree/master/c-api)                                                                           | BSD 3-Clause                                                                                 |
+| [`mimalloc`](https://github.com/microsoft/mimalloc)                                                                                              | MIT                                                                                          |
+| [`picohttp`](https://github.com/h2o/picohttpparser)                                                                                              | dual-licensed under the Perl License or the MIT License                                      |
+| [`zstd`](https://github.com/facebook/zstd)                                                                                                       | dual-licensed under the BSD License or GPLv2 license                                         |
+| [`simdutf`](https://github.com/simdutf/simdutf)                                                                                                  | Apache 2.0                                                                                   |
+| [`tinycc`](https://github.com/tinycc/tinycc)                                                                                                     | LGPL v2.1                                                                                    |
+| [`uSockets`](https://github.com/uNetworking/uSockets)                                                                                            | Apache 2.0                                                                                   |
+| [`zlib-cloudflare`](https://github.com/cloudflare/zlib)                                                                                          | zlib                                                                                         |
+| [`c-ares`](https://github.com/c-ares/c-ares)                                                                                                     | MIT licensed                                                                                 |
+| [`libicu`](https://github.com/unicode-org/icu) 72                                                                                                | [license here](https://github.com/unicode-org/icu/blob/main/icu4c/LICENSE)                   |
+| [`libbase64`](https://github.com/aklomp/base64/blob/master/LICENSE)                                                                              | BSD 2-Clause                                                                                 |
+| [`libuv`](https://github.com/libuv/libuv) (on Windows)                                                                                           | MIT                                                                                          |
+| [`libdeflate`](https://github.com/ebiggers/libdeflate)                                                                                           | MIT                                                                                          |
+| A fork of [`uWebsockets`](https://github.com/jarred-sumner/uwebsockets)                                                                          | Apache 2.0 licensed                                                                          |
+| Parts of [Tigerbeetle's IO code](https://github.com/tigerbeetle/tigerbeetle/blob/532c8b70b9142c17e07737ab6d3da68d7500cbca/src/io/windows.zig#L1) | Apache 2.0 licensed                                                                          |
+
+## Polyfills
+
+For compatibility reasons, the following packages are embedded into Bun's binary and injected if imported.
+
+| Package                                                                  | License |
+| ------------------------------------------------------------------------ | ------- |
+| [`assert`](https://npmjs.com/package/assert)                             | MIT     |
+| [`browserify-zlib`](https://npmjs.com/package/browserify-zlib)           | MIT     |
+| [`buffer`](https://npmjs.com/package/buffer)                             | MIT     |
+| [`constants-browserify`](https://npmjs.com/package/constants-browserify) | MIT     |
+| [`crypto-browserify`](https://npmjs.com/package/crypto-browserify)       | MIT     |
+| [`domain-browser`](https://npmjs.com/package/domain-browser)             | MIT     |
+| [`events`](https://npmjs.com/package/events)                             | MIT     |
+| [`https-browserify`](https://npmjs.com/package/https-browserify)         | MIT     |
+| [`os-browserify`](https://npmjs.com/package/os-browserify)               | MIT     |
+| [`path-browserify`](https://npmjs.com/package/path-browserify)           | MIT     |
+| [`process`](https://npmjs.com/package/process)                           | MIT     |
+| [`punycode`](https://npmjs.com/package/punycode)                         | MIT     |
+| [`querystring-es3`](https://npmjs.com/package/querystring-es3)           | MIT     |
+| [`stream-browserify`](https://npmjs.com/package/stream-browserify)       | MIT     |
+| [`stream-http`](https://npmjs.com/package/stream-http)                   | MIT     |
+| [`string_decoder`](https://npmjs.com/package/string_decoder)             | MIT     |
+| [`timers-browserify`](https://npmjs.com/package/timers-browserify)       | MIT     |
+| [`tty-browserify`](https://npmjs.com/package/tty-browserify)             | MIT     |
+| [`url`](https://npmjs.com/package/url)                                   | MIT     |
+| [`util`](https://npmjs.com/package/util)                                 | MIT     |
+| [`vm-browserify`](https://npmjs.com/package/vm-browserify)               | MIT     |
+
+## Additional credits
+
+- Bun's JS transpiler, CSS lexer, and Node.js module resolver source code is a Zig port of [@evanw](https://github.com/evanw)’s [esbuild](https://github.com/evanw/esbuild) project.
+- Credit to [@kipply](https://github.com/kipply) for the name "Bun"!

data/lib/bundlebun/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  VERSION = '0.1.0' # :nodoc:
+end

data/lib/bundlebun.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+# bundlebun bundles Bun[https://bun.sh], a fast JavaScript runtime, package manager
+# and builder, with your Ruby and Rails applications.
+# No Docker, devcontainers, <tt>curl | sh</tt>, or <tt>brew</tt> needed.
+#
+# bundlebun includes binary distributions of Bun for each of the supported
+# platforms (macOS, Linux, Windows) and architectures.
+module Bundlebun
+  class << self
+    # Runs the Bun runtime with parameters (can be String or Array of strings).
+    #
+    # A shortcut for Bundlebun::Runner.call.
+    #
+    # Example:
+    #
+    #   Bundlebun.call('--version')
+    #   Bundlebun.call(['add', 'postcss'])
+    #
+    # Returns error status <tt>127</tt> if the executable does not exist.
+    def call(...)
+      Runner.call(...)
+    end
+
+    def loader # :nodoc:
+      @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
+        loader.ignore("#{__dir__}/tasks")
+        loader.ignore("#{__dir__}/bundlebun/vendor")
+        loader.ignore("#{__dir__}/templates")
+
+        loader.inflector.inflect('execjs' => 'ExecJS')
+
+        loader.setup
+      end
+    end
+
+    def load_tasks # :nodoc:
+      Dir[File.expand_path('tasks/*.rake', __dir__)].each { |task| load task }
+    end
+
+    def bun = 'Bun' # :nodoc:
+    alias_method :bun?, :bun
+    alias_method :bun!, :bun
+  end
+end
+
+Bundlebun.loader
+
+Bundlebun.load_tasks if defined?(Rake)

data/lib/tasks/bun.rake

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rake'
+
+# Rake command/parameter handling is limited, so we
+# need to use the <tt>[]</tt>-syntax.
+#
+# Even when using <tt>--</tt> with something like
+# <tt>rake bun -- -e 'console.log(1)'</tt>, Rack thinks that
+# <tt>console.log...</tt> is a task it needs to run, warns about an
+# error (although still executes known tasks).
+#
+# Example:
+#
+#   rake "bun[-e 'console.log(2+2)']"
+#
+desc 'Run bundled Bun with parameters. Example: rake "bun[build]"'
+task :bun, [:command] do |_t, args|
+  command = args[:command] || ''
+  Bundlebun::Runner.call(command)
+end

data/lib/tasks/install.rake

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+namespace :bun do
+  desc 'Install bundlebun: install binstub and detect frameworks'
+  task 'install' do
+    puts <<~MESSAGE
+      We are now going to install bundlebun. We'll try to detect the frameworks already in use and install integrations for them.
+
+      Don't forget to run `rake -T bun` to learn more about additional installation tasks for integration with Ruby and JavaScript frameworks, or check the documentation.
+
+      Bun.
+
+    MESSAGE
+
+    Rake::Task['bun:install:bin'].invoke
+
+    if defined?(Rails)
+      puts "Rails detected.\n\n"
+      Rake::Task['bun:install: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'
+  task 'install:bin' do
+    puts "Installing bin/bun...\n\n"
+
+    source = File.expand_path('../../exe/bundlebun', __dir__)
+    target_dir = 'bin'
+    target = File.join(target_dir, 'bun')
+
+    if File.exist?(target)
+      puts "#{target} already exists."
+    else
+      FileUtils.mkdir_p(target_dir)
+      FileUtils.cp(source, target)
+      FileUtils.chmod(0o755, target)
+
+      puts "Installed binstub at #{target}."
+    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.
+
+      Bun.
+
+    MESSAGE
+  end
+
+  desc 'Install bundlebun: Rails, cssbundling-rails, jsbundling-rails integration'
+  task 'install:rails' => :install do
+    puts "Installing Rails integration...\n\n"
+
+    assets_rake = File.expand_path('../templates/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
+      puts "#{target} already exists."
+    end
+
+    puts <<~MESSAGE
+      Install cssbundling-rails [https://github.com/rails/cssbundling-rails] and jsbundling-rails [https://github.com/rails/jsbundling-rails] to get a simple assets pipeline with Rails, powered by Bun.
+
+      Example:
+
+        bundle add cssbundling-rails
+        bin/rails css:install:[tailwind|bootstrap|bulma|postcss|sass]
+        bin/rails css:build
+
+        bundle add jsbundling-rails
+        bin/rails javascript:install:bun
+
+      Those gems enable you to create new Rails templates using Bun, as well as to create a simple build configuration with Bun. Check their READMEs and documentation.
+
+      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.
+
+      Bun.
+
+    MESSAGE
+  end
+
+  desc 'Install bundlebun: vite-ruby integration'
+  task 'install:vite' => :install do
+    puts "Installing vite-ruby integration...\n\n"
+
+    binstub = File.expand_path('../templates/vite-ruby/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')
+
+    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)
+
+      FileUtils.cp(binstub, target)
+      FileUtils.chmod(0o755, target)
+      puts "Installed a vite-ruby + bundlebun binstub at #{target}"
+    else
+      FileUtils.mkdir_p(target_dir)
+      FileUtils.cp(binstub, target)
+      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."
+      else
+        FileUtils.cp(initializer, initializer_target)
+        puts "Installed a Rails initializer for vite-ruby at #{initializer_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.
+
+      Bun.
+
+    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}."
+      end
+    else
+      puts "Directory #{initializers_dir} does not seem to exist; not installing a Rails initializer."
+    end
+
+    puts <<~MESSAGE
+      We've installed a Rails initializer that re-defines the Bun runtime for ExecJS and
+      sets Bun as a default runtime.
+
+      Bun.
+
+    MESSAGE
+  end
+end

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

@@ -0,0 +1,9 @@
+# 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/rails/bundlebun.rake

@@ -0,0 +1,10 @@
+# An initializer of sorts for bundlebun's ExecJS integration.
+# Can't go to `initializers`, does not trigger that way.
+#
+# This forces cssbundling and jsbundling to use a bundlebun'ed
+# version of Bun for building assets.
+#
+# Safe to delete if you no longer use bundlebun or
+# not interested in running Bun anymore.
+Bundlebun::Integrations::Cssbundling.bun!
+Bundlebun::Integrations::Jsbundling.bun!

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

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

@@ -0,0 +1,25 @@
+#!/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

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: bundlebun
+version: !ruby/object:Gem::Version
+  version: 0.1.0.1.1.38
+platform: x64-mingw-ucrt
+authors:
+- Yaroslav Markin
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  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`.
+
+  '
+email:
+- yaroslav@markin.net
+executables:
+- bundlebun
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/bundlebun
+- lib/bundlebun.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/runner.rb
+- lib/bundlebun/vendor/bun/LICENSE.md
+- lib/bundlebun/vendor/bun/bun.exe
+- 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
+homepage: https://github.com/yaroslav/bundlebun
+licenses:
+- MIT
+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
+  bug_tracker_uri: https://github.com/yaroslav/bundlebun/issues
+  documentation_uri: https://github.com/yaroslav/bundlebun/blob/main/README.md
+post_install_message: Bun.
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: bundlebun bundles the Bun JavaScript runtime, package manager and build tool,
+  for use with Ruby and Rails
+test_files: []