Updates

Author: rbro112

src/api/data_types/snapshots.rs

@@ -22,11 +22,15 @@ pub struct SnapshotsManifest {
 
 // Keep in sync with https://github.com/getsentry/sentry/blob/master/src/sentry/preprod/snapshots/manifest.py
 /// Metadata for a single image in a snapshot manifest.
+///
+/// The `image_file_name`, `width`, and `height` fields are set by the CLI.
+/// Any additional fields from a companion JSON sidecar file are included
+/// via `extra` and flattened into the serialized output.
 #[derive(Debug, Serialize)]
 pub struct ImageMetadata {
     pub image_file_name: String,
     pub width: u32,
     pub height: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub display_name: Option<String>,
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
 }

src/commands/build/snapshots.rs

@@ -12,8 +12,6 @@ use secrecy::ExposeSecret as _;
 use sha2::{Digest as _, Sha256};
 use walkdir::WalkDir;
 
-use serde::Deserialize;
-
 use crate::api::{Api, CreateSnapshotResponse, ImageMetadata, SnapshotsManifest};
 use crate::config::{Auth, Config};
 use crate::utils::args::ArgExt as _;
@@ -97,8 +95,8 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
         style(images.len()).yellow(),
         if images.len() == 1 { "file" } else { "files" }
     );
-    let display_names = collect_display_names(dir_path);
-    let manifest_entries = upload_images(images, &display_names, &org, &project)?;
+
+    let manifest_entries = upload_images(images, &org, &project)?;
 
     // Build manifest from discovered images
     let manifest = SnapshotsManifest {
@@ -191,9 +189,42 @@ fn is_image_file(path: &Path) -> bool {
         .unwrap_or(false)
 }
 
+/// Reads the companion JSON sidecar for an image, if it exists.
+///
+/// For an image at `path/to/button.png`, looks for `path/to/button.json`.
+/// Returns a map of all key-value pairs from the JSON file.
+fn read_sidecar_metadata(image_path: &Path) -> HashMap<String, serde_json::Value> {
+    let sidecar_path = image_path.with_extension("json");
+    if !sidecar_path.is_file() {
+        return HashMap::new();
+    }
+
+    debug!("Reading sidecar metadata: {}", sidecar_path.display());
+    let contents = match fs::read_to_string(&sidecar_path) {
+        Ok(c) => c,
+        Err(err) => {
+            warn!(
+                "Failed to read sidecar file {}: {err}",
+                sidecar_path.display()
+            );
+            return HashMap::new();
+        }
+    };
+
+    match serde_json::from_str(&contents) {
+        Ok(map) => map,
+        Err(err) => {
+            warn!(
+                "Failed to parse sidecar file {}: {err}",
+                sidecar_path.display()
+            );
+            HashMap::new()
+        }
+    }
+}
+
 fn upload_images(
     images: Vec<ImageInfo>,
-    display_names: &HashMap<String, String>,
     org: &str,
     project: &str,
 ) -> Result<HashMap<String, ImageMetadata>> {
@@ -251,14 +282,16 @@ fn upload_images(
             .unwrap_or_default()
             .to_string_lossy()
             .into_owned();
-        let display_name = display_names.get(&image_file_name).cloned();
+
+        let extra = read_sidecar_metadata(&image.path);
+
         manifest_entries.insert(
             hash,
             ImageMetadata {
+                extra,
                 image_file_name,
                 width: image.width,
                 height: image.height,
-                display_name,
             },
         );
     }
@@ -286,62 +319,3 @@ fn upload_images(
         }
     }
 }
-
-/// Input format for user-provided JSON manifest files.
-#[derive(Deserialize)]
-struct ManifestFile {
-    images: HashMap<String, ManifestFileEntry>,
-}
-
-#[derive(Deserialize)]
-struct ManifestFileEntry {
-    image_file_name: String,
-    display_name: Option<String>,
-}
-
-/// Collects `image_file_name -> display_name` mappings from JSON manifest files in a directory.
-fn collect_display_names(dir: &Path) -> HashMap<String, String> {
-    let mut display_names = HashMap::new();
-    let entries = WalkDir::new(dir)
-        .follow_links(true)
-        .into_iter()
-        .filter_entry(|e| !is_hidden(dir, e.path()));
-
-    for entry in entries.flatten() {
-        if !entry.file_type().is_file() {
-            continue;
-        }
-        let path = entry.path();
-        let is_json = path
-            .extension()
-            .and_then(|ext| ext.to_str())
-            .map(|ext| ext.eq_ignore_ascii_case("json"))
-            .unwrap_or(false);
-        if !is_json {
-            continue;
-        }
-
-        debug!("Reading manifest file: {}", path.display());
-        let contents = match fs::read_to_string(path) {
-            Ok(c) => c,
-            Err(err) => {
-                warn!("Failed to read manifest file {}: {err}", path.display());
-                continue;
-            }
-        };
-        let manifest: ManifestFile = match serde_json::from_str(&contents) {
-            Ok(m) => m,
-            Err(err) => {
-                warn!("Failed to parse manifest file {}: {err}", path.display());
-                continue;
-            }
-        };
-
-        for entry in manifest.images.into_values() {
-            if let Some(display_name) = entry.display_name {
-                display_names.insert(entry.image_file_name, display_name);
-            }
-        }
-    }
-    display_names
-}