hoodscript 1.4.0__tar.gz → 1.6.0__tar.gz

{hoodscript-1.4.0 → hoodscript-1.6.0}/CHANGELOG.md

@@ -5,6 +5,66 @@ Versioning: the keyword set is the public API; changing it is at least a minor b
 
 ## [Unreleased]
 
+## [1.6.0] — 2026-09-12
+
+Generalized intensive continuative `steady` (Rule R6), 5 new exception mappings
+in the `*Trip` hierarchy, VS Code extension v1.5.0 package, and curriculum updates.
+
+### Added
+
+- **Generalized Intensive Continuative `steady` (Rule R6):**
+  `steady` now supports conditional loops in addition to infinite loops:
+  `steady <expr>:` → `while <expr>:` (and `steady:` → `while True:`).
+  Fully bidirectional: `python_to_hood` (`hood fmt`) maps `while <expr>:` → `steady <expr>:`
+  and `while True:` → `steady:`. Grounded in the Yale Grammatical Diversity Project
+  intensive continuative aspect (*Steady*, Baugh 1984). EBNF and Hypothesis fuzzer updated.
+- **Five New Exception Mappings in the `*Trip` Hierarchy:**
+  `TimeoutTrip` (`TimeoutError`), `InterruptTrip` (`KeyboardInterrupt`), `SystemProblem`
+  (`OSError`), `NotDoneTrip` (`NotImplementedError`), and `DisconnectTrip` (`ConnectionError`).
+  All 1:1 token-substituted, reverse-translated via `python_to_hood`, and equipped with rich
+  conversational plain-English diagnostic cards in the JPE error catalog (HS0140, HS0150,
+  HS0160, HS0170).
+- **VS Code Extension Update (`v1.5.0`):**
+  Added syntax highlighting in `hoodscript.tmLanguage.json` for `be done`, `finna be done`,
+  and `SystemProblem`. Added snippets for `be done` and `steady cond`. Built standalone
+  `hoodscript-1.5.0.vsix` distribution package.
+- **Curriculum & CLI Updates:**
+  Updated `docs/curriculum.md` Lessons 3, 4, and 8 to showcase `steady <cond>:` and `be done`
+  file handling, verified by `tests/test_docs.py` and `hoodscript learn`.
+
+## [1.5.0] — 2026-09-12
+
+Rule R13 (future resultative `be done` → `with`), JPE guidance for retired words,
+and owner sign-off on the sourcing audit (`cap`/`no cap` retained with liability notes).
+
+### Added
+
+- `tests/test_lint_fuzz.py`: the grammar fuzzer from `test_fuzz_ebnf.py`
+  driven against the linter's pure-`ast` rules (HL002, HL004–HL006) — 2,000
+  generated programs on the thorough profile, no crashes, every finding has a
+  filled what/why/fix. PROMPTS.md §2.2 now asks for both fuzz files together
+  after a `patterns.py`/`linter.py` change.
+- **Sourcing audit signed off by owner (2026-09-12):**
+  Owner decision on `cap` / `no cap`: kept in Tier B, with the liability screen
+  hit (GDoS/UD secondary sense) and 2005-test failure (2012 earliest) notes
+  recorded in `GRAMMAR.md` and `hoodscript/docs/linguistics.md`. Sourcing audit
+  status corrections applied to the spec: `trip` single-source caveat lifted
+  (two sources confirmed); `dip` updated to dictionary + corpus; `chill` cited
+  to Lee 1999 (*American Speech*); `fam` cited to OED and Dictionary.com;
+  `tryna` re-ranked below `finna`; Labov 1972 cited for `ain't`.
+- **Rule R13: Future Resultative `be done` → Context Manager (`with`):**
+  Added normative rule R13 implementing `be done expr [as target]:` → `with expr [as target]:`
+  and `finna be done expr [as target]:` → `async with expr [as target]:`. Sourced to
+  Labov (1972), Dayton (1996), and Green (2002) as the future resultative aspect marking
+  guaranteed, inevitable completion — matching Python's context manager contract. Reversible
+  via `python_to_hood` (`hood fmt`). EBNF updated in `docs/grammar.ebnf` and tested in
+  `tests/test_patterns.py` and `tests/test_fuzz_ebnf.py`.
+- **JPE Did-You-Mean for Retired Lexicon:**
+  Added retired/cut keyword recognition in `errors.translator._suggest()` so typos or legacy
+  code (`cook`, `serve`, `Facts`, `Ghost`, `stand_on_it`, `nada`, `peep`, `crew`, `bounce`)
+  receive immediate, conversational guidance pointing to their canonical HoodScript keywords
+  (`bet`, `dip`, `no cap`, `MissingFileTrip`, `AssertTrip`, `None`, `import`, `list`).
+
 ## [1.4.0] — 2026-09-12
 
 New library module, new CLI command, three new lint rules, and the prompt
