@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-b007-unused-loop-control-variable.json

@@ -0,0 +1,368 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b007-unused-loop-control-variable",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B007 (unused-loop-control-variable) with the default `dummy-variable-rgx`: a name bound by a `for` loop's target (itself, or inside tuple/list/starred targets) that does not match `^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$` and never occurs as a name expression in the loop body (the `else` clause does not count; attribute members, keyword-argument names, def/class names, parameters, import and global/nonlocal names and except-handler names are not name expressions). The message says `may not be used` when the body calls `locals`/`globals`/`vars`/`exec`/`eval` (by spelling; Ruff checks they are builtins). Match-statement capture, keyword-pattern, star and `as` names are not name expressions either. Reported on the target name.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "shared",
+      "define": {
+        "language": "python",
+        "utils": {
+          "in-target": {
+            "any": [
+              {
+                "precedes": {
+                  "stopBy": "neighbor",
+                  "regex": "^in$"
+                },
+                "inside": {
+                  "stopBy": "neighbor",
+                  "kind": "for_statement",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "block",
+                      "has": {
+                        "stopBy": "end",
+                        "kind": "identifier",
+                        "pattern": "$NAME",
+                        "not": {
+                          "matches": "not-a-name"
+                        }
+                      }
+                    }
+                  }
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": "neighbor",
+                  "any": [
+                    {
+                      "kind": "pattern_list"
+                    },
+                    {
+                      "kind": "tuple_pattern"
+                    },
+                    {
+                      "kind": "list_pattern"
+                    },
+                    {
+                      "kind": "list_splat_pattern"
+                    },
+                    {
+                      "kind": "parenthesized_expression"
+                    }
+                  ],
+                  "matches": "in-target"
+                }
+              }
+            ]
+          },
+          "magic": {
+            "kind": "call",
+            "has": {
+              "stopBy": "neighbor",
+              "kind": "identifier",
+              "regex": "^(locals|globals|vars|exec|eval)$",
+              "precedes": {
+                "stopBy": "neighbor",
+                "kind": "argument_list"
+              }
+            }
+          },
+          "not-a-name": {
+            "any": [
+              {
+                "follows": {
+                  "stopBy": "neighbor",
+                  "regex": "^\\.$"
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": "neighbor",
+                  "kind": "keyword_argument"
+                },
+                "precedes": {
+                  "stopBy": "neighbor",
+                  "regex": "^=$"
+                }
+              },
+              {
+                "follows": {
+                  "stopBy": "neighbor",
+                  "regex": "^(def|class)$"
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": "neighbor",
+                  "any": [
+                    {
+                      "kind": "parameters"
+                    },
+                    {
+                      "kind": "lambda_parameters"
+                    }
+                  ]
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": "neighbor",
+                  "any": [
+                    {
+                      "kind": "default_parameter"
+                    },
+                    {
+                      "kind": "typed_parameter"
+                    },
+                    {
+                      "kind": "typed_default_parameter"
+                    }
+                  ],
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "parameters"
+                      },
+                      {
+                        "kind": "lambda_parameters"
+                      }
+                    ]
+                  }
+                },
+                "precedes": {
+                  "stopBy": "neighbor",
+                  "regex": "^[=:]$"
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": "neighbor",
+                  "any": [
+                    {
+                      "kind": "list_splat_pattern"
+                    },
+                    {
+                      "kind": "dictionary_splat_pattern"
+                    }
+                  ],
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "parameters"
+                      },
+                      {
+                        "kind": "lambda_parameters"
+                      },
+                      {
+                        "kind": "typed_parameter"
+                      }
+                    ]
+                  }
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": "neighbor",
+                  "kind": "dotted_name",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "regex": "^\\.$"
+                    }
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "case_pattern"
+                      },
+                      {
+                        "kind": "keyword_pattern"
+                      }
+                    ]
+                  }
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": "neighbor",
+                  "kind": "keyword_pattern"
+                },
+                "precedes": {
+                  "stopBy": "neighbor",
+                  "regex": "^=$"
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": "neighbor",
+                  "kind": "splat_pattern"
+                }
+              },
+              {
+                "follows": {
+                  "stopBy": "neighbor",
+                  "regex": "^as$"
+                },
+                "inside": {
+                  "stopBy": "neighbor",
+                  "kind": "as_pattern",
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "case_pattern"
+                  }
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": "end",
+                  "any": [
+                    {
+                      "kind": "import_statement"
+                    },
+                    {
+                      "kind": "import_from_statement"
+                    },
+                    {
+                      "kind": "future_import_statement"
+                    },
+                    {
+                      "kind": "global_statement"
+                    },
+                    {
+                      "kind": "nonlocal_statement"
+                    }
+                  ]
+                }
+              },
+              {
+                "inside": {
+                  "stopBy": "neighbor",
+                  "kind": "as_pattern_target",
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "as_pattern",
+                    "inside": {
+                      "stopBy": "neighbor",
+                      "kind": "except_clause"
+                    }
+                  }
+                }
+              }
+            ]
+          },
+          "uncertain": {
+            "inside": {
+              "stopBy": {
+                "kind": "for_statement"
+              },
+              "kind": "for_statement",
+              "has": {
+                "stopBy": "neighbor",
+                "kind": "block",
+                "has": {
+                  "stopBy": "end",
+                  "matches": "magic"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      "id": "unused-loop-control-variable",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "identifier",
+            "all": [
+              {
+                "pattern": "$NAME"
+              },
+              {
+                "not": {
+                  "regex": "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+                }
+              },
+              {
+                "matches": "in-target"
+              },
+              {
+                "not": {
+                  "matches": "uncertain"
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B007",
+        "message": "Loop control variable `$NAME` not used within loop body",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B007"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "id": "unused-loop-control-variable-uncertain",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "identifier",
+            "all": [
+              {
+                "pattern": "$NAME"
+              },
+              {
+                "not": {
+                  "regex": "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+                }
+              },
+              {
+                "matches": "in-target"
+              },
+              {
+                "matches": "uncertain"
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B007",
+        "message": "Loop control variable `$NAME` may not be used within loop body",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B007"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-b009-get-attr-with-constant.json

@@ -0,0 +1,190 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b009-get-attr-with-constant",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B009 (getattr-with-constant): `getattr(obj, \"name\")` with exactly two positional arguments and no keyword arguments, `obj` not starred, the second 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) and not a mangled private name (`__x` without a trailing `__`). The callee (parentheses transparent) resolves to the builtin `getattr` (Ruff's `match_builtin_expr`): the unshadowed name, or `getattr` of the `builtins` module through the file's imports. Reported on the call.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "getattr-with-constant",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "ref-getattr": {
+              "any": [
+                {
+                  "kind": "identifier"
+                },
+                {
+                  "kind": "attribute"
+                }
+              ],
+              "resolves": {
+                "global": [
+                  "getattr"
+                ],
+                "import": [
+                  "builtins.getattr"
+                ]
+              }
+            },
+            "callee": {
+              "any": [
+                {
+                  "matches": "ref-getattr"
+                },
+                {
+                  "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": "__$"
+                              }
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                },
+                {
+                  "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"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "rule": {
+            "kind": "call",
+            "pattern": "$FUNC($OBJ, $NAME)",
+            "has": {
+              "stopBy": "neighbor",
+              "matches": "no-keywords"
+            }
+          },
+          "constraints": {
+            "FUNC": {
+              "matches": "callee"
+            },
+            "OBJ": {
+              "matches": "positional"
+            },
+            "NAME": {
+              "matches": "identifier-literal"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B009",
+        "message": "Do not call `getattr` with a constant attribute value. It is not any safer than normal property access.",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B009"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}