Binary snapshots (in-memory)

CHANGELOG.md

@@ -11,6 +11,8 @@ All notable changes to insta and cargo-insta are documented here.
 
 - Inline snapshots only use `#` characters as delimiters when required.  #603
 
+- Experimental support for binary snapshots
+
 ## 1.40.0
 
 - `cargo-insta` no longer panics when running `cargo insta test --accept --workspace`

cargo-insta/Cargo.toml

@@ -30,6 +30,7 @@ tempfile = "3.5.0"
 semver = {version = "1.0.7", features = ["serde"]}
 lazy_static = "1.4.0"
 clap = { workspace=true }
+open = "5.3.0"
 itertools = "0.10.0"
 
 [dev-dependencies]

cargo-insta/src/cli.rs

@@ -321,6 +321,24 @@ fn query_snapshot(
             style("toggle snapshot diff").dim()
         );
 
+        let new_is_binary = new.contents().is_binary();
+        let old_is_binary = old.map(|o| o.contents().is_binary()).unwrap_or(false);
+
+        if new_is_binary || old_is_binary {
+            println!(
+                "  {} open       {}",
+                style("o").cyan().bold(),
+                style(if new_is_binary && old_is_binary {
+                    "open snapshot files in external tool"
+                } else if new_is_binary {
+                    "open new snapshot file in external tool"
+                } else {
+                    "open old snapshot file in external tool"
+                })
+                .dim()
+            );
+        }
+
         loop {
             match term.read_key()? {
                 Key::Char('a') | Key::Enter => return Ok(Operation::Accept),
@@ -334,6 +352,21 @@ fn query_snapshot(
                     *show_diff = !*show_diff;
                     break;
                 }
+                Key::Char('o') => {
+                    if let Some(old) = old {
+                        if let Some(path) = old.build_binary_path(snapshot_file.unwrap()) {
+                            open::that_detached(path)?;
+                        }
+                    }
+
+                    if let Some(path) =
+                        new.build_binary_path(snapshot_file.unwrap().with_extension("snap.new"))
+                    {
+                        open::that_detached(path)?;
+                    }
+
+                    // there's no break here because there's no need to re-output anything
+                }
                 _ => {}
             }
         }
