polyrun 1.0.0

data/lib/polyrun/cli/coverage_merge_io.rb

@@ -0,0 +1,124 @@
+require "json"
+require "fileutils"
+require "optparse"
+
+module Polyrun
+  class CLI
+    # Writes merged coverage blob to requested formats (merge-coverage / run-shards).
+    module CoverageMergeIo
+      private
+
+      def merge_coverage_parse_argv(argv)
+        inputs = []
+        output = "coverage/polyrun-merged.json"
+        formats = ["json"]
+        parser = OptionParser.new do |opts|
+          opts.banner = "usage: polyrun merge-coverage -i FILE [-i FILE] [-o PATH] [--format json,lcov,cobertura,console,html]"
+          opts.on("-i", "--input FILE", "Coverage JSON (repeatable; globs ok)") do |f|
+            expand_merge_input_pattern(f).each { |x| inputs << x }
+          end
+          opts.on("-o", "--output PATH", String) { |v| output = v }
+          opts.on("--format LIST", String) { |v| formats = v.split(",").map(&:strip) }
+        end
+        parser.parse!(argv)
+        inputs.uniq!
+        inputs.select! { |p| File.file?(p) }
+        [inputs, output, formats]
+      end
+
+      def merge_coverage_merge_fragments(inputs)
+        Polyrun::Debug.time("Coverage::Merge.merge_fragments") do
+          Polyrun::Coverage::Merge.merge_fragments(inputs)
+        end
+      end
+
+      def merge_coverage_write_json_payload(out_abs, payload)
+        Polyrun::Debug.time("write merged JSON") do
+          FileUtils.mkdir_p(File.dirname(out_abs))
+          File.write(out_abs, JSON.generate(payload))
+        end
+      end
+
+      def merge_coverage_write_format_outputs(merged, r, out_abs, formats)
+        write_merge_lcov(merged, out_abs) if formats.include?("lcov")
+        write_merge_cobertura(merged, r, out_abs) if formats.include?("cobertura")
+        write_merge_console(merged, out_abs) if formats.include?("console")
+        write_merge_html(merged, out_abs) if formats.include?("html")
+      end
+
+      def write_merge_lcov(merged, out_abs)
+        lcov_path = out_abs.sub(/\.json\z/, ".lcov")
+        lcov_path = "#{out_abs}.lcov" if lcov_path == out_abs
+        Polyrun::Debug.time("write lcov") { File.write(lcov_path, Polyrun::Coverage::Merge.emit_lcov(merged)) }
+      end
+
+      def write_merge_cobertura(merged, r, out_abs)
+        cob_path = out_abs.sub(/\.json\z/, ".xml")
+        cob_path = "#{out_abs}.cobertura.xml" if cob_path == out_abs
+        root = merge_cobertura_root(r)
+        Polyrun::Debug.time("write cobertura XML") do
+          File.write(cob_path, Polyrun::Coverage::Merge.emit_cobertura(merged, root: root))
+        end
+      end
+
+      def merge_cobertura_root(r)
+        return nil unless r[:meta].is_a?(Hash)
+
+        r[:meta]["polyrun_coverage_root"] || r[:meta][:polyrun_coverage_root]
+      end
+
+      def write_merge_console(merged, out_abs)
+        sum_path = out_abs.sub(/\.json\z/, "-summary.txt")
+        sum_path = "#{out_abs}-summary.txt" if sum_path == out_abs
+        summary = Polyrun::Coverage::Merge.console_summary(merged)
+        summary_text = Polyrun::Coverage::Merge.format_console_summary(summary)
+        Polyrun::Debug.time("write console summary") { File.write(sum_path, summary_text) }
+        Polyrun::Log.print summary_text
+      end
+
+      def write_merge_html(merged, out_abs)
+        html_path = out_abs.sub(/\.json\z/, ".html")
+        html_path = "#{out_abs}.html" if html_path == out_abs
+        Polyrun::Debug.time("write HTML report") { File.write(html_path, Polyrun::Coverage::Merge.emit_html(merged)) }
+      end
+
+      def merge_coverage_log_finish(elapsed, inputs)
+        thr = merge_slow_warn_threshold_seconds
+        merge_coverage_warn_if_slow(elapsed, thr, inputs) if thr && elapsed > thr
+        return unless @verbose || ENV["POLYRUN_PROFILE_MERGE"] == "1" || Polyrun::Debug.enabled?
+
+        Polyrun::Log.warn format("merge-coverage: finished in %.2fs (%d input fragment(s))", elapsed, inputs.size)
+      end
+
+      def merge_coverage_warn_if_slow(elapsed, thr, inputs)
+        Polyrun::Log.warn format(
+          "merge-coverage: slow merge took %.2fs (warn above %.0fs; typical suites are JSON fragments, not TB-scale data; disable: POLYRUN_MERGE_SLOW_WARN_SECONDS=0)",
+          elapsed,
+          thr
+        )
+      end
+
+      def merge_coverage_min_line_gate_below?(merged_path, gate)
+        Polyrun::Debug.time("minimum_line_percent gate (merged JSON)") do
+          data = JSON.parse(File.read(merged_path))
+          blob = Polyrun::Coverage::Merge.extract_coverage_blob(data)
+          summary = Polyrun::Coverage::Merge.console_summary(blob)
+          min = gate[:minimum]
+          below = summary[:line_percent].round < min.round
+          Polyrun::Debug.log_kv(
+            merged_line_percent: summary[:line_percent],
+            gate_minimum: min,
+            below_gate: below
+          )
+          log_gate_below_minimum(summary, min) if below
+          below
+        end
+      end
+
+      def log_gate_below_minimum(summary, min)
+        Polyrun::Log.warn Polyrun::Coverage::Merge.format_console_summary(summary)
+        Polyrun::Log.warn "Polyrun coverage: #{summary[:line_percent].round(2)}% rounds below minimum #{min}% (merged)."
+      end
+    end
+  end
+end

