240 lines
8.6 KiB
Rust
240 lines
8.6 KiB
Rust
mod arguments;
|
|
mod config;
|
|
mod bookmarks;
|
|
mod stack;
|
|
mod output;
|
|
mod util;
|
|
|
|
use arguments::*;
|
|
use clap::Parser;
|
|
use config::*;
|
|
use bookmarks::*;
|
|
use config_parser::*;
|
|
use dirs::home_dir;
|
|
use output::Output;
|
|
use stack::Stack;
|
|
use util::to_rooted;
|
|
use std::char;
|
|
use std::env::current_dir;
|
|
use std::io::{Error, Result};
|
|
use std::path::{Path, PathBuf};
|
|
use std::str::FromStr;
|
|
|
|
fn main() -> Result<()> {
|
|
let mut output = Output::new();
|
|
let config = match Config::new(true) {
|
|
Ok(value) => value,
|
|
Err(error) => {
|
|
// config object is not ready at this point so the style
|
|
// has to be created by hand
|
|
print!("echo -e '{}{}{}' && false", generate_style_sequence(None, Some(COLORS.fg.red), None), error, RESET_SEQ);
|
|
return Ok(())
|
|
}
|
|
};
|
|
let args = match Arguments::try_parse() {
|
|
Ok(a) => a,
|
|
Err(error) => {
|
|
match error.kind() {
|
|
clap::error::ErrorKind::DisplayHelp | clap::error::ErrorKind::DisplayVersion => {
|
|
output.push_info(&error.to_string());
|
|
},
|
|
clap::error::ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand => {
|
|
output.push_warning(&error.to_string());
|
|
},
|
|
_ => {
|
|
output.push_error(&error.to_string());
|
|
},
|
|
}
|
|
output.print_output(&config);
|
|
return Ok(());
|
|
}
|
|
};
|
|
let mut bookmarks = match Bookmarks::new() {
|
|
Ok(value) => value,
|
|
Err(error) => {
|
|
output.push_error(&error.to_string());
|
|
output.print_output(&config);
|
|
return Ok(());
|
|
}
|
|
};
|
|
let mut stack = match Stack::new(args.pid) {
|
|
Ok(stack) => stack,
|
|
Err(_) => {
|
|
output.push_error(&"-- failed to build stack".to_string());
|
|
return Err(Error::other(""));
|
|
}
|
|
};
|
|
let res = match args.action {
|
|
Action::push(push_args) => handle_push(&push_args, &config, &mut stack, &mut output),
|
|
Action::pop(pop_args) => handle_pop(&pop_args, &config, &mut stack, &mut output),
|
|
Action::stack(stack_args) => handle_stack(&stack_args, &config, &mut stack, &mut output),
|
|
Action::bookmark(bookmark_args) => handle_bookmark(&bookmark_args, &config, &mut bookmarks, &mut stack, &mut output),
|
|
Action::configuration(config_args) => handle_config(&config_args, &mut output),
|
|
};
|
|
|
|
if res.is_err() {
|
|
output.push_error(&res.unwrap_err().to_string());
|
|
output.push_command(&"false".to_owned());
|
|
}
|
|
|
|
// print output and command
|
|
output.print_output(&config);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_push(args: &PushArgs, config: &Config, stack: &mut Stack, output: &mut Output) -> Result<()> {
|
|
// paths arguments starting with `=` are interpreted as stack entry number
|
|
const PREFIX: char = '=';
|
|
|
|
let mut path_string = match args.path.clone() {
|
|
Some(value) => value.join(" "),
|
|
None => {
|
|
String::new()
|
|
}
|
|
};
|
|
let path: PathBuf = if path_string.is_empty() {
|
|
match home_dir() {
|
|
Some(value) => value,
|
|
None => return Err(Error::other("-- failed to determine home directory")),
|
|
}
|
|
} else if path_string.starts_with(PREFIX) {
|
|
path_string = path_string.trim_start_matches(PREFIX).to_string();
|
|
let number: usize = match path_string.parse() {
|
|
Ok(value) => value,
|
|
Err(_) => return Err(Error::other("-- push : failed to convert path argument to number")),
|
|
};
|
|
stack.get_entry_by_number(number)?.to_path_buf()
|
|
} else {
|
|
match PathBuf::from_str(&path_string) {
|
|
Ok(value) => value,
|
|
Err(_) => return Err(Error::other("-- failed to create PathBuf from argument")),
|
|
}
|
|
};
|
|
if let Some(true) = args.show_stack {
|
|
output.push_info(&stack.to_formatted_string(&config)?);
|
|
} else if config.general.show_stack_on_push {
|
|
output.push_info(&stack.to_formatted_string(&config)?);
|
|
}
|
|
push_path(&path, stack, config, output)?;
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_pop(args: &PopArgs, config: &Config, stack: &mut Stack, output: &mut Output) -> Result<()> {
|
|
let mut num : Option<usize> = None;
|
|
if let Some(a) = &args.action {
|
|
match a {
|
|
PopAction::all => num = Some(0),
|
|
}
|
|
} else if let Some(n) = &args.num_entries {
|
|
num = Some(*n);
|
|
}
|
|
let path = stack.pop_entry(num)?;
|
|
if let Some(true) = args.show_stack {
|
|
output.push_info(&stack.to_formatted_string(config)?);
|
|
} else if config.general.show_stack_on_push {
|
|
output.push_info(&stack.to_formatted_string(config)?);
|
|
}
|
|
output.push_command(&format!("cd -- {}", match path.to_str() {
|
|
Some(value) => value,
|
|
None => return Err(Error::other("-- failed to print popped path as string")),
|
|
}));
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_stack(args: &StackArgs, config: &Config, stack: &mut Stack, output: &mut Output) -> Result<()> {
|
|
if args.stack_action.is_some() {
|
|
match args.stack_action.clone().unwrap() {
|
|
StackAction::clear(_) => {
|
|
stack.clear_stack()?;
|
|
output.push_info(&"stack cleared.".to_owned());
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
// retrieve stack
|
|
output.push_info(&stack.to_formatted_string(config)?);
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_bookmark(args: &BookmarkArgs, config: &Config, bookmarks: &mut Bookmarks, stack: &mut Stack, output: &mut Output) -> Result<()> {
|
|
// if args.bookmark_action.is_some() {
|
|
if let Some(action) = &args.bookmark_action {
|
|
match action {
|
|
BookmarkAction::list(_) => list_bookmarks(config, bookmarks, output)?,
|
|
BookmarkAction::add(args) => add_bookmarks(args, config, bookmarks, output)?,
|
|
BookmarkAction::remove(args) => remove_bookmarks(args, config, bookmarks, output)?,
|
|
BookmarkAction::names(_) => println!("echo '{}'", bookmarks.get_bookmarknames()),
|
|
};
|
|
} else if args.name.is_some() { // handle `change to bookmark`
|
|
let path = bookmarks.get_path_by_name(args.name.as_ref().unwrap())?;
|
|
push_path(&path, stack, config, output)?;
|
|
} else {
|
|
list_bookmarks(config, bookmarks, output)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_config(args: &ConfigArgs, output: &mut Output) -> Result<()> {
|
|
let convert: bool = match args.convert {
|
|
Some(value) => value,
|
|
None => false,
|
|
};
|
|
let config = Config::new(convert);
|
|
output.push_info(&format!("config = {:#?}", config));
|
|
Ok(())
|
|
}
|
|
|
|
fn list_bookmarks(config: &Config, bookmarks: &mut Bookmarks, output: &mut Output) -> Result<()> {
|
|
output.push_info(&bookmarks.to_formatted_string(config)?);
|
|
Ok(())
|
|
}
|
|
|
|
fn add_bookmarks(args: &BookmarkSubArgs, config: &Config, bookmarks: &mut Bookmarks, output: &mut Output) -> Result<()> {
|
|
let mut path : PathBuf = match PathBuf::from_str(&args.path.join(" ")) {
|
|
Ok(value) => value,
|
|
Err(error) => return Err(Error::other(error.to_string())),
|
|
};
|
|
bookmarks.add_bookmark(&args.name, &path)?;
|
|
|
|
if config.general.show_books_on_bookmark {
|
|
output.push_info(&bookmarks.to_formatted_string(config)?);
|
|
} else {
|
|
_ = to_rooted(&mut path);
|
|
output.push_info(&format!("added bookmark `{}{}{} = {}{}{}`.",
|
|
generate_style_sequence(Some(STYLES.set.bold), None, None), args.name, RESET_SEQ,
|
|
generate_style_sequence(Some(STYLES.set.italic), None, None), path.to_str().unwrap(), RESET_SEQ));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn remove_bookmarks(args: &BookmarkSubArgs, config: &Config, bookmarks: &mut Bookmarks, output: &mut Output) -> Result<()> {
|
|
bookmarks.remove_bookmark(&args.name)?;
|
|
|
|
if config.general.show_books_on_bookmark {
|
|
output.push_info(&bookmarks.to_formatted_string(config)?);
|
|
} else {
|
|
output.push_info(&format!("remove bookmark `{}{}{}`.", generate_style_sequence(Some(STYLES.set.bold), None, None), args.name, RESET_SEQ));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// push path to stack and print command to navigate to provided path
|
|
fn push_path(path: &Path, stack: &mut Stack, _config: &Config, output: &mut Output) -> Result<()> {
|
|
let mut path = path.to_path_buf();
|
|
let mut current_path: PathBuf = current_dir()?;
|
|
to_rooted(&mut path)?;
|
|
to_rooted(&mut current_path)?;
|
|
if !path.is_dir() {
|
|
return Err(Error::other("-- invalid path argument"));
|
|
} else if !(path == current_path) {
|
|
stack.push_entry(¤t_path)?;
|
|
output.push_command(&format!("cd -- '{}'", match path.canonicalize()?.to_str() {
|
|
Some(value) => value,
|
|
None => return Err(Error::other("-- failed to print provided path as string")),
|
|
}));
|
|
}
|
|
Ok(())
|
|
}
|