@@ -25,6 +85,14 @@ aligner. Keyword set unchanged (v1.1).
   2026-09-12 — DRAFT" (`cap`/`no cap` liability + 2018 dating; `trip` now
   two-source; `dip` meets the corpus clause; `tryna` re-ranked; Rickford →
   Labov on the `ain't` row). No keyword changed.
+- **Tier B sourcing sprint** (PROMPTS.md §3.8): an evidence ledger for the
+  eight naming rows in `hoodscript/docs/linguistics.md` — per row, the
+  source stating Black/AAVE use (quoted, opened 2026-09-13), the second
+  source, CORAAL count, the clause of the Tier B rule it meets, and the
+  2005 test. `trip` is two-source; `dip` meets dictionary + corpus; `chill`'s
+  second source is Lee 1999 (*American Speech*); `no cap` fails the 2005
+  test (2012 earliest). Primaries (Smitherman, Major, Widawski, ODAAE)
+  remain unopenable from here and the section says exactly why.
 - **`hoodscript migrate <file.hs>`** — rewrites v1.0.0 code to the v1.1
   lexicon from the CHANGELOG migration table: two line-preserving token
   passes (v1.0.0 map → Python → `py2hood`), so `cook`→`bet`, `serve`→`dip`,

{hoodscript-1.4.0 → hoodscript-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hoodscript
-Version: 1.4.0
+Version: 1.6.0
 Summary: A production-grade Python 3 conlang based on AAVE with 1:1 AST parity.
 License: MIT
 License-File: LICENSE

{hoodscript-1.4.0 → hoodscript-1.6.0}/docs/curriculum.md

@@ -101,7 +101,8 @@ n is 4
 
 `be x in xs` is `for x in xs` — habitual *be*, the thing that happens over
 and over. `1..3` is 1, 2, 3 — inclusive, unlike Python's `range`. `steady:`
-is `while True:` — keep going until `break`. `skip` is `continue`.
+is `while True:` — keep going until `break`. `steady <cond>:` is `while <cond>:`.
+`skip` is `continue`.
 
 ---
 
@@ -115,7 +116,7 @@ bet greet(who, greeting="wassup"):
 double = lambda x: x * 2
 holla(greet("fam"), greet("Khris", "yo"), double(21))
 bet countdown(n):
-    while n > 0:
+    steady n > 0:
         yield n
         n = n - 1
 holla(list(countdown(3)))
@@ -243,14 +244,14 @@ exception without a `*Trip` name is caught under its Python name.
 
 ## Lesson 8 — Modules and files
 
-**Keywords:** none
+**Keywords:** `be done`
 
 ```hood
 import json
 from pathlib import Path
 import math as m
 holla(json.dumps({"ok": True}), m.sqrt(16), Path("."))
-with open("out.txt", "w") as f:
+be done open("out.txt", "w") as f:
     f.write("written from HoodScript\n")
 holla(open("out.txt").read().strip())
 ```
@@ -260,7 +261,8 @@ holla(open("out.txt").read().strip())
 written from HoodScript
 ```
 
-The whole Python ecosystem is available, spelled the Python way. To import
+The whole Python ecosystem is available. A context manager (`with`) is
+`be done ... as f:` — future resultative: guaranteed completion. To import
 your own `.hs` files, see the onboarding guide §6–7.
 
 ---

{hoodscript-1.4.0 → hoodscript-1.6.0}/docs/grammar.ebnf

@@ -10,7 +10,7 @@ program        = { statement } ;
 
 statement      = output_stmt | assignment | const_decl | func_def | class_def
                | return_stmt | habitual_loop | continuative_loop | while_loop
-               | conditional | try_stmt | throw_stmt | import_stmt
+               | context_stmt | conditional | try_stmt | throw_stmt | import_stmt
                | loop_control | pass_stmt | python_stmt | expr_stmt ;
 
 output_stmt    = "holla" [ expression { "," expression } | "(" [ args ] ")" ] ;
@@ -18,12 +18,14 @@ input_expr     = "ask" ( expression | "(" [ args ] ")" ) ;
 assignment     = target "=" expression ;
 const_decl     = "BIN" IDENT "=" expression ;
 
+context_stmt   = [ "finna" ] "be" "done" expression [ "as" target ] ":" block ;
+
 func_def       = [ "finna" ] "bet" IDENT "(" [ params ] ")" ":" block ;
 return_stmt    = ( "dip" | "return" ) [ expression ] ;
 class_def      = "fam" IDENT [ "(" IDENT { "," IDENT } ")" ] ":" block ;
 
 habitual_loop     = "be" target "in" expression ":" block ;
-continuative_loop = "steady" ":" block ;
+continuative_loop = "steady" [ expression ] ":" block ;
 while_loop        = "while" expression ":" block ;
 loop_control      = "skip" | "break" ;
 pass_stmt         = "chill" ;

{hoodscript-1.4.0 → hoodscript-1.6.0}/docs/keywords.md

@@ -72,6 +72,11 @@ Every other Python keyword and builtin is used under its Python name.
 | `MissingModuleTrip` | `ModuleNotFoundError` |
 | `BadImportTrip` | `ImportError` |
 | `NoAccessTrip` | `PermissionError` |
+| `TimeoutTrip` | `TimeoutError` |
+| `InterruptTrip` | `KeyboardInterrupt` |
+| `SystemProblem` | `OSError` |
+| `NotDoneTrip` | `NotImplementedError` |
+| `DisconnectTrip` | `ConnectionError` |
 
 ## Reserved words
 

{hoodscript-1.4.0 → hoodscript-1.6.0}/src/hoodscript/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.4.0'
-__version_tuple__ = version_tuple = (1, 4, 0)
+__version__ = version = '1.6.0'
+__version_tuple__ = version_tuple = (1, 6, 0)
 
 __commit_id__ = commit_id = None

{hoodscript-1.4.0 → hoodscript-1.6.0}/src/hoodscript/cli.py

@@ -74,12 +74,13 @@ def print_tokens() -> None:
         ("no cap", "True", "R3 Truth assertion"),
         ("cap", "False", "R3 Falsehood"),
         ("it's x", "(x is not None)", "R4 Existence test"),
-        ("steady:", "while True:", "R5 Persistent loop"),
+        ("steady [x]:", "while True: / while x:", "R5 Persistent loop"),
         ("a..b", "range(a, (b) + 1)", "R6 Inclusive range"),
         ("BIN X = v", "X: Final = v", "R7 Constant declaration"),
         ("else if", "elif", "R8 Chained conditional"),
         ("holla x, y", "print(x, y)", "R9 Statement-form print"),
         ("ask x", "input(x)", "R10 Statement-form input"),
+        ("be done x:", "with x:", "R13 Context manager"),
     ]
     for src, py, desc in patterns:
         print(f"  {src:<20} -> {py:<25} ({desc})")

{hoodscript-1.4.0 → hoodscript-1.6.0}/src/hoodscript/constants.py

@@ -54,6 +54,11 @@ HOOD_EXCEPTION_NAMES = {
     "MissingModuleTrip": "ModuleNotFoundError",
     "BadImportTrip": "ImportError",
     "NoAccessTrip": "PermissionError",
+    "TimeoutTrip": "TimeoutError",
+    "InterruptTrip": "KeyboardInterrupt",
+    "SystemProblem": "OSError",
+    "NotDoneTrip": "NotImplementedError",
+    "DisconnectTrip": "ConnectionError",
 }
 
 HOOD_KEYWORD_MAP = {**TIER_A, **TIER_B, **TIER_C, **HOOD_EXCEPTION_NAMES}

{hoodscript-1.4.0 → hoodscript-1.6.0}/src/hoodscript/errors/catalog.py

@@ -215,6 +215,34 @@ CATALOG: list[Entry] = [
           pattern=r"'(?P<value>[^']+)'$",
           fields=("value",)),
 
+    # --- TimeoutError ------------------------------------------------------
+    Entry("HS0140", TimeoutError,
+          what="The operation took too long and timed out: {raw}.",
+          why="Something you asked for took longer than the time limit allowed.",
+          fix="Increase the timeout limit, or check whether the network or task is stuck.",
+          example="throw TimeoutTrip(\"timed out\")\n"),
+
+    # --- NotImplementedError -----------------------------------------------
+    Entry("HS0150", NotImplementedError,
+          what="This part hasn't been built yet.",
+          why="A function or method was called that was left as a placeholder or needs to be overridden.",
+          fix="Fill in the body of the function, or provide the implementation in your class.",
+          example="throw NotDoneTrip(\"not ready\")\n"),
+
+    # --- ConnectionError ---------------------------------------------------
+    Entry("HS0160", ConnectionError,
+          what="Could not connect to the network service.",
+          why="The network connection was refused, dropped, or the destination could not be reached.",
+          fix="Check your internet connection, verify the address and port, or try again later.",
+          example="throw DisconnectTrip(\"connection refused\")\n"),
+
+    # --- OSError -----------------------------------------------------------
+    Entry("HS0170", OSError,
+          what="The operating system reported a problem: {raw}.",
+          why="The operating system could not complete a disk, network, or hardware operation.",
+          fix="Check system resources, permissions, and available disk space.",
+          example="throw SystemProblem(\"device unavailable\")\n"),
+
     # ---------------------------------------------------------------------------
     # Compile-time (SyntaxError family). Line/col come from the exception itself.
     # ---------------------------------------------------------------------------

{hoodscript-1.4.0 → hoodscript-1.6.0}/src/hoodscript/errors/translator.py

@@ -70,13 +70,33 @@ def _module_names(filename):
     return names
 
 
+RETIRED_SUGGESTIONS = {
+    "cook": "bet",
+    "serve": "dip",
+    "Facts": "no cap",
+    "Ghost": "MissingFileTrip",
+    "GhostFileTrip": "MissingFileTrip",
+    "stand_on_it": "assert",
+    "StandOnItTrip": "AssertTrip",
+    "nada": "None",
+    "peep": "import",
+    "crew": "list",
+    "bounce": "dip",
+    "holler": "holla",
+}
+
+
 def _suggest(exc, tb, filename):
     if isinstance(exc, NameError) and not isinstance(exc, UnboundLocalError):
         name = getattr(exc, "name", None)
+        if name in RETIRED_SUGGESTIONS:
+            return RETIRED_SUGGESTIONS[name]
         return _close(name, _scope_names(tb)) if name else None
     if isinstance(exc, AttributeError):
         obj, name = getattr(exc, "obj", None), getattr(exc, "name", None)
         if name is not None and obj is not None:
+            if name in RETIRED_SUGGESTIONS:
+                return RETIRED_SUGGESTIONS[name]
             return _close(name, dir(obj))
     if isinstance(exc, ModuleNotFoundError):
         name = getattr(exc, "name", None)

{hoodscript-1.4.0 → hoodscript-1.6.0}/src/hoodscript/lsp.py

@@ -17,7 +17,7 @@ server = LanguageServer("hoodscript-lsp", __version__)
 _WORD = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
 
 _PATTERNS = {
-    "steady": "`steady:` → `while True:`",
+    "steady": "`steady:` → `while True:` / `steady expr:` → `while expr:`",
     "BIN": "`BIN X = v` → `X: Final = v`",
     "no": "`no cap` → `True`",
     "nobody": "`ain't nobody x` → `not x`",

{hoodscript-1.4.0 → hoodscript-1.6.0}/src/hoodscript/patterns.py

@@ -211,9 +211,28 @@ def _edits(text):
             edits.append((row, end, end, " is not None)"))              # wrap; inner edits survive
             i += 1; continue                                            # keep scanning inside the expression
 
-        # R6  steady: -> while True:
-        if _is(t, tokenize.NAME, "steady") and _stmt_start(toks, i) and nxt is not None and _is(nxt, tokenize.OP, ":"):
-            edits.append((row, col, t.end[1], "while True")); i += 1; continue
+        # R6  steady: -> while True:  /  steady expr: -> while expr:
+        if _is(t, tokenize.NAME, "steady") and _stmt_start(toks, i):
+            if nxt is not None and _is(nxt, tokenize.OP, ":"):
+                edits.append((row, col, t.end[1], "while True")); i += 1; continue
+            else:
+                k = i + 1
+                has_header_colon = False
+                depth = 0
+                while k < len(toks) and toks[k].type not in (tokenize.NEWLINE, tokenize.ENDMARKER):
+                    if toks[k].type == tokenize.OP:
+                        if toks[k].string in _OPENERS:
+                            depth += 1
+                        elif toks[k].string in _CLOSERS:
+                            depth -= 1
+                        elif depth == 0 and toks[k].string == ":":
+                            has_header_colon = True
+                            break
+                        elif depth == 0 and toks[k].string == "=":
+                            break
+                    k += 1
+                if has_header_colon:
+                    edits.append((row, col, t.end[1], "while")); i += 1; continue
 
         # R9  BIN X = v -> [from typing import Final; ]X: Final = v
         if _is(t, tokenize.NAME, "BIN") and _stmt_start(toks, i):
@@ -270,6 +289,15 @@ def _edits(text):
                 and _is(nxt, tokenize.NAME, "if") and nxt.start[0] == row):
             edits.append((row, col, nxt.end[1], "elif")); i += 2; continue
 
