Class: Ace::TestRunner::Molecules::PatternResolver

Inherits:
Object
  • Object
show all
Defined in:
lib/ace/test_runner/molecules/pattern_resolver.rb

Constant Summary collapse

INTERNAL_PATTERN_LABELS = 
{
  "feat_tests" => "feat"
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config) ⇒ PatternResolver

Returns a new instance of PatternResolver.



13
14
15
16
17
18
 
# File 'lib/ace/test_runner/molecules/pattern_resolver.rb', line 13

def initialize(config)
  @config = config
  @patterns = normalize_keys(config.patterns || {})
  @targets = normalize_keys(config.targets || {})
  @using_catch_all = false
end

Instance Attribute Details

#using_catch_all ⇒ Object (readonly)

Returns the value of attribute using_catch_all.



11
12
13
 
# File 'lib/ace/test_runner/molecules/pattern_resolver.rb', line 11

def using_catch_all
  @using_catch_all
end

Instance Method Details

#available_targets ⇒ Object 



69
70
71
72
73
74
 
# File 'lib/ace/test_runner/molecules/pattern_resolver.rb', line 69

def available_targets
  (@targets.keys + @patterns.keys)
    .map(&:to_s)
    .reject { |name| INTERNAL_PATTERN_LABELS.key?(name) }
    .sort
end

#classify_file(file_path) ⇒ Object 



76
77
78
79
80
81
82
83
 
# File 'lib/ace/test_runner/molecules/pattern_resolver.rb', line 76

def classify_file(file_path)
  @patterns.each do |name, pattern|
    if File.fnmatch?(pattern, file_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
      return display_name_for(name)
    end
  end
  "other"
end

#resolve_multiple_targets(targets) ⇒ Object 



41
42
43
 
# File 'lib/ace/test_runner/molecules/pattern_resolver.rb', line 41

def resolve_multiple_targets(targets)
  targets.flat_map { |target| resolve_target(target) }.uniq
end

#resolve_target(target) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/ace/test_runner/molecules/pattern_resolver.rb', line 20

def resolve_target(target)
  return resolve_named_target("fast") if target.nil?
  return resolve_all_files if target == "all"
  return [target] if File.exist?(target)

  # Normalize target to string for consistent lookup
  target_key = target.to_s
  raise_unsupported_target_error(target_key) if %w[e2e all-with-e2e system].include?(target_key)

  if @targets.key?(target_key)
    resolve_named_target(target_key)
  elsif @patterns.key?(target_key)
    expand_pattern(@patterns[target_key])
  elsif looks_like_file_path?(target)
    raise ArgumentError, "File not found: #{target}. " \
      "Make sure you're running from the correct directory or use an absolute path."
  else
    raise ArgumentError, "Unknown target: #{target}. Available targets: #{available_targets.join(", ")}"
  end
end

#resolve_target_sequential(target_name, seen = []) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/ace/test_runner/molecules/pattern_resolver.rb', line 45

def resolve_target_sequential(target_name, seen = [])
  target_key = target_name.to_s
  if seen.include?(target_key)
    raise ArgumentError, "Cyclic test target definition detected: #{(seen + [target_key]).join(' -> ')}"
  end

  target_members = @targets[target_key]
  return [] unless target_members

  target_members.flat_map do |member|
    member_key = member.to_s

    if @targets.key?(member_key)
      resolve_target_sequential(member_key, seen + [target_key])
    elsif @patterns.key?(member_key)
      files = expand_pattern(@patterns[member_key])
      files.empty? ? [] : [{name: display_name_for(member_key), files: files}]
    else
      files = expand_pattern(member)
      files.empty? ? [] : [{name: "other", files: files}]
    end
  end
end