@neralabs/rerail-pack-python 0.1.1

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

@@ -0,0 +1,232 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f632-is-literal",
+  "revision": 1,
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "is-literal",
+      "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 `==` to compare constant literals",
+        "each": "O",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F632"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,299 @@
+{
+  "format": "rerail.policy/v1",
+  "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).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "invalid-print-syntax",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "print-binding": {
+              "kind": "identifier",
+              "regex": "^print$",
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "assignment"
+                      },
+                      {
+                        "kind": "augmented_assignment"
+                      },
+                      {
+                        "kind": "named_expression"
+                      }
+                    ]
+                  },
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    }
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "pattern_list"
+                      },
+                      {
+                        "kind": "tuple_pattern"
+                      },
+                      {
+                        "kind": "list_pattern"
+                      },
+                      {
+                        "kind": "list_splat_pattern"
+                      },
+                      {
+                        "kind": "as_pattern_target"
+                      }
+                    ]
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "for_statement"
+                      },
+                      {
+                        "kind": "for_in_clause"
+                      }
+                    ]
+                  },
+                  "precedes": {
+                    "stopBy": "neighbor",
+                    "regex": "^in$"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "function_definition"
+                      },
+                      {
+                        "kind": "class_definition"
+                      }
+                    ]
+                  },
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "^(def|class)$"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "parameters"
+                      },
+                      {
+                        "kind": "lambda_parameters"
+                      },
+                      {
+                        "kind": "dictionary_splat_pattern"
+                      }
+                    ]
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "default_parameter"
+                      },
+                      {
+                        "kind": "typed_parameter"
+                      },
+                      {
+                        "kind": "typed_default_parameter"
+                      }
+                    ]
+                  },
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    }
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "aliased_import"
+                  },
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "^as$"
+                  }
+                },
+                {
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    }
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "dotted_name",
+                    "any": [
+                      {
+                        "inside": {
+                          "stopBy": "neighbor",
+                          "kind": "import_statement"
+                        }
+                      },
+                      {
+                        "inside": {
+                          "stopBy": "neighbor",
+                          "kind": "import_from_statement"
+                        },
+                        "follows": {
+                          "stopBy": "end",
+                          "regex": "^import$"
+                        },
+                        "not": {
+                          "has": {
+                            "stopBy": "neighbor",
+                            "regex": "^\\.$"
+                          }
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "kind": "global_statement"
+                      },
+                      {
+                        "kind": "nonlocal_statement"
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            "rshift-left": {
+              "any": [
+                {
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    }
+                  },
+                  "precedes": {
+                    "stopBy": "neighbor",
+                    "regex": "^>>$"
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "binary_operator"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "rshift-left"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "any": [
+              {
+                "regex": "^print$",
+                "inside": {
+                  "stopBy": "neighbor",
+                  "kind": "print_statement",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "kind": "chevron"
+                  }
+                },
+                "not": {
+                  "follows": {
+                    "stopBy": "neighbor",
+                    "regex": "(?s)."
+                  }
+                },
+                "all": [
+                  {
+                    "not": {
+                      "inside": {
+                        "stopBy": "end",
+                        "kind": "module",
+                        "has": {
+                          "stopBy": "end",
+                          "matches": "print-binding"
+                        }
+                      }
+                    }
+                  }
+                ]
+              },
+              {
+                "any": [
+                  {
+                    "kind": "identifier"
+                  },
+                  {
+                    "kind": "attribute"
+                  }
+                ],
+                "matches": "rshift-left",
+                "resolves": {
+                  "global": [
+                    "print"
+                  ],
+                  "import": [
+                    "builtins.print"
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F633",
+        "message": "Use of `>>` is invalid with `print` function",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F633"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,64 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "break-outside-loop",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "break_statement",
+            "not": {
+              "inside": {
+                "stopBy": {
+                  "any": [
+                    {
+                      "kind": "function_definition"
+                    },
+                    {
+                      "kind": "class_definition"
+                    }
+                  ]
+                },
+                "kind": "block",
+                "inside": {
+                  "stopBy": "neighbor",
+                  "any": [
+                    {
+                      "kind": "for_statement"
+                    },
+                    {
+                      "kind": "while_statement"
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F701",
+        "message": "`break` outside loop",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F701"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

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

@@ -0,0 +1,64 @@
+{
+  "format": "rerail.policy/v1",
+  "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.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "continue-outside-loop",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "continue_statement",
+            "not": {
+              "inside": {
+                "stopBy": {
+                  "any": [
+                    {
+                      "kind": "function_definition"
+                    },
+                    {
+                      "kind": "class_definition"
+                    }
+                  ]
+                },
+                "kind": "block",
+                "inside": {
+                  "stopBy": "neighbor",
+                  "any": [
+                    {
+                      "kind": "for_statement"
+                    },
+                    {
+                      "kind": "while_statement"
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F702",
+        "message": "`continue` not properly in loop",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F702"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}