+        # R13 be done expr: -> with expr: (or finna be done -> async with)
+        if (_is(t, tokenize.NAME, "be") and nxt is not None and _is(nxt, tokenize.NAME, "done")
+                and nxt.start[0] == row):
+            at_be_done = _stmt_start(toks, i) or (
+                i > 0 and _is(toks[i - 1], tokenize.NAME, "finna") and _stmt_start(toks, i - 1)
+            )
+            if at_be_done:
+                edits.append((row, col, nxt.end[1], "with")); i += 2; continue
+
         i += 1
     return lines, edits
 
@@ -331,9 +359,16 @@ def _reverse_edits(text):
         same_row = i + 1 < len(toks) and toks[i + 1].start[0] == row
         stmt = _stmt_start(toks, i)
 
-        # while True:  -> steady:
-        if name(i, "while") and stmt and same_row and name(i + 1, "True") and op(i + 2, ":"):
-            edits.append((row, col, toks[i + 1].end[1], "steady")); i += 2; continue
+        # while True:  -> steady:   /   while expr: -> steady expr:
+        if name(i, "while") and stmt:
+            if same_row and name(i + 1, "True") and op(i + 2, ":"):
+                edits.append((row, col, toks[i + 1].end[1], "steady")); i += 2; continue
+            else:
+                edits.append((row, col, t.end[1], "steady")); i += 1; continue
+
+        # with expr: -> be done expr: (also async with -> finna be done)
+        if name(i, "with") and (stmt or (i > 0 and name(i - 1, "async") and _stmt_start(toks, i - 1))):
+            edits.append((row, col, t.end[1], "be done")); i += 1; continue
 
         # elif -> else if
         if name(i, "elif") and stmt:

{hoodscript-1.4.0 → hoodscript-1.6.0}/src/hoodscript/sourcing.py

@@ -57,8 +57,14 @@ CUT: frozenset[str] = frozenset({
 })
 
 # Multi-token forms (patterns.py) that are keywords without being NAME entries.
-PATTERN_FORMS = {"steady": "while True:", "BIN": "X: Final = v", "ain't": "not", "it's": "(x is not None)",
-                 "no cap": "True", "trip": "*Trip exception suffix"}
+PATTERN_FORMS = {
+    "steady": "while True: / while expr:",
+    "BIN": "X: Final = v",
+    "ain't": "not",
+    "it's": "(x is not None)",
+    "no cap": "True",
+    "trip": "*Trip exception suffix",
+}
 
 
 # ----------------------------------------------------------------------------- 1. standing

{hoodscript-1.4.0 → hoodscript-1.6.0}/tests/test_conformance.py

@@ -80,4 +80,5 @@ def test_exception_name_prefers_most_specific():
     assert get_hood_exception_name(SyntaxError) == "BadSyntaxTrip"
     assert get_hood_exception_name(KeyError) == "MissingKeyTrip"
     assert get_hood_exception_name(RuntimeError) == "Problem"
-    assert get_hood_exception_name(KeyboardInterrupt) == "BaseProblem"
+    assert get_hood_exception_name(KeyboardInterrupt) == "InterruptTrip"
+    assert get_hood_exception_name(SystemExit) == "BaseProblem"

