pyprettyvba 0.1.0__tar.gz

pyprettyvba-0.1.0/.gitattributes

@@ -0,0 +1,4 @@
+* text=auto
+# Fixtures and oracle evidence are byte-exact: never convert their line endings.
+tests/fixtures/** -text
+tests/oracle/** -text

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

@@ -0,0 +1,57 @@
+name: CI
+
+# Lint, type-check and test on every push to main and every pull request.
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+# A new push to the same branch or pull request cancels the run in progress.
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    name: Lint and type check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: pyproject.toml
+      - run: python -m pip install -e ".[dev]"
+      - name: Ruff
+        run: python -m ruff check src tests tools
+      - name: Mypy
+        run: python -m mypy
+
+  test:
+    name: Test (Python ${{ matrix.python-version }}, ${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+        include:
+          # Reading and writing module files depends on the platform's code
+          # page, so the whole suite runs on Windows too.
+          - os: windows-latest
+            python-version: "3.12"
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+          cache-dependency-path: pyproject.toml
+      - run: python -m pip install -e ".[dev]"
+      - name: Pytest
+        run: python -m pytest -q

pyprettyvba-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,113 @@
+name: Publish to PyPI
+
+# A pushed tag vX.Y.Z builds, checks and publishes that version to PyPI
+# through Trusted Publishing (no token is stored), then makes the GitHub
+# release from the changelog.
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build distributions
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.12"
+
+      - name: Verify tag matches package version
+        if: github.ref_type == 'tag'
+        run: |
+          TAG="${GITHUB_REF_NAME#v}"
+          PKG=$(sed -n 's/^__version__ = "\(.*\)"$/\1/p' src/pyprettyvba/__init__.py)
+          if [ "$TAG" != "$PKG" ]; then
+            echo "ERROR: tag '$TAG' does not match __version__ '$PKG'"
+            exit 1
+          fi
+          echo "Version check passed: $PKG"
+
+      - name: Test
+        run: |
+          python -m pip install -e ".[dev]"
+          python -m pytest -q
+
+      - name: Build sdist and wheel
+        run: |
+          python -m pip install --upgrade build twine
+          python -m build
+
+      - name: Validate metadata
+        run: python -m twine check dist/*
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: dist
+          path: dist/
+          if-no-files-found: error
+
+  publish:
+    name: Publish to PyPI
+    needs: build
+    if: github.ref_type == 'tag'
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/pyprettyvba/
+    permissions:
+      # Required for PyPI Trusted Publishing (OIDC).
+      id-token: write
+    steps:
+      - name: Download artifact
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
+
+  github-release:
+    name: Create GitHub Release
+    needs: publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Download artifact
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: dist
+          path: dist/
+
+      - name: Extract changelog section for this tag
+        run: |
+          TAG="${GITHUB_REF_NAME#v}"
+          awk -v ver="$TAG" '
+            index($0, "## " ver) == 1 { capture=1; next }
+            capture && /^## / { exit }
+            capture { print }
+          ' CHANGELOG.md > release_notes.md
+          if [ ! -s release_notes.md ]; then
+            echo "Release $TAG" > release_notes.md
+          fi
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@efb35369e0ad2afab669f228072c1b0d510eae64 # v3.0.3
+        with:
+          name: ${{ github.ref_name }}
+          tag_name: ${{ github.ref_name }}
+          body_path: release_notes.md
+          files: dist/*
+          fail_on_unmatched_files: true

pyprettyvba-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+# Generated by tools (the XLIDE bundle, the fixture gallery).
+artifacts/
+
+# Python and its tools.
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.hypothesis/

pyprettyvba-0.1.0/.pre-commit-hooks.yaml

@@ -0,0 +1,22 @@
+# Hooks for https://pre-commit.com. In a project's .pre-commit-config.yaml:
+#
+#   - repo: https://github.com/WilliamSmithEdward/pyPrettyVBA
+#     rev: v0.1.0
+#     hooks:
+#       - id: pyprettyvba-format
+
+- id: pyprettyvba-format
+  name: pyprettyvba format
+  description: Format VBA modules in place.
+  entry: pyprettyvba format
+  language: python
+  files: \.(bas|cls|frm|doccls)$
+  require_serial: true
+
+- id: pyprettyvba-check
+  name: pyprettyvba check
+  description: Report what pyPrettyVBA would change in VBA modules, without changing them.
+  entry: pyprettyvba check
+  language: python
+  files: \.(bas|cls|frm|doccls)$
+  require_serial: true

pyprettyvba-0.1.0/AGENTS.md

@@ -0,0 +1,34 @@
+# Notes for coding agents
+
+pyPrettyVBA is a VBA formatter: a pipeline of named rules over a lossless
+token model, with a check that refuses output which runs differently from
+the input. Read `docs/architecture.md` first.
+
+## Commands
+
+```bash
+pip install -e .[dev]
+ruff check src tests tools
+mypy
+python -m pytest                             # fast; no Office needed
+python tools/fixtures.py bless [PREFIX]      # rewrite expected fixture files
+python tools/build_docs.py                   # regenerate docs/rules.md
+```
+
+## Rules of the road
+
+- Formatting must never change what code does. Do not loosen
+  `safety.first_difference` to make a test pass; a `SafetyError` means a
+  rule is wrong.
+- Every rule claim about what the VBE does needs evidence in
+  `tests/oracle/vbe_rendering.json`. Recording it needs Windows, Excel and
+  pyVBAharness (`tools/vbe_oracle.py record`); say so rather than guessing.
+- Bless fixtures only after reading the diff of the expected files, and
+  explain every changed output.
+- A rule's docstring is its user documentation (`docs/rules.md` is built
+  from it, and `tests/test_docs.py` fails when it is stale).
+- The package imports the standard library and pyOpenVBA, nothing else
+  (`tests/test_packaging.py` checks). Other third-party packages are for
+  development only.
+- Keep text in files plain ASCII, apart from test data that is about
+  non-ASCII text.

pyprettyvba-0.1.0/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+## 0.1.0 (2026-09-29)
+
+The first version.
+
+- Twenty rules: keyword and identifier casing, spacing, numeric and date
+  literals, statement forms, statement splitting, indentation, continuation
+  lines, declaration alignment, end-of-line comments, comment style, blank
+  lines, trailing whitespace, end of file, line endings, line length, and
+  directive checking. Each can be enabled, disabled and configured.
+- Presets: `default`, `vbe` (only what the VBE does), `xlide` (XLIDE's
+  Format Document), `strict`, `minimal` and `none`.
+- Suppression with `'@prettyvba-ignore` comments, for a line, the next line,
+  a region or a module, per rule.
+- Configuration in `pyprettyvba.toml` or `pyproject.toml`, with per-file
+  overrides and `extend`.
+- A command line (`format`, `check`, `rules`, `config`, `init`) with text,
+  grouped, JSON and GitHub output, and a Python API.
+- Projects formatted together share their modules' spellings.
+- The VBA inside Excel, Word, PowerPoint and Access files, checked and
+  formatted in place through pyOpenVBA.
+- A digitally signed VBA project is left alone unless `--remove-signatures`
+  is given; then it is formatted and its signature removed.
+- A safety check that refuses output which runs differently from the input.
+- Rule behavior measured against Excel's VBE and replayed by the tests.
+- Python 3.11 or later, and one dependency: pyOpenVBA, which is pure Python
+  with no dependencies of its own.

pyprettyvba-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,86 @@
+# Contributing
+
+## Set up
+
+```bash
+python -m venv .venv
+.venv/Scripts/activate            # Windows; source .venv/bin/activate elsewhere
+pip install -e .[dev]             # pytest, hypothesis, ruff, mypy
+pip install -e .[verify]          # pyVBAanalysis, and pyVBAharness on Windows
+```
+
+## Check
+
+```bash
+ruff check src tests tools
+mypy                              # strict, on src/pyprettyvba
+python -m pytest                  # everything that needs no Office
+```
+
+The suite runs in a few seconds. Longer and heavier runs:
+
+```bash
+HYPOTHESIS_PROFILE=thorough python -m pytest tests/test_properties.py
+PYPRETTYVBA_CORPUS=path/to/modules python -m pytest -m corpus
+python -m pytest -m live          # Windows, desktop Excel, pyVBAharness
+```
+
+The property tests generate random token soup for every preset, and whole
+modules scrambled in every way the default preset repairs; `thorough` runs
+3000 examples of each. The corpus tests format every module under the given
+directories with every preset and compare pyVBAanalysis's diagnostics before
+and after. The live tests import the `vbe` preset's output into a real VBE
+and compile fixtures before and after formatting.
+
+## Fixtures
+
+Each directory under `tests/fixtures/` with a `case.toml` is a case: an
+input, a configuration, and the expected output and report (the layout is
+described in `tests/fixture_support.py`). To add one, write `case.toml` and
+the input, then let the formatter write the expected files and read what it
+wrote:
+
+```bash
+python tools/fixtures.py bless rules/indent/my-case
+git diff tests/fixtures
+```
+
+`bless` with no argument rewrites every case; the diff is the review.
+
+## Adding a rule
+
+1. Write the rule class in the `rules/` module for its area. Its docstring is
+   its documentation: say what it changes, what it leaves alone and why,
+   and what the VBE does, with the evidence.
+2. Add it to `RULES` in `rules/__init__.py` at the point in the pipeline
+   where it belongs, and to the presets in `config.py` that should run it.
+3. Add fixture cases under `tests/fixtures/rules/<code>/`: a basic case, and
+   one for each option.
+4. Run `python tools/build_docs.py` to regenerate `docs/rules.md`.
+
+A rule must never change what code does. Leave the gaps around an
+`UNKNOWN` token alone; never add or remove the space between a name and a
+glued `&`, `!`, `#`, `^` or `.`; and check what a changed line reads as at
+the start of a line (a label? a line number? a directive?). The engine's
+safety check refuses output that runs differently, and the property tests
+go looking for such output; a `SafetyError` in a test is a bug in the
+rule, never in the check.
+
+## Recording what the VBE does
+
+`tools/vbe_oracle.py record` re-records `tests/oracle/vbe_rendering.json`
+from a real Excel. Record on purpose, read the diff, and keep the probe
+names' `zq` prefix: the VBE keeps one spelling per name for a whole
+project, and the prefix keeps probes from changing each other's casing.
+Questions about how names interact go in `ISOLATED_PROBES`, which run in a
+workbook each.
+
+## Other tools
+
+- `tools/build_names.py` rebuilds `src/pyprettyvba/data/names.json.gz`, the
+  library names identifier-case spells, from pyVBAanalysis's object models.
+- `tools/xlide_differential.py PATH` formats modules with the `xlide`
+  preset and with XLIDE's own Format Document, and lists where they differ.
+- `tools/build_gallery.py` renders every fixture case as one
+  self-contained page (`artifacts/gallery/index.html`): input beside output
+  with the changes marked, the configuration, and the report.

pyprettyvba-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William Smith Edward
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyprettyvba-0.1.0/PKG-INFO

@@ -0,0 +1,245 @@
+Metadata-Version: 2.5
+Name: pyprettyvba
+Version: 0.1.0
+Summary: A configurable formatter for VBA, with autofix and rule suppression
+Project-URL: Homepage, https://github.com/WilliamSmithEdward/pyPrettyVBA
+Project-URL: Repository, https://github.com/WilliamSmithEdward/pyPrettyVBA
+Project-URL: Issues, https://github.com/WilliamSmithEdward/pyPrettyVBA/issues
+Author: William Smith Edward
+License-Expression: MIT
+License-File: LICENSE
+Keywords: code-style,excel,formatter,linter,office,prettier,vba
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: pyopenvba>=6.0
+Provides-Extra: build
+Requires-Dist: build>=1.2; extra == 'build'
+Requires-Dist: twine>=5; extra == 'build'
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6; extra == 'dev'
+Requires-Dist: mypy==2.3.1; extra == 'dev'
+Requires-Dist: pytest==9.1.1; extra == 'dev'
+Requires-Dist: ruff==0.16.8; extra == 'dev'
+Provides-Extra: verify
+Requires-Dist: pyvbaanalysis>=2.2; extra == 'verify'
+Requires-Dist: pyvbaharness>=1.1; (sys_platform == 'win32') and extra == 'verify'
+Description-Content-Type: text/markdown
+
+# pyPrettyVBA
+
+A formatter for VBA, in exported modules (`.bas`, `.cls`, `.frm`) or right
+inside Office files (`.xlsm`, `.docm`, `.pptm`, `.accdb` and more). It is
+in the spirit of Prettier but configurable: every change it makes belongs
+to a named rule that can be switched off, tuned, or suppressed for one
+line, a region or a whole module. It spells code the way the VBE spells
+it, lays it out the way you configure, and refuses to return output that
+would run differently from the input.
+
+Before:
+
+```vba
+public function RestockList(ws as worksheet) as collection
+dim r as long,qty as long,result as new collection
+on error goto fail
+for r=2 to ws.cells(ws.rows.count,1).end(xlup).row
+qty=ws.cells(r,3).value
+if qty<low_stock then
+result.add ws.cells(r,1).value
+elseif qty=0 then result.add ws.cells(r,1).value & " (out)"
+end if
+next r
+```
+
+After `pyprettyvba format`:
+
+```vba
+Public Function RestockList(ws As Worksheet) As Collection
+    Dim r As Long, qty As Long, result As New Collection
+    On Error GoTo fail
+    For r = 2 To ws.Cells(ws.Rows.Count, 1).End(xlUp).Row
+        qty = ws.Cells(r, 3).Value
+        If qty < LOW_STOCK Then
+            result.Add ws.Cells(r, 1).Value
+        ElseIf qty = 0 Then result.Add ws.Cells(r, 1).Value & " (out)"
+        End If
+    Next r
+```
+
+The whole module, before and after, is in
+[tests/fixtures/showcase](tests/fixtures/showcase/before-and-after/).
+
+## Install
+
+pyPrettyVBA needs Python 3.11 or later. Its one dependency is
+[pyOpenVBA](https://github.com/WilliamSmithEdward/pyOpenVBA), which reads
+and writes the VBA inside Office files and is pure Python with no
+dependencies of its own.
+
+```bash
+pip install pyprettyvba
+```
+
+## Use
+
+```bash
+pyprettyvba format src/            # format every module under src/ in place
+pyprettyvba format --check src/    # exit 1 if anything would change
+pyprettyvba format --diff src/     # show the changes, write nothing
+pyprettyvba check src/             # list what each rule found, by line
+pyprettyvba check --fix src/       # fix what can be fixed, list the rest
+pyprettyvba rules                  # every rule, on or off, fixable or not
+pyprettyvba rules indent           # one rule's options
+pyprettyvba config src/Module1.bas # the settings that apply to a file
+pyprettyvba init                   # write a starter pyprettyvba.toml
+```
+
+`check` prints one violation per line, `file:line:column: rule message`, with
+`[*]` on the ones formatting fixes. `--output-format` also offers `grouped`,
+`json` and `github` (workflow annotations), and `--statistics` counts them by
+rule. A path of `-` reads standard input. Exit codes: 0 clean, 1 findings or
+changes, 2 an error.
+
+From Python:
+
+```python
+from pyprettyvba import Config, format_source
+
+result = format_source(source_text, Config({"preset": "vbe"}))
+result.output       # the formatted text
+result.violations   # what each rule found, with line and column in the input
+```
+
+`format_file` and `format_paths` read and write files; `project_names`
+gathers what a project's modules declare, so that a name declared in one
+module is spelled the same way in the others.
+
+## Office files
+
+The VBA inside a workbook, document, presentation or database is checked
+and formatted in place, with no Office installed:
+
+```bash
+pyprettyvba check Book1.xlsm        # Book1.xlsm:Module1:12:5: spacing ...
+pyprettyvba format --diff Book1.xlsm
+pyprettyvba format Book1.xlsm
+```
+
+Excel (`.xlsm`, `.xlsb`, `.xlam`, `.xls`), Word (`.docm`, `.dotm`,
+`.doc`), PowerPoint (`.pptm`, `.potm`, `.ppt`) and Access (`.accdb`,
+`.mdb`) files are read and written through pyOpenVBA. The modules of a
+file are one project, as they are in the VBE, so a name one of them
+declares is spelled its way in the others. The file is saved beside the
+original and then moved over it, so an interrupted save changes nothing.
+A project with a digital signature is left unwritten, since any edit
+would invalidate the signature. `--remove-signatures`
+(`remove_signatures=True` from Python) writes it anyway and removes the
+signature, for you to sign the project again in the VBE. The signature is
+found in the zip-based files; in an `.xls`, `.doc`, `.ppt` or Access file
+it is not recognized, and formatting leaves it out of date. A
+password-protected project is written, and keeps its password and its
+lock.
+
+Office files are formatted when named on the command line. Formatting a
+directory takes module files only, unless an `include` pattern names
+Office files too (see [configuration](docs/configuration.md)).
+
+From Python, `format_office_file("Book1.xlsm", write=True)` returns one
+result per module.
+
+## Presets
+
+| Preset | What it does |
+| --- | --- |
+| `default` | What the VBE does to each line (casing, spacing, literal spelling), plus indentation, blank lines and line endings. |
+| `vbe` | Only what the VBE itself does to code it reads in, so the VBE has nothing left to change (the exceptions are listed in [docs/vbe-evidence.md](docs/vbe-evidence.md)). |
+| `xlide` | What XLIDE's Format Document does: indentation, casing and inserted spaces, never removing a space or a line. |
+| `strict` | The defaults plus every style rule: one statement per line, `'` comments with a space, no `Let`, aligned declarations. |
+| `minimal` | Whitespace only: trailing whitespace, the end of the file, line endings. |
+| `none` | Nothing but checking suppression directives; a base for enabling rules one by one. |
+
+## Rules
+
+Twenty rules, each documented with its options in
+[docs/rules.md](docs/rules.md): keyword and identifier casing, spacing,
+numeric and date literal spelling, statement forms, indentation (block
+structure, `Case` arms, `#If` blocks, labels, continuation lines), end-of-line
+comments, blank lines, trailing whitespace, line endings, and a handful of
+optional style rules.
+
+## Configuration
+
+A `pyprettyvba.toml` (or a `[tool.pyprettyvba]` table in `pyproject.toml`)
+next to the code, or in any directory above it:
+
+```toml
+preset = "default"
+indent-width = 4
+line-ending = "crlf"
+
+[rules]
+blank-lines = { max-consecutive = 1 }
+comment-space = true
+numeric-literals = false
+
+[[overrides]]
+files = ["legacy/**"]
+rules = { indent = false }
+```
+
+See [docs/configuration.md](docs/configuration.md) for every key.
+
+## Suppression
+
+```vba
+x   =  1   '@prettyvba-ignore: spacing -- aligned on purpose
+'@prettyvba-ignore-next-line: indent
+'@prettyvba-ignore-start
+    table(0) = Array("id",   "name")
+'@prettyvba-ignore-end
+```
+
+See [docs/suppression.md](docs/suppression.md).
+
+## Safety
+
+Whitespace and letter case are not always meaningless in VBA. `s&t` is a
+syntax error where `s & t` concatenates; `Foo .Bar` passes a With member
+where `Foo.Bar` calls one; a comment ending in ` _` swallows the next line;
+a `Declare` without an `Alias` looks its entry point up case-sensitively.
+Before it returns anything, the formatter reduces the input and the output
+to the statements they run and compares them, and it refuses output that
+differs. Property-based tests, a corpus of 336 real modules, and the VBE
+itself (below) check that this never has to happen.
+
+## What the VBE does, measured
+
+The rules that claim to do what the VBE does are checked against the VBE:
+probe modules pasted into Excel and exported again, compile checks, run-time
+checks, and whole modules imported from files. The recording is replayed by
+the test suite without Office. See [docs/vbe-evidence.md](docs/vbe-evidence.md).
+
+## Development
+
+```bash
+pip install -e .[dev]
+python -m pytest                 # unit tests, fixtures, properties, oracle replay
+python -m pytest -m live         # against a real VBE (Windows, Excel, pyVBAharness)
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the fixture workflow, the corpus
+and property tests, and how to add a rule.
+
+## License
+
+MIT. See [LICENSE](LICENSE).