binpacker 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 86455b4d4ae7992aebada5dc2c22a24f5703b5ac89d36796cdc448492d79ec17
+  data.tar.gz: ffa497df54aaa41919e82230997fc6e46f303328bbd0f37ed95607a14bd9d090
+SHA512:
+  metadata.gz: c97dc45f7a65bb202498407b08bd41ebe9d096331150b0319eca1caee21fd7213238a94198b174b182e08bf06421a0dbc0ef0bff4ffdd7056214e3958ad03b83
+  data.tar.gz: e67e482ec9be17d650405c589857465444bdc1084aeeec9e81f69f0eceb8652a1ee4d0ae0baf45f2744f44801f392657d742e773f9c6ad69f0cf8dc31aeaaac8

data/LICENSE

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

data/exe/binpacker

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "binpacker"
+require "binpacker/cli"
+
+Binpacker::CLI.start(ARGV)

data/exe/binpacker-worker

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require "tempfile"
+
+def run_rspec(files, wid, rspec_args)
+  outfile = Tempfile.new("binpacker-rspec-out")
+  outfile.close
+  cmd = [
+    "rspec",
+    "--format", "json", "--out", outfile.path,
+    "--format", "progress", "--out", $stderr.fileno.to_s,
+    *rspec_args,
+    *files
+  ]
+  success = system(*cmd)
+
+  data = (File.exist?(outfile.path) && File.size(outfile.path) > 0) ? JSON.parse(File.read(outfile.path)) : {}
+  examples = data["examples"] || []
+  summary = data["summary"] || {}
+
+  results = examples.map do |ex|
+    { file: ex["file_path"], name: ex["full_description"] || ex["description"], time: ex["run_time"] || 0.0 }
+  end
+
+  outfile.unlink
+  [$?.exitstatus || 1, results, examples.size, (summary["failure_count"] || 0) == 0 ? examples.size : examples.size - summary["failure_count"]]
+end
+
+def run_minitest(files, wid, _args)
+  results = []
+  exit_code = 0
+  files.each do |file|
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    s = system("ruby", "-Ilib:test", file, exception: false)
+    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+    results << { file: file, name: file, time: elapsed }
+    exit_code = s.exitstatus unless s.success?
+  end
+  [exit_code, results, results.size, exit_code == 0 ? results.size : 0]
+end
+
+options = { runner: "rspec", id: 0 }
+rspec_args = []
+OptionParser.new do |opts|
+  opts.on("--runner RUNNER", "rspec or minitest") { |v| options[:runner] = v }
+  opts.on("--id ID", "Worker ID") { |v| options[:id] = v.to_i }
+  opts.on("--rspec-arg ARG", "Pass-through to rspec") { |v| rspec_args << v }
+end.parse!
+
+wid = options[:id]
+$stderr.puts "[worker-#{wid}] #{options[:runner]} worker started"
+$stdout.puts JSON.generate({ type: "ready" })
+$stdout.flush
+
+tests = []
+$stdin.each_line do |line|
+  data = JSON.parse(line.strip)
+  break if data["type"] == "done"
+  tests << data
+rescue JSON::ParserError
+  $stderr.puts "[worker-#{wid}] skip: #{line.strip[0..60]}"
+end
+
+if tests.empty?
+  $stdout.puts JSON.generate({ type: "result", exit_code: 0, passed: true, total: 0, passed_count: 0 })
+  $stdout.flush
+  exit 0
+end
+
+files = tests.map { |t| t["file"] }.uniq
+$stderr.puts "[worker-#{wid}] #{files.size} files, #{tests.size} test entries"
+
+exit_code, results, total, passed = case options[:runner]
+when "rspec"   then run_rspec(files, wid, rspec_args)
+when "minitest" then run_minitest(files, wid, [])
+else
+  $stderr.puts "[worker-#{wid}] unknown runner: #{options[:runner]}"
+  [1, [], 0, 0]
+end
+
+results.each do |r|
+  $stdout.puts JSON.generate({ type: "timing", file: r[:file], name: r[:name], time: r[:time] })
+end
+$stdout.puts JSON.generate({ type: "result", exit_code: exit_code, passed: exit_code == 0, total: total, passed_count: passed })
+$stdout.flush
+exit exit_code

