davideisinger.com

spelling-hook (5224B)

---

 #!/usr/bin/env python3
 """Test real commits offline, substituting a predictable spellchecker."""
 
 from pathlib import Path
 import os
 import shutil
 import subprocess
 import tempfile
 
 repo = Path(__file__).resolve().parent.parent
 env = dict(os.environ, GIT_CONFIG_NOSYSTEM="1", GIT_CONFIG_GLOBAL=os.devnull)
 
 with tempfile.TemporaryDirectory(prefix="spelling-hook-") as directory:
     root = Path(directory)
     work = root / "work"
     work.mkdir()
     commands = root / "commands"
     commands.mkdir()
     log = root / "calls"
     npx = commands / "npx"
     npx.write_text('''#!/usr/bin/env python3
 import os, sys
 from pathlib import Path
 assert sys.argv[1:-1] == ['--yes', 'cspell', '--words-only', '--unique', '--no-progress',
     '--no-summary', '--config', '.cspell.json']
 assert sys.argv[-1].startswith('stdin://')
 with open(os.environ['SPELL_LOG'], 'a') as log:
     log.write(sys.argv[-1] + '\\n')
 if os.environ.get('SPELL_FAIL'):
     print('simulated tool failure', file=sys.stderr)
     sys.exit(1)
 if os.environ.get('SPELL_NOISE'):
     print('Need to install the following packages:')
     print('Ok to proceed? (y) jammies')
     sys.exit(int(os.environ['SPELL_NOISE']))
 known = set(Path('.dictionary').read_text().splitlines())
 issues = False
 for word in sys.stdin.read().split():
     if word.startswith('unknown') and word not in known:
         print(word)
         issues = True
 sys.exit(1 if issues else 0)
 ''')
     npx.chmod(0o755)
     env.update(PATH=f"{commands}{os.pathsep}{env['PATH']}", SPELL_LOG=str(log))
 
     def git(*args, ok=True):
         result = subprocess.run(["git", "-C", str(work), *args], env=env,
                                 capture_output=True, text=True)
         assert (result.returncode == 0) == ok, result.stderr
         return result
 
     def commit(ok=True):
         return git("commit", "-m", "Test change", ok=ok)
 
     git("init", "-b", "main")
     git("config", "user.name", "Hook Test")
     git("config", "user.email", "[email protected]")
     git("config", "commit.gpgsign", "false")
     for name in (".githooks/pre-commit", ".githooks/lib/check-staged-spelling"):
         target = work / name
         target.parent.mkdir(parents=True, exist_ok=True)
         shutil.copy2(repo / name, target)
     dictionary = work / ".dictionary"
     dictionary.write_text("existing\n")
     (work / ".cspell.json").write_text("{}")
     git("add", ".")
     commit()
     git("config", "core.hooksPath", ".githooks")
 
     # Paths with spaces, duplicate words, and a partially staged file.
     post = work / "post with spaces.md"
     post.write_text("unknownz unknowna unknownz\n")
     git("add", post.name)
     post.write_text("unknownunstaged\n")
     before = git("rev-parse", "HEAD").stdout
     commit(ok=False)
     assert git("rev-parse", "HEAD").stdout == before
     assert dictionary.read_text() == "existing\nunknowna\nunknownz\n"
     assert git("show", ":.dictionary").stdout == "existing\n"
     commit(ok=False)  # An immediate retry must not accept unstaged words.
     git("add", ".dictionary")
     commit()
     assert post.read_text() == "unknownunstaged\n"
     assert git("show", "HEAD:post with spaces.md").stdout == "unknownz unknowna unknownz\n"
 
     # Fix a typo instead of accepting it into the dictionary.
     post.write_text("unknowntypo\n")
     git("add", post.name)
     commit(ok=False)
     dictionary.write_text(dictionary.read_text().replace("unknowntypo\n", ""))
     post.write_text("Correct spelling.\n")
     git("add", post.name)
     commit()
 
     # Operational failure must block without modifying the dictionary.
     post.write_text("unknownfailure\n")
     git("add", post.name)
     env['SPELL_FAIL'] = '1'
     saved = dictionary.read_bytes()
     assert 'Spellcheck failed' in commit(ok=False).stderr
     assert dictionary.read_bytes() == saved
     del env['SPELL_FAIL']
     # Installation prompts or other stdout diagnostics must never become words.
     for status in ('0', '1'):
         env['SPELL_NOISE'] = status
         assert 'unexpected output' in commit(ok=False).stderr
         assert dictionary.read_bytes() == saved
     del env['SPELL_NOISE']
     post.write_text("Correct revised spelling.\n")
     git("add", post.name)
     commit()
 
     # Accented words follow system sort under the invoking shell's locale.
     env['LC_ALL'] = 'en_US.UTF-8'
     dictionary.write_text(dictionary.read_text() + "Ørsted\nrésumé\nresume\nzebra\n")
     expected = subprocess.check_output(['sort', '-u', str(dictionary)], env=env)
     git('add', '.dictionary')
     post.write_text('Another spelling check.\n')
     git('add', post.name)
     commit(ok=False)
     assert dictionary.read_bytes() == expected
     git('add', '.dictionary')
     commit()
 
     # Renames to .markdown are checked, deletions and non-Markdown are skipped.
     git("mv", post.name, "renamed.markdown")
     log.write_text("")
     commit()
     assert log.read_text() == "stdin://renamed.markdown\n"
     git("rm", "renamed.markdown")
     log.write_text("")
     (work / "script.txt").write_text("unknownignored\n")
     git("add", "script.txt")
     commit()
     assert log.read_text() == ""
 
 print("Spelling hook checks passed: staged content, dictionary review, retries, failures, renames, and deletions.")