feat(tags): tag expressions (AND / NOT) and file-level @tags by Chemaclass · Pull Request #1035 · TypedDevs/bashunit

Chemaclass · 2026-08-09T20:06:33Z

🤔 Background

Related #1008

Tag selection was weaker than the systems people migrate from: --tag was OR-only with no negation, and tags were per-function only — tagging a whole file meant repeating # @tag above every test.

💡 Changes

# @tags a b applies to every test in the file, unioned with per-function # @tag and deduplicated. Collected in the same single awk pass and buffered to END, so a # @tags line placed below the functions still applies to them
--tag accepts a&&b (AND) and !a (NOT), combinable as a&&!b. !a matches untagged tests, which meant dropping the early "no tags means no match" short-circuit
Repeated --tag flags keep OR semantics between expressions (no behaviour change for existing users), and --exclude-tag still wins
Malformed expressions are rejected at parse time with a non-zero exit

The bug worth calling out

--tag 'slow&&' reads as valid and used to silently evaluate as plain slow: consuming the && emptied the remainder, so the while [ -n "$rest" ] loop ended before the empty trailing term was ever checked. Both the evaluator and the validator now always consume one term per iteration and stop only after the last, so the empty term surfaces. The test that first covered this only used '&&', which was caught — a separate case now pins the trailing form.

Verification