data/lib/polyrun/cli/database_commands.rb

@@ -0,0 +1,149 @@
+require "optparse"
+
+module Polyrun
+  class CLI
+    module DatabaseCommands
+      private
+
+      def cmd_db_setup_template(argv, config_path)
+        dry = false
+        rails_root = Dir.pwd
+        parser = OptionParser.new do |opts|
+          opts.on("--dry-run", "Print only") { dry = true }
+          opts.on("--rails-root PATH", String) { |v| rails_root = v }
+        end
+        parser.parse!(argv)
+
+        cfg = Polyrun::Config.load(path: config_path || ENV["POLYRUN_CONFIG"])
+        dh = cfg.databases
+        if !dh.is_a?(Hash) || dh.empty?
+          Polyrun::Log.warn "db:setup-template: configure databases: in polyrun.yml"
+          return 2
+        end
+
+        begin
+          te = Polyrun::Database::UrlBuilder.template_prepare_env(dh)
+        rescue Polyrun::Error => e
+          Polyrun::Log.warn "db:setup-template: #{e.message}"
+          return 2
+        end
+
+        if dry
+          log = Polyrun::Database::UrlBuilder.template_prepare_env_shell_log(dh)
+          Polyrun::Log.warn "would: RAILS_ENV=test #{log} bin/rails db:prepare"
+          return 0
+        end
+
+        child_env = ENV.to_h.merge(te)
+        child_env["RAILS_ENV"] ||= ENV["RAILS_ENV"] || "test"
+        Polyrun::Database::Provision.prepare_template!(
+          rails_root: File.expand_path(rails_root),
+          env: child_env,
+          silent: !@verbose
+        )
+        0
+      end
+
+      def cmd_db_setup_shard(argv, config_path)
+        dry = db_setup_shard_parse_options!(argv)
+        cfg = Polyrun::Config.load(path: config_path || ENV["POLYRUN_CONFIG"])
+        dh = cfg.databases
+        if !dh.is_a?(Hash) || dh.empty?
+          Polyrun::Log.warn "db:setup-shard: configure databases: in polyrun.yml"
+          return 2
+        end
+
+        shard = resolve_shard_index(cfg.partition)
+        template = dh["template_db"] || dh[:template_db]
+        if !template
+          Polyrun::Log.warn "db:setup-shard: set databases.template_db"
+          return 2
+        end
+
+        plan = Polyrun::Database::UrlBuilder.shard_database_plan(dh, shard_index: shard)
+        if plan.empty?
+          Polyrun::Log.warn "db:setup-shard: could not derive shard database names from polyrun.yml"
+          return 2
+        end
+
+        db_setup_shard_run_plan(plan, dry: dry)
+      end
+
+      def db_setup_shard_parse_options!(argv)
+        dry = false
+        OptionParser.new do |opts|
+          opts.on("--dry-run", "Print only") { dry = true }
+        end.parse!(argv)
+        dry
+      end
+
+      def db_setup_shard_run_plan(plan, dry:)
+        if dry
+          plan.each do |row|
+            Polyrun::Log.warn "would: CREATE DATABASE #{row[:new_db]} TEMPLATE #{row[:template_db]}"
+          end
+          return 0
+        end
+
+        threads = plan.map do |row|
+          Thread.new do
+            Polyrun::Database::Provision.create_database_from_template!(
+              new_db: row[:new_db],
+              template_db: row[:template_db].to_s
+            )
+          end
+        end
+        threads.each(&:join)
+        0
+      end
+
+      # Migrate all template DBs + create every shard database (primary + +connections+).
+      def cmd_db_clone_shards(argv, config_path)
+        opts = db_clone_shards_parse_options!(argv)
+        cfg = Polyrun::Config.load(path: config_path || ENV["POLYRUN_CONFIG"])
+        dh = cfg.databases
+        if !dh.is_a?(Hash) || dh.empty?
+          Polyrun::Log.warn "db:clone-shards: configure databases: in polyrun.yml"
+          return 2
+        end
+
+        workers = opts[:workers].clamp(1, 10)
+        Polyrun::Database::CloneShards.provision!(
+          dh,
+          workers: workers,
+          rails_root: File.expand_path(opts[:rails_root]),
+          migrate: opts[:migrate],
+          replace: opts[:replace],
+          force_drop: opts[:force_drop],
+          dry_run: opts[:dry],
+          silent: !@verbose
+        )
+        0
+      rescue Polyrun::Error => e
+        Polyrun::Log.warn "db:clone-shards: #{e.message}"
+        1
+      end
+
+      def db_clone_shards_parse_options!(argv)
+        dry = false
+        migrate = true
+        replace = true
+        force_drop = false
+        rails_root = Dir.pwd
+        workers = env_int("POLYRUN_WORKERS", 5)
+
+        OptionParser.new do |opts|
+          opts.banner = "usage: polyrun db:clone-shards [--workers N] [--rails-root PATH] [--dry-run] [--no-migrate] [--no-replace] [--force-drop]"
+          opts.on("--workers N", Integer) { |v| workers = v }
+          opts.on("--dry-run", "Print only") { dry = true }
+          opts.on("--rails-root PATH", String) { |v| rails_root = v }
+          opts.on("--no-migrate", "Skip db:prepare on template databases") { migrate = false }
+          opts.on("--no-replace", "Skip DROP DATABASE before CREATE (fail if shard DB exists)") { replace = false }
+          opts.on("--force-drop", "DROP DATABASE … WITH (FORCE) (PostgreSQL 13+)") { force_drop = true }
+        end.parse!(argv)
+
+        {dry: dry, migrate: migrate, replace: replace, force_drop: force_drop, rails_root: rails_root, workers: workers}
+      end
+    end
+  end
+end

