commit 63cc39016d5601d608749bf6d999f1f0e22bd5e9
parent 7b92123f283d2fd54d44caedd060caebd97b1d9b
Author: Asher Morgan <59518073+ashermorgan@users.noreply.github.com>
Date: Tue, 18 Jun 2024 11:43:07 -0700
Update tags_match function parameter types
Diffstat:
| M | src/tags.rs | | | 112 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
1 file changed, 56 insertions(+), 56 deletions(-)
diff --git a/src/tags.rs b/src/tags.rs
@@ -1,31 +1,30 @@
-/// Checks if a set of tags matches a set of rules
+/// Checks if a list of tags matches a list of tag rules
///
/// Rules and tags are both specified as strings. Each rule contains one or more
-/// desired tags separated by `|`. A list of tags matches a set of rules if each
-/// rule contains at least one tag that appears in the list of tags. The results
-/// of rules prefixed with `^` will be negated. An empty list of rules will
-/// match any list of tags.
+/// desired tags separated by `|`. A list of tags matches a list of rules if
+/// each rule contains at least one tag that appears in the list of tags. The
+/// results of rules prefixed with `^` will be negated. Any list of tags will
+/// match an empty list of tag rules. An empty list of tags will only match an
+/// empty list of tag rules.
///
/// ```
-/// let rules = ["linux|macos", "system", "^work"].map(|x| x.to_string());
-/// let tags_1 = ["macos", "system", "user"].map(|x| x.to_string());
-/// let tags_2 = ["linux", "system", "work"].map(|x| x.to_string());
+/// let rules = ["linux|macos", "system", "^work"];
+/// let tags_1 = ["macos", "system", "user"];
+/// let tags_2 = ["linux", "system", "work"];
/// assert_eq!(tags_match(&rules, &tags_1), true);
/// assert_eq!(tags_match(&rules, &tags_2), false);
/// ```
-pub fn tags_match(rules: &[String], tags: &[String]) -> bool {
+pub fn tags_match<S: AsRef<str>>(rules: &[S], tags: &[S]) -> bool {
for rule in rules.iter() {
- let is_negated = rule.chars().nth(0) == Some('^');
- let _rule: &str;
+ let mut _rule = rule.as_ref();
+ let is_negated = _rule.chars().nth(0) == Some('^');
if is_negated {
- _rule = &rule[1..]; // Strip leading '^'
- } else {
- _rule = &rule;
+ _rule = &_rule[1..]; // Strip leading '^'
}
let tag_found = _rule.split("|").any(|subrule| {
tags.iter().any(|tag| {
- tag == subrule
+ tag.as_ref() == subrule
})
});
@@ -43,16 +42,17 @@ mod tests {
#[test]
fn tags_match_empty_parameters() {
- let tags_1 = ["linux", "user"].map(|x| x.to_string());
- assert_eq!(tags_match(&[], &[]), true);
- assert_eq!(tags_match(&[], &tags_1), true);
- assert_eq!(tags_match(&tags_1, &[]), false);
+ let tags_1 = [];
+ let tags_2 = ["linux", "user"];
+ assert_eq!(tags_match(&tags_1, &tags_1), true);
+ assert_eq!(tags_match(&tags_1, &tags_2), true);
+ assert_eq!(tags_match(&tags_2, &tags_1), false);
}
#[test]
fn tags_match_one_match() {
- let tags_1 = ["linux"].map(|x| x.to_string());
- let tags_2 = ["linux", "windows"].map(|x| x.to_string());
+ let tags_1 = ["linux"];
+ let tags_2 = ["linux", "windows"];
assert_eq!(tags_match(&tags_1.clone(), &tags_1.clone()), true);
assert_eq!(tags_match(&tags_1.clone(), &tags_2.clone()), true);
@@ -62,8 +62,8 @@ mod tests {
#[test]
fn tags_match_two_matches() {
- let tags_1 = ["linux", "user"].map(|x| x.to_string());
- let tags_2 = ["linux", "user", "windows"].map(|x| x.to_string());
+ let tags_1 = ["linux", "user"];
+ let tags_2 = ["linux", "user", "windows"];
assert_eq!(tags_match(&tags_1.clone(), &tags_1.clone()), true);
assert_eq!(tags_match(&tags_1.clone(), &tags_2.clone()), true);
@@ -73,11 +73,11 @@ mod tests {
#[test]
fn tags_match_negated() {
- let rules = ["^linux"].map(|x| x.to_string());
- let tags_1 = ["linux"].map(|x| x.to_string());
- let tags_2 = ["windows"].map(|x| x.to_string());
- let tags_3 = ["macos"].map(|x| x.to_string());
- let tags_4 = ["linux", "macos"].map(|x| x.to_string());
+ let rules = ["^linux"];
+ let tags_1 = ["linux"];
+ let tags_2 = ["windows"];
+ let tags_3 = ["macos"];
+ let tags_4 = ["linux", "macos"];
assert_eq!(tags_match(&rules.clone(), &tags_1.clone()), false);
assert_eq!(tags_match(&rules.clone(), &tags_2.clone()), true);
@@ -87,12 +87,12 @@ mod tests {
#[test]
fn tags_match_negated_two_rules() {
- let rules_1 = ["^linux", "^user"].map(|x| x.to_string());
- let rules_2 = ["^linux", "user"].map(|x| x.to_string());
- let tags_1 = ["linux", "system"].map(|x| x.to_string());
- let tags_2 = ["windows", "user"].map(|x| x.to_string());
- let tags_3 = ["macos", "system"].map(|x| x.to_string());
- let tags_4 = ["linux", "macos", "user"].map(|x| x.to_string());
+ let rules_1 = ["^linux", "^user"];
+ let rules_2 = ["^linux", "user"];
+ let tags_1 = ["linux", "system"];
+ let tags_2 = ["windows", "user"];
+ let tags_3 = ["macos", "system"];
+ let tags_4 = ["linux", "macos", "user"];
assert_eq!(tags_match(&rules_1.clone(), &tags_1.clone()), false);
assert_eq!(tags_match(&rules_1.clone(), &tags_2.clone()), false);
@@ -106,11 +106,11 @@ mod tests {
#[test]
fn tags_match_union() {
- let rules = ["linux|macos"].map(|x| x.to_string());
- let tags_1 = ["linux"].map(|x| x.to_string());
- let tags_2 = ["macos"].map(|x| x.to_string());
- let tags_3 = ["linux", "macos"].map(|x| x.to_string());
- let tags_4 = ["windows"].map(|x| x.to_string());
+ let rules = ["linux|macos"];
+ let tags_1 = ["linux"];
+ let tags_2 = ["macos"];
+ let tags_3 = ["linux", "macos"];
+ let tags_4 = ["windows"];
assert_eq!(tags_match(&rules.clone(), &tags_1.clone()), true);
assert_eq!(tags_match(&rules.clone(), &tags_2.clone()), true);
@@ -120,12 +120,12 @@ mod tests {
#[test]
fn tags_match_union_two_rules() {
- let rules_1 = ["linux|macos", "user|system"].map(|x| x.to_string());
- let rules_2 = ["linux|macos", "user"].map(|x| x.to_string());
- let tags_1 = ["user", "linux"].map(|x| x.to_string());
- let tags_2 = ["system", "macos"].map(|x| x.to_string());
- let tags_3 = ["user", "linux", "macos"].map(|x| x.to_string());
- let tags_4 = ["system", "windows"].map(|x| x.to_string());
+ let rules_1 = ["linux|macos", "user|system"];
+ let rules_2 = ["linux|macos", "user"];
+ let tags_1 = ["user", "linux"];
+ let tags_2 = ["system", "macos"];
+ let tags_3 = ["user", "linux", "macos"];
+ let tags_4 = ["system", "windows"];
assert_eq!(tags_match(&rules_1.clone(), &tags_1.clone()), true);
assert_eq!(tags_match(&rules_1.clone(), &tags_2.clone()), true);
@@ -139,11 +139,11 @@ mod tests {
#[test]
fn tags_match_union_negated() {
- let rules = ["^linux|macos"].map(|x| x.to_string());
- let tags_1 = ["linux"].map(|x| x.to_string());
- let tags_2 = ["macos"].map(|x| x.to_string());
- let tags_3 = ["linux", "macos"].map(|x| x.to_string());
- let tags_4 = ["windows"].map(|x| x.to_string());
+ let rules = ["^linux|macos"];
+ let tags_1 = ["linux"];
+ let tags_2 = ["macos"];
+ let tags_3 = ["linux", "macos"];
+ let tags_4 = ["windows"];
assert_eq!(tags_match(&rules.clone(), &tags_1.clone()), false);
assert_eq!(tags_match(&rules.clone(), &tags_2.clone()), false);
@@ -153,12 +153,12 @@ mod tests {
#[test]
fn tags_match_union_negated_two_rules() {
- let rules_1 = ["^linux|macos", "^user"].map(|x| x.to_string());
- let rules_2 = ["^linux|macos", "user|system"].map(|x| x.to_string());
- let rules_3 = ["^linux|macos", "user"].map(|x| x.to_string());
- let tags_1 = ["linux", "macos", "system"].map(|x| x.to_string());
- let tags_2 = ["windows", "user"].map(|x| x.to_string());
- let tags_3 = ["windows", "system"].map(|x| x.to_string());
+ let rules_1 = ["^linux|macos", "^user"];
+ let rules_2 = ["^linux|macos", "user|system"];
+ let rules_3 = ["^linux|macos", "user"];
+ let tags_1 = ["linux", "macos", "system"];
+ let tags_2 = ["windows", "user"];
+ let tags_3 = ["windows", "system"];
assert_eq!(tags_match(&rules_1.clone(), &tags_1.clone()), false);
assert_eq!(tags_match(&rules_1.clone(), &tags_2.clone()), false);
