1use anyhow::{anyhow, Context, Result};
  2use collections::{BTreeMap, HashMap};
  3use fs::Fs;
  4use language::LanguageServerName;
  5use semantic_version::SemanticVersion;
  6use serde::{Deserialize, Serialize};
  7use std::{
  8    ffi::OsStr,
  9    fmt,
 10    path::{Path, PathBuf},
 11    sync::Arc,
 12};
 13
 14/// This is the old version of the extension manifest, from when it was `extension.json`.
 15#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
 16pub struct OldExtensionManifest {
 17    pub name: String,
 18    pub version: Arc<str>,
 19
 20    #[serde(default)]
 21    pub description: Option<String>,
 22    #[serde(default)]
 23    pub repository: Option<String>,
 24    #[serde(default)]
 25    pub authors: Vec<String>,
 26
 27    #[serde(default)]
 28    pub themes: BTreeMap<Arc<str>, PathBuf>,
 29    #[serde(default)]
 30    pub languages: BTreeMap<Arc<str>, PathBuf>,
 31    #[serde(default)]
 32    pub grammars: BTreeMap<Arc<str>, PathBuf>,
 33}
 34
 35/// The schema version of the [`ExtensionManifest`].
 36#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
 37pub struct SchemaVersion(pub i32);
 38
 39impl fmt::Display for SchemaVersion {
 40    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 41        write!(f, "{}", self.0)
 42    }
 43}
 44
 45impl SchemaVersion {
 46    pub const ZERO: Self = Self(0);
 47
 48    pub fn is_v0(&self) -> bool {
 49        self == &Self::ZERO
 50    }
 51}
 52
 53#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
 54pub struct ExtensionManifest {
 55    pub id: Arc<str>,
 56    pub name: String,
 57    pub version: Arc<str>,
 58    pub schema_version: SchemaVersion,
 59
 60    #[serde(default)]
 61    pub description: Option<String>,
 62    #[serde(default)]
 63    pub repository: Option<String>,
 64    #[serde(default)]
 65    pub authors: Vec<String>,
 66    #[serde(default)]
 67    pub lib: LibManifestEntry,
 68
 69    #[serde(default)]
 70    pub themes: Vec<PathBuf>,
 71    #[serde(default)]
 72    pub languages: Vec<PathBuf>,
 73    #[serde(default)]
 74    pub grammars: BTreeMap<Arc<str>, GrammarManifestEntry>,
 75    #[serde(default)]
 76    pub language_servers: BTreeMap<LanguageServerName, LanguageServerManifestEntry>,
 77}
 78
 79#[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
 80pub struct LibManifestEntry {
 81    pub kind: Option<ExtensionLibraryKind>,
 82    pub version: Option<SemanticVersion>,
 83}
 84
 85#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
 86pub enum ExtensionLibraryKind {
 87    Rust,
 88}
 89
 90#[derive(Clone, Default, PartialEq, Eq, Debug, Deserialize, Serialize)]
 91pub struct GrammarManifestEntry {
 92    pub repository: String,
 93    #[serde(alias = "commit")]
 94    pub rev: String,
 95    #[serde(default)]
 96    pub path: Option<String>,
 97}
 98
 99#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
100pub struct LanguageServerManifestEntry {
101    pub language: Arc<str>,
102    #[serde(default)]
103    pub language_ids: HashMap<String, String>,
104}
105
106impl ExtensionManifest {
107    pub async fn load(fs: Arc<dyn Fs>, extension_dir: &Path) -> Result<Self> {
108        let extension_name = extension_dir
109            .file_name()
110            .and_then(OsStr::to_str)
111            .ok_or_else(|| anyhow!("invalid extension name"))?;
112
113        let mut extension_manifest_path = extension_dir.join("extension.json");
114        if fs.is_file(&extension_manifest_path).await {
115            let manifest_content = fs
116                .load(&extension_manifest_path)
117                .await
118                .with_context(|| format!("failed to load {extension_name} extension.json"))?;
119            let manifest_json = serde_json::from_str::<OldExtensionManifest>(&manifest_content)
120                .with_context(|| {
121                    format!("invalid extension.json for extension {extension_name}")
122                })?;
123
124            Ok(manifest_from_old_manifest(manifest_json, extension_name))
125        } else {
126            extension_manifest_path.set_extension("toml");
127            let manifest_content = fs
128                .load(&extension_manifest_path)
129                .await
130                .with_context(|| format!("failed to load {extension_name} extension.toml"))?;
131            toml::from_str(&manifest_content)
132                .with_context(|| format!("invalid extension.json for extension {extension_name}"))
133        }
134    }
135}
136
137fn manifest_from_old_manifest(
138    manifest_json: OldExtensionManifest,
139    extension_id: &str,
140) -> ExtensionManifest {
141    ExtensionManifest {
142        id: extension_id.into(),
143        name: manifest_json.name,
144        version: manifest_json.version,
145        description: manifest_json.description,
146        repository: manifest_json.repository,
147        authors: manifest_json.authors,
148        schema_version: SchemaVersion::ZERO,
149        lib: Default::default(),
150        themes: {
151            let mut themes = manifest_json.themes.into_values().collect::<Vec<_>>();
152            themes.sort();
153            themes.dedup();
154            themes
155        },
156        languages: {
157            let mut languages = manifest_json.languages.into_values().collect::<Vec<_>>();
158            languages.sort();
159            languages.dedup();
160            languages
161        },
162        grammars: manifest_json
163            .grammars
164            .into_keys()
165            .map(|grammar_name| (grammar_name, Default::default()))
166            .collect(),
167        language_servers: Default::default(),
168    }
169}