data/lib/polyrun/cli/env_commands.rb

@@ -0,0 +1,43 @@
+require "optparse"
+
+module Polyrun
+  class CLI
+    module EnvCommands
+      private
+
+      def cmd_env(argv, config_path)
+        shard, total, base_database = env_parse_options!(argv)
+        cfg = Polyrun::Config.load(path: config_path || ENV["POLYRUN_CONFIG"])
+        pc = cfg.partition
+        shard = shard.nil? ? resolve_shard_index(pc) : shard
+        total = total.nil? ? resolve_shard_total(pc) : total
+
+        env_print_database_exports(cfg.databases, shard)
+        Polyrun::Database::Shard.env_map(shard_index: shard, shard_total: total, base_database: base_database).each do |k, v|
+          Polyrun::Log.puts %(export #{k}=#{v})
+        end
+        0
+      end
+
+      def env_parse_options!(argv)
+        shard = nil
+        total = nil
+        base_database = nil
+        OptionParser.new do |opts|
+          opts.on("--shard INDEX", Integer) { |v| shard = v }
+          opts.on("--total N", Integer) { |v| total = v }
+          opts.on("--database TEMPLATE", String) { |v| base_database = v }
+        end.parse!(argv)
+        [shard, total, base_database]
+      end
+
+      def env_print_database_exports(dh, shard)
+        return unless dh.is_a?(Hash) && !dh.empty?
+
+        Polyrun::Database::UrlBuilder.env_exports_for_databases(dh, shard_index: shard).each do |k, v|
+          Polyrun::Log.puts %(export #{k}=#{v})
+        end
+      end
+    end
+  end
+end

data/lib/polyrun/cli/helpers.rb

@@ -0,0 +1,113 @@
+require "yaml"
+
+module Polyrun
+  class CLI
+    module Helpers
+      private
+
+      def partition_int(pc, keys, default)
+        keys.each do |k|
+          v = pc[k] || pc[k.to_sym]
+          next if v.nil? || v.to_s.empty?
+
+          i = Integer(v, exception: false)
+          return i unless i.nil?
+        end
+        default
+      end
+
+      def env_int(name, fallback)
+        s = ENV[name]
+        return fallback if s.nil? || s.empty?
+
+        Integer(s, exception: false) || fallback
+      end
+
+      def resolve_shard_index(pc)
+        return Integer(ENV["POLYRUN_SHARD_INDEX"]) if ENV["POLYRUN_SHARD_INDEX"] && !ENV["POLYRUN_SHARD_INDEX"].empty?
+
+        ci = Polyrun::Env::Ci.detect_shard_index
+        return ci unless ci.nil?
+
+        partition_int(pc, %w[shard_index shard], 0)
+      end
+
+      def resolve_shard_total(pc)
+        return Integer(ENV["POLYRUN_SHARD_TOTAL"]) if ENV["POLYRUN_SHARD_TOTAL"] && !ENV["POLYRUN_SHARD_TOTAL"].empty?
+
+        ci = Polyrun::Env::Ci.detect_shard_total
+        return ci unless ci.nil?
+
+        partition_int(pc, %w[shard_total total], 1)
+      end
+
+      def expand_merge_input_pattern(path)
+        p = path.to_s
+        abs = File.expand_path(p, Dir.pwd)
+        return Dir.glob(abs).sort if p.include?("*") || p.include?("?")
+
+        [abs]
+      end
+
+      # Same rounding/strict semantics as {Polyrun::Coverage::Collector} for +config/polyrun_coverage.yml+.
+      def coverage_minimum_line_gate_from_polyrun_coverage_yml
+        path = File.join(Dir.pwd, "config", "polyrun_coverage.yml")
+        return nil unless File.file?(path)
+
+        data = YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: true)
+        return nil unless data.is_a?(Hash)
+
+        min = data["minimum_line_percent"] || data[:minimum_line_percent]
+        return nil if min.nil?
+
+        sv = data["strict"] if data.key?("strict")
+        sv = data[:strict] if !data.key?("strict") && data.key?(:strict)
+        strict = sv.nil? || sv
+
+        {minimum: min.to_f, strict: strict != false}
+      rescue Psych::SyntaxError, ArgumentError, TypeError
+        nil
+      end
+
+      def load_partition_constraints(pc, constraints_path)
+        if constraints_path
+          path = File.expand_path(constraints_path.to_s, Dir.pwd)
+          unless File.file?(path)
+            Polyrun::Log.warn "polyrun: constraints file not found: #{path}"
+            return nil
+          end
+          h = YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: true)
+          return Polyrun::Partition::Constraints.from_hash(h, root: Dir.pwd)
+        end
+        if pc["constraints"].is_a?(Hash)
+          return Polyrun::Partition::Constraints.from_hash(pc["constraints"], root: Dir.pwd)
+        end
+        cf = pc["constraints_file"] || pc[:constraints_file]
+        if cf
+          path = File.expand_path(cf.to_s, Dir.pwd)
+          return nil unless File.file?(path)
+
+          h = YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: true)
+          return Polyrun::Partition::Constraints.from_hash(h, root: Dir.pwd)
+        end
+        nil
+      end
+
+      # +default_weight+ should be precomputed when sorting many paths (e.g. +queue init+), matching
+      # {Partition::Plan#default_weight} semantics: mean of known timing costs for missing paths.
+      def queue_weight_for(path, costs, default_weight = nil)
+        abs = File.expand_path(path.to_s, Dir.pwd)
+        return costs[abs] if costs.key?(abs)
+
+        unless default_weight.nil?
+          return default_weight
+        end
+
+        vals = costs.values
+        return 1.0 if vals.empty?
+
+        vals.sum / vals.size.to_f
+      end
+    end
+  end
+end

