bundle_matrix 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4167a86314145a5afc95384b77c4b3820a623578eb4d1d579a526e4150dd82af
+  data.tar.gz: b6d67d2373ba4810848712cf2d08272479771acfe4febe2b761e9d8ded79cd66
+SHA512:
+  metadata.gz: 19b4dc2513e12c4cf9054961cd24844325b375641d6b19dd4bb7c764acd2b7dd3c7b68264e7b2ed7f372f3de2b78dec7585f29971130b4549f594b558f86c780
+  data.tar.gz: 6d52388801b2a6abcbe745166d36eef8d0048f33151ec8e8b5f21a7e5272ac7f1f56722e97b250142ba7e880da934b9fa667b647ec521d466904eb89c83a3454

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-11-08
+
+Initial release. bundle_matrix is a Bundler plugin that repeats `bundle install`, `bundle update` and `bundle add` against every secondary gemfile in your project, so each lockfile stays in step with the main gemfile.
+
+- Finds secondary gemfiles (`*.gemfile` in the project root and `gemfiles/`), plus `gems.rb` or `Gemfile` in any directories listed in `matrix.paths`
+- Forwards the same flags to each gemfile, handling gems, groups, `--path` and `--lockfile` per gemfile
+- Runs each secondary gemfile with its own lockfile's Bundler version
+- Shares the project's `.bundle/config` and `BUNDLE_*` environment variables with every gemfile
+- Recognizes command aliases and prefixes (`i`, `a`, `u`) and plain `bundle`, as Bundler does
+- Reports a gemfile that fails as an error and keeps going with the rest

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 joe-sharp
+
+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.

data/README.md

