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.

29.9 KB
Raw Blame
use std::{collections::BTreeSet, sync::Arc};

use cloud_api_types::{ExtensionApiManifest, ExtensionMetadata, ExtensionProvides};
use extension::{ExtensionManifest, SchemaVersion};
use extension_host::{ExtensionOperation, ExtensionStatus, ExtensionStore};
use gpui::{Anchor, ElementId, Entity, Point, SharedString, prelude::*};
use release_channel::ReleaseChannel;
use ui::{Chip, ContextMenu, PopoverMenu, Tooltip, prelude::*, utils::format_number_with_commas};

type ContextMenuBuilder = Box<
    dyn Fn(Arc<str>, SharedString, &mut Window, &mut App) -> Option<Entity<ContextMenu>> + 'static,
>;
type ExtensionCardActions = [Option<Button>; 3];

/// Local state of a published extension, derived from the `ExtensionStore`.
#[derive(Clone)]
enum PublishedExtensionState {
    /// A dev extension with the same id is installed locally and takes
    /// precedence, so the published version can't be installed or managed.
    /// This replaces the store status, which would describe the dev extension.
    OverriddenByDevExtension,
    /// Managed by the store like any other extension.
    Store(ExtensionStatus),
}

impl PublishedExtensionState {
    fn new(extension_id: &str, extension_store: &ExtensionStore) -> Self {
        if extension_store.is_dev_extension(extension_id) {
            Self::OverriddenByDevExtension
        } else {
            Self::Store(extension_store.extension_status(extension_id))
        }
    }
}

#[derive(Clone, Copy, PartialEq, Eq)]
enum LocalExtensionKind {
    Dev,
    Installed,
}

struct ExtensionCardDetails {
    id: Arc<str>,
    name: SharedString,
    version: Arc<str>,
    description: Option<SharedString>,
    authors: SharedString,
    repository_url: Option<SharedString>,
    repository_icon: IconName,
    provided_features: Vec<&'static str>,
    source: ExtensionCardSource,
}

#[derive(Clone)]
enum ExtensionCardSource {
    Dev,
    Installed,
    Remote {
        state: PublishedExtensionState,
        download_count: u64,
    },
}

impl ExtensionCardSource {
    fn installed_version(&self, latest_version: &Arc<str>) -> Option<Arc<str>> {
        match self {
            Self::Remote {
                state: PublishedExtensionState::Store(ExtensionStatus::Installed(installed_version)),
                ..
            } if installed_version != latest_version => Some(installed_version.clone()),
            _ => None,
        }
    }

    fn download_count(&self) -> Option<u64> {
        match self {
            Self::Remote { download_count, .. } => Some(*download_count),
            Self::Dev | Self::Installed => None,
        }
    }

    fn is_dev(&self) -> bool {
        matches!(self, Self::Dev)
    }

    fn is_overridden(&self) -> bool {
        matches!(
            self,
            Self::Remote {
                state: PublishedExtensionState::OverriddenByDevExtension,
                ..
            }
        )
    }
}

#[derive(IntoElement, RegisterComponent)]
pub struct ExtensionCard {
    details: ExtensionCardDetails,
    actions: ExtensionCardActions,
    context_menu: Option<ContextMenuBuilder>,
}

impl ExtensionCard {
    pub fn for_dev(extension: Arc<ExtensionManifest>, extension_store: &ExtensionStore) -> Self {
        let status = extension_store.extension_status(&extension.id);
        Self::manifest(extension, status, LocalExtensionKind::Dev)
    }

    pub fn for_installed(
        extension: Arc<ExtensionManifest>,
        extension_store: &ExtensionStore,
    ) -> Self {
        let status = extension_store.extension_status(&extension.id);
        Self::manifest(extension, status, LocalExtensionKind::Installed)
    }

    pub fn for_remote(
        extension: &ExtensionMetadata,
        extension_store: &ExtensionStore,
        cx: &App,
    ) -> Self {
        let state = PublishedExtensionState::new(&extension.id, extension_store);
        Self::remote(extension, state, cx)
    }