data/lib/polyrun/cli/init_command.rb

@@ -0,0 +1,99 @@
+require "optparse"
+
+module Polyrun
+  class CLI
+    module InitCommand
+      INIT_PROFILES = {
+        "gem" => "minimal_gem.polyrun.yml",
+        "rails" => "rails_prepare.polyrun.yml",
+        "ci-matrix" => "ci_matrix.polyrun.yml",
+        "doc" => "POLYRUN.md"
+      }.freeze
+
+      private
+
+      def templates_dir
+        File.expand_path("../templates", __dir__)
+      end
+
+      def cmd_init(argv, _config_path)
+        profile, output, dry_run, force, list = init_parse_options!(argv)
+        return init_list_profiles if list
+        return init_missing_profile if profile.nil?
+
+        filename = INIT_PROFILES[profile]
+        return init_unknown_profile(profile) unless filename
+
+        src = File.join(templates_dir, filename)
+        return init_missing_template(src) unless File.file?(src)
+
+        body = File.read(src, encoding: Encoding::UTF_8)
+        dest = output || default_init_output(profile)
+        return init_dry_run_print(body) if dry_run
+
+        path = File.expand_path(dest)
+        return init_refuses_overwrite(path) if File.file?(path) && !force
+
+        File.write(path, body)
+        Polyrun::Log.warn "polyrun init: wrote #{path}"
+        0
+      end
+
+      def init_parse_options!(argv)
+        profile = nil
+        output = nil
+        dry_run = false
+        force = false
+        list = false
+
+        OptionParser.new do |opts|
+          opts.banner = "usage: polyrun init [--profile NAME] [--output PATH] [--dry-run] [--force]\n       polyrun init --list"
+          opts.on("--profile NAME", INIT_PROFILES.keys.join(", ")) { |p| profile = p }
+          opts.on("-o", "--output PATH", "destination file (default: polyrun.yml or POLYRUN.md for --profile doc)") { |p| output = p }
+          opts.on("--dry-run", "print template to stdout; do not write") { dry_run = true }
+          opts.on("--force", "overwrite existing output file") { force = true }
+          opts.on("--list", "print available profiles") { list = true }
+        end.parse!(argv)
+
+        [profile, output, dry_run, force, list]
+      end
+
+      def init_list_profiles
+        Polyrun::Log.puts "polyrun init profiles:"
+        INIT_PROFILES.each do |name, file|
+          Polyrun::Log.puts "  #{name.ljust(12)} #{file}"
+        end
+        0
+      end
+
+      def init_missing_profile
+        Polyrun::Log.warn "polyrun init: specify --profile (#{INIT_PROFILES.keys.join(", ")}) or --list"
+        2
+      end
+
+      def init_unknown_profile(profile)
+        Polyrun::Log.warn "polyrun init: unknown profile #{profile.inspect}"
+        2
+      end
+
+      def init_missing_template(src)
+        Polyrun::Log.warn "polyrun init: template missing: #{src}"
+        1
+      end
+
+      def init_dry_run_print(body)
+        Polyrun::Log.print body
+        0
+      end
+
+      def init_refuses_overwrite(path)
+        Polyrun::Log.warn "polyrun init: #{path} exists (use --force to overwrite)"
+        1
+      end
+
+      def default_init_output(profile)
+        (profile == "doc") ? "POLYRUN.md" : "polyrun.yml"
+      end
+    end
+  end
+end

