Wire elyspace import export UI

2026-05-08 23:22:55 -04:00
parent 058d377eab
commit 0203840b68
11 changed files with 747 additions and 206 deletions
@@ -0,0 +1,322 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+use directories::UserDirs;
+use ely_browser_core::{ELYSPACE_FILE_EXTENSION, SpaceImportProfileMapping};
+use ely_domain::SpaceId;
+use gpui::{Context, PathPromptOptions, Window};
+
+use super::{ElyShell, ShellState};
+
+const SPACE_SETTINGS_URL: &str = "ely://settings/spaces";
+
+impl ElyShell {
+    pub(super) fn export_active_space(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let space_id = match &self.state {
+            ShellState::Ready(core) => match core.snapshot() {
+                Ok(snapshot) => snapshot.active_space_id,
+                Err(error) => {
+                    self.set_space_file_error(error.to_string(), cx);
+                    return;
+                }
+            },
+            ShellState::StartupError(message) => {
+                self.set_space_file_error(message.clone(), cx);
+                return;
+            }
+        };
+
+        self.export_space(&space_id, window, cx);
+    }
+
+    pub(super) fn export_space(
+        &mut self,
+        space_id: &SpaceId,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.ensure_space_settings_surface(window, cx);
+        self.clear_space_file_message();
+
+        let export = match &mut self.state {
+            ShellState::Ready(core) => {
+                let package_json = match core.export_space_package_json(space_id) {
+                    Ok(package_json) => package_json,
+                    Err(error) => {
+                        self.set_space_file_error(error.to_string(), cx);
+                        return;
+                    }
+                };
+                let package = match core.export_space_package(space_id) {
+                    Ok(package) => package,
+                    Err(error) => {
+                        self.set_space_file_error(error.to_string(), cx);
+                        return;
+                    }
+                };
+                Ok((package.space_name().to_string(), package_json))
+            }
+            ShellState::StartupError(message) => Err(message.clone()),
+        };
+
+        let (space_name, package_json) = match export {
+            Ok(export) => export,
+            Err(error) => {
+                self.set_space_file_error(error, cx);
+                return;
+            }
+        };
+        let directory = match default_export_directory() {
+            Ok(directory) => directory,
+            Err(error) => {
+                self.set_space_file_error(error, cx);
+                return;
+            }
+        };
+        let suggested_name = space_export_filename(&space_name);
+        let prompt = cx.prompt_for_new_path(&directory, Some(&suggested_name));
+
+        cx.spawn_in(window, async move |shell, window| {
+            let selected_path = match prompt.await {
+                Ok(Ok(path)) => path,
+                Ok(Err(error)) => {
+                    _ = shell.update_in(window, |shell, _, cx| {
+                        shell.set_space_file_error(error.to_string(), cx);
+                    });
+                    return;
+                }
+                Err(error) => {
+                    _ = shell.update_in(window, |shell, _, cx| {
+                        shell.set_space_file_error(error.to_string(), cx);
+                    });
+                    return;
+                }
+            };
+
+            let Some(path) = selected_path else {
+                return;
+            };
+
+            let result = window
+                .background_executor()
+                .spawn(async move { write_space_package(path, package_json) })
+                .await;
+            _ = shell.update_in(window, |shell, _, cx| {
+                shell.handle_space_export_result(result, cx);
+            });
+        })
+        .detach();
+    }
+
+    pub(super) fn choose_space_import(
+        &mut self,
+        profile_mapping: SpaceImportProfileMapping,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.ensure_space_settings_surface(window, cx);
+        self.clear_space_file_message();
+
+        let prompt = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: false,
+            prompt: Some("Select .elyspace file".into()),
+        });
+
+        cx.spawn_in(window, async move |shell, window| {
+            let selected_path = match prompt.await {
+                Ok(Ok(Some(paths))) => paths.into_iter().next(),
+                Ok(Ok(None)) => None,
+                Ok(Err(error)) => {
+                    _ = shell.update_in(window, |shell, _, cx| {
+                        shell.set_space_file_error(error.to_string(), cx);
+                    });
+                    return;
+                }
+                Err(error) => {
+                    _ = shell.update_in(window, |shell, _, cx| {
+                        shell.set_space_file_error(error.to_string(), cx);
+                    });
+                    return;
+                }
+            };
+
+            let Some(path) = selected_path else {
+                return;
+            };
+
+            let result =
+                window.background_executor().spawn(async move { read_space_package(path) }).await;
+            _ = shell.update_in(window, |shell, window, cx| {
+                shell.handle_space_import_result(result, profile_mapping, window, cx);
+            });
+        })
+        .detach();
+    }
+
+    fn ensure_space_settings_surface(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if self.active_tab_matches_url(SPACE_SETTINGS_URL) {
+            return;
+        }
+
+        self.open_internal_tab(SPACE_SETTINGS_URL, window, cx);
+    }
+
+    fn clear_space_file_message(&mut self) {
+        self.space_file_error = None;
+        self.space_file_notice = None;
+    }
+
+    fn set_space_file_error(&mut self, message: String, cx: &mut Context<Self>) {
+        self.space_file_error = Some(message);
+        self.space_file_notice = None;
+        cx.notify();
+    }
+
+    fn set_space_file_notice(&mut self, message: String, cx: &mut Context<Self>) {
+        self.space_file_notice = Some(message);
+        self.space_file_error = None;
+        cx.notify();
+    }
+
+    fn handle_space_export_result(
+        &mut self,
+        result: Result<PathBuf, String>,
+        cx: &mut Context<Self>,
+    ) {
+        match result {
+            Ok(path) => self.set_space_file_notice(format!("Exported {}", path.display()), cx),
+            Err(error) => self.set_space_file_error(error, cx),
+        }
+    }
+
+    fn handle_space_import_result(
+        &mut self,
+        result: Result<String, String>,
+        profile_mapping: SpaceImportProfileMapping,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let package_json = match result {
+            Ok(package_json) => package_json,
+            Err(error) => {
+                self.set_space_file_error(error, cx);
+                return;
+            }
+        };
+
+        let import_result = match &mut self.state {
+            ShellState::Ready(core) => core
+                .import_space_package_json(&package_json, profile_mapping)
+                .and_then(|space_id| {
+                    core.snapshot().map(|snapshot| {
+                        snapshot.spaces.iter().find(|space| space.id() == &space_id).map_or_else(
+                            || "Imported Space".to_string(),
+                            |space| format!("Imported {}", space.name()),
+                        )
+                    })
+                })
+                .map_err(|error| error.to_string()),
+            ShellState::StartupError(message) => Err(message.clone()),
+        };
+
+        match import_result {
+            Ok(message) => {
+                self.sync_address_input(window, cx);
+                self.set_space_file_notice(message, cx);
+            }
+            Err(error) => self.set_space_file_error(error, cx),
+        }
+    }
+}
+
+fn default_export_directory() -> Result<PathBuf, String> {
+    UserDirs::new()
+        .and_then(|dirs| dirs.document_dir().map(Path::to_path_buf))
+        .ok_or_else(|| "Documents directory is unavailable.".to_string())
+}
+
+fn write_space_package(path: PathBuf, package_json: String) -> Result<PathBuf, String> {
+    let path = normalize_export_path(path)?;
+    fs::write(&path, package_json)
+        .map_err(|error| format!("Unable to write {}: {error}", path.display()))?;
+    Ok(path)
+}
+
+fn read_space_package(path: PathBuf) -> Result<String, String> {
+    if !path_has_elyspace_extension(&path) {
+        return Err("Selected file must use .elyspace extension.".to_string());
+    }
+
+    fs::read_to_string(&path).map_err(|error| format!("Unable to read {}: {error}", path.display()))
+}
+
+fn normalize_export_path(mut path: PathBuf) -> Result<PathBuf, String> {
+    if path.extension().is_none() {
+        path.set_extension(ELYSPACE_FILE_EXTENSION);
+        return Ok(path);
+    }
+
+    if path_has_elyspace_extension(&path) {
+        Ok(path)
+    } else {
+        Err("Export path must use .elyspace extension.".to_string())
+    }
+}
+
+fn path_has_elyspace_extension(path: &Path) -> bool {
+    path.extension().is_some_and(|extension| {
+        extension.to_string_lossy().eq_ignore_ascii_case(ELYSPACE_FILE_EXTENSION)
+    })
+}
+
+fn space_export_filename(space_name: &str) -> String {
+    let mut stem = String::new();
+    let mut previous_separator = false;
+
+    for ch in space_name.chars() {
+        if ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_') {
+            stem.push(ch);
+            previous_separator = false;
+        } else if !previous_separator {
+            stem.push('-');
+            previous_separator = true;
+        }
+    }
+
+    let stem = stem.trim_matches('-');
+    let stem = if stem.is_empty() { "space" } else { stem };
+    format!("{stem}.{ELYSPACE_FILE_EXTENSION}")
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use super::{normalize_export_path, space_export_filename};
+
+    #[test]
+    fn space_export_filename_sanitizes_names() {
+        assert_eq!(space_export_filename("Work"), "Work.elyspace");
+        assert_eq!(space_export_filename("Client / Research"), "Client-Research.elyspace");
+        assert_eq!(space_export_filename("  "), "space.elyspace");
+    }
+
+    #[test]
+    fn normalize_export_path_adds_missing_extension() -> Result<(), String> {
+        let path = normalize_export_path(PathBuf::from("Work"))?;
+
+        assert_eq!(path, PathBuf::from("Work.elyspace"));
+        Ok(())
+    }
+
+    #[test]
+    fn normalize_export_path_rejects_other_extensions() {
+        let error = normalize_export_path(PathBuf::from("Work.json"));
+
+        assert_eq!(error, Err("Export path must use .elyspace extension.".to_string()));
+    }
+}