    fn manifest(
        extension: Arc<ExtensionManifest>,
        status: ExtensionStatus,
        kind: LocalExtensionKind,
    ) -> Self {
        let actions = Self::actions_for_manifest_extension(&extension, &status, kind);
        let details = ExtensionCardDetails {
            id: extension.id.clone(),
            name: extension.name.clone().into(),
            version: extension.version.clone(),
            description: extension.description.clone().map(Into::into),
            authors: extension.authors.join(", ").into(),
            repository_url: extension.repository.clone().map(Into::into),
            repository_icon: IconName::Link,
            provided_features: provided_feature_labels(extension.provides()),
            source: match kind {
                LocalExtensionKind::Dev => ExtensionCardSource::Dev,
                LocalExtensionKind::Installed => ExtensionCardSource::Installed,
            },
        };

        Self {
            details,
            actions,
            context_menu: None,
        }
    }

    fn remote(extension: &ExtensionMetadata, state: PublishedExtensionState, cx: &App) -> Self {
        let actions = Self::actions_for_remote_extension(extension, &state, cx);
        let details = ExtensionCardDetails {
            id: extension.id.clone(),
            name: extension.manifest.name.clone().into(),
            version: extension.manifest.version.clone(),
            description: extension.manifest.description.clone().map(Into::into),
            authors: extension.manifest.authors.join(", ").into(),
            repository_url: Some(extension.manifest.repository.clone().into()),
            repository_icon: IconName::Link,
            provided_features: provided_feature_labels(extension.manifest.provides.iter().copied()),
            source: ExtensionCardSource::Remote {
                state,
                download_count: extension.download_count,
            },
        };

        Self {
            details,
            actions,
            context_menu: None,
        }
    }

    fn disables_actions(status: &ExtensionStatus) -> bool {
        match status {
            ExtensionStatus::Installing
            | ExtensionStatus::Upgrading
            | ExtensionStatus::Removing => true,
            ExtensionStatus::NotInstalled | ExtensionStatus::Installed(_) => false,
        }
    }

    fn button_id(extension_id: &Arc<str>, operation: ExtensionOperation) -> ElementId {
        (SharedString::from(extension_id.clone()), operation as usize).into()
    }

    fn uninstall_button(extension_id: &Arc<str>, is_dev: bool) -> Button {
        Button::new(
            Self::button_id(extension_id, ExtensionOperation::Remove),
            "Uninstall",
        )
        .on_click({
            let extension_id = extension_id.clone();
            move |_, _, cx| {
                if !is_dev {
                    telemetry::event!("Extension Uninstalled", extension_id);
                }
                ExtensionStore::global(cx).update(cx, |store, cx| {
                    store
                        .uninstall_extension(extension_id.clone(), cx)
                        .detach_and_log_err(cx);
                });
            }
        })
    }

    fn configure_button(
        extension_id: &Arc<str>,
        manifest: Option<Arc<ExtensionManifest>>,
    ) -> Button {
        Button::new(
            SharedString::from(format!("configure-{extension_id}")),
            "Configure",
        )
        .on_click({
            let extension_id = extension_id.clone();
            move |_, _, cx| {
                let manifest = manifest.clone().or_else(|| {
                    ExtensionStore::global(cx)
                        .read(cx)
                        .extension_manifest_for_id(&extension_id)
                        .cloned()
                });
                if let Some(manifest) = manifest
                    && let Some(events) = extension::ExtensionEvents::try_global(cx)
                {
                    events.update(cx, |this, cx| {
                        this.emit(extension::Event::ConfigureExtensionRequested(manifest), cx)
                    });
                }
            }
        })
    }