{hoodscript-1.4.0 → hoodscript-1.6.0}/tests/test_errors.py

@@ -85,6 +85,16 @@ def test_did_you_mean_knows_hoodscript_keywords():
     assert d.suggestion == "holla"
 
 
+def test_did_you_mean_knows_retired_words():
+    exc = _run_example("x = cook\n")
+    d = diagnose(type(exc), exc, exc.__traceback__)
+    assert d.suggestion == "bet"
+    exc = _run_example("x = Facts\n")
+    assert diagnose(type(exc), exc, exc.__traceback__).suggestion == "no cap"
+    exc = _run_example("x = Ghost\n")
+    assert diagnose(type(exc), exc, exc.__traceback__).suggestion == "MissingFileTrip"
+
+
 def test_did_you_mean_for_attributes_and_modules():
     exc = _run_example("fam Dog:\n    bet speak(self):\n        chill\nDog().speek()\n")
     assert diagnose(type(exc), exc, exc.__traceback__).suggestion == "speak"

{hoodscript-1.4.0 → hoodscript-1.6.0}/tests/test_fuzz_ebnf.py

@@ -113,12 +113,15 @@ def _stmt(depth=0):
         st.tuples(_ident, _postfix(), _postfix(), body).map(
             lambda t: f"be {t[0]} in {t[1]}..{t[2]}:\n{_indent(t[3])}"),
         body.map(lambda b: f"steady:\n{_indent(b)}"),
