@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-b020-loop-variable-overrides-iterator.json

@@ -0,0 +1,341 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b020-loop-variable-overrides-iterator",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B020 (loop-variable-overrides-iterator): a name in a `for` loop's target that also occurs as a name in its iterable, where comprehensions in the iterable contribute only the iterables of their `for` clauses and lambdas the children of their body (Ruff's `NameFinder` walks the body's children, so `lambda: x` adds nothing). A name that is a (non-variadic) parameter of a lambda in the iterable is exempt unless it occurs again after that lambda, as Ruff's walk removes it and a later occurrence adds it back. Reported on each such target name (Ruff reports only the last occurrence of a name repeated in the target).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "loop-variable-overrides-iterator",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "name-ref": {
+              "kind": "identifier",
+              "pattern": "$NAME",
+              "not": {
+                "any": [
+                  {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "^\\.$"
+                    }
+                  },
+                  {
+                    "precedes": {
+                      "stopBy": "neighbor",
+                      "regex": "^=$"
+                    },
+                    "inside": {
+                      "stopBy": "neighbor",
+                      "kind": "keyword_argument"
+                    }
+                  }
+                ]
+              }
+            },
+            "mentions": {
+              "any": [
+                {
+                  "matches": "name-ref"
+                },
+                {
+                  "any": [
+                    {
+                      "kind": "list_comprehension"
+                    },
+                    {
+                      "kind": "set_comprehension"
+                    },
+                    {
+                      "kind": "dictionary_comprehension"
+                    },
+                    {
+                      "kind": "generator_expression"
+                    }
+                  ],
+                  "has": {
+                    "stopBy": "neighbor",
+                    "kind": "for_in_clause",
+                    "has": {
+                      "stopBy": "neighbor",
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "^in$"
+                      },
+                      "matches": "mentions"
+                    }
+                  }
+                },
+                {
+                  "kind": "lambda",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "^:$"
+                    },
+                    "matches": "lambda-body"
+                  }
+                },
+                {
+                  "not": {
+                    "any": [
+                      {
+                        "kind": "list_comprehension"
+                      },
+                      {
+                        "kind": "set_comprehension"
+                      },
+                      {
+                        "kind": "dictionary_comprehension"
+                      },
+                      {
+                        "kind": "generator_expression"
+                      },
+                      {
+                        "kind": "lambda"
+                      }
+                    ]
+                  },
+                  "matches": "mentions-inside"
+                }
+              ]
+            },
+            "lambda-body": {
+              "any": [
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "lambda-body"
+                  }
+                },
+                {
+                  "not": {
+                    "kind": "parenthesized_expression"
+                  },
+                  "has": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "matches": "mentions"
+                      },
+                      {
+                        "any": [
+                          {
+                            "kind": "for_in_clause"
+                          },
+                          {
+                            "kind": "if_clause"
+                          }
+                        ],
+                        "has": {
+                          "stopBy": "neighbor",
+                          "matches": "mentions"
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            "mentions-inside": {
+              "has": {
+                "stopBy": {
+                  "any": [
+                    {
+                      "kind": "list_comprehension"
+                    },
+                    {
+                      "kind": "set_comprehension"
+                    },
+                    {
+                      "kind": "dictionary_comprehension"
+                    },
+                    {
+                      "kind": "generator_expression"
+                    },
+                    {
+                      "kind": "lambda"
+                    }
+                  ]
+                },
+                "any": [
+                  {
+                    "matches": "name-ref"
+                  },
+                  {
+                    "any": [
+                      {
+                        "kind": "list_comprehension"
+                      },
+                      {
+                        "kind": "set_comprehension"
+                      },
+                      {
+                        "kind": "dictionary_comprehension"
+                      },
+                      {
+                        "kind": "generator_expression"
+                      },
+                      {
+                        "kind": "lambda"
+                      }
+                    ],
+                    "matches": "mentions"
+                  }
+                ]
+              }
+            },
+            "lambda-parameter": {
+              "kind": "lambda",
+              "has": {
+                "stopBy": "neighbor",
+                "kind": "lambda_parameters",
+                "has": {
+                  "stopBy": "neighbor",
+                  "any": [
+                    {
+                      "kind": "identifier",
+                      "pattern": "$NAME"
+                    },
+                    {
+                      "kind": "default_parameter",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "identifier",
+                        "pattern": "$NAME",
+                        "precedes": {
+                          "stopBy": "neighbor",
+                          "regex": "^=$"
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            },
+            "shadowing-lambda": {
+              "matches": "lambda-parameter",
+              "not": {
+                "matches": "later-mention"
+              }
+            },
+            "later-mention": {
+              "any": [
+                {
+                  "precedes": {
+                    "stopBy": "end",
+                    "matches": "mentions"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "not": {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "^in$"
+                      },
+                      "inside": {
+                        "stopBy": "neighbor",
+                        "kind": "for_statement"
+                      }
+                    },
+                    "matches": "later-mention"
+                  }
+                }
+              ]
+            },
+            "in-target": {
+              "any": [
+                {
+                  "precedes": {
+                    "stopBy": "neighbor",
+                    "regex": "^in$"
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "for_statement",
+                    "has": {
+                      "stopBy": "neighbor",
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "^in$"
+                      },
+                      "all": [
+                        {
+                          "matches": "mentions"
+                        },
+                        {
+                          "not": {
+                            "any": [
+                              {
+                                "matches": "shadowing-lambda"
+                              },
+                              {
+                                "has": {
+                                  "stopBy": "end",
+                                  "matches": "shadowing-lambda"
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "matches": "in-target"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "identifier",
+            "all": [
+              {
+                "pattern": "$NAME"
+              },
+              {
+                "not": {
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "^\\.$"
+                  }
+                }
+              },
+              {
+                "matches": "in-target"
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B020",
+        "message": "Loop control variable `$NAME` overrides iterable it iterates",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B020"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-b021-f-string-docstring.json

@@ -0,0 +1,48 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b021-f-string-docstring",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B021 (f-string-docstring): the first statement of a module, function or class body is an expression statement whose value is an f-string (an `f`-prefixed literal, or an implicit concatenation containing one; parentheses transparent). Comments before it are not statements. Reported on the statement.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "f-string-docstring",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "f-string": {
+              "any": [
+                { "kind": "string", "has": { "stopBy": "neighbor", "kind": "string_start", "regex": "[fF]" } },
+                { "kind": "concatenated_string", "has": { "stopBy": "neighbor", "matches": "f-string" } },
+                { "kind": "parenthesized_expression", "has": { "stopBy": "neighbor", "matches": "f-string" } }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "expression_statement",
+            "all": [
+              { "has": { "stopBy": "neighbor", "matches": "f-string" } },
+              { "not": { "has": { "stopBy": "neighbor", "regex": "^,$" } } },
+              { "not": { "follows": { "stopBy": "end", "not": { "kind": "comment" } } } },
+              {
+                "any": [
+                  { "inside": { "stopBy": "neighbor", "kind": "module" } },
+                  {
+                    "inside": {
+                      "stopBy": "neighbor",
+                      "kind": "block",
+                      "inside": { "stopBy": "neighbor", "any": [ { "kind": "function_definition" }, { "kind": "class_definition" } ] }
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      },
+      "violation": { "anchor": "witness.span", "code": "B021", "message": "f-string used as docstring. Python will interpret this as a joined string, rather than a docstring.", "suppress": { "noqa": { "codes": ["B021"] } } }
+    }
+  ]
+}

package/rules/ruff-b022-useless-contextlib-suppress.json

@@ -0,0 +1,95 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-b022-useless-contextlib-suppress",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's B022 (useless-contextlib-suppress): a call to `contextlib.suppress` with no positional arguments, reported on the call. The callee (parentheses transparent) resolves to `contextlib.suppress` with `resolves` (imports and shadowing as Ruff's semantic model sees them).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "useless-contextlib-suppress",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "suppress": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "import": [
+                      "contextlib.suppress"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "suppress"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "call",
+            "has": {
+              "stopBy": "neighbor",
+              "kind": "argument_list",
+              "not": {
+                "has": {
+                  "stopBy": "neighbor",
+                  "not": {
+                    "any": [
+                      {
+                        "kind": "keyword_argument"
+                      },
+                      {
+                        "kind": "dictionary_splat"
+                      },
+                      {
+                        "kind": "comment"
+                      },
+                      {
+                        "regex": "^[(),]$"
+                      }
+                    ]
+                  }
+                }
+              },
+              "follows": {
+                "stopBy": "neighbor",
+                "matches": "suppress"
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "B022",
+        "message": "No arguments passed to `contextlib.suppress`. No exceptions will be suppressed and therefore this context manager is redundant",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "B022"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}