    fn actions_for_manifest_extension(
        extension: &Arc<ExtensionManifest>,
        status: &ExtensionStatus,
        kind: LocalExtensionKind,
    ) -> ExtensionCardActions {
        let is_dev = kind == LocalExtensionKind::Dev;
        let rebuild = is_dev.then(|| {
            Button::new(
                SharedString::from(format!("rebuild-{}", extension.id)),
                "Rebuild",
            )
            .color(Color::Accent)
            .disabled(Self::disables_actions(status))
            .on_click({
                let extension_id = extension.id.clone();
                move |_, _, cx| {
                    ExtensionStore::global(cx).update(cx, |store, cx| {
                        store.rebuild_dev_extension(extension_id.clone(), cx)
                    });
                }
            })
        });
        let uninstall = Self::uninstall_button(&extension.id, is_dev)
            .when_else(
                is_dev,
                |button| button.color(Color::Accent),
                |button| button.style(ButtonStyle::OutlinedGhost),
            )
            .disabled(Self::disables_actions(status));
        let configure = (!extension.context_servers.is_empty()).then(|| {
            Self::configure_button(&extension.id, Some(extension.clone()))
                .when_else(
                    is_dev,
                    |button| button.color(Color::Accent),
                    |button| button.style(ButtonStyle::OutlinedGhost),
                )
                .disabled(Self::disables_actions(status))
        });

        if is_dev {
            [rebuild, Some(uninstall), configure]
        } else {
            [None, configure, Some(uninstall)]
        }
    }

    fn install_button(extension_id: &Arc<str>) -> Button {
        Button::new(
            Self::button_id(extension_id, ExtensionOperation::Install),
            "Install",
        )
        .style(ButtonStyle::Tinted(ui::TintColor::Accent))
        .start_icon(
            Icon::new(IconName::Download)
                .size(IconSize::Small)
                .color(Color::Muted),
        )
        .on_click({
            let extension_id = extension_id.clone();
            move |_, _, cx| {
                telemetry::event!("Extension Installed");
                ExtensionStore::global(cx).update(cx, |store, cx| {
                    store.install_latest_extension(extension_id.clone(), cx)
                });
            }
        })
    }

    fn actions_for_remote_extension(
        extension: &ExtensionMetadata,
        state: &PublishedExtensionState,
        cx: &App,
    ) -> ExtensionCardActions {
        let is_configurable = extension
            .manifest
            .provides
            .contains(&ExtensionProvides::ContextServers);

        let status = match state {
            PublishedExtensionState::OverriddenByDevExtension => {
                return [
                    None,
                    None,
                    Some(Self::install_button(&extension.id).disabled(true)),
                ];
            }
            PublishedExtensionState::Store(status) => status,
        };

        match status {
            ExtensionStatus::NotInstalled | ExtensionStatus::Installing => [
                None,
                None,
                Some(Self::install_button(&extension.id).disabled(Self::disables_actions(status))),
            ],
            ExtensionStatus::Upgrading | ExtensionStatus::Removing => {
                let uninstall = Self::uninstall_button(&extension.id, false)
                    .style(ButtonStyle::OutlinedGhost)
                    .disabled(Self::disables_actions(status));
                let upgrade = matches!(status, ExtensionStatus::Upgrading).then(|| {
                    Button::new(
                        Self::button_id(&extension.id, ExtensionOperation::Upgrade),
                        "Upgrade",
                    )
                    .disabled(Self::disables_actions(status))
                });
                let configure = is_configurable.then(|| {
                    Self::configure_button(&extension.id, None)
                        .disabled(Self::disables_actions(status))
                });

                [upgrade, configure, Some(uninstall)]
            }
            ExtensionStatus::Installed(installed_version) => {
                let uninstall =
                    Self::uninstall_button(&extension.id, false).style(ButtonStyle::OutlinedGhost);
                let upgrade = (installed_version != &extension.manifest.version).then(|| {
                    let is_compatible = extension_host::is_version_compatible(
                        ReleaseChannel::global(cx),
                        extension,
                    );
                    Button::new(
                        Self::button_id(&extension.id, ExtensionOperation::Upgrade),
                        "Upgrade",
                    )
                    .style(ButtonStyle::Tinted(ui::TintColor::Accent))
                    .when(!is_compatible, |button| {
                        button.tooltip({
                            let version = extension.manifest.version.clone();
                            move |_, cx| {
                                Tooltip::simple(
                                    format!(
                                        "v{version} is not compatible with this version of Zed."
                                    ),
                                    cx,
                                )
                            }
                        })
                    })
                    .disabled(!is_compatible)
                    .on_click({
                        let extension_id = extension.id.clone();
                        let version = extension.manifest.version.clone();
                        move |_, _, cx| {
                            telemetry::event!("Extension Installed", extension_id, version);
                            ExtensionStore::global(cx).update(cx, |store, cx| {
                                store
                                    .upgrade_extension(extension_id.clone(), version.clone(), cx)
                                    .detach_and_log_err(cx)
                            });
                        }
                    })
                });
                let configure = is_configurable.then(|| {
                    Self::configure_button(&extension.id, None).style(ButtonStyle::OutlinedGhost)
                });

                [upgrade, configure, Some(uninstall)]
            }
        }
    }

