@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-sim101-duplicate-isinstance-call.json

@@ -0,0 +1,384 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-sim101-duplicate-isinstance-call",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's SIM101 (duplicate-isinstance-call): two adjacent operands of one `or` chain that are calls of the builtin `isinstance(T, C)` (exactly two positional arguments, no keywords) with equal targets (Ruff's ComparableExpr, `text: \"structure\"`; names without NFKC normalization), reported on the whole `or` chain once per run of adjacent such calls with equal targets. A parenthesized `or` is its own chain, as in Ruff's AST. `isinstance` must resolve to the builtin (`match_builtin_expr`: the unshadowed name, or `builtins.isinstance` through an import).",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "duplicate-isinstance-call",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "or-op": {
+              "kind": "boolean_operator",
+              "has": {
+                "field": "operator",
+                "regex": "^or$"
+              }
+            },
+            "isinstance-a": {
+              "any": [
+                {
+                  "kind": "call",
+                  "pattern": "$_F($_, $_)",
+                  "all": [
+                    {
+                      "has": {
+                        "field": "arguments",
+                        "kind": "argument_list",
+                        "not": {
+                          "has": {
+                            "stopBy": "neighbor",
+                            "any": [
+                              {
+                                "kind": "keyword_argument"
+                              },
+                              {
+                                "kind": "dictionary_splat"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "has": {
+                        "field": "function",
+                        "matches": "isinstance-ref"
+                      }
+                    },
+                    {
+                      "has": {
+                        "field": "arguments",
+                        "kind": "argument_list",
+                        "has": {
+                          "stopBy": "neighbor",
+                          "follows": {
+                            "stopBy": "neighbor",
+                            "regex": "^\\($"
+                          },
+                          "matches": "target-a"
+                        }
+                      }
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "isinstance-a"
+                  }
+                }
+              ]
+            },
+            "target-a": {
+              "pattern": "$A"
+            },
+            "isinstance-t": {
+              "any": [
+                {
+                  "kind": "call",
+                  "pattern": "$_F($_, $_)",
+                  "all": [
+                    {
+                      "has": {
+                        "field": "arguments",
+                        "kind": "argument_list",
+                        "not": {
+                          "has": {
+                            "stopBy": "neighbor",
+                            "any": [
+                              {
+                                "kind": "keyword_argument"
+                              },
+                              {
+                                "kind": "dictionary_splat"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "has": {
+                        "field": "function",
+                        "matches": "isinstance-ref"
+                      }
+                    },
+                    {
+                      "has": {
+                        "field": "arguments",
+                        "kind": "argument_list",
+                        "has": {
+                          "stopBy": "neighbor",
+                          "follows": {
+                            "stopBy": "neighbor",
+                            "regex": "^\\($"
+                          },
+                          "matches": "target-t"
+                        }
+                      }
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "isinstance-t"
+                  }
+                }
+              ]
+            },
+            "target-t": {
+              "any": [
+                {
+                  "not": {
+                    "kind": "parenthesized_expression"
+                  },
+                  "pattern": "$T"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "not": {
+                      "regex": "^[()]$"
+                    },
+                    "matches": "target-t"
+                  }
+                }
+              ]
+            },
+            "isinstance-b": {
+              "any": [
+                {
+                  "kind": "call",
+                  "pattern": "$_F($_, $_)",
+                  "all": [
+                    {
+                      "has": {
+                        "field": "arguments",
+                        "kind": "argument_list",
+                        "not": {
+                          "has": {
+                            "stopBy": "neighbor",
+                            "any": [
+                              {
+                                "kind": "keyword_argument"
+                              },
+                              {
+                                "kind": "dictionary_splat"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "has": {
+                        "field": "function",
+                        "matches": "isinstance-ref"
+                      }
+                    },
+                    {
+                      "has": {
+                        "field": "arguments",
+                        "kind": "argument_list",
+                        "has": {
+                          "stopBy": "neighbor",
+                          "follows": {
+                            "stopBy": "neighbor",
+                            "regex": "^\\($"
+                          },
+                          "matches": "target-b"
+                        }
+                      }
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "isinstance-b"
+                  }
+                }
+              ]
+            },
+            "target-b": {
+              "any": [
+                {
+                  "not": {
+                    "kind": "parenthesized_expression"
+                  },
+                  "pattern": "$B"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "not": {
+                      "regex": "^[()]$"
+                    },
+                    "matches": "target-b"
+                  }
+                }
+              ]
+            },
+            "adjacent-pair": {
+              "matches": "or-op",
+              "all": [
+                {
+                  "has": {
+                    "field": "left",
+                    "any": [
+                      {
+                        "not": {
+                          "matches": "or-op"
+                        },
+                        "matches": "isinstance-t"
+                      },
+                      {
+                        "matches": "or-op",
+                        "has": {
+                          "field": "right",
+                          "matches": "isinstance-t"
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "has": {
+                    "field": "right",
+                    "matches": "isinstance-a"
+                  }
+                }
+              ],
+              "compare": {
+                "left": "T",
+                "op": "eq",
+                "right": "A",
+                "text": "structure"
+              }
+            },
+            "isinstance-ref": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "import": [
+                      "builtins.isinstance"
+                    ],
+                    "global": [
+                      "isinstance"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "isinstance-ref"
+                  }
+                }
+              ]
+            },
+            "last-is-b": {
+              "any": [
+                {
+                  "not": {
+                    "matches": "or-op"
+                  },
+                  "matches": "isinstance-b"
+                },
+                {
+                  "matches": "or-op",
+                  "has": {
+                    "field": "right",
+                    "matches": "isinstance-b"
+                  }
+                }
+              ]
+            },
+            "run-start": {
+              "matches": "adjacent-pair",
+              "pattern": "$P",
+              "not": {
+                "has": {
+                  "field": "left",
+                  "matches": "or-op",
+                  "has": {
+                    "field": "left",
+                    "matches": "last-is-b",
+                    "compare": {
+                      "left": "B",
+                      "op": "eq",
+                      "right": "T",
+                      "text": "structure"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "rule": {
+            "kind": "boolean_operator",
+            "matches": "or-op",
+            "not": {
+              "inside": {
+                "stopBy": "neighbor",
+                "matches": "or-op"
+              }
+            },
+            "any": [
+              {
+                "matches": "run-start"
+              },
+              {
+                "has": {
+                  "stopBy": {
+                    "not": {
+                      "matches": "or-op"
+                    }
+                  },
+                  "matches": "run-start"
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "SIM101",
+        "message": "Multiple `isinstance` calls for `$T`, merge into a single call",
+        "each": "P",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "SIM101"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-sim107-return-in-try-except-finally.json

@@ -0,0 +1,82 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-sim107-return-in-try-except-finally",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's SIM107 (return-in-try-except-finally): the first top-level `return` of a `finally` body when the `try` body or an `except` handler body has a top-level `return`.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "return-in-try-except-finally",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "rule": {
+            "kind": "return_statement",
+            "not": {
+              "follows": {
+                "stopBy": "end",
+                "kind": "return_statement"
+              }
+            },
+            "inside": {
+              "stopBy": "neighbor",
+              "kind": "block",
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "finally_clause",
+                "inside": {
+                  "stopBy": "neighbor",
+                  "kind": "try_statement",
+                  "any": [
+                    {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "block",
+                        "has": {
+                          "stopBy": "neighbor",
+                          "kind": "return_statement"
+                        }
+                      }
+                    },
+                    {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "except_clause",
+                        "has": {
+                          "stopBy": "neighbor",
+                          "kind": "block",
+                          "has": {
+                            "stopBy": "neighbor",
+                            "kind": "return_statement"
+                          }
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "SIM107",
+        "message": "Don't use `return` in `try`-`except` and `finally`",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "SIM107"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-sim109-compare-with-tuple.json

@@ -0,0 +1,205 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-sim109-compare-with-tuple",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's SIM109 (compare-with-tuple): an `or` chain with two or more operands `N == name` (one `==`, both sides names) for the same `N`, anywhere in the chain; not reported when a comment lies inside the chain or follows it on its last line with only white space between (Ruff's has_comments). Reported on the whole `or` chain, once per such name.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "compare-with-tuple",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "or-op": {
+              "kind": "boolean_operator",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "^or$"
+              }
+            },
+            "eq-target": {
+              "any": [
+                {
+                  "kind": "comparison_operator",
+                  "count": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "regex": "(?s)."
+                    },
+                    "max": 3
+                  },
+                  "all": [
+                    {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "identifier",
+                        "precedes": {
+                          "stopBy": "neighbor",
+                          "regex": "^==$"
+                        },
+                        "pattern": "$N"
+                      }
+                    },
+                    {
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "identifier",
+                        "follows": {
+                          "stopBy": "neighbor",
+                          "regex": "^==$"
+                        }
+                      }
+                    }
+                  ]
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "eq-target"
+                  }
+                }
+              ]
+            }
+          },
+          "rule": {
+            "kind": "boolean_operator",
+            "matches": "or-op",
+            "not": {
+              "any": [
+                {
+                  "inside": {
+                    "stopBy": "neighbor",
+                    "matches": "or-op"
+                  }
+                },
+                {
+                  "has": {
+                    "stopBy": "end",
+                    "kind": "comment"
+                  }
+                },
+                {
+                  "layout": {
+                    "after": {
+                      "to": "token",
+                      "comments": true,
+                      "breaks": {
+                        "eq": 0
+                      }
+                    }
+                  },
+                  "not": {
+                    "layout": {
+                      "after": {
+                        "to": "token",
+                        "breaks": {
+                          "eq": 0
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "has": {
+              "stopBy": {
+                "not": {
+                  "matches": "or-op"
+                }
+              },
+              "not": {
+                "any": [
+                  {
+                    "matches": "or-op"
+                  },
+                  {
+                    "follows": {
+                      "stopBy": "end",
+                      "any": [
+                        {
+                          "not": {
+                            "matches": "or-op"
+                          },
+                          "matches": "eq-target"
+                        },
+                        {
+                          "matches": "or-op",
+                          "has": {
+                            "stopBy": {
+                              "not": {
+                                "matches": "or-op"
+                              }
+                            },
+                            "not": {
+                              "matches": "or-op"
+                            },
+                            "matches": "eq-target"
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ]
+              },
+              "matches": "eq-target",
+              "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": "eq-target",
+                  "pattern": "$SECOND",
+                  "compare": {
+                    "left": "SECOND",
+                    "op": "ne",
+                    "right": "FIRST",
+                    "text": "node"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "SIM109",
+        "message": "Use `$N in (...)` instead of multiple equality comparisons",
+        "each": "FIRST",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "SIM109"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}