data/lib/binpacker/calibration.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "time"
+require "tempfile"
+
+module Binpacker
+  # Runs tests serially to generate an initial Timing file.
+  class Calibration
+    def initialize(config)
+      @config = config
+      @timing = Timing.new(config.timing_file)
+    end
+
+    def run(tests)
+      results = []
+
+      tests.each do |test|
+        elapsed = run_single(test)
+        results << { file: test.file, name: test.name, time: elapsed }
+      end
+
+      @timing.append_all(results)
+      results
+    end
+
+    private
+
+    def run_single(test)
+      outfile = Tempfile.new("binpacker-cal")
+      outfile.close
+
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      case @config.test_runner
+      when "rspec"
+        cmd = [
+          "rspec", test.file,
+          "--example", test.name,
+          "--format", "json", "--out", outfile.path
+        ]
+      when "minitest"
+        cmd = ["ruby", "-Ilib:test", test.file, "--name", test.name]
+      else
+        raise ConfigError, "unsupported runner for calibration: #{@config.test_runner}"
+      end
+
+      system(*cmd, exception: false)
+
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+      elapsed
+    ensure
+      outfile&.unlink if outfile
+    end
+  end
+end

data/lib/binpacker/cli.rb

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+
+module Binpacker
+  class CLI
+    def self.start(args)
+      new(args).run
+    end
+
+    def initialize(args)
+      @args = args.dup
+      @command = nil
+      @profile = nil
+      @passthrough = []
+      parse!
+    end
+
+    def run
+      case @command
+      when "calibrate"
+        cmd_calibrate
+      when "run"
+        cmd_run
+      when "--version", "-v"
+        puts "binpacker #{Binpacker::VERSION}"
+      when "--help", "-h", nil
+        print_help
+      else
+        $stderr.puts "unknown command: #{@command}"
+        print_help
+        exit 1
+      end
+    end
+
+    private
+
+    def parse!
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: binpacker <command> [options]"
+
+        opts.on("--profile PROFILE", "Profile name from binpacker.yml") do |v|
+          @profile = v
+        end
+
+        opts.on("--version", "Show version") do
+          @command ||= "--version"
+        end
+
+        opts.on("--help", "Show help") do
+          @command ||= "--help"
+        end
+      end
+
+      # Extract passthrough arguments after "--"
+      if (split_idx = @args.index("--"))
+        @passthrough = @args[(split_idx + 1)..] || []
+        @args = @args[0...split_idx]
+      end
+
+      remaining = parser.parse(@args)
+      @command = remaining.shift
+    end
+
+    def cmd_calibrate
+      config = Config.new(profile: @profile)
+      discovery_klass = config.test_runner == "rspec" ? RSpecDiscovery : MinitestDiscovery
+      tests = discovery_klass.new(config).enumerate
+
+      puts "Calibrating #{tests.size} tests..."
+      cal = Calibration.new(config)
+      timings = cal.run(tests)
+
+      total = timings.sum { |t| t[:time] }
+      puts "Calibration complete: #{tests.size} tests in #{total.round(2)}s"
+      puts "Timing data written to #{config.timing_file}"
+    end
+
+    def cmd_run
+      config = Config.new(profile: @profile)
+      orchestrator = Orchestrator.new(config, passthrough: @passthrough)
+
+      puts "binpacker starting (#{config.worker_count} workers, profile: #{config.profile})"
+      result = orchestrator.run
+
+      if result[:passed]
+        puts "All #{result[:total]} examples passed across #{config.worker_count} workers."
+        exit 0
+      else
+        failed = result[:total] - result[:passed_count]
+        puts "#{failed}/#{result[:total]} examples failed."
+        exit 1
+      end
+    end
+
+    def print_help
+      puts <<~HELP
+        binpacker #{Binpacker::VERSION}
+
+        Commands:
+          run          Execute tests across worker processes
+          calibrate    Run tests serially to generate timing data
+
+        Options:
+          --profile NAME   Select profile from binpacker.yml
+          --help           Show this message
+
+        Examples:
+          binpacker run --profile ci
+          binpacker run -- --tag ~slow
+          binpacker calibrate
+      HELP
+    end
+  end
+end