+        st.tuples(_expr(), body).map(lambda t: f"steady {t[0]}:\n{_indent(t[1])}"),
         st.tuples(_expr(), body).map(lambda t: f"while {t[0]}:\n{_indent(t[1])}"),
         st.tuples(_ident, st.lists(_ident, max_size=2, unique=True), body).map(
             lambda t: f"bet {t[0]}({', '.join(t[1])}):\n{_indent(t[2])}"),
         st.tuples(_ident, st.lists(_ident, max_size=2, unique=True), body).map(
             lambda t: f"finna bet {t[0]}({', '.join(t[1])}):\n{_indent(t[2])}"),
         st.tuples(_ident, body).map(lambda t: f"fam {t[0]}:\n{_indent(t[1])}"),
+        st.tuples(_ident, body).map(lambda t: f"be done {t[0]}:\n{_indent(t[1])}"),
+        st.tuples(_ident, _ident, body).map(lambda t: f"be done {t[0]} as {t[1]}:\n{_indent(t[2])}"),
         st.tuples(body, body).map(lambda t: f"tryna:\n{_indent(t[0])}\ncatch BadValueTrip as e:\n{_indent(t[1])}"),
         st.tuples(body, body, body).map(
             lambda t: f"tryna:\n{_indent(t[0])}\ncatch:\n{_indent(t[1])}\nregardless:\n{_indent(t[2])}"),

