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.

8.3 KB
Raw Blame
use std::path::{Path, PathBuf};
use std::sync::Arc;

use anyhow::{Context as _, Result};
use fs::{CopyOptions, Fs, copy_recursive};

use crate::ExtensionManifest;

async fn create_dir(fs: &dyn Fs, path: &Path) -> Result<()> {
    fs.create_dir(path)
        .await
        .with_context(|| format!("creating {path:?}"))
}

pub async fn copy_extension_resources(
    manifest: &ExtensionManifest,
    extension_path: &Path,
    output_dir: &Path,
    fs: Arc<dyn Fs>,
) -> Result<()> {
    create_dir(fs.as_ref(), output_dir).await?;

    let manifest_toml = toml::to_string(manifest).context("serializing extension manifest")?;
    let manifest_path = output_dir.join("extension.toml");
    fs.write(&manifest_path, manifest_toml.as_bytes())
        .await
        .with_context(|| format!("writing {manifest_path:?}"))?;

    if manifest.lib.kind.is_some() {
        let source_path = extension_path.join("extension.wasm");
        let output_path = output_dir.join("extension.wasm");
        fs.copy_file(
            &source_path,
            &output_path,
            CopyOptions {
                overwrite: true,
                ignore_if_exists: false,
            },
        )
        .await
        .with_context(|| format!("copying {source_path:?} to {output_path:?}"))?;
    }

    if !manifest.grammars.is_empty() {
        let source_grammars_dir = extension_path.join("grammars");
        let output_grammars_dir = output_dir.join("grammars");
        create_dir(fs.as_ref(), &output_grammars_dir).await?;
        futures::future::try_join_all(manifest.grammars.keys().map(|grammar_name| {
            let fs = fs.clone();
            let source_grammars_dir = source_grammars_dir.as_path();
            let output_grammars_dir = output_grammars_dir.as_path();
            async move {
                let mut grammar_filename = PathBuf::from(grammar_name.as_ref());
                grammar_filename.set_extension("wasm");
                fs.copy_file(
                    &source_grammars_dir.join(&grammar_filename),
                    &output_grammars_dir.join(&grammar_filename),
                    CopyOptions {
                        overwrite: true,
                        ignore_if_exists: false,
                    },
                )
                .await
                .with_context(|| format!("copying grammar {grammar_filename:?}"))
            }
        }))
        .await?;
    }

    if !manifest.themes.is_empty() {
        let output_themes_dir = output_dir.join("themes");
        create_dir(fs.as_ref(), &output_themes_dir).await?;
        futures::future::try_join_all(manifest.themes.iter().map(|theme_path| {
            let fs = fs.clone();
            let output_themes_dir = output_themes_dir.as_path();
            async move {
                let theme_path = theme_path.as_std_path();
                fs.copy_file(
                    &extension_path.join(theme_path),
                    &output_themes_dir.join(theme_path.file_name().context("invalid theme path")?),
                    CopyOptions {
                        overwrite: true,
                        ignore_if_exists: false,
                    },
                )
                .await
                .with_context(|| format!("copying theme {theme_path:?}"))
            }
        }))
        .await?;
    }

    if !manifest.icon_themes.is_empty() {
        let output_icon_themes_dir = output_dir.join("icon_themes");
        create_dir(fs.as_ref(), &output_icon_themes_dir).await?;
        futures::future::try_join_all(manifest.icon_themes.iter().map(|icon_theme_path| {
            let fs = fs.clone();
            let output_icon_themes_dir = output_icon_themes_dir.as_path();
            async move {
                let icon_theme_path = icon_theme_path.as_std_path();
                fs.copy_file(
                    &extension_path.join(icon_theme_path),
                    &output_icon_themes_dir.join(
                        icon_theme_path
                            .file_name()
                            .context("invalid icon theme path")?,
                    ),
                    CopyOptions {
                        overwrite: true,
                        ignore_if_exists: false,
                    },
                )
                .await
                .with_context(|| format!("copying icon theme {icon_theme_path:?}"))
            }
        }))
        .await?;

        let source_icons_dir = extension_path.join("icons");
        let output_icons_dir = output_dir.join("icons");
        create_dir(fs.as_ref(), &output_icons_dir).await?;
        copy_recursive(
            fs.as_ref(),
            &source_icons_dir,
            &output_icons_dir,
            CopyOptions {
                overwrite: true,
                ignore_if_exists: false,
            },
        )
        .await
        .with_context(|| format!("copying {source_icons_dir:?} to {output_icons_dir:?}"))?;
    }

    if !manifest.languages.is_empty() {
        let output_languages_dir = output_dir.join("languages");
        create_dir(fs.as_ref(), &output_languages_dir).await?;
        futures::future::try_join_all(manifest.languages.iter().map(|language_path| {
            let fs = fs.clone();
            let output_languages_dir = output_languages_dir.clone();
            async move {
                let language_path = language_path.as_std_path();
                let source_path = extension_path.join(language_path);
                let output_path = output_languages_dir
                    .join(language_path.file_name().context("invalid language path")?);
                copy_recursive(
                    fs.as_ref(),
                    &source_path,
                    &output_path,
                    CopyOptions {
                        overwrite: true,
                        ignore_if_exists: false,
                    },
                )
                .await
                .with_context(|| format!("copying {source_path:?} to {output_path:?}"))
            }
        }))
        .await?;
    }

    if !manifest.debug_adapters.is_empty() {
        futures::future::try_join_all(manifest.debug_adapters.iter().map(
            |(debug_adapter, entry)| {
                let fs = fs.clone();
                let debug_adapter = debug_adapter.clone();
                async move {
                    let schema_path =
                        crate::build_debug_adapter_schema_path(&debug_adapter, &entry)?;
                    let parent = schema_path.parent().with_context(|| {
                        format!("invalid empty schema path for {debug_adapter}")
                    })?;
                    let schema_path = schema_path.as_std_path();
                    let source_path = extension_path.join(schema_path);
                    let output_path = output_dir.join(schema_path);
                    create_dir(fs.as_ref(), &output_dir.join(parent)).await?;
                    copy_recursive(
                        fs.as_ref(),
                        &source_path,
                        &output_path,
                        CopyOptions {
                            overwrite: true,
                            ignore_if_exists: false,
                        },
                    )
                    .await
                    .with_context(|| format!("copying {source_path:?} to {output_path:?}"))
                }
            },
        ))
        .await?;
    }

    if let Some(snippets) = manifest.snippets.as_ref() {
        futures::future::try_join_all(snippets.paths().map(|snippets_path| {
            let fs = fs.clone();
            async move {
                let parent = snippets_path.parent();
                if let Some(parent) = parent.filter(|p| p.components().next().is_some()) {
                    create_dir(fs.as_ref(), &output_dir.join(parent)).await?;
                }
                let source_path = extension_path.join(snippets_path);
                let output_path = output_dir.join(snippets_path);
                copy_recursive(
                    fs.as_ref(),
                    &source_path,
                    &output_path,
                    CopyOptions {
                        overwrite: true,
                        ignore_if_exists: false,
                    },
                )
                .await
                .with_context(|| format!("copying {source_path:?} to {output_path:?}"))
            }
        }))
        .await?;
    }

    Ok(())
}