sundgren 0.1.0__tar.gz

sundgren-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,53 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  UV_LOCKED: "1"
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884  # v10.3.0
+      - run: uv sync
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+      - run: uv run mypy
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884  # v10.3.0
+        with:
+          python-version: ${{ matrix.python }}
+      - run: uv sync
+      - run: uv run pytest tests/unit
+      - run: uv run pytest tests/e2e/test_shed_py.py -rs
+
+  e2e-rust:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884  # v10.3.0
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: llvm-tools-preview
+      - uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-llvm-cov,cargo-tarpaulin
+      - run: uv sync
+      - run: uv run pytest tests/e2e/test_shed_rs.py -rs

sundgren-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,58 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  contents: read
+
+env:
+  UV_LOCKED: "1"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884  # v10.3.0
+      - run: uv sync
+      - name: Tag matches package version
+        run: |
+          version=$(uv run python -c "import sundgren; print(sundgren.__version__)")
+          test "v$version" = "$GITHUB_REF_NAME" || { echo "tag $GITHUB_REF_NAME != v$version"; exit 1; }
+      - run: uv run pytest tests/unit
+      - run: uv build
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/sundgren
+    permissions:
+      id-token: write  # PyPI Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    needs: publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+      - run: gh release create "$GITHUB_REF_NAME" dist/* --repo "$GITHUB_REPOSITORY" --generate-notes
+        env:
+          GH_TOKEN: ${{ github.token }}

sundgren-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+__pycache__/
+*.egg-info/
+dist/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.coverage

sundgren-0.1.0/DECISIONS.md

