From 6bbb79a9f55beba80c3e6e776411cf3f3fc63a54 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 2 Nov 2023 21:21:41 +0200 Subject: [PATCH] Rework prettier installation and start --- crates/prettier/src/prettier.rs | 134 +------ crates/project/src/project.rs | 622 ++++++++++++++++++-------------- crates/project/src/search.rs | 3 +- 3 files changed, 366 insertions(+), 393 deletions(-) diff --git a/crates/prettier/src/prettier.rs b/crates/prettier/src/prettier.rs index 58de2fc913..3e846db66e 100644 --- a/crates/prettier/src/prettier.rs +++ b/crates/prettier/src/prettier.rs @@ -1,4 +1,3 @@ -use std::collections::VecDeque; use std::path::{Path, PathBuf}; use std::sync::Arc; @@ -20,7 +19,6 @@ pub enum Prettier { } pub struct RealPrettier { - worktree_id: Option, default: bool, prettier_dir: PathBuf, server: Arc, @@ -28,17 +26,10 @@ pub struct RealPrettier { #[cfg(any(test, feature = "test-support"))] pub struct TestPrettier { - worktree_id: Option, prettier_dir: PathBuf, default: bool, } -#[derive(Debug)] -pub struct LocateStart { - pub worktree_root_path: Arc, - pub starting_path: Arc, -} - pub const PRETTIER_SERVER_FILE: &str = "prettier_server.js"; pub const PRETTIER_SERVER_JS: &str = include_str!("./prettier_server.js"); const PRETTIER_PACKAGE_NAME: &str = "prettier"; @@ -130,75 +121,21 @@ impl Prettier { } } - pub async fn locate( - starting_path: Option, - fs: Arc, - ) -> anyhow::Result { - let paths_to_check = match starting_path.as_ref() { - Some(starting_path) => { - let worktree_root = starting_path - .worktree_root_path - .components() - .into_iter() - .take_while(|path_component| !is_node_modules(path_component)) - .collect::(); - if worktree_root != starting_path.worktree_root_path.as_ref() { - vec![worktree_root] - } else { - if starting_path.starting_path.as_ref() == Path::new("") { - worktree_root - .parent() - .map(|path| vec![path.to_path_buf()]) - .unwrap_or_default() - } else { - let file_to_format = starting_path.starting_path.as_ref(); - let mut paths_to_check = VecDeque::new(); - let mut current_path = worktree_root; - for path_component in file_to_format.components().into_iter() { - let new_path = current_path.join(path_component); - let old_path = std::mem::replace(&mut current_path, new_path); - paths_to_check.push_front(old_path); - if is_node_modules(&path_component) { - break; - } - } - Vec::from(paths_to_check) - } - } - } - None => Vec::new(), - }; - - match find_closest_prettier_dir(fs.as_ref(), paths_to_check) - .await - .with_context(|| format!("finding prettier starting with {starting_path:?}"))? - { - Some(prettier_dir) => Ok(prettier_dir), - None => Ok(DEFAULT_PRETTIER_DIR.to_path_buf()), - } - } - #[cfg(any(test, feature = "test-support"))] pub async fn start( - worktree_id: Option, _: LanguageServerId, prettier_dir: PathBuf, _: Arc, _: AsyncAppContext, ) -> anyhow::Result { - Ok( - #[cfg(any(test, feature = "test-support"))] - Self::Test(TestPrettier { - worktree_id, - default: prettier_dir == DEFAULT_PRETTIER_DIR.as_path(), - prettier_dir, - }), - ) + Ok(Self::Test(TestPrettier { + default: prettier_dir == DEFAULT_PRETTIER_DIR.as_path(), + prettier_dir, + })) } #[cfg(not(any(test, feature = "test-support")))] pub async fn start( - worktree_id: Option, server_id: LanguageServerId, prettier_dir: PathBuf, node: Arc, @@ -206,7 +143,7 @@ impl Prettier { ) -> anyhow::Result { use lsp::LanguageServerBinary; - let backgroud = cx.background(); + let background = cx.background(); anyhow::ensure!( prettier_dir.is_dir(), "Prettier dir {prettier_dir:?} is not a directory" @@ -217,7 +154,7 @@ impl Prettier { "no prettier server package found at {prettier_server:?}" ); - let node_path = backgroud + let node_path = background .spawn(async move { node.binary_path().await }) .await?; let server = LanguageServer::new( @@ -232,12 +169,11 @@ impl Prettier { cx, ) .context("prettier server creation")?; - let server = backgroud + let server = background .spawn(server.initialize(None)) .await .context("prettier server initialization")?; Ok(Self::Real(RealPrettier { - worktree_id, server, default: prettier_dir == DEFAULT_PRETTIER_DIR.as_path(), prettier_dir, @@ -403,14 +339,6 @@ impl Prettier { Self::Test(test_prettier) => &test_prettier.prettier_dir, } } - - pub fn worktree_id(&self) -> Option { - match self { - Self::Real(local) => local.worktree_id, - #[cfg(any(test, feature = "test-support"))] - Self::Test(test_prettier) => test_prettier.worktree_id, - } - } } async fn has_prettier_in_node_modules(fs: &dyn Fs, path: &Path) -> anyhow::Result { @@ -466,54 +394,6 @@ fn has_prettier_in_package_json( false } -async fn find_closest_prettier_dir( - fs: &dyn Fs, - paths_to_check: Vec, -) -> anyhow::Result> { - for path in paths_to_check { - let possible_package_json = path.join("package.json"); - if let Some(package_json_metadata) = fs - .metadata(&possible_package_json) - .await - .with_context(|| format!("Fetching metadata for {possible_package_json:?}"))? - { - if !package_json_metadata.is_dir && !package_json_metadata.is_symlink { - let package_json_contents = fs - .load(&possible_package_json) - .await - .with_context(|| format!("reading {possible_package_json:?} file contents"))?; - if let Ok(json_contents) = serde_json::from_str::>( - &package_json_contents, - ) { - if let Some(serde_json::Value::Object(o)) = json_contents.get("dependencies") { - if o.contains_key(PRETTIER_PACKAGE_NAME) { - return Ok(Some(path)); - } - } - if let Some(serde_json::Value::Object(o)) = json_contents.get("devDependencies") - { - if o.contains_key(PRETTIER_PACKAGE_NAME) { - return Ok(Some(path)); - } - } - } - } - } - - let possible_node_modules_location = path.join("node_modules").join(PRETTIER_PACKAGE_NAME); - if let Some(node_modules_location_metadata) = fs - .metadata(&possible_node_modules_location) - .await - .with_context(|| format!("fetching metadata for {possible_node_modules_location:?}"))? - { - if node_modules_location_metadata.is_dir { - return Ok(Some(path)); - } - } - } - Ok(None) -} - enum Format {} #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs index b38bcd1db2..a5c26bbb41 100644 --- a/crates/project/src/project.rs +++ b/crates/project/src/project.rs @@ -54,7 +54,7 @@ use lsp_command::*; use node_runtime::NodeRuntime; use parking_lot::Mutex; use postage::watch; -use prettier::{LocateStart, Prettier}; +use prettier::Prettier; use project_settings::{LspSettings, ProjectSettings}; use rand::prelude::*; use search::SearchQuery; @@ -82,8 +82,11 @@ use std::{ use terminals::Terminals; use text::Anchor; use util::{ - debug_panic, defer, http::HttpClient, merge_json_value_into, - paths::LOCAL_SETTINGS_RELATIVE_PATH, post_inc, ResultExt, TryFutureExt as _, + debug_panic, defer, + http::HttpClient, + merge_json_value_into, + paths::{DEFAULT_PRETTIER_DIR, LOCAL_SETTINGS_RELATIVE_PATH}, + post_inc, ResultExt, TryFutureExt as _, }; pub use fs::*; @@ -162,17 +165,14 @@ pub struct Project { copilot_log_subscription: Option, current_lsp_settings: HashMap, LspSettings>, node: Option>, - #[cfg(not(any(test, feature = "test-support")))] default_prettier: Option, - prettier_instances: HashMap< - (Option, PathBuf), - Shared, Arc>>>, - >, + prettiers_per_worktree: HashMap>>, + prettier_instances: HashMap, Arc>>>>, } -#[cfg(not(any(test, feature = "test-support")))] struct DefaultPrettier { - installation_process: Option>>, + instance: Option, Arc>>>>, + #[cfg(not(any(test, feature = "test-support")))] installed_plugins: HashSet<&'static str>, } @@ -685,8 +685,8 @@ impl Project { copilot_log_subscription: None, current_lsp_settings: settings::get::(cx).lsp.clone(), node: Some(node), - #[cfg(not(any(test, feature = "test-support")))] default_prettier: None, + prettiers_per_worktree: HashMap::default(), prettier_instances: HashMap::default(), } }) @@ -786,8 +786,8 @@ impl Project { copilot_log_subscription: None, current_lsp_settings: settings::get::(cx).lsp.clone(), node: None, - #[cfg(not(any(test, feature = "test-support")))] default_prettier: None, + prettiers_per_worktree: HashMap::default(), prettier_instances: HashMap::default(), }; for worktree in worktrees { @@ -2681,20 +2681,8 @@ impl Project { let buffer_file = File::from_dyn(buffer_file.as_ref()); let worktree = buffer_file.as_ref().map(|f| f.worktree_id(cx)); - let task_buffer = buffer.clone(); - let prettier_installation_task = - self.install_default_formatters(worktree, &new_language, &settings, cx); - cx.spawn(|project, mut cx| async move { - prettier_installation_task.await?; - let _ = project - .update(&mut cx, |project, cx| { - project.prettier_instance_for_buffer(&task_buffer, cx) - }) - .await; - anyhow::Ok(()) - }) - .detach_and_log_err(cx); - + self.install_default_formatters(worktree, &new_language, &settings, cx) + .detach_and_log_err(cx); if let Some(file) = buffer_file { let worktree = file.worktree.clone(); if let Some(tree) = worktree.read(cx).as_local() { @@ -4029,7 +4017,7 @@ impl Project { } pub fn format( - &self, + &mut self, buffers: HashSet>, push_to_history: bool, trigger: FormatTrigger, @@ -4049,10 +4037,10 @@ impl Project { }) .collect::>(); - cx.spawn(|this, mut cx| async move { + cx.spawn(|project, mut cx| async move { // Do not allow multiple concurrent formatting requests for the // same buffer. - this.update(&mut cx, |this, cx| { + project.update(&mut cx, |this, cx| { buffers_with_paths_and_servers.retain(|(buffer, _, _)| { this.buffers_being_formatted .insert(buffer.read(cx).remote_id()) @@ -4060,7 +4048,7 @@ impl Project { }); let _cleanup = defer({ - let this = this.clone(); + let this = project.clone(); let mut cx = cx.clone(); let buffers = &buffers_with_paths_and_servers; move || { @@ -4128,7 +4116,7 @@ impl Project { { format_operation = Some(FormatOperation::Lsp( Self::format_via_lsp( - &this, + &project, &buffer, buffer_abs_path, &language_server, @@ -4163,16 +4151,24 @@ impl Project { } } (Formatter::Auto, FormatOnSave::On | FormatOnSave::Off) => { - if let Some(prettier_task) = this + if let Some((prettier_path, prettier_task)) = project .update(&mut cx, |project, cx| { project.prettier_instance_for_buffer(buffer, cx) }).await { match prettier_task.await { Ok(prettier) => { - let buffer_path = buffer.read_with(&cx, |buffer, cx| { - File::from_dyn(buffer.file()).map(|file| file.abs_path(cx)) - }); + let buffer_file = buffer.update(&mut cx, |buffer, _| buffer.file().cloned()); + let buffer_path= { + File::from_dyn(buffer_file.as_ref()).map(|file| { + cx.update(|cx| { + let worktree_id = file.worktree_id(cx); + let file_abs_path = file.abs_path(cx); + project.update(cx, |project, _| project.prettiers_per_worktree.entry(worktree_id).or_default().insert(prettier_path)); + file_abs_path + }) + }) + }; format_operation = Some(FormatOperation::Prettier( prettier .format(buffer, buffer_path, &cx) @@ -4180,16 +4176,29 @@ impl Project { .context("formatting via prettier")?, )); } - Err(e) => anyhow::bail!( - "Failed to create prettier instance for buffer during autoformatting: {e:#}" - ), + Err(e) => { + project.update(&mut cx, |project, _| { + match &prettier_path { + Some(prettier_path) => { + project.prettier_instances.remove(prettier_path); + }, + None => { + if let Some(default_prettier) = project.default_prettier.as_mut() { + default_prettier.instance = None; + } + }, + } + }); + anyhow::bail!( + "Failed to create prettier instance from {prettier_path:?} for buffer during autoformatting: {e:#}" + )}, } } else if let Some((language_server, buffer_abs_path)) = language_server.as_ref().zip(buffer_abs_path.as_ref()) { format_operation = Some(FormatOperation::Lsp( Self::format_via_lsp( - &this, + &project, &buffer, buffer_abs_path, &language_server, @@ -4202,16 +4211,24 @@ impl Project { } } (Formatter::Prettier { .. }, FormatOnSave::On | FormatOnSave::Off) => { - if let Some(prettier_task) = this + if let Some((prettier_path, prettier_task)) = project .update(&mut cx, |project, cx| { project.prettier_instance_for_buffer(buffer, cx) }).await { match prettier_task.await { Ok(prettier) => { - let buffer_path = buffer.read_with(&cx, |buffer, cx| { - File::from_dyn(buffer.file()).map(|file| file.abs_path(cx)) - }); + let buffer_file = buffer.update(&mut cx, |buffer, _| buffer.file().cloned()); + let buffer_path= { + File::from_dyn(buffer_file.as_ref()).map(|file| { + cx.update(|cx| { + let worktree_id = file.worktree_id(cx); + let file_abs_path = file.abs_path(cx); + project.update(cx, |project, _| project.prettiers_per_worktree.entry(worktree_id).or_default().insert(prettier_path)); + file_abs_path + }) + }) + }; format_operation = Some(FormatOperation::Prettier( prettier .format(buffer, buffer_path, &cx) @@ -4219,9 +4236,22 @@ impl Project { .context("formatting via prettier")?, )); } - Err(e) => anyhow::bail!( - "Failed to create prettier instance for buffer during formatting: {e:#}" - ), + Err(e) => { + project.update(&mut cx, |project, _| { + match &prettier_path { + Some(prettier_path) => { + project.prettier_instances.remove(prettier_path); + }, + None => { + if let Some(default_prettier) = project.default_prettier.as_mut() { + default_prettier.instance = None; + } + }, + } + }); + anyhow::bail!( + "Failed to create prettier instance from {prettier_path:?} for buffer during formatting: {e:#}" + )}, } } } @@ -6431,15 +6461,25 @@ impl Project { "Prettier config file {config_path:?} changed, reloading prettier instances for worktree {current_worktree_id}" ); let prettiers_to_reload = self - .prettier_instances + .prettiers_per_worktree + .get(¤t_worktree_id) .iter() - .filter_map(|((worktree_id, prettier_path), prettier_task)| { - if worktree_id.is_none() || worktree_id == &Some(current_worktree_id) { - Some((*worktree_id, prettier_path.clone(), prettier_task.clone())) - } else { - None - } + .flat_map(|prettier_paths| prettier_paths.iter()) + .flatten() + .filter_map(|prettier_path| { + Some(( + current_worktree_id, + Some(prettier_path.clone()), + self.prettier_instances.get(prettier_path)?.clone(), + )) }) + .chain(self.default_prettier.iter().filter_map(|default_prettier| { + Some(( + current_worktree_id, + None, + default_prettier.instance.clone()?, + )) + })) .collect::>(); cx.background() @@ -6450,9 +6490,15 @@ impl Project { .clear_cache() .await .with_context(|| { - format!( - "clearing prettier {prettier_path:?} cache for worktree {worktree_id:?} on prettier settings update" - ) + match prettier_path { + Some(prettier_path) => format!( + "clearing prettier {prettier_path:?} cache for worktree {worktree_id:?} on prettier settings update" + ), + None => format!( + "clearing default prettier cache for worktree {worktree_id:?} on prettier settings update" + ), + } + }) .map_err(Arc::new) } @@ -8364,7 +8410,12 @@ impl Project { &mut self, buffer: &ModelHandle, cx: &mut ModelContext, - ) -> Task, Arc>>>>> { + ) -> Task< + Option<( + Option, + Shared, Arc>>>, + )>, + > { let buffer = buffer.read(cx); let buffer_file = buffer.file(); let Some(buffer_language) = buffer.language() else { @@ -8374,136 +8425,136 @@ impl Project { return Task::ready(None); } - let buffer_file = File::from_dyn(buffer_file); - let buffer_path = buffer_file.map(|file| Arc::clone(file.path())); - let worktree_path = buffer_file - .as_ref() - .and_then(|file| Some(file.worktree.read(cx).abs_path())); - let worktree_id = buffer_file.map(|file| file.worktree_id(cx)); - if self.is_local() || worktree_id.is_none() || worktree_path.is_none() { + if self.is_local() { let Some(node) = self.node.as_ref().map(Arc::clone) else { return Task::ready(None); }; - cx.spawn(|this, mut cx| async move { - let fs = this.update(&mut cx, |project, _| Arc::clone(&project.fs)); - let prettier_dir = match cx - .background() - .spawn(Prettier::locate( - worktree_path.zip(buffer_path).map( - |(worktree_root_path, starting_path)| LocateStart { - worktree_root_path, - starting_path, - }, - ), - fs, - )) - .await - { - Ok(path) => path, - Err(e) => { - return Some( - Task::ready(Err(Arc::new(e.context( - "determining prettier path for worktree {worktree_path:?}", - )))) - .shared(), - ); - } - }; - - if let Some(existing_prettier) = this.update(&mut cx, |project, _| { - project - .prettier_instances - .get(&(worktree_id, prettier_dir.clone())) - .cloned() - }) { - return Some(existing_prettier); - } - - log::info!("Found prettier in {prettier_dir:?}, starting."); - let task_prettier_dir = prettier_dir.clone(); - let weak_project = this.downgrade(); - let new_server_id = - this.update(&mut cx, |this, _| this.languages.next_language_server_id()); - let new_prettier_task = cx - .spawn(|mut cx| async move { - let prettier = Prettier::start( - worktree_id.map(|id| id.to_usize()), - new_server_id, - task_prettier_dir, - node, - cx.clone(), - ) - .await - .context("prettier start") - .map_err(Arc::new)?; - log::info!("Started prettier in {:?}", prettier.prettier_dir()); - - if let Some((project, prettier_server)) = - weak_project.upgrade(&mut cx).zip(prettier.server()) + match File::from_dyn(buffer_file).map(|file| file.abs_path(cx)) { + Some(buffer_path) => { + let fs = Arc::clone(&self.fs); + let installed_prettiers = self.prettier_instances.keys().cloned().collect(); + return cx.spawn(|project, mut cx| async move { + match cx + .background() + .spawn(async move { + Prettier::locate_prettier_installation( + fs.as_ref(), + &installed_prettiers, + &buffer_path, + ) + .await + }) + .await { - project.update(&mut cx, |project, cx| { - let name = if prettier.is_default() { - LanguageServerName(Arc::from("prettier (default)")) - } else { - let prettier_dir = prettier.prettier_dir(); - let worktree_path = prettier - .worktree_id() - .map(WorktreeId::from_usize) - .and_then(|id| project.worktree_for_id(id, cx)) - .map(|worktree| worktree.read(cx).abs_path()); - match worktree_path { - Some(worktree_path) => { - if worktree_path.as_ref() == prettier_dir { - LanguageServerName(Arc::from(format!( - "prettier ({})", - prettier_dir - .file_name() - .and_then(|name| name.to_str()) - .unwrap_or_default() - ))) - } else { - let dir_to_display = match prettier_dir - .strip_prefix(&worktree_path) - .ok() - { - Some(relative_path) => relative_path, - None => prettier_dir, - }; - LanguageServerName(Arc::from(format!( - "prettier ({})", - dir_to_display.display(), - ))) - } - } - None => LanguageServerName(Arc::from(format!( - "prettier ({})", - prettier_dir.display(), - ))), - } - }; + Ok(None) => { + let new_task = project.update(&mut cx, |project, cx| { + let new_task = spawn_default_prettier(node, cx); + project + .default_prettier + .get_or_insert_with(|| DefaultPrettier { + instance: None, + #[cfg(not(any(test, feature = "test-support")))] + installed_plugins: HashSet::default(), + }) + .instance = Some(new_task.clone()); + new_task + }); + return Some((None, new_task)); + } + Err(e) => { + return Some(( + None, + Task::ready(Err(Arc::new(e.context( + "determining prettier path for worktree {worktree_path:?}", + )))) + .shared(), + )); + } + Ok(Some(prettier_dir)) => { + if let Some(existing_prettier) = + project.update(&mut cx, |project, _| { + project.prettier_instances.get(&prettier_dir).cloned() + }) + { + return Some((Some(prettier_dir), existing_prettier)); + } - project - .supplementary_language_servers - .insert(new_server_id, (name, Arc::clone(prettier_server))); - cx.emit(Event::LanguageServerAdded(new_server_id)); - }); + log::info!("Found prettier in {prettier_dir:?}, starting."); + let task_prettier_dir = prettier_dir.clone(); + let weak_project = project.downgrade(); + let new_server_id = project.update(&mut cx, |this, _| { + this.languages.next_language_server_id() + }); + let new_prettier_task = cx + .spawn(|mut cx| async move { + let prettier = Prettier::start( + new_server_id, + task_prettier_dir, + node, + cx.clone(), + ) + .await + .context("prettier start") + .map_err(Arc::new)?; + log::info!( + "Started prettier in {:?}", + prettier.prettier_dir() + ); + + if let Some((project, prettier_server)) = + weak_project.upgrade(&mut cx).zip(prettier.server()) + { + project.update(&mut cx, |project, cx| { + let name = if prettier.is_default() { + LanguageServerName(Arc::from( + "prettier (default)", + )) + } else { + LanguageServerName(Arc::from(format!( + "prettier ({})", + prettier.prettier_dir().display(), + ))) + }; + + project.supplementary_language_servers.insert( + new_server_id, + (name, Arc::clone(prettier_server)), + ); + cx.emit(Event::LanguageServerAdded(new_server_id)); + }); + } + Ok(Arc::new(prettier)).map_err(Arc::new) + }) + .shared(); + project.update(&mut cx, |project, _| { + project + .prettier_instances + .insert(prettier_dir.clone(), new_prettier_task.clone()); + }); + Some((Some(prettier_dir), new_prettier_task)) + } } - Ok(Arc::new(prettier)).map_err(Arc::new) - }) - .shared(); - this.update(&mut cx, |project, _| { - project - .prettier_instances - .insert((worktree_id, prettier_dir), new_prettier_task.clone()); - }); - Some(new_prettier_task) - }) + }); + } + None => { + let new_task = spawn_default_prettier(node, cx); + self.default_prettier + .get_or_insert_with(|| DefaultPrettier { + instance: None, + #[cfg(not(any(test, feature = "test-support")))] + installed_plugins: HashSet::default(), + }) + .instance = Some(new_task.clone()); + return Task::ready(Some((None, new_task))); + } + } } else if self.remote_id().is_some() { return Task::ready(None); } else { - Task::ready(Some( + Task::ready(Some(( + None, Task::ready(Err(Arc::new(anyhow!("project does not have a remote id")))).shared(), - )) + ))) } } @@ -8537,7 +8588,7 @@ impl Project { let mut prettier_plugins = None; if new_language.prettier_parser_name().is_some() { prettier_plugins - .get_or_insert_with(|| HashSet::default()) + .get_or_insert_with(|| HashSet::<&'static str>::default()) .extend( new_language .lsp_adapters() @@ -8549,27 +8600,25 @@ impl Project { return Task::ready(Ok(())); }; + let fs = Arc::clone(&self.fs); + let locate_prettier_installation = match worktree.and_then(|worktree_id| { + self.worktree_for_id(worktree_id, cx) + .map(|worktree| worktree.read(cx).abs_path()) + }) { + Some(locate_from) => { + let installed_prettiers = self.prettier_instances.keys().cloned().collect(); + cx.background().spawn(async move { + Prettier::locate_prettier_installation( + fs.as_ref(), + &installed_prettiers, + locate_from.as_ref(), + ) + .await + }) + } + None => Task::ready(Ok(None)), + }; let mut plugins_to_install = prettier_plugins; - let (mut install_success_tx, mut install_success_rx) = - futures::channel::mpsc::channel::>(1); - let new_installation_process = cx - .spawn(|this, mut cx| async move { - if let Some(installed_plugins) = install_success_rx.next().await { - this.update(&mut cx, |this, _| { - let default_prettier = - this.default_prettier - .get_or_insert_with(|| DefaultPrettier { - installation_process: None, - installed_plugins: HashSet::default(), - }); - if !installed_plugins.is_empty() { - log::info!("Installed new prettier plugins: {installed_plugins:?}"); - default_prettier.installed_plugins.extend(installed_plugins); - } - }) - } - }) - .shared(); let previous_installation_process = if let Some(default_prettier) = &mut self.default_prettier { plugins_to_install @@ -8577,83 +8626,128 @@ impl Project { if plugins_to_install.is_empty() { return Task::ready(Ok(())); } - std::mem::replace( - &mut default_prettier.installation_process, - Some(new_installation_process.clone()), - ) + default_prettier.instance.clone() } else { None }; - - let default_prettier_dir = util::paths::DEFAULT_PRETTIER_DIR.as_path(); - let already_running_prettier = self - .prettier_instances - .get(&(worktree, default_prettier_dir.to_path_buf())) - .cloned(); let fs = Arc::clone(&self.fs); cx.spawn(|this, mut cx| async move { - if let Some(previous_installation_process) = previous_installation_process { - previous_installation_process.await; - } - let mut everything_was_installed = false; - this.update(&mut cx, |this, _| { - match &mut this.default_prettier { - Some(default_prettier) => { - plugins_to_install - .retain(|plugin| !default_prettier.installed_plugins.contains(plugin)); - everything_was_installed = plugins_to_install.is_empty(); - }, - None => this.default_prettier = Some(DefaultPrettier { installation_process: Some(new_installation_process), installed_plugins: HashSet::default() }), - } - }); - if everything_was_installed { - return Ok(()); - } - - cx.background() - .spawn(async move { - let prettier_wrapper_path = default_prettier_dir.join(prettier::PRETTIER_SERVER_FILE); - // method creates parent directory if it doesn't exist - fs.save(&prettier_wrapper_path, &text::Rope::from(prettier::PRETTIER_SERVER_JS), text::LineEnding::Unix).await - .with_context(|| format!("writing {} file at {prettier_wrapper_path:?}", prettier::PRETTIER_SERVER_FILE))?; - - let packages_to_versions = future::try_join_all( - plugins_to_install - .iter() - .chain(Some(&"prettier")) - .map(|package_name| async { - let returned_package_name = package_name.to_string(); - let latest_version = node.npm_package_latest_version(package_name) - .await - .with_context(|| { - format!("fetching latest npm version for package {returned_package_name}") - })?; - anyhow::Ok((returned_package_name, latest_version)) - }), - ) - .await - .context("fetching latest npm versions")?; - - log::info!("Fetching default prettier and plugins: {packages_to_versions:?}"); - let borrowed_packages = packages_to_versions.iter().map(|(package, version)| { - (package.as_str(), version.as_str()) - }).collect::>(); - node.npm_install_packages(default_prettier_dir, &borrowed_packages).await.context("fetching formatter packages")?; - let installed_packages = !plugins_to_install.is_empty(); - install_success_tx.try_send(plugins_to_install).ok(); - - if !installed_packages { - if let Some(prettier) = already_running_prettier { - prettier.await.map_err(|e| anyhow::anyhow!("Default prettier startup await failure: {e:#}"))?.clear_cache().await.context("clearing default prettier cache after plugins install")?; + match locate_prettier_installation + .await + .context("locate prettier installation")? + { + Some(_non_default_prettier) => return Ok(()), + None => { + let mut needs_restart = match previous_installation_process { + Some(previous_installation_process) => { + previous_installation_process.await.is_err() } + None => true, + }; + this.update(&mut cx, |this, _| { + if let Some(default_prettier) = &mut this.default_prettier { + plugins_to_install.retain(|plugin| { + !default_prettier.installed_plugins.contains(plugin) + }); + needs_restart |= !plugins_to_install.is_empty(); + } + }); + if needs_restart { + let installed_plugins = plugins_to_install.clone(); + cx.background() + .spawn(async move { + install_default_prettier(plugins_to_install, node, fs).await + }) + .await + .context("prettier & plugins install")?; + this.update(&mut cx, |this, _| { + let default_prettier = + this.default_prettier + .get_or_insert_with(|| DefaultPrettier { + instance: None, + installed_plugins: HashSet::default(), + }); + default_prettier.instance = None; + default_prettier.installed_plugins.extend(installed_plugins); + }); } - - anyhow::Ok(()) - }).await + } + } + Ok(()) }) } } +fn spawn_default_prettier( + node: Arc, + cx: &mut ModelContext<'_, Project>, +) -> Shared, Arc>>> { + cx.spawn(|project, mut cx| async move { + let new_server_id = project.update(&mut cx, |project, _| { + project.languages.next_language_server_id() + }); + Prettier::start( + new_server_id, + DEFAULT_PRETTIER_DIR.clone(), + node, + cx.clone(), + ) + .await + .context("default prettier spawn") + .map(Arc::new) + .map_err(Arc::new) + }) + .shared() +} + +#[cfg(not(any(test, feature = "test-support")))] +async fn install_default_prettier( + plugins_to_install: HashSet<&'static str>, + node: Arc, + fs: Arc, +) -> anyhow::Result<()> { + let prettier_wrapper_path = DEFAULT_PRETTIER_DIR.join(prettier::PRETTIER_SERVER_FILE); + // method creates parent directory if it doesn't exist + fs.save( + &prettier_wrapper_path, + &text::Rope::from(prettier::PRETTIER_SERVER_JS), + text::LineEnding::Unix, + ) + .await + .with_context(|| { + format!( + "writing {} file at {prettier_wrapper_path:?}", + prettier::PRETTIER_SERVER_FILE + ) + })?; + + let packages_to_versions = + future::try_join_all(plugins_to_install.iter().chain(Some(&"prettier")).map( + |package_name| async { + let returned_package_name = package_name.to_string(); + let latest_version = node + .npm_package_latest_version(package_name) + .await + .with_context(|| { + format!("fetching latest npm version for package {returned_package_name}") + })?; + anyhow::Ok((returned_package_name, latest_version)) + }, + )) + .await + .context("fetching latest npm versions")?; + + log::info!("Fetching default prettier and plugins: {packages_to_versions:?}"); + let borrowed_packages = packages_to_versions + .iter() + .map(|(package, version)| (package.as_str(), version.as_str())) + .collect::>(); + node.npm_install_packages(DEFAULT_PRETTIER_DIR.as_path(), &borrowed_packages) + .await + .context("fetching formatter packages")?; + anyhow::Ok(()) +} + fn subscribe_for_copilot_events( copilot: &ModelHandle, cx: &mut ModelContext<'_, Project>, diff --git a/crates/project/src/search.rs b/crates/project/src/search.rs index f626f15d12..7e360e22ee 100644 --- a/crates/project/src/search.rs +++ b/crates/project/src/search.rs @@ -1,7 +1,6 @@ use aho_corasick::{AhoCorasick, AhoCorasickBuilder}; use anyhow::{Context, Result}; use client::proto; -use globset::{Glob, GlobMatcher}; use itertools::Itertools; use language::{char_kind, BufferSnapshot}; use regex::{Regex, RegexBuilder}; @@ -10,7 +9,7 @@ use std::{ borrow::Cow, io::{BufRead, BufReader, Read}, ops::Range, - path::{Path, PathBuf}, + path::Path, sync::Arc, }; use util::paths::PathMatcher;