use super::*;
impl Workspace {
pub(super) fn say(&mut self, text: String) {
match self.editors.get_mut(self.active) {
Some(editor) => editor.message = text,
None => self.message = text,
}
}
pub fn open(&mut self, path: &Path) -> bool {
let path = std::fs::canonicalize(path)
.or_else(|_| std::path::absolute(path))
.unwrap_or_else(|_| path.to_path_buf());
let text = path.to_string_lossy().into_owned();
let name = path.file_name().map_or_else(
|| text.clone(),
|name| name.to_string_lossy().into_owned(),
);
if let Some(index) = self
.editors
.iter()
.position(|editor| editor.abs_path.as_deref() == Some(text.as_str()))
{
self.active = index;
} else if path.is_dir() {
self.say(format!("{name} is a folder"));
return false;
} else {
let document = match Document::open(&text) {
Ok(document) => document,
Err(error) => {
self.say(format!("Could not open {name}: {error}"));
return false;
}
};
let mut editor = Editor::new(document);
self.attach_lsp(&mut editor);
let placeholder = self.editors.len() == 1
&& self.editors[0].document.path.is_none()
&& !self.editors[0].document.dirty;
if placeholder {
self.editors.clear();
}
self.editors.push(editor);
self.active = self.editors.len() - 1;
self.show_branch();
self.fetch_committed(text.clone());
}
self.focus = Focus::Editor;
self.tree.reveal(&path);
true
}
pub(super) fn activate(&mut self, index: usize) {
if index < self.editors.len() {
self.active = index;
self.focus = Focus::Editor;
if let Some(path) = self.editors[index].abs_path.clone() {
self.tree.reveal(Path::new(&path));
}
}
}
pub(super) fn next_tab(&mut self, step: isize) {
let count = self.editors.len() as isize;
if count > 0 {
self.activate((self.active as isize + step).rem_euclid(count) as usize);
}
}
pub(super) fn close_active(&mut self, was_pending: bool) {
let Some(editor) = self.editors.get_mut(self.active) else {
return;
};
if editor.document.dirty && !was_pending {
self.close_pending = true;
editor.message = "Unsaved changes! Close again to discard".into();
return;
}
let editor = self.editors.remove(self.active);
if let (Some(lsp), Some(path)) = (&editor.lsp, &editor.abs_path) {
lsp.borrow_mut().close(path);
}
drop(editor);
self.servers.retain(|server| !server.client.borrow().is_unused());
self.active = self.active.min(self.editors.len().saturating_sub(1));
if self.editors.is_empty() {
self.show_folder();
} else {
self.activate(self.active);
}
}
pub(super) fn close_tab(&mut self, index: usize) {
let pending = std::mem::take(&mut self.close_pending) && index == self.active;
if index < self.editors.len() {
self.activate(index);
self.close_active(pending);
}
}
pub(super) fn quit(&mut self, was_pending: bool) {
let unsaved = self.editors.iter().filter(|editor| editor.document.dirty).count();
if unsaved == 0 || was_pending {
self.should_quit = true;
return;
}
self.quit_pending = true;
if !self.editors[self.active].document.dirty {
let first = self.editors.iter().position(|editor| editor.document.dirty);
self.activate(first.unwrap_or(self.active));
}
self.say(match unsaved {
1 => "Unsaved changes! Ctrl+Q again to quit".into(),
_ => format!("Unsaved changes in {unsaved} files! Ctrl+Q again to quit"),
});
}
pub(super) fn selected_folder(&self) -> PathBuf {
match self.tree.selected() {
Some(entry) if entry.is_dir => entry.path.clone(),
Some(entry) => entry.path.parent().unwrap_or(self.tree.root()).to_path_buf(),
None => self.tree.root().to_path_buf(),
}
}
pub(super) fn ask_new(&mut self, picker: Picker) {
self.file_target = self.selected_folder();
self.pick(picker, Vec::new());
}
pub(super) fn ask_rename(&mut self) {
let Some(entry) = self.tree.selected() else {
return;
};
self.file_target = entry.path.clone();
let name = entry.name.clone();
self.pick(Picker::Rename, Vec::new());
if let Some(finder) = &mut self.finder {
finder.query = name;
}
}
pub(super) fn open_under(&self, path: &Path) -> Vec<usize> {
(0..self.editors.len())
.filter(|index| {
let file = self.editors[*index].abs_path.as_deref().map(Path::new);
file.is_some_and(|file| file.starts_with(path))
})
.collect()
}
pub(super) fn close_under(&mut self, path: &Path) -> Vec<PathBuf> {
let mut closed = Vec::new();
for index in self.open_under(path).into_iter().rev() {
let editor = self.editors.remove(index);
if let (Some(lsp), Some(file)) = (&editor.lsp, &editor.abs_path) {
lsp.borrow_mut().close(file);
}
let file = PathBuf::from(editor.abs_path.unwrap_or_default());
closed.push(file.strip_prefix(path).unwrap_or(Path::new("")).to_path_buf());
}
self.servers.retain(|server| !server.client.borrow().is_unused());
self.active = self.active.min(self.editors.len().saturating_sub(1));
closed
}
pub(super) fn unsaved_under(&mut self, path: &Path) -> bool {
let unsaved = self.open_under(path).iter().any(|index| self.editors[*index].document.dirty);
if unsaved {
self.say("Save or close the file first: it has unsaved changes".into());
}
unsaved
}
pub(super) fn make_new(&mut self, name: &str, folder: bool) {
let path = self.file_target.join(name);
if path.exists() {
return self.say(format!("{name} already exists"));
}
let made = if folder {
std::fs::create_dir_all(&path)
} else {
std::fs::create_dir_all(path.parent().unwrap_or(&self.file_target))
.and_then(|()| std::fs::write(&path, ""))
};
if let Err(error) = made {
return self.say(format!("Could not make {name}: {error}"));
}
self.tree.refresh();
self.refresh_git();
if folder {
self.tree.reveal(&path);
self.say(format!("Made the folder {name}"));
} else {
self.open(&path);
}
}
pub(super) fn rename_to(&mut self, name: &str) {
let from = self.file_target.clone();
let to = from.parent().unwrap_or(self.tree.root()).join(name);
if to == from || self.unsaved_under(&from) {
return;
}
if to.exists() {
return self.say(format!("{name} already exists"));
}
if let Err(error) = std::fs::rename(&from, &to) {
return self.say(format!("Could not rename it: {error}"));
}
let moved = self.close_under(&from);
self.tree.refresh();
self.refresh_git();
let focus = self.focus;
for below in moved.into_iter().rev() {
let path = if below.as_os_str().is_empty() { to.clone() } else { to.join(below) };
self.open(&path);
}
self.focus = focus;
self.tree.reveal(&to);
self.say(format!("Renamed to {name}"));
}
pub(super) fn delete_selected(&mut self, pending: Option<PathBuf>) {
let Some(entry) = self.tree.selected() else {
return;
};
let (path, name, is_dir) = (entry.path.clone(), entry.name.clone(), entry.is_dir);
if self.unsaved_under(&path) {
return;
}
if pending.as_ref() != Some(&path) {
let what = if is_dir { " and everything in it" } else { "" };
self.say(format!("Delete {name}{what}? Press d again"));
self.delete_pending = Some(path);
return;
}
let removed = if is_dir { std::fs::remove_dir_all(&path) } else { std::fs::remove_file(&path) };
if let Err(error) = removed {
return self.say(format!("Could not delete {name}: {error}"));
}
self.close_under(&path);
self.tree.refresh();
self.refresh_git();
if !self.has_files() {
self.show_folder();
}
self.say(format!("Deleted {name}"));
}
}