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

{blockwatch_cli-0.14.2 → blockwatch_cli-0.16.0}/.pre-commit-config.yaml

@@ -43,6 +43,14 @@ repos:
         types: [ rust ]
         stages: [ pre-commit ]
         pass_filenames: false
+      - id: cargo-test
+        name: cargo test
+        description: Run the unit, integration and doc tests.
+        entry: cargo test --quiet
+        language: system
+        types: [ rust ]
+        stages: [ pre-commit ]
+        pass_filenames: false
 
   # Rules and the set of files linted live in `.markdownlint-cli2.yaml`, which the tool picks up
   # from the repository root. The hook passes only the staged Markdown files, so a commit is judged

{blockwatch_cli-0.14.2 → blockwatch_cli-0.16.0}/AGENTS.md

@@ -65,9 +65,9 @@ For example:
 - *Always* handle the variants of an enum with an exhaustive `match`. A `let ... else`, or an `if` that handles one
   variant and sends the rest to a single branch, quietly gives any new variant whatever that branch does. With a
   `match`, the compiler makes you decide what to do with each new variant. One exception: a `match` on another
-  crate's enum can end with `_` when it only asks whether a value is one variant, and no new variant could be that
-  one. For example, every Markdown heading is `mdast::Node::Heading`, so the other node types can go to `_ => None`.
-  Say why in a comment next to the `_`.
+  crate's enum can end with `_` when it only picks out one or a few variants, and no new variant could be one of
+  them. For example, every Markdown heading is `mdast::Node::Heading`, so the other node types can go to
+  `_ => None`. Say why in a comment next to the `_`.
 - *Always* give an item the narrowest visibility that compiles: private, then `pub(super)`, then `pub(crate)`.
   blockwatch is a program, not a library. Only `run` and `count_rust_blocks` in `lib.rs` are `pub`, for `main.rs` and
   the fuzz target. The `unreachable_pub` lint makes `cargo clippy -- -D warnings` fail on any other `pub`.
