polyrun 2.2.5 → 2.2.6

data/lib/polyrun/cli.rb

@@ -108,6 +108,9 @@ module Polyrun
       )
 
       dispatch_cli_command(command, argv, config_path)
+    rescue Polyrun::Error => e
+      Polyrun::Log.warn "polyrun: #{e.message}"
+      2
     end
 
     private

data/lib/polyrun/config.rb

@@ -12,14 +12,19 @@ module Polyrun
     attr_reader :path, :raw
 
     def self.load(path: nil)
-      path = resolve_path(path)
+      explicit = path && !path.to_s.strip.empty?
+      resolved = resolve_path(path)
+      if explicit && !(resolved && File.file?(resolved))
+        raise Polyrun::Error, "polyrun config not found: #{path}"
+      end
+
       raw =
-        if path && File.file?(path)
-          YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: true) || {}
+        if resolved && File.file?(resolved)
+          YAML.safe_load_file(resolved, permitted_classes: [Symbol], aliases: true) || {}
         else
           {}
         end
-      new(path: path, raw: raw)
+      new(path: resolved, raw: raw)
     end
 
     def self.resolve_path(explicit)

data/lib/polyrun/coverage/example_diff.rb

@@ -131,14 +131,13 @@ module Polyrun
       end
 
       def collect_diff_paths(before_blob, after_blob, filter: nil)
-        keys = before_blob.keys.dup
-        after_blob.each_key do |path|
-          string_path = path.to_s
-          keys << string_path unless keys.include?(string_path)
-        end
-        return keys unless filter
+        keys = {}
+        before_blob.each_key { |path| keys[path.to_s] = true }
+        after_blob.each_key { |path| keys[path.to_s] = true }
+        list = keys.keys
+        return list unless filter
 
-        keys.select { |path| filter.include_path?(path) }
+        list.select { |path| filter.include_path?(path) }
       end
 
       def accumulate_line_delta(before_entry, after_lines)

data/lib/polyrun/coverage/merge/formatters_html.rb

@@ -23,7 +23,7 @@ module Polyrun
         )
         file_list_html = render_html_partial("file_list", file_rows_html: files.map { |file| html_file_list_row(file) }.join("\n"))
         file_sections_html = files.map { |file| render_html_partial("file_section", file: file) }.join("\n")
