diff options
Diffstat (limited to 'src/bibiman.rs')
| -rw-r--r-- | src/bibiman.rs | 376 |
1 files changed, 369 insertions, 7 deletions
diff --git a/src/bibiman.rs b/src/bibiman.rs index 5d8dbf2..4f66c9c 100644 --- a/src/bibiman.rs +++ b/src/bibiman.rs @@ -15,12 +15,18 @@ // along with this program. If not, see <https://www.gnu.org/licenses/>. ///// +use crate::bibiman::entries::EntryTableColumn; use crate::bibiman::{bibisetup::*, search::BibiSearch}; use crate::cliargs::CLIArgs; +use crate::tui::Tui; use crate::{bibiman::entries::EntryTable, bibiman::keywords::TagList}; use arboard::Clipboard; -use color_eyre::eyre::{Ok, Result}; +use color_eyre::eyre::{Context, Ok, Result}; +use core::panic; +use editor_command::EditorBuilder; +use ratatui::widgets::ScrollbarState; use std::path::PathBuf; +use std::process::{Command, Stdio}; use tui_input::Input; pub mod bibisetup; @@ -147,7 +153,360 @@ impl Bibiman { .entry_info_scroll_state .position(self.entry_table.entry_info_scroll.into()); } +} + +impl Bibiman { + // Entry Table commands + + /// Select next entry in Table holding the bibliographic entries. + /// + /// Takes u16 value as argument to specify number of entries which + /// should be scrolled + pub fn select_next_entry(&mut self, entries: u16) { + self.entry_table.entry_info_scroll = 0; + self.entry_table.entry_info_scroll_state = + self.entry_table.entry_info_scroll_state.position(0); + self.entry_table.entry_table_state.scroll_down_by(entries); + self.entry_table.entry_scroll_state = self + .entry_table + .entry_scroll_state + .position(self.entry_table.entry_table_state.selected().unwrap()); + } + + /// Select previous entry in Table holding the bib entries. + /// + /// Takes u16 value as argument to specify number of entries which + /// should be scrolled + pub fn select_previous_entry(&mut self, entries: u16) { + self.entry_table.entry_info_scroll = 0; + self.entry_table.entry_info_scroll_state = + self.entry_table.entry_info_scroll_state.position(0); + self.entry_table.entry_table_state.scroll_up_by(entries); + self.entry_table.entry_scroll_state = self + .entry_table + .entry_scroll_state + .position(self.entry_table.entry_table_state.selected().unwrap()); + } + + /// Select first entry in bib list + pub fn select_first_entry(&mut self) { + self.entry_table.entry_info_scroll = 0; + self.entry_table.entry_info_scroll_state = + self.entry_table.entry_info_scroll_state.position(0); + self.entry_table.entry_table_state.select_first(); + self.entry_table.entry_scroll_state = self.entry_table.entry_scroll_state.position(0); + } + + /// Select last entry in bib list + pub fn select_last_entry(&mut self) { + self.entry_table.entry_info_scroll = 0; + self.entry_table.entry_info_scroll_state = + self.entry_table.entry_info_scroll_state.position(0); + // self.entry_table.entry_table_state.select_last(); // Does not work properly after upgrading to ratatui 0.29.0 + self.entry_table + .entry_table_state + .select(Some(self.entry_table.entry_table_items.len() - 1)); + self.entry_table.entry_scroll_state = self + .entry_table + .entry_scroll_state + .position(self.entry_table.entry_table_items.len()); + } + + /// Select next (right) column of entry table + pub fn select_next_column(&mut self) { + match self.entry_table.entry_table_selected_column { + EntryTableColumn::Authors => { + self.entry_table.entry_table_selected_column = EntryTableColumn::Title; + } + EntryTableColumn::Title => { + self.entry_table.entry_table_selected_column = EntryTableColumn::Year; + } + EntryTableColumn::Year => { + self.entry_table.entry_table_selected_column = EntryTableColumn::Pubtype; + } + EntryTableColumn::Pubtype => { + self.entry_table.entry_table_selected_column = EntryTableColumn::Authors; + } + } + } + + /// Select previous (left) column of entry table + pub fn select_prev_column(&mut self) { + match self.entry_table.entry_table_selected_column { + EntryTableColumn::Authors => { + self.entry_table.entry_table_selected_column = EntryTableColumn::Pubtype; + } + EntryTableColumn::Title => { + self.entry_table.entry_table_selected_column = EntryTableColumn::Authors; + } + EntryTableColumn::Year => { + self.entry_table.entry_table_selected_column = EntryTableColumn::Title; + } + EntryTableColumn::Pubtype => { + self.entry_table.entry_table_selected_column = EntryTableColumn::Year; + } + } + } + + // Get the citekey of the selected entry + pub fn get_selected_citekey(&self) -> &str { + let idx = self.entry_table.entry_table_state.selected().unwrap(); + let citekey = &self.entry_table.entry_table_items[idx].citekey; + citekey + } + + pub fn run_editor(&mut self, tui: &mut Tui) -> Result<()> { + // get filecontent and citekey for calculating line number + let citekey = self.get_selected_citekey(); + // create independent copy of citekey for finding entry after updating list + let saved_key = citekey.to_owned(); + let filepath = self.main_biblio.bibfile.display().to_string(); + let filecontent = self.main_biblio.bibfilestring.clone(); + let mut line_count = 0; + + for line in filecontent.lines() { + line_count = line_count + 1; + // if reaching the citekey break the loop + // if reaching end of lines without match, reset to 0 + if line.contains(&citekey) { + break; + } else if line_count == filecontent.len() { + eprintln!( + "Citekey {} not found, opening file {} at line 1", + &citekey, &filepath + ); + line_count = 0; + break; + } + } + + // Exit TUI to enter editor + tui.exit()?; + // Use VISUAL or EDITOR. Set "vi" as last fallback + let mut cmd: Command = EditorBuilder::new() + .environment() + .source(Some("vi")) + .build() + .unwrap(); + // Prepare arguments to open file at specific line + let args: Vec<String> = vec![format!("+{}", line_count), filepath]; + let status = cmd.args(&args).status()?; + if !status.success() { + eprintln!("Spawning editor failed with status {}", status); + } + + // Enter TUI again + tui.enter()?; + tui.terminal.clear()?; + + // Update the database and the lists to show changes + self.update_lists(); + + // Search for entry, selected before editing, by matching citekeys + // Use earlier saved copy of citekey to match + let mut idx_count = 0; + loop { + if self.entry_table.entry_table_items[idx_count] + .citekey + .contains(&saved_key) + { + break; + } + idx_count = idx_count + 1 + } + + // Set selected entry to vec-index of match + self.entry_table.entry_table_state.select(Some(idx_count)); + + Ok(()) + } + + // Search entry list + pub fn search_entries(&mut self) { + // Use snapshot of entry list saved when starting the search + // so deleting a char, will show former entries too + let orig_list = self.entry_table.entry_table_at_search_start.clone(); + let filtered_list = + BibiSearch::search_entry_list(&mut self.search_struct.search_string, orig_list.clone()); + self.entry_table.entry_table_items = filtered_list; + if self.entry_table.entry_table_reversed_sort { + self.entry_table.sort_entry_table(false); + } + self.entry_table.entry_scroll_state = ScrollbarState::content_length( + self.entry_table.entry_scroll_state, + self.entry_table.entry_table_items.len(), + ); + } + // Open file connected with entry through 'file' or 'pdf' field + pub fn open_connected_file(&mut self) -> Result<()> { + let idx = self.entry_table.entry_table_state.selected().unwrap(); + let filepath = &self.entry_table.entry_table_items[idx].filepath.clone(); + + // Build command to execute pdf-reader. 'xdg-open' is Linux standard + let cmd = { + match std::env::consts::OS { + "linux" => String::from("xdg-open"), + "macos" => String::from("open"), + "windows" => String::from("start"), + _ => panic!("Couldn't detect OS for setting correct opener"), + } + }; + + // Pass filepath as argument, pipe stdout and stderr to /dev/null + // to keep the TUI clean (where is it piped on Windows???) + let _ = Command::new(&cmd) + .arg(&filepath) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .spawn() + .wrap_err("Opening file not possible"); + + Ok(()) + } + + pub fn open_doi_url(&mut self) -> Result<()> { + let idx = self.entry_table.entry_table_state.selected().unwrap(); + let web_adress = self.entry_table.entry_table_items[idx].doi_url.clone(); + + // Resolve strings using the resolving function of dx.doi.org, so the + // terminal is not blocked by the resolving process + let url = if web_adress.starts_with("10.") { + let prefix = "https://doi.org/".to_string(); + prefix + &web_adress + } else if web_adress.starts_with("www.") { + let prefix = "https://".to_string(); + prefix + &web_adress + } else { + web_adress + }; + + // Build command to execute browser. 'xdg-open' is Linux standard + let cmd = { + match std::env::consts::OS { + "linux" => String::from("xdg-open"), + "macos" => String::from("open"), + "windows" => String::from("start"), + _ => panic!("Couldn't detect OS for setting correct opener"), + } + }; + + // Pass filepath as argument, pipe stdout and stderr to /dev/null + // to keep the TUI clean (where is it piped on Windows???) + let _ = Command::new(&cmd) + .arg(url) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .spawn() + .wrap_err("Opening file not possible"); + + Ok(()) + } +} + +impl Bibiman { + // Tag List commands + + // Movement + pub fn select_next_tag(&mut self, keywords: u16) { + self.tag_list.tag_list_state.scroll_down_by(keywords); + self.tag_list.tag_scroll_state = self + .tag_list + .tag_scroll_state + .position(self.tag_list.tag_list_state.selected().unwrap()); + } + + pub fn select_previous_tag(&mut self, keywords: u16) { + self.tag_list.tag_list_state.scroll_up_by(keywords); + self.tag_list.tag_scroll_state = self + .tag_list + .tag_scroll_state + .position(self.tag_list.tag_list_state.selected().unwrap()); + } + + pub fn select_first_tag(&mut self) { + self.tag_list.tag_list_state.select_first(); + self.tag_list.tag_scroll_state = self.tag_list.tag_scroll_state.position(0); + } + + pub fn select_last_tag(&mut self) { + self.tag_list.tag_list_state.select_last(); + self.tag_list.tag_scroll_state = self + .tag_list + .tag_scroll_state + .position(self.tag_list.tag_list_items.len()); + } + + pub fn get_selected_tag(&self) -> &str { + let idx = self.tag_list.tag_list_state.selected().unwrap(); + let keyword = &self.tag_list.tag_list_items[idx]; + // let keyword = &self.tag_list.tag_list_items[idx].keyword; + keyword + } + + pub fn search_tags(&mut self) { + let orig_list = &self.tag_list.tag_list_at_search_start; + let filtered_list = + BibiSearch::search_tag_list(&self.search_struct.search_string, orig_list.clone()); + self.tag_list.tag_list_items = filtered_list; + // Update scrollbar length after filtering list + self.tag_list.tag_scroll_state = ScrollbarState::content_length( + self.tag_list.tag_scroll_state, + self.tag_list.tag_list_items.len(), + ); + } + + pub fn filter_tags_by_entries(&mut self) { + let mut filtered_keywords: Vec<String> = Vec::new(); + + let orig_list = &self.entry_table.entry_table_items; + + for e in orig_list { + if !e.keywords.is_empty() { + let mut key_vec: Vec<String> = e + .keywords + .split(',') + .map(|s| s.trim().to_string()) + .filter(|s| !s.is_empty()) + .collect(); + filtered_keywords.append(&mut key_vec); + } + } + + filtered_keywords.sort_by(|a, b| a.to_lowercase().cmp(&b.to_lowercase())); + filtered_keywords.dedup(); + + self.search_struct.filtered_tag_list = filtered_keywords.clone(); + self.tag_list.tag_list_items = filtered_keywords; + self.tag_list.tag_scroll_state = ScrollbarState::content_length( + self.tag_list.tag_scroll_state, + self.tag_list.tag_list_items.len(), + ); + } + + // Filter the entry list by tags when hitting enter + // If already inside a filtered tag or entry list, apply the filtering + // to the already filtered list only + pub fn filter_for_tags(&mut self) { + let orig_list = &self.entry_table.entry_table_items; + let keyword = self.get_selected_tag(); + let filtered_list = BibiSearch::filter_entries_by_tag(&keyword, &orig_list); + // self.tag_list.selected_keyword = keyword.to_string(); + self.tag_list.selected_keywords.push(keyword.to_string()); + self.entry_table.entry_table_items = filtered_list; + // Update scrollbar state with new lenght of itemlist + self.entry_table.entry_scroll_state = ScrollbarState::content_length( + self.entry_table.entry_scroll_state, + self.entry_table.entry_table_items.len(), + ); + self.filter_tags_by_entries(); + self.toggle_area(); + self.entry_table.entry_table_state.select(Some(0)); + self.former_area = Some(FormerArea::TagArea); + } +} + +impl Bibiman { // Search Area // Enter the search area @@ -160,6 +519,7 @@ impl Bibiman { self.entry_table.entry_table_items.clone(); self.former_area = Some(FormerArea::EntryArea) } else if let CurrentArea::TagArea = self.current_area { + self.tag_list.tag_list_at_search_start = self.tag_list.tag_list_items.clone(); self.former_area = Some(FormerArea::TagArea) } self.current_area = CurrentArea::SearchArea @@ -169,24 +529,27 @@ impl Bibiman { pub fn confirm_search(&mut self) { if let Some(FormerArea::EntryArea) = self.former_area { self.current_area = CurrentArea::EntryArea; - self.entry_table.entry_table_state.select(Some(0)) + self.entry_table.entry_table_state.select(Some(0)); + self.entry_table.entry_table_at_search_start.clear(); } else if let Some(FormerArea::TagArea) = self.former_area { self.current_area = CurrentArea::TagArea; - self.tag_list.tag_list_state.select(Some(0)) + self.tag_list.tag_list_state.select(Some(0)); + self.tag_list.tag_list_at_search_start.clear(); } self.former_area = Some(FormerArea::SearchArea); self.search_struct.search_string.clear(); - self.entry_table.entry_table_at_search_start.clear(); } // Break search: leave search area without filtering list pub fn break_search(&mut self) { if let Some(FormerArea::EntryArea) = self.former_area { self.current_area = CurrentArea::EntryArea; - self.entry_table.entry_table_state.select(Some(0)) + self.entry_table.entry_table_state.select(Some(0)); + self.entry_table.entry_table_at_search_start.clear(); } else if let Some(FormerArea::TagArea) = self.former_area { self.current_area = CurrentArea::TagArea; - self.tag_list.tag_list_state.select(Some(0)) + self.tag_list.tag_list_state.select(Some(0)); + self.tag_list.tag_list_at_search_start.clear(); } // But keep filtering by tag if applied before entering search area if !self.search_struct.inner_search { @@ -195,7 +558,6 @@ impl Bibiman { self.former_area = None; // If search is canceled, reset default status of struct self.search_struct.search_string.clear(); - self.entry_table.entry_table_at_search_start.clear(); } // Remove last char from search pattern and filter list immidiately |