@@ -173,8 +173,9 @@ The whole pipeline is in `src/cli.rs`. `src/main.rs` only calls `blockwatch::run
    from the command line select, and that don't match the settings' ignore globs. `PathArguments::resolve` turns an
    existing file or directory into a glob first, so `src` selects `src/**`. Pick each file's language by its
    extension, using the settings' extension mappings too.
-6. For each file, the matching `language_parsers::<lang>` (a tree-sitter grammar) finds the comments. `tag_parser` and
-   `block_parser` turn the comment text into `Block` values, with their attributes and their byte and line ranges.
+6. For each file, the matching `language_parsers::<lang>` (usually a tree-sitter grammar) finds the comments.
+   `tag_parser` and `block_parser` turn the comment text into `Block` values, with their attributes and their byte and
+   line ranges.
    `VirtualBlock::resolve` finds each virtual block in the file, by its `Locator`, and adds it as a `Block` too. A file
    without a grammar is read as plain text: it has no tags, only its virtual blocks. A target that does not resolve
    stops the run. `--only-changed` also parses the file of a virtual block whose entry the diff
@@ -224,7 +225,8 @@ The main modules:
 - `src/repo_path.rs` — `RepoPath`, the one way to write a path relative to the repository root. A diff header
   (`b/src/main.rs`), a path found in the walk and a `file:name` attribute all become a `RepoPath`. So the same file is
   always the same map key.
-- `src/language_parsers/` — one tree-sitter grammar for each language. Each language has a `parser()` that returns a
+- `src/language_parsers/` — one parser for each language, most of them a tree-sitter grammar. Markdown and MDX use
+  the `markdown` crate, and Lean has its own scanner. Each language has a `parser()` that returns a
   `LanguageParser`, which knows which syntax nodes are comments. `src/block_parser.rs` turns those comments into
   blocks. `language_parsers()` in `language_parsers/mod.rs` returns `LanguageParsers`: the parser of each extension.
   Its `parser_for` picks the parser of a file, using the settings' extension mappings too. **To add a language, add a
@@ -238,8 +240,7 @@ The main modules:
     syntax tree is nested.
   - YAML walks its syntax tree itself. An alias has a position in a sequence but can't be addressed, and a query can't
     express that.
-  - Markdown finds its sections with the `markdown` crate. The `section` nodes of `tree-sitter-md` don't end at a
-    heading underlined with `---`.
+  - Markdown finds its sections with the `markdown` crate, the same parser that finds its comments.
 
   Each language's tests list every symbol it finds. When you give a language symbols, also document its paths in
   `docs/symbols.md` and in the "Symbols" section of the skill, `src/skill.md`. A test in `language_parsers/mod.rs` and the

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

@@ -12,6 +12,58 @@ 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
+
+- In Markdown, a `<!--` is a comment only where HTML is kept as it is: in an HTML block or in raw HTML in a line of
+  text. These were read as comments before and are not now:
+  - the alt text of an image: `![Logo <!-- x -->](logo.png)`;
+  - the title of a link: `[Docs](docs.md "<!-- x -->")`;
+  - an escaped `<`: `\<!-- x -->`.
+
+  In a line of text, `<!-->` is now a whole comment, so a tag after it on that line is not read.
+
+### Fixed
+
+- In Markdown, blockwatch skipped every tag after a fenced code block that holds a line like `` ``` `` indented by 4
+  spaces or a tab, or `` echo x``` ``. Such a line closed the code block too early, so the rest of the file became
+  code. The run gave no error. Now such a line stays in the code block, as CommonMark says
+  ([#176](https://github.com/mennanov/blockwatch/issues/176)).
+
 ## [0.14.2] - 2026-10-21
 
 ### Added

{blockwatch_cli-0.14.2 → blockwatch_cli-0.16.0}/CLAUDE.md

@@ -65,9 +65,9 @@ For example:
 - *Always* handle the variants of an enum with an exhaustive `match`. A `let ... else`, or an `if` that handles one
   variant and sends the rest to a single branch, quietly gives any new variant whatever that branch does. With a
   `match`, the compiler makes you decide what to do with each new variant. One exception: a `match` on another
-  crate's enum can end with `_` when it only asks whether a value is one variant, and no new variant could be that
-  one. For example, every Markdown heading is `mdast::Node::Heading`, so the other node types can go to `_ => None`.
-  Say why in a comment next to the `_`.
+  crate's enum can end with `_` when it only picks out one or a few variants, and no new variant could be one of
+  them. For example, every Markdown heading is `mdast::Node::Heading`, so the other node types can go to
+  `_ => None`. Say why in a comment next to the `_`.
 - *Always* give an item the narrowest visibility that compiles: private, then `pub(super)`, then `pub(crate)`.
   blockwatch is a program, not a library. Only `run` and `count_rust_blocks` in `lib.rs` are `pub`, for `main.rs` and
   the fuzz target. The `unreachable_pub` lint makes `cargo clippy -- -D warnings` fail on any other `pub`.
@@ -173,8 +173,9 @@ The whole pipeline is in `src/cli.rs`. `src/main.rs` only calls `blockwatch::run
    from the command line select, and that don't match the settings' ignore globs. `PathArguments::resolve` turns an
    existing file or directory into a glob first, so `src` selects `src/**`. Pick each file's language by its
    extension, using the settings' extension mappings too.
-6. For each file, the matching `language_parsers::<lang>` (a tree-sitter grammar) finds the comments. `tag_parser` and
-   `block_parser` turn the comment text into `Block` values, with their attributes and their byte and line ranges.
+6. For each file, the matching `language_parsers::<lang>` (usually a tree-sitter grammar) finds the comments.
+   `tag_parser` and `block_parser` turn the comment text into `Block` values, with their attributes and their byte and
+   line ranges.
    `VirtualBlock::resolve` finds each virtual block in the file, by its `Locator`, and adds it as a `Block` too. A file
    without a grammar is read as plain text: it has no tags, only its virtual blocks. A target that does not resolve
    stops the run. `--only-changed` also parses the file of a virtual block whose entry the diff
@@ -224,7 +225,8 @@ The main modules:
 - `src/repo_path.rs` — `RepoPath`, the one way to write a path relative to the repository root. A diff header
   (`b/src/main.rs`), a path found in the walk and a `file:name` attribute all become a `RepoPath`. So the same file is
   always the same map key.
-- `src/language_parsers/` — one tree-sitter grammar for each language. Each language has a `parser()` that returns a
+- `src/language_parsers/` — one parser for each language, most of them a tree-sitter grammar. Markdown and MDX use
+  the `markdown` crate, and Lean has its own scanner. Each language has a `parser()` that returns a
   `LanguageParser`, which knows which syntax nodes are comments. `src/block_parser.rs` turns those comments into
   blocks. `language_parsers()` in `language_parsers/mod.rs` returns `LanguageParsers`: the parser of each extension.
   Its `parser_for` picks the parser of a file, using the settings' extension mappings too. **To add a language, add a
@@ -238,8 +240,7 @@ The main modules:
     syntax tree is nested.
   - YAML walks its syntax tree itself. An alias has a position in a sequence but can't be addressed, and a query can't
     express that.
-  - Markdown finds its sections with the `markdown` crate. The `section` nodes of `tree-sitter-md` don't end at a
-    heading underlined with `---`.
+  - Markdown finds its sections with the `markdown` crate, the same parser that finds its comments.
 
   Each language's tests list every symbol it finds. When you give a language symbols, also document its paths in
   `docs/symbols.md` and in the "Symbols" section of the skill, `src/skill.md`. A test in `language_parsers/mod.rs` and the

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

@@ -274,7 +274,7 @@ checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 
 [[package]]
 name = "blockwatch"
-version = "0.14.2"
+version = "0.16.0"
 dependencies = [
  "anyhow",
  "assert-json-diff",
@@ -327,7 +327,6 @@ dependencies = [
  "tree-sitter-kotlin-ng",
  "tree-sitter-lua",
  "tree-sitter-make",
- "tree-sitter-md",
  "tree-sitter-nix",
  "tree-sitter-ocaml",
  "tree-sitter-php",
@@ -2637,16 +2636,6 @@ dependencies = [
  "tree-sitter-language",
 ]
 
-[[package]]
-name = "tree-sitter-md"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2efd398be546456c814598ee56c0f51769a77241511b4a58077815d120afa882"
-dependencies = [
- "cc",
- "tree-sitter-language",
-]
-
 [[package]]
 name = "tree-sitter-nix"
 version = "0.3.0"

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

@@ -1,6 +1,6 @@
 [package]
 name = "blockwatch"
-version = "0.14.2"
+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"
@@ -62,7 +62,6 @@ tree-sitter-json = "0.24.8"
 tree-sitter-kotlin-ng = "1.1"
 tree-sitter-lua = "0.5"
 tree-sitter-make = "1.1"
-tree-sitter-md = "0.5"
 tree-sitter-nix = "0.3.0"
 tree-sitter-ocaml = "0.26"
 tree-sitter-php = "0.25"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blockwatch-cli
-Version: 0.14.2
+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.14.2 → 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.14.2  # 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.14.2 → 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.14.2  # 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.14.2  # Use latest release
+  rev: v0.16.0  # Use latest release
   hooks:
     - id: blockwatch-commit-msg
 ```

{blockwatch_cli-0.14.2 → 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.14.2",
-          "semanticVersion": "0.14.2",
+          "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.14.2/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.14.2 → 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.14.2 → 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.14.2 → 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.14.2 → 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.14.2 → 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.14.2 → 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.14.2'],
+    install_requires=['blockwatch-cli==0.16.0'],
     # </block>
     # Without it, setuptools takes the directories under src/ for Python packages.
     packages=[],

{blockwatch_cli-0.14.2 → 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.14.2 → 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.14.2 → 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")
 }