@@ -0,0 +1,149 @@
+# BundleMatrix
+
+A Bundler plugin that repeats `bundle install`, `bundle update` and `bundle add` against every other gemfile in your project, so each lockfile stays in step with the main `Gemfile`.
+
+Projects that test against several dependency sets keep extra gemfiles (`ci.gemfile`, `gemfiles/rails7.gemfile`, engine Gemfiles, and so on). Without help, every one of them needs its own `BUNDLE_GEMFILE=… bundle install`. With bundle_matrix, running the command on the main `Gemfile` does that for you.
+
+![BundleMatrix](https://raw.githubusercontent.com/joe-sharp/bundle_matrix/main/BundleMatrix.webp)
+
+## Installation
+
+Install the plugin once for your user:
+
+```bash
+bundle plugin install bundle_matrix
+```
+
+Or declare it in the project's `Gemfile`:
+
+```ruby
+plugin "bundle_matrix"
+```
+
+## Usage
+
+Run the command on the main `Gemfile` as usual:
+
+```bash
+bundle install
+bundle update rails --conservative
+bundle update --all
+bundle add rack --group development
+```
+
+After the main run succeeds, each discovered gemfile is run with the same command and flags. Output is headed by the gemfile it applies to:
+
+```
+== bundle_matrix: gemfiles/rails7.gemfile -> bundle update rails --conservative
+== bundle_matrix: engines/admin/Gemfile -> bundle install
+```
+
+Only `install`, `update` and `add` are fanned out. `bundle check`, `bundle exec` and similar commands are not, because Bundler does not run plugin hooks for them.
+
+Bundler's short forms work too: `bundle i`, `bundle ins`, `bundle a`, `bundle u`, and any other unambiguous prefix of a command name.
+
+A plain `bundle`, or `bundle` with only flags such as `bundle --jobs=4`, runs as `install` and fans out as `install`, but only while `default_cli_command` is unset or `install`. With it set to `cli_help`, those commands print help and nothing fans out. Bundler's documentation already names `cli_help` as the default, while its code still runs `install` and prints a notice that this will change. To keep fanning out whatever Bundler does, set the setting explicitly, or run `bundle install`:
+
+```bash
+bundle config set default_cli_command install
+```
+
+## Which gemfiles are found
+
+The main gemfile is `Gemfile` in the project root, or the file named by `matrix.default_gemfile`. It is never treated as a secondary gemfile. Secondary gemfiles are found in:
+
+- `*.gemfile` in the project root, e.g. `ci.gemfile` with `ci.gemfile.lock`
+- `*.gemfile` in `gemfiles/`
+- any directories listed in `matrix.paths`, each contributing its `gems.rb`, or its `Gemfile` when it has no `gems.rb`, the order Bundler uses
+
+## Configuration
+
+Settings use `bundle config` or `BUNDLE_MATRIX__*` environment variables:
+
+| Setting | Default | Meaning |
+| --- | --- | --- |
+| `matrix.default_gemfile` | `Gemfile` | File name of the main gemfile in the project root. Fan-out starts only when the command runs on this file, e.g. `gems.rb` |
+| `matrix.paths` | none | Extra directories or globs to search for a `gems.rb` or `Gemfile`, separated by commas, e.g. `engines/*,apps/admin` |
+| `matrix.disabled` | `false` | Turn fan-out off |
+| `matrix.fail_fast` | `false` | Stop at the first failing gemfile |
+| `matrix.bundler_warnings` | `true` | Warn when a gemfile runs a different Bundler from the main Gemfile. Set it to `false` for projects that pin different Bundlers on purpose |
+
+```bash
+bundle config set matrix.paths "engines/*,apps/admin"
+```
+
+For a project whose main file is `gems.rb`, set the main gemfile name once, and run the command on `gems.rb`:
+
+```bash
+bundle config set matrix.default_gemfile gems.rb
+bundle install
+```
+
+To skip the matrix for a single run, set `BUNDLE_MATRIX__DISABLED` on that command:
+
+```bash
+BUNDLE_MATRIX__DISABLED=1 bundle install
+```
+
+`bundle config set matrix.disabled true` is the persistent version, and stays in effect until you change it back.
+
+## How each command is applied
+
+Flags are forwarded as typed, and Bundler's own option table decides what each flag means. The exceptions below are where a flag can't be applied to another gemfile as-is.
+
+- **`install`**: `--lockfile` and `--standalone` only apply to the main Gemfile, so they are not forwarded.
+- **`update <gems>`**: only the named gems that appear in that gemfile's lockfile are updated. A gemfile with none of them is skipped. `--group` is limited to groups it declares. If it has no lockfile yet, `install` is run to create one.
+- **`update --all`**, `--conservative`, `--patch`, `--minor`, `--major`, `--pre`, `--strict` and the rest: forwarded unchanged.
+- **`add <gems>`**: gems the gemfile already declares, including through `eval_gemfile`, are not added again. If every gem is already declared, `install` is run to re-lock the gemfile. A relative `--path` is rewritten so it resolves from that gemfile's directory.
+- `--gemfile` is never forwarded. The target is set through `BUNDLE_GEMFILE` instead.
+
+## Settings and Bundler versions
+
+Each gemfile is run the way `bundle` would run it on its own, with the project's settings:
+
+- The project's `.bundle/config` and the `BUNDLE_*` environment variables you set are passed on, so `frozen`, `without`, `jobs` and the rest apply to every gemfile. A relative `path`, `bin` or `cache_path` still resolves from the project root, so every gemfile shares the same `vendor/bundle`. A `.bundle/config` next to a secondary gemfile takes priority for that gemfile.
+- `gemfile` and `lockfile` are not passed on, because they name the main Gemfile's own files.
+- Each gemfile runs with the Bundler version in its own `BUNDLED WITH` line, and `install` installs that version first if it is missing. A `gem "bundler"` line in a gemfile that has no lockfile yet is not installed for you, so install that version yourself first. Bundler's `version` setting controls this: `bundle config set version system` keeps every gemfile on the running version, and `bundle config set version 4.0.23` pins one. `BUNDLER_VERSION` is not passed on, because it would hold every gemfile to one version.
+- When a gemfile runs with a different Bundler from the main Gemfile, a one-line warning names both versions, and the run ends by suggesting either `bundle update --bundler`, which updates Bundler in every lockfile, or `bundle config set matrix.bundler_warnings false`, which turns these warnings off when each gemfile should keep its own Bundler.
+
+## How it uses Bundler
+
+bundle_matrix needs Bundler 2.6.9 or newer, below 4.2 and its prereleases, and is tested against 2.6.9, 2.7.2, 4.0.24 and 4.1.0.beta3. The upper bound moves up once a new Bundler minor has been tested. Under any other Bundler the plugin still runs, but prints a one-line warning that it is untested there, with a link to the issue tracker.
+
+Fan-out starts from Bundler's documented plugin hook, `after-install-all`, and each gemfile runs in its own `bundle` process. Everything else uses Bundler classes that work today but are not a plugin API, so a new Bundler release could change them:
+
+- Thor's command and option tables (`Bundler::CLI`), which decide what each flag means and which command was run (`ArgvParser`, `Invocation`). Command names such as `ins` are resolved by calling Thor's protected `normalize_command_name` with `send`
+- `Bundler::Dsl` and `Bundler::LockfileParser`, which read each secondary gemfile and lockfile (`Planner`). `Bundler.definition` and `Bundler.locked_gems` only describe the main Gemfile, so they can't be used for the others.
+- The settings' storage levels, through `Bundler.settings` (`ProjectSettings`)
+
+## Limitations
+
+- `bundle check` is not supported. Bundler only calls plugin hooks around installation.
+- `bundle add --skip-install` never runs the hook, because no installation happens.
+- Flags that Bundler does not know about are forwarded as-is, and any value after them is treated as a gem name.
+
+## Development
+
+Run `bin/setup`, then `rake`. The default task runs the unit specs, the end-to-end specs, RuboCop, `rake rbs`, which runs `rbs validate` on the signatures in `sig/` with the Bundler stubs in `sig_stubs/`, and `rake steep`, which type checks `lib/` against those signatures. Run `rake e2e` on its own for the end-to-end specs, which run real `bundle` commands and take longer. Run `COVERAGE=true bundle exec rake spec` to also write a coverage report to `coverage/index.html`. That run fails below 90% line coverage or 80% branch coverage, and CI runs it this way.
+
+Run `bundle exec guard` to re-run the unit specs and RuboCop on every change. It also regenerates the docs when the files they are built from change.
+
+`docs/` is generated by Boondoc, so edit `README.md` and the code comments rather than `docs/`. To regenerate it by hand, run `bundle exec boondoc`
+
+To try a change against a real project, install from a local checkout with `bundle plugin install bundle_matrix --path /path/to/bundle_matrix` (the directory must contain `plugins.rb`).
+
+## Contributing
+
+Bug reports and pull requests are welcome. Send issues and pull requests to https://github.com/joe-sharp/bundle_matrix.
+
+Run `bundle exec rake` before you open a pull request. The Development section above explains what it runs.
+
+A bug report should include:
+
+- the Bundler version, from `bundle -v`
+- the command you ran, e.g. `bundle update rails --conservative`
+- your gemfile layout: which gemfiles exist, where they are, and any `matrix.*` settings
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/bundle_matrix/argv_parser.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "bundler/cli"
+
+module BundleMatrix
+  # Finds the command in argv the way Bundler does, then splits the tokens after it into
+  # options, gems and unknown switches, using the switch table Bundler itself uses for that command.
+  # Every touch of Bundler::CLI is in this class, so the rest of the plugin only sees command names and tokens.
+  class ArgvParser
+    Switch = Data.define(:name, :option, :negated)
+
+    # One switch Bundler accepts for a command; negated is true for its `--no-name` form
+    class Switch
+      def initialize(name:, option:, negated: false)
+        super
+      end
+    end
+
+    INSTALL_ALIASES = %w[install install_or_cli_help].freeze
+
+    # @return [Array(String, Array<String>)] the command Bundler would run (nil when unknown) and the tokens after it
+    def self.split_command(argv)
+      first, *rest = argv
+      return [resolve_command(first), rest] unless default_command_used?(first)
+
+      command = resolve_command(Bundler.settings[:default_cli_command] || "install")
+      # Bundler runs install for its deprecated install_or_cli_help alias too
+      [INSTALL_ALIASES.include?(command) ? "install" : command, argv]
+    end
+
+    # Bundler runs its default command when argv is empty or starts with a switch
+    # (`bundle`, `bundle --jobs=4`), and then every token is an argument. A mapped
+    # switch such as `-v` is still a command of its own. With default_cli_command unset,
+    # Bundler 4 still runs install here, with a notice that this will change. Its docs
+    # already name cli_help as the default, but the code does not, so this follows the code.
+    # The setting is read directly, because Bundler::CLI.default_command prints that notice again.
+    def self.default_command_used?(token)
+      token.nil? || (token.start_with?("-") && !Bundler::CLI.map.key?(token))
+    end
+    private_class_method :default_command_used?
+
+    # Thor has no public method for prefix lookup (`i`, `ins`, `a`, `u`), so this calls its protected
+    # normalize_command_name. The code already relies on Thor's tables, and calling the method keeps
+    # the result identical to Bundler's, where a copy could drift without anyone noticing.
+    def self.resolve_command(token)
+      return unless token
+
+      Bundler::CLI.send(:normalize_command_name, token)
+    rescue Bundler::Thor::AmbiguousTaskError
+      # Bundler rejects an ambiguous name before installing, so the hook never sees one. This is only a safeguard.
+      nil
+    end
+    private_class_method :resolve_command
+
+    # @return [Array(Array<Invocation::Option>, Array<String>, Array<String>)]
+    def self.call(command, tokens)
+      new(table_for(command)).call(tokens)
+    end
+
+    # Bundler's global options (--retry, --verbose, --no-color) apply to every command, so they are added to its own.
+    # Thor's tables are not a plugin API, so a Bundler release can change them; the Appraisals cover each version.
+    def self.table_for(command)
+      Bundler::CLI.class_options.merge(Bundler::CLI.commands.fetch(command).options)
+    end
+
+    def initialize(table)
+      @switches = switch_table(table)
+    end
+
+    def call(tokens)
+      switch_tokens, literal_gems = split_terminator(tokens)
+      options, gems, unknown = collect(switch_tokens.dup)
+      [options, gems + literal_gems, unknown]
+    end
+
+    private
+
+    def collect(rest)
+      options = []
+      gems = []
+      unknown = []
+
+      until rest.empty?
+        token = rest.shift
+        next gems << token unless switch?(token)
+
+        option = read_option(token, rest)
+        option ? options << option : unknown << token
+      end
+
+      [options, gems, unknown]
+    end
+
+    def switch_table(table)
+      switches = table.each_with_object({}) do |(name, option), lookup|
+        lookup["--#{name}"] = Switch.new(name: name, option: option)
+        option.aliases.each { |alias_name| lookup[alias_name] = Switch.new(name: name, option: option) }
+      end
+
+      table.each do |name, option|
+        next unless option.type == :boolean
+
+        switches["--no-#{name}"] ||= Switch.new(name: name, option: option, negated: true)
+      end
+
+      switches
+    end
+
+    def switch?(token)
+      token.start_with?("-") && token != "-"
+    end
+
+    # Everything after a bare `--` is a gem name, whatever it looks like
+    def split_terminator(tokens)
+      index = tokens.index("--")
+      return [tokens, []] unless index
+
+      [tokens.take(index), tokens.drop(index + 1)]
+    end
+
+    # Consumes the values that belong to a switch from the front of rest
+    def read_option(token, rest)
+      key, inline = split_switch(token)
+      switch = @switches[key]
+      return unless switch
+
+      values, used = values_for(switch.option, inline, rest)
+      Invocation::Option.new(
+        name: switch.name, tokens: [token, *rest.shift(used)], values: values, negated: switch.negated
+      )
+    end
+
+    # `--name=value`, and `-jvalue` for single-dash switches
+    def split_switch(token)
+      key, separator, value = token.partition("=")
+      value = nil if separator.empty?
+      return [key, value] if @switches.key?(key) || !token.match?(/\A-[^-]/)
+
+      short = token[0, 2].to_s
+      @switches.key?(short) ? [short, token[2..]] : [key, value]
+    end
+
+    # @return [Array(Array<String>, Integer)] the values and how many following tokens they used
+    def values_for(option, inline, rest)
+      return array_values(rest, [inline]) if option.type == :array && inline
+      return [[inline], 0] if inline
+      return [[], 0] if option.type == :boolean
+      return array_values(rest, []) if option.type == :array
+      return [[], 0] if rest.empty? || (option.lazy_default && switch?(rest.first))
+
+      [[rest.first], 1]
+    end
+
+    # An array option takes every value up to the next switch, after any value given inline with `=`
+    def array_values(rest, leading)
+      values = rest.take_while { |token| !switch?(token) }
+      [leading + values, values.size]
+    end
+  end
+end

data/lib/bundle_matrix/bundle

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# The same as RubyGems' `bundle` binstub. Loading Bundler through RubyGems picks
+# the Bundler version for each gemfile from BUNDLER_VERSION, the `version`
+# setting or its lockfile's BUNDLED WITH line, as running `bundle` would.
+# Kept in lib/ so it is not installed as an executable of this gem.
+require "rubygems"
+
+if Gem.respond_to?(:activate_and_load_bin_path)
+  Gem.activate_and_load_bin_path("bundler", "bundle", ">= 0.a")
+else
+  load Gem.activate_bin_path("bundler", "bundle", ">= 0.a")
+end

data/lib/bundle_matrix/config.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module BundleMatrix
+  # Reads the matrix.* settings, from `bundle config` or BUNDLE_MATRIX__* env vars.
+  class Config
+    TRUE_VALUES = %w[true 1 yes].freeze
+    FALSE_VALUES = %w[false 0 no].freeze
+    DEFAULT_GEMFILE = "Gemfile"
+
+    # Extra directories (or globs) to search for a Gemfile, e.g. "engines/*,apps/admin".
+    def paths
+      Bundler.settings["matrix.paths"].to_s.split(",").map(&:strip).reject(&:empty?)
+    end
+
+    # The file name of the main gemfile in the project root, e.g. "gems.rb". Fan-out starts from it.
+    def default_gemfile
+      value = Bundler.settings["matrix.default_gemfile"].to_s.strip
+      value.empty? ? DEFAULT_GEMFILE : value
+    end
+
+    def disabled?
+      truthy?("matrix.disabled")
+    end
+
+    def fail_fast?
+      truthy?("matrix.fail_fast")
+    end
+
+    # Warn when a gemfile runs a different Bundler from the main one; on unless set to false, 0 or no
+    def bundler_warnings?
+      !FALSE_VALUES.include?(Bundler.settings["matrix.bundler_warnings"].to_s.downcase)
+    end
+
+    private
+
+    def truthy?(key)
+      TRUE_VALUES.include?(Bundler.settings[key].to_s.downcase)
+    end
+  end
+end

data/lib/bundle_matrix/discovery.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module BundleMatrix
+  # Finds the secondary gemfiles that follow the main Gemfile.
+  class Discovery
+    # The gemfile a matrix.paths directory contributes, in Bundler's order
+    DIRECTORY_GEMFILES = %w[gems.rb Gemfile].freeze
+
+    # default_gemfile is the main gemfile's file name in root; it is never returned, whatever its name
+    def initialize(root, paths, default_gemfile:)
+      @root = Pathname(root).expand_path
+      @paths = paths
+      @default_gemfile = default_gemfile
+    end
+
+    # @return [Array<Pathname>] sorted, unique, excluding the main gemfile
+    def gemfiles
+      found = glob("*.gemfile") + glob("gemfiles/*.gemfile") + configured_gemfiles
+
+      found.map(&:expand_path).uniq.sort.reject { |path| main_gemfile?(path) }
+    end
+
+    private
+
+    def default_gemfile_path
+      @root.join(@default_gemfile)
+    end
+
+    # Compares files, not paths, so a symlink to the main gemfile is excluded too
+    def main_gemfile?(path)
+      File.identical?(path, default_gemfile_path)
+    end
+
+    # Patterns are relative to the root, so glob characters in the project's own path are not special
+    def glob(pattern)
+      Dir.glob(pattern, base: @root.to_s).map { |match| @root.join(match) }
+    end
+
+    def configured_gemfiles
+      @paths.flat_map do |entry|
+        found = glob(entry).flat_map { |match| gemfiles_at(match) }
+        Bundler.ui.warn("bundle_matrix: matrix.paths entry #{entry.inspect} matched no Gemfile") if found.empty?
+        found
+      end
+    end
+
+    def gemfiles_at(path)
+      if path.directory?
+        gemfile = DIRECTORY_GEMFILES.map { |name| path.join(name) }.find(&:file?)
+        gemfile ? [gemfile] : []
+      elsif path.file? && path.basename.to_s.match?(/(gemfile|\Agems\.rb)\z/i)
+        [path]
+      else
+        []
+      end
+    end
+  end
+end

data/lib/bundle_matrix/hook.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module BundleMatrix
+  # Called by Bundler after `install`, `update` or `add` has finished.
+  module Hook
+    ISSUES_URL = "https://github.com/joe-sharp/bundle_matrix/issues"
+
+    # Checked before parsing, so a disabled plugin or a child run never depends on how Bundler's CLI parses
+    def self.call(argv = ARGV)
+      return if secondary_run?
+
+      config = Config.new
+      return if config.disabled?
+
+      invocation = Invocation.parse(argv)
+      return unless invocation && default_gemfile?(config)
+
+      root = Bundler.root
+      gemfiles = Discovery.new(root, config.paths, default_gemfile: config.default_gemfile).gemfiles
+      return if gemfiles.empty?
+
+      warn_untested_bundler
+
+      runner = Runner.new(root, fail_fast: config.fail_fast?, bundler_warnings: config.bundler_warnings?)
+      runner.run(plans_for(invocation, gemfiles, root))
+    end
+
+    def self.plans_for(invocation, gemfiles, root)
+      gemfiles.to_h do |gemfile|
+        [gemfile, Planner.new(invocation, gemfile, root).plan]
+      end
+    end
+
+    # Fan-out still runs under an untested Bundler, but asks to hear about anything that breaks
+    def self.warn_untested_bundler
+      return if TESTED_BUNDLER.satisfied_by?(Gem::Version.new(Bundler::VERSION))
+
+      Bundler.ui.warn(
+        "bundle_matrix: not tested with Bundler #{Bundler::VERSION}; " \
+        "if anything goes wrong, please open an issue at #{ISSUES_URL}"
+      )
+    end
+
+    def self.default_gemfile?(config)
+      Bundler.default_gemfile.basename.to_s == config.default_gemfile
+    end
+
+    # Child runs set this, so they never fan out again
+    def self.secondary_run?
+      !ENV["BUNDLE_MATRIX_ACTIVE"].to_s.empty?
+    end
+    private_class_method :default_gemfile?, :secondary_run?, :plans_for, :warn_untested_bundler
+    private_constant :ISSUES_URL
+  end
+end

data/lib/bundle_matrix/invocation.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module BundleMatrix
+  # A parsed `bundle install|update|add` command line.
+  #
+  # Option names, aliases and value types come from Bundler's own Thor tables,
+  # so every flag Bundler accepts is understood, and the raw tokens are kept
+  # so they can be forwarded exactly as the user typed them.
+  class Invocation < Data.define(:command, :options, :gems, :unknown)
+    COMMANDS = %w[install update add].freeze
+
+    Option = Data.define(:name, :tokens, :values, :negated)
+
+    # negated is true for a `--no-name` switch, which unsets the option rather than setting it
+    class Option
+      def initialize(name:, tokens:, values:, negated: false)
+        super
+      end
+    end
+
+    # @return [Invocation, nil] nil when the command is not one we fan out
+    def self.parse(argv)
+      command, tokens = ArgvParser.split_command(argv)
+      return unless command && COMMANDS.include?(command)
+
+      options, gems, unknown = ArgvParser.call(command, tokens)
+      new(command: command, options: options, gems: gems, unknown: unknown)
+    end
+
+    # `--no-name` does not count as setting the option
+    def option?(name)
+      opt = option(name)
+      !opt.nil? && !opt.negated
+    end
+
+    # Bundler keeps the last copy of a repeated option, so that is the one that counts
+    def option(name)
+      options.reverse_each.find { |opt| opt.name == name }
+    end
+
+    def values(name)
+      option(name)&.values || []
+    end
+
+    def with_gems(new_gems)
+      with(gems: new_gems)
+    end
+
+    def without(*names)
+      with(options: options.reject { |opt| names.include?(opt.name) })
+    end
+
+    # Replaces an option's values, dropping the option when none are left.
+    def replace_values(name, new_values)
+      rest = without(name)
+      return rest if new_values.empty?
+
+      added = Option.new(name: name, tokens: ["--#{name}", *new_values], values: new_values)
+      rest.with(options: rest.options + [added])
+    end
+
+    # The same flags, re-targeted at another command. Only options that command
+    # understands are kept, and the gems are replaced.
+    def as(target, gems: [])
+      table = ArgvParser.table_for(target)
+      with(command: target, options: options.select { |opt| table.key?(opt.name) }, gems: gems, unknown: [])
+    end
+
+    def to_argv
+      flags = [*options.flat_map(&:tokens), *unknown]
+      return [command, *gems, *flags] unless gems.any? { |gem| gem.start_with?("-") }
+
+      # A gem that starts with a dash would be read as a switch, so the gems go after a `--` that ends the switches
+      [command, *flags, "--", *gems]
+    end
+  end
+end

data/lib/bundle_matrix/planner.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module BundleMatrix
+  # Decides what to run against one secondary gemfile, given the command the
+  # user ran on the main Gemfile.
+  class Planner
+    Plan = Data.define(:invocation, :notes, :error, :locked_bundler)
+
+    # invocation is nil when the gemfile should be skipped; notes explain why; error is set when planning failed;
+    # locked_bundler is the Bundler named in this gemfile's lockfile, set on every plan that runs a command
+    class Plan
+      def initialize(invocation:, notes:, error: nil, locked_bundler: nil)
+        super
+      end
+
+      def failed?
+        !error.nil?
+      end
+
+      def skipped?
+        invocation.nil? && error.nil?
+      end
+    end
+
+    # Install flags that only make sense for the main Gemfile, or that Bundler no longer accepts
+    MAIN_ONLY_INSTALL_OPTIONS = %w[lockfile standalone path].freeze
+
+    # Options whose values are paths. A child resolves a relative one from its own gemfile's directory,
+    # so each is rewritten to be relative to that directory instead
+    PATH_OPTIONS = %w[binstubs path target-rbconfig].freeze
+
+    def initialize(invocation, gemfile, root)
+      @invocation = invocation.without("gemfile")
+      @gemfile = SecondaryGemfile.new(gemfile)
+      @root = Pathname(root).expand_path
+    end
+
+    def plan
+      case @invocation.command
+      when "install" then install_plan(@invocation)
+      when "update" then update_plan
+      when "add" then add_plan
+      else raise ArgumentError, "unknown command #{@invocation.command}"
+      end
+    rescue => e
+      # One gemfile that can't be read must not stop the others, so its error is reported as its own failure
+      Plan.new(invocation: nil, notes: [], error: e.message)
+    end
+
+    private
+
+    def install_plan(invocation, notes = [])
+      dropped = MAIN_ONLY_INSTALL_OPTIONS.select { |name| invocation.option?(name) }
+      notes += dropped.map { |name| dropped_note(name) }
+      run(invocation.without(*MAIN_ONLY_INSTALL_OPTIONS), notes)
+    end
+
+    # Bundler 2 saves --path to .bundle/config, which ProjectSettings passes on, so it still reaches other gemfiles
+    def dropped_note(name)
+      return "--#{name} is not forwarded to other gemfiles" unless name == "path"
+
+      "--path is not forwarded to other gemfiles, but a path Bundler saved in .bundle/config " \
+        "reaches them as BUNDLE_PATH"
+    end
+
+    def update_plan
+      return run(@invocation) if full_update?(@invocation)
+      return install_instead("no lockfile yet") unless @gemfile.locked?
+
+      narrow_update(@invocation)
+    end
+
+    # Keeps only the named gems and groups that this gemfile's lockfile or dependencies know about
+    def narrow_update(invocation)
+      gems = invocation.gems & @gemfile.lock_names
+      # --source names gems too, so it is narrowed to the lockfile the same way
+      sources = invocation.values("source") & @gemfile.lock_names
+      groups = narrow_groups(invocation)
+      if unmatched?(invocation, [*gems, *sources, *groups])
+        return skip("none of #{requested(invocation).join(", ")} are in this gemfile")
+      end
+
+      run(invocation.with_gems(gems).replace_values("source", sources).replace_values("group", groups))
+    end
+
+    # Declared groups are only read when --group was given, because reading them evaluates the whole gemfile
+    def narrow_groups(invocation)
+      requested_groups = invocation.values("group")
+      return [] if requested_groups.empty?
+
+      requested_groups & @gemfile.declared_groups
+    end
+
+    # Named gems or groups were given, but none of them apply to this gemfile
+    def unmatched?(invocation, matched)
+      requested(invocation).any? && matched.empty? &&
+        !invocation.option?("ruby") && !invocation.option?("bundler")
+    end
+
+    def requested(invocation)
+      invocation.gems + invocation.values("source") + invocation.values("group")
+    end
+
+    def add_plan
+      declared = @gemfile.declared_names
+      already = @invocation.gems & declared
+      new_gems = @invocation.gems - declared
+      notes = already.map { |name| "#{name} is already declared, not added again" }
+
+      if new_gems.empty?
+        return install_plan(@invocation.as("install"), notes + ["gems already declared, re-locking with install"])
+      end
+
+      run(@invocation.with_gems(new_gems), notes)
+    end
+
+    def full_update?(invocation)
+      return true if invocation.option?("all")
+
+      invocation.gems.empty? && invocation.values("source").empty? && invocation.values("group").empty? &&
+        !invocation.option?("ruby") && !invocation.option?("bundler")
+    end
+
+    def install_instead(reason)
+      install_plan(@invocation.as("install"), ["#{reason}, running install to create it"])
+    end
+
+    # A relative path is relative to the root in the main run, so it has to be rewritten to be relative to
+    # this gemfile's directory, where the child runs.
+    def rewrite_paths(invocation)
+      PATH_OPTIONS.reduce(invocation) do |rewritten, name|
+        values = rewritten.values(name)
+        next rewritten if values.empty?
+
+        rewritten.replace_values(name, values.map { |value| relative_to_gemfile(value) })
+      end
+    end
+
+    def relative_to_gemfile(value)
+      absolute = File.expand_path(value, @root)
+      Bundler::SharedHelpers.relative_path_to(absolute, from: @gemfile.path.dirname)
+    end
+
+    def run(invocation, notes = [])
+      Plan.new(invocation: rewrite_paths(invocation), notes: notes, locked_bundler: @gemfile.bundler_version)
+    end
+
+    def skip(reason)
+      Plan.new(invocation: nil, notes: ["skipped, #{reason}"])
+    end
+  end
+end

data/lib/bundle_matrix/project_settings.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module BundleMatrix
+  # The project's settings that a child run would otherwise lose: its .bundle/config,
+  # which a child doesn't read because it looks in its own gemfile's directory, and
+  # the BUNDLE_* variables the user set, which Bundler.with_unbundled_env strips.
+  # They are passed on as BUNDLE_* variables, so a gemfile's own .bundle/config still wins.
+  # Settings#all and #locations are not a plugin API, so a Bundler release can change them.
+  module ProjectSettings
+    # Settings that point at the main Gemfile's own files; each child sets these itself
+    MAIN_ONLY = %w[gemfile lockfile app_config bin_path].freeze
+
+    # Settings holding a path relative to the project root, which a child would
+    # otherwise resolve from its own directory
+    PATHS = %w[path bin cache_path].freeze
+
+    # @return [Hash{String => String}] BUNDLE_* variables for a child run
+    def self.env(root)
+      settings = Bundler.settings
+      user_env = Bundler.original_env
+
+      (settings.all - MAIN_ONLY).each_with_object({}) do |name, env|
+        key = settings.key_for(name)
+        # Bundler gives .bundle/config priority over the environment
+        value = settings.locations(name)[:local] || user_env[key]
+        next if value.nil?
+
+        env[key] = PATHS.include?(name) ? File.expand_path(value.to_s, root) : value.to_s
+      end
+    end
+  end
+end

data/lib/bundle_matrix/runner.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module BundleMatrix
+  # Runs each planned command in a separate `bundle` process. Bundler keeps
+  # global state, so the secondary gemfiles can't be run in this process.
+  class Runner
+    # Launched like a plain `bundle`, so RubyGems and Bundler pick each gemfile's Bundler version.
+    # __dir__ is only nil inside eval, which Steep can't rule out.
+    BUNDLE = File.expand_path("bundle", __dir__) # steep:ignore
+
+    # bundler_warnings is false when the matrix.bundler_warnings setting turns off the Bundler version warnings
+    def initialize(root, fail_fast: false, bundler_warnings: true)
+      @root = Pathname(root).expand_path
+      @fail_fast = fail_fast
+      @bundler_warnings = bundler_warnings
+    end
+
+    # @param plans [Hash{Pathname => Planner::Plan}]
+    def run(plans)
+      failures = []
+      other_bundler = false
+
+      plans.each do |gemfile, plan|
+        label = gemfile.relative_path_from(@root)
+        # Only a plan that runs carries a locked_bundler, so a skipped or unplannable one never sets this
+        version = other_bundler_for(plan)
+        other_bundler ||= version
+        next if plan_passed?(gemfile, label, plan, version)
+
+        failures << label
+        break if @fail_fast
+      end
+
+      suggest_bundler_update if other_bundler
+      return if failures.empty?
+
+      raise Error, "bundle_matrix: failed for #{failures.join(", ")}"
+    end
+
+    private
+
+    # @return [Boolean] true when the plan was skipped or its command succeeded
+    def plan_passed?(gemfile, label, plan, other_bundler)
+      if plan.failed?
+        report_unplanned(label, plan.error)
+        return false
+      end
+
+      plan.notes.each { |note| say(label, note) }
+      # A plan that neither failed nor has a command was skipped
+      invocation = plan.invocation
+      return true unless invocation
+
+      Bundler.ui.info("== bundle_matrix: #{label} -> bundle #{invocation.to_argv.join(" ")}")
+      warn_other_bundler(label, other_bundler)
+      success?(gemfile, invocation)
+    end
+
+    def say(label, message)
+      Bundler.ui.info("== bundle_matrix: #{label}: #{message}")
+    end
+
+    # A gemfile that could not be planned is a failure, and the other gemfiles still run
+    def report_unplanned(label, error)
+      Bundler.ui.error("== bundle_matrix: #{label}: could not plan: #{error}")
+    end
+
+    # The Bundler a plan's lockfile switches to, when that is worth a warning; nil otherwise.
+    # A child switches only when the `version` setting is lockfile, the default. With `system` or a pinned
+    # version, every gemfile runs the same Bundler as the main one.
+    def other_bundler_for(plan)
+      version = plan.locked_bundler
+      return unless version && @bundler_warnings && [nil, "lockfile"].include?(Bundler.settings[:version])
+
+      version unless version == Gem::Version.new(Bundler::VERSION)
+    end
+
+    def warn_other_bundler(label, version)
+      return unless version
+
+      Bundler.ui.warn("bundle_matrix: #{label} uses Bundler #{version}, the main Gemfile uses #{Bundler::VERSION}")
+    end
+
+    def suggest_bundler_update
+      Bundler.ui.warn(
+        "bundle_matrix: run `bundle update --bundler` to update Bundler in every lockfile, " \
+        "or `bundle config set matrix.bundler_warnings false` to silence these warnings"
+      )
+    end
+
+    def success?(gemfile, invocation)
+      Bundler.unbundled_system(
+        child_env(gemfile), Gem.ruby, BUNDLE, *invocation.to_argv, chdir: gemfile.dirname.to_s
+      ) == true
+    end
+
+    # BUNDLER_VERSION would hold every gemfile to one version, and it is left set in this
+    # process when Bundler restarted itself for the main lockfile, so it is cleared.
+    def child_env(gemfile)
+      project_env.merge(
+        "BUNDLE_GEMFILE" => gemfile.to_s,
+        "BUNDLE_MATRIX_ACTIVE" => "1",
+        "BUNDLER_VERSION" => nil
+      )
+    end
+
+    def project_env
+      @project_env ||= ProjectSettings.env(@root)
+    end
+  end
+end

data/lib/bundle_matrix/secondary_gemfile.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module BundleMatrix
+  # A secondary gemfile, and what its lockfile and declarations say about it.
+  class SecondaryGemfile
+    attr_reader :path
+
+    def initialize(path)
+      @path = Pathname(path).expand_path
+    end
+
+    # Bundler locks a gems.rb in gems.locked, and every other gemfile in <gemfile>.lock
+    def lockfile
+      return path.sub_ext(".locked") if path.basename.to_s == "gems.rb"
+
+      Pathname("#{path}.lock")
+    end
+
+    def locked?
+      lockfile.file?
+    end
+
+    # The Bundler this gemfile's lockfile names in BUNDLED WITH, nil without a lockfile
+    def bundler_version
+      locked&.bundler_version
+    end
+
+    # Empty without a lockfile
+    def lock_names
+      @lock_names ||= (locked&.specs || []).map(&:name).uniq
+    end
+
+    def declared_names
+      declared.map(&:name)
+    end
+
+    def declared_groups
+      declared.flat_map(&:groups).map(&:to_s).uniq
+    end
+
+    private
+
+    # nil when this gemfile has no lockfile yet. Bundler.locked_gems only reads the main Gemfile's lockfile,
+    # so LockfileParser, which is not a plugin API, reads this one.
+    def locked
+      return @locked if defined?(@locked)
+
+      @locked = locked? ? Bundler::LockfileParser.new(lockfile.read) : nil
+    end
+
+    # Dependencies declared by this gemfile, including those pulled in by eval_gemfile.
+    # Bundler.definition only describes the main Gemfile, so Dsl, which is not a plugin API, evaluates this one.
+    def declared
+      @declared ||= Bundler::Dsl.new.tap { |dsl| dsl.eval_gemfile(path) }.dependencies
+    end
+  end
+end

data/lib/bundle_matrix/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module BundleMatrix
+  VERSION = "0.1.0"
+
+  # The oldest Bundler the plugin runs under. The gemspec requires it, and nothing newer is refused.
+  # It is where Bundler::SharedHelpers.relative_path_to, which Planner uses, first appeared.
+  MIN_BUNDLER = "2.6.9"
+
+  # The Bundler versions the Appraisals test. The hook warns outside this range, not the gemspec.
+  # The `.a` keeps 4.2 prereleases out too; raise it once a new Bundler minor has been tested.
+  TESTED_BUNDLER = Gem::Requirement.new(">= #{MIN_BUNDLER}", "< 4.2.a")
+end

data/lib/bundle_matrix.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "bundler"
+require_relative "bundle_matrix/version"
+require_relative "bundle_matrix/config"
+require_relative "bundle_matrix/project_settings"
+require_relative "bundle_matrix/discovery"
+require_relative "bundle_matrix/argv_parser"
+require_relative "bundle_matrix/invocation"
+require_relative "bundle_matrix/secondary_gemfile"
+require_relative "bundle_matrix/planner"
+require_relative "bundle_matrix/runner"
+require_relative "bundle_matrix/hook"
+
+# A Bundler plugin that repeats `install`, `update` and `add` against every secondary gemfile in a project.
+module BundleMatrix
+  # Raised after the matrix run, when one or more secondary gemfiles failed
+  class Error < Bundler::BundlerError
+    status_code(1)
+  end
+end

data/plugins.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "lib/bundle_matrix"
+
+Bundler::Plugin::API.hook(Bundler::Plugin::Events::GEM_AFTER_INSTALL_ALL) do |_dependencies|
+  BundleMatrix::Hook.call
+end

data/sig/bundle_matrix.rbs

@@ -0,0 +1,214 @@
+module BundleMatrix
+  VERSION: String
+  MIN_BUNDLER: String
+  TESTED_BUNDLER: Gem::Requirement
+
+  class Error < Bundler::BundlerError
+    def status_code: () -> Integer
+  end
+
+  class ArgvParser
+    class Switch < Data
+      attr_reader name: String
+      attr_reader option: Bundler::Thor::Option
+      attr_reader negated: bool
+
+      def self.new: (name: String, option: Bundler::Thor::Option, ?negated: bool) -> instance
+      def initialize: (name: String, option: Bundler::Thor::Option, ?negated: bool) -> void
+    end
+
+    INSTALL_ALIASES: Array[String]
+
+    @switches: Hash[String, Switch]
+
+    def self.split_command: (Array[String] argv) -> [String?, Array[String]]
+    private def self.default_command_used?: (String? token) -> bool
+    private def self.resolve_command: (String? token) -> String?
+    def self.call: (String command, Array[String] tokens) -> [Array[Invocation::Option], Array[String], Array[String]]
+    def self.table_for: (String command) -> Hash[String, Bundler::Thor::Option]
+
+    def initialize: (Hash[String, Bundler::Thor::Option] table) -> void
+    def call: (Array[String] tokens) -> [Array[Invocation::Option], Array[String], Array[String]]
+
+    private
+
+    def collect: (Array[String] rest) -> [Array[Invocation::Option], Array[String], Array[String]]
+    def switch_table: (Hash[String, Bundler::Thor::Option] table) -> Hash[String, Switch]
+    def switch?: (String token) -> bool
+    def split_terminator: (Array[String] tokens) -> [Array[String], Array[String]]
+    def read_option: (String token, Array[String] rest) -> Invocation::Option?
+    def split_switch: (String token) -> [String, String?]
+    def values_for: (Bundler::Thor::Option option, String? inline, Array[String] rest) -> [Array[String], Integer]
+    def array_values: (Array[String] rest, Array[String] leading) -> [Array[String], Integer]
+  end
+
+  class Config
+    TRUE_VALUES: Array[String]
+    FALSE_VALUES: Array[String]
+    DEFAULT_GEMFILE: String
+
+    def paths: () -> Array[String]
+    def default_gemfile: () -> String
+    def disabled?: () -> bool
+    def fail_fast?: () -> bool
+    def bundler_warnings?: () -> bool
+
+    private
+
+    def truthy?: (String key) -> bool
+  end
+
+  class Discovery
+    DIRECTORY_GEMFILES: Array[String]
+
+    @root: Pathname
+    @paths: Array[String]
+    @default_gemfile: String
+
+    def initialize: (Pathname | String root, Array[String] paths, default_gemfile: String) -> void
+    def gemfiles: () -> Array[Pathname]
+
+    private
+
+    def default_gemfile_path: () -> Pathname
+    def main_gemfile?: (Pathname path) -> bool
+    def glob: (String pattern) -> Array[Pathname]
+    def configured_gemfiles: () -> Array[Pathname]
+    def gemfiles_at: (Pathname path) -> Array[Pathname]
+  end
+
+  class Invocation < Data
+    COMMANDS: Array[String]
+
+    class Option < Data
+      attr_reader name: String
+      attr_reader tokens: Array[String]
+      attr_reader values: Array[String]
+      attr_reader negated: bool
+
+      def self.new: (name: String, tokens: Array[String], values: Array[String], ?negated: bool) -> instance
+      def initialize: (name: String, tokens: Array[String], values: Array[String], ?negated: bool) -> void
+    end
+
+    attr_reader command: String
+    attr_reader options: Array[Option]
+    attr_reader gems: Array[String]
+    attr_reader unknown: Array[String]
+
+    def self.new: (command: String, options: Array[Option], gems: Array[String], unknown: Array[String]) -> instance
+    def self.parse: (Array[String] argv) -> Invocation?
+
+    def with: (?command: String, ?options: Array[Option], ?gems: Array[String], ?unknown: Array[String]) -> Invocation
+    def option?: (String name) -> bool
+    def option: (String name) -> Option?
+    def values: (String name) -> Array[String]
+    def with_gems: (Array[String] new_gems) -> Invocation
+    def without: (*String names) -> Invocation
+    def replace_values: (String name, Array[String] new_values) -> Invocation
+    def as: (String target, ?gems: Array[String]) -> Invocation
+    def to_argv: () -> Array[String]
+  end
+
+  class SecondaryGemfile
+    @locked: Bundler::LockfileParser?
+    @lock_names: Array[String]?
+    @declared: Array[Bundler::Dependency]?
+
+    attr_reader path: Pathname
+
+    def initialize: (Pathname | String path) -> void
+    def lockfile: () -> Pathname
+    def locked?: () -> bool
+    def bundler_version: () -> Gem::Version?
+    def lock_names: () -> Array[String]
+    def declared_names: () -> Array[String]
+    def declared_groups: () -> Array[String]
+
+    private
+
+    def locked: () -> Bundler::LockfileParser?
+    def declared: () -> Array[Bundler::Dependency]
+  end
+
+  class Planner
+    class Plan < Data
+      attr_reader invocation: Invocation?
+      attr_reader notes: Array[String]
+      attr_reader error: String?
+      attr_reader locked_bundler: Gem::Version?
+
+      def self.new: (invocation: Invocation?, notes: Array[String], ?error: String?, ?locked_bundler: Gem::Version?) -> instance
+      def initialize: (invocation: Invocation?, notes: Array[String], ?error: String?, ?locked_bundler: Gem::Version?) -> void
+      def failed?: () -> bool
+      def skipped?: () -> bool
+    end
+
+    MAIN_ONLY_INSTALL_OPTIONS: Array[String]
+    PATH_OPTIONS: Array[String]
+
+    @invocation: Invocation
+    @gemfile: SecondaryGemfile
+    @root: Pathname
+
+    def initialize: (Invocation invocation, Pathname | String gemfile, Pathname | String root) -> void
+    def plan: () -> Plan
+
+    private
+
+    def install_plan: (Invocation invocation, ?Array[String] notes) -> Plan
+    def dropped_note: (String name) -> String
+    def update_plan: () -> Plan
+    def narrow_update: (Invocation invocation) -> Plan
+    def narrow_groups: (Invocation invocation) -> Array[String]
+    def unmatched?: (Invocation invocation, Array[String] matched) -> bool
+    def requested: (Invocation invocation) -> Array[String]
+    def add_plan: () -> Plan
+    def full_update?: (Invocation invocation) -> bool
+    def install_instead: (String reason) -> Plan
+    def rewrite_paths: (Invocation invocation) -> Invocation
+    def relative_to_gemfile: (String value) -> String
+    def run: (Invocation invocation, ?Array[String] notes) -> Plan
+    def skip: (String reason) -> Plan
+  end
+
+  module ProjectSettings
+    MAIN_ONLY: Array[String]
+    PATHS: Array[String]
+
+    def self.env: (Pathname root) -> Hash[String, String]
+  end
+
+  class Runner
+    BUNDLE: String
+
+    @root: Pathname
+    @fail_fast: bool
+    @bundler_warnings: bool
+    @project_env: Hash[String, String]?
+
+    def initialize: (Pathname | String root, ?fail_fast: bool, ?bundler_warnings: bool) -> void
+    def run: (Hash[Pathname, Planner::Plan] plans) -> void
+
+    private
+
+    def plan_passed?: (Pathname gemfile, Pathname label, Planner::Plan plan, Gem::Version? other_bundler) -> bool
+    def say: (Pathname label, String message) -> void
+    def report_unplanned: (Pathname label, String? error) -> void
+    def other_bundler_for: (Planner::Plan plan) -> Gem::Version?
+    def warn_other_bundler: (Pathname label, Gem::Version? version) -> void
+    def suggest_bundler_update: () -> void
+    def success?: (Pathname gemfile, Invocation invocation) -> bool
+    def child_env: (Pathname gemfile) -> Hash[String, String?]
+    def project_env: () -> Hash[String, String]
+  end
+
+  module Hook
+    ISSUES_URL: String
+
+    def self.call: (?Array[String] argv) -> void
+    private def self.plans_for: (Invocation invocation, Array[Pathname] gemfiles, Pathname root) -> Hash[Pathname, Planner::Plan]
+    private def self.warn_untested_bundler: () -> void
+    private def self.default_gemfile?: (Config config) -> bool
+    private def self.secondary_run?: () -> bool
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: bundle_matrix
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joe Sharp
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.9
+description: A Bundler plugin. After install, update or add on the main Gemfile, it
+  replays the same command, with the same flags, against *.gemfile files in the project
+  root and gemfiles/, and any extra directories configured with matrix.paths.
+email:
+- joesharp13@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/bundle_matrix.rb
+- lib/bundle_matrix/argv_parser.rb
+- lib/bundle_matrix/bundle
+- lib/bundle_matrix/config.rb
+- lib/bundle_matrix/discovery.rb
+- lib/bundle_matrix/hook.rb
+- lib/bundle_matrix/invocation.rb
+- lib/bundle_matrix/planner.rb
+- lib/bundle_matrix/project_settings.rb
+- lib/bundle_matrix/runner.rb
+- lib/bundle_matrix/secondary_gemfile.rb
+- lib/bundle_matrix/version.rb
+- plugins.rb
+- sig/bundle_matrix.rbs
+homepage: https://github.com/joe-sharp/bundle_matrix
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/joe-sharp/bundle_matrix
+  source_code_uri: https://github.com/joe-sharp/bundle_matrix/tree/v0.1.0
+  bug_tracker_uri: https://github.com/joe-sharp/bundle_matrix/issues
+  changelog_uri: https://github.com/joe-sharp/bundle_matrix/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Runs bundle install, update and add against every secondary gemfile too.
+test_files: []