@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-b003-assignment-to-os-environ.json

@@ -0,0 +1,54 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b003-assignment-to-os-environ",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B003 (assignment-to-os-environ): a plain assignment statement with exactly one target, that target being the attribute `os.environ` (the name `os`, not resolved; parentheses around the target are transparent). Chained assignments (several targets), annotated and augmented assignments are not checked, as in Ruff. Reported on the attribute.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "assignment-to-os-environ",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "single-target-assignment": {
+              "kind": "assignment",
+              "not": {
+                "any": [
+                  { "has": { "stopBy": "neighbor", "regex": "^:$" } },
+                  { "has": { "stopBy": "neighbor", "kind": "assignment" } },
+                  { "inside": { "stopBy": "neighbor", "kind": "assignment" } }
+                ]
+              }
+            },
+            "sole-target": {
+              "any": [
+                {
+                  "precedes": { "stopBy": "neighbor", "regex": "^=$" },
+                  "inside": { "stopBy": "neighbor", "matches": "single-target-assignment" }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      { "kind": "parenthesized_expression" },
+                      { "kind": "tuple_pattern", "not": { "has": { "stopBy": "neighbor", "regex": "^,$" } } }
+                    ],
+                    "matches": "sole-target"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "attribute",
+            "pattern": "os.environ",
+            "matches": "sole-target"
+          }
+        }
+      },
+      "violation": { "anchor": "witness.span", "code": "B003", "message": "Assigning to `os.environ` doesn't clear the environment", "suppress": { "noqa": { "codes": ["B003"] } } }
+    }
+  ]
+}

package/rules/ruff-b004-unreliable-callable-check.json

@@ -0,0 +1,171 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b004-unreliable-callable-check",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B004 (unreliable-callable-check): `hasattr(x, \"__call__\")` with exactly two positional arguments, or `getattr(x, \"__call__\")` / `getattr(x, \"__call__\", default)` with two or three, no keyword arguments, the second argument a str literal (not bytes, an f- or t-string; parentheses transparent) whose value is `__call__` (escapes decoded, implicit concatenations joined). The callee (parentheses transparent) resolves to the builtin `hasattr`/`getattr` (Ruff's `resolve_builtin_symbol`, via `resolves`): the unshadowed name, or that attribute of the `builtins` module through the file's imports. Reported on the call.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "unreliable-callable-check",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "call-string": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "string",
+                      "regex": "^[rRuU]{0,2}['\"]"
+                    },
+                    {
+                      "kind": "concatenated_string",
+                      "not": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "kind": "string",
+                          "not": {
+                            "regex": "^[rRuU]{0,2}['\"]"
+                          }
+                        }
+                      }
+                    }
+                  ],
+                  "value": {
+                    "eq": "__call__"
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "call-string"
+                  }
+                }
+              ]
+            },
+            "positional": {
+              "not": {
+                "any": [
+                  {
+                    "kind": "keyword_argument"
+                  },
+                  {
+                    "kind": "dictionary_splat"
+                  }
+                ]
+              }
+            },
+            "builtin-callee": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "global": [
+                      "hasattr",
+                      "getattr"
+                    ],
+                    "import": [
+                      "builtins.hasattr",
+                      "builtins.getattr"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "builtin-callee"
+                  }
+                }
+              ]
+            },
+            "getattr-callee": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "global": [
+                      "getattr"
+                    ],
+                    "import": [
+                      "builtins.getattr"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "getattr-callee"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "call",
+            "any": [
+              {
+                "pattern": "$FUNC($OBJ, $ATTR)"
+              },
+              {
+                "pattern": "$GETATTR($OBJ, $ATTR, $DEFAULT)"
+              }
+            ]
+          },
+          "constraints": {
+            "FUNC": {
+              "matches": "builtin-callee"
+            },
+            "GETATTR": {
+              "matches": "getattr-callee"
+            },
+            "OBJ": {
+              "matches": "positional"
+            },
+            "ATTR": {
+              "matches": "call-string"
+            },
+            "DEFAULT": {
+              "matches": "positional"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B004",
+        "message": "Using `hasattr(x, \"__call__\")` to test if x is callable is unreliable. Use `callable(x)` for consistent results.",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B004"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-b005-strip-with-multi-characters.json

@@ -0,0 +1,131 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b005-strip-with-multi-characters",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B005 (strip-with-multi-characters): `.strip`/`.lstrip`/`.rstrip` called with exactly one positional argument that is a str literal (not bytes, an f- or t-string; escapes decoded, implicit concatenations joined) whose value repeats a character, tested with a backreference (`(.).*\\1`). Reported on the call.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "strip-with-multi-characters",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "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": "(?s)(.).*\\1"
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "literal"
+                  }
+                }
+              ]
+            },
+            "positional": {
+              "not": {
+                "any": [
+                  {
+                    "kind": "keyword_argument"
+                  },
+                  {
+                    "kind": "dictionary_splat"
+                  },
+                  {
+                    "kind": "comment"
+                  },
+                  {
+                    "regex": "^[(),]$"
+                  }
+                ]
+              }
+            }
+          },
+          "rule": {
+            "kind": "call",
+            "has": {
+              "stopBy": "neighbor",
+              "kind": "attribute",
+              "has": {
+                "stopBy": "neighbor",
+                "kind": "identifier",
+                "regex": "^[lr]?strip$",
+                "follows": {
+                  "stopBy": "neighbor",
+                  "regex": "^\\.$"
+                }
+              }
+            },
+            "all": [
+              {
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "argument_list",
+                  "all": [
+                    {
+                      "count": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "matches": "positional"
+                        },
+                        "min": 1,
+                        "max": 1
+                      }
+                    },
+                    {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "matches": "literal"
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B005",
+        "message": "Using `.strip()` with multi-character strings is misleading",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B005"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}