model2data 1.9.0__tar.gz → 1.10.1__tar.gz

{model2data-1.9.0/model2data.egg-info → model2data-1.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.9.0
+Version: 1.10.1
 Summary: Generate analytics-ready datasets from DBML models
 Author: JB Analytica
 License-Expression: MIT
@@ -177,6 +177,12 @@ run:
 CLI option overrides the one it names. `model2data validate FILE` checks a model and prints every
 issue with its path in the document.
 
+**Validate models in CI.** `model2data validate a.model2data.yml b.model2data.yml` (or
+`--glob "**/*.model2data.yml"`, `--format github` for inline pull request annotations) exits 1
+when any model has an error. A GitHub Action (`uses: JB-Analytica/model2data@v1`), a pre-commit
+hook (`model2data-validate`) and a GitLab CI snippet are in the
+[README](https://github.com/JB-Analytica/model2data#validate-models-in-ci).
+
 **DBML is supported input.** `--file` also takes a `.dbml` file, converted to the same model
 before generating; a JSON note on a column (`[note: '{"min": 1}']`) becomes its `generate`, any
 other note its description. `model2data convert schema.dbml -o schema.model2data.yml` writes the

{model2data-1.9.0 → model2data-1.10.1}/README.md

@@ -199,6 +199,54 @@ unquoted non-ASCII names — can't be read yet, and are refused with the line an
 
 ---
 
+## Validate models in CI
+
+Teams that keep `*.model2data.yml` models in git can fail a pull request that breaks one.
+`model2data validate` takes several files and `--glob` patterns, prefixes each issue with its
+file, exits 1 if any model has an error, and with `--format github` prints annotations that show
+inline on the pull request's Files tab. `--require-files` fails when nothing matched.
+
+**GitHub Actions**
+
+```yaml
+name: model2data
+on:
+  pull_request:
+    paths: ["**/*.model2data.yml"]
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: JB-Analytica/model2data@v1
+```
+
+Inputs: `files` (glob, default `**/*.model2data.yml`), `version` (default: the release the tag
+points at, e.g. `1.10.1`; a specifier such as `>=1.10,<2` also works), `python-version` (3.12).
+
+**pre-commit**
+
+```yaml
+repos:
+  - repo: https://github.com/JB-Analytica/model2data
+    rev: v1.10.1
+    hooks:
+      - id: model2data-validate
+```
+
+**GitLab CI**
+
+```yaml
+model2data:
+  image: python:3.12-slim
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      changes: ["**/*.model2data.yml"]
+  script:
+    - pip install model2data==1.10.1
+    - model2data validate --glob "**/*.model2data.yml"
+```
+
 ## model2data studio — the same engine, in the browser
 
 [**model2data studio**](https://studio.jbanalytica.com) puts everything on this page behind a

{model2data-1.9.0 → model2data-1.10.1}/README_PYPI.md

@@ -130,6 +130,12 @@ run:
 CLI option overrides the one it names. `model2data validate FILE` checks a model and prints every
 issue with its path in the document.
 
+**Validate models in CI.** `model2data validate a.model2data.yml b.model2data.yml` (or
+`--glob "**/*.model2data.yml"`, `--format github` for inline pull request annotations) exits 1
+when any model has an error. A GitHub Action (`uses: JB-Analytica/model2data@v1`), a pre-commit
+hook (`model2data-validate`) and a GitLab CI snippet are in the
+[README](https://github.com/JB-Analytica/model2data#validate-models-in-ci).
+
 **DBML is supported input.** `--file` also takes a `.dbml` file, converted to the same model
 before generating; a JSON note on a column (`[note: '{"min": 1}']`) becomes its `generate`, any
 other note its description. `model2data convert schema.dbml -o schema.model2data.yml` writes the

{model2data-1.9.0 → model2data-1.10.1}/model2data/cli.py

@@ -196,15 +196,16 @@ def _read_model(file: Path) -> Model:
     return model
 
 
-def _print_issues(file: Path, issues: list[Issue]) -> None:
+def _print_issues(file: Path, issues: list[Issue], label: Optional[str] = None) -> None:
     """Errors, then warnings, each with its document path."""
+    label = label or file.name
     errors = [issue for issue in issues if issue.is_error]
     warnings = [issue for issue in issues if not issue.is_error]
     for marker, group, word in (("❌", errors, "error"), ("⚠️ ", warnings, "warning")):
         if not group:
             continue
         count = f"1 {word}" if len(group) == 1 else f"{len(group)} {word}s"
-        typer.echo(f"{marker} {file.name}: {count}")
+        typer.echo(f"{marker} {label}: {count}")
         for issue in group:
             text = str(issue).removeprefix("warning: ").replace("\n", "\n      ")
             typer.echo(f"  - {text}")
@@ -756,26 +757,101 @@ def _print_defects(report: DefectsReport) -> None:
         typer.echo(f"    - {failure.test}{warn}")
 
 
+_SKIPPED_DIRS = {".git", ".venv", "node_modules"}
+
+
+def _expand_globs(patterns: list[str]) -> list[Path]:
+    """Files matching recursive glob patterns relative to the cwd, sorted, without duplicates."""
+    found: dict[Path, None] = {}
+    for pattern in patterns:
+        for match in sorted(Path.cwd().glob(pattern)):
+            relative = match.relative_to(Path.cwd())
+            if match.is_file() and not _SKIPPED_DIRS.intersection(relative.parts):
+                found[relative] = None
+    return list(found)
+
+
+def _github_escape(text: str, *, prop: bool = False) -> str:
+    """Escape a workflow-command message (or property value) the way GitHub expects."""
+    text = text.replace("%", "%25").replace("\r", "%0D").replace("\n", "%0A")
+    return text.replace(":", "%3A").replace(",", "%2C") if prop else text
+
+
+def _print_github_issues(file: Path, issues: list[Issue]) -> None:
+    """One `::error` / `::warning` annotation per issue, shown inline on a pull request."""
+    for issue in issues:
+        level = "error" if issue.is_error else "warning"
+        where = f"file={_github_escape(file.as_posix(), prop=True)}"
+        if issue.line:
+            where += f",line={issue.line}"
+        text = f"{issue.path}: {issue.message}" if issue.path else issue.message
+        typer.echo(f"::{level} {where}::{_github_escape(text)}")
+
+
 @app.command("validate")
 def validate_command(
-    file: Path = typer.Argument(  # noqa: B008
-        ...,
+    files: Optional[list[Path]] = typer.Argument(  # noqa: B008
+        None,
         exists=True,
         file_okay=True,
         dir_okay=False,
         readable=True,
-        help="The model: a .model2data.yml / .yaml / .json document, or a .dbml file.",
+        help="The models: .model2data.yml / .yaml / .json documents, or .dbml files.",
+    ),
+    glob: Optional[list[str]] = typer.Option(  # noqa: B008
+        None,
+        "--glob",
+        help=(
+            "A recursive glob relative to the current directory, e.g. '**/*.model2data.yml'. "
+            "Repeatable; expands without the shell, so CI needs no globstar."
+        ),
+    ),
+    output_format: str = typer.Option(
+        "text",
+        "--format",
+        help="'text' (default) or 'github' for ::error / ::warning annotations on a pull request.",
+    ),
+    require_files: bool = typer.Option(
+        False, "--require-files", help="Exit 1 when no model file was given or matched."
     ),
 ):
-    """Check that a model conforms to spec 0.3.0 (or 0.2.x), printing every issue with its path.
+    """Check that models conform to spec 0.3.0 (or 0.2.x), printing every issue with its path.
 
-    Exits 1 when there is an error; warnings are printed, and the model conforms.
+    Takes one or more files and/or --glob patterns. Exits 1 when any file has an error;
+    warnings are printed, and the model conforms.
     """
-    issues = validate(file)
-    _print_issues(file, issues)
-    if any(issue.is_error for issue in issues):
+    if output_format not in ("text", "github"):
+        raise typer.BadParameter("must be 'text' or 'github'", param_hint="--format")
+    targets = list(files or [])
+    if glob:
+        targets += [path for path in _expand_globs(glob) if path not in targets]
+    if not targets:
+        typer.echo("no model files matched")
+        raise typer.Exit(1 if require_files else 0)
+
+    failed = 0
+    for file in targets:
+        issues = validate(file)
+        if output_format == "github":
+            _print_github_issues(file, issues)
+        else:
+            _print_issues(file, issues, label=str(file) if len(targets) > 1 else file.name)
+        if any(issue.is_error for issue in issues):
+            failed += 1
+        elif output_format == "text":
+            typer.echo(
+                f"✅ {file if len(targets) > 1 else file.name} conforms to spec {_spec_of(file)}."
+            )
+    if len(targets) > 1 or output_format == "github":
+        count = len(targets)
+        checked = f"{count} model file{'s' if count != 1 else ''}"
+        if failed:
+            verb = "does" if failed == 1 else "do"
+            typer.echo(f"❌ {failed} of {checked} {verb} not conform.")
+        else:
+            typer.echo(f"✅ {checked} {'conforms' if count == 1 else 'conform'}.")
+    if failed:
         raise typer.Exit(1)
-    typer.echo(f"✅ {file.name} conforms to spec {_spec_of(file)}.")
 
 
 @app.command("convert")

{model2data-1.9.0 → model2data-1.10.1}/model2data/model/_yaml.py

@@ -23,6 +23,7 @@ from __future__ import annotations
 
 import math
 import re
+from dataclasses import replace
 from typing import Any
 
 import yaml
@@ -160,6 +161,71 @@ def _check_mappings(node: Node, path: list[PathPart], issues: list[Issue]) -> No
             _check_mappings(item, [*path, index], issues)
 
 
+def locate_issues(text: str, issues: list[Issue]) -> list[Issue]:
+    """`issues` with a `line` on each one that has none, from where its path sits in `text`.
+
+    `text` is a YAML (or JSON) document; it is composed once, with the profile's
+    own loader so the node tree is the one `parse_yaml` read, and each issue's
+    dotted path is walked down it. A path that stops resolving (a key that is
+    missing, say) takes the line of the deepest node that did. Text that does
+    not compose leaves the issues as they are.
+    """
+    if not any(issue.line is None and issue.path for issue in issues):
+        return issues
+    loader = _CoreLoader(text)
+    try:
+        root = loader.get_single_node()
+    except Exception:
+        return issues
+    finally:
+        loader.dispose()
+    if root is None:
+        return issues
+    located = []
+    for issue in issues:
+        if issue.line is None and issue.path:
+            line = _line_of_path(root, issue.path)
+            if line is not None:
+                issue = replace(issue, line=line)
+        located.append(issue)
+    return located
+
+
+def _line_of_path(root: Node, path: str) -> int | None:
+    """The line of the deepest node `path` reaches, or None if it reaches only the root."""
+    node = root
+    rest = path
+    line: int | None = None
+    while rest:
+        if isinstance(node, MappingNode):
+            best: tuple[Node, Node] | None = None
+            best_len = 0
+            for key_node, value_node in node.value:
+                key = _key_text(key_node)
+                if not isinstance(key, str) or not key or len(key) <= best_len:
+                    continue
+                if rest == key or rest.startswith(key + "."):
+                    best, best_len = (key_node, value_node), len(key)
+            if best is None:
+                break
+            line = best[0].start_mark.line + 1
+            node = best[1]
+            rest = rest[best_len + 1 :]
+        elif isinstance(node, SequenceNode):
+            match = re.match(r"^(?:\[(\d+)\]|(\d+))(?:\.|$)", rest)
+            if match is None:
+                break
+            index = int(match.group(1) or match.group(2))
+            if index >= len(node.value):
+                break
+            node = node.value[index]
+            line = node.start_mark.line + 1
+            rest = rest[match.end() :]
+        else:
+            break
+    return line
+
+
 def parse_yaml(text: str) -> Any:
     """Read one YAML document under the spec's profile, or raise `ModelError`."""
     loader = _CoreLoader(text)

{model2data-1.9.0 → model2data-1.10.1}/model2data/model/reader.py

@@ -7,7 +7,7 @@ import os
 from pathlib import Path
 from typing import Literal, Optional, Union
 
-from model2data.model._yaml import parse_yaml
+from model2data.model._yaml import locate_issues, parse_yaml
 from model2data.model.document import from_dict
 from model2data.model.errors import Issue, ModelError
 from model2data.model.types import Model
@@ -78,9 +78,16 @@ def load(source: Source, *, format: Optional[Format] = None) -> Model:
         from model2data.model.dbml import from_dbml
 
         return from_dbml(text)
-    if format == "json":
-        return from_dict(_parse_json(text))
-    return from_dict(parse_yaml(text))
+    document = _parse_json(text) if format == "json" else parse_yaml(text)
+    try:
+        model = from_dict(document)
+    except ModelError as error:
+        # One composition of the text, however many issues: each gets its line.
+        raise ModelError(
+            locate_issues(text, error.issues), locate_issues(text, error.warnings)
+        ) from None
+    model.warnings = locate_issues(text, model.warnings)
+    return model
 
 
 def _parse_json(text: str):

{model2data-1.9.0 → model2data-1.10.1/model2data.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.9.0
+Version: 1.10.1
 Summary: Generate analytics-ready datasets from DBML models
 Author: JB Analytica
 License-Expression: MIT
@@ -177,6 +177,12 @@ run:
 CLI option overrides the one it names. `model2data validate FILE` checks a model and prints every
 issue with its path in the document.
 
+**Validate models in CI.** `model2data validate a.model2data.yml b.model2data.yml` (or
+`--glob "**/*.model2data.yml"`, `--format github` for inline pull request annotations) exits 1
+when any model has an error. A GitHub Action (`uses: JB-Analytica/model2data@v1`), a pre-commit
+hook (`model2data-validate`) and a GitLab CI snippet are in the
+[README](https://github.com/JB-Analytica/model2data#validate-models-in-ci).
+
 **DBML is supported input.** `--file` also takes a `.dbml` file, converted to the same model
 before generating; a JSON note on a column (`[note: '{"min": 1}']`) becomes its `generate`, any
 other note its description. `model2data convert schema.dbml -o schema.model2data.yml` writes the

{model2data-1.9.0 → model2data-1.10.1}/model2data.egg-info/SOURCES.txt

@@ -140,6 +140,7 @@ tests/test_faker_name_inference.py
 tests/test_generation.py
 tests/test_hint_tests.py
 tests/test_history.py
+tests/test_issue_lines.py
 tests/test_lone_country.py
 tests/test_model.py
 tests/test_model_dbml.py

{model2data-1.9.0 → model2data-1.10.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "model2data"
-version = "1.9.0"
+version = "1.10.1"
 description = "Generate analytics-ready datasets from DBML models"
 readme = "README_PYPI.md"
 requires-python = ">=3.10"

{model2data-1.9.0 → model2data-1.10.1}/tests/test_cli_model.py

@@ -187,8 +187,8 @@ def test_validate_prints_every_issue_with_its_path_and_exits_1(tmp_path):
     result = runner.invoke(app, ["validate", str(model)])
     assert result.exit_code == 1
     assert "❌ m.model2data.yml: 2 errors" in result.output
-    assert "  - tables.orders.columns.customer_id.nul: unknown key" in result.output
-    assert "  - run.rows: must be 1 or more (got 0)" in result.output
+    assert "  - tables.orders.columns.customer_id.nul (line 16): unknown key" in result.output
+    assert "  - run.rows (line 21): must be 1 or more (got 0)" in result.output
 
 
 def test_validate_exits_0_on_warnings_alone(tmp_path):
@@ -246,3 +246,135 @@ def test_help_lists_the_commands():
     assert result.exit_code == 0
     for command in ("generate", "validate", "convert"):
         assert command in result.output
+
+
+# ---------------------------------------------------------------------------
+# validate: several files, --glob, --format github, and the CI integration files
+# ---------------------------------------------------------------------------
+def _broken(tmp_path, name="bad.model2data.yml"):
+    return _write(tmp_path, name, MODEL.replace("rows: 12", "rows: 0"))
+
+
+def test_validate_several_files_all_valid(tmp_path):
+    a = _write(tmp_path, "a.model2data.yml", MODEL)
+    b = _write(tmp_path, "b.model2data.yml", MODEL)
+    result = runner.invoke(app, ["validate", str(a), str(b)])
+    assert result.exit_code == 0, result.output
+    assert f"✅ {a} conforms to spec 0.2.0." in result.output
+    assert "✅ 2 model files conform." in result.output
+
+
+def test_validate_several_files_one_invalid_exits_1_with_path_prefixed_issues(tmp_path):
+    good = _write(tmp_path, "good.model2data.yml", MODEL)
+    bad = _broken(tmp_path)
+    result = runner.invoke(app, ["validate", str(good), str(bad)])
+    assert result.exit_code == 1
+    assert f"❌ {bad}: 1 error" in result.output
+    assert "  - run.rows (line 21): must be 1 or more (got 0)" in result.output
+    assert "❌ 1 of 2 model files does not conform." in result.output
+
+
+def test_validate_glob_matches_nested_files(tmp_path, monkeypatch):
+    (tmp_path / "deep" / "er").mkdir(parents=True)
+    _write(tmp_path, "top.model2data.yml", MODEL)
+    _write(tmp_path / "deep" / "er", "nested.model2data.yml", MODEL)
+    (tmp_path / "node_modules").mkdir()
+    _write(tmp_path / "node_modules", "skipped.model2data.yml", MODEL)
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["validate", "--glob", "**/*.model2data.yml"])
+    assert result.exit_code == 0, result.output
+    assert "top.model2data.yml" in result.output
+    assert "nested.model2data.yml" in result.output
+    assert "skipped" not in result.output
+    assert "2 model files conform" in result.output
+
+
+def test_validate_glob_with_no_match_is_a_note_unless_files_are_required(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["validate", "--glob", "**/*.model2data.yml"])
+    assert result.exit_code == 0
+    assert "no model files matched" in result.output
+    required = runner.invoke(app, ["validate", "--glob", "**/*.model2data.yml", "--require-files"])
+    assert required.exit_code == 1
+    assert "no model files matched" in required.output
+
+
+def test_validate_format_github_prints_annotations(tmp_path, monkeypatch):
+    _broken(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["validate", "bad.model2data.yml", "--format", "github"])
+    assert result.exit_code == 1
+    assert (
+        "::error file=bad.model2data.yml,line=21::run.rows: must be 1 or more (got 0)"
+        in result.output
+    )
+    yaml_error = _write(tmp_path, "dup.model2data.yml", MODEL + "name: again\n")
+    result = runner.invoke(app, ["validate", yaml_error.name, "--format", "github"])
+    assert "::error file=dup.model2data.yml,line=25::" in result.output
+
+
+def test_validate_format_github_prints_warnings_and_exits_0():
+    result = runner.invoke(
+        app, ["validate", str(EXAMPLES / "hackernews.dbml"), "--format", "github"]
+    )
+    assert result.exit_code == 0
+    assert "::warning file=" in result.output
+
+
+def test_validate_rejects_an_unknown_format(tmp_path):
+    model = _write(tmp_path, "m.model2data.yml", MODEL)
+    assert runner.invoke(app, ["validate", str(model), "--format", "xml"]).exit_code != 0
+
+
+def test_ci_integration_files_run_the_validate_command():
+    import yaml
+
+    root = Path(__file__).resolve().parent.parent
+    action = yaml.safe_load((root / "action.yml").read_text())
+    assert action["runs"]["using"] == "composite"
+    assert set(action["inputs"]) == {"files", "version", "python-version"}
+    steps = " ".join(str(step.get("run", "")) for step in action["runs"]["steps"])
+    assert "model2data validate --glob" in steps
+    assert "--format github" in steps
+    hooks = yaml.safe_load((root / ".pre-commit-hooks.yaml").read_text())
+    assert hooks[0]["id"] == "model2data-validate"
+    assert hooks[0]["entry"] == "model2data validate"
+    assert hooks[0]["language"] == "python"
+    assert hooks[0]["pass_filenames"] is True
+
+
+def test_validate_format_github_puts_the_line_on_a_value_issue(tmp_path, monkeypatch):
+    _write(
+        tmp_path,
+        "m.model2data.yml",
+        MODEL.replace("pk: true}\n      email", "pk: maybe}\n      email"),
+    )
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["validate", "m.model2data.yml", "--format", "github"])
+    assert result.exit_code == 1
+    assert (
+        "::error file=m.model2data.yml,line=10::tables.customers.columns.id.pk: "
+        'must be true or false, not the string "maybe"'
+    ) in result.output
+
+
+def test_validate_summary_agrees_with_its_count(tmp_path):
+    good = _write(tmp_path, "good.model2data.yml", MODEL)
+    bad = _broken(tmp_path)
+    one_good = runner.invoke(app, ["validate", str(good), "--format", "github"])
+    assert "✅ 1 model file conforms." in one_good.output
+    one_bad = runner.invoke(app, ["validate", str(bad), "--format", "github"])
+    assert "❌ 1 of 1 model file does not conform." in one_bad.output
+    mixed = runner.invoke(app, ["validate", str(good), str(bad)])
+    assert "❌ 1 of 2 model files does not conform." in mixed.output
+    both = runner.invoke(app, ["validate", str(bad), str(_broken(tmp_path, "b2.model2data.yml"))])
+    assert "❌ 2 of 2 model files do not conform." in both.output
+
+
+def test_action_uses_setup_python_v6():
+    import yaml
+
+    root = Path(__file__).resolve().parent.parent
+    action = yaml.safe_load((root / "action.yml").read_text())
+    uses = [step.get("uses") for step in action["runs"]["steps"]]
+    assert "actions/setup-python@v6" in uses

model2data-1.10.1/tests/test_issue_lines.py

@@ -0,0 +1,87 @@
+"""Validation issues carry the line of the node their path points at."""
+
+from model2data.model import Issue, validate
+from model2data.model._yaml import _CoreLoader, _line_of_path, locate_issues
+
+DOC = """\
+model2data: 0.2.0
+name: shop
+tables:
+  raw.users:
+    columns:
+      id: {type: bigint, pk: true}
+      email: {type: email, bogus: 1}
+  orders:
+    columns:
+      id: {type: bigint, pk: maybe}
+    keys:
+      - unique: [id]
+      - unique: 5
+"""
+
+
+def _line(path, text=DOC):
+    loader = _CoreLoader(text)
+    try:
+        return _line_of_path(loader.get_single_node(), path)
+    finally:
+        loader.dispose()
+
+
+def test_a_simple_path_resolves_to_its_key_line():
+    assert _line("tables.orders.columns.id.pk") == 10
+    assert _line("name") == 2
+
+
+def test_a_table_name_with_a_dot_resolves_by_longest_key():
+    assert _line("tables.raw.users.columns.email") == 7
+
+
+def test_a_sequence_index_resolves_in_either_spelling():
+    assert _line("tables.orders.keys.1") == 13
+    assert _line("tables.orders.keys.[1]") == 13
+    assert _line("tables.orders.keys.1.unique") == 13
+
+
+def test_an_unresolvable_tail_falls_back_to_the_deepest_node():
+    assert _line("tables.orders.columns.nope.type") == 9
+    assert _line("tables.orders.keys.9") == 11
+    assert _line("nothing.at.all") is None
+    assert _line("") is None
+
+
+def test_validate_gives_issues_their_lines():
+    issues = validate(DOC)
+    by_path = {issue.path: issue for issue in issues}
+    assert by_path["tables.raw.users.columns.email.bogus"].line == 7
+    assert by_path["tables.orders.columns.id.pk"].line == 10
+    assert "(line 10)" in str(by_path["tables.orders.columns.id.pk"])
+
+
+def test_json_issues_get_lines_too():
+    text = '{\n  "model2data": "0.2.0",\n  "name": "m",\n  "tables": {\n    "t": {"columns": {"id": {"type": "bigint", "pk": "maybe"}}}\n  }\n}'
+    issues = validate(text)
+    assert [issue.line for issue in issues] == [5]
+
+
+def test_dbml_issues_keep_no_line():
+    assert all(issue.line is None for issue in validate("Table t { id int }\n", format="dbml"))
+
+
+def test_a_sequence_followed_by_a_name_stops_at_the_sequence():
+    # `keys` is a list: a path that names a key inside it cannot be followed.
+    assert _line("tables.orders.keys.unique") == 11
+
+
+def test_a_path_past_a_plain_value_stops_at_that_value():
+    assert _line("name.first") == 2
+
+
+def test_text_that_does_not_compose_leaves_the_issues_as_they_were():
+    issue = Issue("tables", "broken")
+    assert locate_issues("a: [unclosed", [issue]) == [issue]
+
+
+def test_an_empty_document_leaves_the_issues_as_they_were():
+    issue = Issue("tables", "missing")
+    assert locate_issues("", [issue]) == [issue]

{model2data-1.9.0 → model2data-1.10.1}/tests/test_model.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import copy
 import json
+from dataclasses import replace
 from pathlib import Path
 
 import pytest
@@ -350,7 +351,8 @@ def test_2_foreign_key_columns_pair_up():
         "are drawn from the ones it holds, but a parent of one row per value needs them to be "
         "its primary key, one of its keys, or a unique column",
     ]
-    assert [str(issue) for issue in validate(json.dumps(document))][1:] == [
+    # `validate` on text adds the line each issue sits on; `from_dict` has no text.
+    assert [str(replace(issue, line=None)) for issue in validate(json.dumps(document))][1:] == [
         str(issue) for issue in raised.value.warnings
     ]