skylos 1.0.10__py3-none-any.whl → 2.5.2__py3-none-any.whl

skylos/rules/quality/complexity.py

@@ -0,0 +1,95 @@
+import ast
+from pathlib import Path
+from skylos.rules.base import SkylosRule
+
+RULE_ID = "SKY-Q301"
+
+_COMPLEX_NODES = (
+    ast.If,
+    ast.For,
+    ast.While,
+    ast.Try,
+    ast.With,
+    ast.ExceptHandler,
+    ast.BoolOp,
+    ast.IfExp,
+    ast.comprehension,
+)
+
+
+def _func_complexity(node):
+    c = 1
+    for child in ast.walk(node):
+        if isinstance(child, _COMPLEX_NODES):
+            if isinstance(child, ast.BoolOp):
+                c += len(child.values) - 1
+            else:
+                c += 1
+    return c
+
+
+def _func_length(node):
+    start = getattr(node, "lineno", None)
+    end = getattr(node, "end_lineno", None)
+
+    if start is None:
+        return 0
+
+    if end is None:
+        end = start
+        for child in ast.walk(node):
+            ln = getattr(child, "lineno", None)
+            if ln is not None and ln > end:
+                end = ln
+
+    return max(end - start + 1, 0)
+
+
+class ComplexityRule(SkylosRule):
+    rule_id = "SKY-Q301"
+    name = "Cyclomatic Complexity"
+
+    def __init__(self, threshold=10):
+        self.threshold = threshold
+
+    def visit_node(self, node, context):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return None
+
+        complexity = _func_complexity(node)
+
+        if complexity < self.threshold:
+            return None
+
+        if complexity < 15:
+            severity = "WARN"
+        elif complexity < 25:
+            severity = "HIGH"
+        else:
+            severity = "CRITICAL"
+
+        length = _func_length(node)
+        mod = context.get("mod", "")
+
+        if mod:
+            func_name = f"{mod}.{node.name}"
+        else:
+            func_name = node.name
+
+        return [
+            {
+                "rule_id": self.rule_id,
+                "kind": "complexity",
+                "severity": severity,
+                "type": "function",
+                "name": func_name,
+                "simple_name": node.name,
+                "value": complexity,
+                "threshold": self.threshold,
+                "length": length,
+                "message": f"Function is complex (McCabe={complexity}). Consider splitting loops/branches.",
+                "file": context.get("filename"),
+                "basename": Path(context.get("filename", "")).name,
+                "line": node.lineno,
+            }
+        ]

skylos/rules/quality/logic.py

@@ -0,0 +1,96 @@
+import ast
+from pathlib import Path
+from skylos.rules.base import SkylosRule
+
+class MutableDefaultRule(SkylosRule):
+    rule_id = "SKY-L001"
+    name = "Mutable Default Argument"
+
+    def visit_node(self, node, context):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): 
+            return None
+        findings = []
+        
+        kw_defaults_filtered = []
+        for d in node.args.kw_defaults:
+            if d:
+                kw_defaults_filtered.append(d)
+
+        for default in node.args.defaults + kw_defaults_filtered:
+            if isinstance(default, (ast.List, ast.Dict, ast.Set)):
+                findings.append({
+                    "rule_id": self.rule_id,
+                    "kind": "logic",
+                    "severity": "HIGH",
+                    "type": "function",
+                    "name": node.name,
+                    "simple_name": node.name,
+                    "value": "mutable",
+                    "threshold": 0,
+                    "message": "Mutable default argument detected (List/Dict/Set). This causes state leaks.",
+                    "file": context.get("filename"),
+                    "basename": Path(context.get("filename", "")).name,
+                    "line": default.lineno,
+                    "col": default.col_offset
+                })
+        if findings:
+            return findings
+        else:
+            return None
+
+class BareExceptRule(SkylosRule):
+    rule_id = "SKY-L002"
+    name = "Bare Except Block"
+
+    def visit_node(self, node, context):
+        if isinstance(node, ast.ExceptHandler) and node.type is None:
+            return [{
+                "rule_id": self.rule_id,
+                "kind": "logic",
+                "severity": "MEDIUM",
+                "type": "block",
+                "name": "except",
+                "simple_name": "except",
+                "value": "bare",
+                "threshold": 0,
+                "message": "Bare 'except:' block swallows SystemExit and other critical errors.",
+                "file": context.get("filename"),
+                "basename": Path(context.get("filename", "")).name,
+                "line": node.lineno,
+                "col": node.col_offset
+            }]
+        return None
+
+class DangerousComparisonRule(SkylosRule):
+    rule_id = "SKY-L003"
+    name = "Dangerous Comparison"
+
+    def visit_node(self, node, context):
+        if not isinstance(node, ast.Compare): 
+            return None
+        
+        findings = []
+        for op, comparator in zip(node.ops, node.comparators):
+            if isinstance(op, (ast.Eq, ast.NotEq)):
+                if isinstance(comparator, ast.Constant):
+                    val = comparator.value
+                    if val is True or val is False or val is None:
+                        findings.append({
+                        "rule_id": self.rule_id,
+                        "kind": "logic",
+                        "severity": "LOW",
+                        "type": "comparison",
+                        "name": "==",
+                        "simple_name": "==",
+                        "value": str(comparator.value),
+                        "threshold": 0,
+                        "message": f"Comparison to {comparator.value} should use 'is' or 'is not'.",
+                        "file": context.get("filename"),
+                        "basename": Path(context.get("filename", "")).name,
+                        "line": node.lineno,
+                        "col": node.col_offset
+                    })
+        if findings:
+            return findings
+        else:
+            return None