data/lib/binpacker/config.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "etc"
+
+module Binpacker
+  class Config
+    attr_reader :profile
+
+    DEFAULTS = {
+      "test_runner" => "rspec",
+      "workers" => "auto",
+      "timing_file" => "binpacker.timings",
+      "test_pattern" => "spec/**/*_spec.rb",
+      "test_exclude" => [],
+      "scheduler" => {
+        "strategy" => "static",
+        "steal_enabled" => false,
+        "algorithm" => "lpt"
+      }
+    }.freeze
+
+    CI_ENV_VARS = %w[CI GITHUB_ACTIONS GITLAB_CI JENKINS_HOME].freeze
+
+    def initialize(profile: nil, config_path: nil)
+      @config_path = config_path || find_config
+      @raw = load_config
+      @profile = resolve_profile(profile)
+      @merged = build_profile(@profile)
+    end
+
+    def method_missing(name, *)
+      key = name.to_s
+      if @merged.key?(key)
+        @merged[key]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, *)
+      @merged.key?(name.to_s) || super
+    end
+
+    def scheduler
+      @merged["scheduler"]
+    end
+
+    def worker_count
+      workers = @merged["workers"]
+      return Etc.nprocessors if workers == "auto"
+      Integer(workers)
+    end
+
+    private
+
+    def find_config
+      Pathname.pwd.join("binpacker.yml")
+    end
+
+    def load_config
+      return {} unless @config_path.exist?
+      data = YAML.safe_load_file(@config_path.to_s, permitted_classes: [Symbol])
+      data || {}
+    end
+
+    def resolve_profile(explicit)
+      return explicit if explicit
+      return ENV["BINPACKER_PROFILE"] if ENV["BINPACKER_PROFILE"]
+      return "ci" if ci_environment?
+      "default"
+    end
+
+    def ci_environment?
+      CI_ENV_VARS.any? { |v| ENV.key?(v) }
+    end
+
+    def build_profile(name)
+      profiles = @raw.fetch("profiles", {})
+      entry = profiles[name]
+      raise ConfigError, "profile '#{name}' not found in binpacker.yml" unless entry
+      parent = entry["extends"]
+      base = parent ? build_profile(parent) : DEFAULTS.dup
+      deep_merge(base, entry.reject { |k, _| k == "extends" })
+    end
+
+    def deep_merge(base, override)
+      base.merge(override) { |_key, old_val, new_val|
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          old_val.merge(new_val)
+        else
+          new_val
+        end
+      }
+    end
+  end
+end

data/lib/binpacker/orchestrator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Binpacker
+  class Orchestrator
+    def initialize(config, passthrough: [])
+      @config = config
+      @passthrough = passthrough
+    end
+
+    def run
+      tests = discover
+
+      timing = Timing.new(@config.timing_file)
+      timings = timing.load_with_fallback(tests)
+
+      scheduler = Scheduler.for(@config.scheduler["algorithm"])
+      queues = scheduler.partition(
+        tests: tests,
+        worker_count: @config.worker_count,
+        timings: timings
+      )
+
+      runner_class = TestRunner.for(@config.test_runner)
+      workers = queues.map.with_index do |queue, idx|
+        Worker.new(idx, runner_class, passthrough: @passthrough).tap(&:start)
+      end
+
+      workers.zip(queues).each do |worker, queue|
+        worker.send_tests(queue.remaining)
+      end
+
+      all_timings = []
+      all_passed = true
+      total_examples = 0
+      passed_examples = 0
+
+      workers.each do |worker|
+        worker.finish
+        all_timings.concat(worker.timings)
+        all_passed &&= worker.success?
+        total_examples += worker.example_count
+        passed_examples += worker.passed_count
+      rescue WorkerError => e
+        $stderr.puts "worker #{worker.id} error: #{e.message}"
+        all_passed = false
+      ensure
+        worker.cleanup
+      end
+
+      timing.append_all(all_timings) unless all_timings.empty?
+
+      {
+        passed: all_passed,
+        total: total_examples,
+        passed_count: passed_examples,
+        timings: all_timings
+      }
+    end
+
+    private
+
+    def discover
+      case @config.test_runner
+      when "rspec"
+        RSpecDiscovery.new(@config).enumerate
+      when "minitest"
+        MinitestDiscovery.new(@config).enumerate
+      else
+        raise ConfigError, "unsupported runner: #{@config.test_runner}"
+      end
+    end
+  end
+end

