Class: Ace::Task::Molecules::TaskResolver

Inherits:
Object
  • Object
show all
Defined in:
lib/ace/task/molecules/task_resolver.rb

Overview

Wraps ShortcutResolver for task-format IDs (9-char formatted IDs like “8pp.t.q7w”).

Normalizes various reference forms before resolving:

"8pp.t.q7w"    → full ID lookup (9 chars)
"t.q7w"        → strip marker, suffix lookup "q7w"
"q7w"          → bare suffix lookup
"8pp.t.q7w.a"  → subtask lookup (11 chars: parent + ".{char}")

Constant Summary collapse

FULL_ID_LENGTH =

Task formatted IDs are 9 chars: “8pp.t.q7w”

9
SHORT_REF_PATTERN =

Short reference pattern: “t.q7w” → extract suffix “q7w”

/^[a-z]\.([0-9a-z]{3})$/
SUBTASK_REF_PATTERN =

Subtask reference pattern: “8pp.t.q7w.a” (parent ID + dot + single char)

/^([0-9a-z]{3}\.[a-z]\.[0-9a-z]{3})\.([a-z0-9])$/
SHORT_SUBTASK_REF_PATTERN =

Short subtask reference: “q7w.a” or “t.q7w.a” (suffix + subtask char)

/^(?:[a-z]\.)?([0-9a-z]{3})\.([a-z0-9])$/

Instance Method Summary collapse

Constructor Details

#initialize(scan_results) ⇒ TaskResolver

Returns a new instance of TaskResolver.

Parameters:

  • scan_results (Array<ScanResult>) —

    Scan results to resolve against



29
30
31
32
33
34
35
 
# File 'lib/ace/task/molecules/task_resolver.rb', line 29

def initialize(scan_results)
  @scan_results = scan_results
  @resolver = Ace::Support::Items::Molecules::ShortcutResolver.new(
    scan_results,
    full_id_length: FULL_ID_LENGTH
  )
end

Instance Method Details

#resolve(ref, on_ambiguity: nil) ⇒ ScanResult?

Resolve a task reference to a ScanResult. Handles full IDs, shortcuts, and subtask references.

Parameters:

  • ref (String) —

    Task reference (full ID, short, suffix, or subtask)

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

    Called with array of matches on ambiguity

Returns:

  • (ScanResult, nil) 


43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/ace/task/molecules/task_resolver.rb', line 43

def resolve(ref, on_ambiguity: nil)
  return nil if ref.nil? || ref.empty?

  cleaned = ref.strip.downcase

  # Check for full subtask reference first: "8pp.t.q7w.a"
  if (subtask_match = cleaned.match(SUBTASK_REF_PATTERN))
    return resolve_subtask(subtask_match[1], subtask_match[2])
  end

  # Check for short subtask reference: "q7w.a" or "t.q7w.a"
  if (short_sub = cleaned.match(SHORT_SUBTASK_REF_PATTERN))
    suffix = short_sub[1]
    subtask_char = short_sub[2]
    parent_result = @resolver.resolve(suffix)
    return resolve_subtask(parent_result.id, subtask_char) if parent_result
  end

  normalized = normalize_ref(cleaned)
  @resolver.resolve(normalized, on_ambiguity: on_ambiguity)
end