bundlebun 0.5.0.1.3.13-aarch64-linux-gnu

data/lib/bundlebun/integrations/vite_ruby.rb

@@ -0,0 +1,58 @@
+# 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 `bin/vite`
+    # 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 `bin/dev` would work, as well as integration tests.
+    #
+    # @see https://github.com/ElMassimo/vite_ruby
+    # @see https://vite-ruby.netlify.app
+    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.
+      #
+      # @example
+      #   Bundlebun::Integrations::ViteRuby.bun!
+      def self.bun!
+        return unless defined?(::ViteRuby::Runner)
+
+        ::ViteRuby::Runner.prepend(self::RunnerExtensions)
+      end
+
+      # A monkey-patch for ViteRuby.
+      #
+      # @see https://github.com/ElMassimo/vite_ruby/blob/main/vite_ruby/lib/vite_ruby/runner.rb
+      module RunnerExtensions
+        # 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,31 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  # Bundlebun includes several integrations for frontend-related gems and frameworks.
+  #
+  # Usually you would need to run a provided Rake task (see the list at `rake -T bun`)
+  # to install any initializers or binstubs you might need.
+  # Then, the provided files will help you to initialize (patch) the code.
+  #
+  # Typically, to call an integration / patch the loaded code, you would need to call
+  # the `bun!` method, like `Bundlebun::Integrations::Foobar.bun!`.
+  #
+  # 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

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Bundlebun
+  # {Runner} is the class that bundlebun uses to run the bundled Bun executable.
+  #
+  # bundlebun provides two ways to run Bun:
+  #
+  # - {.call} (also available as {.exec}): Replaces the current Ruby process with Bun. This is the default.
+  #
+  # - {.system}: Runs Bun as a subprocess and returns control to Ruby.
+  #   Use this when you need to continue executing Ruby code after Bun finishes.
+  #
+  # @see Bundlebun
+  #
+  # @example Running Bun (replaces process, never returns)
+  #   Bundlebun.('install')
+  #   Bundlebun.call('outdated')
+  #   Bundlebun.call(['add', 'postcss'])
+  #
+  # @example Running Bun as subprocess (returns to Ruby)
+  #   if Bundlebun.system('install')
+  #     puts 'Dependencies installed!'
+  #   end
+  class Runner
+    BINSTUB_PATH = 'bin/bun'
+    RELATIVE_DIRECTORY = 'lib/bundlebun/vendor/bun'
+
+    class << self
+      # Replaces the current Ruby process with Bun.
+      #
+      # When `ActiveSupport::Notifications` is available, this method publishes an
+      # `exec.bundlebun` event before replacing the process. The payload contains
+      # `{ command: arguments }` where `arguments` is what was passed to the method.
+      #
+      # @param arguments [String, Array<String>] Command arguments to pass to Bun
+      # @return [void] This method never returns
+      #
+      # @example In a binstub (bin/bun)
+      #   #!/usr/bin/env ruby
+      #   require 'bundlebun'
+      #   Bundlebun.exec(ARGV)
+      #
+      # @see .call
+      # @see .system
+      def exec(...)
+        new(...).exec
+      end
+
+      # Replaces the current Ruby process with Bun. Alias for {.exec}.
+      # Also available via the `.()` shorthand syntax.
+      #
+      # @param arguments [String, Array<String>] Command arguments to pass to Bun
+      # @return [void] This method never returns
+      #
+      # @example Basic usage
+      #   Bundlebun.call('outdated')
+      #   Bundlebun.call(['add', 'postcss'])
+      #
+      # @example Using the .() shorthand
+      #   Bundlebun.('install')
+      #
+      # @see .exec
+      # @see .system
+      def call(...)
+        exec(...)
+      end
+
+      # Runs Bun as a subprocess and returns control to Ruby.
+      #
+      # Unlike {.call} and {.exec}, this method does not replace the current process.
+      # Use this when you need to run Bun and then continue executing Ruby code.
+      #
+      # When `ActiveSupport::Notifications` is available, this method publishes a
+      # `system.bundlebun` event with timing information. The payload contains
+      # `{ command: arguments }` where `arguments` is what was passed to the method.
+      #
+      # @param arguments [String, Array<String>] Command arguments to pass to Bun
+      # @return [Boolean, nil] `true` if Bun exited successfully (status 0),
+      #   `false` if it exited with an error, `nil` if execution failed
+      #
+      # @example Run install and check result
+      #   if Bundlebun.system('install')
+      #     puts 'Dependencies installed!'
+      #   else
+      #     puts 'Installation failed'
+      #   end
+      #
+      # @see .call
+      # @see .exec
+      def system(...)
+        new(...).system
+      end
+
+      # 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
+        return @binstub_path if defined?(@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
+        return @full_binstub_path if defined?(@full_binstub_path)
+
+        @full_binstub_path = File.expand_path(binstub_path)
+      end
+
+      # A relative directory path to the bundled Bun executable from the root of the gem.
+      #
+      # @return [String]
+      def relative_directory
+        RELATIVE_DIRECTORY
+      end
+
+      # A full directory path to the bundled Bun executable from the root of the gem.
+      #
+      # @return [String]
+      def full_directory
+        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
+      # (includes `.exe` on Windows).
+      #
+      # @return [String]
+      def binary_path
+        return @binary_path if defined?(@binary_path)
+
+        executable = "bun#{".exe" if Bundlebun::Platform.windows?}"
+        @binary_path = File.join(full_directory, executable)
+      end
+
+      # Does the bundled Bun binary exist?
+      #
+      # @return [Boolean]
+      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 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? ? full_binstub_path : binary_path
+      end
+
+      # Does the binstub exist?
+      #
+      # @return [Boolean]
+      def binstub_exist?
+        File.exist?(binstub_path)
+      end
+    end
+
+    # Initialize the {Runner} with arguments to run the Bun runtime later.
+    #
+    # @param arguments [String, Array<String>] Command arguments to pass to Bun
+    #
+    # @example String as an argument
+    #   Bundlebun::Runner.new('--version')
+    #
+    # @example Array of strings as an argument
+    #   Bundlebun::Runner.new(['add', 'postcss'])
+    #
+    # @see #system
+    # @see #exec
+    def initialize(arguments)
+      @arguments = arguments
+    end
+
+    # Replaces the current Ruby process with Bun.
+    # This is the default behavior.
+    #
+    # When `ActiveSupport::Notifications` is available, this method publishes an
+    # `exec.bundlebun` event before replacing the process. The payload contains
+    # `{ command: arguments }` where `arguments` is what was passed to the runner.
+    #
+    # @return [void] This method never returns
+    #
+    # @example
+    #   runner = Bundlebun::Runner.new(ARGV)
+    #   runner.exec  # Ruby process ends here, Bun takes over
+    #
+    # @see #system
+    def exec
+      check_executable!
+      instrument('exec.bundlebun')
+      Kernel.exec(*command)
+    end
+
+    # Replaces the current Ruby process with Bun. Alias for {#exec}.
+    #
+    # @return [void] This method never returns
+    #
+    # @see #exec
+    def call
+      exec
+    end
+
+    # Runs Bun as a subprocess and returns control to Ruby.
+    #
+    # Unlike {#call} and {#exec}, this method does not replace the current process.
+    # Use this when you need to run Bun and then continue executing Ruby code.
+    #
+    # When `ActiveSupport::Notifications` is available, this method publishes a
+    # `system.bundlebun` event with timing information. The payload contains
+    # `{ command: arguments }` where `arguments` is what was passed to the runner.
+    #
+    # @return [Boolean, nil] `true` if Bun exited successfully (status 0),
+    #   `false` if it exited with an error, `nil` if execution failed
+    #
+    # @example
+    #   runner = Bundlebun::Runner.new('install')
+    #   if runner.system
+    #     puts 'Dependencies installed!'
+    #   end
+    #
+    # @see #exec
+    def system
+      check_executable!
+      instrument('system.bundlebun') do
+        Kernel.system(*command)
+      end
+    end
+
+    private
+
+    attr_reader :arguments
+
+    def instrument(event, &block)
+      return block&.call unless defined?(ActiveSupport::Notifications)
+
+      payload = {command: arguments}
+      if block
+        ActiveSupport::Notifications.instrument(event, payload, &block)
+      else
+        ActiveSupport::Notifications.instrument(event, payload)
+      end
+    end
+
+    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, *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/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,12 @@
+# frozen_string_literal: true
+
+module Bundlebun
+  # bundlebun uses the `#{bundlebun.version}.#{bun.version}`
+  # versioning scheme.
+  # 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`.
+  #
+  # This constant always points to the "own" version of the gem.
+  VERSION = '0.5.0'
+end

data/lib/bundlebun.rb

@@ -0,0 +1,130 @@
+# 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, `curl | sh`, or `brew` needed.
+#
+# bundlebun includes binary distributions of Bun for each of the supported
+# platforms (macOS, Linux, Windows) and architectures.
+#
+# bundlebun provides two ways to run Bun:
+#
+# - {.call} (also available as {.exec}): Replaces the current Ruby process with Bun. The default.
+#
+# - {.system}: Runs Bun as a subprocess and returns control to Ruby.
+#   Use this when you need to continue executing Ruby code after Bun finishes.
+#
+# @see Bundlebun::Runner
+# @see Bundlebun::Integrations
+#
+# @example Running Bun (replaces process, never returns)
+#   Bundlebun.('install')                # .() shorthand syntax
+#   Bundlebun.call('outdated')
+#   Bundlebun.call(['add', 'postcss'])
+#
+# @example Running Bun as subprocess (returns to Ruby)
+#   if Bundlebun.system('install')
+#     puts 'Dependencies installed!'
+#   end
+module Bundlebun
+  class << self
+    # Replaces the current Ruby process with Bun.
+    #
+    # This is the default way to run Bun. The Ruby process is replaced by Bun
+    # and never returns. Also available via the `.()` shorthand syntax.
+    #
+    # @param arguments [String, Array<String>] Command arguments to pass to Bun
+    # @return [void] This method never returns
+    #
+    # @example Basic usage
+    #   Bundlebun.call('outdated')
+    #   Bundlebun.call(['add', 'postcss'])
+    #
+    # @example Using the .() shorthand
+    #   Bundlebun.('install')
+    #   Bundlebun.(ARGV)
+    #
+    # @see .exec
+    # @see .system
+    # @see Bundlebun::Runner.call
+    def call(...)
+      Runner.call(...)
+    end
+
+    # Replaces the current Ruby process with Bun. Same as {.call}.
+    #
+    # @param arguments [String, Array<String>] Command arguments to pass to Bun
+    # @return [void] This method never returns
+    #
+    # @see .call
+    # @see Bundlebun::Runner.exec
+    def exec(...)
+      Runner.exec(...)
+    end
+
+    # Runs Bun as a subprocess and returns control to Ruby.
+    #
+    # Unlike {.call} and {.exec}, this method does not replace the current process.
+    # Use this when you need to run Bun and then continue executing Ruby code.
+    #
+    # @param arguments [String, Array<String>] Command arguments to pass to Bun
+    # @return [Boolean, nil] `true` if Bun exited successfully (status 0),
+    #   `false` if it exited with an error, `nil` if execution failed
+    #
+    # @example Run install and check result
+    #   if Bundlebun.system('install')
+    #     puts 'Dependencies installed!'
+    #   else
+    #     puts 'Installation failed'
+    #   end
+    #
+    # @see .call
+    # @see .exec
+    # @see Bundlebun::Runner.system
+    def system(...)
+      Runner.system(...)
+    end
+
+    def loader # @private
+      @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
+
+    # 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
+  end
+end
+
+Bundlebun.loader
+Bundlebun.prepend_to_path
+Bundlebun.load_tasks if defined?(Rake)
+Bundlebun.load_integrations

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.call(command)
+end