hoodscript-1.6.0/tests/test_lint_fuzz.py

@@ -0,0 +1,37 @@
+"""Property test for the linter: `lint_source`'s ast-only checks (HL002, HL004,
+HL005, HL006) must never crash, no matter what valid HoodScript the grammar
+fuzzer generates. tests/test_fuzz_ebnf.py already builds a grammar-directed
+generator of valid programs; this reuses it rather than duplicating one.
+
+ruff- and mypy-backed findings (HL001, HL003) are not exercised here — they
+shell out, which is what test_lint.py's few hand-written cases already cover;
+this test is about the pure-ast rules added with hoodlib.chart/replay."""
+
+import os
+import sys
+from pathlib import Path
+
+from hypothesis import HealthCheck, given, settings
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from hoodscript.linter import _check_ast_rules, _check_unreachable  # noqa: E402
+from hoodscript.migrator import hood_to_python  # noqa: E402
+from test_fuzz_ebnf import _python_accepts, programs  # noqa: E402
+
+settings.register_profile("thorough", max_examples=2000, deadline=None)
+settings.register_profile("default", max_examples=200, deadline=None,
+                          suppress_health_check=[HealthCheck.too_slow])
+settings.load_profile(os.environ.get("HYPOTHESIS_PROFILE", "default"))
+
+
+@given(programs)
+def test_ast_lint_rules_never_crash_on_valid_programs(src):
+    py = hood_to_python(src)
+    if not _python_accepts(py):
+        return
+    findings = _check_unreachable(py, "fuzz.hs") + _check_ast_rules(py, "fuzz.hs")
+    for f in findings:
+        assert f.line >= 1 and f.col >= 1
+        assert f.what and f.why and f.fix
+        assert "{" not in f.what and "{" not in f.why and "{" not in f.fix   # no unfilled template braces

{hoodscript-1.4.0 → hoodscript-1.6.0}/tests/test_lsp_features.py

@@ -31,7 +31,7 @@ def test_lsp_hover_keywords_and_patterns():
     assert _describe("bet") == "**`bet`** → Python `def`"
     assert _describe("holla") == "**`holla`** → Python `print`"
     assert _describe("ZeroSplitTrip") == "**`ZeroSplitTrip`** → Python exception `ZeroDivisionError`"
-    assert _describe("steady") == "`steady:` → `while True:`"
+    assert _describe("steady") == "`steady:` → `while True:` / `steady expr:` → `while expr:`"
     assert _describe("unknown_word") is None
 
 

{hoodscript-1.4.0 → hoodscript-1.6.0}/tests/test_patterns.py