data/lib/polyrun/cli/plan_command.rb

@@ -0,0 +1,134 @@
+require "json"
+require "optparse"
+
+module Polyrun
+  class CLI
+    module PlanCommand
+      private
+
+      def cmd_plan(argv, config_path)
+        cfg = Polyrun::Config.load(path: config_path || ENV["POLYRUN_CONFIG"])
+        pc = cfg.partition
+        ctx = plan_command_initial_context(pc)
+        plan_command_parse_argv!(argv, ctx)
+
+        paths_file = ctx[:paths_file] || (pc["paths_file"] || pc[:paths_file])
+        code = Polyrun::Partition::PathsBuild.apply!(partition: pc, cwd: Dir.pwd)
+        return code if code != 0
+
+        timing_path = plan_resolve_timing_path(pc, ctx[:timing_path], ctx[:strategy])
+        Polyrun::Log.warn "polyrun plan: using #{cfg.path}" if @verbose && cfg.path
+
+        items = plan_plan_items(paths_file, argv)
+        return 2 if items.nil?
+
+        loaded = plan_load_costs_and_strategy(timing_path, ctx[:strategy])
+        return 2 if loaded.nil?
+
+        costs, strategy = loaded
+
+        constraints = load_partition_constraints(pc, ctx[:constraints_path])
+
+        plan_command_emit_manifest(
+          items: items,
+          total: ctx[:total],
+          strategy: strategy,
+          seed: ctx[:seed],
+          costs: costs,
+          constraints: constraints,
+          shard: ctx[:shard]
+        )
+      end
+
+      def plan_command_initial_context(pc)
+        {
+          shard: resolve_shard_index(pc),
+          total: resolve_shard_total(pc),
+          strategy: (pc["strategy"] || pc[:strategy] || "round_robin").to_s,
+          seed: pc["seed"] || pc[:seed],
+          paths_file: nil,
+          timing_path: nil,
+          constraints_path: nil
+        }
+      end
+
+      def plan_command_parse_argv!(argv, ctx)
+        OptionParser.new do |opts|
+          opts.banner = "usage: polyrun plan [options] [--] [paths...]"
+          opts.on("--shard INDEX", Integer) { |v| ctx[:shard] = v }
+          opts.on("--total N", Integer) { |v| ctx[:total] = v }
+          opts.on("--strategy NAME", String) { |v| ctx[:strategy] = v }
+          opts.on("--seed VAL") { |v| ctx[:seed] = v }
+          opts.on("--paths-file PATH", String) { |v| ctx[:paths_file] = v }
+          opts.on("--constraints PATH", "YAML: pin / serial_glob (see spec_queue.md)") { |v| ctx[:constraints_path] = v }
+          opts.on("--timing PATH", "path => seconds JSON; implies cost_binpack unless strategy is cost-based or hrw") do |v|
+            ctx[:timing_path] = v
+          end
+        end.parse!(argv)
+      end
+
+      def plan_command_emit_manifest(items:, total:, strategy:, seed:, costs:, constraints:, shard:)
+        plan = Polyrun::Debug.time("Partition::Plan.new (plan command)") do
+          Polyrun::Partition::Plan.new(
+            items: items,
+            total_shards: total,
+            strategy: strategy,
+            seed: seed,
+            costs: costs,
+            constraints: constraints,
+            root: Dir.pwd
+          )
+        end
+        Polyrun::Debug.log_kv(
+          plan: "emit manifest JSON",
+          shard: shard,
+          total: total,
+          strategy: strategy,
+          path_count: items.size
+        )
+        Polyrun::Log.puts JSON.generate(plan.manifest(shard))
+        0
+      end
+
+      def plan_resolve_timing_path(pc, timing_path, strategy)
+        return timing_path if timing_path
+
+        tf = pc["timing_file"] || pc[:timing_file]
+        return tf if tf && (Polyrun::Partition::Plan.cost_strategy?(strategy) || Polyrun::Partition::Plan.hrw_strategy?(strategy))
+
+        nil
+      end
+
+      def plan_plan_items(paths_file, argv)
+        if paths_file
+          Polyrun::Partition::Paths.read_lines(paths_file)
+        elsif argv.empty?
+          Polyrun::Log.warn "polyrun plan: provide spec paths, --paths-file, or partition.paths_file in polyrun.yml"
+          nil
+        else
+          argv
+        end
+      end
+
+      def plan_load_costs_and_strategy(timing_path, strategy)
+        if timing_path
+          costs = Polyrun::Partition::Plan.load_timing_costs(File.expand_path(timing_path.to_s, Dir.pwd))
+          if costs.empty?
+            Polyrun::Log.warn "polyrun plan: timing file missing or has no entries: #{timing_path}"
+            return nil
+          end
+          unless Polyrun::Partition::Plan.cost_strategy?(strategy) || Polyrun::Partition::Plan.hrw_strategy?(strategy)
+            Polyrun::Log.warn "polyrun plan: using cost_binpack (timing data present)" if @verbose
+            strategy = "cost_binpack"
+          end
+          [costs, strategy]
+        elsif Polyrun::Partition::Plan.cost_strategy?(strategy)
+          Polyrun::Log.warn "polyrun plan: --timing or partition.timing_file required for strategy #{strategy}"
+          nil
+        else
+          [nil, strategy]
+        end
+      end
+    end
+  end
+end