@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-pie807-reimplemented-container-builtin.json

@@ -0,0 +1,100 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-pie807-reimplemented-container-builtin",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's PIE807 (reimplemented-container-builtin): a parameterless `lambda` whose body is an empty list or dict display.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "reimplemented-container-builtin",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "empty-container": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "any": [
+                        {
+                          "kind": "list"
+                        },
+                        {
+                          "kind": "dictionary"
+                        }
+                      ]
+                    }
+                  ],
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "any": [
+                          {
+                            "regex": "^[\\[\\]{}]$"
+                          },
+                          {
+                            "any": [
+                              {
+                                "kind": "comment"
+                              },
+                              {
+                                "kind": "line_continuation"
+                              }
+                            ]
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "empty-container"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "lambda",
+            "not": {
+              "has": {
+                "stopBy": "neighbor",
+                "kind": "lambda_parameters"
+              }
+            },
+            "has": {
+              "stopBy": "neighbor",
+              "not": {
+                "regex": "^(lambda|:)$"
+              },
+              "matches": "empty-container"
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "PIE807",
+        "message": "Prefer `list` or `dict` over useless lambda",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "PIE807"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-pie810-multiple-starts-ends-with.json

@@ -0,0 +1,585 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-pie810-multiple-starts-ends-with",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's PIE810 (multiple-starts-ends-with): an `or` chain with two or more operands `R.startswith(x)` (or two `R.endswith(x)`) on the same name `R`, each with one positional argument and no keywords, where the argument is not a name bound to a tuple (Ruff's is_bound_to_tuple through `resolves.binding`, read as lookup_symbol does with `stopAtGlobal`: a `def`'s `*args`, a tuple-typed value, `tuple(...)`, or a `tuple`/`Tuple` annotation or return annotation). Reported on the whole chain, once per such group.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "multiple-starts-ends-with",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "or-op": {
+              "kind": "boolean_operator",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "^or$"
+              }
+            },
+            "tuple-expr": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "tuple"
+                    },
+                    {
+                      "kind": "expression_list"
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "tuple-expr"
+                  }
+                },
+                {
+                  "kind": "named_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "follows": {
+                      "stopBy": "neighbor",
+                      "regex": "^:=$"
+                    },
+                    "matches": "tuple-expr"
+                  }
+                },
+                {
+                  "kind": "conditional_expression",
+                  "all": [
+                    {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "precedes": {
+                          "stopBy": "neighbor",
+                          "regex": "^if$"
+                        },
+                        "matches": "tuple-expr"
+                      }
+                    },
+                    {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "follows": {
+                          "stopBy": "neighbor",
+                          "regex": "^else$"
+                        },
+                        "matches": "tuple-expr"
+                      }
+                    }
+                  ]
+                },
+                {
+                  "kind": "boolean_operator",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "any": [
+                          {
+                            "regex": "^(and|or)$"
+                          },
+                          {
+                            "kind": "comment"
+                          },
+                          {
+                            "matches": "tuple-expr"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                {
+                  "kind": "binary_operator",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "regex": "^\\+$"
+                  },
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "not": {
+                        "any": [
+                          {
+                            "regex": "^\\+$"
+                          },
+                          {
+                            "kind": "comment"
+                          },
+                          {
+                            "matches": "tuple-expr"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "tuple-init": {
+              "any": [
+                {
+                  "matches": "tuple-expr"
+                },
+                {
+                  "kind": "call",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "tuple-callee",
+                    "precedes": {
+                      "stopBy": "neighbor",
+                      "any": [
+                        {
+                          "kind": "argument_list"
+                        },
+                        {
+                          "kind": "generator_expression"
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            },
+            "tuple-callee": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "import": [
+                      "builtins.tuple"
+                    ],
+                    "global": [
+                      "tuple"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "tuple-callee"
+                  }
+                }
+              ]
+            },
+            "tuple-ann": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "import": [
+                      "builtins.tuple"
+                    ],
+                    "global": [
+                      "tuple"
+                    ]
+                  }
+                },
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "import": [
+                      "typing.Tuple",
+                      "_typeshed.Tuple",
+                      "typing_extensions.Tuple"
+                    ]
+                  }
+                },
+                {
+                  "any": [
+                    {
+                      "any": [
+                        {
+                          "kind": "subscript"
+                        },
+                        {
+                          "kind": "generic_type"
+                        }
+                      ]
+                    }
+                  ],
+                  "has": {
+                    "stopBy": "neighbor",
+                    "not": {
+                      "follows": {
+                        "stopBy": "neighbor",
+                        "regex": "(?s)."
+                      }
+                    },
+                    "matches": "tuple-ann"
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "tuple-ann"
+                  }
+                }
+              ]
+            },
+            "tuple-bound": {
+              "any": [
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "tuple-bound"
+                  }
+                },
+                {
+                  "kind": "identifier",
+                  "any": [
+                    {
+                      "resolves": {
+                        "binding": {
+                          "stopAtGlobal": true,
+                          "site": {
+                            "any": [
+                              {
+                                "kind": "list_splat_pattern",
+                                "inside": {
+                                  "stopBy": "neighbor",
+                                  "kind": "parameters"
+                                }
+                              },
+                              {
+                                "kind": "typed_parameter",
+                                "inside": {
+                                  "stopBy": "neighbor",
+                                  "kind": "parameters"
+                                },
+                                "has": {
+                                  "stopBy": "neighbor",
+                                  "kind": "list_splat_pattern"
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "resolves": {
+                        "binding": {
+                          "stopAtGlobal": true,
+                          "value": {
+                            "matches": "tuple-init"
+                          },
+                          "site": {
+                            "not": {
+                              "has": {
+                                "stopBy": "neighbor",
+                                "kind": "type"
+                              }
+                            }
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "resolves": {
+                        "binding": {
+                          "stopAtGlobal": true,
+                          "site": {
+                            "kind": "as_pattern",
+                            "inside": {
+                              "stopBy": "neighbor",
+                              "kind": "with_item"
+                            },
+                            "all": [
+                              {
+                                "has": {
+                                  "stopBy": "neighbor",
+                                  "matches": "tuple-init",
+                                  "precedes": {
+                                    "stopBy": "end",
+                                    "regex": "^as$"
+                                  }
+                                }
+                              },
+                              {
+                                "has": {
+                                  "stopBy": "neighbor",
+                                  "kind": "as_pattern_target",
+                                  "has": {
+                                    "stopBy": "neighbor",
+                                    "matches": "plain-target"
+                                  }
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "resolves": {
+                        "binding": {
+                          "annotation": {
+                            "matches": "tuple-ann"
+                          },
+                          "site": {
+                            "not": {
+                              "has": {
+                                "stopBy": "neighbor",
+                                "any": [
+                                  {
+                                    "kind": "list_splat_pattern"
+                                  },
+                                  {
+                                    "kind": "dictionary_splat_pattern"
+                                  }
+                                ]
+                              }
+                            }
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "resolves": {
+                        "binding": {
+                          "site": {
+                            "kind": "function_definition",
+                            "has": {
+                              "stopBy": "neighbor",
+                              "kind": "type",
+                              "has": {
+                                "stopBy": "neighbor",
+                                "matches": "tuple-ann"
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            },
+            "plain-target": {
+              "any": [
+                {
+                  "kind": "identifier"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "plain-target"
+                  }
+                }
+              ]
+            },
+            "affix-call": {
+              "any": [
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "affix-call"
+                  }
+                },
+                {
+                  "kind": "call",
+                  "all": [
+                    {
+                      "has": {
+                        "field": "function",
+                        "kind": "attribute",
+                        "all": [
+                          {
+                            "has": {
+                              "field": "object",
+                              "kind": "identifier",
+                              "pattern": "$R"
+                            }
+                          },
+                          {
+                            "has": {
+                              "field": "attribute",
+                              "regex": "^(startswith|endswith)$",
+                              "pattern": "$M"
+                            }
+                          }
+                        ]
+                      }
+                    },
+                    {
+                      "has": {
+                        "field": "arguments",
+                        "kind": "argument_list",
+                        "count": {
+                          "has": {
+                            "stopBy": "neighbor",
+                            "not": {
+                              "regex": "^[(),]$"
+                            }
+                          },
+                          "min": 1,
+                          "max": 1
+                        },
+                        "not": {
+                          "has": {
+                            "stopBy": "neighbor",
+                            "any": [
+                              {
+                                "any": [
+                                  {
+                                    "kind": "keyword_argument"
+                                  },
+                                  {
+                                    "kind": "dictionary_splat"
+                                  }
+                                ]
+                              },
+                              {
+                                "matches": "tuple-bound"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "boolean_operator",
+            "matches": "or-op",
+            "not": {
+              "inside": {
+                "stopBy": "neighbor",
+                "matches": "or-op"
+              }
+            },
+            "has": {
+              "stopBy": {
+                "not": {
+                  "matches": "or-op"
+                }
+              },
+              "not": {
+                "any": [
+                  {
+                    "matches": "or-op"
+                  },
+                  {
+                    "follows": {
+                      "stopBy": "end",
+                      "any": [
+                        {
+                          "not": {
+                            "matches": "or-op"
+                          },
+                          "matches": "affix-call"
+                        },
+                        {
+                          "matches": "or-op",
+                          "has": {
+                            "stopBy": {
+                              "not": {
+                                "matches": "or-op"
+                              }
+                            },
+                            "not": {
+                              "matches": "or-op"
+                            },
+                            "matches": "affix-call"
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ]
+              },
+              "matches": "affix-call",
+              "pattern": "$FIRST",
+              "inside": {
+                "stopBy": {
+                  "not": {
+                    "matches": "or-op"
+                  }
+                },
+                "matches": "or-op",
+                "not": {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "matches": "or-op"
+                  }
+                },
+                "has": {
+                  "stopBy": {
+                    "not": {
+                      "matches": "or-op"
+                    }
+                  },
+                  "not": {
+                    "matches": "or-op"
+                  },
+                  "matches": "affix-call",
+                  "pattern": "$SECOND",
+                  "compare": {
+                    "left": "SECOND",
+                    "op": "ne",
+                    "right": "FIRST",
+                    "text": "node"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "PIE810",
+        "message": "Call `$M` once with a `tuple`",
+        "each": "FIRST",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "PIE810"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}