    pub fn repository_icon(mut self, icon: IconName) -> Self {
        self.details.repository_icon = icon;
        self
    }

    pub fn context_menu(
        mut self,
        builder: impl Fn(Arc<str>, SharedString, &mut Window, &mut App) -> Option<Entity<ContextMenu>>
        + 'static,
    ) -> Self {
        self.context_menu = Some(Box::new(builder));
        self
    }
}

fn provided_feature_labels(
    provides: impl IntoIterator<Item = ExtensionProvides>,
) -> Vec<&'static str> {
    provides
        .into_iter()
        .filter(|provides| !provides.is_deprecated())
        .map(extension_provides_label)
        .collect()
}

pub(crate) fn extension_provides_label(provides: ExtensionProvides) -> &'static str {
    match provides {
        ExtensionProvides::Themes => "Themes",
        ExtensionProvides::IconThemes => "Icon Themes",
        ExtensionProvides::Languages => "Languages",
        ExtensionProvides::Grammars => "Grammars",
        ExtensionProvides::LanguageServers => "Language Servers",
        ExtensionProvides::ContextServers => "MCP Servers",
        ExtensionProvides::AgentServers => "Agent Servers",
        ExtensionProvides::SlashCommands => "Slash Commands",
        ExtensionProvides::IndexedDocsProviders => "Indexed Docs Providers",
        ExtensionProvides::Snippets => "Snippets",
        ExtensionProvides::DebugAdapters => "Debug Adapters",
    }
}

impl Component for ExtensionCard {
    fn scope() -> ComponentScope {
        ComponentScope::DataDisplay
    }

