Add from_dict for plain-scan, remove old nested_checks

Author: davegaeddert

plain-scan/plain/scan/metadata.py

@@ -21,6 +21,20 @@ class CookieMetadata:
     samesite: str | None
     expires: int | None = None
 
+    @classmethod
+    def from_dict(cls, data: dict) -> CookieMetadata:
+        """Reconstruct CookieMetadata from dictionary."""
+        return cls(
+            name=data["name"],
+            value=data["value"],
+            domain=data["domain"],
+            path=data["path"],
+            secure=data["secure"],
+            httponly=data["httponly"],
+            samesite=data["samesite"],
+            expires=data.get("expires"),
+        )
+
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""
         result = {
@@ -82,6 +96,17 @@ def from_response(cls, response: requests.Response) -> ResponseMetadata:
             cookies=cookies,
         )
 
+    @classmethod
+    def from_dict(cls, data: dict) -> ResponseMetadata:
+        """Reconstruct ResponseMetadata from dictionary."""
+        cookies = [CookieMetadata.from_dict(c) for c in data.get("cookies", [])]
+        return cls(
+            url=data["url"],
+            status_code=data["status_code"],
+            headers=data["headers"],
+            cookies=cookies,
+        )
+
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""
         result = {
@@ -122,6 +147,15 @@ def from_response(cls, response: requests.Response | None) -> ScanMetadata:
 
         return cls(timestamp=timestamp, responses=responses)
 
+    @classmethod
+    def from_dict(cls, data: dict) -> ScanMetadata:
+        """Reconstruct ScanMetadata from dictionary."""
+        responses = [ResponseMetadata.from_dict(r) for r in data.get("responses", [])]
+        return cls(
+            timestamp=data["timestamp"],
+            responses=responses,
+        )
+
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""
         return {

plain-scan/plain/scan/output.py

@@ -21,13 +21,7 @@ def format_check_result(check: CheckResult, indent: int = 0) -> list[str]:
         + ": "
         + click.style(check.message, dim=True)
     )
-    lines = [line]
-
-    # Add nested checks
-    for nested_check in check.nested_checks:
-        lines.extend(format_check_result(nested_check, indent + 1))
-
-    return lines
+    return [line]
 
 
 def format_verbose_metadata(metadata: ScanMetadata | None) -> str:
@@ -282,10 +276,6 @@ def to_markdown(scan_result: ScanResult, verbose: bool = False) -> str:
             for check in audit.checks:
                 check_icon = "✓" if check.passed else "✗"
                 lines.append(f"- {check_icon} **{check.name}:** {check.message}")
-
-                for nested in check.nested_checks:
-                    nested_icon = "✓" if nested.passed else "✗"
-                    lines.append(f"  - {nested_icon} {nested.message}")
         else:
             # Security feature not detected - check if user disabled or just not found
             if audit.disabled:

plain-scan/plain/scan/results.py

@@ -14,18 +14,23 @@ class CheckResult:
     name: str
     passed: bool
     message: str
-    nested_checks: list[CheckResult] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> CheckResult:
+        """Reconstruct CheckResult from dictionary."""
+        return cls(
+            name=data["name"],
+            passed=data["passed"],
+            message=data["message"],
+        )
 
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""
-        result = {
+        return {
             "name": self.name,
             "passed": self.passed,
             "message": self.message,
         }
-        if self.nested_checks:
-            result["nested_checks"] = [check.to_dict() for check in self.nested_checks]
-        return result
 
 
 @dataclass
@@ -50,6 +55,19 @@ def passed(self) -> bool:
             return not self.required
         return all(check.passed for check in self.checks)
 
+    @classmethod
+    def from_dict(cls, data: dict) -> AuditResult:
+        """Reconstruct AuditResult from dictionary."""
+        checks = [CheckResult.from_dict(c) for c in data.get("checks", [])]
+        return cls(
+            name=data["name"],
+            detected=data["detected"],
+            checks=checks,
+            required=data.get("required", True),
+            disabled=data.get("disabled", False),
+            description=data.get("description"),
+        )
+
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""
         result = {
@@ -98,6 +116,21 @@ def total_count(self) -> int:
         """Total count of audits (excluding disabled audits)."""
         return sum(1 for audit in self.audits if not audit.disabled)
 
+    @classmethod
+    def from_dict(cls, data: dict) -> ScanResult:
+        """Reconstruct ScanResult from dictionary."""
+        from .metadata import ScanMetadata
+
+        audits = [AuditResult.from_dict(a) for a in data.get("audits", [])]
+        metadata = None
+        if "metadata" in data:
+            metadata = ScanMetadata.from_dict(data["metadata"])
+        return cls(
+            url=data["url"],
+            audits=audits,
+            metadata=metadata,
+        )
+
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""
         result = {