@@ -0,0 +1,218 @@
+# Decisions
+
+Choices made where the scaffold spec was silent or where the implementation deviates from it.
+Spec deviations are marked **(deviation)**.
+
+## Build and layout
+
+- hatchling build. `coverage` and `pytest` are dev dependencies only, for the e2e target project;
+  sundgren never imports them.
+- Language packs register their own `presets.toml` (`register_builtin_presets`), so `run` never
+  globs `lang/`. Only `cli.py` imports `lang`.
+
+## CLI and run mode
+
+- `--format` defaults to json. `{python}` is `python` on PATH, else `python3`; `--python` overrides.
+- Run mode builds line maps from the diff git actually applied, not from the user's patch file:
+  `git apply --index`, then `git diff --cached` in the patched worktree. That diff's shape is pinned
+  against user git config (prefixes, colour, external diff, textconv, rename detection, context).
+  An offset or a non-`a/`/`b/` prefix in the user's patch therefore can't skew the line maps.
+- A hunk applied at an offset adds the warning `patch_offset`. `i/`/`w/` prefixes don't warn.
+- `meta.patch.files` comes from the applied diff; `meta.patch.sha256` is the user's file.
+- Patches are read as bytes and decoded as UTF-8 with `surrogateescape`, without newline
+  translation, so CRs and non-UTF-8 path bytes survive.
+- Exit codes: a bad `--base` ref is 2, a patch that doesn't apply is 3, any other git failure is 1.
+- `meta.base_ref` is the full sha. `meta.commands` expands only `{python}` and `{tests}`, because temp
+  paths would break determinism.
+- `sundgren diff --patch` uses the user's patch as it is and assumes it applies exactly to the base
+  tree.
+
+## Presets, templates, runner
+
+- Only `commands` (non-empty) and `lcov` are required in a preset. Unknown keys are rejected.
+  Defaults: description "", env {}, junit/selector None, tests_style "args", shell false, hints ().
+- If `sundgren.toml` and `[tool.sundgren.presets]` define the same name, `sundgren.toml` wins. Two
+  language packs defining the same name differently raise `PresetError`.
+- Templates expand in one regex pass, so an expanded value containing `{out}` is not expanded again.
+  In shell mode only `{tests}` is quoted.
+- The runner runs every command; a side fails only when its lcov is missing. `returncode` is the
+  first non-zero code. Commands get stdin from /dev/null. A command that can't start is logged as
+  127 (missing) or 126 (other OSError).
+- Relative lcov/junit templates resolve against the worktree. Leftover output files are deleted
+  before the commands run. Repeats go to `run-1`, `run-2`, ….
+- Each side runs with its own `CARGO_TARGET_DIR`: slower, but the trees never share build artifacts.
+- Both worktrees are checked out at the resolved base sha. If setup fails, everything is cleaned up,
+  even with `--keep-worktrees`. With `--workdir`, only `base/` and `patched/` are removed.
+
+## Test selection (Python)
+
+- **(deviation)** A touched test file that was added, deleted or renamed gives `run_all`. The same
+  selection runs on both sides, so a new test file would otherwise fail on the base side.
+- With `tests_style = "args"`, test paths missing on a side are dropped for that side. If none
+  remain, that side counts as empty coverage with a `nothing_to_run` warning.
+
+## Patch parsing and line maps
+
+- Paths drop their first component as `git apply -p1` does (`a/`, `i/`, `old/`, anything); a bare
+  name is kept. `rename from/to` names are never stripped. `/dev/null` is `None`.
+- `new file mode` / `deleted file mode` override the `---`/`+++` paths; `rename from/to` and
+  `---`/`+++` override the `diff --git` header.
+- Plain (non-git) diffs never rename: both sides take the `+++` name, or the `---` name when it is a
+  prefix of it (`diff -u x.orig x` is a change to `x`).
+- C-quoted paths are decoded (escapes, octal bytes, UTF-8 with surrogateescape).
+- Text before the first diff is skipped (format-patch email, commit message, diffstat, signature).
+  Unknown lines inside a git header are skipped.
+- Binary diffs give `binary=True`, no hunks, and a warning; their line map has no changed lines.
+  Copies are treated as renames with a warning. Mode-only changes have no hunks and no warning.
+- The hunk header's counts decide which lines belong to a hunk. Malformed input raises `ValueError`
+  with a 1-based line number. This includes extra hunk lines after an undercounting header, which is
+  stricter than `git apply`.
+- A hunk whose `new_start` disagrees with `old_start` plus the drift so far is placed from
+  `old_start` and warns.
+- Line maps are keyed by both old and new path. On a key collision, the map whose `new_path` is the
+  key wins.
+- `LineMap.to_new`/`to_old` use a counting rule from `deleted_old`/`added_new`; `old_to_new` holds
+  in-hunk pairs only. A randomized check against `difflib` (1600 diffs, context 0–3) found no
+  disagreement.
+
+## lcov ingest
+
+- BRDA: line and block split from the left, taken from the right, so branch ids may contain commas.
+  Block stays a string.
+- FN: `start,<digits>,name` is lcov 2.x; anything else is 1.x, so names may contain commas. FNL/FNA
+  (lcov 2.2) are supported.
+- A FNDA with no FN of that name is dropped (debug log); a FN with no FNDA has `hits=None`.
+- Repeats within one SF section are summed. Duplicate SF sections merge with `merge_file_coverage`
+  (`-` + n = n, `-` + `-` = `-`).
+- Malformed known records raise `ValueError` (exit 1); unknown records are skipped with a debug log.
+- A leading BOM is stripped. Lines split on `\n` only, not on `\f`, `\x85` and the like.
+- `dump` is deterministic and round-trips: `parse(dump(s)) == s`.
+- Rust function names stay mangled.
+
+## Path normalization
+
+- Lexical only: `\` becomes `/`, `.` and empty components are dropped, and `..` pops. The only file
+  system access is `realpath`.
+- The longest matching root wins, on component boundaries only. Every absolute root also matches
+  its `realpath`, and an unmatched absolute path is retried via `realpath` (`/tmp` vs `/private/tmp`).
+- An absolute path matching no root, or a relative path escaping via `..`, is external.
+- `C:/…` is absolute, with a case-insensitive drive letter; the rest of a Windows path stays
+  case-sensitive.
+
+## JUnit
+
+- pytest 9 writes xfail as `<skipped type="pytest.xfail">`, so `type` decides: `pytest.xfail` gives
+  xfailed and `pytest.skip` gives skipped, whatever the message says. An untyped `<skipped>` follows
+  the spec's message-prefix rule.
+- **(deviation)** A strict XPASS (`<failure message="[XPASS(strict)]…">`) is `xpassed`, not
+  `failed`. A non-strict xpass can't be detected and reads as passed.
+- Severity order: passed < skipped < xfailed < xpassed < failed < error. Duplicate ids (reruns,
+  failure plus teardown error) and multiple result children resolve to the most severe.
+- Test id is `classname::name`, or `name` when classname is empty. Testcases are found at any
+  nesting depth, and suite names are ignored.
+- A testcase without a name is dropped with a debug log. Malformed XML or a wrong root raises
+  `ValueError`, and the CLI then drops the file with a `junit_unreadable` warning.
+
+## Function spans
+
+- Function status counts only `Span.body_lines`, so signature and decorator lines, which run at
+  import in Python, don't count.
+- Python symbolizer (`ast`): names match `__qualname__`; `start` is the first decorator line. A
+  leading docstring is skipped when another statement follows. A one-liner has `body_start = None`.
+- Every parse failure becomes `SyntaxError`, including `RecursionError` and `MemoryError` on deeply
+  nested source, so `resolve_spans` falls back to lcov FN. Warnings from parsing the target's
+  source are silenced. A leading BOM is stripped.
+- `LcovFnSymbolizer` sets `body_start = start + 1` for multi-line spans: tarpaulin and coverage.py
+  report the FN line as hit even when the body never runs. A missing end runs to the next distinct
+  FN start − 1, and the last function runs to the last executable line.
+
+## Diff
+
+- File pairing: patched paths first, via `linemap_for(P).old_path`; then unclaimed base paths. A
+  base file colliding with an already-paired path is dropped with an `unpaired_file` warning.
+- A side is *measured*, *inferred* (missing from coverage but present under a known root),
+  *nonexistent* (per the line map or the root), or *unmeasured* (root unknown, line map silent).
+- An inferred side takes the other side's executable lines and branches, mapped through the line
+  map, with count 0, and warns `inferred_file`. When the measured side has nothing executable,
+  nothing is inferred and there is no warning.
+- An unchanged line executable on one side only is `unmeasured`, with one warning per file (none
+  when the count is 0).
+- A changed line counts as deleted plus added, so an edited `if` line gives branch_deleted plus
+  branch_new.
+- Branches match on (mapped line, block, mapped id), and every `line N` in a base branch id is
+  mapped through the line map. coverage.py ids name the target line (`jump to line 7`), so a shift
+  would otherwise produce false lost/gained. A target that doesn't map leaves the branch unmatched.
+- Branch categories: `branch_kept_hit`, `branch_kept_miss`, `branch_lost`, `branch_gained`,
+  `branch_new`, `branch_deleted`, `branch_flaky`, `branch_unmeasured`. Entries carry `base_line`
+  (an addition to spec §7).
+- Flaky (hit in some repeats but not all) lines are removed from `lines` entirely, including the
+  new/deleted counts, and listed in `files[].flaky`. Stats come from run 0.
+- `source_changed`: sha256 differs when both shas are known; otherwise true if the file is absent
+  on one side or its line map has changes. A pure rename is not a source change.
+- Tests: when both outcome maps are None the list is `[]`. When only one exists it's `[]` plus a
+  `tests_one_side` warning. Otherwise the result is the union of ids, with `not_run` for a missing
+  side.
+- Warnings are `{code, message}`, deduplicated, sorted, and use repo-relative paths only.
+- Sort order: lines by line then base_line, with deleted lines (`line` null) last. Branches follow,
+  then by block and a natural-sorted branch id.
+
+## Functions and tree
+
+- Functions match by qualified name (first span per name), then by largest line overlap after
+  mapping. That overlap step pairs coverage.py FN names (`outer.inner`) with symbolizer names
+  (`outer.<locals>.inner`).
+- `went_dark`/`lit_up` take precedence. Otherwise `mixed`, `partial_loss` or `partial_gain` follow
+  from the body's lost/gained counts, else `unchanged`. Flaky lines are ignored.
+- A side with unknown spans borrows the other side's spans through the line map.
+- `tree` covers every non-external file on either side, not just changed ones. Dir stats are sums.
+  A file and a dir may share a name (file `a` deleted, `a/b` added).
+
+## Reports
+
+- Default output lists only files with a non-kept change, drops `kept_*` lines, kept branches and
+  `unchanged` functions, and lists only changed test outcomes. `--full` keeps everything; `summary`
+  and `tree` are never filtered.
+- `--counts` fills `count_changed` and also lists files whose only change is hit counts.
+- `summary.functions` has 7 statuses (no `unchanged`). Coverage % is from the root tree stats,
+  rounded to 1 decimal, and null when nothing is executable.
+- `dumps` is `json.dumps(sort_keys=True, indent=2)` plus a trailing newline. The schema is Draft
+  2020-12 with `additionalProperties: false`, and meta fields are conditional on mode.
+- The text report renders from the JSON dict, not the Delta. Hints are printed only when there are
+  warnings or a listed file has `inferred_side`.
+
+## Tests and fixtures
+
+- `shed_py` is the spec's §12.1 code verbatim, including its header comment, so `divide` is at
+  lines 5–8.
+- `shed_rs` returns `Result` from `divide`. No `Cargo.lock` is committed.
+- Rust E2E covers both `cargo-llvm-cov` and `cargo-tarpaulin`; each is skipped if not installed.
+  CI installs both. Tarpaulin skips when it can't trace (no ptrace). The stderr pattern is a guess,
+  since no machine without ptrace was available.
+- E2E runs sundgren in a clean env (no `GIT_*`, `PYTEST_*`, `COVERAGE_*`, `PYTHONPATH`, user git
+  config) with a private TMPDIR. After every run it asserts that no worktree or temp dir is left.
+  One scenario uses a deliberately hostile git config.
+- Saved JUnit fixtures have neutral hostname, timestamps and paths.
+
+## Known limitations (v1)
+
+- Functions with the same name in one lcov file collapse into one record, as lcov keys by name.
+- Rust closures have FN records with no end, so the enclosing function is cut at the closure's
+  start. Fixing this needs a Rust symbolizer.
+- A one-line function can't be `went_dark` from line data, because its def line runs at import.
+- A deleted file plus a rename onto the same path (or a file turning into a symlink) can't both be
+  represented in the line maps.
+- A 1.x FN name starting with `<digits>,` is read as 2.x.
+- The Python symbolizer parses with the running interpreter's grammar, so newer syntax falls back
+  to lcov FN.
+- lcov 2.2 FNL/FNA support was written from the documented format, without real output to check
+  against. The llvm-cov unit fixture and nextest JUnit are hand-written; real llvm-cov output is
+  only exercised by the CI e2e run, which asserts loosely (no exact function names).
+
+## Spec examples vs. real output
+
+- skip_divide loses 3 lines, not the 6 in the §7 example, because the def line runs at import. The
+  lost branches have taken `[1, null]` (coverage.py writes `-`), not `[1, 0]`.
+- **(deviation)** touch_source: the new function's def line is `new_hit`, because it runs at import;
+  only its body is `new_miss`.
+- With tarpaulin, `divide`'s signature line stays hit when its test is ignored, which is why
+  `LcovFnSymbolizer` skips the FN line.

sundgren-0.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

sundgren-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.5
+Name: sundgren
+Version: 0.1.0
+Summary: CLI tool for measuring how code patches affect line coverage.
+Project-URL: Homepage, https://github.com/axean/sundgren
+Project-URL: Source, https://github.com/axean/sundgren
+Project-URL: Issues, https://github.com/axean/sundgren/issues
+Author: Axel E. Andersson
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: coverage,diff,lcov,patch,pytest,rust,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# sundgren
+
+*Sundgren* is Swedish for "sound branch". Given a repo, a base ref and a patch (usually one that
+changes tests), it answers: **what happened to source coverage because of this patch?**
+
+It runs a coverage command on the base tree and on the patched tree (git worktrees), diffs the two
+lcov files with line numbers mapped through the patch, and writes a JSON report
+(`sundgren.delta/1`) or a text summary.
+
+## Install
+
+```sh
+uv tool install sundgren      # or: pipx install sundgren
+```
+
+Sundgren never imports coverage or pytest itself. They run as commands in your project's
+environment: `{python}` is the `python` on your `PATH` (or `python3`), override with `--python`.
+
+## Python
+
+```sh
+sundgren run --patch skip_divide.patch                 # preset "pytest" is picked from pyproject.toml
+sundgren run --patch p.patch --base main --format text
+```
+
+The `pytest` preset runs `coverage run --branch -m pytest <selected tests>` then `coverage lcov`.
+It only runs the test files the patch touches; if the patch touches `conftest.py`, any other `.py`
+file or pytest config, it runs everything. Override with `--tests tests/test_x.py ...`.
+
+- Set `[run] source = <your package>` in `.coveragerc`, so never-imported files are reported.
+- Editable installs measure your main checkout, not the worktree. Sundgren detects this and exits 1;
+  fix with `--env PYTHONPATH={worktree}/src`.
+
+## Rust
+
+```sh
+sundgren run --patch ignore_divide.patch                          # cargo-llvm-cov
+sundgren run --patch ignore_divide.patch --preset cargo-tarpaulin
+sundgren run --patch p.patch --tests divide                       # name filters, passed after --
+```
+
+Each run uses its own `CARGO_TARGET_DIR`, so both sides build from scratch. Function names are
+stored mangled.
+
+## Any language: `--cmd`
+
+Anything that writes lcov works:
+
+```sh
+sundgren run --patch p.patch \
+  --cmd "npx jest --coverage --coverageReporters=lcov --coverageDirectory={out}" \
+  --lcov "{out}/lcov.info"
+```
+
+Placeholders: `{python}`, `{out}` (per-run output dir), `{worktree}`, `{lcov}`, `{junit}`,
+`{tests}`. A token that is exactly `{tests}` expands to one argv entry per selected test (none if
+nothing is selected). `--shell` runs commands through `/bin/sh -c`. `--junit TEMPLATE` adds test
+outcomes to the report. `--env K=V` sets (templated) environment variables.
+
+Custom presets go in `sundgren.toml` (`[presets.<name>]`) or `[tool.sundgren.presets.<name>]` in
+`pyproject.toml`, with the same keys as `src/sundgren/lang/python/presets.toml`. `sundgren presets`
+lists them.
+
+## Other commands
+
+```sh
+sundgren diff base.lcov patched.lcov --patch p.patch --base-root A --patched-root B
+sundgren ingest coverage.lcov --root .        # normalized snapshot as JSON
+```
+
+Options shared by `run` and `diff`: `--format json|text`, `-o OUT`, `--full` (include unchanged
+lines, functions and tests), `--counts` (hit-count changes on lines that stayed hit), `--repeat N`
+(`run` only; lines whose status varies across runs are reported as `flaky`).
+
+Exit codes: 0 ok, 1 tool or run failure, 2 usage error, 3 patch doesn't apply.
+
+## Report
+
+`files[].lines[].category` is one of `lost`, `gained`, `new_hit`, `new_miss`, `deleted_hit`,
+`deleted_miss`, `kept_hit`, `kept_miss`, `unmeasured` (genhtml: LBC, GBC, GNC, UNC, DCB, DUB, CBC,
+UBC). Functions are `went_dark`, `lit_up`, `partial_loss`, `partial_gain`, `mixed`, `unchanged`,
+`added` or `removed`. `tree` rolls the line stats up per directory. Schema:
+`src/sundgren/core/report/delta.schema.json`.
+
+## Development
+
+```sh
+uv sync                       # dev env in .venv
+uv run pytest
+uv run ruff check . && uv run ruff format --check .
+uv run mypy
+```
+
+Layers: `core` (no languages, no subprocesses) ← `run` (worktrees, command templates) ← `lang`
+(presets, selectors, symbolizers). Only `cli.py` imports `lang`. `tests/unit/test_layering.py`
+enforces this. See `DECISIONS.md` for choices the spec left open.
+
+## License
+
+Apache-2.0. See `LICENSE`.