@@ -1085,8 +1118,11 @@ fn pending_snapshots_cmd(cmd: PendingSnapshotsCommand) -> Result<(), Box<dyn Err
         let is_inline = snapshot_container.snapshot_file().is_none();
         for snapshot_ref in snapshot_container.iter_snapshots() {
             if cmd.as_json {
-                let old_snapshot = snapshot_ref.old.as_ref().map(|x| x.contents_string());
-                let new_snapshot = snapshot_ref.new.contents_string();
+                let old_snapshot = snapshot_ref
+                    .old
+                    .as_ref()
+                    .map(|x| x.contents_string().unwrap());
+                let new_snapshot = snapshot_ref.new.contents_string().unwrap();
                 let info = if is_inline {
                     SnapshotKey::InlineSnapshot {
                         path: &target_file,

cargo-insta/src/container.rs

@@ -3,7 +3,7 @@ use std::fs;
 use std::path::{Path, PathBuf};
 
 use insta::Snapshot;
-pub(crate) use insta::SnapshotKind;
+pub(crate) use insta::TextSnapshotKind;
 use insta::_cargo_insta_support::{ContentError, PendingInlineSnapshot};
 
 use crate::inline::FilePatcher;
@@ -51,7 +51,7 @@ pub(crate) struct SnapshotContainer {
     pending_path: PathBuf,
     // Path of the target snapshot file (generally a `.snap` file)
     target_path: PathBuf,
-    kind: SnapshotKind,
+    kind: TextSnapshotKind,
     snapshots: Vec<PendingSnapshot>,
     patcher: Option<FilePatcher>,
 }
@@ -60,11 +60,11 @@ impl SnapshotContainer {
     pub(crate) fn load(
         pending_path: PathBuf,
         target_path: PathBuf,
-        kind: SnapshotKind,
+        kind: TextSnapshotKind,
     ) -> Result<SnapshotContainer, Box<dyn Error>> {
         let mut snapshots = Vec::new();
         let patcher = match kind {
-            SnapshotKind::File => {
+            TextSnapshotKind::File => {
                 let old = if fs::metadata(&target_path).is_err() {
                     None
                 } else {
@@ -80,7 +80,7 @@ impl SnapshotContainer {
                 });
                 None
             }
-            SnapshotKind::Inline => {
+            TextSnapshotKind::Inline => {
                 let mut pending_vec = PendingInlineSnapshot::load_batch(&pending_path)?;
                 let mut have_new = false;
 
@@ -136,8 +136,8 @@ impl SnapshotContainer {
 
     pub(crate) fn snapshot_file(&self) -> Option<&Path> {
         match self.kind {
-            SnapshotKind::File => Some(&self.target_path),
-            SnapshotKind::Inline => None,
+            TextSnapshotKind::File => Some(&self.target_path),
+            TextSnapshotKind::Inline => None,
         }
     }
 
@@ -167,7 +167,7 @@ impl SnapshotContainer {
         // Try removing the snapshot file. If it fails, it's
         // likely because it another process removed it; which
         // is fine — print a message and continue.
-        let try_removing_snapshot = |p| {
+        let try_removing_snapshot = |p: &Path| {
             fs::remove_file(p).unwrap_or_else(|_| {
                     eprintln!(
                         "Pending snapshot file at {:?} couldn't be removed. It was likely removed by another process.",
@@ -184,7 +184,10 @@ impl SnapshotContainer {
             for (idx, snapshot) in self.snapshots.iter().enumerate() {
                 match snapshot.op {
                     Operation::Accept => {
-                        patcher.set_new_content(idx, snapshot.new.contents());
+                        patcher.set_new_content(
+                            idx,
+                            snapshot.new.contents().as_string_contents().unwrap(),
+                        );
                         did_accept = true;
                     }
                     Operation::Reject => {}
@@ -213,22 +216,28 @@ impl SnapshotContainer {
             for snapshot in self.snapshots.iter() {
                 match snapshot.op {
                     Operation::Accept => {
-                        let snapshot = Snapshot::from_file(&self.pending_path).map_err(|e| {
-                            // If it's an IO error, pass a ContentError back so
-                            // we get a slightly clearer error message
-                            match e.downcast::<std::io::Error>() {
-                                Ok(io_error) => Box::new(ContentError::FileIo(
-                                    *io_error,
-                                    self.pending_path.to_path_buf(),
-                                )),
-                                Err(other_error) => other_error,
-                            }
-                        })?;
-                        snapshot.save(&self.target_path)?;
                         try_removing_snapshot(&self.pending_path);
+
+                        if let Some(ref old) = snapshot.old {
+                            if let Some(path) = old.build_binary_path(&self.target_path) {
+                                try_removing_snapshot(&path);
+                            }
+                        }
+
+                        if let Some(path) = snapshot.new.build_binary_path(&self.pending_path) {
+                            try_removing_snapshot(&path);
+                        }
+
+                        // We save at the end because we might write a binary file into the same
+                        // path again.
+                        snapshot.new.save(&self.target_path)?;
                     }
                     Operation::Reject => {
                         try_removing_snapshot(&self.pending_path);
+
+                        if let Some(path) = snapshot.new.build_binary_path(&self.pending_path) {
+                            try_removing_snapshot(&path);
+                        }
                     }
                     Operation::Skip => {}
                 }

cargo-insta/src/inline.rs

@@ -4,7 +4,7 @@ use std::fs;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 
-use insta::_cargo_insta_support::SnapshotContents;
+use insta::_cargo_insta_support::TextSnapshotContents;
 use proc_macro2::TokenTree;
 
 use syn::__private::ToTokens;
@@ -90,7 +90,7 @@ impl FilePatcher {
         self.inline_snapshots[id].start.0 + 1
     }
 
-    pub(crate) fn set_new_content(&mut self, id: usize, snapshot: &SnapshotContents) {
+    pub(crate) fn set_new_content(&mut self, id: usize, snapshot: &TextSnapshotContents) {
         let inline = &mut self.inline_snapshots[id];
 
         // find prefix and suffix on the first and last lines

cargo-insta/src/walk.rs

@@ -5,7 +5,7 @@ use std::path::Path;
 use ignore::overrides::OverrideBuilder;
 use ignore::{DirEntry, Walk, WalkBuilder};
 
-use crate::container::{SnapshotContainer, SnapshotKind};
+use crate::container::{SnapshotContainer, TextSnapshotKind};
 
 #[derive(Debug, Copy, Clone)]
 pub(crate) struct FindFlags {
@@ -38,7 +38,7 @@ pub(crate) fn find_pending_snapshots<'a>(
                 Some(SnapshotContainer::load(
                     path.clone(),
                     path.with_file_name(new_fname),
-                    SnapshotKind::File,
+                    TextSnapshotKind::File,
                 ))
             } else if let Some(new_fname) = fname
                 .strip_prefix('.')
@@ -47,7 +47,7 @@ pub(crate) fn find_pending_snapshots<'a>(
                 Some(SnapshotContainer::load(
                     path.clone(),
                     path.with_file_name(new_fname),
-                    SnapshotKind::Inline,
+                    TextSnapshotKind::Inline,
                 ))
             } else {
                 None