@@ -15,6 +15,8 @@ RULES = [
     ("R5b", "if it's a and b:\n    chill\n",        "if (a is not None) and b:\n    pass\n"),
     ("R5c", "f(it's x, 2)\n",                       "f((x is not None), 2)\n"),
     ("R6",  "steady:\n    break\n",                 "while True:\n    break\n"),
+    ("R6b", "steady count < 5:\n    chill\n",        "while count < 5:\n    pass\n"),
+    ("R6c", "steady it's item:\n    chill\n",       "while (item is not None):\n    pass\n"),
     ("R7",  "be x in xs:\n    chill\n",             "for x in xs:\n    pass\n"),
     ("R8",  "finna bet f():\n    chill\n",          "async def f():\n    pass\n"),
     ("R9",  "BIN LIMIT = 5\n",                      "from typing import Final; LIMIT: Final = 5\n"),
@@ -30,6 +32,11 @@ RULES = [
     ("R11d", 'holla("call form")\n',                'print("call form")\n'),
     ("R12", 'ask "name? "\n',                       'input("name? ")\n'),
     ("R12b", 'line = ask("> ")\n',                  'line = input("> ")\n'),
+    ("R13", "be done open('f') as f:\n    chill\n", "with open('f') as f:\n    pass\n"),
+    ("R13b", "finna bet f():\n    finna be done open('f') as f:\n        chill\n",
+     "async def f():\n    async with open('f') as f:\n        pass\n"),
+    ("R13c", "be done lock:\n    chill\n",          "with lock:\n    pass\n"),
+    ("R13d", "be done a() as x, b() as y:\n    chill\n", "with a() as x, b() as y:\n    pass\n"),
     ("elif", "if x:\n    chill\nelse if y:\n    chill\n", "if x:\n    pass\nelif y:\n    pass\n"),
 ]
 
@@ -84,6 +91,7 @@ def test_patterns_compose():
 
 @pytest.mark.parametrize("py,hood", [
     ("while True:\n    break\n", "steady:\n    break\n"),
+    ("while count < 5:\n    pass\n", "steady count < 5:\n    chill\n"),
     ("if a:\n    pass\nelif b:\n    pass\n", "if a:\n    chill\nelse if b:\n    chill\n"),
     ("x = True\ny = not x\nz = a is not b\nw = a not in b\n",
      "x = no cap\ny = ain't x\nz = a is not b\nw = a not in b\n"),
@@ -95,6 +103,8 @@ def test_patterns_compose():
     ("print(a, b)\nprint()\nx = print(1)\ninput(\"> \")\n", 'holla a, b\nholla\nx = holla(1)\nask "> "\n'),
     ("print(i, True, not x)\n", "holla i, no cap, ain't x\n"),
     ("s = \"it's not True\"  # not a comment\n", "s = \"it's not True\"  # not a comment\n"),
+    ("with open('f') as f:\n    pass\n", "be done open('f') as f:\n    chill\n"),
+    ("async with open('f') as f:\n    pass\n", "finna be done open('f') as f:\n    chill\n"),
 ])
 def test_reverse_patterns(py, hood):
     from hoodscript.migrator import python_to_hood

{hoodscript-1.4.0 → hoodscript-1.6.0}/tests/test_rule_zero.py

@@ -110,3 +110,15 @@ def test_screen_script_uses_word_boundaries():
 def test_cut_list_is_not_empty_and_has_no_live_keyword():
     assert len(CUT) >= 50
     assert not (CUT & set(HOOD_KEYWORD_MAP))
+
+
+@pytest.mark.parametrize("word", sorted(TIER_B) + ["no cap", "trip"])
+def test_tier_b_ledger_names_the_clause_met(word):
+    """The Tier B rule has two clauses (two dictionaries, or one + CORAAL).
+    The evidence ledger must say which one each row meets."""
+    text = LINGUISTICS.read_text(encoding="utf-8")
+    ledger = text.split("### Evidence ledger")[1].split("### What changes")[0]
+    rows = [ln for ln in ledger.splitlines() if ln.startswith(f"| `{word}`")]
+    assert rows, f"no ledger row for `{word}`"
+    clauses = ("two dictionaries", "dictionary + corpus", "two sources")
+    assert any(c in rows[0] for c in clauses), f"ledger row for `{word}` does not name a clause"