isotarp 0.1.12

Identify which tests provide code coverage of which lines, uniquness, and redundancy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use wildmatch::WildMatch;

// Categorize patterns by type for more efficient processing
fn categorize_patterns(
    patterns: &[String],
) -> (Vec<String>, Vec<String>, Vec<String>, Vec<String>) {
    let mut exact_patterns = Vec::new();
    let mut exact_names = Vec::new();
    let mut path_wildcard_patterns = Vec::new();
    let mut name_wildcard_patterns = Vec::new();

    for pattern in patterns {
        if pattern.contains('*') || pattern.contains('?') {
            if pattern.contains("::") {
                path_wildcard_patterns.push(pattern.clone());
            } else {
                name_wildcard_patterns.push(pattern.clone());
            }
        } else if pattern.contains("::") {
            exact_patterns.push(pattern.clone());
        } else {
            exact_names.push(pattern.clone());
        }
    }

    (
        exact_patterns,
        exact_names,
        path_wildcard_patterns,
        name_wildcard_patterns,
    )
}

// Main utility function to resolve test patterns to test names
pub fn resolve_test_patterns(
    available_tests: &[String],
    patterns: &[String],
) -> (Vec<String>, Vec<String>) {
    let mut selected_tests = Vec::new();
    let mut invalid_patterns = Vec::new();

    // Categorize patterns first
    let (exact_patterns, exact_names, path_wildcard_patterns, name_wildcard_patterns) =
        categorize_patterns(patterns);

    // Process exact matches first (most efficient)
    for pattern in exact_patterns {
        if available_tests.contains(&pattern) {
            selected_tests.push(pattern.clone());
        } else {
            invalid_patterns.push(pattern);
        }
    }

    // Process exact name matches
    for pattern in exact_names {
        let matches = match_test_by_name(available_tests, &pattern);
        if !matches.is_empty() {
            selected_tests.extend(matches);
        } else {
            invalid_patterns.push(pattern);
        }
    }

    // Process path wildcard patterns
    for pattern in path_wildcard_patterns {
        let matches = match_test_by_path(available_tests, &pattern);
        if !matches.is_empty() {
            selected_tests.extend(matches);
        } else {
            invalid_patterns.push(pattern);
        }
    }

    // Process name wildcard patterns
    for pattern in name_wildcard_patterns {
        let matches = match_test_by_name(available_tests, &pattern);
        if !matches.is_empty() {
            selected_tests.extend(matches);
        } else {
            invalid_patterns.push(pattern);
        }
    }

    // Remove duplicates
    selected_tests.sort();
    selected_tests.dedup();

    (selected_tests, invalid_patterns)
}

// Match tests by their full path (including ::)
fn match_test_by_path(available_tests: &[String], pattern: &str) -> Vec<String> {
    let wildcard = WildMatch::new(pattern);
    available_tests
        .iter()
        .filter(|test| wildcard.matches(test))
        .cloned()
        .collect()
}

// Match tests by just their name (part after the last ::)
fn match_test_by_name(available_tests: &[String], pattern: &str) -> Vec<String> {
    let wildcard = WildMatch::new(pattern);
    available_tests
        .iter()
        .filter(|test| {
            if let Some(test_name) = test.split("::").last() {
                wildcard.matches(test_name)
            } else {
                false
            }
        })
        .cloned()
        .collect()
}