@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-f505-percent-format-missing-argument.json

@@ -0,0 +1,49 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f505-percent-format-missing-argument",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F505 (percent-format-missing-argument): a valid `%`-format string without positional placeholders applied to a dict display without `**`, all of whose keys are string literals, that passes no value for some `%(key)` placeholder. `formatArgs` reads the format string left of `%` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser), and the right operand as Ruff's strings.rs does.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "percent-format-missing-argument",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "pattern": "$S % $R",
+            "formatArgs": {
+              "style": "percent",
+              "string": "S",
+              "args": "R",
+              "missing": {
+                "kind": "placeholder",
+                "has": {
+                  "kind": "mapping_key"
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F505",
+        "message": "`%`-format string is missing argument(s) for placeholder(s)",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F505"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f506-percent-format-mixed-positional-and-named.json

@@ -0,0 +1,114 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f506-percent-format-mixed-positional-and-named",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F506 (percent-format-mixed-positional-and-named): a valid `%`-format string with both a `%(key)` placeholder and a positional value (a placeholder without a key, or a `*` width or precision). The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) left of `%`, read with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "percent-format-mixed-positional-and-named",
+      "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": "percentFormat",
+                    "not": {
+                      "has": {
+                        "kind": "error"
+                      }
+                    },
+                    "all": [
+                      {
+                        "has": {
+                          "kind": "placeholder",
+                          "stopBy": "end",
+                          "has": {
+                            "kind": "mapping_key"
+                          }
+                        }
+                      },
+                      {
+                        "has": {
+                          "stopBy": "end",
+                          "any": [
+                            {
+                              "kind": "placeholder",
+                              "not": {
+                                "has": {
+                                  "kind": "mapping_key"
+                                }
+                              }
+                            },
+                            {
+                              "kind": "star"
+                            }
+                          ]
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "format-string"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "pattern": "$S % $R"
+          },
+          "constraints": {
+            "S": {
+              "matches": "format-string"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F506",
+        "message": "`%`-format string has mixed positional and named placeholders",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F506"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f507-percent-format-positional-count-mismatch.json

@@ -0,0 +1,78 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f507-percent-format-positional-count-mismatch",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F507 (percent-format-positional-count-mismatch): a valid `%`-format string without `%(key)` placeholders whose positional values differ in number from a tuple display without starred items, or, with any count but one, from a right operand Ruff's ResolvedPythonType infers as one non-tuple value; with no placeholder, any right operand but a tuple display or one Ruff types as a tuple (`(1,) + (2,)`). `formatArgs` reads the format string left of `%` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser), and the right operand as Ruff's strings.rs does. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F507.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "percent-format-positional-count-mismatch",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "pattern": "$S % $R",
+            "all": [
+              {
+                "any": [
+                  {
+                    "formatArgs": {
+                      "style": "percent",
+                      "string": "S",
+                      "args": "R",
+                      "unused": {
+                        "not": {
+                          "kind": "pair"
+                        }
+                      }
+                    }
+                  },
+                  {
+                    "formatArgs": {
+                      "style": "percent",
+                      "string": "S",
+                      "args": "R",
+                      "missing": {
+                        "any": [
+                          {
+                            "kind": "star"
+                          },
+                          {
+                            "kind": "placeholder",
+                            "not": {
+                              "has": {
+                                "kind": "mapping_key"
+                              }
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F507",
+        "message": "`%`-format string placeholder count differs from the substitution count",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F507"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f508-percent-format-star-requires-sequence.json

@@ -0,0 +1,112 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f508-percent-format-star-requires-sequence",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F508 (percent-format-star-requires-sequence): a valid `%`-format string with a `*` width or precision applied to a dict display or comprehension. The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) left of `%`, read with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "percent-format-star-requires-sequence",
+      "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": "percentFormat",
+                    "not": {
+                      "has": {
+                        "kind": "error"
+                      }
+                    },
+                    "has": {
+                      "kind": "star",
+                      "stopBy": "end"
+                    }
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "format-string"
+                  }
+                }
+              ]
+            },
+            "operand": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "dictionary"
+                    },
+                    {
+                      "kind": "dictionary_comprehension"
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "operand"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "pattern": "$S % $R"
+          },
+          "constraints": {
+            "S": {
+              "matches": "format-string"
+            },
+            "R": {
+              "matches": "operand"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F508",
+        "message": "`%`-format string `*` specifier requires sequence",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F508"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f509-percent-format-unsupported-format-character.json

@@ -0,0 +1,86 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f509-percent-format-unsupported-format-character",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F509 (percent-format-unsupported-format-character): a `%`-format string the parser refuses at an unsupported conversion character. The format string is a str literal (no f/t/b prefix; implicit concatenations joined, escapes decoded, parentheses transparent) left of `%`, read with the `percentFormat` grammar (a port of ruff_python_literal's cformat parser).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "percent-format-unsupported-format-character",
+      "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": "percentFormat",
+                    "has": {
+                      "kind": "error",
+                      "value": {
+                        "regex": "^unsupported format character"
+                      }
+                    }
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "format-string"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "pattern": "$S % $R"
+          },
+          "constraints": {
+            "S": {
+              "matches": "format-string"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F509",
+        "message": "`%`-format string has unsupported format character",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F509"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f521-string-dot-format-invalid-format.json

@@ -0,0 +1,83 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f521-string-dot-format-invalid-format",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F521 (string-dot-format-invalid-format): a `.format` call on a str literal the format parser refuses (unmatched braces, fields nested deeper than one level, an empty attribute or index, an unclosed `[`, a bad conversion or format spec). 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-invalid-format",
+      "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",
+                    "has": {
+                      "kind": "error"
+                    }
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "matches": "format-string"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "pattern": "$S.format($$$A)"
+          },
+          "constraints": {
+            "S": {
+              "matches": "format-string"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F521",
+        "message": "`.format` call has invalid format string",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F521"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f522-string-dot-format-extra-named-arguments.json

@@ -0,0 +1,46 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f522-string-dot-format-extra-named-arguments",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F522 (string-dot-format-extra-named-arguments): a `.format` call without `**` on a valid format string, passing a keyword argument no named field (top level or nested in a spec) reads. `formatArgs` reads the format string receiving `.format` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `braceFormat` grammar (a port of ruff_python_literal's format parser as pyflakes' FormatSummary reads it), and the call's arguments as Ruff's strings.rs does.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "string-dot-format-extra-named-arguments",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "pattern": "$S.format($$$A)",
+            "formatArgs": {
+              "style": "brace",
+              "string": "S",
+              "args": "A",
+              "unused": {
+                "kind": "keyword_argument"
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F522",
+        "message": "`.format` call has unused named argument(s)",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F522"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f523-string-dot-format-extra-positional-arguments.json

@@ -0,0 +1,48 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f523-string-dot-format-extra-positional-arguments",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F523 (string-dot-format-extra-positional-arguments): a `.format` call on a valid format string with a positional argument (not starred; counted by syntactic index, past a starred one too) that no automatic or numbered field reads. `formatArgs` reads the format string receiving `.format` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `braceFormat` grammar (a port of ruff_python_literal's format parser as pyflakes' FormatSummary reads it), and the call's arguments as Ruff's strings.rs does. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F523.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "string-dot-format-extra-positional-arguments",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "pattern": "$S.format($$$A)",
+            "formatArgs": {
+              "style": "brace",
+              "string": "S",
+              "args": "A",
+              "unused": {
+                "not": {
+                  "kind": "keyword_argument"
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F523",
+        "message": "`.format` call has unused arguments",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F523"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-f524-string-dot-format-missing-arguments.json

@@ -0,0 +1,46 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-f524-string-dot-format-missing-arguments",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's F524 (string-dot-format-missing-arguments): a `.format` call without `*` or `**` on a valid format string with a field (top level or nested in a spec) whose index is past the positional arguments or whose name no keyword argument passes. `formatArgs` reads the format string receiving `.format` (a str literal with no f/t/b prefix, implicit concatenations joined, escapes decoded, parentheses transparent) with the `braceFormat` grammar (a port of ruff_python_literal's format parser as pyflakes' FormatSummary reads it), and the call's arguments as Ruff's strings.rs does. Ported from the Ruff conformance suite (rerail/conformance/ruff/rules/F524.json at 3f102adcb), with Ruff's `# noqa` honoured as the Ruff CLI honours it.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "string-dot-format-missing-arguments",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "pattern": "$S.format($$$A)",
+            "formatArgs": {
+              "style": "brace",
+              "string": "S",
+              "args": "A",
+              "missing": {
+                "kind": "field"
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "F524",
+        "message": "`.format` call is missing argument(s) for placeholder(s)",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "F524"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}