Mutation-tested: ignoring negation fails 7 tests, turning AND into OR fails 16, dropping file tags fails 6. Green on the Bash 3.2 floor. Tags containing spaces (# @tag needs db) still select and negate correctly.

Selection is asserted through --list (#1007) rather than by parsing run output.

--tag was OR-only with no negation, and tags were per-function only, so tagging a whole file meant repeating `# @tag` above every test. `# @tags a b` now applies to every test in the file, unioned with per-function `# @tag` and deduplicated. It is collected in the same single awk pass, buffered to END so a `# @tags` line below the functions still applies to them. A single --tag value accepts `a&&b` and `!a`, combinable as `a&&!b`. Repeated --tag flags arrive comma-joined and keep OR semantics between expressions, so existing usage is unchanged, and --exclude-tag still wins. `!a` matches untagged tests, which required dropping the early "no tags means no match" short-circuit. A malformed expression is rejected at parse time with a non-zero exit. The trailing-separator case is the one that mattered: `a&&` reads as valid and used to evaluate as plain `a`, because consuming the separator emptied the remainder and ended the loop before the empty term was checked. Closes#1008

Chemaclass · 2026-08-09T20:06:33Z

🤔 Background

Related #1008

Tag selection was weaker than the systems people migrate from: --tag was OR-only with no negation, and tags were per-function only — tagging a whole file meant repeating # @tag above every test.

💡 Changes

# @tags a b applies to every test in the file, unioned with per-function # @tag and deduplicated. Collected in the same single awk pass and buffered to END, so a # @tags line placed below the functions still applies to them
--tag accepts a&&b (AND) and !a (NOT), combinable as a&&!b. !a matches untagged tests, which meant dropping the early "no tags means no match" short-circuit
Repeated --tag flags keep OR semantics between expressions (no behaviour change for existing users), and --exclude-tag still wins
Malformed expressions are rejected at parse time with a non-zero exit

The bug worth calling out

--tag 'slow&&' reads as valid and used to silently evaluate as plain slow: consuming the && emptied the remainder, so the while [ -n "$rest" ] loop ended before the empty trailing term was ever checked. Both the evaluator and the validator now always consume one term per iteration and stop only after the last, so the empty term surfaces. The test that first covered this only used '&&', which was caught — a separate case now pins the trailing form.

Verification

Mutation-tested: ignoring negation fails 7 tests, turning AND into OR fails 16, dropping file tags fails 6. Green on the Bash 3.2 floor. Tags containing spaces (# @tag needs db) still select and negate correctly.

Selection is asserted through --list (#1007) rather than by parsing run output.

--tag was OR-only with no negation, and tags were per-function only, so tagging a whole file meant repeating `# @tag` above every test. `# @tags a b` now applies to every test in the file, unioned with per-function `# @tag` and deduplicated. It is collected in the same single awk pass, buffered to END so a `# @tags` line below the functions still applies to them. A single --tag value accepts `a&&b` and `!a`, combinable as `a&&!b`. Repeated --tag flags arrive comma-joined and keep OR semantics between expressions, so existing usage is unchanged, and --exclude-tag still wins. `!a` matches untagged tests, which required dropping the early "no tags means no match" short-circuit. A malformed expression is rejected at parse time with a non-zero exit. The trailing-separator case is the one that mattered: `a&&` reads as valid and used to evaluate as plain `a`, because consuming the separator emptied the remainder and ended the loop before the empty term was checked. Closes#1008

Chemaclass · 2026-08-09T20:06:33Z

🤔 Background

Related #1008

Tag selection was weaker than the systems people migrate from: --tag was OR-only with no negation, and tags were per-function only — tagging a whole file meant repeating # @tag above every test.

💡 Changes

# @tags a b applies to every test in the file, unioned with per-function # @tag and deduplicated. Collected in the same single awk pass and buffered to END, so a # @tags line placed below the functions still applies to them
--tag accepts a&&b (AND) and !a (NOT), combinable as a&&!b. !a matches untagged tests, which meant dropping the early "no tags means no match" short-circuit
Repeated --tag flags keep OR semantics between expressions (no behaviour change for existing users), and --exclude-tag still wins
Malformed expressions are rejected at parse time with a non-zero exit

The bug worth calling out

--tag 'slow&&' reads as valid and used to silently evaluate as plain slow: consuming the && emptied the remainder, so the while [ -n "$rest" ] loop ended before the empty trailing term was ever checked. Both the evaluator and the validator now always consume one term per iteration and stop only after the last, so the empty term surfaces. The test that first covered this only used '&&', which was caught — a separate case now pins the trailing form.

Verification

Mutation-tested: ignoring negation fails 7 tests, turning AND into OR fails 16, dropping file tags fails 6. Green on the Bash 3.2 floor. Tags containing spaces (# @tag needs db) still select and negate correctly.

Selection is asserted through --list (#1007) rather than by parsing run output.

--tag was OR-only with no negation, and tags were per-function only, so tagging a whole file meant repeating `# @tag` above every test. `# @tags a b` now applies to every test in the file, unioned with per-function `# @tag` and deduplicated. It is collected in the same single awk pass, buffered to END so a `# @tags` line below the functions still applies to them. A single --tag value accepts `a&&b` and `!a`, combinable as `a&&!b`. Repeated --tag flags arrive comma-joined and keep OR semantics between expressions, so existing usage is unchanged, and --exclude-tag still wins. `!a` matches untagged tests, which required dropping the early "no tags means no match" short-circuit. A malformed expression is rejected at parse time with a non-zero exit. The trailing-separator case is the one that mattered: `a&&` reads as valid and used to evaluate as plain `a`, because consuming the separator emptied the remainder and ended the loop before the empty term was checked. Closes#1008

Chemaclass · 2026-08-09T20:06:33Z

🤔 Background

Related #1008

Tag selection was weaker than the systems people migrate from: --tag was OR-only with no negation, and tags were per-function only — tagging a whole file meant repeating # @tag above every test.

💡 Changes

# @tags a b applies to every test in the file, unioned with per-function # @tag and deduplicated. Collected in the same single awk pass and buffered to END, so a # @tags line placed below the functions still applies to them
--tag accepts a&&b (AND) and !a (NOT), combinable as a&&!b. !a matches untagged tests, which meant dropping the early "no tags means no match" short-circuit
Repeated --tag flags keep OR semantics between expressions (no behaviour change for existing users), and --exclude-tag still wins
Malformed expressions are rejected at parse time with a non-zero exit

The bug worth calling out

--tag 'slow&&' reads as valid and used to silently evaluate as plain slow: consuming the && emptied the remainder, so the while [ -n "$rest" ] loop ended before the empty trailing term was ever checked. Both the evaluator and the validator now always consume one term per iteration and stop only after the last, so the empty term surfaces. The test that first covered this only used '&&', which was caught — a separate case now pins the trailing form.

Verification

Mutation-tested: ignoring negation fails 7 tests, turning AND into OR fails 16, dropping file tags fails 6. Green on the Bash 3.2 floor. Tags containing spaces (# @tag needs db) still select and negate correctly.

Selection is asserted through --list (#1007) rather than by parsing run output.

--tag was OR-only with no negation, and tags were per-function only, so tagging a whole file meant repeating `# @tag` above every test. `# @tags a b` now applies to every test in the file, unioned with per-function `# @tag` and deduplicated. It is collected in the same single awk pass, buffered to END so a `# @tags` line below the functions still applies to them. A single --tag value accepts `a&&b` and `!a`, combinable as `a&&!b`. Repeated --tag flags arrive comma-joined and keep OR semantics between expressions, so existing usage is unchanged, and --exclude-tag still wins. `!a` matches untagged tests, which required dropping the early "no tags means no match" short-circuit. A malformed expression is rejected at parse time with a non-zero exit. The trailing-separator case is the one that mattered: `a&&` reads as valid and used to evaluate as plain `a`, because consuming the separator emptied the remainder and ended the loop before the empty term was checked. Closes#1008

Chemaclass · 2026-08-09T20:06:33Z

🤔 Background

Related #1008

Tag selection was weaker than the systems people migrate from: --tag was OR-only with no negation, and tags were per-function only — tagging a whole file meant repeating # @tag above every test.

💡 Changes

# @tags a b applies to every test in the file, unioned with per-function # @tag and deduplicated. Collected in the same single awk pass and buffered to END, so a # @tags line placed below the functions still applies to them
--tag accepts a&&b (AND) and !a (NOT), combinable as a&&!b. !a matches untagged tests, which meant dropping the early "no tags means no match" short-circuit
Repeated --tag flags keep OR semantics between expressions (no behaviour change for existing users), and --exclude-tag still wins
Malformed expressions are rejected at parse time with a non-zero exit

The bug worth calling out

--tag 'slow&&' reads as valid and used to silently evaluate as plain slow: consuming the && emptied the remainder, so the while [ -n "$rest" ] loop ended before the empty trailing term was ever checked. Both the evaluator and the validator now always consume one term per iteration and stop only after the last, so the empty term surfaces. The test that first covered this only used '&&', which was caught — a separate case now pins the trailing form.

Verification

Mutation-tested: ignoring negation fails 7 tests, turning AND into OR fails 16, dropping file tags fails 6. Green on the Bash 3.2 floor. Tags containing spaces (# @tag needs db) still select and negate correctly.

Selection is asserted through --list (#1007) rather than by parsing run output.

--tag was OR-only with no negation, and tags were per-function only, so tagging a whole file meant repeating `# @tag` above every test. `# @tags a b` now applies to every test in the file, unioned with per-function `# @tag` and deduplicated. It is collected in the same single awk pass, buffered to END so a `# @tags` line below the functions still applies to them. A single --tag value accepts `a&&b` and `!a`, combinable as `a&&!b`. Repeated --tag flags arrive comma-joined and keep OR semantics between expressions, so existing usage is unchanged, and --exclude-tag still wins. `!a` matches untagged tests, which required dropping the early "no tags means no match" short-circuit. A malformed expression is rejected at parse time with a non-zero exit. The trailing-separator case is the one that mattered: `a&&` reads as valid and used to evaluate as plain `a`, because consuming the separator emptied the remainder and ended the loop before the empty term was checked. Closes#1008

Chemaclass · 2026-08-09T20:06:33Z

🤔 Background

Related #1008

Tag selection was weaker than the systems people migrate from: --tag was OR-only with no negation, and tags were per-function only — tagging a whole file meant repeating # @tag above every test.

💡 Changes

# @tags a b applies to every test in the file, unioned with per-function # @tag and deduplicated. Collected in the same single awk pass and buffered to END, so a # @tags line placed below the functions still applies to them
--tag accepts a&&b (AND) and !a (NOT), combinable as a&&!b. !a matches untagged tests, which meant dropping the early "no tags means no match" short-circuit
Repeated --tag flags keep OR semantics between expressions (no behaviour change for existing users), and --exclude-tag still wins
Malformed expressions are rejected at parse time with a non-zero exit

The bug worth calling out

--tag 'slow&&' reads as valid and used to silently evaluate as plain slow: consuming the && emptied the remainder, so the while [ -n "$rest" ] loop ended before the empty trailing term was ever checked. Both the evaluator and the validator now always consume one term per iteration and stop only after the last, so the empty term surfaces. The test that first covered this only used '&&', which was caught — a separate case now pins the trailing form.

Verification

Mutation-tested: ignoring negation fails 7 tests, turning AND into OR fails 16, dropping file tags fails 6. Green on the Bash 3.2 floor. Tags containing spaces (# @tag needs db) still select and negate correctly.

Selection is asserted through --list (#1007) rather than by parsing run output.

--tag was OR-only with no negation, and tags were per-function only, so tagging a whole file meant repeating `# @tag` above every test. `# @tags a b` now applies to every test in the file, unioned with per-function `# @tag` and deduplicated. It is collected in the same single awk pass, buffered to END so a `# @tags` line below the functions still applies to them. A single --tag value accepts `a&&b` and `!a`, combinable as `a&&!b`. Repeated --tag flags arrive comma-joined and keep OR semantics between expressions, so existing usage is unchanged, and --exclude-tag still wins. `!a` matches untagged tests, which required dropping the early "no tags means no match" short-circuit. A malformed expression is rejected at parse time with a non-zero exit. The trailing-separator case is the one that mattered: `a&&` reads as valid and used to evaluate as plain `a`, because consuming the separator emptied the remainder and ended the loop before the empty term was checked. Closes#1008

Chemaclass · 2026-08-09T20:06:33Z

🤔 Background

Related #1008

Tag selection was weaker than the systems people migrate from: --tag was OR-only with no negation, and tags were per-function only — tagging a whole file meant repeating # @tag above every test.

💡 Changes

# @tags a b applies to every test in the file, unioned with per-function # @tag and deduplicated. Collected in the same single awk pass and buffered to END, so a # @tags line placed below the functions still applies to them
--tag accepts a&&b (AND) and !a (NOT), combinable as a&&!b. !a matches untagged tests, which meant dropping the early "no tags means no match" short-circuit
Repeated --tag flags keep OR semantics between expressions (no behaviour change for existing users), and --exclude-tag still wins
Malformed expressions are rejected at parse time with a non-zero exit

The bug worth calling out

--tag 'slow&&' reads as valid and used to silently evaluate as plain slow: consuming the && emptied the remainder, so the while [ -n "$rest" ] loop ended before the empty trailing term was ever checked. Both the evaluator and the validator now always consume one term per iteration and stop only after the last, so the empty term surfaces. The test that first covered this only used '&&', which was caught — a separate case now pins the trailing form.

Verification

Mutation-tested: ignoring negation fails 7 tests, turning AND into OR fails 16, dropping file tags fails 6. Green on the Bash 3.2 floor. Tags containing spaces (# @tag needs db) still select and negate correctly.

Selection is asserted through --list (#1007) rather than by parsing run output.

--tag was OR-only with no negation, and tags were per-function only, so tagging a whole file meant repeating `# @tag` above every test. `# @tags a b` now applies to every test in the file, unioned with per-function `# @tag` and deduplicated. It is collected in the same single awk pass, buffered to END so a `# @tags` line below the functions still applies to them. A single --tag value accepts `a&&b` and `!a`, combinable as `a&&!b`. Repeated --tag flags arrive comma-joined and keep OR semantics between expressions, so existing usage is unchanged, and --exclude-tag still wins. `!a` matches untagged tests, which required dropping the early "no tags means no match" short-circuit. A malformed expression is rejected at parse time with a non-zero exit. The trailing-separator case is the one that mattered: `a&&` reads as valid and used to evaluate as plain `a`, because consuming the separator emptied the remainder and ended the loop before the empty term was checked. Closes#1008

Chemaclass · 2026-08-09T20:06:33Z

🤔 Background

Related #1008

Tag selection was weaker than the systems people migrate from: --tag was OR-only with no negation, and tags were per-function only — tagging a whole file meant repeating # @tag above every test.

💡 Changes

# @tags a b applies to every test in the file, unioned with per-function # @tag and deduplicated. Collected in the same single awk pass and buffered to END, so a # @tags line placed below the functions still applies to them
--tag accepts a&&b (AND) and !a (NOT), combinable as a&&!b. !a matches untagged tests, which meant dropping the early "no tags means no match" short-circuit
Repeated --tag flags keep OR semantics between expressions (no behaviour change for existing users), and --exclude-tag still wins
Malformed expressions are rejected at parse time with a non-zero exit

The bug worth calling out

--tag 'slow&&' reads as valid and used to silently evaluate as plain slow: consuming the && emptied the remainder, so the while [ -n "$rest" ] loop ended before the empty trailing term was ever checked. Both the evaluator and the validator now always consume one term per iteration and stop only after the last, so the empty term surfaces. The test that first covered this only used '&&', which was caught — a separate case now pins the trailing form.

Verification

Mutation-tested: ignoring negation fails 7 tests, turning AND into OR fails 16, dropping file tags fails 6. Green on the Bash 3.2 floor. Tags containing spaces (# @tag needs db) still select and negate correctly.

Selection is asserted through --list (#1007) rather than by parsing run output.

--tag was OR-only with no negation, and tags were per-function only, so tagging a whole file meant repeating `# @tag` above every test. `# @tags a b` now applies to every test in the file, unioned with per-function `# @tag` and deduplicated. It is collected in the same single awk pass, buffered to END so a `# @tags` line below the functions still applies to them. A single --tag value accepts `a&&b` and `!a`, combinable as `a&&!b`. Repeated --tag flags arrive comma-joined and keep OR semantics between expressions, so existing usage is unchanged, and --exclude-tag still wins. `!a` matches untagged tests, which required dropping the early "no tags means no match" short-circuit. A malformed expression is rejected at parse time with a non-zero exit. The trailing-separator case is the one that mattered: `a&&` reads as valid and used to evaluate as plain `a`, because consuming the separator emptied the remainder and ended the loop before the empty term was checked. Closes#1008

Chemaclass added the enhancement New feature or request label Aug 9, 2026

Chemaclass self-assigned this Aug 9, 2026