@neralabs/rerail-pack-python 0.1.3 → 0.1.5

package/rules/ruff-f622-multiple-starred-expressions.json

@@ -3,7 +3,7 @@
   "id": "ruff-f622-multiple-starred-expressions",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F622 (multiple-starred-expressions, a semantic syntax error) with default settings: a tuple or list assignment target (assignment, `for`, comprehension `for`, `with ... as`), at any nesting, with two or more starred elements of its own. Reported on the target tuple or list, parentheses included.",
+  "description": "Use at most one starred element in each Python unpacking target; two in the same target is a syntax error.",
   "scope": { "include": ["**/*"], "exclude": [] },
   "clauses": [
     {

package/rules/ruff-f632-is-literal.json

@@ -1,9 +1,9 @@
 {
   "format": "rerail.policy/v1",
   "id": "ruff-f632-is-literal",
-  "revision": 1,
+  "revision": 2,
   "mode": "steer",
-  "description": "Port of Ruff's F632 (is-literal) with default settings: `is` or `is not` with an operand that is a non-singleton constant (string, bytes or number literal, tuple of constants) or a list, set or dict display or comprehension, one finding per offending operator reported on the whole comparison, as in Ruff; also a comparison inside a string Ruff parses as a type definition (a string annotation, `cast`/`TypeVar` arguments, `List[\"...\"]`), reported on the comparison inside the string, once per offending operator; strings nested in one (`List['1 is x']` inside a string annotation) are read too. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F632.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Use == or != instead of is or is not to compare literal values; the identity of such values is unreliable.",
   "scope": {
     "include": [
       "**/*"
@@ -12,7 +12,7 @@
   },
   "clauses": [
     {
-      "id": "is-literal",
+      "id": "is-literal-is",
       "forbid": {
         "ast": {
           "language": "python",
@@ -150,7 +150,7 @@
               ]
             },
             "is-literal-op": {
-              "regex": "^is(?:[\\s\\\\]+not)?$",
+              "regex": "^is$",
               "any": [
                 {
                   "follows": {
@@ -217,7 +217,224 @@
       "violation": {
         "anchor": "capture.C",
         "code": "F632",
-        "message": "Use `==` to compare constant literals",
+        "message": "Use `==` instead of `is` to compare this literal value.",
+        "each": "O",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F632"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "id": "is-literal-is-not",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "constant": {
+              "any": [
+                {
+                  "kind": "string",
+                  "not": {
+                    "has": {
+                      "stopBy": "end",
+                      "kind": "interpolation"
+                    }
+                  }
+                },
+                {
+                  "kind": "concatenated_string",
+                  "not": {
+                    "has": {
+                      "stopBy": "end",
+                      "kind": "interpolation"
+                    }
+                  }
+                },
+                {
+                  "kind": "integer"
+                },
+                {
+                  "kind": "float"
+                },
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "true"
+                },
+                {
+                  "kind": "false"
+                },
+                {
+                  "kind": "ellipsis"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "constant"
+                  }
+                },
+                {
+                  "kind": "tuple",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "any": [
+                          {
+                            "matches": "constant"
+                          },
+                          {
+                            "regex": "^[(),]$"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "singleton": {
+              "any": [
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "true"
+                },
+                {
+                  "kind": "false"
+                },
+                {
+                  "kind": "ellipsis"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "singleton"
+                  }
+                }
+              ]
+            },
+            "constant-non-singleton": {
+              "all": [
+                {
+                  "matches": "constant"
+                },
+                {
+                  "not": {
+                    "matches": "singleton"
+                  }
+                }
+              ]
+            },
+            "literal-operand": {
+              "any": [
+                {
+                  "matches": "constant-non-singleton"
+                },
+                {
+                  "kind": "set"
+                },
+                {
+                  "kind": "set_comprehension"
+                },
+                {
+                  "kind": "list"
+                },
+                {
+                  "kind": "list_comprehension"
+                },
+                {
+                  "kind": "dictionary"
+                },
+                {
+                  "kind": "dictionary_comprehension"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "literal-operand"
+                  }
+                }
+              ]
+            },
+            "is-literal-op": {
+              "regex": "^is[\\s\\\\]+not$",
+              "any": [
+                {
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "matches": "literal-operand"
+                  }
+                },
+                {
+                  "precedes": {
+                    "stopBy": "neighbor",
+                    "matches": "literal-operand"
+                  }
+                }
+              ]
+            },
+            "is-literal-in-string": {
+              "any": [
+                {
+                  "kind": "string"
+                },
+                {
+                  "kind": "concatenated_string"
+                }
+              ],
+              "parse": {
+                "grammar": "annotation",
+                "has": {
+                  "stopBy": "end",
+                  "any": [
+                    {
+                      "kind": "comparison_operator",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "matches": "is-literal-op",
+                        "capture": "O"
+                      },
+                      "capture": "C"
+                    },
+                    {
+                      "matches": "is-literal-in-string"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "rule": {
+            "any": [
+              {
+                "matches": "is-literal-op",
+                "inside": {
+                  "stopBy": "neighbor",
+                  "kind": "comparison_operator",
+                  "pattern": "$C"
+                }
+              },
+              {
+                "matches": "is-literal-in-string"
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "capture.C",
+        "code": "F632",
+        "message": "Use `!=` instead of `is not` to compare this literal value.",
         "each": "O",
         "suppress": {
           "noqa": {

package/rules/ruff-f633-invalid-print-syntax.json

@@ -3,7 +3,7 @@
   "id": "ruff-f633-invalid-print-syntax",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F633 (invalid-print-syntax) with default settings: the left operand of `>>` when it resolves to the builtin `print` (or `builtins.print`), reported on `print`. tree-sitter-python parses a statement `print >> f, x` as a Python 2 print statement whose `print` is a keyword token, not a name reference, so name resolution cannot be asked there; that form falls back to a file-wide test: no binding of `print` anywhere in the file (assignment, loop, with/except and walrus targets, def/class names, parameters, imports, global/nonlocal).",
+  "description": "Use print()'s file argument instead of Python 2's >> redirection, which raises TypeError with the print function.",
   "scope": {
     "include": [
       "**/*"
@@ -285,7 +285,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F633",
-        "message": "Use of `>>` is invalid with `print` function",
+        "message": "Replace `>>` with print()'s `file=` argument, as in `print(msg, file=sys.stderr)`.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f701-break-outside-loop.json

@@ -3,7 +3,7 @@
   "id": "ruff-f701-break-outside-loop",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F701 (break-outside-loop, a semantic syntax error) with default settings: `break` with no enclosing `for`/`while` body between it and the nearest function or class definition. A loop's `else` block does not count as inside that loop.",
+  "description": "Keep break inside a for or while loop body; outside one (including a loop's else block) it is a Python syntax error.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f702-continue-outside-loop.json

@@ -3,7 +3,7 @@
   "id": "ruff-f702-continue-outside-loop",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F702 (continue-outside-loop, a semantic syntax error) with default settings: `continue` with no enclosing `for`/`while` body between it and the nearest function or class definition. A loop's `else` block does not count as inside that loop.",
+  "description": "Keep continue inside a for or while loop body; outside one (including a loop's else block) it is a Python syntax error.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f706-return-outside-function.json

@@ -3,7 +3,7 @@
   "id": "ruff-f706-return-outside-function",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F706 (return-outside-function, a semantic syntax error) with default settings: `return` whose nearest enclosing function or class body is not a function body (module level, or directly in a class body).",
+  "description": "Keep return inside a function; at module level or directly in a class body it is a Python syntax error.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f707-default-except-not-last.json

@@ -1,9 +1,9 @@
 {
   "format": "rerail.policy/v1",
   "id": "ruff-f707-default-except-not-last",
-  "revision": 1,
+  "revision": 2,
   "mode": "steer",
-  "description": "Port of Ruff's F707 (default-except-not-last) with default settings: a bare `except:` handler followed by another handler of the same `try`. Reported on the `except` keyword.",
+  "description": "Put a bare except handler last in its try statement; Python rejects any handler after it.",
   "scope": {
     "include": [
       "**/*"
@@ -36,7 +36,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F707",
-        "message": "An `except` block as not the last exception handler",
+        "message": "Move this bare `except:` handler after all typed handlers; a bare handler must be last.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f822-undefined-export.json

@@ -3,7 +3,7 @@
   "id": "ruff-f822-undefined-export",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F822 (undefined-export) with default settings, on the engine's name resolution (M10a `resolves.unresolved` on `__all__` entries): a string entry of a static module `__all__` definition (Ruff's extract_dunder_all_names) (an implicit concatenation is one entry) that names no module binding (a bare annotation included) and no builtin, in a module without a star import. `__init__.py` is exempt (Ruff reports it only in preview). Reported on the string.",
+  "description": "List only names the module actually defines in its __all__ (outside __init__.py); an undefined entry breaks star imports.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f823-undefined-local.json

@@ -3,7 +3,7 @@
   "id": "ruff-f823-undefined-local",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F823 (undefined-local) with default settings, on the engine's name resolution (M10a `resolves.beforeLocal`, Ruff's undefined_local): a function's first read of a name that resolves to an enclosing function's or the module's binding which the function's own later binding of the name shadows, where that binding is the function's first and latest of the name (not `global`, `nonlocal` or `del`). Reported on the read. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F823.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "description": "Don't read a variable before the function assigns it, even when an outer scope has the same name; Python raises UnboundLocalError.",
   "scope": {
     "include": [
       "**/*"
@@ -28,7 +28,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "F823",
-        "message": "Local variable `$N` referenced before assignment",
+        "message": "Assign `$N` before reading it here, or declare it `global` or `nonlocal` if you meant the outer variable.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-f842-unused-annotation.json

@@ -3,7 +3,7 @@
   "id": "ruff-f842-unused-annotation",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F842 (unused-annotation) with default settings (`dummy-variable-rgx` = `^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$`), on the engine's usedness (M10a `binds` with form `annotation`, Ruff's unused_annotation): the latest binding of a name in a function or lambda scope that is a bare annotation (`x: int`, `(x): int`) nothing reads, not a dummy name. Names in strings Ruff parses as type definitions are reads (M11a).",
+  "description": "Remove local variables that are annotated but never assigned or read; the annotation alone does nothing.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-f901-raise-not-implemented.json

@@ -3,7 +3,7 @@
   "id": "ruff-f901-raise-not-implemented",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's F901 (raise-not-implemented) with default settings: the exception of a `raise` (not its `from` cause) that is the name `NotImplemented` or a call whose callee is that name, parentheses transparent. Reported on the name. Ruff matches the name itself, not the builtin binding.",
+  "description": "Raise NotImplementedError, not NotImplemented; NotImplemented is a comparison sentinel and raising it is a TypeError.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-pie794-duplicate-class-field-definition.json

@@ -3,7 +3,7 @@
   "id": "ruff-pie794-duplicate-class-field-definition",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's PIE794 (duplicate-class-field-definition): in a class body, an assignment or annotated assignment to a name `N` whose value does not mention `N`, after an earlier such definition of `N` in the same body.",
+  "description": "Define each class field once; a later definition silently replaces the earlier one.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-pie796-non-unique-enums.json

@@ -3,7 +3,7 @@
   "id": "ruff-pie796-non-unique-enums",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's PIE796 (non-unique-enums): in a class with an `enum.Enum` base, a plain assignment whose value equals the value of an earlier assignment in the same body as Ruff's ComparableExpr (`text: \"structure\"`: literals by type and value, `1 == 0x1`, `'a' == \"a\"`, `-1 == -(1)`, not `1 == 1.0 == True`; names compared without NFKC normalization); `enum.auto()` values (alone or in a tuple) are skipped, and in stubs (`.pyi`) so are `...` and `typing.cast(T, ...)`. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/PIE796.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it, and its `.py`/`.pyi` split read per file (`ast.file.path`): the suite's `select_when` gate holds wherever a matching file exists anywhere in the workspace, so in a repository it would read stubs as modules and modules as stubs.",
+  "description": "Give each Enum member a unique value; a duplicate becomes an alias of the earlier member instead of a new one.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-pie800-unnecessary-spread.json

@@ -3,7 +3,7 @@
   "id": "ruff-pie800-unnecessary-spread",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's PIE800 (unnecessary-spread): a dict display spread with `**` into another dict display, reported on the inner dict (inside any parentheses).",
+  "description": "Write the entries directly instead of spreading a dict literal into another Python dict literal.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-pie804-unnecessary-dict-kwargs.json

@@ -3,7 +3,7 @@
   "id": "ruff-pie804-unnecessary-dict-kwargs",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's PIE804 (unnecessary-dict-kwargs): a call argument `**{...}` whose dict display is a single `**x` spread, empty, or has only keys that are str literals (not bytes, f- or t-strings; escapes decoded, implicit concatenations joined) whose value is a Python identifier (not a keyword). Reported on the `**` argument.",
+  "description": "Pass keyword arguments directly instead of unpacking a dict literal into a Python call.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-pie807-reimplemented-container-builtin.json

@@ -3,7 +3,7 @@
   "id": "ruff-pie807-reimplemented-container-builtin",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's PIE807 (reimplemented-container-builtin): a parameterless `lambda` whose body is an empty list or dict display.",
+  "description": "Use list or dict directly instead of a lambda that returns an empty list or dict, such as for a default factory.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-pie810-multiple-starts-ends-with.json

@@ -3,7 +3,7 @@
   "id": "ruff-pie810-multiple-starts-ends-with",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's PIE810 (multiple-starts-ends-with): an `or` chain with two or more operands `R.startswith(x)` (or two `R.endswith(x)`) on the same name `R`, each with one positional argument and no keywords, where the argument is not a name bound to a tuple (Ruff's is_bound_to_tuple through `resolves.binding`, read as lookup_symbol does with `stopAtGlobal`: a `def`'s `*args`, a tuple-typed value, `tuple(...)`, or a `tuple`/`Tuple` annotation or return annotation). Reported on the whole chain, once per such group.",
+  "description": "Pass a tuple to one startswith() or endswith() call instead of or-ing several calls on the same string.",
   "scope": {
     "include": [
       "**/*"
@@ -570,7 +570,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "PIE810",
-        "message": "Call `$M` once with a `tuple`",
+        "message": "Call `$M` once with a tuple of all the prefixes or suffixes instead of or-ing several calls.",
         "each": "FIRST",
         "suppress": {
           "noqa": {

package/rules/ruff-ret501-unnecessary-return-none.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret501-unnecessary-return-none",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET501 (unnecessary-return-none): `return None` in a function whose every `return` is bare or returns `None` (nested functions and classes are separate; generators and functions whose body is a lone `return` are skipped), unless the function has a return annotation other than `None` or a property decorator (`property`, `enum.property`, `functools.cached_property`, `abc.abstractproperty`, `types.DynamicClassAttribute`, resolved through the file's bindings and imports). Reported on the `return` statement.",
+  "description": "Use a bare return instead of return None in Python functions that never return anything else.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-ret502-implicit-return-value.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret502-implicit-return-value",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET502 (implicit-return-value): a bare `return` in a function that also has a `return` with a value other than `None` (nested functions and classes are separate; generators and functions whose body is a lone `return` are skipped), reported on the `return`.",
+  "description": "Use return None instead of a bare return in Python functions that also return a value; make the None result explicit.",
   "scope": {
     "include": [
       "**/*"
@@ -149,7 +149,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "RET502",
-        "message": "Do not implicitly `return None` in function able to return non-`None` value",
+        "message": "Write `return None` instead of a bare `return`, since this function returns a value elsewhere.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-ret505-superfluous-else-return.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret505-superfluous-else-return",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET505 (superfluous-else-return): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `return` statement and no earlier direct raise/continue/break statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "description": "Remove the else or elif after an if branch that returns, and dedent its code; the branch already leaves the function.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-ret506-superfluous-else-raise.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret506-superfluous-else-raise",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET506 (superfluous-else-raise): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `raise` statement and no earlier direct return/continue/break statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "description": "Remove the else or elif after an if branch that raises, and dedent its code; the branch already leaves the function.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-ret507-superfluous-else-continue.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret507-superfluous-else-continue",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET507 (superfluous-else-continue): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `continue` statement and no earlier direct return/raise/break statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "description": "Remove the else or elif after an if branch that continues the loop, and dedent its code; the branch already skips ahead.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-ret508-superfluous-else-break.json

@@ -3,7 +3,7 @@
   "id": "ruff-ret508-superfluous-else-break",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's RET508 (superfluous-else-break): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `break` statement and no earlier direct return/raise/continue statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "description": "Remove the else or elif after an if branch that breaks out of the loop, and dedent its code; the branch already exits the loop.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim101-duplicate-isinstance-call.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim101-duplicate-isinstance-call",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM101 (duplicate-isinstance-call): two adjacent operands of one `or` chain that are calls of the builtin `isinstance(T, C)` (exactly two positional arguments, no keywords) with equal targets (Ruff's ComparableExpr, `text: \"structure\"`; names without NFKC normalization), reported on the whole `or` chain once per run of adjacent such calls with equal targets. A parenthesized `or` is its own chain, as in Ruff's AST. `isinstance` must resolve to the builtin (`match_builtin_expr`: the unshadowed name, or `builtins.isinstance` through an import).",
+  "description": "Merge isinstance() checks on the same object joined by or into one call with a tuple of types.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim107-return-in-try-except-finally.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim107-return-in-try-except-finally",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM107 (return-in-try-except-finally): the first top-level `return` of a `finally` body when the `try` body or an `except` handler body has a top-level `return`.",
+  "description": "Don't return from a finally block when the try or except also returns; the finally return silently overrides theirs.",
   "scope": {
     "include": [
       "**/*"
@@ -68,7 +68,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "SIM107",
-        "message": "Don't use `return` in `try`-`except` and `finally`",
+        "message": "Remove the `return` from the `finally` block; it silently overrides the `return` in `try` or `except`.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-sim109-compare-with-tuple.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim109-compare-with-tuple",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM109 (compare-with-tuple): an `or` chain with two or more operands `N == name` (one `==`, both sides names) for the same `N`, anywhere in the chain; not reported when a comment lies inside the chain or follows it on its last line with only white space between (Ruff's has_comments). Reported on the whole `or` chain, once per such name.",
+  "description": "Use a membership test against a tuple instead of several or-chained equality checks of the same variable.",
   "scope": {
     "include": [
       "**/*"

package/rules/ruff-sim112-uncapitalized-environment-variables.json

@@ -1,9 +1,9 @@
 {
   "format": "rerail.policy/v1",
   "id": "ruff-sim112-uncapitalized-environment-variables",
-  "revision": 1,
+  "revision": 2,
   "mode": "steer",
-  "description": "Port of Ruff's SIM112 (uncapitalized-environment-variables): a str literal (not bytes, an f- or t-string; escapes decoded, implicit concatenations joined) whose value has an ASCII lowercase letter, other than `https_proxy`/`http_proxy`/`no_proxy`, used as `os.environ[...]` or as the first argument of a call resolving to `os.environ.get`/`os.getenv`, after Ruff's traversal has visited an absolute import of `os` (M10a `resolves.seenBefore`). Reported on the string.",
+  "description": "Use uppercase names when reading environment variables through os.environ or os.getenv; the lowercase proxy variables are exempt.",
   "scope": {
     "include": [
       "**/*"
@@ -154,7 +154,7 @@
       "violation": {
         "anchor": "witness.span",
         "code": "SIM112",
-        "message": "Use capitalized environment variable",
+        "message": "Uppercase only if the deployment uses that name; preserve intentional lowercase keys because lookups are case-sensitive on POSIX.",
         "suppress": {
           "noqa": {
             "codes": [

package/rules/ruff-sim113-enumerate-for-loop.json

@@ -3,7 +3,7 @@
   "id": "ruff-sim113-enumerate-for-loop",
   "revision": 1,
   "mode": "steer",
-  "description": "Port of Ruff's SIM113 (enumerate-for-loop): `N += 1` as a top-level statement of a non-async `for` body without `continue`, where the binding `N` reads (`resolves.binding`) is a name assignment of `0` (plain, annotated, or an unpacked element of a display, paired by index as Ruff's match_value where the engine gives no value) whose parent statement is the loop's, `N` is bound only once inside the loop (`binds` with `bindings` within the loop: deletions and comprehension walruses count, comprehension targets, nested functions' locals and keyword arguments do not), and no load of `N` outside the loop in its scope, at or after the initial assignment, reads the initial binding (whose references Ruff's rebinding inherits) or a binding inside the loop. The loop and the initial assignment are found again by node identity (`compare` with `text: \"node\"`), so identical loops in one scope stay apart.",
+  "description": "Use enumerate() instead of a counter that starts at 0 and is incremented by hand in each pass of a for loop.",
   "scope": {
     "include": [
       "**/*"