@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-f525-string-dot-format-mixing-automatic.json

@@ -0,0 +1,99 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f525-string-dot-format-mixing-automatic",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F525 (string-dot-format-mixing-automatic): a `.format` call on a valid format string with both an automatically numbered field (`{}`) and a manually numbered one (`{0}`), nested fields in specs included. The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) receiving `.format`, read with the `braceFormat` grammar (a port of ruff_python_literal's format parser as pyflakes' FormatSummary reads it).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "string-dot-format-mixing-automatic",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "plain-string": {
+              "any": [
+                {
+                  "kind": "string",
+                  "not": {
+                    "regex": "^[A-Za-z]*[fFbBtT][A-Za-z]*['\"]"
+                  }
+                },
+                {
+                  "kind": "concatenated_string",
+                  "not": {
+                    "has": {
+                      "kind": "string",
+                      "regex": "^[A-Za-z]*[fFbBtT][A-Za-z]*['\"]"
+                    }
+                  }
+                }
+              ]
+            },
+            "format-string": {
+              "any": [
+                {
+                  "matches": "plain-string",
+                  "parse": {
+                    "grammar": "braceFormat",
+                    "not": {
+                      "has": {
+                        "kind": "error"
+                      }
+                    },
+                    "all": [
+                      {
+                        "has": {
+                          "kind": "auto",
+                          "stopBy": "end"
+                        }
+                      },
+                      {
+                        "has": {
+                          "kind": "index",
+                          "stopBy": "end"
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "format-string"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "pattern": "$S.format($$$A)"
+          },
+          "constraints": {
+            "S": {
+              "matches": "format-string"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F525",
+        "message": "`.format` string mixes automatic and manual numbering",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F525"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f541-f-string-missing-placeholders.json

@@ -0,0 +1,52 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f541-f-string-missing-placeholders",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F541 (f-string-missing-placeholders) with default settings: every f-string part of a string expression (an implicit concatenation counts as one expression) when no f-string part of that expression has a replacement field. `{{`/`}}` escapes are not placeholders; nested f-strings inside a replacement field or format spec are their own expressions.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "f-string-missing-placeholders",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "has-placeholder": {
+              "kind": "string",
+              "has": { "stopBy": "neighbor", "kind": "interpolation" }
+            }
+          },
+          "rule": {
+            "kind": "string",
+            "has": { "stopBy": "neighbor", "kind": "string_start", "regex": "^[A-Za-z]*[fF]" },
+            "not": {
+              "any": [
+                { "matches": "has-placeholder" },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "concatenated_string",
+                    "has": { "stopBy": "neighbor", "matches": "has-placeholder" }
+                  }
+                }
+              ]
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F541",
+        "message": "f-string without any placeholders",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F541"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f601-multi-value-repeated-key-literal.json

@@ -0,0 +1,215 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f601-multi-value-repeated-key-literal",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F601 (multi-value-repeated-key-literal) with default settings: a literal dictionary key (string, bytes, number, boolean, None, Ellipsis, tuple, f-string, signed number, real +/- imaginary; Ruff's is_literal_key) equal to an earlier key of the same dict display, reported on each repeat (parentheses are transparent). Equality is Ruff's HashableExpr (`compare` `text: \"structure-hash\"`): numbers fold by value (`1 == 1.0 == True`, `1 + 0j == 1`), strings by decoded value, tuples of constants element by element, anything else structurally as ComparableExpr (names without NFKC normalization). Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F601.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "multi-value-repeated-key-literal",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "complex": {
+              "any": [
+                {
+                  "kind": "integer"
+                },
+                {
+                  "kind": "float"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "complex"
+                  }
+                }
+              ],
+              "regex": "[jJ]\\)*$"
+            },
+            "literal-key": {
+              "any": [
+                {
+                  "kind": "string",
+                  "not": {
+                    "regex": "^[A-Za-z]*[tT]"
+                  }
+                },
+                {
+                  "kind": "concatenated_string",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "string",
+                      "regex": "^[A-Za-z]*[tT]"
+                    }
+                  }
+                },
+                {
+                  "kind": "integer"
+                },
+                {
+                  "kind": "float"
+                },
+                {
+                  "kind": "true"
+                },
+                {
+                  "kind": "false"
+                },
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "ellipsis"
+                },
+                {
+                  "kind": "tuple"
+                },
+                {
+                  "kind": "unary_operator",
+                  "regex": "^[-+]",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "signed-literal"
+                  }
+                },
+                {
+                  "kind": "binary_operator",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "regex": "^[-+]$",
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "matches": "signed-literal",
+                      "not": {
+                        "regex": "[jJ]\\)*$"
+                      }
+                    },
+                    "precedes": {
+                      "stopBy": "neighbor",
+                      "matches": "complex"
+                    }
+                  }
+                }
+              ]
+            },
+            "signed-literal": {
+              "any": [
+                {
+                  "kind": "integer"
+                },
+                {
+                  "kind": "float"
+                },
+                {
+                  "kind": "unary_operator",
+                  "regex": "^[-+]",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "signed-literal"
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "signed-literal"
+                  }
+                }
+              ]
+            },
+            "key-slot": {
+              "any": [
+                {
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    }
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "pair"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "key-slot"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "pattern": "$KEY",
+            "not": {
+              "kind": "parenthesized_expression"
+            },
+            "all": [
+              {
+                "matches": "literal-key"
+              },
+              {
+                "matches": "key-slot"
+              }
+            ],
+            "inside": {
+              "stopBy": {
+                "not": {
+                  "kind": "parenthesized_expression"
+                }
+              },
+              "kind": "pair",
+              "count": {
+                "follows": {
+                  "stopBy": "end",
+                  "kind": "pair",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "not": {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "(?s)."
+                      }
+                    },
+                    "pattern": "$J"
+                  },
+                  "compare": {
+                    "left": "J",
+                    "op": "eq",
+                    "right": "KEY",
+                    "text": "structure-hash"
+                  }
+                },
+                "min": 1
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F601",
+        "message": "Dictionary key literal `$KEY` repeated",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F601"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f602-multi-value-repeated-key-variable.json

@@ -0,0 +1,123 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f602-multi-value-repeated-key-variable",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F602 (multi-value-repeated-key-variable) with default settings: a dictionary key that is a bare name equal to an earlier key of the same dict display, reported on each repeat (parentheses transparent).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "multi-value-repeated-key-variable",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "dict-key": {
+              "any": [
+                {
+                  "not": {
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    }
+                  },
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "pair"
+                  }
+                },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "kind": "parenthesized_expression",
+                    "matches": "dict-key"
+                  }
+                }
+              ]
+            },
+            "earlier-same": {
+              "any": [
+                {
+                  "not": {
+                    "kind": "parenthesized_expression"
+                  },
+                  "pattern": "$EARLIER",
+                  "kind": "identifier",
+                  "compare": {
+                    "left": "EARLIER",
+                    "op": "eq",
+                    "right": "KEY"
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "earlier-same"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "all": [
+              {
+                "pattern": "$KEY"
+              },
+              {
+                "not": {
+                  "kind": "parenthesized_expression"
+                }
+              },
+              {
+                "kind": "identifier"
+              },
+              {
+                "matches": "dict-key"
+              },
+              {
+                "inside": {
+                  "stopBy": {
+                    "kind": "pair"
+                  },
+                  "kind": "pair",
+                  "follows": {
+                    "stopBy": "end",
+                    "kind": "pair",
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "follows": {
+                          "stopBy": "neighbor",
+                          "regex": "(?s)."
+                        }
+                      },
+                      "matches": "earlier-same"
+                    }
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F602",
+        "message": "Dictionary key `$KEY` repeated",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F602"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f622-multiple-starred-expressions.json

@@ -0,0 +1,57 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f622-multiple-starred-expressions",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F622 (multiple-starred-expressions, a semantic syntax error) with default settings: a tuple or list assignment target (assignment, `for`, comprehension `for`, `with ... as`), at any nesting, with two or more starred elements of its own. Reported on the target tuple or list, parentheses included.",
+  "scope": { "include": ["**/*"], "exclude": [] },
+  "clauses": [
+    {
+      "id": "multiple-starred-expressions",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "with-target": {
+              "any": [
+                { "inside": { "stopBy": "neighbor", "kind": "as_pattern_target" } },
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "any": [{ "kind": "tuple" }, { "kind": "list" }, { "kind": "parenthesized_expression" }],
+                    "matches": "with-target"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "any": [
+              {
+                "any": [{ "kind": "pattern_list" }, { "kind": "tuple_pattern" }, { "kind": "list_pattern" }],
+                "count": { "has": { "stopBy": "neighbor", "kind": "list_splat_pattern" }, "min": 2 }
+              },
+              {
+                "any": [{ "kind": "tuple" }, { "kind": "list" }],
+                "matches": "with-target",
+                "count": { "has": { "stopBy": "neighbor", "kind": "list_splat" }, "min": 2 }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F622",
+        "message": "Two starred expressions in assignment",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F622"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}