blockwatch-cli 0.15.0__tar.gz → 0.16.0__tar.gz

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/CHANGELOG.md

@@ -12,6 +12,39 @@ Releases up to and including v0.3.11 predate this file. Their notes live on the
 
 ## [Unreleased] - ReleaseDate
 
+## [0.16.0] - 2026-10-24
+
+### Changed
+
+- Without `same-as-pattern`, `same-as` compares each line that isn't blank as one value. Before, the whole block was
+  one value, so `same-as-mode` and `same-as-format` didn't work on a block of several lines. For example,
+  `same-as-mode="single"` passed with two lines, `subset` failed on a line that the target had, and `numeric` reported
+  that `1` and `2` together are not a number ([#179](https://github.com/mennanov/blockwatch/issues/179)).
+- Without `same-as-mode`, a block without `same-as-pattern` compares in `sequence` mode. So it still fails when its
+  lines differ from the target's or come in another order. A block with a pattern still compares in `set` mode.
+- A block without `same-as-pattern` now fails when its target's pattern finds a value more than once, or in another
+  order: `["1.2.3"] != ["1.2.3", "1.2.3"]`. Before, the default `set` mode ignored this. To keep the old result, add
+  `same-as-mode="set"`, or `same-as-mode="subset"` when the target may hold other values too.
+- `same-as` now fails on two empty blocks, as it does on a pattern that matches nothing. The message for both is
+  `this block or its target has no values to compare`.
+- `same-as-paths` no longer needs `same-as-pattern`. Without one, each line of the block must be a path, in sorted
+  order.
+- An attribute that changes how a validator works now stops the run on a block without the validator's main
+  attribute. Before, it did nothing there. For example, `same-as-mode="sequence"` on a target let values in another
+  order pass. The attributes are:
+  - `same-as-mode` and `same-as-format`, without `same-as` or `same-as-paths`;
+  - `same-as-pattern`, without `same-as`, `same-as-paths` or `name`, because only a block with a name can be a target;
+  - `keep-sorted-pattern` and `keep-sorted-format`, without `keep-sorted`;
+  - `line-count-pattern`, without `line-count`;
+  - `check-ai-pattern`, without `check-ai`;
+  - `check-lua-pattern` and `check-lua-timeout`, without `check-lua`.
+
+### Fixed
+
+- An empty alternative in braces now matches, so `{,sub/}a.yml` matches both `a.yml` and `sub/a.yml`. Before, it
+  matched only `sub/a.yml`, with no error. This was true of every glob: a `[[block]]` target, `same-as-paths`, the
+  `ignore` setting and `--ignore`, and a path argument ([#177](https://github.com/mennanov/blockwatch/issues/177)).
+
 ## [0.15.0] - 2026-10-21
 
 ### Changed

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/Cargo.lock

@@ -274,7 +274,7 @@ checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 
 [[package]]
 name = "blockwatch"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "anyhow",
  "assert-json-diff",

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "blockwatch"
-version = "0.15.0"
+version = "0.16.0"
 edition = "2024"
 repository = "https://github.com/mennanov/blockwatch"
 description = "Language agnostic linter that keeps your code and documentation in sync and valid"

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blockwatch-cli
-Version: 0.15.0
+Version: 0.16.0
 Summary: Language agnostic linter that keeps your code and documentation in sync and valid
 Keywords: linter,sync,drift,comments,agents
 Home-Page: https://github.com/mennanov/blockwatch

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/README.md

@@ -218,7 +218,7 @@ exclusions, and custom extension mappings.
 
 ```yaml
 - repo: https://github.com/mennanov/blockwatch
-  rev: v0.15.0  # Use latest release
+  rev: v0.16.0  # Use latest release
   hooks:
     - id: blockwatch
 ```

blockwatch_cli-0.16.0/clippy.toml

@@ -0,0 +1,11 @@
+# The integration tests run inside this repository, so a run would read its blockwatch.toml, which
+# skips tests/testdata.
+disallowed-macros = [
+    { path = "assert_cmd::cargo_bin_cmd", reason = "use common::cargo_bin_cmd!, which passes an empty config" },
+]
+# globset drops an empty alternative in braces by default, so `{,sub/}a.yml` would not match
+# `a.yml`.
+disallowed-methods = [
+    { path = "globset::Glob::new", reason = "use paths_glob::glob_builder, which keeps an empty alternative" },
+    { path = "globset::GlobBuilder::new", reason = "use paths_glob::glob_builder, which keeps an empty alternative" },
+]

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/docs/ci.md

@@ -19,7 +19,7 @@ To use [pre-commit](https://pre-commit.com), add the hook to `.pre-commit-config
 
 ```yaml
 - repo: https://github.com/mennanov/blockwatch
-  rev: v0.15.0  # Use latest release
+  rev: v0.16.0  # Use latest release
   hooks:
     - id: blockwatch
 ```
@@ -59,7 +59,7 @@ The `blockwatch` hook runs before the commit message exists, so it cannot see a
 
 ```yaml
 - repo: https://github.com/mennanov/blockwatch
-  rev: v0.15.0  # Use latest release
+  rev: v0.16.0  # Use latest release
   hooks:
     - id: blockwatch-commit-msg
 ```

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/docs/cli.md

@@ -557,15 +557,15 @@ Nothing else about the run changes: the same violations are found, and the exit
       "tool": {
         "driver": {
           "name": "blockwatch",
-          "version": "0.15.0",
-          "semanticVersion": "0.15.0",
+          "version": "0.16.0",
+          "semanticVersion": "0.16.0",
           "informationUri": "https://github.com/mennanov/blockwatch",
           "rules": [
             {
               "id": "keep-sorted",
               "name": "keep-sorted",
               "shortDescription": { "text": "Requires the lines of a block to stay in order." },
-              "helpUri": "https://github.com/mennanov/blockwatch/blob/v0.15.0/docs/validators/keep-sorted.md"
+              "helpUri": "https://github.com/mennanov/blockwatch/blob/v0.16.0/docs/validators/keep-sorted.md"
             }
           ]
         }
@@ -790,16 +790,16 @@ A trace stops where its validator stops, such as at the first line out of order.
 file, and `text` is that line trimmed, as the validator compares it. A key that holds what a violation reports has the
 name the violation's `data` gives it, such as `reason`.
 
-| Validator      | What it shows                                                                                                                                                                                                                                                                                                                                                                          |
-|----------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `same-as`      | `records`: each match of `same-as-pattern` in the block, with its `line`, the text the regex matched (`match`), and each named group after `same-as-format` (`groups`). `targets`: the `records` of each target, and the `reason` of its violation, or `null` when the two agree. `paths`: with `same-as-paths`, the `glob`, the paths it `matched`, their `records` and the `reason`. |
-| `keep-sorted`  | `lines`: each line read, with the `value` it compares, or `null` when `keep-sorted-pattern` skips the line. `format` and `order`.                                                                                                                                                                                                                                                      |
-| `keep-unique`  | `lines`, as for `keep-sorted`. A repeated value has `duplicate_of`: the line where it first appeared.                                                                                                                                                                                                                                                                                  |
-| `line-pattern` | `lines`: each line read, with the text `line-pattern` matched (`match`). A line that fails has `fails`: the check it fails. `forbidden_match` is the text `line-pattern-forbidden` found.                                                                                                                                                                                              |
-| `line-count`   | `lines`, as for `keep-sorted`. A line counts when its `value` isn't `null`. The number of lines counted (`actual`), and the rule (`op` and `expected`).                                                                                                                                                                                                                                |
-| `affects`      | Whether the diff changed the block (`block_changed`). For each target: whether the diff `changed` it, or the `reason` it doesn't resolve.                                                                                                                                                                                                                                              |
-| `check-lua`    | The `content` and the `affects` the script got, and the message it returned (`lua_error`), or `null` when it passed. `affects` is `ctx.affects` without the content of each target.                                                                                                                                                                                                    |
-| `check-ai`     | The `model`, the `prompt` sent and the `response`. Both are `null` when `check-ai-pattern` matched nothing, so no request was sent.                                                                                                                                                                                                                                                    |
+| Validator      | What it shows                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+|----------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `same-as`      | `records`: each match of `same-as-pattern` in the block, or each line without a pattern, with its `line`, the text the regex matched (`match`), and each named group after `same-as-format` (`groups`). `mode`: the `same-as-mode` it compared with. `targets`: the `records` of each target, and the `reason` of its violation, or `null` when the two agree. `paths`: with `same-as-paths`, the `glob`, the paths it `matched`, their `records` and the `reason`. |
+| `keep-sorted`  | `lines`: each line read, with the `value` it compares, or `null` when `keep-sorted-pattern` skips the line. `format` and `order`.                                                                                                                                                                                                                                                                                                                                   |
+| `keep-unique`  | `lines`, as for `keep-sorted`. A repeated value has `duplicate_of`: the line where it first appeared.                                                                                                                                                                                                                                                                                                                                                               |
+| `line-pattern` | `lines`: each line read, with the text `line-pattern` matched (`match`). A line that fails has `fails`: the check it fails. `forbidden_match` is the text `line-pattern-forbidden` found.                                                                                                                                                                                                                                                                           |
+| `line-count`   | `lines`, as for `keep-sorted`. A line counts when its `value` isn't `null`. The number of lines counted (`actual`), and the rule (`op` and `expected`).                                                                                                                                                                                                                                                                                                             |
+| `affects`      | Whether the diff changed the block (`block_changed`). For each target: whether the diff `changed` it, or the `reason` it doesn't resolve.                                                                                                                                                                                                                                                                                                                           |
+| `check-lua`    | The `content` and the `affects` the script got, and the message it returned (`lua_error`), or `null` when it passed. `affects` is `ctx.affects` without the content of each target.                                                                                                                                                                                                                                                                                 |
+| `check-ai`     | The `model`, the `prompt` sent and the `response`. Both are `null` when `check-ai-pattern` matched nothing, so no request was sent.                                                                                                                                                                                                                                                                                                                                 |
 
 ## Run Reports
 

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/docs/validators/check-ai.md

@@ -10,6 +10,9 @@ mention the company name", "no TODOs left", "the tone matches the rest of the pa
 | `check-ai`         | the condition, in natural language                        | —           |
 | `check-ai-pattern` | regex; every match's `(?P<value>…)` group, or whole match | whole block |
 
+`check-ai-pattern` works only next to `check-ai`. On a block without it, it stops the run, because it would do nothing
+there.
+
 ## Example
 
 ```html

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/docs/validators/check-lua.md

@@ -19,6 +19,9 @@ string when it fails.
 
 <!-- </block> -->
 
+`check-lua-pattern` and `check-lua-timeout` work only next to `check-lua`. On a block without it, they stop the run,
+because they would do nothing there.
+
 The script path must point to a file inside the repository. Paths that escape it — absolute paths outside the project,
 `../` traversal, or symlinks pointing outward — are rejected.
 

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/docs/validators/keep-sorted.md

@@ -10,6 +10,9 @@ Keeps a list ordered. Eliminates "please sort this" review nits.
 | `keep-sorted-pattern` | regex; the `(?P<value>…)` group, or the whole match | whole line |
 | `keep-sorted-format`  | `numeric`                                           | text       |
 
+`keep-sorted-pattern` and `keep-sorted-format` work only next to `keep-sorted`. On a block without it, they stop the
+run, because they would do nothing there.
+
 ## Example
 
 ```python

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/docs/validators/line-count.md

@@ -10,6 +10,9 @@ size of the enum it maps.
 | `line-count`         | `<N`, `<=N`, `==N`, `>=N`, `>N`            | —                        |
 | `line-count-pattern` | regex; a line counts when it gives a value | every line that has text |
 
+`line-count-pattern` works only next to `line-count`. On a block without it, it stops the run, because it would do
+nothing there.
+
 ## Example
 
 ```python

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/docs/validators/same-as.md

@@ -8,13 +8,17 @@ It runs on every scan, with or without a diff.
 
 ## Syntax
 
-| Attribute         | Value                                                                                | Default           |
-|-------------------|--------------------------------------------------------------------------------------|-------------------|
-| `same-as`         | One or more [targets](#targets), comma-separated                                     | —                 |
-| `same-as-paths`   | A [glob](#paths-as-targets) of paths to compare                                      | —                 |
-| `same-as-pattern` | A regex that picks the values to compare                                             | the whole content |
-| `same-as-mode`    | `set`, `sequence`, `single` or `subset`                                              | `set`             |
-| `same-as-format`  | `numeric`, `identifier` or `flat`, or [one for each group](#a-format-for-each-group) | text              |
+| Attribute         | Value                                                                                | Default                                  |
+|-------------------|--------------------------------------------------------------------------------------|------------------------------------------|
+| `same-as`         | One or more [targets](#targets), comma-separated                                     | —                                        |
+| `same-as-paths`   | A [glob](#paths-as-targets) of paths to compare                                      | —                                        |
+| `same-as-pattern` | A regex that picks the values to compare                                             | each line                                |
+| `same-as-mode`    | `set`, `sequence`, `single` or `subset`                                              | [`sequence` or `set`](#comparison-modes) |
+| `same-as-format`  | `numeric`, `identifier` or `flat`, or [one for each group](#a-format-for-each-group) | text                                     |
+
+`same-as-mode` and `same-as-format` work only next to `same-as` or `same-as-paths`. `same-as-pattern` also works next
+to `name`, because a block with a name can be a target. On any other block, they stop the run, because they would do
+nothing there.
 
 ## Targets
 
@@ -28,7 +32,8 @@ It runs on every scan, with or without a diff.
 
 ## Example
 
-With no other attributes, both blocks must hold **identical** text. Blank lines and indentation don't count. This suits
+With no other attributes, both blocks must hold **identical** text: the same lines in the same order. Blank lines and
+indentation don't count. This suits
 text you can't share any other way, such as a command shown in two docs:
 
 **README.md**:
@@ -145,7 +150,8 @@ pub const NODE_VERSION: &str = "20.11.1";
 ```
 
 The file has no block of its own, so the referencing block's pattern reads both sides. For anything longer than one
-line, you will want a pattern: without one, the block must equal the entire file.
+line, you will want a pattern: without one, the block must equal the entire file. Or add `same-as-mode="subset"`: then
+each line of the block must be a line of the file.
 
 ## Symbols as targets
 
@@ -187,10 +193,10 @@ show every entry of a directory, such as the services in a README:
 The glob lists `services/auth/`, `services/billing/` and `services/search/`. The pattern picks `auth`, `billing` and
 `search` from them, and `billing` and `search` from the block. So the run reports that `auth` is missing.
 
-- **`same-as-pattern` is required.** It reads both the block and the paths. To compare whole lines, use
-  `same-as-pattern=".+"`.
-- **The paths are sorted, and each one is listed once.** So `same-as-mode="sequence"` also checks that the block
-  lists them in that order.
+- **The block's `same-as-pattern` reads both the block and the paths.** Without a pattern, each line of the block must
+  be a path, such as `services/billing/`.
+- **The paths are sorted, and each one is listed once.** Without a pattern, or with `same-as-mode="sequence"`, the
+  block must list them in that order. To allow any order, add `same-as-mode="set"`.
 - **A trailing `/` lists directories.** A directory is listed when it holds a file, and `services/billing/` is listed
   once however many files it holds. Without the `/`, the glob lists files: `crates/*/AGENTS.md`.
 - **`*` stops at `/`.** `services/*/` lists `services/billing/`, but not `services/billing/src/`. `**` matches any
@@ -205,12 +211,22 @@ A block can have both `same-as` and `same-as-paths`. Each target is compared wit
 
 ## Comparison modes
 
-| `same-as-mode`  | Passes when                                                       |
-|-----------------|-------------------------------------------------------------------|
-| `set` (default) | both sides hold the same values, in any order, ignoring repeats   |
-| `sequence`      | both sides hold the same values in the same order                 |
-| `single`        | each side holds exactly one value, and the two are equal          |
-| `subset`        | every value in this block also appears in the target              |
+| `same-as-mode` | Passes when                                                     |
+|----------------|-----------------------------------------------------------------|
+| `set`          | both sides hold the same values, in any order, ignoring repeats |
+| `sequence`     | both sides hold the same values in the same order               |
+| `single`       | each side holds exactly one value, and the two are equal        |
+| `subset`       | every value in this block also appears in the target            |
+
+Without `same-as-mode`, the mode depends on the block's own `same-as-pattern`. A target's pattern doesn't change it.
+
+- **The block has no pattern:** `sequence`. Each line that isn't blank is a value, so the two sides must hold the same
+  lines in the same order, as in the [example](#example).
+- **The block has a pattern:** `set`.
+
+So adding a pattern stops order from mattering. To keep the order, add `same-as-mode="sequence"` too. And a block
+without a pattern fails when its target's pattern finds a value twice: `["1.2.3"] != ["1.2.3", "1.2.3"]`. To allow
+repeats, add `same-as-mode="set"` or `same-as-mode="subset"`.
 
 `subset` checks one direction only. Use it when one side should hold part of the other, like a test that uses only
 some of the environment variables:
@@ -356,14 +372,18 @@ const TIMEOUT_SECS: f64 = 2.0;
 ## Notes
 
 - **Which block's attributes count.** The referencing block's `same-as-mode` and `same-as-format` decide how to compare.
-  Each block's `same-as-pattern` reads only that block. A whole file, a symbol or a list of paths has no block, so the
-  referencing block's pattern reads it too.
+  On a target, or any block without `same-as` or `same-as-paths`, they stop the run, because they would do nothing
+  there. Each block's `same-as-pattern` reads only that block. A whole file, a symbol or a list of paths has no block,
+  so the referencing block's pattern reads it too. Only a block with a name can be a target, so `same-as-pattern` on a
+  block without `same-as`, `same-as-paths` or `name` stops the run.
 - **Violations:** a missing block, a missing or repeated key, a value that is not a number under `numeric`, a `single`
-  side without exactly one value, a pattern that matches nothing on either side, two patterns with different groups,
-  and a `same-as-paths` glob that matches no path. Two empty sides do not count as equal.
-- **Errors that stop the run:** an unknown `same-as-mode` or `same-as-format`, a `same-as-format` entry for a group
-  that the pattern doesn't have, an invalid regex or glob, `same-as-paths` without `same-as-pattern`, a missing target
-  file, and a symbol in a file with a syntax error, without symbols, or with several YAML documents.
+  side without exactly one value, a side with no values (such as an empty block, or a pattern that matches nothing),
+  two patterns with different groups, and a `same-as-paths` glob that matches no path. Two empty sides do not count as
+  equal.
+- **Errors that stop the run:** an unknown `same-as-mode` or `same-as-format`, either of them on a block without
+  `same-as` or `same-as-paths`, `same-as-pattern` on a block without `same-as`, `same-as-paths` or `name`, a
+  `same-as-format` entry for a group that the pattern doesn't have, an invalid regex or glob, a missing target file,
+  and a symbol in a file with a syntax error, without symbols, or with several YAML documents.
 - **Run it on the whole tree now and then.** `same-as` needs no diff, so a plain `blockwatch` run catches drift that
   `--only-changed` misses. See [CI integration](../ci.md).
 - **A rename alone goes unnoticed in a diff.** Renaming a target file without changing it (a plain `git mv`) gives

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/setup.py

@@ -6,7 +6,7 @@ setup(
     name='blockwatch-pre-commit-placeholder',
     version='0.0.0',
     # <block name="blockwatch-cli-version" same-as-pattern="blockwatch-cli==(?P<value>\d+\.\d+\.\d+)">
-    install_requires=['blockwatch-cli==0.15.0'],
+    install_requires=['blockwatch-cli==0.16.0'],
     # </block>
     # Without it, setuptools takes the directories under src/ for Python packages.
     packages=[],

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/src/blocks.rs

@@ -13,6 +13,7 @@ use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::fmt;
 use std::ops::Range;
 use std::str::FromStr;
+use strum::IntoEnumIterator;
 use strum_macros::EnumString;
 
 const UNNAMED_BLOCK_LABEL: &str = "(unnamed)";
@@ -496,11 +497,12 @@ const RECOGNIZED_ATTRIBUTES: &[&str] = &[
     // </block>
 ];
 
-/// Checks that each attribute of a block is recognized. It does not check the values: see
+/// Checks that each attribute of a block is recognized, and that each validator accepts the
+/// attributes it reads (see [`Validator::check_attributes`]). It does not check the values: see
 /// [`BlockSeverity::from_attributes`] for `severity`.
 ///
 /// # Errors
-/// Returns an error that quotes the attribute that is not recognized, such as
+/// Returns an error that quotes the first attribute found to be wrong, such as
 /// ``unrecognized attribute `keep-sortd` ``.
 pub(crate) fn validate_attributes(attributes: &HashMap<String, String>) -> anyhow::Result<()> {
     if let Some(name) = attributes
@@ -509,7 +511,39 @@ pub(crate) fn validate_attributes(attributes: &HashMap<String, String>) -> anyho
     {
         bail!("unrecognized attribute `{name}`");
     }
-    Ok(())
+    // A block can be in a file that the run reads only to find a target, and no validator runs on
+    // such a block. Every parsed block passes here.
+    Validator::iter().try_for_each(|validator| validator.check_attributes(attributes))
+}
+
+#[cfg(test)]
+mod validate_attributes_tests {
+    use crate::blocks::{RECOGNIZED_ATTRIBUTES, validate_attributes};
+    use crate::validators::Validator;
+    use std::collections::HashMap;
+    use strum::IntoEnumIterator;
+
+    #[test]
+    fn single_attribute_returns_an_error_only_when_it_needs_another() {
+        // A new attribute must either work alone or stop the run alone. Otherwise a block with
+        // only that attribute would pass without being checked.
+        let needs_no_other: Vec<&str> = Validator::iter()
+            .map(Validator::as_str)
+            .chain([
+                "line-pattern-forbidden",
+                "name",
+                "same-as-paths",
+                "severity",
+            ])
+            .collect();
+        for name in RECOGNIZED_ATTRIBUTES {
+            let attributes = HashMap::from([(name.to_string(), String::new())]);
+
+            let result = validate_attributes(&attributes);
+
+            assert_eq!(result.is_ok(), needs_no_other.contains(name), "{name}");
+        }
+    }
 }
 
 #[cfg(test)]

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/src/config.rs

@@ -272,7 +272,9 @@ fn is_entry_modified(
 /// - the target's file is a glob that is not valid or that matches no file;
 /// - `target-pattern` comes with a symbol, or is not a valid regex;
 /// - an attribute is not one a tag can have, or has a value that is not a string, `true` or an
-///   integer.
+///   integer;
+/// - an attribute comes without the attribute its validator needs, such as `check-lua-timeout`
+///   without `check-lua`.
 fn entry_blocks(
     block_entry: BlockEntry,
     entry: ConfigEntry,
@@ -433,6 +435,7 @@ mod tests {
 target = 'package.json#/version'
 name = 'version'
 keep-unique = true
+check-lua = 'check.lua'
 check-lua-timeout = 30
 
 [[block]]
@@ -450,6 +453,7 @@ target = 'a.yaml#/b'
                     attributes: HashMap::from([
                         ("name".to_string(), "version".to_string()),
                         ("keep-unique".to_string(), String::new()),
+                        ("check-lua".to_string(), "check.lua".to_string()),
                         ("check-lua-timeout".to_string(), "30".to_string()),
                     ]),
                     entry: ConfigEntry {
@@ -465,7 +469,7 @@ target = 'a.yaml#/b'
                     attributes: HashMap::new(),
                     entry: ConfigEntry {
                         file: PathBuf::from(DEFAULT_FILE),
-                        line: 9,
+                        line: 10,
                     },
                     is_entry_modified: false,
                     severity: BlockSeverity::Error,

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/src/fs.rs

@@ -263,7 +263,11 @@ impl PathFilter {
 fn glob_set(globs: impl IntoIterator<Item = impl AsRef<str>>) -> GlobSet {
     let mut builder = GlobSet::builder();
     for glob in globs {
-        builder.add(globset::Glob::new(glob.as_ref()).expect("malformed test glob"));
+        builder.add(
+            crate::paths_glob::glob_builder(glob.as_ref())
+                .build()
+                .expect("malformed test glob"),
+        );
     }
     builder.build().expect("failed to build test glob set")
 }

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/src/path_arguments.rs

@@ -1,9 +1,10 @@
 //! The paths and globs given on the command line, and the check that each selects a file.
 
 use crate::fs::{Entry, FileSystem};
+use crate::paths_glob::glob_builder;
 use crate::repo_path::RepoPath;
 use anyhow::{Context, bail};
-use globset::{Glob, GlobSet, GlobSetBuilder};
+use globset::{GlobSet, GlobSetBuilder};
 use std::collections::BTreeSet;
 use std::path::Path;
 
@@ -42,7 +43,9 @@ impl PathArguments {
                 None => argument.trim_start_matches("./").to_string(),
             };
             builder.add(
-                Glob::new(&glob).with_context(|| format!("invalid glob pattern: {argument}"))?,
+                glob_builder(&glob)
+                    .build()
+                    .with_context(|| format!("invalid glob pattern: {argument}"))?,
             );
         }
         Ok(Self {
@@ -55,7 +58,7 @@ impl PathArguments {
     /// no arguments, because then every file is checked.
     pub(crate) fn allowed_globs(&self) -> anyhow::Result<GlobSet> {
         if self.written.is_empty() {
-            return Ok(GlobSet::new([Glob::new("**")?])?);
+            return Ok(GlobSet::new([glob_builder("**").build()?])?);
         }
         Ok(self.globs.clone())
     }
@@ -180,6 +183,15 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn glob_argument_with_empty_alternative_selects_the_path_without_it() -> anyhow::Result<()> {
+        assert_eq!(
+            selected_files(&["a.py", "sub/a.py", "other/a.py"], &["{,sub/}a.py"])?,
+            ["a.py", "sub/a.py"]
+        );
+        Ok(())
+    }
+
     #[test]
     fn error_in_files_ensure_each_matches_returns_the_error() -> anyhow::Result<()> {
         let error = resolve_globs(&["src/**"])?

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/src/paths_glob.rs

@@ -9,6 +9,20 @@ use std::collections::BTreeSet;
 /// path it spells.
 pub(crate) const GLOB_CHARACTERS: [char; 5] = ['*', '?', '[', '{', '\\'];
 
+/// Starts building `glob`, so that an empty alternative in braces matches the empty string:
+/// `{,sub/}a.yml` matches both `a.yml` and `sub/a.yml`.
+pub(crate) fn glob_builder(glob: &str) -> GlobBuilder<'_> {
+    // globset drops an empty alternative by default, so `{,sub/}a.yml` would match only
+    // `sub/a.yml`. Shells and most other glob tools match both.
+    #[expect(
+        clippy::disallowed_methods,
+        reason = "the one place that sets empty_alternates"
+    )]
+    let mut builder = GlobBuilder::new(glob);
+    builder.empty_alternates(true);
+    builder
+}
+
 /// A glob over the repository's paths, compiled to list the files or the directories it matches.
 pub(crate) struct PathsGlob {
     /// Matches a path written without a trailing `/`.
@@ -25,7 +39,7 @@ impl PathsGlob {
     pub(crate) fn new(glob: &str) -> anyhow::Result<Self> {
         // `*` stops at `/`, so `services/*` matches the services and not the directories inside
         // them.
-        let matcher = GlobBuilder::new(glob)
+        let matcher = glob_builder(glob)
             .literal_separator(true)
             .build()?
             .compile_matcher();
@@ -93,3 +107,54 @@ fn base_directory(glob: &str) -> Option<RepoPath> {
     // the walk. Walking the whole repository gives the same paths, only more slowly.
     RepoPath::from_reference(&fixed_segments.join("/")).ok()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::fs::test_utils::FakeFileSystem;
+
+    /// The files that `glob` matches in a repository that holds `files`, sorted.
+    fn matching_files(glob: &str, files: &[&str]) -> anyhow::Result<Vec<String>> {
+        let file_system = FakeFileSystem::new(
+            files
+                .iter()
+                .map(|file| (file.to_string(), String::new()))
+                .collect(),
+        );
+        Ok(PathsGlob::new(glob)?
+            .matching_files(&file_system)?
+            .iter()
+            .map(ToString::to_string)
+            .collect())
+    }
+
+    #[test]
+    fn empty_first_alternative_matches_the_path_without_it() -> anyhow::Result<()> {
+        assert_eq!(
+            matching_files(
+                "{,sub/}a.yml",
+                &["a.yml", "sub/a.yml", "other/a.yml", "b.yml"]
+            )?,
+            ["a.yml", "sub/a.yml"]
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn empty_last_alternative_matches_the_path_without_it() -> anyhow::Result<()> {
+        assert_eq!(
+            matching_files("a{.yml,}", &["a", "a.yml", "a.json", "ab"])?,
+            ["a", "a.yml"]
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn empty_nested_alternative_matches_the_path_without_it() -> anyhow::Result<()> {
+        assert_eq!(
+            matching_files("{x,{,y}}a", &["a", "xa", "ya", "za"])?,
+            ["a", "xa", "ya"]
+        );
+        Ok(())
+    }
+}

{blockwatch_cli-0.15.0 → blockwatch_cli-0.16.0}/src/settings.rs

@@ -1,6 +1,7 @@
 //! Project settings: how they are validated, and how the flags and the config file are merged.
 
 use crate::blocks::BlockAddress;
+use crate::paths_glob::glob_builder;
 use crate::validators::Validator;
 use anyhow::{Context, bail};
 use globset::{Glob, GlobSet, GlobSetBuilder};
@@ -36,7 +37,9 @@ impl RawSettings {
             .ignore
             .iter()
             .map(|glob| {
-                Glob::new(glob).with_context(|| format!("invalid ignore glob pattern: {glob}"))
+                glob_builder(glob)
+                    .build()
+                    .with_context(|| format!("invalid ignore glob pattern: {glob}"))
             })
             .collect::<anyhow::Result<_>>()?;
         let extensions = self
@@ -286,6 +289,19 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn ignore_glob_with_empty_alternative_ignores_the_path_without_it() -> anyhow::Result<()> {
+        let config_file = RawSettings {
+            ignore: to_string_vec(&["{,sub/}a.rs"]),
+            ..RawSettings::default()
+        };
+        let settings = resolve(RawSettings::default(), config_file)?;
+        assert!(settings.ignored_globs.is_match("a.rs"));
+        assert!(settings.ignored_globs.is_match("sub/a.rs"));
+        assert!(!settings.ignored_globs.is_match("other/a.rs"));
+        Ok(())
+    }
+
     #[test]
     fn extensions_in_flags_and_config_file_are_combined() -> anyhow::Result<()> {
         let flags = RawSettings {