refactor: simplify conversion of scan result

Author: tembleking

src/infra/sysdig_image_scanner_result.rs

@@ -9,7 +9,6 @@ use crate::app::{self, ImageScanResult, LayerScanResult, VulnerabilityEntry};
 
 impl From<SysdigImageScannerReport> for ImageScanResult {
     fn from(report: SysdigImageScannerReport) -> Self {
-        // a) Todas las vulnerabilidades de la imagen
         let vulnerabilities = report
             .result
             .as_ref()
@@ -24,7 +23,6 @@ impl From<SysdigImageScannerReport> for ImageScanResult {
             })
             .unwrap_or_default();
 
-        // b) Cumplimiento de políticas
         let is_compliant = report
             .result
             .as_ref()
@@ -33,8 +31,8 @@ impl From<SysdigImageScannerReport> for ImageScanResult {
             .map(|e| e == &PoliciesGlobalEvaluation::Accepted)
             .unwrap_or(false);
 
-        // c) Por capas
-        let layers = layers_for_result(report.result.as_ref().unwrap());
+        let scan_result_response = report.result.as_ref().expect("the report must always have a scan result response, this one didn't, which should never happen");
+        let layers = layers_for_result(scan_result_response);
 
         ImageScanResult {
             vulnerabilities,
@@ -45,54 +43,53 @@ impl From<SysdigImageScannerReport> for ImageScanResult {
 }
 
 fn layers_for_result(scan: &ScanResultResponse) -> Option<Vec<LayerScanResult>> {
-    // Agrupa cada vuln por digest de capa
     let mut layer_map: HashMap<&String, Vec<VulnerabilityEntry>> = HashMap::new();
+
     for vuln in scan.vulnerabilities.as_ref()?.values() {
-        if let (Some(_pkg), Some(layer_ref)) = (
-            vuln.package_ref.as_ref().and_then(|r| scan.packages.get(r)),
-            scan.packages
-                .get(vuln.package_ref.as_ref()?)?
-                .layer_ref
-                .as_ref(),
-        ) {
-            layer_map
-                .entry(layer_ref)
-                .or_default()
-                .push(VulnerabilityEntry {
-                    id: vuln.name.clone(),
-                    severity: severity_for(&vuln.severity),
-                });
-        }
+        let Some(package_ref) = vuln.package_ref.as_ref() else {
+            continue;
+        };
+
+        let Some(package) = scan.packages.get(package_ref) else {
+            continue;
+        };
+
+        let Some(layer_ref) = package.layer_ref.as_ref() else {
+            continue;
+        };
+
+        layer_map
+            .entry(layer_ref)
+            .or_default()
+            .push(VulnerabilityEntry {
+                id: vuln.name.clone(),
+                severity: severity_for(&vuln.severity),
+            });
     }
 
-    Some(
-        scan.layers
-            .as_ref()?
-            .values()
-            .sorted_by(|left, right| {
-                left.index
-                    .unwrap_or_default()
-                    .cmp(&right.index.unwrap_or_default())
-            })
-            .map(|layer| {
-                let entries = layer_map.get(&layer.digest).cloned().unwrap_or_default();
-                LayerScanResult {
-                    layer_instruction: layer
-                        .command
-                        .as_deref()
-                        .unwrap_or_default()
-                        .strip_prefix("/bin/sh -c #(nop) ")
-                        .unwrap_or_default()
-                        .split_whitespace()
-                        .next()
-                        .unwrap_or_default()
-                        .to_uppercase(),
-                    layer_text: layer.command.clone().unwrap_or_default(),
-                    vulnerabilities: entries,
-                }
-            })
-            .collect(),
-    )
+    let layers_in_scan = scan.layers.as_ref()?.values();
+
+    let layers_ordered = layers_in_scan.sorted_by(|left, right| left.index.cmp(&right.index));
+
+    let layers_converted_to_layer_scan_result = layers_ordered.map(|layer| {
+        let entries = layer_map.get(&layer.digest).cloned().unwrap_or_default();
+        LayerScanResult {
+            layer_instruction: layer
+                .command
+                .as_deref()
+                .unwrap_or_default()
+                .strip_prefix("/bin/sh -c #(nop) ")
+                .unwrap_or_default()
+                .split_whitespace()
+                .next()
+                .unwrap_or_default()
+                .to_uppercase(),
+            layer_text: layer.command.clone().unwrap_or_default(),
+            vulnerabilities: entries,
+        }
+    });
+
+    Some(layers_converted_to_layer_scan_result.collect())
 }
 
 fn severity_for(sev: &VulnSeverity) -> app::VulnSeverity {