skylos/rules/quality/nesting.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+import ast
+from pathlib import Path
+from skylos.rules.base import SkylosRule
+
+RULE_ID = "SKY-Q302"
+
+NEST_NODES = (ast.If, ast.For, ast.While, ast.Try, ast.With)
+
+
+def _max_depth(nodes, depth=0):
+    max_depth = depth
+    for node in nodes:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            continue
+
+        if isinstance(node, NEST_NODES):
+            branches = []
+            if isinstance(node, ast.If):
+                branches.append(node.body)
+                if node.orelse:
+                    branches.append(node.orelse)
+
+            elif isinstance(node, (ast.For, ast.While)):
+                branches.append(node.body)
+                if node.orelse:
+                    branches.append(node.orelse)
+
+            elif isinstance(node, ast.With):
+                branches.append(node.body)
+
+            elif isinstance(node, ast.Try):
+                branches.append(node.body)
+                for handler in node.handlers:
+                    branches.append(handler.body)
+                if node.orelse:
+                    branches.append(node.orelse)
+                if node.finalbody:
+                    branches.append(node.finalbody)
+
+            for branch in branches:
+                max_depth = max(max_depth, _max_depth(branch, depth + 1))
+
+    return max_depth
+
+
+def _physical_length(node):
+    start = getattr(node, "lineno", 0)
+    end = getattr(node, "end_lineno", start)
+    return max(end - start + 1, 0)
+
+
+class NestingRule(SkylosRule):
+    rule_id = "SKY-Q302"
+    name = "Deep Nesting"
+
+    def __init__(self, threshold=3):
+        self.threshold = threshold
+
+    def visit_node(self, node, context):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return None
+
+        depth = _max_depth(node.body, 0)
+
+        if depth <= self.threshold:
+            return None
+
+        if depth <= self.threshold + 2:
+            severity = "MEDIUM"
+        elif depth <= self.threshold + 5:
+            severity = "HIGH"
+        else:
+            severity = "CRITICAL"
+
+        physical_len = _physical_length(node)
+        mod = context.get("mod", "")
+
+        if mod:
+            func_name = f"{mod}.{node.name}"
+        else:
+            func_name = node.name
+
+        return [
+            {
+                "rule_id": self.rule_id,
+                "kind": "nesting",
+                "severity": severity,
+                "type": "function",
+                "name": func_name,
+                "simple_name": node.name,
+                "file": context.get("filename"),
+                "basename": Path(context.get("filename", "")).name,
+                "line": node.lineno,
+                "metric": "max_nesting",
+                "value": depth,
+                "threshold": self.threshold,
+                "length": physical_len,
+                "message": f"Nesting depth of {depth} exceeds threshold of {self.threshold}. Consider using early returns.",
+            }
+        ]

skylos/rules/quality/structure.py

@@ -0,0 +1,99 @@
+import ast
+from skylos.rules.base import SkylosRule
+from pathlib import Path
+
+
+class ArgCountRule(SkylosRule):
+    rule_id = "SKY-C303"
+    name = "Too Many Arguments"
+
+    def __init__(self, max_args=5):
+        self.max_args = max_args
+
+    def visit_node(self, node, context):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return None
+
+        args = node.args.args
+        clean_args = []
+        for a in args:
+            if a.arg not in ("self", "cls"):
+                clean_args.append(a)
+
+        total_count = len(clean_args) + len(node.args.kwonlyargs)
+
+        if total_count <= self.max_args:
+            return None
+
+        mod = context.get("mod", "")
+        if mod:
+            func_name = f"{mod}.{node.name}"
+        else:
+            func_name = node.name
+
+        return [
+            {
+                "rule_id": self.rule_id,
+                "kind": "structure",
+                "type": "function",
+                "name": func_name,
+                "simple_name": node.name,
+                "value": total_count,
+                "threshold": self.max_args,
+                "severity": "MEDIUM",
+                "message": f"Function has {total_count} arguments (limit: {self.max_args}). Refactor.",
+                "file": context.get("filename"),
+                "basename": Path(context.get("filename", "")).name,
+                "line": node.lineno,
+                "col": node.col_offset,
+            }
+        ]
+
+
+class FunctionLengthRule(SkylosRule):
+    rule_id = "SKY-C304"
+    name = "Function Too Long"
+
+    def __init__(self, max_lines=50):
+        self.max_lines = max_lines
+
+    def visit_node(self, node, context):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            return None
+
+        start = getattr(node, "lineno", 0)
+        end = getattr(node, "end_lineno", start)
+        physical_length = max(end - start + 1, 0)
+
+        if physical_length <= self.max_lines:
+            return None
+
+        if physical_length < 100:
+            severity = "MEDIUM"
+        else:
+            severity = "HIGH"
+
+        mod = context.get("mod", "")
+
+        if mod:
+            func_name = f"{mod}.{node.name}"
+        else:
+            func_name = node.name
+
+        return [
+            {
+                "rule_id": self.rule_id,
+                "kind": "structure",
+                "type": "function",
+                "name": func_name,
+                "simple_name": node.name,
+                "value": physical_length,
+                "threshold": self.max_lines,
+                "severity": severity,
+                "message": f"Function is {physical_length} lines long (limit: {self.max_lines}). It is too big.",
+                "file": context.get("filename"),
+                "basename": Path(context.get("filename", "")).name,
+                "line": node.lineno,
+                "col": node.col_offset,
+            }
+        ]