    fn description() -> &'static str {
        "A card that displays an extension's details, installation state, and available actions."
    }

    fn preview(_window: &mut Window, cx: &mut App) -> AnyElement {
        fn remote_extension(
            id: &'static str,
            name: &'static str,
            version: &'static str,
            description: &'static str,
            download_count: u64,
            provides: impl IntoIterator<Item = ExtensionProvides>,
        ) -> ExtensionMetadata {
            ExtensionMetadata {
                id: id.into(),
                manifest: ExtensionApiManifest {
                    name: name.to_owned(),
                    version: version.into(),
                    description: Some(description.to_owned()),
                    authors: vec!["Zed Industries".to_owned()],
                    repository: "https://github.com/zed-industries/zed".to_owned(),
                    schema_version: Some(1),
                    wasm_api_version: None,
                    provides: BTreeSet::from_iter(provides),
                },
                published_at: Default::default(),
                download_count,
            }
        }

        fn dev_extension() -> Arc<ExtensionManifest> {
            Arc::new(ExtensionManifest {
                // Fake ID which will never be accepted during publishing
                id: "zed-demo-theme".into(),
                name: "Local Theme".to_owned(),
                version: "0.1.0".into(),
                schema_version: SchemaVersion::ZERO,
                description: Some("A locally installed extension under development.".to_owned()),
                repository: Some("https://github.com/zed-industries/zed".to_owned()),
                authors: vec!["Extension Developer".to_owned()],
                lib: Default::default(),
                themes: Vec::new(),
                icon_themes: Vec::new(),
                languages: Vec::new(),
                grammars: Default::default(),
                language_servers: Default::default(),
                context_servers: Default::default(),
                slash_commands: Default::default(),
                snippets: None,
                capabilities: Vec::new(),
                debug_adapters: Default::default(),
                debug_locators: Default::default(),
                language_model_providers: Default::default(),
            })
        }

        let examples = vec![
            single_example(
                "Available to Install",
                ExtensionCard::remote(
                    &remote_extension(
                        "preview-toml",
                        "TOML",
                        "0.6.2",
                        "TOML language support.",
                        482_391,
                        [ExtensionProvides::Languages],
                    ),
                    PublishedExtensionState::Store(ExtensionStatus::NotInstalled),
                    cx,
                )
                .into_any_element(),
            ),
            single_example(
                "Installed",
                ExtensionCard::remote(
                    &remote_extension(
                        "preview-python",
                        "Python",
                        "0.5.1",
                        "Python language support powered by basedpyright.",
                        1_284_613,
                        [
                            ExtensionProvides::Languages,
                            ExtensionProvides::LanguageServers,
                            ExtensionProvides::ContextServers,
                        ],
                    ),
                    PublishedExtensionState::Store(ExtensionStatus::Installed("0.5.1".into())),
                    cx,
                )
                .into_any_element(),
            ),
            single_example(
                "Update Available",
                ExtensionCard::remote(
                    &remote_extension(
                        "preview-rust",
                        "Rust",
                        "0.4.0",
                        "Rust language support powered by rust-analyzer.",
                        2_947_028,
                        [
                            ExtensionProvides::Languages,
                            ExtensionProvides::LanguageServers,
                        ],
                    ),
                    PublishedExtensionState::Store(ExtensionStatus::Installed("0.3.1".into())),
                    cx,
                )
                .into_any_element(),
            ),
            single_example(
                "Development Extension",
                ExtensionCard::manifest(
                    dev_extension(),
                    ExtensionStatus::Installed("0.1.0".into()),
                    LocalExtensionKind::Dev,
                )
                .into_any_element(),
            ),
            single_example(
                "Overridden by Development Extension",
                ExtensionCard::remote(
                    &remote_extension(
                        "preview-overridden-theme",
                        "Local Theme",
                        "1.3.0",
                        "The published version of a locally developed extension.",
                        36_512,
                        [ExtensionProvides::Themes],
                    ),
                    PublishedExtensionState::OverriddenByDevExtension,
                    cx,
                )
                .into_any_element(),
            ),
        ];

        div()
            .w_128()
            .child(example_group(examples).vertical())
            .into_any_element()
    }
}

impl RenderOnce for ExtensionCard {
    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
        let Self {
            details,
            actions,
            context_menu,
        } = self;
        let ExtensionCardDetails {
            id,
            name,
            version,
            description,
            authors,
            repository_url,
            repository_icon,
            provided_features,
            source,
        } = details;
        let installed_version = source.installed_version(&version);
        let download_count = source.download_count();
        let is_dev = source.is_dev();
        let is_overridden = source.is_overridden();
        let repository_button_id = SharedString::from(format!("repository-{id}"));
        let context_menu_button_id = SharedString::from(format!("more-{id}"));
        let context_menu_extension_id = id;
        let context_menu_authors = authors.clone();