data/lib/binpacker/scheduler.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Binpacker
+  class Scheduler
+    # Returns Array<WorkerQueue> one per worker.
+    def partition(tests:, worker_count:, timings:)
+      raise NotImplementedError
+    end
+
+    def self.for(strategy)
+      case strategy.to_s
+      when "lpt" then LptScheduler.new
+      else
+        raise SchedulerError, "unknown scheduling algorithm: #{strategy}"
+      end
+    end
+  end
+
+  class LptScheduler < Scheduler
+    # Longest Processing Time first.
+    # Sort tests by descending weight, assign each to the least-loaded worker.
+    def partition(tests:, worker_count:, timings:)
+      queues = Array.new(worker_count) { |i| WorkerQueue.new(i) }
+      loads = Array.new(worker_count, 0.0)
+
+      # Sort by weight descending; unknown tests get default weight
+      sorted = tests.sort_by { |t|
+        -timings.fetch(t.key, Timing::DEFAULT_WEIGHT)
+      }
+
+      sorted.each do |test|
+        min_idx = loads.each_with_index.min_by { |load, _| load }.last
+        queues[min_idx].push(test)
+        loads[min_idx] += timings.fetch(test.key, Timing::DEFAULT_WEIGHT)
+      end
+
+      queues
+    end
+  end
+end

data/lib/binpacker/test_discovery.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Binpacker
+  Test = Struct.new(:file, :name, keyword_init: true) do
+    # Composite key used as timing lookup and identity.
+    def key
+      [file, name]
+    end
+  end
+
+  class TestDiscovery
+    def initialize(config)
+      @config = config
+      @pattern = config.test_pattern
+      @exclude = config.test_exclude
+    end
+
+    # Returns Array<Test>. Concrete strategies subclass this.
+    def enumerate
+      raise NotImplementedError
+    end
+
+    private
+
+    def glob_files
+      Dir.glob(@pattern).reject { |f|
+        @exclude.any? { |ex| File.fnmatch?(ex, f) }
+      }
+    end
+  end
+
+  class RSpecDiscovery < TestDiscovery
+    def enumerate
+      glob_files.map { |f| Test.new(file: f, name: f) }
+    end
+  end
+
+  class MinitestDiscovery < TestDiscovery
+    # For Minitest, we can't easily enumerate test names without running them.
+    # Instead, treat each file as a single test unit, with the file path as the name.
+    def enumerate
+      glob_files.map { |f|
+        Test.new(file: f, name: f)
+      }
+    end
+  end
+end

data/lib/binpacker/test_runner.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Binpacker
+  class TestRunner
+    def self.runner_name
+      raise NotImplementedError
+    end
+
+    def self.for(name)
+      case name.to_s
+      when "rspec" then RSpecRunner
+      when "minitest" then MinitestRunner
+      else raise ConfigError, "unknown test runner: #{name}"
+      end
+    end
+  end
+
+  class RSpecRunner < TestRunner
+    def self.runner_name
+      "rspec"
+    end
+
+    # Returns the RSpec binary invocation for dry-run discovery
+    def self.discovery_command(files)
+      ["rspec", "--dry-run", "--format", "json", *files]
+    end
+  end
+
+  class MinitestRunner < TestRunner
+    def self.runner_name
+      "minitest"
+    end
+  end
+end

