Class: Ace::Git::Worktree::Molecules::CleanupPrResolver

Inherits:
Object
  • Object
show all
Defined in:
lib/ace/git/worktree/molecules/cleanup_pr_resolver.rb

Overview

Resolves PR evidence for candidate branches through the registered forge provider to prove safe merge cleanup.

Only confirmed remote merge evidence (:merged) can prove removal; object states (:no_pr, :open, :closed_unmerged) and transport failures (:offline, :authentication_error, :malformed) always retain the candidate. Local ancestry proof is handled by the reporter before this resolver is consulted.

Instance Method Summary collapse

Constructor Details

#initialize(target:, target_sha:, offline: false, server_name: nil, use_default: false, remote_name: nil, timeout: nil, runner: nil) ⇒ CleanupPrResolver

Returns a new instance of CleanupPrResolver.

Parameters:

  • target (String) —

    base ref the PR must have targeted

  • target_sha (String) —

    commit SHA of the target

  • offline (Boolean) (defaults to: false) —

    skip provider evidence entirely

  • server_name (String, nil) (defaults to: nil) —

    explicit server selection

  • use_default (Boolean) (defaults to: false) —

    resolve the configured default server

  • remote_name (String, nil) (defaults to: nil) —

    remote used for fallback resolution

  • timeout (Integer, nil) (defaults to: nil) —

    provider timeout

  • runner (Proc, nil) (defaults to: nil) —

    injectable provider runner (tests)



28
29
30
31
32
33
34
35
36
 
# File 'lib/ace/git/worktree/molecules/cleanup_pr_resolver.rb', line 28

def initialize(target:, target_sha:, offline: false, server_name: nil, use_default: false,
  remote_name: nil, timeout: nil, runner: nil)
  @target = target
  @target_sha = target_sha
  @offline = offline
  @selection = {server_name: server_name, use_default: use_default, remote_name: remote_name}
  @timeout = timeout
  @runner = runner
end

Instance Method Details

#classify(branch, candidate_sha) ⇒ Hash

Classify a candidate branch with provider PR evidence.

Parameters:

  • branch (String) —

    the branch name (e.g. "feature")

  • candidate_sha (String) —

    the commit SHA of the candidate

Returns:

  • (Hash) —

    proof classification; :status is one of Ace::Git::CLEANUP_PROOF_STATUSES



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/ace/git/worktree/molecules/cleanup_pr_resolver.rb', line 51

def classify(branch, candidate_sha)
  return unproven_result(:no_pr, "provider_disabled") if @offline

  evidence = fetch_merged_evidence(branch)
  return failure_result(evidence) if evidence.is_a?(Hash) # transport failure marker

  return unproven_result(:no_pr) unless evidence
  return unproven_result(:open) if evidence.state == :open
  return unproven_result(:closed_unmerged) if evidence.state == :closed
  return unproven_result(:no_pr, "state_unavailable") unless evidence.state == :merged
  return unproven_result(:merged, "merge_commit_unavailable") unless evidence.merge_commit_sha
  return unproven_result(:merged, "merge_commit_unreachable") unless ancestor?(evidence.merge_commit_sha, @target_sha)

  merge_commit_sha = evidence.merge_commit_sha
  pr_head_sha = evidence.head_sha

  if candidate_sha == pr_head_sha
    proof_result(evidence, "exact_merged_pr_head", candidate_sha, pr_head_sha, merge_commit_sha)
  elsif patch_equivalent?(candidate_sha, merge_commit_sha)
    proof_result(evidence, "stable_patch_equivalence", candidate_sha, pr_head_sha, merge_commit_sha)
  else
    {
      status: :merged,
      proof: nil,
      pr: evidence.number,
      pr_url: evidence.url,
      candidate_head: candidate_sha,
      merged_head: pr_head_sha,
      merge_commit: merge_commit_sha,
      target_reachable: true,
      provider_status: "available",
      action: "retain",
      retention_reason: "patch_mismatch"
    }
  end
end

#resolved_server ⇒ Ace::Git::ResolvedServer?

Returns the server resolved for provider evidence; nil when unresolvable (local proof only).

Returns:

  • (Ace::Git::ResolvedServer, nil) —

    the server resolved for provider evidence; nil when unresolvable (local proof only)



40
41
42
43
 
# File 'lib/ace/git/worktree/molecules/cleanup_pr_resolver.rb', line 40

def resolved_server
  resolve_provider
  @resolved_server
end