        div().w_full().child(
            v_flex()
                .mt_4()
                .w_full()
                .h(rems_from_px(110_f32))
                .p_3()
                .gap_2()
                .bg(cx.theme().colors().elevated_surface_background.opacity(0.5))
                .border_1()
                .border_color(cx.theme().colors().border_variant)
                .rounded_md()
                .child(
                    h_flex()
                        .gap_2()
                        .justify_between()
                        .child(
                            h_flex()
                                .flex_shrink_1()
                                .min_w_0()
                                .overflow_hidden()
                                .whitespace_nowrap()
                                .gap_2()
                                .child(Headline::new(name).size(HeadlineSize::Small))
                                .child(
                                    Headline::new(if is_dev {
                                        format!("v{version} (dev)")
                                    } else {
                                        format!("v{version}")
                                    })
                                    .size(HeadlineSize::XSmall)
                                    .color(Color::Muted),
                                )
                                .children(installed_version.map(|installed_version| {
                                    Headline::new(format!("(v{installed_version} installed)"))
                                        .size(HeadlineSize::XSmall)
                                }))
                                .when(!provided_features.is_empty(), |parent| {
                                    parent.child(
                                        h_flex()
                                            .gap_1()
                                            .children(provided_features.into_iter().map(Chip::new)),
                                    )
                                }),
                        )
                        .child(
                            h_flex()
                                .flex_shrink_0()
                                .gap_1()
                                .children(actions.into_iter().flatten()),
                        ),
                )
                .child(
                    h_flex()
                        .gap_2()
                        .justify_between()
                        .children(description.map(|description| {
                            Label::new(description)
                                .size(LabelSize::Small)
                                .color(Color::Default)
                                .truncate()
                        }))
                        .children(download_count.map(|download_count| {
                            Label::new(format!(
                                "Downloads: {}",
                                format_number_with_commas(u128::from(download_count))
                            ))
                            .size(LabelSize::Small)
                        })),
                )
                .child(
                    h_flex()
                        .min_w_0()
                        .w_full()
                        .justify_between()
                        .child(
                            h_flex()
                                .min_w_0()
                                .gap_1()
                                .child(
                                    Icon::new(IconName::Person)
                                        .size(IconSize::XSmall)
                                        .color(Color::Muted),
                                )
                                .child(
                                    Label::new(authors)
                                        .size(LabelSize::Small)
                                        .color(Color::Muted)
                                        .truncate(),
                                ),
                        )
                        .child(
                            h_flex()
                                .gap_1()
                                .flex_shrink_0()
                                .when_some(repository_url, |this, repository_url| {
                                    let repository_url_for_tooltip = repository_url.clone();
                                    this.child(
                                        IconButton::new(repository_button_id, repository_icon)
                                            .icon_size(IconSize::Small)
                                            .tooltip(move |_, cx| {
                                                Tooltip::with_meta(
                                                    "Visit Extension Repository",
                                                    None,
                                                    repository_url_for_tooltip.clone(),
                                                    cx,
                                                )
                                            })
                                            .on_click(move |_, _, cx| {
                                                cx.open_url(&repository_url);
                                            }),
                                    )
                                })
                                .when_some(context_menu, |this, context_menu| {
                                    this.child(
                                        PopoverMenu::new(context_menu_button_id.clone())
                                            .trigger(
                                                IconButton::new(
                                                    context_menu_button_id,
                                                    IconName::Ellipsis,
                                                )
                                                .icon_size(IconSize::Small),
                                            )
                                            .anchor(Anchor::TopRight)
                                            .offset(Point {
                                                x: px(0.0),
                                                y: px(2.0),
                                            })
                                            .menu(move |window, cx| {
                                                context_menu(
                                                    context_menu_extension_id.clone(),
                                                    context_menu_authors.clone(),
                                                    window,
                                                    cx,
                                                )
                                            }),
                                    )
                                }),
                        ),
                )
                .when(is_overridden, |card| {
                    card.child(
                        h_flex()
                            .absolute()
                            .top_0()
                            .left_0()
                            .block_mouse_except_scroll()
                            .cursor_default()
                            .size_full()
                            .justify_center()
                            .bg(cx.theme().colors().elevated_surface_background.alpha(0.8))
                            .child(Label::new("Overridden by dev extension.")),
                    )
                }),
        )
    }
}