@neralabs/rerail-pack-python 0.1.1

package/rules/ruff-ret501-unnecessary-return-none.json

@@ -0,0 +1,256 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-ret501-unnecessary-return-none",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's RET501 (unnecessary-return-none): `return None` in a function whose every `return` is bare or returns `None` (nested functions and classes are separate; generators and functions whose body is a lone `return` are skipped), unless the function has a return annotation other than `None` or a property decorator (`property`, `enum.property`, `functools.cached_property`, `abc.abstractproperty`, `types.DynamicClassAttribute`, resolved through the file's bindings and imports). Reported on the `return` statement.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "unnecessary-return-none",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "analysed-function": {
+              "kind": "function_definition",
+              "all": [
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": {
+                        "any": [
+                          {
+                            "kind": "function_definition"
+                          },
+                          {
+                            "kind": "class_definition"
+                          }
+                        ]
+                      },
+                      "kind": "yield"
+                    }
+                  }
+                },
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "block",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "return_statement"
+                      },
+                      "not": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "any": [
+                              {
+                                "kind": "return_statement"
+                              },
+                              {
+                                "kind": "comment"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "none-literal": {
+              "any": [
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "none-literal"
+                  }
+                }
+              ]
+            },
+            "value-return": {
+              "kind": "return_statement",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "(?s).",
+                "not": {
+                  "any": [
+                    {
+                      "regex": "^return$"
+                    },
+                    {
+                      "kind": "comment"
+                    },
+                    {
+                      "matches": "none-literal"
+                    }
+                  ]
+                }
+              }
+            },
+            "own-return": {
+              "kind": "return_statement"
+            },
+            "has-result": {
+              "has": {
+                "stopBy": {
+                  "any": [
+                    {
+                      "kind": "function_definition"
+                    },
+                    {
+                      "kind": "class_definition"
+                    }
+                  ]
+                },
+                "matches": "value-return"
+              }
+            },
+            "property-decorated": {
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "decorated_definition",
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "decorator",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "any": [
+                      {
+                        "matches": "property-name"
+                      },
+                      {
+                        "kind": "call",
+                        "has": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "follows": {
+                              "stopBy": "neighbor",
+                              "regex": "(?s)."
+                            }
+                          },
+                          "matches": "property-name"
+                        }
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            "property-name": {
+              "any": [
+                {
+                  "any": [
+                    {
+                      "kind": "identifier"
+                    },
+                    {
+                      "kind": "attribute"
+                    }
+                  ],
+                  "resolves": {
+                    "global": [
+                      "property"
+                    ],
+                    "import": [
+                      "builtins.property",
+                      "enum.property",
+                      "functools.cached_property",
+                      "abc.abstractproperty",
+                      "types.DynamicClassAttribute"
+                    ]
+                  }
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "property-name"
+                  }
+                }
+              ]
+            },
+            "none-or-no-annotation": {
+              "not": {
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "type",
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "matches": "none-literal"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "rule": {
+            "kind": "return_statement",
+            "has": {
+              "stopBy": "neighbor",
+              "matches": "none-literal"
+            },
+            "inside": {
+              "stopBy": {
+                "any": [
+                  {
+                    "kind": "function_definition"
+                  },
+                  {
+                    "kind": "class_definition"
+                  }
+                ]
+              },
+              "kind": "function_definition",
+              "all": [
+                {
+                  "matches": "analysed-function"
+                },
+                {
+                  "not": {
+                    "any": [
+                      {
+                        "matches": "has-result"
+                      },
+                      {
+                        "matches": "property-decorated"
+                      }
+                    ]
+                  }
+                },
+                {
+                  "matches": "none-or-no-annotation"
+                }
+              ]
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "RET501",
+        "message": "Do not explicitly `return None` in function if it is the only possible return value",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "RET501"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-ret502-implicit-return-value.json

@@ -0,0 +1,163 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-ret502-implicit-return-value",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's RET502 (implicit-return-value): a bare `return` in a function that also has a `return` with a value other than `None` (nested functions and classes are separate; generators and functions whose body is a lone `return` are skipped), reported on the `return`.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "implicit-return-value",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "analysed-function": {
+              "kind": "function_definition",
+              "all": [
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": {
+                        "any": [
+                          {
+                            "kind": "function_definition"
+                          },
+                          {
+                            "kind": "class_definition"
+                          }
+                        ]
+                      },
+                      "kind": "yield"
+                    }
+                  }
+                },
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "block",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "return_statement"
+                      },
+                      "not": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "any": [
+                              {
+                                "kind": "return_statement"
+                              },
+                              {
+                                "kind": "comment"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "none-literal": {
+              "any": [
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "none-literal"
+                  }
+                }
+              ]
+            },
+            "value-return": {
+              "kind": "return_statement",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "(?s).",
+                "not": {
+                  "any": [
+                    {
+                      "regex": "^return$"
+                    },
+                    {
+                      "kind": "comment"
+                    },
+                    {
+                      "matches": "none-literal"
+                    }
+                  ]
+                }
+              }
+            },
+            "own-return": {
+              "kind": "return_statement"
+            },
+            "has-result": {
+              "has": {
+                "stopBy": {
+                  "any": [
+                    {
+                      "kind": "function_definition"
+                    },
+                    {
+                      "kind": "class_definition"
+                    }
+                  ]
+                },
+                "matches": "value-return"
+              }
+            }
+          },
+          "rule": {
+            "kind": "return_statement",
+            "regex": "^return$",
+            "inside": {
+              "stopBy": {
+                "any": [
+                  {
+                    "kind": "function_definition"
+                  },
+                  {
+                    "kind": "class_definition"
+                  }
+                ]
+              },
+              "kind": "function_definition",
+              "all": [
+                {
+                  "matches": "analysed-function"
+                },
+                {
+                  "matches": "has-result"
+                }
+              ]
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "RET502",
+        "message": "Do not implicitly `return None` in function able to return non-`None` value",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "RET502"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/ruff-ret505-superfluous-else-return.json

@@ -0,0 +1,211 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "ruff-ret505-superfluous-else-return",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Port of Ruff's RET505 (superfluous-else-return): the first `elif`/`else` clause of an `if` statement inside a function whose `if` body has a direct `return` statement and no earlier direct raise/continue/break statement, reported on the `elif`/`else` keyword. As in Ruff, only the `if` body and the first clause are compared, nested functions and classes are separate, and generator functions and functions whose body is a lone `return` are skipped.",
+  "scope": {
+    "include": [
+      "**/*"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "superfluous-else-return",
+      "forbid": {
+        "ast": {
+          "language": "python",
+          "utils": {
+            "analysed-function": {
+              "kind": "function_definition",
+              "all": [
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": {
+                        "any": [
+                          {
+                            "kind": "function_definition"
+                          },
+                          {
+                            "kind": "class_definition"
+                          }
+                        ]
+                      },
+                      "kind": "yield"
+                    }
+                  }
+                },
+                {
+                  "not": {
+                    "has": {
+                      "stopBy": "neighbor",
+                      "kind": "block",
+                      "has": {
+                        "stopBy": "neighbor",
+                        "kind": "return_statement"
+                      },
+                      "not": {
+                        "has": {
+                          "stopBy": "neighbor",
+                          "not": {
+                            "any": [
+                              {
+                                "kind": "return_statement"
+                              },
+                              {
+                                "kind": "comment"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              ]
+            },
+            "none-literal": {
+              "any": [
+                {
+                  "kind": "none"
+                },
+                {
+                  "kind": "parenthesized_expression",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "matches": "none-literal"
+                  }
+                }
+              ]
+            },
+            "value-return": {
+              "kind": "return_statement",
+              "has": {
+                "stopBy": "neighbor",
+                "regex": "(?s).",
+                "not": {
+                  "any": [
+                    {
+                      "regex": "^return$"
+                    },
+                    {
+                      "kind": "comment"
+                    },
+                    {
+                      "matches": "none-literal"
+                    }
+                  ]
+                }
+              }
+            },
+            "own-return": {
+              "kind": "return_statement"
+            },
+            "has-result": {
+              "has": {
+                "stopBy": {
+                  "any": [
+                    {
+                      "kind": "function_definition"
+                    },
+                    {
+                      "kind": "class_definition"
+                    }
+                  ]
+                },
+                "matches": "value-return"
+              }
+            }
+          },
+          "rule": {
+            "regex": "^(?<BRANCH>elif|else)$",
+            "inside": {
+              "stopBy": "neighbor",
+              "any": [
+                {
+                  "kind": "elif_clause"
+                },
+                {
+                  "kind": "else_clause"
+                }
+              ],
+              "not": {
+                "follows": {
+                  "stopBy": "end",
+                  "any": [
+                    {
+                      "kind": "elif_clause"
+                    },
+                    {
+                      "kind": "else_clause"
+                    }
+                  ]
+                }
+              },
+              "inside": {
+                "stopBy": "neighbor",
+                "kind": "if_statement",
+                "has": {
+                  "stopBy": "neighbor",
+                  "kind": "block",
+                  "has": {
+                    "stopBy": "neighbor",
+                    "kind": "return_statement",
+                    "not": {
+                      "follows": {
+                        "stopBy": "end",
+                        "any": [
+                          {
+                            "kind": "raise_statement"
+                          },
+                          {
+                            "kind": "continue_statement"
+                          },
+                          {
+                            "kind": "break_statement"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                },
+                "inside": {
+                  "stopBy": {
+                    "any": [
+                      {
+                        "kind": "function_definition"
+                      },
+                      {
+                        "kind": "class_definition"
+                      }
+                    ]
+                  },
+                  "kind": "function_definition",
+                  "all": [
+                    {
+                      "matches": "analysed-function"
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.span",
+        "code": "RET505",
+        "message": "Unnecessary `$BRANCH` after `return` statement",
+        "suppress": {
+          "noqa": {
+            "codes": [
+              "RET505"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}