-        ERB.new(File.read(html_template_path, encoding: Encoding::UTF_8), trim_mode: "-").result_with_hash(
+        html_root_template_erb.result_with_hash(
           title: CGI.escapeHTML(title.to_s),
           generated_label: html_generated_label(generated_at),
           overview_html: overview_html,
@@ -56,9 +56,27 @@ module Polyrun
       end
 
       def render_html_partial(name, locals = {})
-        ERB.new(File.read(html_partial_path(name), encoding: Encoding::UTF_8), trim_mode: "-").result_with_hash(locals)
+        html_partial_erb(name).result_with_hash(locals)
       end
 
+      # rubocop:disable ThreadSafety/ClassInstanceVariable -- template cache keyed by partial name; process-local
+      def html_partial_erb(name)
+        @html_partial_erbs ||= {}
+        @html_partial_erbs[name] ||= ERB.new(
+          File.read(html_partial_path(name), encoding: Encoding::UTF_8),
+          trim_mode: "-"
+        )
+      end
+
+      def html_root_template_erb
+        @html_root_template_erb ||= ERB.new(
+          File.read(html_template_path, encoding: Encoding::UTF_8),
+          trim_mode: "-"
+        )
+      end
+      # rubocop:enable ThreadSafety/ClassInstanceVariable
+      private_class_method :html_partial_erb, :html_root_template_erb
+
       def html_file_payload(path, file, root)
         line_arr = line_array_from_file_entry(file) || []
         source_lines = html_source_lines(path, line_arr.length)

data/lib/polyrun/coverage/merge.rb

@@ -26,10 +26,16 @@ module Polyrun
       def merge_fragments(paths)
         return {blob: {}, meta: {}, groups: nil} if paths.empty?
 
-        docs = paths.map { |p| JSON.parse(File.read(p)) }
-        blobs = docs.map { |d| extract_coverage_blob(d) }
+        # Parse one fragment at a time: keep only meta + blob so peak RSS drops after each fold step.
+        metas = []
+        blobs = []
+        paths.each do |path|
+          doc = JSON.parse(File.read(path))
+          metas << extract_doc_meta(doc)
+          blobs << extract_coverage_blob(doc)
+        end
         merged_blob = merge_blob_tree(blobs)
-        merged_meta = merge_fragment_metas(docs)
+        merged_meta = merge_fragment_metas_from_metas(metas)
         merged_blob = apply_track_files_once_after_merge(merged_blob, merged_meta)
         groups_payload = recompute_groups_from_meta(merged_blob, merged_meta)
         {blob: merged_blob, meta: merged_meta, groups: groups_payload}

data/lib/polyrun/coverage/merge_fragment_meta.rb

@@ -4,7 +4,12 @@ module Polyrun
       module_function
 
       def merge_fragment_metas(docs)
-        metas = docs.map { |d| extract_doc_meta(d) }
+        merge_fragment_metas_from_metas(docs.map { |d| extract_doc_meta(d) })
+      end
+
+      def merge_fragment_metas_from_metas(metas)
+        return {} if metas.empty?
+
         base = metas.first.dup
         roots = metas.map { |m| m["polyrun_coverage_root"] }.compact
         grs = metas.map { |m| m["polyrun_coverage_groups"] }.compact

data/lib/polyrun/coverage/rails.rb

@@ -67,7 +67,7 @@ module Polyrun
         path = File.expand_path(path)
         return {} unless File.file?(path)
 
-        data = YAML.load_file(path)
+        data = YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: true)
         data.is_a?(Hash) ? stringify_keys(data) : {}
       end
 

data/lib/polyrun/database/clone_shards.rb

@@ -9,6 +9,7 @@ module Polyrun
       # See +provision!+ on the singleton class for options.
       def provision!(databases_hash, workers:, rails_root:, migrate: true, replace: true, force_drop: false, dry_run: false, silent: true)
         dh = databases_hash.is_a?(Hash) ? databases_hash : {}
+        ensure_postgresql!(dh)
         workers = Integer(workers)
         raise Polyrun::Error, "workers must be >= 1" if workers < 1
 
@@ -19,6 +20,16 @@ module Polyrun
         true
       end
 
+      def ensure_postgresql!(dh)
+        return if UrlBuilder::ConnectionInfer.postgresql?(dh)
+
+        adapter = UrlBuilder::ConnectionInfer.infer_adapter_name(dh)
+        raise Polyrun::Error,
+          "CloneShards is PostgreSQL-only (databases adapter is #{adapter}). " \
+          "Use polyrun env for URLs and provision shards yourself."
+      end
+      private_class_method :ensure_postgresql!
+
       def migrate_canonical_databases!(dh, rails_root, dry_run, silent)
         pt = (dh["template_db"] || dh[:template_db]).to_s
         if pt.empty?
@@ -37,6 +48,7 @@ module Polyrun
       private_class_method :migrate_canonical_databases!
 
       def create_shards_from_plan!(dh, workers, replace, force_drop, dry_run)
+        conn = UrlBuilder::Connection.resolve_connection(dh)
         if dry_run
           workers.times do |shard_index|
             plan = UrlBuilder.shard_database_plan(dh, shard_index: shard_index)
@@ -44,7 +56,7 @@ module Polyrun
               raise Polyrun::Error, "CloneShards: empty shard plan for shard_index=#{shard_index}"
             end
 
-            plan.each { |row| create_one_shard!(row, replace, force_drop, dry_run) }
+            plan.each { |row| create_one_shard!(row, replace, force_drop, dry_run, conn) }
           end
           return
         end
@@ -56,7 +68,7 @@ module Polyrun
               raise Polyrun::Error, "CloneShards: empty shard plan for shard_index=#{shard_index}"
             end
 
-            plan.each { |row| create_one_shard!(row, replace, force_drop, dry_run) }
+            plan.each { |row| create_one_shard!(row, replace, force_drop, dry_run, conn) }
           rescue => e
             raise Polyrun::Error, "CloneShards shard_index=#{shard_index}: #{e.message}"
           end
@@ -65,7 +77,7 @@ module Polyrun
       end
       private_class_method :create_shards_from_plan!
 
-      def create_one_shard!(row, replace, force_drop, dry_run)
+      def create_one_shard!(row, replace, force_drop, dry_run, conn)
         new_db = row[:new_db].to_s
         tmpl = row[:template_db].to_s
         if dry_run
@@ -74,10 +86,21 @@ module Polyrun
           return
         end
 
-        Provision.drop_database_if_exists!(database: new_db, force: force_drop) if replace
-        Provision.create_database_from_template!(new_db: new_db, template_db: tmpl)
+        opts = provision_connection_options(conn)
+        Provision.drop_database_if_exists!(database: new_db, force: force_drop, **opts) if replace
+        Provision.create_database_from_template!(new_db: new_db, template_db: tmpl, **opts)
       end
       private_class_method :create_one_shard!
+
+      def provision_connection_options(conn)
+        {
+          host: conn[:host],
+          port: conn[:port],
+          username: conn[:user],
+          password: conn[:password]
+        }
+      end
+      private_class_method :provision_connection_options
     end
   end
 end

data/lib/polyrun/database/provision.rb

@@ -14,7 +14,7 @@ module Polyrun
       end
 
       # +DROP DATABASE IF EXISTS name;+ — maintenance DB +postgres+ (or +maintenance_db+).
-      def drop_database_if_exists!(database:, host: nil, port: nil, username: nil, maintenance_db: "postgres", force: false)
+      def drop_database_if_exists!(database:, host: nil, port: nil, username: nil, password: nil, maintenance_db: "postgres", force: false)
         host ||= ENV["PGHOST"] || "localhost"
         port ||= ENV["PGPORT"] || "5432"
         username ||= ENV["PGUSER"] || "postgres"
@@ -25,26 +25,32 @@ module Polyrun
           else
             "DROP DATABASE IF EXISTS #{quote_ident(database)};"
           end
-        cmd = ["psql", "-U", username, "-h", host, "-p", port.to_s, "-d", maintenance_db, "-v", "ON_ERROR_STOP=1", "-c", sql]
-        _out, err, st = Open3.capture3(*cmd)
-        raise Polyrun::Error, "drop database failed: #{err}" unless st.success?
-
-        true
+        run_psql!(sql, host: host, port: port, username: username, password: password, maintenance_db: maintenance_db, failure_prefix: "drop database failed")
       end
 
       # CREATE DATABASE new_db TEMPLATE template_db — connects to maintenance DB +postgres+.
-      def create_database_from_template!(new_db:, template_db:, host: nil, port: nil, username: nil, maintenance_db: "postgres")
+      def create_database_from_template!(new_db:, template_db:, host: nil, port: nil, username: nil, password: nil, maintenance_db: "postgres")
         host ||= ENV["PGHOST"] || "localhost"
         port ||= ENV["PGPORT"] || "5432"
         username ||= ENV["PGUSER"] || "postgres"
 
         sql = "CREATE DATABASE #{quote_ident(new_db)} TEMPLATE #{quote_ident(template_db)};"
+        run_psql!(sql, host: host, port: port, username: username, password: password, maintenance_db: maintenance_db, failure_prefix: "create database failed")
+      end
+
+      def run_psql!(sql, host:, port:, username:, password:, maintenance_db:, failure_prefix:)
         cmd = ["psql", "-U", username, "-h", host, "-p", port.to_s, "-d", maintenance_db, "-v", "ON_ERROR_STOP=1", "-c", sql]
-        _out, err, st = Open3.capture3(*cmd)
-        raise Polyrun::Error, "create database failed: #{err}" unless st.success?
+        _out, err, st =
+          if password.nil? || password.to_s.empty?
+            Open3.capture3(*cmd)
+          else
+            Open3.capture3(ENV.to_h.merge("PGPASSWORD" => password.to_s), *cmd)
+          end
+        raise Polyrun::Error, "#{failure_prefix}: #{err}" unless st.success?
 
         true
       end
+      private_class_method :run_psql!
 
       # Runs +bin/rails db:prepare+ with merged ENV (+DATABASE_URL+ for primary, +CACHE_DATABASE_URL+, etc.).
       # Multi-DB Rails apps must pass all template URLs in one invocation so each DB uses its own +migrations_paths+.

data/lib/polyrun/database/url_builder/connection/infer.rb

@@ -29,6 +29,10 @@ module Polyrun
           "postgresql"
         end
 
+        def postgresql?(databases_hash)
+          infer_adapter_name(databases_hash.is_a?(Hash) ? databases_hash : {}) == "postgresql"
+        end
+
         def normalize_adapter_alias(name)
           case name
           when "postgres", "pg" then "postgresql"

data/lib/polyrun/database/url_builder.rb

@@ -48,7 +48,9 @@ module Polyrun
       end
 
       def template_prepare_env_shell_log(databases_hash)
-        template_prepare_env(databases_hash).sort.map { |k, v| "#{k}=#{Shellwords.escape(v.to_s)}" }.join(" ")
+        template_prepare_env(databases_hash).sort.map do |k, v|
+          "#{k}=#{Shellwords.escape(redact_url_userinfo_password(v.to_s))}"
+        end.join(" ")
       end
 
       def unique_template_migrate_urls(databases_hash)
@@ -111,6 +113,19 @@ module Polyrun
       def url_for_shard(databases_hash, shard_index:, connection: nil)
         dh = databases_hash.is_a?(Hash) ? databases_hash : {}
         conn = Connection.resolve_connection(dh)
+        pattern = shard_pattern(dh, connection)
+        validate_shard_db_pattern!(pattern)
+
+        dbname = pattern.to_s.gsub("%{shard}", Integer(shard_index).to_s).gsub("%<shard>d", format("%d", Integer(shard_index)))
+        template_name = template_database_name_for(dh, connection: connection)
+        if !template_name.to_s.empty? && dbname == template_name.to_s
+          raise Polyrun::Error,
+            "databases.shard_db_pattern resolves to template_db #{template_name.inspect} for shard #{shard_index}"
+        end
+        Connection.build_database_url(dbname, conn)
+      end
+
+      def shard_pattern(dh, connection)
         pattern =
           if connection
             conns = dh["connections"] || dh[:connections] || []
@@ -120,10 +135,23 @@ module Polyrun
             dh["shard_db_pattern"] || dh[:shard_db_pattern]
           end
         pattern ||= "app_test_%{shard}"
+        pattern
+      end
+      private_class_method :shard_pattern
 
-        dbname = pattern.to_s.gsub("%{shard}", Integer(shard_index).to_s).gsub("%<shard>d", format("%d", Integer(shard_index)))
-        Connection.build_database_url(dbname, conn)
+      def validate_shard_db_pattern!(pattern)
+        p = pattern.to_s
+        return if p.include?("%{shard}") || p.include?("%<shard>d")
+
+        raise Polyrun::Error, "databases.shard_db_pattern must include %{shard} or %<shard>d (got #{p.inspect})"
+      end
+      private_class_method :validate_shard_db_pattern!
+
+      def redact_url_userinfo_password(url)
+        s = url.to_s
+        s.sub(%r{\A([a-z][a-z0-9+.-]*://[^:/?#]+:)[^@/?#]+(@)}i, '\1***\2')
       end
+      private_class_method :redact_url_userinfo_password
 
       def env_exports_for_databases(databases_hash, shard_index:)
         dh = databases_hash.is_a?(Hash) ? databases_hash : {}

data/lib/polyrun/partition/plan.rb

@@ -110,11 +110,9 @@ module Polyrun
       end
 
       def default_weight
-        vals = @costs&.values || []
-        if vals.empty?
-          1.0
-        else
-          vals.sum / vals.size
+        @default_weight ||= begin
+          vals = @costs&.values || []
+          vals.empty? ? 1.0 : vals.sum / vals.size
         end
       end
 
@@ -193,13 +191,7 @@ module Polyrun
 
         out = {}
         map.each do |k, v|
-          key =
-            if @timing_granularity == :example
-              TimingKeys.normalize_locator(k.to_s, @root, :example)
-            else
-              File.expand_path(k.to_s, @root)
-            end
-          out[key] = Integer(v)
+          out[TimingKeys.normalize_locator(k.to_s, @root, @timing_granularity)] = Integer(v)
         end
         out
       end
@@ -209,13 +201,7 @@ module Polyrun
 
         c = {}
         costs.each do |k, v|
-          key =
-            if @timing_granularity == :example
-              TimingKeys.normalize_locator(k.to_s, @root, :example)
-            else
-              File.expand_path(k.to_s, @root)
-            end
-          c[key] = v.to_f
+          c[TimingKeys.normalize_locator(k.to_s, @root, @timing_granularity)] = v.to_f
         end
         c
       end
@@ -243,11 +229,7 @@ module Polyrun
       end
 
       def cost_lookup_key(path)
-        if @timing_granularity == :example
-          TimingKeys.normalize_locator(path, @root, :example)
-        else
-          File.expand_path(path, @root)
-        end
+        TimingKeys.normalize_locator(path, @root, @timing_granularity)
       end
 
       def cost_shards

data/lib/polyrun/partition/timing_diagnostics.rb

@@ -16,8 +16,9 @@ module Polyrun
         item_keys = items.map { |p| lookup_key(p, root, g) }
         cost_keys = costs&.keys || []
 
+        item_keys_set = item_keys.to_set
+        stale = cost_keys.reject { |k| item_keys_set.include?(k) }
         if g == :example
-          item_keys_set = item_keys.to_set
           cost_keys_set = cost_keys.to_set
           cost_file_keys_set = cost_keys.map { |k| file_from_locator(k) }.uniq.to_set
           known = item_keys.count do |ik|
@@ -26,11 +27,9 @@ module Polyrun
           missing = item_keys.reject do |ik|
             cost_keys_set.include?(ik) || cost_file_keys_set.include?(file_from_locator(ik))
           end
-          stale = cost_keys.reject { |k| item_keys_set.include?(k) }
         else
           known = item_keys.count { |k| costs&.key?(k) }
           missing = item_keys.reject { |k| costs&.key?(k) }
-          stale = cost_keys.reject { |k| item_keys.include?(k) }
         end
         total = item_keys.size