@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-b010-set-attr-with-constant.json

@@ -0,0 +1,219 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b010-set-attr-with-constant",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B010 (set-attr-with-constant): `setattr(obj, \"name\", value)` used as an expression statement, with exactly three positional arguments and no keyword arguments, `obj` not starred, the name a str literal (not bytes, an f- or t-string; escapes decoded, implicit concatenations joined) whose value is a Python identifier (Unicode XID, not a keyword), not `__debug__` and not a mangled private name. The callee (parentheses transparent) resolves to the builtin `setattr` (Ruff's `match_builtin_expr`): the unshadowed name, or `setattr` of the `builtins` module through the file's imports. Reported on the call.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "set-attr-with-constant",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "ref-setattr": {
+              "any": [
+                {
+                  "kind": "identifier"
+                },
+                {
+                  "kind": "attribute"
+                }
+              ],
+              "resolves": {
+                "global": [
+                  "setattr"
+                ],
+                "import": [
+                  "builtins.setattr"
+                ]
+              }
+            },
+            "callee": {
+              "any": [
+                {
+                  "matches": "ref-setattr"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "callee"
+                  }
+                }
+              ]
+            },
+            "identifier-literal": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "string",
+                      "regex": "^[rRuU]{0,2}['\"]"
+                    },
+                    {
+                      "kind": "concatenated_string",
+                      "not": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "kind": "string",
+                          "not": {
+                            "regex": "^[rRuU]{0,2}['\"]"
+                          }
+                        }
+                      }
+                    }
+                  ],
+                  "value": {
+                    "regex": "^[\\p{XID_Start}_]\\p{XID_Continue}*$"
+                  },
+                  "not": {
+                    "any": [
+                      {
+                        "value": {
+                          "regex": "^(False|None|True|and|as|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|raise|return|try|while|with|yield)$"
+                        }
+                      },
+                      {
+                        "all": [
+                          {
+                            "value": {
+                              "regex": "^__"
+                            }
+                          },
+                          {
+                            "not": {
+                              "value": {
+                                "regex": "__$"
+                              }
+                            }
+                          }
+                        ]
+                      },
+                      {
+                        "value": {
+                          "eq": "__debug__"
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "identifier-literal"
+                  }
+                }
+              ]
+            },
+            "positional": {
+              "not": {
+                "any": [
+                  {
+                    "kind": "keyword_argument"
+                  },
+                  {
+                    "kind": "dictionary_splat"
+                  },
+                  {
+                    "kind": "list_splat"
+                  }
+                ]
+              }
+            },
+            "argument": {
+              "not": {
+                "any": [
+                  {
+                    "kind": "keyword_argument"
+                  },
+                  {
+                    "kind": "dictionary_splat"
+                  }
+                ]
+              }
+            },
+            "no-keywords": {
+              "kind": "argument_list",
+              "not": {
+                "has": {
+                  "stopBy": "neighbor",
+                  "any": [
+                    {
+                      "kind": "keyword_argument"
+                    },
+                    {
+                      "kind": "dictionary_splat"
+                    }
+                  ]
+                }
+              }
+            },
+            "statement-expression": {
+              "inside": {
+                "stopBy": "neighbor",
+                "any": [
+                  {
+                    "kind": "expression_statement",
+                    "not": {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "regex": "^,$"
+                      }
+                    }
+                  },
+                  {
+                    "kind": "parenthesized_expression",
+                    "matches": "statement-expression"
+                  }
+                ]
+              }
+            }
+          },
+          "rule": {
+            "kind": "call",
+            "pattern": "$FUNC($OBJ, $NAME, $VALUE)",
+            "matches": "statement-expression",
+            "has": {
+              "stopBy": "neighbor",
+              "matches": "no-keywords"
+            }
+          },
+          "constraints": {
+            "FUNC": {
+              "matches": "callee"
+            },
+            "OBJ": {
+              "matches": "positional"
+            },
+            "NAME": {
+              "matches": "identifier-literal"
+            },
+            "VALUE": {
+              "matches": "argument"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B010",
+        "message": "Do not call `setattr` with a constant attribute value. It is not any safer than normal property access.",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B010"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-b011-assert-false.json

@@ -0,0 +1,62 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b011-assert-false",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B011 (assert-false): an `assert` statement whose test is the literal `False` (Ruff's `is_const_false`; parentheses transparent), reported on the literal. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/B011.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "assert-false",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "assert-test": {
+              "any": [
+                {
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "^assert$"
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "assert_statement"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "assert-test"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "false",
+            "matches": "assert-test"
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B011",
+        "message": "Do not `assert False` (`python -O` removes these calls), raise `AssertionError()`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B011"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-b013-redundant-tuple-in-exception-handler.json

@@ -0,0 +1,94 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b013-redundant-tuple-in-exception-handler",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B013 (redundant-tuple-in-exception-handler): the type of an `except` (or `except*`) handler is a parenthesized tuple with exactly one element that is not starred. Parentheses around the tuple are transparent, and an `as` name does not matter. Reported on the tuple.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "redundant-tuple-in-exception-handler",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "handler-type": {
+              "inside": {
+                "stopBy": "neighbor",
+                "any": [
+                  {
+                    "kind": "except_clause"
+                  },
+                  {
+                    "kind": "as_pattern",
+                    "inside": {
+                      "stopBy": "neighbor",
+                      "kind": "except_clause"
+                    }
+                  },
+                  {
+                    "kind": "parenthesized_expression",
+                    "matches": "handler-type"
+                  }
+                ]
+              }
+            },
+            "element": {
+              "not": {
+                "any": [
+                  {
+                    "kind": "comment"
+                  },
+                  {
+                    "regex": "^[(),]$"
+                  }
+                ]
+              }
+            }
+          },
+          "rule": {
+            "kind": "tuple",
+            "matches": "handler-type",
+            "all": [
+              {
+                "count": {
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "element"
+                  },
+                  "min": 1,
+                  "max": 1
+                }
+              },
+              {
+                "not": {
+                  "has": {
+                    "stopBy": "neighbor",
+                    "kind": "list_splat"
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B013",
+        "message": "A length-one tuple literal is redundant in exception handlers",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B013"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-b014-duplicate-handler-exception.json

@@ -0,0 +1,126 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b014-duplicate-handler-exception",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B014 (duplicate-handler-exception): the type of an `except` (or `except*`) handler is a tuple in which the same dotted name (a name or an attribute chain of names, Ruff's `UnqualifiedName`) occurs more than once (parentheses around an element are transparent). Reported once on the tuple, whatever the number of duplicates.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "duplicate-handler-exception",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "handler-type": {
+              "inside": {
+                "stopBy": "neighbor",
+                "any": [
+                  {
+                    "kind": "except_clause"
+                  },
+                  {
+                    "kind": "as_pattern",
+                    "inside": {
+                      "stopBy": "neighbor",
+                      "kind": "except_clause"
+                    }
+                  },
+                  {
+                    "kind": "parenthesized_expression",
+                    "matches": "handler-type"
+                  }
+                ]
+              }
+            },
+            "dotted-name": {
+              "any": [
+                {
+                  "kind": "identifier"
+                },
+                {
+                  "kind": "attribute",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "kind": "identifier",
+                    "precedes": {
+                      "stopBy": "neighbor",
+                      "regex": "^\\.$"
+                    },
+                    "matches": "dotted-name"
+                  }
+                },
+                {
+                  "kind": "attribute",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "kind": "attribute",
+                    "matches": "dotted-name"
+                  }
+                }
+              ]
+            },
+            "element": {
+              "any": [
+                {
+                  "matches": "dotted-name",
+                  "pattern": "$NAME"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "element"
+                  }
+                }
+              ]
+            },
+            "same-element": {
+              "any": [
+                {
+                  "pattern": "$NAME"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "same-element"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "tuple",
+            "matches": "handler-type",
+            "has": {
+              "stopBy": "neighbor",
+              "matches": "element",
+              "precedes": {
+                "stopBy": "end",
+                "matches": "same-element"
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B014",
+        "message": "Exception handler with duplicate exception: `$NAME`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B014"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-b016-raise-literal.json

@@ -0,0 +1,47 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b016-raise-literal",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B016 (raise-literal): the exception of a `raise` statement is a literal (Ruff's `is_literal_expr`: string, bytes, number, `True`/`False`, `None`, `...`; not an f-string or t-string, including an implicit concatenation with one; parentheses transparent). Reported on the literal.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "raise-literal",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "plain-string": {
+              "kind": "string",
+              "not": { "has": { "stopBy": "neighbor", "kind": "string_start", "regex": "[fFtT]" } }
+            },
+            "raised": {
+              "any": [
+                {
+                  "follows": { "stopBy": "neighbor", "regex": "^raise$" },
+                  "inside": { "stopBy": "neighbor", "kind": "raise_statement" }
+                },
+                { "inside": { "stopBy": "neighbor", "kind": "parenthesized_expression", "matches": "raised" } }
+              ]
+            }
+          },
+          "rule": {
+            "matches": "raised",
+            "any": [
+              { "matches": "plain-string" },
+              { "kind": "concatenated_string", "not": { "has": { "stopBy": "neighbor", "kind": "string", "not": { "matches": "plain-string" } } } },
+              { "kind": "integer" },
+              { "kind": "float" },
+              { "kind": "true" },
+              { "kind": "false" },
+              { "kind": "none" },
+              { "kind": "ellipsis" }
+            ]
+          }
+        }
+      },
+      "violation": { "anchor": "witness.span", "code": "B016", "message": "Cannot raise a literal. Did you intend to return it or raise an Exception?", "suppress": { "noqa": { "codes": ["B016"] } } }
+    }
+  ]
+}