Detailed changes
@@ -8982,6 +8982,7 @@ dependencies = [
"async-trait",
"collections",
"command_palette",
+ "diagnostics",
"editor",
"futures 0.3.28",
"gpui",
@@ -9003,6 +9004,7 @@ dependencies = [
"tokio",
"util",
"workspace",
+ "zed-actions",
]
[[package]]
@@ -9992,12 +9994,14 @@ dependencies = [
"rpc",
"rsa",
"rust-embed",
+ "schemars",
"search",
"semantic_index",
"serde",
"serde_derive",
"serde_json",
"settings",
+ "shellexpand",
"simplelog",
"smallvec",
"smol",
@@ -30,6 +30,7 @@
"cmd-s": "workspace::Save",
"cmd-shift-s": "workspace::SaveAs",
"cmd-=": "zed::IncreaseBufferFontSize",
+ "cmd-+": "zed::IncreaseBufferFontSize",
"cmd--": "zed::DecreaseBufferFontSize",
"cmd-0": "zed::ResetBufferFontSize",
"cmd-,": "zed::OpenSettings",
@@ -588,14 +589,20 @@
}
},
{
- "context": "CollabPanel",
+ "context": "CollabPanel && not_editing",
"bindings": {
"ctrl-backspace": "collab_panel::Remove",
"space": "menu::Confirm"
}
},
{
- "context": "CollabPanel > Editor",
+ "context": "(CollabPanel && editing) > Editor",
+ "bindings": {
+ "space": "collab_panel::InsertSpace"
+ }
+ },
+ {
+ "context": "(CollabPanel && not_editing) > Editor",
"bindings": {
"cmd-c": "collab_panel::StartLinkChannel",
"cmd-x": "collab_panel::StartMoveChannel",
@@ -18,6 +18,7 @@
}
}
],
+ ":": "command_palette::Toggle",
"h": "vim::Left",
"left": "vim::Left",
"backspace": "vim::Backspace",
@@ -125,6 +126,21 @@
"g shift-t": "pane::ActivatePrevItem",
"g d": "editor::GoToDefinition",
"g shift-d": "editor::GoToTypeDefinition",
+ "g n": "vim::SelectNext",
+ "g shift-n": "vim::SelectPrevious",
+ "g >": [
+ "editor::SelectNext",
+ {
+ "replace_newest": true
+ }
+ ],
+ "g <": [
+ "editor::SelectPrevious",
+ {
+ "replace_newest": true
+ }
+ ],
+ "g a": "editor::SelectAllMatches",
"g s": "outline::Toggle",
"g shift-s": "project_symbols::Toggle",
"g .": "editor::ToggleCodeActions", // zed specific
@@ -205,13 +221,13 @@
"shift-z shift-q": [
"pane::CloseActiveItem",
{
- "saveBehavior": "dontSave"
+ "saveIntent": "skip"
}
],
"shift-z shift-z": [
"pane::CloseActiveItem",
{
- "saveBehavior": "promptOnConflict"
+ "saveIntent": "saveAll"
}
],
// Count support
@@ -318,7 +334,17 @@
"ctrl-w c": "pane::CloseAllItems",
"ctrl-w ctrl-c": "pane::CloseAllItems",
"ctrl-w q": "pane::CloseAllItems",
- "ctrl-w ctrl-q": "pane::CloseAllItems"
+ "ctrl-w ctrl-q": "pane::CloseAllItems",
+ "ctrl-w o": "workspace::CloseInactiveTabsAndPanes",
+ "ctrl-w ctrl-o": "workspace::CloseInactiveTabsAndPanes",
+ "ctrl-w n": [
+ "workspace::NewFileInDirection",
+ "Up"
+ ],
+ "ctrl-w ctrl-n": [
+ "workspace::NewFileInDirection",
+ "Up"
+ ]
}
},
{
@@ -372,6 +372,27 @@
"semantic_index": {
"enabled": false
},
+ // Settings specific to our elixir integration
+ "elixir": {
+ // Set Zed to use the experimental Next LS LSP server.
+ // Note that changing this setting requires a restart of Zed
+ // to take effect.
+ //
+ // May take 3 values:
+ // 1. Use the standard elixir-ls LSP server
+ // "next": "off"
+ // 2. Use a bundled version of the next Next LS LSP server
+ // "next": "on",
+ // 3. Use a local build of the next Next LS LSP server:
+ // "next": {
+ // "local": {
+ // "path": "~/next-ls/bin/start",
+ // "arguments": ["--stdio"]
+ // }
+ // },
+ //
+ "next": "off"
+ },
// Different settings for specific languages.
"languages": {
"Plain Text": {
@@ -136,6 +136,7 @@ actions!(
StartMoveChannel,
StartLinkChannel,
MoveOrLinkToSelected,
+ InsertSpace,
]
);
@@ -184,6 +185,7 @@ pub fn init(cx: &mut AppContext) {
cx.add_action(CollabPanel::select_next);
cx.add_action(CollabPanel::select_prev);
cx.add_action(CollabPanel::confirm);
+ cx.add_action(CollabPanel::insert_space);
cx.add_action(CollabPanel::remove);
cx.add_action(CollabPanel::remove_selected_channel);
cx.add_action(CollabPanel::show_inline_context_menu);
@@ -2518,6 +2520,14 @@ impl CollabPanel {
}
}
+ fn insert_space(&mut self, _: &InsertSpace, cx: &mut ViewContext<Self>) {
+ if self.channel_editing_state.is_some() {
+ self.channel_name_editor.update(cx, |editor, cx| {
+ editor.insert(" ", cx);
+ });
+ }
+ }
+
fn confirm_channel_edit(&mut self, cx: &mut ViewContext<CollabPanel>) -> bool {
if let Some(editing_state) = &mut self.channel_editing_state {
match editing_state {
@@ -3054,6 +3064,19 @@ impl View for CollabPanel {
.on_click(MouseButton::Left, |_, _, cx| cx.focus_self())
.into_any_named("collab panel")
}
+
+ fn update_keymap_context(
+ &self,
+ keymap: &mut gpui::keymap_matcher::KeymapContext,
+ _: &AppContext,
+ ) {
+ Self::reset_to_default_keymap_context(keymap);
+ if self.channel_editing_state.is_some() {
+ keymap.add_identifier("editing");
+ } else {
+ keymap.add_identifier("not_editing");
+ }
+ }
}
impl Panel for CollabPanel {
@@ -18,6 +18,15 @@ actions!(command_palette, [Toggle]);
pub type CommandPalette = Picker<CommandPaletteDelegate>;
+pub type CommandPaletteInterceptor =
+ Box<dyn Fn(&str, &AppContext) -> Option<CommandInterceptResult>>;
+
+pub struct CommandInterceptResult {
+ pub action: Box<dyn Action>,
+ pub string: String,
+ pub positions: Vec<usize>,
+}
+
pub struct CommandPaletteDelegate {
actions: Vec<Command>,
matches: Vec<StringMatch>,
@@ -117,7 +126,7 @@ impl PickerDelegate for CommandPaletteDelegate {
}
})
.collect::<Vec<_>>();
- let actions = cx.read(move |cx| {
+ let mut actions = cx.read(move |cx| {
let hit_counts = cx.optional_global::<HitCounts>();
actions.sort_by_key(|action| {
(
@@ -136,7 +145,7 @@ impl PickerDelegate for CommandPaletteDelegate {
char_bag: command.name.chars().collect(),
})
.collect::<Vec<_>>();
- let matches = if query.is_empty() {
+ let mut matches = if query.is_empty() {
candidates
.into_iter()
.enumerate()
@@ -158,6 +167,40 @@ impl PickerDelegate for CommandPaletteDelegate {
)
.await
};
+ let intercept_result = cx.read(|cx| {
+ if cx.has_global::<CommandPaletteInterceptor>() {
+ cx.global::<CommandPaletteInterceptor>()(&query, cx)
+ } else {
+ None
+ }
+ });
+ if let Some(CommandInterceptResult {
+ action,
+ string,
+ positions,
+ }) = intercept_result
+ {
+ if let Some(idx) = matches
+ .iter()
+ .position(|m| actions[m.candidate_id].action.id() == action.id())
+ {
+ matches.remove(idx);
+ }
+ actions.push(Command {
+ name: string.clone(),
+ action,
+ keystrokes: vec![],
+ });
+ matches.insert(
+ 0,
+ StringMatch {
+ candidate_id: actions.len() - 1,
+ string,
+ positions,
+ score: 0.0,
+ },
+ )
+ }
picker
.update(&mut cx, |picker, _| {
let delegate = picker.delegate_mut();
@@ -103,7 +103,7 @@ use sum_tree::TreeMap;
use text::Rope;
use theme::{DiagnosticStyle, Theme, ThemeSettings};
use util::{post_inc, RangeExt, ResultExt, TryFutureExt};
-use workspace::{ItemNavHistory, ViewId, Workspace};
+use workspace::{ItemNavHistory, SplitDirection, ViewId, Workspace};
use crate::git::diff_hunk_to_display;
@@ -363,6 +363,7 @@ pub fn init_settings(cx: &mut AppContext) {
pub fn init(cx: &mut AppContext) {
init_settings(cx);
cx.add_action(Editor::new_file);
+ cx.add_action(Editor::new_file_in_direction);
cx.add_action(Editor::cancel);
cx.add_action(Editor::newline);
cx.add_action(Editor::newline_above);
@@ -1131,12 +1132,14 @@ struct CodeActionsMenu {
impl CodeActionsMenu {
fn select_first(&mut self, cx: &mut ViewContext<Editor>) {
self.selected_item = 0;
+ self.list.scroll_to(ScrollTarget::Show(self.selected_item));
cx.notify()
}
fn select_prev(&mut self, cx: &mut ViewContext<Editor>) {
if self.selected_item > 0 {
self.selected_item -= 1;
+ self.list.scroll_to(ScrollTarget::Show(self.selected_item));
cx.notify()
}
}
@@ -1144,12 +1147,14 @@ impl CodeActionsMenu {
fn select_next(&mut self, cx: &mut ViewContext<Editor>) {
if self.selected_item + 1 < self.actions.len() {
self.selected_item += 1;
+ self.list.scroll_to(ScrollTarget::Show(self.selected_item));
cx.notify()
}
}
fn select_last(&mut self, cx: &mut ViewContext<Editor>) {
self.selected_item = self.actions.len() - 1;
+ self.list.scroll_to(ScrollTarget::Show(self.selected_item));
cx.notify()
}
@@ -1202,7 +1207,9 @@ impl CodeActionsMenu {
workspace.update(cx, |workspace, cx| {
if let Some(task) = Editor::confirm_code_action(
workspace,
- &Default::default(),
+ &ConfirmCodeAction {
+ item_ix: Some(item_ix),
+ },
cx,
) {
task.detach_and_log_err(cx);
@@ -1627,6 +1634,26 @@ impl Editor {
}
}
+ pub fn new_file_in_direction(
+ workspace: &mut Workspace,
+ action: &workspace::NewFileInDirection,
+ cx: &mut ViewContext<Workspace>,
+ ) {
+ let project = workspace.project().clone();
+ if project.read(cx).is_remote() {
+ cx.propagate_action();
+ } else if let Some(buffer) = project
+ .update(cx, |project, cx| project.create_buffer("", None, cx))
+ .log_err()
+ {
+ workspace.split_item(
+ action.0,
+ Box::new(cx.add_view(|cx| Editor::for_buffer(buffer, Some(project.clone()), cx))),
+ cx,
+ );
+ }
+ }
+
pub fn replica_id(&self, cx: &AppContext) -> ReplicaId {
self.buffer.read(cx).replica_id()
}
@@ -7130,7 +7157,7 @@ impl Editor {
);
});
if split {
- workspace.split_item(Box::new(editor), cx);
+ workspace.split_item(SplitDirection::Right, Box::new(editor), cx);
} else {
workspace.add_item(Box::new(editor), cx);
}
@@ -3,8 +3,8 @@ use crate::{
};
use futures::Future;
use gpui::{
- keymap_matcher::Keystroke, AnyWindowHandle, AppContext, ContextHandle, ModelContext,
- ViewContext, ViewHandle,
+ executor::Foreground, keymap_matcher::Keystroke, AnyWindowHandle, AppContext, ContextHandle,
+ ModelContext, ViewContext, ViewHandle,
};
use indoc::indoc;
use language::{Buffer, BufferSnapshot};
@@ -114,6 +114,7 @@ impl<'a> EditorTestContext<'a> {
let keystroke = Keystroke::parse(keystroke_text).unwrap();
self.cx.dispatch_keystroke(self.window, keystroke, false);
+
keystroke_under_test_handle
}
@@ -126,6 +127,16 @@ impl<'a> EditorTestContext<'a> {
for keystroke_text in keystroke_texts.into_iter() {
self.simulate_keystroke(keystroke_text);
}
+ // it is common for keyboard shortcuts to kick off async actions, so this ensures that they are complete
+ // before returning.
+ // NOTE: we don't do this in simulate_keystroke() because a possible cause of bugs is that typing too
+ // quickly races with async actions.
+ if let Foreground::Deterministic { cx_id: _, executor } = self.cx.foreground().as_ref() {
+ executor.run_until_parked();
+ } else {
+ unreachable!();
+ }
+
keystrokes_under_test_handle
}
@@ -1528,13 +1528,8 @@ mod tests {
let active_pane = cx.read(|cx| workspace.read(cx).active_pane().clone());
active_pane
.update(cx, |pane, cx| {
- pane.close_active_item(
- &workspace::CloseActiveItem {
- save_behavior: None,
- },
- cx,
- )
- .unwrap()
+ pane.close_active_item(&workspace::CloseActiveItem { save_intent: None }, cx)
+ .unwrap()
})
.await
.unwrap();
@@ -507,7 +507,7 @@ impl FakeFs {
state.emit_event(&[path]);
}
- fn write_file_internal(&self, path: impl AsRef<Path>, content: String) -> Result<()> {
+ pub fn write_file_internal(&self, path: impl AsRef<Path>, content: String) -> Result<()> {
let mut state = self.state.lock();
let path = path.as_ref();
let inode = state.next_inode;
@@ -8,8 +8,8 @@ use gpui::{
ParentElement, Stack,
},
platform::{CursorStyle, MouseButton},
- AnyElement, AppContext, Element, Entity, ModelContext, ModelHandle, View, ViewContext,
- ViewHandle, WeakModelHandle,
+ AnyElement, AppContext, Element, Entity, ModelContext, ModelHandle, Subscription, View,
+ ViewContext, ViewHandle, WeakModelHandle,
};
use language::{Buffer, LanguageServerId, LanguageServerName};
use lsp::IoKind;
@@ -53,10 +53,12 @@ pub struct LspLogView {
current_server_id: Option<LanguageServerId>,
is_showing_rpc_trace: bool,
project: ModelHandle<Project>,
+ _log_store_subscription: Subscription,
}
pub struct LspLogToolbarItemView {
log_view: Option<ViewHandle<LspLogView>>,
+ _log_view_subscription: Option<Subscription>,
menu_open: bool,
}
@@ -373,12 +375,49 @@ impl LspLogView {
.get(&project.downgrade())
.and_then(|project| project.servers.keys().copied().next());
let buffer = cx.add_model(|cx| Buffer::new(0, cx.model_id() as u64, ""));
+ let _log_store_subscription = cx.observe(&log_store, |this, store, cx| {
+ (|| -> Option<()> {
+ let project_state = store.read(cx).projects.get(&this.project.downgrade())?;
+ if let Some(current_lsp) = this.current_server_id {
+ if !project_state.servers.contains_key(¤t_lsp) {
+ if let Some(server) = project_state.servers.iter().next() {
+ if this.is_showing_rpc_trace {
+ this.show_rpc_trace_for_server(*server.0, cx)
+ } else {
+ this.show_logs_for_server(*server.0, cx)
+ }
+ } else {
+ this.current_server_id = None;
+ this.editor.update(cx, |editor, cx| {
+ editor.set_read_only(false);
+ editor.clear(cx);
+ editor.set_read_only(true);
+ });
+ cx.notify();
+ }
+ }
+ } else {
+ if let Some(server) = project_state.servers.iter().next() {
+ if this.is_showing_rpc_trace {
+ this.show_rpc_trace_for_server(*server.0, cx)
+ } else {
+ this.show_logs_for_server(*server.0, cx)
+ }
+ }
+ }
+
+ Some(())
+ })();
+
+ cx.notify();
+ });
let mut this = Self {
editor: Self::editor_for_buffer(project.clone(), buffer, cx),
project,
log_store,
current_server_id: None,
is_showing_rpc_trace: false,
+ _log_store_subscription,
};
if let Some(server_id) = server_id {
this.show_logs_for_server(server_id, cx);
@@ -601,18 +640,22 @@ impl ToolbarItemView for LspLogToolbarItemView {
fn set_active_pane_item(
&mut self,
active_pane_item: Option<&dyn ItemHandle>,
- _: &mut ViewContext<Self>,
+ cx: &mut ViewContext<Self>,
) -> workspace::ToolbarItemLocation {
self.menu_open = false;
if let Some(item) = active_pane_item {
if let Some(log_view) = item.downcast::<LspLogView>() {
self.log_view = Some(log_view.clone());
+ self._log_view_subscription = Some(cx.observe(&log_view, |_, _, cx| {
+ cx.notify();
+ }));
return ToolbarItemLocation::PrimaryLeft {
flex: Some((1., false)),
};
}
}
self.log_view = None;
+ self._log_view_subscription = None;
ToolbarItemLocation::Hidden
}
}
@@ -743,6 +786,7 @@ impl LspLogToolbarItemView {
Self {
menu_open: false,
log_view: None,
+ _log_view_subscription: None,
}
}
@@ -716,11 +716,11 @@ impl LanguageServer {
}
}
- pub fn name<'a>(self: &'a Arc<Self>) -> &'a str {
+ pub fn name(&self) -> &str {
&self.name
}
- pub fn capabilities<'a>(self: &'a Arc<Self>) -> &'a ServerCapabilities {
+ pub fn capabilities(&self) -> &ServerCapabilities {
&self.capabilities
}
@@ -25,7 +25,8 @@ pub struct Picker<D: PickerDelegate> {
max_size: Vector2F,
theme: Arc<Mutex<Box<dyn Fn(&theme::Theme) -> theme::Picker>>>,
confirmed: bool,
- pending_update_matches: Task<Option<()>>,
+ pending_update_matches: Option<Task<Option<()>>>,
+ confirm_on_update: Option<bool>,
has_focus: bool,
}
@@ -208,7 +209,8 @@ impl<D: PickerDelegate> Picker<D> {
max_size: vec2f(540., 420.),
theme,
confirmed: false,
- pending_update_matches: Task::ready(None),
+ pending_update_matches: None,
+ confirm_on_update: None,
has_focus: false,
};
this.update_matches(String::new(), cx);
@@ -263,11 +265,13 @@ impl<D: PickerDelegate> Picker<D> {
pub fn update_matches(&mut self, query: String, cx: &mut ViewContext<Self>) {
let update = self.delegate.update_matches(query, cx);
self.matches_updated(cx);
- self.pending_update_matches = cx.spawn(|this, mut cx| async move {
+ self.pending_update_matches = Some(cx.spawn(|this, mut cx| async move {
update.await;
- this.update(&mut cx, |this, cx| this.matches_updated(cx))
- .log_err()
- });
+ this.update(&mut cx, |this, cx| {
+ this.matches_updated(cx);
+ })
+ .log_err()
+ }));
}
fn matches_updated(&mut self, cx: &mut ViewContext<Self>) {
@@ -278,6 +282,11 @@ impl<D: PickerDelegate> Picker<D> {
ScrollTarget::Show(index)
};
self.list_state.scroll_to(target);
+ self.pending_update_matches = None;
+ if let Some(secondary) = self.confirm_on_update.take() {
+ self.confirmed = true;
+ self.delegate.confirm(secondary, cx)
+ }
cx.notify();
}
@@ -331,13 +340,21 @@ impl<D: PickerDelegate> Picker<D> {
}
pub fn confirm(&mut self, _: &Confirm, cx: &mut ViewContext<Self>) {
- self.confirmed = true;
- self.delegate.confirm(false, cx);
+ if self.pending_update_matches.is_some() {
+ self.confirm_on_update = Some(false)
+ } else {
+ self.confirmed = true;
+ self.delegate.confirm(false, cx);
+ }
}
pub fn secondary_confirm(&mut self, _: &SecondaryConfirm, cx: &mut ViewContext<Self>) {
- self.confirmed = true;
- self.delegate.confirm(true, cx);
+ if self.pending_update_matches.is_some() {
+ self.confirm_on_update = Some(true)
+ } else {
+ self.confirmed = true;
+ self.delegate.confirm(true, cx);
+ }
}
fn cancel(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
@@ -2280,11 +2280,13 @@ impl Project {
};
for (_, _, server) in self.language_servers_for_worktree(worktree_id) {
+ let text = include_text(server.as_ref()).then(|| buffer.read(cx).text());
+
server
.notify::<lsp::notification::DidSaveTextDocument>(
lsp::DidSaveTextDocumentParams {
text_document: text_document.clone(),
- text: None,
+ text,
},
)
.log_err();
@@ -8041,24 +8043,27 @@ fn subscribe_for_copilot_events(
copilot::Event::CopilotLanguageServerStarted => {
match copilot.read(cx).language_server() {
Some((name, copilot_server)) => {
- let new_server_id = copilot_server.server_id();
- let weak_project = cx.weak_handle();
- let copilot_log_subscription = copilot_server
- .on_notification::<copilot::request::LogMessage, _>(
- move |params, mut cx| {
- if let Some(project) = weak_project.upgrade(&mut cx) {
- project.update(&mut cx, |_, cx| {
- cx.emit(Event::LanguageServerLog(
- new_server_id,
- params.message,
- ));
- })
- }
- },
- );
- project.supplementary_language_servers.insert(new_server_id, (name.clone(), Arc::clone(copilot_server)));
- project.copilot_log_subscription = Some(copilot_log_subscription);
- cx.emit(Event::LanguageServerAdded(new_server_id));
+ // Another event wants to re-add the server that was already added and subscribed to, avoid doing it again.
+ if !copilot_server.has_notification_handler::<copilot::request::LogMessage>() {
+ let new_server_id = copilot_server.server_id();
+ let weak_project = cx.weak_handle();
+ let copilot_log_subscription = copilot_server
+ .on_notification::<copilot::request::LogMessage, _>(
+ move |params, mut cx| {
+ if let Some(project) = weak_project.upgrade(&mut cx) {
+ project.update(&mut cx, |_, cx| {
+ cx.emit(Event::LanguageServerLog(
+ new_server_id,
+ params.message,
+ ));
+ })
+ }
+ },
+ );
+ project.supplementary_language_servers.insert(new_server_id, (name.clone(), Arc::clone(copilot_server)));
+ project.copilot_log_subscription = Some(copilot_log_subscription);
+ cx.emit(Event::LanguageServerAdded(new_server_id));
+ }
}
None => debug_panic!("Received Copilot language server started event, but no language server is running"),
}
@@ -8325,3 +8330,19 @@ async fn wait_for_loading_buffer(
receiver.next().await;
}
}
+
+fn include_text(server: &lsp::LanguageServer) -> bool {
+ server
+ .capabilities()
+ .text_document_sync
+ .as_ref()
+ .and_then(|sync| match sync {
+ lsp::TextDocumentSyncCapability::Kind(_) => None,
+ lsp::TextDocumentSyncCapability::Options(options) => options.save.as_ref(),
+ })
+ .and_then(|save_options| match save_options {
+ lsp::TextDocumentSyncSaveOptions::Supported(_) => None,
+ lsp::TextDocumentSyncSaveOptions::SaveOptions(options) => options.include_text,
+ })
+ .unwrap_or(false)
+}
@@ -69,7 +69,7 @@ impl ProjectSymbolsDelegate {
&self.external_match_candidates,
query,
false,
- MAX_MATCHES - visible_matches.len(),
+ MAX_MATCHES - visible_matches.len().min(MAX_MATCHES),
&Default::default(),
cx.background().clone(),
));
@@ -539,6 +539,23 @@ impl BufferSearchBar {
.map(|searchable_item| searchable_item.query_suggestion(cx))
}
+ pub fn set_replacement(&mut self, replacement: Option<&str>, cx: &mut ViewContext<Self>) {
+ if replacement.is_none() {
+ self.replace_enabled = false;
+ return;
+ }
+ self.replace_enabled = true;
+ self.replacement_editor
+ .update(cx, |replacement_editor, cx| {
+ replacement_editor
+ .buffer()
+ .update(cx, |replacement_buffer, cx| {
+ let len = replacement_buffer.len(cx);
+ replacement_buffer.edit([(0..len, replacement.unwrap())], None, cx);
+ });
+ });
+ }
+
pub fn search(
&mut self,
query: &str,
@@ -679,6 +696,22 @@ impl BufferSearchBar {
}
}
+ pub fn select_last_match(&mut self, cx: &mut ViewContext<Self>) {
+ if let Some(searchable_item) = self.active_searchable_item.as_ref() {
+ if let Some(matches) = self
+ .searchable_items_with_matches
+ .get(&searchable_item.downgrade())
+ {
+ if matches.len() == 0 {
+ return;
+ }
+ let new_match_index = matches.len() - 1;
+ searchable_item.update_matches(matches, cx);
+ searchable_item.activate_match(new_match_index, matches, cx);
+ }
+ }
+ }
+
fn select_next_match_on_pane(
pane: &mut Pane,
action: &SelectNextMatch,
@@ -946,7 +979,7 @@ impl BufferSearchBar {
cx.propagate_action();
}
}
- fn replace_all(&mut self, _: &ReplaceAll, cx: &mut ViewContext<Self>) {
+ pub fn replace_all(&mut self, _: &ReplaceAll, cx: &mut ViewContext<Self>) {
if !self.dismissed && self.active_search.is_some() {
if let Some(searchable_item) = self.active_searchable_item.as_ref() {
if let Some(query) = self.active_search.as_ref() {
@@ -456,7 +456,7 @@ fn main() {
let languages = Arc::new(languages);
let node_runtime = RealNodeRuntime::new(http.clone());
- languages::init(languages.clone(), node_runtime.clone());
+ languages::init(languages.clone(), node_runtime.clone(), cx);
language::init(cx);
project::Project::init(&client, cx);
@@ -820,14 +820,9 @@ impl SemanticIndex {
let batch_results = futures::future::join_all(batch_results).await;
let mut results = Vec::new();
- let mut min_similarity = None;
for batch_result in batch_results {
if batch_result.is_ok() {
for (id, similarity) in batch_result.unwrap() {
- if min_similarity.map_or_else(|| false, |min_sim| min_sim > similarity) {
- continue;
- }
-
let ix = match results
.binary_search_by_key(&Reverse(similarity), |(_, s)| Reverse(*s))
{
@@ -835,11 +830,8 @@ impl SemanticIndex {
Err(ix) => ix,
};
- if ix <= limit {
- min_similarity = Some(similarity);
- results.insert(ix, (id, similarity));
- results.truncate(limit);
- }
+ results.insert(ix, (id, similarity));
+ results.truncate(limit);
}
}
}
@@ -284,12 +284,7 @@ impl TerminalView {
pub fn deploy_context_menu(&mut self, position: Vector2F, cx: &mut ViewContext<Self>) {
let menu_entries = vec![
ContextMenuItem::action("Clear", Clear),
- ContextMenuItem::action(
- "Close",
- pane::CloseActiveItem {
- save_behavior: None,
- },
- ),
+ ContextMenuItem::action("Close", pane::CloseActiveItem { save_intent: None }),
];
self.context_menu.update(cx, |menu, cx| {
@@ -41,6 +41,8 @@ pub fn truncate(s: &str, max_chars: usize) -> &str {
}
}
+/// Removes characters from the end of the string if it's length is greater than `max_chars` and
+/// appends "..." to the string. Returns string unchanged if it's length is smaller than max_chars.
pub fn truncate_and_trailoff(s: &str, max_chars: usize) -> String {
debug_assert!(max_chars >= 5);
@@ -51,6 +53,18 @@ pub fn truncate_and_trailoff(s: &str, max_chars: usize) -> String {
}
}
+/// Removes characters from the front of the string if it's length is greater than `max_chars` and
+/// prepends the string with "...". Returns string unchanged if it's length is smaller than max_chars.
+pub fn truncate_and_remove_front(s: &str, max_chars: usize) -> String {
+ debug_assert!(max_chars >= 5);
+
+ let truncation_ix = s.char_indices().map(|(i, _)| i).nth_back(max_chars);
+ match truncation_ix {
+ Some(length) => "β¦".to_string() + &s[length..],
+ None => s.to_string(),
+ }
+}
+
pub fn post_inc<T: From<u8> + AddAssign<T> + Copy>(value: &mut T) -> T {
let prev = *value;
*value += T::from(1);
@@ -34,6 +34,8 @@ settings = { path = "../settings" }
workspace = { path = "../workspace" }
theme = { path = "../theme" }
language_selector = { path = "../language_selector"}
+diagnostics = { path = "../diagnostics" }
+zed-actions = { path = "../zed-actions" }
[dev-dependencies]
indoc.workspace = true
@@ -0,0 +1,434 @@
+use command_palette::CommandInterceptResult;
+use editor::{SortLinesCaseInsensitive, SortLinesCaseSensitive};
+use gpui::{impl_actions, Action, AppContext};
+use serde_derive::Deserialize;
+use workspace::{SaveIntent, Workspace};
+
+use crate::{
+ motion::{EndOfDocument, Motion},
+ normal::{
+ move_cursor,
+ search::{FindCommand, ReplaceCommand},
+ JoinLines,
+ },
+ state::Mode,
+ Vim,
+};
+
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+pub struct GoToLine {
+ pub line: u32,
+}
+
+impl_actions!(vim, [GoToLine]);
+
+pub fn init(cx: &mut AppContext) {
+ cx.add_action(|_: &mut Workspace, action: &GoToLine, cx| {
+ Vim::update(cx, |vim, cx| {
+ vim.switch_mode(Mode::Normal, false, cx);
+ move_cursor(vim, Motion::StartOfDocument, Some(action.line as usize), cx);
+ });
+ });
+}
+
+pub fn command_interceptor(mut query: &str, _: &AppContext) -> Option<CommandInterceptResult> {
+ // Note: this is a very poor simulation of vim's command palette.
+ // In the future we should adjust it to handle parsing range syntax,
+ // and then calling the appropriate commands with/without ranges.
+ //
+ // We also need to support passing arguments to commands like :w
+ // (ideally with filename autocompletion).
+ //
+ // For now, you can only do a replace on the % range, and you can
+ // only use a specific line number range to "go to line"
+ while query.starts_with(":") {
+ query = &query[1..];
+ }
+
+ let (name, action) = match query {
+ // save and quit
+ "w" | "wr" | "wri" | "writ" | "write" => (
+ "write",
+ workspace::Save {
+ save_intent: Some(SaveIntent::Save),
+ }
+ .boxed_clone(),
+ ),
+ "w!" | "wr!" | "wri!" | "writ!" | "write!" => (
+ "write!",
+ workspace::Save {
+ save_intent: Some(SaveIntent::Overwrite),
+ }
+ .boxed_clone(),
+ ),
+ "q" | "qu" | "qui" | "quit" => (
+ "quit",
+ workspace::CloseActiveItem {
+ save_intent: Some(SaveIntent::Close),
+ }
+ .boxed_clone(),
+ ),
+ "q!" | "qu!" | "qui!" | "quit!" => (
+ "quit!",
+ workspace::CloseActiveItem {
+ save_intent: Some(SaveIntent::Skip),
+ }
+ .boxed_clone(),
+ ),
+ "wq" => (
+ "wq",
+ workspace::CloseActiveItem {
+ save_intent: Some(SaveIntent::Save),
+ }
+ .boxed_clone(),
+ ),
+ "wq!" => (
+ "wq!",
+ workspace::CloseActiveItem {
+ save_intent: Some(SaveIntent::Overwrite),
+ }
+ .boxed_clone(),
+ ),
+ "x" | "xi" | "xit" | "exi" | "exit" => (
+ "exit",
+ workspace::CloseActiveItem {
+ save_intent: Some(SaveIntent::SaveAll),
+ }
+ .boxed_clone(),
+ ),
+ "x!" | "xi!" | "xit!" | "exi!" | "exit!" => (
+ "exit!",
+ workspace::CloseActiveItem {
+ save_intent: Some(SaveIntent::Overwrite),
+ }
+ .boxed_clone(),
+ ),
+ "up" | "upd" | "upda" | "updat" | "update" => (
+ "update",
+ workspace::Save {
+ save_intent: Some(SaveIntent::SaveAll),
+ }
+ .boxed_clone(),
+ ),
+ "wa" | "wal" | "wall" => (
+ "wall",
+ workspace::SaveAll {
+ save_intent: Some(SaveIntent::SaveAll),
+ }
+ .boxed_clone(),
+ ),
+ "wa!" | "wal!" | "wall!" => (
+ "wall!",
+ workspace::SaveAll {
+ save_intent: Some(SaveIntent::Overwrite),
+ }
+ .boxed_clone(),
+ ),
+ "qa" | "qal" | "qall" | "quita" | "quital" | "quitall" => (
+ "quitall",
+ workspace::CloseAllItemsAndPanes {
+ save_intent: Some(SaveIntent::Close),
+ }
+ .boxed_clone(),
+ ),
+ "qa!" | "qal!" | "qall!" | "quita!" | "quital!" | "quitall!" => (
+ "quitall!",
+ workspace::CloseAllItemsAndPanes {
+ save_intent: Some(SaveIntent::Skip),
+ }
+ .boxed_clone(),
+ ),
+ "xa" | "xal" | "xall" => (
+ "xall",
+ workspace::CloseAllItemsAndPanes {
+ save_intent: Some(SaveIntent::SaveAll),
+ }
+ .boxed_clone(),
+ ),
+ "xa!" | "xal!" | "xall!" => (
+ "xall!",
+ workspace::CloseAllItemsAndPanes {
+ save_intent: Some(SaveIntent::Overwrite),
+ }
+ .boxed_clone(),
+ ),
+ "wqa" | "wqal" | "wqall" => (
+ "wqall",
+ workspace::CloseAllItemsAndPanes {
+ save_intent: Some(SaveIntent::SaveAll),
+ }
+ .boxed_clone(),
+ ),
+ "wqa!" | "wqal!" | "wqall!" => (
+ "wqall!",
+ workspace::CloseAllItemsAndPanes {
+ save_intent: Some(SaveIntent::Overwrite),
+ }
+ .boxed_clone(),
+ ),
+ "cq" | "cqu" | "cqui" | "cquit" | "cq!" | "cqu!" | "cqui!" | "cquit!" => {
+ ("cquit!", zed_actions::Quit.boxed_clone())
+ }
+
+ // pane management
+ "sp" | "spl" | "spli" | "split" => ("split", workspace::SplitUp.boxed_clone()),
+ "vs" | "vsp" | "vspl" | "vspli" | "vsplit" => {
+ ("vsplit", workspace::SplitLeft.boxed_clone())
+ }
+ "new" => (
+ "new",
+ workspace::NewFileInDirection(workspace::SplitDirection::Up).boxed_clone(),
+ ),
+ "vne" | "vnew" => (
+ "vnew",
+ workspace::NewFileInDirection(workspace::SplitDirection::Left).boxed_clone(),
+ ),
+ "tabe" | "tabed" | "tabedi" | "tabedit" => ("tabedit", workspace::NewFile.boxed_clone()),
+ "tabnew" => ("tabnew", workspace::NewFile.boxed_clone()),
+
+ "tabn" | "tabne" | "tabnex" | "tabnext" => {
+ ("tabnext", workspace::ActivateNextItem.boxed_clone())
+ }
+ "tabp" | "tabpr" | "tabpre" | "tabprev" | "tabprevi" | "tabprevio" | "tabpreviou"
+ | "tabprevious" => ("tabprevious", workspace::ActivatePrevItem.boxed_clone()),
+ "tabN" | "tabNe" | "tabNex" | "tabNext" => {
+ ("tabNext", workspace::ActivatePrevItem.boxed_clone())
+ }
+ "tabc" | "tabcl" | "tabclo" | "tabclos" | "tabclose" => (
+ "tabclose",
+ workspace::CloseActiveItem {
+ save_intent: Some(SaveIntent::Close),
+ }
+ .boxed_clone(),
+ ),
+
+ // quickfix / loclist (merged together for now)
+ "cl" | "cli" | "clis" | "clist" => ("clist", diagnostics::Deploy.boxed_clone()),
+ "cc" => ("cc", editor::Hover.boxed_clone()),
+ "ll" => ("ll", editor::Hover.boxed_clone()),
+ "cn" | "cne" | "cnex" | "cnext" => ("cnext", editor::GoToDiagnostic.boxed_clone()),
+ "lne" | "lnex" | "lnext" => ("cnext", editor::GoToDiagnostic.boxed_clone()),
+
+ "cpr" | "cpre" | "cprev" | "cprevi" | "cprevio" | "cpreviou" | "cprevious" => {
+ ("cprevious", editor::GoToPrevDiagnostic.boxed_clone())
+ }
+ "cN" | "cNe" | "cNex" | "cNext" => ("cNext", editor::GoToPrevDiagnostic.boxed_clone()),
+ "lp" | "lpr" | "lpre" | "lprev" | "lprevi" | "lprevio" | "lpreviou" | "lprevious" => {
+ ("lprevious", editor::GoToPrevDiagnostic.boxed_clone())
+ }
+ "lN" | "lNe" | "lNex" | "lNext" => ("lNext", editor::GoToPrevDiagnostic.boxed_clone()),
+
+ // modify the buffer (should accept [range])
+ "j" | "jo" | "joi" | "join" => ("join", JoinLines.boxed_clone()),
+ "d" | "de" | "del" | "dele" | "delet" | "delete" | "dl" | "dell" | "delel" | "deletl"
+ | "deletel" | "dp" | "dep" | "delp" | "delep" | "deletp" | "deletep" => {
+ ("delete", editor::DeleteLine.boxed_clone())
+ }
+ "sor" | "sor " | "sort" | "sort " => ("sort", SortLinesCaseSensitive.boxed_clone()),
+ "sor i" | "sort i" => ("sort i", SortLinesCaseInsensitive.boxed_clone()),
+
+ // goto (other ranges handled under _ => )
+ "$" => ("$", EndOfDocument.boxed_clone()),
+
+ _ => {
+ if query.starts_with("/") || query.starts_with("?") {
+ (
+ query,
+ FindCommand {
+ query: query[1..].to_string(),
+ backwards: query.starts_with("?"),
+ }
+ .boxed_clone(),
+ )
+ } else if query.starts_with("%") {
+ (
+ query,
+ ReplaceCommand {
+ query: query.to_string(),
+ }
+ .boxed_clone(),
+ )
+ } else if let Ok(line) = query.parse::<u32>() {
+ (query, GoToLine { line }.boxed_clone())
+ } else {
+ return None;
+ }
+ }
+ };
+
+ let string = ":".to_owned() + name;
+ let positions = generate_positions(&string, query);
+
+ Some(CommandInterceptResult {
+ action,
+ string,
+ positions,
+ })
+}
+
+fn generate_positions(string: &str, query: &str) -> Vec<usize> {
+ let mut positions = Vec::new();
+ let mut chars = query.chars().into_iter();
+
+ let Some(mut current) = chars.next() else {
+ return positions;
+ };
+
+ for (i, c) in string.chars().enumerate() {
+ if c == current {
+ positions.push(i);
+ if let Some(c) = chars.next() {
+ current = c;
+ } else {
+ break;
+ }
+ }
+ }
+
+ positions
+}
+
+#[cfg(test)]
+mod test {
+ use std::path::Path;
+
+ use crate::test::{NeovimBackedTestContext, VimTestContext};
+ use gpui::{executor::Foreground, TestAppContext};
+ use indoc::indoc;
+
+ #[gpui::test]
+ async fn test_command_basics(cx: &mut TestAppContext) {
+ if let Foreground::Deterministic { cx_id: _, executor } = cx.foreground().as_ref() {
+ executor.run_until_parked();
+ }
+ let mut cx = NeovimBackedTestContext::new(cx).await;
+
+ cx.set_shared_state(indoc! {"
+ Λa
+ b
+ c"})
+ .await;
+
+ cx.simulate_shared_keystrokes([":", "j", "enter"]).await;
+
+ // hack: our cursor positionining after a join command is wrong
+ cx.simulate_shared_keystrokes(["^"]).await;
+ cx.assert_shared_state(indoc! {
+ "Λa b
+ c"
+ })
+ .await;
+ }
+
+ #[gpui::test]
+ async fn test_command_goto(cx: &mut TestAppContext) {
+ let mut cx = NeovimBackedTestContext::new(cx).await;
+
+ cx.set_shared_state(indoc! {"
+ Λa
+ b
+ c"})
+ .await;
+ cx.simulate_shared_keystrokes([":", "3", "enter"]).await;
+ cx.assert_shared_state(indoc! {"
+ a
+ b
+ Λc"})
+ .await;
+ }
+
+ #[gpui::test]
+ async fn test_command_replace(cx: &mut TestAppContext) {
+ let mut cx = NeovimBackedTestContext::new(cx).await;
+
+ cx.set_shared_state(indoc! {"
+ Λa
+ b
+ c"})
+ .await;
+ cx.simulate_shared_keystrokes([":", "%", "s", "/", "b", "/", "d", "enter"])
+ .await;
+ cx.assert_shared_state(indoc! {"
+ a
+ Λd
+ c"})
+ .await;
+ cx.simulate_shared_keystrokes([
+ ":", "%", "s", ":", ".", ":", "\\", "0", "\\", "0", "enter",
+ ])
+ .await;
+ cx.assert_shared_state(indoc! {"
+ aa
+ dd
+ Λcc"})
+ .await;
+ }
+
+ #[gpui::test]
+ async fn test_command_search(cx: &mut TestAppContext) {
+ let mut cx = NeovimBackedTestContext::new(cx).await;
+
+ cx.set_shared_state(indoc! {"
+ Λa
+ b
+ a
+ c"})
+ .await;
+ cx.simulate_shared_keystrokes([":", "/", "b", "enter"])
+ .await;
+ cx.assert_shared_state(indoc! {"
+ a
+ Λb
+ a
+ c"})
+ .await;
+ cx.simulate_shared_keystrokes([":", "?", "a", "enter"])
+ .await;
+ cx.assert_shared_state(indoc! {"
+ Λa
+ b
+ a
+ c"})
+ .await;
+ }
+
+ #[gpui::test]
+ async fn test_command_write(cx: &mut TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+ let path = Path::new("/root/dir/file.rs");
+ let fs = cx.workspace(|workspace, cx| workspace.project().read(cx).fs().clone());
+
+ cx.simulate_keystrokes(["i", "@", "escape"]);
+ cx.simulate_keystrokes([":", "w", "enter"]);
+
+ assert_eq!(fs.load(&path).await.unwrap(), "@\n");
+
+ fs.as_fake()
+ .write_file_internal(path, "oops\n".to_string())
+ .unwrap();
+
+ // conflict!
+ cx.simulate_keystrokes(["i", "@", "escape"]);
+ cx.simulate_keystrokes([":", "w", "enter"]);
+ let window = cx.window;
+ assert!(window.has_pending_prompt(cx.cx));
+ // "Cancel"
+ window.simulate_prompt_answer(0, cx.cx);
+ assert_eq!(fs.load(&path).await.unwrap(), "oops\n");
+ assert!(!window.has_pending_prompt(cx.cx));
+ // force overwrite
+ cx.simulate_keystrokes([":", "w", "!", "enter"]);
+ assert!(!window.has_pending_prompt(cx.cx));
+ assert_eq!(fs.load(&path).await.unwrap(), "@@\n");
+ }
+
+ #[gpui::test]
+ async fn test_command_quit(cx: &mut TestAppContext) {
+ let mut cx = VimTestContext::new(cx, true).await;
+
+ cx.simulate_keystrokes([":", "n", "e", "w", "enter"]);
+ cx.workspace(|workspace, cx| assert_eq!(workspace.items(cx).count(), 2));
+ cx.simulate_keystrokes([":", "q", "enter"]);
+ cx.workspace(|workspace, cx| assert_eq!(workspace.items(cx).count(), 1));
+ }
+}
@@ -4,7 +4,7 @@ mod delete;
mod paste;
pub(crate) mod repeat;
mod scroll;
-mod search;
+pub(crate) mod search;
pub mod substitute;
mod yank;
@@ -168,7 +168,12 @@ pub fn normal_object(object: Object, cx: &mut WindowContext) {
})
}
-fn move_cursor(vim: &mut Vim, motion: Motion, times: Option<usize>, cx: &mut WindowContext) {
+pub(crate) fn move_cursor(
+ vim: &mut Vim,
+ motion: Motion,
+ times: Option<usize>,
+ cx: &mut WindowContext,
+) {
vim.update_active_editor(cx, |editor, cx| {
editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
s.move_cursors_with(|map, cursor, goal| {
@@ -3,7 +3,7 @@ use search::{buffer_search, BufferSearchBar, SearchMode, SearchOptions};
use serde_derive::Deserialize;
use workspace::{searchable::Direction, Pane, Workspace};
-use crate::{state::SearchState, Vim};
+use crate::{motion::Motion, normal::move_cursor, state::SearchState, Vim};
#[derive(Clone, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
@@ -25,7 +25,29 @@ pub(crate) struct Search {
backwards: bool,
}
-impl_actions!(vim, [MoveToNext, MoveToPrev, Search]);
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+pub struct FindCommand {
+ pub query: String,
+ pub backwards: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+pub struct ReplaceCommand {
+ pub query: String,
+}
+
+#[derive(Debug, Default)]
+struct Replacement {
+ search: String,
+ replacement: String,
+ should_replace_all: bool,
+ is_case_sensitive: bool,
+}
+
+impl_actions!(
+ vim,
+ [MoveToNext, MoveToPrev, Search, FindCommand, ReplaceCommand]
+);
actions!(vim, [SearchSubmit]);
pub(crate) fn init(cx: &mut AppContext) {
@@ -34,6 +56,9 @@ pub(crate) fn init(cx: &mut AppContext) {
cx.add_action(search);
cx.add_action(search_submit);
cx.add_action(search_deploy);
+
+ cx.add_action(find_command);
+ cx.add_action(replace_command);
}
fn move_to_next(workspace: &mut Workspace, action: &MoveToNext, cx: &mut ViewContext<Workspace>) {
@@ -65,6 +90,7 @@ fn search(workspace: &mut Workspace, action: &Search, cx: &mut ViewContext<Works
cx.focus_self();
if query.is_empty() {
+ search_bar.set_replacement(None, cx);
search_bar.set_search_options(SearchOptions::CASE_SENSITIVE, cx);
search_bar.activate_search_mode(SearchMode::Regex, cx);
}
@@ -151,6 +177,174 @@ pub fn move_to_internal(
});
}
+fn find_command(workspace: &mut Workspace, action: &FindCommand, cx: &mut ViewContext<Workspace>) {
+ let pane = workspace.active_pane().clone();
+ pane.update(cx, |pane, cx| {
+ if let Some(search_bar) = pane.toolbar().read(cx).item_of_type::<BufferSearchBar>() {
+ let search = search_bar.update(cx, |search_bar, cx| {
+ if !search_bar.show(cx) {
+ return None;
+ }
+ let mut query = action.query.clone();
+ if query == "" {
+ query = search_bar.query(cx);
+ };
+
+ search_bar.activate_search_mode(SearchMode::Regex, cx);
+ Some(search_bar.search(&query, Some(SearchOptions::CASE_SENSITIVE), cx))
+ });
+ let Some(search) = search else { return };
+ let search_bar = search_bar.downgrade();
+ let direction = if action.backwards {
+ Direction::Prev
+ } else {
+ Direction::Next
+ };
+ cx.spawn(|_, mut cx| async move {
+ search.await?;
+ search_bar.update(&mut cx, |search_bar, cx| {
+ search_bar.select_match(direction, 1, cx)
+ })?;
+ anyhow::Ok(())
+ })
+ .detach_and_log_err(cx);
+ }
+ })
+}
+
+fn replace_command(
+ workspace: &mut Workspace,
+ action: &ReplaceCommand,
+ cx: &mut ViewContext<Workspace>,
+) {
+ let replacement = parse_replace_all(&action.query);
+ let pane = workspace.active_pane().clone();
+ pane.update(cx, |pane, cx| {
+ let Some(search_bar) = pane.toolbar().read(cx).item_of_type::<BufferSearchBar>() else {
+ return;
+ };
+ let search = search_bar.update(cx, |search_bar, cx| {
+ if !search_bar.show(cx) {
+ return None;
+ }
+
+ let mut options = SearchOptions::default();
+ if replacement.is_case_sensitive {
+ options.set(SearchOptions::CASE_SENSITIVE, true)
+ }
+ let search = if replacement.search == "" {
+ search_bar.query(cx)
+ } else {
+ replacement.search
+ };
+
+ search_bar.set_replacement(Some(&replacement.replacement), cx);
+ search_bar.activate_search_mode(SearchMode::Regex, cx);
+ Some(search_bar.search(&search, Some(options), cx))
+ });
+ let Some(search) = search else { return };
+ let search_bar = search_bar.downgrade();
+ cx.spawn(|_, mut cx| async move {
+ search.await?;
+ search_bar.update(&mut cx, |search_bar, cx| {
+ if replacement.should_replace_all {
+ search_bar.select_last_match(cx);
+ search_bar.replace_all(&Default::default(), cx);
+ Vim::update(cx, |vim, cx| {
+ move_cursor(
+ vim,
+ Motion::StartOfLine {
+ display_lines: false,
+ },
+ None,
+ cx,
+ )
+ })
+ }
+ })?;
+ anyhow::Ok(())
+ })
+ .detach_and_log_err(cx);
+ })
+}
+
+// convert a vim query into something more usable by zed.
+// we don't attempt to fully convert between the two regex syntaxes,
+// but we do flip \( and \) to ( and ) (and vice-versa) in the pattern,
+// and convert \0..\9 to $0..$9 in the replacement so that common idioms work.
+fn parse_replace_all(query: &str) -> Replacement {
+ let mut chars = query.chars();
+ if Some('%') != chars.next() || Some('s') != chars.next() {
+ return Replacement::default();
+ }
+
+ let Some(delimeter) = chars.next() else {
+ return Replacement::default();
+ };
+
+ let mut search = String::new();
+ let mut replacement = String::new();
+ let mut flags = String::new();
+
+ let mut buffer = &mut search;
+
+ let mut escaped = false;
+ // 0 - parsing search
+ // 1 - parsing replacement
+ // 2 - parsing flags
+ let mut phase = 0;
+
+ for c in chars {
+ if escaped {
+ escaped = false;
+ if phase == 1 && c.is_digit(10) {
+ buffer.push('$')
+ // unescape escaped parens
+ } else if phase == 0 && c == '(' || c == ')' {
+ } else if c != delimeter {
+ buffer.push('\\')
+ }
+ buffer.push(c)
+ } else if c == '\\' {
+ escaped = true;
+ } else if c == delimeter {
+ if phase == 0 {
+ buffer = &mut replacement;
+ phase = 1;
+ } else if phase == 1 {
+ buffer = &mut flags;
+ phase = 2;
+ } else {
+ break;
+ }
+ } else {
+ // escape unescaped parens
+ if phase == 0 && c == '(' || c == ')' {
+ buffer.push('\\')
+ }
+ buffer.push(c)
+ }
+ }
+
+ let mut replacement = Replacement {
+ search,
+ replacement,
+ should_replace_all: true,
+ is_case_sensitive: true,
+ };
+
+ for c in flags.chars() {
+ match c {
+ 'g' | 'I' => {}
+ 'c' | 'n' => replacement.should_replace_all = false,
+ 'i' => replacement.is_case_sensitive = false,
+ _ => {}
+ }
+ }
+
+ replacement
+}
+
#[cfg(test)]
mod test {
use std::sync::Arc;
@@ -186,9 +186,6 @@ async fn test_selection_on_search(cx: &mut gpui::TestAppContext) {
assert_eq!(bar.query(cx), "cc");
});
- // wait for the query editor change event to fire.
- search_bar.next_notification(&cx).await;
-
cx.update_editor(|editor, cx| {
let highlights = editor.all_text_background_highlights(cx);
assert_eq!(3, highlights.len());
@@ -1,7 +1,5 @@
use std::ops::{Deref, DerefMut};
-use gpui::ContextHandle;
-
use crate::state::Mode;
use super::{ExemptionFeatures, NeovimBackedTestContext, SUPPORTED_FEATURES};
@@ -33,26 +31,17 @@ impl<'a, const COUNT: usize> NeovimBackedBindingTestContext<'a, COUNT> {
self.consume().binding(keystrokes)
}
- pub async fn assert(
- &mut self,
- marked_positions: &str,
- ) -> Option<(ContextHandle, ContextHandle)> {
+ pub async fn assert(&mut self, marked_positions: &str) {
self.cx
.assert_binding_matches(self.keystrokes_under_test, marked_positions)
- .await
+ .await;
}
- pub async fn assert_exempted(
- &mut self,
- marked_positions: &str,
- feature: ExemptionFeatures,
- ) -> Option<(ContextHandle, ContextHandle)> {
+ pub async fn assert_exempted(&mut self, marked_positions: &str, feature: ExemptionFeatures) {
if SUPPORTED_FEATURES.contains(&feature) {
self.cx
.assert_binding_matches(self.keystrokes_under_test, marked_positions)
.await
- } else {
- None
}
}
@@ -106,26 +106,25 @@ impl<'a> NeovimBackedTestContext<'a> {
pub async fn simulate_shared_keystrokes<const COUNT: usize>(
&mut self,
keystroke_texts: [&str; COUNT],
- ) -> ContextHandle {
+ ) {
for keystroke_text in keystroke_texts.into_iter() {
self.recent_keystrokes.push(keystroke_text.to_string());
self.neovim.send_keystroke(keystroke_text).await;
}
- self.simulate_keystrokes(keystroke_texts)
+ self.simulate_keystrokes(keystroke_texts);
}
- pub async fn set_shared_state(&mut self, marked_text: &str) -> ContextHandle {
+ pub async fn set_shared_state(&mut self, marked_text: &str) {
let mode = if marked_text.contains("Β»") {
Mode::Visual
} else {
Mode::Normal
};
- let context_handle = self.set_state(marked_text, mode);
+ self.set_state(marked_text, mode);
self.last_set_state = Some(marked_text.to_string());
self.recent_keystrokes = Vec::new();
self.neovim.set_state(marked_text).await;
self.is_dirty = true;
- context_handle
}
pub async fn set_shared_wrap(&mut self, columns: u32) {
@@ -288,18 +287,18 @@ impl<'a> NeovimBackedTestContext<'a> {
&mut self,
keystrokes: [&str; COUNT],
initial_state: &str,
- ) -> Option<(ContextHandle, ContextHandle)> {
+ ) {
if let Some(possible_exempted_keystrokes) = self.exemptions.get(initial_state) {
match possible_exempted_keystrokes {
Some(exempted_keystrokes) => {
if exempted_keystrokes.contains(&format!("{keystrokes:?}")) {
// This keystroke was exempted for this insertion text
- return None;
+ return;
}
}
None => {
// All keystrokes for this insertion text are exempted
- return None;
+ return;
}
}
}
@@ -307,7 +306,6 @@ impl<'a> NeovimBackedTestContext<'a> {
let _state_context = self.set_shared_state(initial_state).await;
let _keystroke_context = self.simulate_shared_keystrokes(keystrokes).await;
self.assert_state_matches().await;
- Some((_state_context, _keystroke_context))
}
pub async fn assert_binding_matches_all<const COUNT: usize>(
@@ -65,7 +65,13 @@ impl NeovimConnection {
// Ensure we don't create neovim connections in parallel
let _lock = NEOVIM_LOCK.lock();
let (nvim, join_handle, child) = new_child_cmd(
- &mut Command::new("nvim").arg("--embed").arg("--clean"),
+ &mut Command::new("nvim")
+ .arg("--embed")
+ .arg("--clean")
+ // disable swap (otherwise after about 1000 test runs you run out of swap file names)
+ .arg("-n")
+ // disable writing files (just in case)
+ .arg("-m"),
handler,
)
.await
@@ -1,6 +1,7 @@
#[cfg(test)]
mod test;
+mod command;
mod editor_events;
mod insert;
mod mode_indicator;
@@ -13,6 +14,7 @@ mod visual;
use anyhow::Result;
use collections::{CommandPaletteFilter, HashMap};
+use command_palette::CommandPaletteInterceptor;
use editor::{movement, Editor, EditorMode, Event};
use gpui::{
actions, impl_actions, keymap_matcher::KeymapContext, keymap_matcher::MatchResult, Action,
@@ -63,6 +65,7 @@ pub fn init(cx: &mut AppContext) {
insert::init(cx);
object::init(cx);
motion::init(cx);
+ command::init(cx);
// Vim Actions
cx.add_action(|_: &mut Workspace, &SwitchMode(mode): &SwitchMode, cx| {
@@ -469,6 +472,12 @@ impl Vim {
}
});
+ if self.enabled {
+ cx.set_global::<CommandPaletteInterceptor>(Box::new(command::command_interceptor));
+ } else if cx.has_global::<CommandPaletteInterceptor>() {
+ let _ = cx.remove_global::<CommandPaletteInterceptor>();
+ }
+
cx.update_active_window(|cx| {
if self.enabled {
let active_editor = cx
@@ -1,3 +1,4 @@
+use anyhow::Result;
use std::{cmp, sync::Arc};
use collections::HashMap;
@@ -28,6 +29,8 @@ actions!(
VisualDelete,
VisualYank,
OtherEnd,
+ SelectNext,
+ SelectPrevious,
]
);
@@ -46,6 +49,9 @@ pub fn init(cx: &mut AppContext) {
cx.add_action(other_end);
cx.add_action(delete);
cx.add_action(yank);
+
+ cx.add_action(select_next);
+ cx.add_action(select_previous);
}
pub fn visual_motion(motion: Motion, times: Option<usize>, cx: &mut WindowContext) {
@@ -384,6 +390,50 @@ pub(crate) fn visual_replace(text: Arc<str>, cx: &mut WindowContext) {
});
}
+pub fn select_next(
+ _: &mut Workspace,
+ _: &SelectNext,
+ cx: &mut ViewContext<Workspace>,
+) -> Result<()> {
+ Vim::update(cx, |vim, cx| {
+ let count =
+ vim.take_count(cx)
+ .unwrap_or_else(|| if vim.state().mode.is_visual() { 1 } else { 2 });
+ vim.update_active_editor(cx, |editor, cx| {
+ for _ in 0..count {
+ match editor.select_next(&Default::default(), cx) {
+ Err(a) => return Err(a),
+ _ => {}
+ }
+ }
+ Ok(())
+ })
+ })
+ .unwrap_or(Ok(()))
+}
+
+pub fn select_previous(
+ _: &mut Workspace,
+ _: &SelectPrevious,
+ cx: &mut ViewContext<Workspace>,
+) -> Result<()> {
+ Vim::update(cx, |vim, cx| {
+ let count =
+ vim.take_count(cx)
+ .unwrap_or_else(|| if vim.state().mode.is_visual() { 1 } else { 2 });
+ vim.update_active_editor(cx, |editor, cx| {
+ for _ in 0..count {
+ match editor.select_previous(&Default::default(), cx) {
+ Err(a) => return Err(a),
+ _ => {}
+ }
+ }
+ Ok(())
+ })
+ })
+ .unwrap_or(Ok(()))
+}
+
#[cfg(test)]
mod test {
use indoc::indoc;
@@ -0,0 +1,6 @@
+{"Put":{"state":"Λa\nb\nc"}}
+{"Key":":"}
+{"Key":"j"}
+{"Key":"enter"}
+{"Key":"^"}
+{"Get":{"state":"Λa b\nc","mode":"Normal"}}
@@ -0,0 +1,5 @@
+{"Put":{"state":"Λa\nb\nc"}}
+{"Key":":"}
+{"Key":"3"}
+{"Key":"enter"}
+{"Get":{"state":"a\nb\nΛc","mode":"Normal"}}
@@ -0,0 +1,29 @@
+{"Put":{"state":"Λa\nb\nc"}}
+{"Key":":"}
+{"Key":"%"}
+{"Key":"s"}
+{"Key":"/"}
+{"Key":"b"}
+{"Key":"/"}
+{"Key":"d"}
+{"Key":"enter"}
+{"Get":{"state":"a\nΛd\nc","mode":"Normal"}}
+{"Key":":"}
+{"Key":"%"}
+{"Key":"s"}
+{"Key":":"}
+{"Key":"."}
+{"Key":":"}
+{"Key":"\\"}
+{"Key":"0"}
+{"Key":"\\"}
+{"Key":"0"}
+{"Key":"enter"}
+{"Get":{"state":"aa\ndd\nΛcc","mode":"Normal"}}
+{"Key":":"}
+{"Key":"%"}
+{"Key":"s"}
+{"Key":"/"}
+{"Key":"/"}
+{"Key":"/"}
+{"Key":"enter"}
@@ -0,0 +1,11 @@
+{"Put":{"state":"Λa\nb\na\nc"}}
+{"Key":":"}
+{"Key":"/"}
+{"Key":"b"}
+{"Key":"enter"}
+{"Get":{"state":"a\nΛb\na\nc","mode":"Normal"}}
+{"Key":":"}
+{"Key":"?"}
+{"Key":"a"}
+{"Key":"enter"}
+{"Get":{"state":"Λa\nb\na\nc","mode":"Normal"}}
@@ -475,11 +475,7 @@ impl<T: Item> ItemHandle for ViewHandle<T> {
match item_event {
ItemEvent::CloseItem => {
pane.update(cx, |pane, cx| {
- pane.close_item_by_id(
- item.id(),
- crate::SaveBehavior::PromptOnWrite,
- cx,
- )
+ pane.close_item_by_id(item.id(), crate::SaveIntent::Close, cx)
})
.detach_and_log_err(cx);
return;
@@ -42,18 +42,25 @@ use std::{
},
};
use theme::{Theme, ThemeSettings};
+use util::truncate_and_remove_front;
#[derive(PartialEq, Clone, Copy, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
-pub enum SaveBehavior {
- /// ask before overwriting conflicting files (used by default with %s)
- PromptOnConflict,
- /// ask before writing any file that wouldn't be auto-saved (used by default with %w)
- PromptOnWrite,
- /// never prompt, write on conflict (used with vim's :w!)
- SilentlyOverwrite,
- /// skip all save-related behaviour (used with vim's :cq)
- DontSave,
+pub enum SaveIntent {
+ /// write all files (even if unchanged)
+ /// prompt before overwriting on-disk changes
+ Save,
+ /// write any files that have local changes
+ /// prompt before overwriting on-disk changes
+ SaveAll,
+ /// always prompt for a new path
+ SaveAs,
+ /// prompt "you have unsaved changes" before writing
+ Close,
+ /// write all dirty files, don't prompt on conflict
+ Overwrite,
+ /// skip all save-related behavior
+ Skip,
}
#[derive(Clone, Deserialize, PartialEq)]
@@ -78,8 +85,15 @@ pub struct CloseItemsToTheRightById {
}
#[derive(Clone, PartialEq, Debug, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
pub struct CloseActiveItem {
- pub save_behavior: Option<SaveBehavior>,
+ pub save_intent: Option<SaveIntent>,
+}
+
+#[derive(Clone, PartialEq, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CloseAllItems {
+ pub save_intent: Option<SaveIntent>,
}
actions!(
@@ -92,7 +106,6 @@ actions!(
CloseCleanItems,
CloseItemsToTheLeft,
CloseItemsToTheRight,
- CloseAllItems,
GoBack,
GoForward,
ReopenClosedItem,
@@ -103,7 +116,7 @@ actions!(
]
);
-impl_actions!(pane, [ActivateItem, CloseActiveItem]);
+impl_actions!(pane, [ActivateItem, CloseActiveItem, CloseAllItems]);
const MAX_NAVIGATION_HISTORY_LEN: usize = 1024;
@@ -722,7 +735,7 @@ impl Pane {
let active_item_id = self.items[self.active_item_index].id();
Some(self.close_item_by_id(
active_item_id,
- action.save_behavior.unwrap_or(SaveBehavior::PromptOnWrite),
+ action.save_intent.unwrap_or(SaveIntent::Close),
cx,
))
}
@@ -730,12 +743,10 @@ impl Pane {
pub fn close_item_by_id(
&mut self,
item_id_to_close: usize,
- save_behavior: SaveBehavior,
+ save_intent: SaveIntent,
cx: &mut ViewContext<Self>,
) -> Task<Result<()>> {
- self.close_items(cx, save_behavior, move |view_id| {
- view_id == item_id_to_close
- })
+ self.close_items(cx, save_intent, move |view_id| view_id == item_id_to_close)
}
pub fn close_inactive_items(
@@ -748,11 +759,9 @@ impl Pane {
}
let active_item_id = self.items[self.active_item_index].id();
- Some(
- self.close_items(cx, SaveBehavior::PromptOnWrite, move |item_id| {
- item_id != active_item_id
- }),
- )
+ Some(self.close_items(cx, SaveIntent::Close, move |item_id| {
+ item_id != active_item_id
+ }))
}
pub fn close_clean_items(
@@ -765,11 +774,9 @@ impl Pane {
.filter(|item| !item.is_dirty(cx))
.map(|item| item.id())
.collect();
- Some(
- self.close_items(cx, SaveBehavior::PromptOnWrite, move |item_id| {
- item_ids.contains(&item_id)
- }),
- )
+ Some(self.close_items(cx, SaveIntent::Close, move |item_id| {
+ item_ids.contains(&item_id)
+ }))
}
pub fn close_items_to_the_left(
@@ -794,7 +801,7 @@ impl Pane {
.take_while(|item| item.id() != item_id)
.map(|item| item.id())
.collect();
- self.close_items(cx, SaveBehavior::PromptOnWrite, move |item_id| {
+ self.close_items(cx, SaveIntent::Close, move |item_id| {
item_ids.contains(&item_id)
})
}
@@ -822,27 +829,66 @@ impl Pane {
.take_while(|item| item.id() != item_id)
.map(|item| item.id())
.collect();
- self.close_items(cx, SaveBehavior::PromptOnWrite, move |item_id| {
+ self.close_items(cx, SaveIntent::Close, move |item_id| {
item_ids.contains(&item_id)
})
}
pub fn close_all_items(
&mut self,
- _: &CloseAllItems,
+ action: &CloseAllItems,
cx: &mut ViewContext<Self>,
) -> Option<Task<Result<()>>> {
if self.items.is_empty() {
return None;
}
- Some(self.close_items(cx, SaveBehavior::PromptOnWrite, |_| true))
+ Some(
+ self.close_items(cx, action.save_intent.unwrap_or(SaveIntent::Close), |_| {
+ true
+ }),
+ )
+ }
+
+ pub(super) fn file_names_for_prompt(
+ items: &mut dyn Iterator<Item = &Box<dyn ItemHandle>>,
+ all_dirty_items: usize,
+ cx: &AppContext,
+ ) -> String {
+ /// Quantity of item paths displayed in prompt prior to cutoff..
+ const FILE_NAMES_CUTOFF_POINT: usize = 10;
+ let mut file_names: Vec<_> = items
+ .filter_map(|item| {
+ item.project_path(cx).and_then(|project_path| {
+ project_path
+ .path
+ .file_name()
+ .and_then(|name| name.to_str().map(ToOwned::to_owned))
+ })
+ })
+ .take(FILE_NAMES_CUTOFF_POINT)
+ .collect();
+ let should_display_followup_text =
+ all_dirty_items > FILE_NAMES_CUTOFF_POINT || file_names.len() != all_dirty_items;
+ if should_display_followup_text {
+ let not_shown_files = all_dirty_items - file_names.len();
+ if not_shown_files == 1 {
+ file_names.push(".. 1 file not shown".into());
+ } else {
+ file_names.push(format!(".. {} files not shown", not_shown_files).into());
+ }
+ }
+ let file_names = file_names.join("\n");
+ format!(
+ "Do you want to save changes to the following {} files?\n{file_names}",
+ all_dirty_items
+ )
}
pub fn close_items(
&mut self,
cx: &mut ViewContext<Pane>,
- save_behavior: SaveBehavior,
+ mut save_intent: SaveIntent,
should_close: impl 'static + Fn(usize) -> bool,
) -> Task<Result<()>> {
// Find the items to close.
@@ -861,6 +907,25 @@ impl Pane {
let workspace = self.workspace.clone();
cx.spawn(|pane, mut cx| async move {
+ if save_intent == SaveIntent::Close && items_to_close.len() > 1 {
+ let mut answer = pane.update(&mut cx, |_, cx| {
+ let prompt = Self::file_names_for_prompt(
+ &mut items_to_close.iter(),
+ items_to_close.len(),
+ cx,
+ );
+ cx.prompt(
+ PromptLevel::Warning,
+ &prompt,
+ &["Save all", "Discard all", "Cancel"],
+ )
+ })?;
+ match answer.next().await {
+ Some(0) => save_intent = SaveIntent::Save,
+ Some(1) => save_intent = SaveIntent::Skip,
+ _ => {}
+ }
+ }
let mut saved_project_items_ids = HashSet::default();
for item in items_to_close.clone() {
// Find the item's current index and its set of project item models. Avoid
@@ -900,7 +965,7 @@ impl Pane {
&pane,
item_ix,
&*item,
- save_behavior,
+ save_intent,
&mut cx,
)
.await?
@@ -998,18 +1063,17 @@ impl Pane {
pane: &WeakViewHandle<Pane>,
item_ix: usize,
item: &dyn ItemHandle,
- save_behavior: SaveBehavior,
+ save_intent: SaveIntent,
cx: &mut AsyncAppContext,
) -> Result<bool> {
const CONFLICT_MESSAGE: &str =
"This file has changed on disk since you started editing it. Do you want to overwrite it?";
- const DIRTY_MESSAGE: &str = "This file contains unsaved edits. Do you want to save it?";
- if save_behavior == SaveBehavior::DontSave {
+ if save_intent == SaveIntent::Skip {
return Ok(true);
}
- let (has_conflict, is_dirty, can_save, is_singleton) = cx.read(|cx| {
+ let (mut has_conflict, mut is_dirty, mut can_save, can_save_as) = cx.read(|cx| {
(
item.has_conflict(cx),
item.is_dirty(cx),
@@ -1018,67 +1082,77 @@ impl Pane {
)
});
+ // when saving a single buffer, we ignore whether or not it's dirty.
+ if save_intent == SaveIntent::Save {
+ is_dirty = true;
+ }
+
+ if save_intent == SaveIntent::SaveAs {
+ is_dirty = true;
+ has_conflict = false;
+ can_save = false;
+ }
+
+ if save_intent == SaveIntent::Overwrite {
+ has_conflict = false;
+ }
+
if has_conflict && can_save {
- if save_behavior == SaveBehavior::SilentlyOverwrite {
- pane.update(cx, |_, cx| item.save(project, cx))?.await?;
- } else {
- let mut answer = pane.update(cx, |pane, cx| {
- pane.activate_item(item_ix, true, true, cx);
- cx.prompt(
- PromptLevel::Warning,
- CONFLICT_MESSAGE,
- &["Overwrite", "Discard", "Cancel"],
- )
- })?;
- match answer.next().await {
- Some(0) => pane.update(cx, |_, cx| item.save(project, cx))?.await?,
- Some(1) => pane.update(cx, |_, cx| item.reload(project, cx))?.await?,
- _ => return Ok(false),
- }
+ let mut answer = pane.update(cx, |pane, cx| {
+ pane.activate_item(item_ix, true, true, cx);
+ cx.prompt(
+ PromptLevel::Warning,
+ CONFLICT_MESSAGE,
+ &["Overwrite", "Discard", "Cancel"],
+ )
+ })?;
+ match answer.next().await {
+ Some(0) => pane.update(cx, |_, cx| item.save(project, cx))?.await?,
+ Some(1) => pane.update(cx, |_, cx| item.reload(project, cx))?.await?,
+ _ => return Ok(false),
}
- } else if is_dirty && (can_save || is_singleton) {
- let will_autosave = cx.read(|cx| {
- matches!(
- settings::get::<WorkspaceSettings>(cx).autosave,
- AutosaveSetting::OnFocusChange | AutosaveSetting::OnWindowChange
- ) && Self::can_autosave_item(&*item, cx)
- });
- let should_save = if save_behavior == SaveBehavior::PromptOnWrite && !will_autosave {
- let mut answer = pane.update(cx, |pane, cx| {
- pane.activate_item(item_ix, true, true, cx);
- cx.prompt(
- PromptLevel::Warning,
- DIRTY_MESSAGE,
- &["Save", "Don't Save", "Cancel"],
- )
- })?;
- match answer.next().await {
- Some(0) => true,
- Some(1) => false,
- _ => return Ok(false),
+ } else if is_dirty && (can_save || can_save_as) {
+ if save_intent == SaveIntent::Close {
+ let will_autosave = cx.read(|cx| {
+ matches!(
+ settings::get::<WorkspaceSettings>(cx).autosave,
+ AutosaveSetting::OnFocusChange | AutosaveSetting::OnWindowChange
+ ) && Self::can_autosave_item(&*item, cx)
+ });
+ if !will_autosave {
+ let mut answer = pane.update(cx, |pane, cx| {
+ pane.activate_item(item_ix, true, true, cx);
+ let prompt = dirty_message_for(item.project_path(cx));
+ cx.prompt(
+ PromptLevel::Warning,
+ &prompt,
+ &["Save", "Don't Save", "Cancel"],
+ )
+ })?;
+ match answer.next().await {
+ Some(0) => {}
+ Some(1) => return Ok(true), // Don't save his file
+ _ => return Ok(false), // Cancel
+ }
}
- } else {
- true
- };
+ }
- if should_save {
- if can_save {
- pane.update(cx, |_, cx| item.save(project, cx))?.await?;
- } else if is_singleton {
- let start_abs_path = project
- .read_with(cx, |project, cx| {
- let worktree = project.visible_worktrees(cx).next()?;
- Some(worktree.read(cx).as_local()?.abs_path().to_path_buf())
- })
- .unwrap_or_else(|| Path::new("").into());
+ if can_save {
+ pane.update(cx, |_, cx| item.save(project, cx))?.await?;
+ } else if can_save_as {
+ let start_abs_path = project
+ .read_with(cx, |project, cx| {
+ let worktree = project.visible_worktrees(cx).next()?;
+ Some(worktree.read(cx).as_local()?.abs_path().to_path_buf())
+ })
+ .unwrap_or_else(|| Path::new("").into());
- let mut abs_path = cx.update(|cx| cx.prompt_for_new_path(&start_abs_path));
- if let Some(abs_path) = abs_path.next().await.flatten() {
- pane.update(cx, |_, cx| item.save_as(project, abs_path, cx))?
- .await?;
- } else {
- return Ok(false);
- }
+ let mut abs_path = cx.update(|cx| cx.prompt_for_new_path(&start_abs_path));
+ if let Some(abs_path) = abs_path.next().await.flatten() {
+ pane.update(cx, |_, cx| item.save_as(project, abs_path, cx))?
+ .await?;
+ } else {
+ return Ok(false);
}
}
}
@@ -1167,15 +1241,16 @@ impl Pane {
vec![
ContextMenuItem::action(
"Close Active Item",
- CloseActiveItem {
- save_behavior: None,
- },
+ CloseActiveItem { save_intent: None },
),
ContextMenuItem::action("Close Inactive Items", CloseInactiveItems),
ContextMenuItem::action("Close Clean Items", CloseCleanItems),
ContextMenuItem::action("Close Items To The Left", CloseItemsToTheLeft),
ContextMenuItem::action("Close Items To The Right", CloseItemsToTheRight),
- ContextMenuItem::action("Close All Items", CloseAllItems),
+ ContextMenuItem::action(
+ "Close All Items",
+ CloseAllItems { save_intent: None },
+ ),
]
} else {
// In the case of the user right clicking on a non-active tab, for some item-closing commands, we need to provide the id of the tab, for the others, we can reuse the existing command.
@@ -1187,7 +1262,7 @@ impl Pane {
pane.update(cx, |pane, cx| {
pane.close_item_by_id(
target_item_id,
- SaveBehavior::PromptOnWrite,
+ SaveIntent::Close,
cx,
)
.detach_and_log_err(cx);
@@ -1219,7 +1294,10 @@ impl Pane {
}
}
}),
- ContextMenuItem::action("Close All Items", CloseAllItems),
+ ContextMenuItem::action(
+ "Close All Items",
+ CloseAllItems { save_intent: None },
+ ),
]
},
cx,
@@ -1339,12 +1417,8 @@ impl Pane {
.on_click(MouseButton::Middle, {
let item_id = item.id();
move |_, pane, cx| {
- pane.close_item_by_id(
- item_id,
- SaveBehavior::PromptOnWrite,
- cx,
- )
- .detach_and_log_err(cx);
+ pane.close_item_by_id(item_id, SaveIntent::Close, cx)
+ .detach_and_log_err(cx);
}
})
.on_down(
@@ -1552,7 +1626,7 @@ impl Pane {
cx.window_context().defer(move |cx| {
if let Some(pane) = pane.upgrade(cx) {
pane.update(cx, |pane, cx| {
- pane.close_item_by_id(item_id, SaveBehavior::PromptOnWrite, cx)
+ pane.close_item_by_id(item_id, SaveIntent::Close, cx)
.detach_and_log_err(cx);
});
}
@@ -2135,6 +2209,15 @@ impl<V: 'static> Element<V> for PaneBackdrop<V> {
}
}
+fn dirty_message_for(buffer_path: Option<ProjectPath>) -> String {
+ let path = buffer_path
+ .as_ref()
+ .and_then(|p| p.path.to_str())
+ .unwrap_or(&"Untitled buffer");
+ let path = truncate_and_remove_front(path, 80);
+ format!("{path} contains unsaved edits. Do you want to save it?")
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -2155,12 +2238,7 @@ mod tests {
pane.update(cx, |pane, cx| {
assert!(pane
- .close_active_item(
- &CloseActiveItem {
- save_behavior: None
- },
- cx
- )
+ .close_active_item(&CloseActiveItem { save_intent: None }, cx)
.is_none())
});
}
@@ -2412,12 +2490,7 @@ mod tests {
assert_item_labels(&pane, ["A", "B", "1*", "C", "D"], cx);
pane.update(cx, |pane, cx| {
- pane.close_active_item(
- &CloseActiveItem {
- save_behavior: None,
- },
- cx,
- )
+ pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
})
.unwrap()
.await
@@ -2428,12 +2501,7 @@ mod tests {
assert_item_labels(&pane, ["A", "B", "C", "D*"], cx);
pane.update(cx, |pane, cx| {
- pane.close_active_item(
- &CloseActiveItem {
- save_behavior: None,
- },
- cx,
- )
+ pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
})
.unwrap()
.await
@@ -2441,12 +2509,7 @@ mod tests {
assert_item_labels(&pane, ["A", "B*", "C"], cx);
pane.update(cx, |pane, cx| {
- pane.close_active_item(
- &CloseActiveItem {
- save_behavior: None,
- },
- cx,
- )
+ pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
})
.unwrap()
.await
@@ -2454,12 +2517,7 @@ mod tests {
assert_item_labels(&pane, ["A", "C*"], cx);
pane.update(cx, |pane, cx| {
- pane.close_active_item(
- &CloseActiveItem {
- save_behavior: None,
- },
- cx,
- )
+ pane.close_active_item(&CloseActiveItem { save_intent: None }, cx)
})
.unwrap()
.await
@@ -2479,12 +2537,14 @@ mod tests {
set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
- pane.update(cx, |pane, cx| {
- pane.close_inactive_items(&CloseInactiveItems, cx)
- })
- .unwrap()
- .await
- .unwrap();
+ let task = pane
+ .update(cx, |pane, cx| {
+ pane.close_inactive_items(&CloseInactiveItems, cx)
+ })
+ .unwrap();
+ cx.foreground().run_until_parked();
+ window.simulate_prompt_answer(2, cx);
+ task.await.unwrap();
assert_item_labels(&pane, ["C*"], cx);
}
@@ -2505,10 +2565,12 @@ mod tests {
add_labeled_item(&pane, "E", false, cx);
assert_item_labels(&pane, ["A^", "B", "C^", "D", "E*"], cx);
- pane.update(cx, |pane, cx| pane.close_clean_items(&CloseCleanItems, cx))
- .unwrap()
- .await
+ let task = pane
+ .update(cx, |pane, cx| pane.close_clean_items(&CloseCleanItems, cx))
.unwrap();
+ cx.foreground().run_until_parked();
+ window.simulate_prompt_answer(2, cx);
+ task.await.unwrap();
assert_item_labels(&pane, ["A^", "C*^"], cx);
}
@@ -2524,12 +2586,14 @@ mod tests {
set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
- pane.update(cx, |pane, cx| {
- pane.close_items_to_the_left(&CloseItemsToTheLeft, cx)
- })
- .unwrap()
- .await
- .unwrap();
+ let task = pane
+ .update(cx, |pane, cx| {
+ pane.close_items_to_the_left(&CloseItemsToTheLeft, cx)
+ })
+ .unwrap();
+ cx.foreground().run_until_parked();
+ window.simulate_prompt_answer(2, cx);
+ task.await.unwrap();
assert_item_labels(&pane, ["C*", "D", "E"], cx);
}
@@ -2545,12 +2609,14 @@ mod tests {
set_labeled_items(&pane, ["A", "B", "C*", "D", "E"], cx);
- pane.update(cx, |pane, cx| {
- pane.close_items_to_the_right(&CloseItemsToTheRight, cx)
- })
- .unwrap()
- .await
- .unwrap();
+ let task = pane
+ .update(cx, |pane, cx| {
+ pane.close_items_to_the_right(&CloseItemsToTheRight, cx)
+ })
+ .unwrap();
+ cx.foreground().run_until_parked();
+ window.simulate_prompt_answer(2, cx);
+ task.await.unwrap();
assert_item_labels(&pane, ["A", "B", "C*"], cx);
}
@@ -2569,10 +2635,14 @@ mod tests {
add_labeled_item(&pane, "C", false, cx);
assert_item_labels(&pane, ["A", "B", "C*"], cx);
- pane.update(cx, |pane, cx| pane.close_all_items(&CloseAllItems, cx))
- .unwrap()
- .await
+ let t = pane
+ .update(cx, |pane, cx| {
+ pane.close_all_items(&CloseAllItems { save_intent: None }, cx)
+ })
.unwrap();
+ cx.foreground().run_until_parked();
+ window.simulate_prompt_answer(2, cx);
+ t.await.unwrap();
assert_item_labels(&pane, [], cx);
}
@@ -126,9 +126,8 @@ actions!(
CloseInactiveTabsAndPanes,
AddFolderToProject,
Unfollow,
- Save,
SaveAs,
- SaveAll,
+ ReloadActiveItem,
ActivatePreviousPane,
ActivateNextPane,
FollowNextCollaborator,
@@ -158,6 +157,27 @@ pub struct ActivatePane(pub usize);
#[derive(Clone, Deserialize, PartialEq)]
pub struct ActivatePaneInDirection(pub SplitDirection);
+#[derive(Clone, Deserialize, PartialEq)]
+pub struct NewFileInDirection(pub SplitDirection);
+
+#[derive(Clone, PartialEq, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveAll {
+ pub save_intent: Option<SaveIntent>,
+}
+
+#[derive(Clone, PartialEq, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Save {
+ pub save_intent: Option<SaveIntent>,
+}
+
+#[derive(Clone, PartialEq, Debug, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct CloseAllItemsAndPanes {
+ pub save_intent: Option<SaveIntent>,
+}
+
#[derive(Deserialize)]
pub struct Toast {
id: usize,
@@ -210,7 +230,16 @@ pub struct OpenTerminal {
impl_actions!(
workspace,
- [ActivatePane, ActivatePaneInDirection, Toast, OpenTerminal]
+ [
+ ActivatePane,
+ ActivatePaneInDirection,
+ NewFileInDirection,
+ Toast,
+ OpenTerminal,
+ SaveAll,
+ Save,
+ CloseAllItemsAndPanes,
+ ]
);
pub type WorkspaceId = i64;
@@ -251,6 +280,7 @@ pub fn init(app_state: Arc<AppState>, cx: &mut AppContext) {
cx.add_async_action(Workspace::follow_next_collaborator);
cx.add_async_action(Workspace::close);
cx.add_async_action(Workspace::close_inactive_items_and_panes);
+ cx.add_async_action(Workspace::close_all_items_and_panes);
cx.add_global_action(Workspace::close_global);
cx.add_global_action(restart);
cx.add_async_action(Workspace::save_all);
@@ -262,13 +292,17 @@ pub fn init(app_state: Arc<AppState>, cx: &mut AppContext) {
},
);
cx.add_action(
- |workspace: &mut Workspace, _: &Save, cx: &mut ViewContext<Workspace>| {
- workspace.save_active_item(false, cx).detach_and_log_err(cx);
+ |workspace: &mut Workspace, action: &Save, cx: &mut ViewContext<Workspace>| {
+ workspace
+ .save_active_item(action.save_intent.unwrap_or(SaveIntent::Save), cx)
+ .detach_and_log_err(cx);
},
);
cx.add_action(
|workspace: &mut Workspace, _: &SaveAs, cx: &mut ViewContext<Workspace>| {
- workspace.save_active_item(true, cx).detach_and_log_err(cx);
+ workspace
+ .save_active_item(SaveIntent::SaveAs, cx)
+ .detach_and_log_err(cx);
},
);
cx.add_action(|workspace: &mut Workspace, _: &ActivatePreviousPane, cx| {
@@ -1317,14 +1351,19 @@ impl Workspace {
Ok(this
.update(&mut cx, |this, cx| {
- this.save_all_internal(SaveBehavior::PromptOnWrite, cx)
+ this.save_all_internal(SaveIntent::Close, cx)
})?
.await?)
})
}
- fn save_all(&mut self, _: &SaveAll, cx: &mut ViewContext<Self>) -> Option<Task<Result<()>>> {
- let save_all = self.save_all_internal(SaveBehavior::PromptOnConflict, cx);
+ fn save_all(
+ &mut self,
+ action: &SaveAll,
+ cx: &mut ViewContext<Self>,
+ ) -> Option<Task<Result<()>>> {
+ let save_all =
+ self.save_all_internal(action.save_intent.unwrap_or(SaveIntent::SaveAll), cx);
Some(cx.foreground().spawn(async move {
save_all.await?;
Ok(())
@@ -1333,13 +1372,12 @@ impl Workspace {
fn save_all_internal(
&mut self,
- save_behaviour: SaveBehavior,
+ mut save_intent: SaveIntent,
cx: &mut ViewContext<Self>,
) -> Task<Result<bool>> {
if self.project.read(cx).is_read_only() {
return Task::ready(Ok(true));
}
-
let dirty_items = self
.panes
.iter()
@@ -1355,7 +1393,27 @@ impl Workspace {
.collect::<Vec<_>>();
let project = self.project.clone();
- cx.spawn(|_, mut cx| async move {
+ cx.spawn(|workspace, mut cx| async move {
+ // Override save mode and display "Save all files" prompt
+ if save_intent == SaveIntent::Close && dirty_items.len() > 1 {
+ let mut answer = workspace.update(&mut cx, |_, cx| {
+ let prompt = Pane::file_names_for_prompt(
+ &mut dirty_items.iter().map(|(_, handle)| handle),
+ dirty_items.len(),
+ cx,
+ );
+ cx.prompt(
+ PromptLevel::Warning,
+ &prompt,
+ &["Save all", "Discard all", "Cancel"],
+ )
+ })?;
+ match answer.next().await {
+ Some(0) => save_intent = SaveIntent::Save,
+ Some(1) => save_intent = SaveIntent::Skip,
+ _ => {}
+ }
+ }
for (pane, item) in dirty_items {
let (singleton, project_entry_ids) =
cx.read(|cx| (item.is_singleton(cx), item.project_entry_ids(cx)));
@@ -1368,7 +1426,7 @@ impl Workspace {
&pane,
ix,
&*item,
- save_behaviour,
+ save_intent,
&mut cx,
)
.await?
@@ -1640,75 +1698,72 @@ impl Workspace {
pub fn save_active_item(
&mut self,
- force_name_change: bool,
+ save_intent: SaveIntent,
cx: &mut ViewContext<Self>,
) -> Task<Result<()>> {
let project = self.project.clone();
- if let Some(item) = self.active_item(cx) {
- if !force_name_change && item.can_save(cx) {
- if item.has_conflict(cx) {
- const CONFLICT_MESSAGE: &str = "This file has changed on disk since you started editing it. Do you want to overwrite it?";
+ let pane = self.active_pane();
+ let item_ix = pane.read(cx).active_item_index();
+ let item = pane.read(cx).active_item();
+ let pane = pane.downgrade();
- let mut answer = cx.prompt(
- PromptLevel::Warning,
- CONFLICT_MESSAGE,
- &["Overwrite", "Cancel"],
- );
- cx.spawn(|this, mut cx| async move {
- let answer = answer.recv().await;
- if answer == Some(0) {
- this.update(&mut cx, |this, cx| item.save(this.project.clone(), cx))?
- .await?;
- }
- Ok(())
- })
- } else {
- item.save(self.project.clone(), cx)
- }
- } else if item.is_singleton(cx) {
- let worktree = self.worktrees(cx).next();
- let start_abs_path = worktree
- .and_then(|w| w.read(cx).as_local())
- .map_or(Path::new(""), |w| w.abs_path())
- .to_path_buf();
- let mut abs_path = cx.prompt_for_new_path(&start_abs_path);
- cx.spawn(|this, mut cx| async move {
- if let Some(abs_path) = abs_path.recv().await.flatten() {
- this.update(&mut cx, |_, cx| item.save_as(project, abs_path, cx))?
- .await?;
- }
- Ok(())
- })
+ cx.spawn(|_, mut cx| async move {
+ if let Some(item) = item {
+ Pane::save_item(project, &pane, item_ix, item.as_ref(), save_intent, &mut cx)
+ .await
+ .map(|_| ())
} else {
- Task::ready(Ok(()))
+ Ok(())
}
- } else {
- Task::ready(Ok(()))
- }
+ })
}
pub fn close_inactive_items_and_panes(
&mut self,
_: &CloseInactiveTabsAndPanes,
cx: &mut ViewContext<Self>,
+ ) -> Option<Task<Result<()>>> {
+ self.close_all_internal(true, SaveIntent::Close, cx)
+ }
+
+ pub fn close_all_items_and_panes(
+ &mut self,
+ action: &CloseAllItemsAndPanes,
+ cx: &mut ViewContext<Self>,
+ ) -> Option<Task<Result<()>>> {
+ self.close_all_internal(false, action.save_intent.unwrap_or(SaveIntent::Close), cx)
+ }
+
+ fn close_all_internal(
+ &mut self,
+ retain_active_pane: bool,
+ save_intent: SaveIntent,
+ cx: &mut ViewContext<Self>,
) -> Option<Task<Result<()>>> {
let current_pane = self.active_pane();
let mut tasks = Vec::new();
- if let Some(current_pane_close) = current_pane.update(cx, |pane, cx| {
- pane.close_inactive_items(&CloseInactiveItems, cx)
- }) {
- tasks.push(current_pane_close);
- };
+ if retain_active_pane {
+ if let Some(current_pane_close) = current_pane.update(cx, |pane, cx| {
+ pane.close_inactive_items(&CloseInactiveItems, cx)
+ }) {
+ tasks.push(current_pane_close);
+ };
+ }
for pane in self.panes() {
- if pane.id() == current_pane.id() {
+ if retain_active_pane && pane.id() == current_pane.id() {
continue;
}
if let Some(close_pane_items) = pane.update(cx, |pane: &mut Pane, cx| {
- pane.close_all_items(&CloseAllItems, cx)
+ pane.close_all_items(
+ &CloseAllItems {
+ save_intent: Some(save_intent),
+ },
+ cx,
+ )
}) {
tasks.push(close_pane_items)
}
@@ -1939,8 +1994,13 @@ impl Workspace {
.update(cx, |pane, cx| pane.add_item(item, true, true, None, cx));
}
- pub fn split_item(&mut self, item: Box<dyn ItemHandle>, cx: &mut ViewContext<Self>) {
- let new_pane = self.split_pane(self.active_pane.clone(), SplitDirection::Right, cx);
+ pub fn split_item(
+ &mut self,
+ split_direction: SplitDirection,
+ item: Box<dyn ItemHandle>,
+ cx: &mut ViewContext<Self>,
+ ) {
+ let new_pane = self.split_pane(self.active_pane.clone(), split_direction, cx);
new_pane.update(cx, move |new_pane, cx| {
new_pane.add_item(item, true, true, None, cx)
})
@@ -2118,7 +2178,7 @@ impl Workspace {
}
let item = cx.add_view(|cx| T::for_project_item(self.project().clone(), project_item, cx));
- self.split_item(Box::new(item.clone()), cx);
+ self.split_item(SplitDirection::Right, Box::new(item.clone()), cx);
item
}
@@ -4320,7 +4380,9 @@ mod tests {
});
let task = workspace.update(cx, |w, cx| w.prepare_to_close(false, cx));
cx.foreground().run_until_parked();
- window.simulate_prompt_answer(2, cx); // cancel
+ window.simulate_prompt_answer(2, cx); // cancel save all
+ cx.foreground().run_until_parked();
+ window.simulate_prompt_answer(2, cx); // cancel save all
cx.foreground().run_until_parked();
assert!(!window.has_pending_prompt(cx));
assert!(!task.await.unwrap());
@@ -4372,19 +4434,21 @@ mod tests {
let item1_id = item1.id();
let item3_id = item3.id();
let item4_id = item4.id();
- pane.close_items(cx, SaveBehavior::PromptOnWrite, move |id| {
+ pane.close_items(cx, SaveIntent::Close, move |id| {
[item1_id, item3_id, item4_id].contains(&id)
})
});
cx.foreground().run_until_parked();
+ assert!(window.has_pending_prompt(cx));
+ // Ignore "Save all" prompt
+ window.simulate_prompt_answer(2, cx);
+ cx.foreground().run_until_parked();
// There's a prompt to save item 1.
pane.read_with(cx, |pane, _| {
assert_eq!(pane.items_len(), 4);
assert_eq!(pane.active_item().unwrap().id(), item1.id());
});
- assert!(window.has_pending_prompt(cx));
-
// Confirm saving item 1.
window.simulate_prompt_answer(0, cx);
cx.foreground().run_until_parked();
@@ -4510,8 +4574,12 @@ mod tests {
// prompts, the task should complete.
let close = left_pane.update(cx, |pane, cx| {
- pane.close_items(cx, SaveBehavior::PromptOnWrite, move |_| true)
+ pane.close_items(cx, SaveIntent::Close, move |_| true)
});
+ cx.foreground().run_until_parked();
+ // Discard "Save all" prompt
+ window.simulate_prompt_answer(2, cx);
+
cx.foreground().run_until_parked();
left_pane.read_with(cx, |pane, cx| {
assert_eq!(
@@ -4628,7 +4696,7 @@ mod tests {
});
pane.update(cx, |pane, cx| {
- pane.close_items(cx, SaveBehavior::PromptOnWrite, move |id| id == item_id)
+ pane.close_items(cx, SaveIntent::Close, move |id| id == item_id)
})
.await
.unwrap();
@@ -4651,7 +4719,7 @@ mod tests {
// Ensure autosave is prevented for deleted files also when closing the buffer.
let _close_items = pane.update(cx, |pane, cx| {
- pane.close_items(cx, SaveBehavior::PromptOnWrite, move |id| id == item_id)
+ pane.close_items(cx, SaveIntent::Close, move |id| id == item_id)
});
deterministic.run_until_parked();
assert!(window.has_pending_prompt(cx));
@@ -62,6 +62,7 @@ rpc = { path = "../rpc" }
settings = { path = "../settings" }
feature_flags = { path = "../feature_flags" }
sum_tree = { path = "../sum_tree" }
+shellexpand = "2.1.0"
text = { path = "../text" }
terminal_view = { path = "../terminal_view" }
theme = { path = "../theme" }
@@ -99,6 +100,7 @@ rust-embed.workspace = true
serde.workspace = true
serde_derive.workspace = true
serde_json.workspace = true
+schemars.workspace = true
simplelog = "0.9"
smallvec.workspace = true
smol.workspace = true
@@ -1,13 +1,17 @@
use anyhow::Context;
+use gpui::AppContext;
pub use language::*;
use node_runtime::NodeRuntime;
use rust_embed::RustEmbed;
use std::{borrow::Cow, str, sync::Arc};
use util::asset_str;
+use self::elixir_next::ElixirSettings;
+
mod c;
mod css;
mod elixir;
+mod elixir_next;
mod go;
mod html;
mod json;
@@ -37,7 +41,13 @@ mod yaml;
#[exclude = "*.rs"]
struct LanguageDir;
-pub fn init(languages: Arc<LanguageRegistry>, node_runtime: Arc<dyn NodeRuntime>) {
+pub fn init(
+ languages: Arc<LanguageRegistry>,
+ node_runtime: Arc<dyn NodeRuntime>,
+ cx: &mut AppContext,
+) {
+ settings::register::<elixir_next::ElixirSettings>(cx);
+
let language = |name, grammar, adapters| {
languages.register(name, load_config(name), grammar, adapters, load_queries)
};
@@ -61,11 +71,28 @@ pub fn init(languages: Arc<LanguageRegistry>, node_runtime: Arc<dyn NodeRuntime>
Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
],
);
- language(
- "elixir",
- tree_sitter_elixir::language(),
- vec![Arc::new(elixir::ElixirLspAdapter)],
- );
+
+ match &settings::get::<ElixirSettings>(cx).next {
+ elixir_next::ElixirNextSetting::Off => language(
+ "elixir",
+ tree_sitter_elixir::language(),
+ vec![Arc::new(elixir::ElixirLspAdapter)],
+ ),
+ elixir_next::ElixirNextSetting::On => language(
+ "elixir",
+ tree_sitter_elixir::language(),
+ vec![Arc::new(elixir_next::NextLspAdapter)],
+ ),
+ elixir_next::ElixirNextSetting::Local { path, arguments } => language(
+ "elixir",
+ tree_sitter_elixir::language(),
+ vec![Arc::new(elixir_next::LocalNextLspAdapter {
+ path: path.clone(),
+ arguments: arguments.clone(),
+ })],
+ ),
+ }
+
language(
"go",
tree_sitter_go::language(),
@@ -0,0 +1,266 @@
+use anyhow::{anyhow, bail, Result};
+
+use async_trait::async_trait;
+pub use language::*;
+use lsp::{LanguageServerBinary, SymbolKind};
+use schemars::JsonSchema;
+use serde_derive::{Deserialize, Serialize};
+use settings::Setting;
+use smol::{fs, stream::StreamExt};
+use std::{any::Any, env::consts, ops::Deref, path::PathBuf, sync::Arc};
+use util::{
+ async_iife,
+ github::{latest_github_release, GitHubLspBinaryVersion},
+ ResultExt,
+};
+
+#[derive(Clone, Serialize, Deserialize, JsonSchema)]
+pub struct ElixirSettings {
+ pub next: ElixirNextSetting,
+}
+
+#[derive(Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum ElixirNextSetting {
+ Off,
+ On,
+ Local {
+ path: String,
+ arguments: Vec<String>,
+ },
+}
+
+#[derive(Clone, Serialize, Default, Deserialize, JsonSchema)]
+pub struct ElixirSettingsContent {
+ next: Option<ElixirNextSetting>,
+}
+
+impl Setting for ElixirSettings {
+ const KEY: Option<&'static str> = Some("elixir");
+
+ type FileContent = ElixirSettingsContent;
+
+ fn load(
+ default_value: &Self::FileContent,
+ user_values: &[&Self::FileContent],
+ _: &gpui::AppContext,
+ ) -> Result<Self>
+ where
+ Self: Sized,
+ {
+ Self::load_via_json_merge(default_value, user_values)
+ }
+}
+
+pub struct NextLspAdapter;
+
+#[async_trait]
+impl LspAdapter for NextLspAdapter {
+ async fn name(&self) -> LanguageServerName {
+ LanguageServerName("next-ls".into())
+ }
+
+ fn short_name(&self) -> &'static str {
+ "next-ls"
+ }
+
+ async fn fetch_latest_server_version(
+ &self,
+ delegate: &dyn LspAdapterDelegate,
+ ) -> Result<Box<dyn 'static + Send + Any>> {
+ let release =
+ latest_github_release("elixir-tools/next-ls", false, delegate.http_client()).await?;
+ let version = release.name.clone();
+ let platform = match consts::ARCH {
+ "x86_64" => "darwin_arm64",
+ "aarch64" => "darwin_amd64",
+ other => bail!("Running on unsupported platform: {other}"),
+ };
+ let asset_name = format!("next_ls_{}", platform);
+ let asset = release
+ .assets
+ .iter()
+ .find(|asset| asset.name == asset_name)
+ .ok_or_else(|| anyhow!("no asset found matching {:?}", asset_name))?;
+ let version = GitHubLspBinaryVersion {
+ name: version,
+ url: asset.browser_download_url.clone(),
+ };
+ Ok(Box::new(version) as Box<_>)
+ }
+
+ async fn fetch_server_binary(
+ &self,
+ version: Box<dyn 'static + Send + Any>,
+ container_dir: PathBuf,
+ delegate: &dyn LspAdapterDelegate,
+ ) -> Result<LanguageServerBinary> {
+ let version = version.downcast::<GitHubLspBinaryVersion>().unwrap();
+
+ let binary_path = container_dir.join("next-ls");
+
+ if fs::metadata(&binary_path).await.is_err() {
+ let mut response = delegate
+ .http_client()
+ .get(&version.url, Default::default(), true)
+ .await
+ .map_err(|err| anyhow!("error downloading release: {}", err))?;
+
+ let mut file = smol::fs::File::create(&binary_path).await?;
+ if !response.status().is_success() {
+ Err(anyhow!(
+ "download failed with status {}",
+ response.status().to_string()
+ ))?;
+ }
+ futures::io::copy(response.body_mut(), &mut file).await?;
+
+ fs::set_permissions(
+ &binary_path,
+ <fs::Permissions as fs::unix::PermissionsExt>::from_mode(0o755),
+ )
+ .await?;
+ }
+
+ Ok(LanguageServerBinary {
+ path: binary_path,
+ arguments: vec!["--stdio".into()],
+ })
+ }
+
+ async fn cached_server_binary(
+ &self,
+ container_dir: PathBuf,
+ _: &dyn LspAdapterDelegate,
+ ) -> Option<LanguageServerBinary> {
+ get_cached_server_binary(container_dir)
+ .await
+ .map(|mut binary| {
+ binary.arguments = vec!["--stdio".into()];
+ binary
+ })
+ }
+
+ async fn installation_test_binary(
+ &self,
+ container_dir: PathBuf,
+ ) -> Option<LanguageServerBinary> {
+ get_cached_server_binary(container_dir)
+ .await
+ .map(|mut binary| {
+ binary.arguments = vec!["--help".into()];
+ binary
+ })
+ }
+
+ async fn label_for_symbol(
+ &self,
+ name: &str,
+ symbol_kind: SymbolKind,
+ language: &Arc<Language>,
+ ) -> Option<CodeLabel> {
+ label_for_symbol_next(name, symbol_kind, language)
+ }
+}
+
+async fn get_cached_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
+ async_iife!({
+ let mut last_binary_path = None;
+ let mut entries = fs::read_dir(&container_dir).await?;
+ while let Some(entry) = entries.next().await {
+ let entry = entry?;
+ if entry.file_type().await?.is_file()
+ && entry
+ .file_name()
+ .to_str()
+ .map_or(false, |name| name == "next-ls")
+ {
+ last_binary_path = Some(entry.path());
+ }
+ }
+
+ if let Some(path) = last_binary_path {
+ Ok(LanguageServerBinary {
+ path,
+ arguments: Vec::new(),
+ })
+ } else {
+ Err(anyhow!("no cached binary"))
+ }
+ })
+ .await
+ .log_err()
+}
+
+pub struct LocalNextLspAdapter {
+ pub path: String,
+ pub arguments: Vec<String>,
+}
+
+#[async_trait]
+impl LspAdapter for LocalNextLspAdapter {
+ async fn name(&self) -> LanguageServerName {
+ LanguageServerName("local-next-ls".into())
+ }
+
+ fn short_name(&self) -> &'static str {
+ "next-ls"
+ }
+
+ async fn fetch_latest_server_version(
+ &self,
+ _: &dyn LspAdapterDelegate,
+ ) -> Result<Box<dyn 'static + Send + Any>> {
+ Ok(Box::new(()) as Box<_>)
+ }
+
+ async fn fetch_server_binary(
+ &self,
+ _: Box<dyn 'static + Send + Any>,
+ _: PathBuf,
+ _: &dyn LspAdapterDelegate,
+ ) -> Result<LanguageServerBinary> {
+ let path = shellexpand::full(&self.path)?;
+ Ok(LanguageServerBinary {
+ path: PathBuf::from(path.deref()),
+ arguments: self.arguments.iter().map(|arg| arg.into()).collect(),
+ })
+ }
+
+ async fn cached_server_binary(
+ &self,
+ _: PathBuf,
+ _: &dyn LspAdapterDelegate,
+ ) -> Option<LanguageServerBinary> {
+ let path = shellexpand::full(&self.path).ok()?;
+ Some(LanguageServerBinary {
+ path: PathBuf::from(path.deref()),
+ arguments: self.arguments.iter().map(|arg| arg.into()).collect(),
+ })
+ }
+
+ async fn installation_test_binary(&self, _: PathBuf) -> Option<LanguageServerBinary> {
+ let path = shellexpand::full(&self.path).ok()?;
+ Some(LanguageServerBinary {
+ path: PathBuf::from(path.deref()),
+ arguments: self.arguments.iter().map(|arg| arg.into()).collect(),
+ })
+ }
+
+ async fn label_for_symbol(
+ &self,
+ name: &str,
+ symbol: SymbolKind,
+ language: &Arc<Language>,
+ ) -> Option<CodeLabel> {
+ label_for_symbol_next(name, symbol, language)
+ }
+}
+
+fn label_for_symbol_next(name: &str, _: SymbolKind, language: &Arc<Language>) -> Option<CodeLabel> {
+ Some(CodeLabel {
+ runs: language.highlight_text(&name.into(), 0..name.len()),
+ text: name.to_string(),
+ filter_range: 0..name.len(),
+ })
+}
@@ -135,7 +135,7 @@ fn main() {
let languages = Arc::new(languages);
let node_runtime = RealNodeRuntime::new(http.clone());
- languages::init(languages.clone(), node_runtime.clone());
+ languages::init(languages.clone(), node_runtime.clone(), cx);
let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http.clone(), cx));
let channel_store =
cx.add_model(|cx| ChannelStore::new(client.clone(), user_store.clone(), cx));
@@ -38,14 +38,12 @@ pub fn menus() -> Vec<Menu<'static>> {
MenuItem::action("Open Recent...", recent_projects::OpenRecent),
MenuItem::separator(),
MenuItem::action("Add Folder to Projectβ¦", workspace::AddFolderToProject),
- MenuItem::action("Save", workspace::Save),
+ MenuItem::action("Save", workspace::Save { save_intent: None }),
MenuItem::action("Save Asβ¦", workspace::SaveAs),
- MenuItem::action("Save All", workspace::SaveAll),
+ MenuItem::action("Save All", workspace::SaveAll { save_intent: None }),
MenuItem::action(
"Close Editor",
- workspace::CloseActiveItem {
- save_behavior: None,
- },
+ workspace::CloseActiveItem { save_intent: None },
),
MenuItem::action("Close Window", workspace::CloseWindow),
],
@@ -744,7 +744,7 @@ mod tests {
use theme::{ThemeRegistry, ThemeSettings};
use workspace::{
item::{Item, ItemHandle},
- open_new, open_paths, pane, NewFile, SaveBehavior, SplitDirection, WorkspaceHandle,
+ open_new, open_paths, pane, NewFile, SaveIntent, SplitDirection, WorkspaceHandle,
};
#[gpui::test]
@@ -945,10 +945,14 @@ mod tests {
editor.update(cx, |editor, cx| {
assert!(editor.text(cx).is_empty());
+ assert!(!editor.is_dirty(cx));
});
- let save_task = workspace.update(cx, |workspace, cx| workspace.save_active_item(false, cx));
+ let save_task = workspace.update(cx, |workspace, cx| {
+ workspace.save_active_item(SaveIntent::Save, cx)
+ });
app_state.fs.create_dir(Path::new("/root")).await.unwrap();
+ cx.foreground().run_until_parked();
cx.simulate_new_path_selection(|_| Some(PathBuf::from("/root/the-new-name")));
save_task.await.unwrap();
editor.read_with(cx, |editor, cx| {
@@ -1311,7 +1315,10 @@ mod tests {
.await;
cx.read(|cx| assert!(editor.is_dirty(cx)));
- let save_task = workspace.update(cx, |workspace, cx| workspace.save_active_item(false, cx));
+ let save_task = workspace.update(cx, |workspace, cx| {
+ workspace.save_active_item(SaveIntent::Save, cx)
+ });
+ cx.foreground().run_until_parked();
window.simulate_prompt_answer(0, cx);
save_task.await.unwrap();
editor.read_with(cx, |editor, cx| {
@@ -1353,7 +1360,10 @@ mod tests {
});
// Save the buffer. This prompts for a filename.
- let save_task = workspace.update(cx, |workspace, cx| workspace.save_active_item(false, cx));
+ let save_task = workspace.update(cx, |workspace, cx| {
+ workspace.save_active_item(SaveIntent::Save, cx)
+ });
+ cx.foreground().run_until_parked();
cx.simulate_new_path_selection(|parent_dir| {
assert_eq!(parent_dir, Path::new("/root"));
Some(parent_dir.join("the-new-name.rs"))
@@ -1377,7 +1387,9 @@ mod tests {
editor.handle_input(" there", cx);
assert!(editor.is_dirty(cx));
});
- let save_task = workspace.update(cx, |workspace, cx| workspace.save_active_item(false, cx));
+ let save_task = workspace.update(cx, |workspace, cx| {
+ workspace.save_active_item(SaveIntent::Save, cx)
+ });
save_task.await.unwrap();
assert!(!cx.did_prompt_for_new_path());
editor.read_with(cx, |editor, cx| {
@@ -1444,7 +1456,10 @@ mod tests {
});
// Save the buffer. This prompts for a filename.
- let save_task = workspace.update(cx, |workspace, cx| workspace.save_active_item(false, cx));
+ let save_task = workspace.update(cx, |workspace, cx| {
+ workspace.save_active_item(SaveIntent::Save, cx)
+ });
+ cx.foreground().run_until_parked();
cx.simulate_new_path_selection(|_| Some(PathBuf::from("/root/the-new-name.rs")));
save_task.await.unwrap();
// The buffer is not dirty anymore and the language is assigned based on the path.
@@ -1508,9 +1523,7 @@ mod tests {
});
cx.dispatch_action(
window.into(),
- workspace::CloseActiveItem {
- save_behavior: None,
- },
+ workspace::CloseActiveItem { save_intent: None },
);
cx.foreground().run_until_parked();
@@ -1521,9 +1534,7 @@ mod tests {
cx.dispatch_action(
window.into(),
- workspace::CloseActiveItem {
- save_behavior: None,
- },
+ workspace::CloseActiveItem { save_intent: None },
);
cx.foreground().run_until_parked();
window.simulate_prompt_answer(1, cx);
@@ -1682,7 +1693,7 @@ mod tests {
pane.update(cx, |pane, cx| {
let editor3_id = editor3.id();
drop(editor3);
- pane.close_item_by_id(editor3_id, SaveBehavior::PromptOnWrite, cx)
+ pane.close_item_by_id(editor3_id, SaveIntent::Close, cx)
})
.await
.unwrap();
@@ -1717,7 +1728,7 @@ mod tests {
pane.update(cx, |pane, cx| {
let editor2_id = editor2.id();
drop(editor2);
- pane.close_item_by_id(editor2_id, SaveBehavior::PromptOnWrite, cx)
+ pane.close_item_by_id(editor2_id, SaveIntent::Close, cx)
})
.await
.unwrap();
@@ -1874,28 +1885,28 @@ mod tests {
// Close all the pane items in some arbitrary order.
pane.update(cx, |pane, cx| {
- pane.close_item_by_id(file1_item_id, SaveBehavior::PromptOnWrite, cx)
+ pane.close_item_by_id(file1_item_id, SaveIntent::Close, cx)
})
.await
.unwrap();
assert_eq!(active_path(&workspace, cx), Some(file4.clone()));
pane.update(cx, |pane, cx| {
- pane.close_item_by_id(file4_item_id, SaveBehavior::PromptOnWrite, cx)
+ pane.close_item_by_id(file4_item_id, SaveIntent::Close, cx)
})
.await
.unwrap();
assert_eq!(active_path(&workspace, cx), Some(file3.clone()));
pane.update(cx, |pane, cx| {
- pane.close_item_by_id(file2_item_id, SaveBehavior::PromptOnWrite, cx)
+ pane.close_item_by_id(file2_item_id, SaveIntent::Close, cx)
})
.await
.unwrap();
assert_eq!(active_path(&workspace, cx), Some(file3.clone()));
pane.update(cx, |pane, cx| {
- pane.close_item_by_id(file3_item_id, SaveBehavior::PromptOnWrite, cx)
+ pane.close_item_by_id(file3_item_id, SaveIntent::Close, cx)
})
.await
.unwrap();
@@ -2388,11 +2399,12 @@ mod tests {
#[gpui::test]
fn test_bundled_languages(cx: &mut AppContext) {
+ cx.set_global(SettingsStore::test(cx));
let mut languages = LanguageRegistry::test();
languages.set_executor(cx.background().clone());
let languages = Arc::new(languages);
let node_runtime = node_runtime::FakeNodeRuntime::new();
- languages::init(languages.clone(), node_runtime);
+ languages::init(languages.clone(), node_runtime, cx);
for name in languages.language_names() {
languages.language_for_name(&name);
}
@@ -0,0 +1,2 @@
+psql -c "DROP DATABASE zed (FORCE);"
+script/bootstrap