data/lib/binpacker/timing.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Binpacker
+  class Timing
+    Entry = Struct.new(:file, :name, :time, keyword_init: true)
+
+    DEFAULT_WEIGHT = 1.0
+
+    def initialize(path)
+      @path = Pathname(path)
+    end
+
+    def load_with_fallback(tests)
+      per_file = load_per_file
+      tests.each_with_object({}) do |test, hash|
+        key = normalize_path(test.file)
+        hash[test.key] = per_file.fetch(key) { filesize_weight(test.file) }
+      end
+    end
+
+    def load_raw
+      return {} unless @path.exist?
+
+      @path.each_line
+        .map { |line| parse_line(line) }
+        .compact
+        .group_by { |e| [normalize_path(e.file), e.name] }
+        .transform_values { |entries| entries.last.time }
+    end
+
+    def load_per_file
+      return {} unless @path.exist?
+
+      @path.each_line
+        .map { |line| parse_line(line) }
+        .compact
+        .group_by { |e| normalize_path(e.file) }
+        .transform_values { |entries| entries.sum(&:time) }
+    end
+
+    def normalize_path(path)
+      Pathname(path).cleanpath.to_s.sub(/\A\.\//, "")
+    end
+
+    def weight_for(file:, name:)
+      measured = load_raw
+      measured.fetch([file, name]) { filesize_weight(file) }
+    end
+
+    def append(file:, name:, time:)
+      @path.dirname.mkpath unless @path.dirname.directory?
+      @path.open("a") { |io| io.puts JSON.generate({ file: file, name: name, time: time }) }
+    end
+
+    def append_all(entries)
+      return if entries.empty?
+      @path.dirname.mkpath unless @path.dirname.directory?
+      @path.open("a") do |io|
+        entries.each { |e| io.puts JSON.generate({ file: e[:file], name: e[:name], time: e[:time] }) }
+      end
+    end
+
+    private
+
+    def filesize_weight(file)
+      path = Pathname(file)
+      path.exist? ? [path.size / 1024.0, DEFAULT_WEIGHT].max : DEFAULT_WEIGHT
+    end
+
+    def parse_line(line)
+      data = JSON.parse(line.strip)
+      Entry.new(file: data["file"], name: data["name"], time: data["time"])
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/binpacker/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Binpacker
+  VERSION = "0.0.1"
+end

data/lib/binpacker/worker.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Binpacker
+  class Worker
+    attr_reader :id, :status, :example_count, :passed_count
+
+    def initialize(id, runner_class, passthrough: [])
+      @id = id
+      @runner_class = runner_class
+      @passthrough = passthrough
+      @status = :created
+      @timings = []
+      @exit_code = nil
+      @example_count = 0
+      @passed_count = 0
+    end
+
+    def start
+      worker_script = File.expand_path("../../exe/binpacker-worker", __dir__)
+
+      @stdin_r, @stdin_w = IO.pipe
+      @stdout_r, @stdout_w = IO.pipe
+      @stderr_r, @stderr_w = IO.pipe
+
+      @pid = Process.spawn(
+        RbConfig.ruby, worker_script,
+        "--runner", @runner_class.runner_name,
+        *passthrough_args,
+        in: @stdin_r, out: @stdout_w, err: @stderr_w,
+        close_others: true
+      )
+
+      @stdin_r.close; @stdout_w.close; @stderr_w.close
+
+      @stderr_thread = Thread.new do
+        @stderr_r.each_line { |line| $stderr.write line }
+      end
+
+      ready_line = read_line(timeout: 30)
+      if ready_line
+        data = JSON.parse(ready_line.strip)
+        @status = :ready if data["type"] == "ready"
+      end
+
+      raise WorkerError, "worker #{@id} failed to start" unless @status == :ready
+      self
+    rescue JSON::ParserError
+      @status = :error
+      raise WorkerError, "worker #{@id} sent invalid ready signal"
+    end
+
+    def send_tests(tests)
+      tests.each { |t| @stdin_w.puts JSON.generate({ file: t.file, name: t.name }) }
+    end
+
+    def send_test(test)
+      @stdin_w.puts JSON.generate({ file: test.file, name: test.name })
+    end
+
+    def finish
+      @stdin_w.puts JSON.generate({ type: "done" })
+      @stdin_w.close
+
+      @status = :running
+      @stdout_r.each_line do |line|
+        data = JSON.parse(line.strip)
+        case data["type"]
+        when "timing"
+          @timings << { file: data["file"], name: data["name"], time: data["time"] }
+        when "result"
+          @exit_code = data["exit_code"]
+          @passed = data["passed"]
+          @example_count = data["total"] || 0
+          @passed_count = data["passed_count"] || 0
+        when "output"
+          $stdout.write data["text"] if data["text"]
+        end
+      rescue JSON::ParserError
+        $stdout.write line
+      end
+
+      Process.wait(@pid)
+      @status = :finished
+    rescue Errno::ECHILD
+      @status = :crashed
+      @passed = false
+    end
+
+    def timings
+      @timings
+    end
+
+    def success?
+      @exit_code == 0
+    end
+
+    def cleanup
+      kill! if @status == :running || @status == :ready
+      [@stdin_w, @stdout_r, @stderr_r].each { |io| io&.close unless io&.closed? }
+      @stderr_thread&.kill
+    rescue IOError
+    end
+
+    private
+
+    def passthrough_args
+      return [] if @passthrough.empty?
+      @passthrough.flat_map { |arg| ["--rspec-arg", arg] }
+    end
+
+    def kill!
+      Process.kill("TERM", @pid)
+      Process.wait(@pid)
+    rescue Errno::ESRCH, Errno::ECHILD
+    end
+
+    def read_line(timeout: 1)
+      io = [@stdout_r]
+      readable = IO.select(io, nil, nil, timeout)
+      return nil unless readable
+      readable.first.first.gets
+    rescue IOError, Errno::EPIPE
+      nil
+    end
+  end
+end

data/lib/binpacker/worker_queue.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Binpacker
+  class WorkerQueue
+    include Enumerable
+
+    attr_reader :worker_id
+
+    def initialize(worker_id, tests = [])
+      @worker_id = worker_id
+      @tests = tests.dup
+      @index = 0
+    end
+
+    def pop
+      return nil if empty?
+      test = @tests[@index]
+      @index += 1
+      test
+    end
+
+    def peek
+      return nil if empty?
+      @tests[@index]
+    end
+
+    def empty?
+      @index >= @tests.size
+    end
+
+    def size
+      @tests.size - @index
+    end
+
+    def remaining
+      @tests[@index..] || []
+    end
+
+    def total_weight(timings)
+      remaining.sum { |t| timings.fetch(t.key, Timing::DEFAULT_WEIGHT) }
+    end
+
+    def push(test)
+      @tests << test
+    end
+
+    def each(&block)
+      @tests[@index..].each(&block)
+    end
+  end
+end

data/lib/binpacker.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "binpacker/version"
+require_relative "binpacker/config"
+require_relative "binpacker/timing"
+require_relative "binpacker/test_discovery"
+require_relative "binpacker/worker_queue"
+require_relative "binpacker/scheduler"
+require_relative "binpacker/worker"
+require_relative "binpacker/test_runner"
+require_relative "binpacker/calibration"
+require_relative "binpacker/orchestrator"
+
+module Binpacker
+  Error = Class.new(StandardError)
+  ConfigError = Class.new(Error)
+  DiscoveryError = Class.new(Error)
+  SchedulerError = Class.new(Error)
+  WorkerError = Class.new(Error)
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: binpacker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- megurine
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A test runner wrapper that manages worker processes and distributes tests
+  among them using LPT scheduling with optional work-stealing.
+executables:
+- binpacker
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- exe/binpacker
+- exe/binpacker-worker
+- lib/binpacker.rb
+- lib/binpacker/calibration.rb
+- lib/binpacker/cli.rb
+- lib/binpacker/config.rb
+- lib/binpacker/orchestrator.rb
+- lib/binpacker/scheduler.rb
+- lib/binpacker/test_discovery.rb
+- lib/binpacker/test_runner.rb
+- lib/binpacker/timing.rb
+- lib/binpacker/version.rb
+- lib/binpacker/worker.rb
+- lib/binpacker/worker_queue.rb
+homepage: https://github.com/rigortype/binpacker
+licenses:
+- MPL-2.0
+metadata:
+  homepage_uri: https://github.com/rigortype/binpacker
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Minimize CI test-suite makespan by solving an identical-machines scheduling
+  problem
+test_files: []