Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Fix SVG images in remote Markdown previews (#66404)

max1ab1d76f828eebf
diff --git a/Cargo.lock b/Cargo.lock
index 29a1c720485..08e67786227 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -13911,6 +13911,7 @@ dependencies = [
"tracing",
"unindent",
"url",
+ "usvg",
"util",
"watch",
"wax",
diff --git a/crates/image_viewer/src/image_info.rs b/crates/image_viewer/src/image_info.rs
index c819970051b..2c1d7f153aa 100644
--- a/crates/image_viewer/src/image_info.rs
+++ b/crates/image_viewer/src/image_info.rs
@@ -1,5 +1,5 @@
use gpui::{App, Context, Entity, IntoElement, ParentElement, Render, Subscription, div};
-use project::image_store::{ImageFormat, ImageMetadata};
+use project::image_store::{ImageFormat, ImageMetadata, RasterImageFormat};
use settings::Settings;
use ui::prelude::*;
use util::size::format_file_size;
@@ -64,15 +64,18 @@ impl Render for ImageInfo {
components.push(
match metadata.format {
- ImageFormat::Png => "PNG",
- ImageFormat::Jpeg => "JPEG",
- ImageFormat::Gif => "GIF",
- ImageFormat::WebP => "WebP",
- ImageFormat::Tiff => "TIFF",
- ImageFormat::Bmp => "BMP",
- ImageFormat::Ico => "ICO",
- ImageFormat::Avif => "Avif",
- _ => "Unknown",
+ ImageFormat::Svg => "SVG",
+ ImageFormat::Raster(format) => match format {
+ RasterImageFormat::Png => "PNG",
+ RasterImageFormat::Jpeg => "JPEG",
+ RasterImageFormat::Gif => "GIF",
+ RasterImageFormat::WebP => "WebP",
+ RasterImageFormat::Tiff => "TIFF",
+ RasterImageFormat::Bmp => "BMP",
+ RasterImageFormat::Ico => "ICO",
+ RasterImageFormat::Avif => "Avif",
+ _ => "Unknown",
+ },
}
.to_string(),
);
diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.toml
index de922bee0b2..585f5ce5787 100644
--- a/crates/project/Cargo.toml
+++ b/crates/project/Cargo.toml
@@ -99,6 +99,7 @@ text.workspace = true
toml.workspace = true
tracing.workspace = true
url.workspace = true
+usvg.workspace = true
util.workspace = true
watch.workspace = true
wax.workspace = true
diff --git a/crates/project/src/image_store.rs b/crates/project/src/image_store.rs
index a667f217887..82dd087aef8 100644
--- a/crates/project/src/image_store.rs
+++ b/crates/project/src/image_store.rs
@@ -9,7 +9,7 @@ use gpui::{
App, Asset, AssetLogger, AsyncApp, Context, Entity, EventEmitter, ImageCacheError, ImageSource,
Img, RenderImage, Subscription, Task, WeakEntity, prelude::*,
};
-pub use image::ImageFormat;
+pub use image::ImageFormat as RasterImageFormat;
use image::{ExtendedColorType, GenericImageView, ImageReader};
use language::{DiskState, File};
use rpc::{AnyProtoClient, ErrorExt as _, TypedEnvelope, proto};
@@ -57,6 +57,12 @@ pub enum ImageStoreEvent {
impl EventEmitter<ImageStoreEvent> for ImageStore {}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ImageFormat {
+ Raster(RasterImageFormat),
+ Svg,
+}
+
#[derive(Debug, Clone, Copy)]
pub struct ImageMetadata {
pub width: u32,
@@ -150,7 +156,20 @@ pub fn project_image_source(project: WeakEntity<Project>, path: ProjectPath) ->
impl ImageItem {
pub fn compute_metadata_from_bytes(image_bytes: &[u8]) -> Result<ImageMetadata> {
- let image_format = image::guess_format(image_bytes)?;
+ let image_format = match image::guess_format(image_bytes) {
+ Ok(format) => format,
+ Err(_) => {
+ let svg = usvg::Tree::from_data(image_bytes, &usvg::Options::default())?;
+ let size = svg.size().to_int_size();
+ return Ok(ImageMetadata {
+ width: size.width(),
+ height: size.height(),
+ file_size: image_bytes.len() as u64,
+ format: ImageFormat::Svg,
+ colors: None,
+ });
+ }
+ };
let mut image_reader = ImageReader::new(std::io::Cursor::new(image_bytes));
image_reader.set_format(image_format);
@@ -162,7 +181,7 @@ impl ImageItem {
width,
height,
file_size: image_bytes.len() as u64,
- format: image_format,
+ format: ImageFormat::Raster(image_format),
colors: ImageColorInfo::from_color_type(image.color()),
})
}
@@ -932,7 +951,16 @@ impl LocalImageStore {
}
fn create_gpui_image(content: Vec<u8>) -> anyhow::Result<Arc<gpui::Image>> {
- let format = image::guess_format(&content)?;
+ let format = match image::guess_format(&content) {
+ Ok(format) => format,
+ Err(_) => {
+ usvg::Tree::from_data(&content, &usvg::Options::default())?;
+ return Ok(Arc::new(gpui::Image::from_bytes(
+ gpui::ImageFormat::Svg,
+ content,
+ )));
+ }
+ };
Ok(Arc::new(gpui::Image::from_bytes(
match format {
diff --git a/crates/project/tests/integration/image_store.rs b/crates/project/tests/integration/image_store.rs
index 1252c2b7b5c..888fdc7683c 100644
--- a/crates/project/tests/integration/image_store.rs
+++ b/crates/project/tests/integration/image_store.rs
@@ -73,6 +73,99 @@ fn test_compute_metadata_from_bytes() {
assert_eq!(metadata.width, 1);
assert_eq!(metadata.height, 1);
assert_eq!(metadata.file_size, png_bytes.len() as u64);
- assert_eq!(metadata.format, image::ImageFormat::Png);
+ assert_eq!(
+ metadata.format,
+ ImageFormat::Raster(image::ImageFormat::Png)
+ );
assert!(metadata.colors.is_some());
}
+
+#[test]
+fn test_svg_metadata_from_contents() {
+ for prefix in [
+ "",
+ "<?xml version=\"1.0\"?>\n",
+ "\u{feff}",
+ "<!-- image -->\n",
+ ] {
+ let content = format!(
+ "{prefix}<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 200 100\"><rect width=\"200\" height=\"100\" fill=\"red\"/></svg>"
+ );
+ let metadata = ImageItem::compute_metadata_from_bytes(content.as_bytes())
+ .expect("SVG metadata should load regardless of the XML prefix");
+ assert_eq!(metadata.format, ImageFormat::Svg);
+ assert_eq!((metadata.width, metadata.height), (200, 100));
+ assert_eq!(metadata.file_size, content.len() as u64);
+ assert!(metadata.colors.is_none());
+ }
+}
+
+#[test]
+fn test_invalid_svg_metadata() {
+ for content in [
+ "",
+ "not an image",
+ "<svg",
+ "<html><body>SVG</body></html>",
+ "<!-- <svg xmlns=\"http://www.w3.org/2000/svg\"/> -->",
+ ] {
+ assert!(ImageItem::compute_metadata_from_bytes(content.as_bytes()).is_err());
+ }
+}
+
+#[gpui::test]
+async fn test_open_svg_image_by_contents(cx: &mut TestAppContext) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ "/root",
+ json!({
+ "image.bin": "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"10\"/>",
+ "broken.svg": "<svg",
+ "html.svg": "<html><body>not an SVG</body></html>"
+ }),
+ )
+ .await;
+ let project = Project::test(fs, ["/root".as_ref()], cx).await;
+ let worktree_id = project.read_with(cx, |project, cx| {
+ project
+ .worktrees(cx)
+ .next()
+ .expect("worktree")
+ .read(cx)
+ .id()
+ });
+ let image = project
+ .update(cx, |project, cx| {
+ project.open_image(
+ ProjectPath {
+ worktree_id,
+ path: rel_path("image.bin").into(),
+ },
+ cx,
+ )
+ })
+ .await
+ .expect("ImageStore should identify SVG by contents");
+ image.read_with(cx, |image, _| {
+ assert_eq!(image.image.format(), gpui::ImageFormat::Svg);
+ let metadata = image.image_metadata.expect("SVG should have metadata");
+ assert_eq!(metadata.format, ImageFormat::Svg);
+ assert_eq!((metadata.width, metadata.height), (20, 10));
+ });
+
+ for image_path in ["broken.svg", "html.svg"] {
+ let result = project
+ .update(cx, |project, cx| {
+ project.open_image(
+ ProjectPath {
+ worktree_id,
+ path: rel_path(image_path).into(),
+ },
+ cx,
+ )
+ })
+ .await;
+ assert!(result.is_err(), "{image_path}");
+ }
+}
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index 5f9137aecec..a9d324bed4e 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -674,7 +674,11 @@ async fn test_remote_project_image_source(cx: &mut TestAppContext, server_cx: &m
json!({
"project": {
"docs": {
- "image.ppm": "P3\n1 1\n255\n255 0 0\n"
+ "image.ppm": "P3\n1 1\n255\n255 0 0\n",
+ "image.svg": r#"<?xml version="1.0"?>
+ <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1 1">
+ <rect width="1" height="1" fill="red"/>
+ </svg>"#
}
}
}),
@@ -689,48 +693,47 @@ async fn test_remote_project_image_source(cx: &mut TestAppContext, server_cx: &m
.await
.expect("remote worktree should open");
let worktree_id = worktree.read_with(cx, |worktree, _cx| worktree.id());
- let source = image_store::project_image_source(
- project.downgrade(),
- ProjectPath {
- worktree_id,
- path: rel_path("docs/image.ppm").into(),
- },
- );
- let ImageSource::Custom(load_image) = source else {
- panic!("expected a project-backed image source");
- };
- let loaded_bytes = Arc::new(std::sync::Mutex::new(None));
- let observed_source = ImageSource::from({
- let loaded_bytes = loaded_bytes.clone();
- move |window: &mut gpui::Window, cx: &mut gpui::App| {
- let result = load_image(window, cx);
- if let Some(Ok(image)) = &result {
- *loaded_bytes.lock().expect("loaded image mutex poisoned") =
- image.as_bytes(0).map(ToOwned::to_owned);
+ for image_path in ["docs/image.ppm", "docs/image.svg"] {
+ let source = image_store::project_image_source(
+ project.downgrade(),
+ ProjectPath {
+ worktree_id,
+ path: rel_path(image_path).into(),
+ },
+ );
+ let ImageSource::Custom(load_image) = source else {
+ panic!("expected a project-backed image source");
+ };
+ let loaded_bytes = Arc::new(std::sync::Mutex::new(None));
+ let observed_source = ImageSource::from({
+ let loaded_bytes = loaded_bytes.clone();
+ move |window: &mut gpui::Window, cx: &mut gpui::App| {
+ let result = load_image(window, cx);
+ if let Some(Ok(image)) = &result {
+ *loaded_bytes.lock().expect("loaded image mutex poisoned") =
+ image.as_bytes(0).map(ToOwned::to_owned);
+ }
+ result
}
- result
- }
- });
+ });
- let (view, cx) = cx.add_window_view(|_window, _cx| RemoteImageTestView {
- source: observed_source,
- });
- cx.draw(Default::default(), size(px(10.), px(10.)), {
- let view = view.clone();
- move |_, _| view.into_any_element()
- });
- cx.run_until_parked();
- cx.draw(Default::default(), size(px(10.), px(10.)), move |_, _| {
- view.into_any_element()
- });
+ let (view, cx) = cx.add_window_view(|_window, _cx| RemoteImageTestView {
+ source: observed_source,
+ });
+ cx.draw(Default::default(), size(px(10.), px(10.)), {
+ let view = view.clone();
+ move |_, _| view.into_any_element()
+ });
+ cx.run_until_parked();
+ cx.draw(Default::default(), size(px(10.), px(10.)), move |_, _| {
+ view.into_any_element()
+ });
- assert_eq!(
- loaded_bytes
- .lock()
- .expect("loaded image mutex poisoned")
- .as_deref(),
- Some([0, 0, 255, 255].as_slice())
- );
+ let loaded_bytes = loaded_bytes.lock().expect("loaded image mutex poisoned");
+ let bytes = loaded_bytes.as_ref().expect("remote image should render");
+ let pixel_count = if image_path.ends_with(".ppm") { 1 } else { 4 };
+ assert_eq!(bytes, &[0, 0, 255, 255].repeat(pixel_count), "{image_path}");
+ }
}
#[gpui::test]