537 lines
15 KiB
Rust
537 lines
15 KiB
Rust
use std::{collections::HashMap, fmt::Display, str::FromStr};
|
|
|
|
use crate::{
|
|
libsh::error::{Note, ShErr, ShErrKind, ShResult},
|
|
state::ShFunc,
|
|
};
|
|
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub enum FernBellStyle {
|
|
Audible,
|
|
Visible,
|
|
Disable,
|
|
}
|
|
|
|
impl FromStr for FernBellStyle {
|
|
type Err = ShErr;
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s.to_ascii_lowercase().as_str() {
|
|
"audible" => Ok(Self::Audible),
|
|
"visible" => Ok(Self::Visible),
|
|
"disable" => Ok(Self::Disable),
|
|
_ => Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
format!("Invalid bell style '{s}'"),
|
|
)),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default, Clone, Copy, Debug)]
|
|
pub enum FernEditMode {
|
|
#[default]
|
|
Vi,
|
|
Emacs,
|
|
}
|
|
|
|
impl FromStr for FernEditMode {
|
|
type Err = ShErr;
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s.to_ascii_lowercase().as_str() {
|
|
"vi" => Ok(Self::Vi),
|
|
"emacs" => Ok(Self::Emacs),
|
|
_ => Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
format!("Invalid edit mode '{s}'"),
|
|
)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for FernEditMode {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
FernEditMode::Vi => write!(f, "vi"),
|
|
FernEditMode::Emacs => write!(f, "emacs"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct ShOpts {
|
|
pub core: ShOptCore,
|
|
pub prompt: ShOptPrompt,
|
|
}
|
|
|
|
impl Default for ShOpts {
|
|
fn default() -> Self {
|
|
let core = ShOptCore::default();
|
|
|
|
let prompt = ShOptPrompt::default();
|
|
|
|
Self { core, prompt }
|
|
}
|
|
}
|
|
|
|
impl ShOpts {
|
|
pub fn query(&mut self, query: &str) -> ShResult<Option<String>> {
|
|
if let Some((opt, new_val)) = query.split_once('=') {
|
|
self.set(opt, new_val)?;
|
|
Ok(None)
|
|
} else {
|
|
self.get(query)
|
|
}
|
|
}
|
|
|
|
pub fn set(&mut self, opt: &str, val: &str) -> ShResult<()> {
|
|
let mut query = opt.split('.');
|
|
let Some(key) = query.next() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: No option given",
|
|
));
|
|
};
|
|
|
|
let remainder = query.collect::<Vec<_>>().join(".");
|
|
|
|
match key {
|
|
"core" => self.core.set(&remainder, val)?,
|
|
"prompt" => self.prompt.set(&remainder, val)?,
|
|
_ => {
|
|
return Err(
|
|
ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected 'core' or 'prompt' in shopt key",
|
|
)
|
|
.with_note(
|
|
Note::new("'shopt' takes arguments separated by periods to denote namespaces")
|
|
.with_sub_notes(vec!["Example: 'shopt core.autocd=true'"]),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get(&self, query: &str) -> ShResult<Option<String>> {
|
|
// TODO: handle escapes?
|
|
let mut query = query.split('.');
|
|
let Some(key) = query.next() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: No option given",
|
|
));
|
|
};
|
|
let remainder = query.collect::<Vec<_>>().join(".");
|
|
|
|
match key {
|
|
"core" => self.core.get(&remainder),
|
|
"prompt" => self.prompt.get(&remainder),
|
|
_ => Err(
|
|
ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: Expected 'core' or 'prompt' in shopt key",
|
|
)
|
|
.with_note(
|
|
Note::new("'shopt' takes arguments separated by periods to denote namespaces")
|
|
.with_sub_notes(vec!["Example: 'shopt core.autocd=true'"]),
|
|
),
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct ShOptCore {
|
|
pub dotglob: bool,
|
|
pub autocd: bool,
|
|
pub hist_ignore_dupes: bool,
|
|
pub max_hist: usize,
|
|
pub interactive_comments: bool,
|
|
pub auto_hist: bool,
|
|
pub bell_enabled: bool,
|
|
pub max_recurse_depth: usize,
|
|
}
|
|
|
|
impl ShOptCore {
|
|
pub fn set(&mut self, opt: &str, val: &str) -> ShResult<()> {
|
|
match opt {
|
|
"dotglob" => {
|
|
let Ok(val) = val.parse::<bool>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected 'true' or 'false' for dotglob value",
|
|
));
|
|
};
|
|
self.dotglob = val;
|
|
}
|
|
"autocd" => {
|
|
let Ok(val) = val.parse::<bool>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected 'true' or 'false' for autocd value",
|
|
));
|
|
};
|
|
self.autocd = val;
|
|
}
|
|
"hist_ignore_dupes" => {
|
|
let Ok(val) = val.parse::<bool>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected 'true' or 'false' for hist_ignore_dupes value",
|
|
));
|
|
};
|
|
self.hist_ignore_dupes = val;
|
|
}
|
|
"max_hist" => {
|
|
let Ok(val) = val.parse::<usize>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected a positive integer for max_hist value",
|
|
));
|
|
};
|
|
self.max_hist = val;
|
|
}
|
|
"interactive_comments" => {
|
|
let Ok(val) = val.parse::<bool>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected 'true' or 'false' for interactive_comments value",
|
|
));
|
|
};
|
|
self.interactive_comments = val;
|
|
}
|
|
"auto_hist" => {
|
|
let Ok(val) = val.parse::<bool>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected 'true' or 'false' for auto_hist value",
|
|
));
|
|
};
|
|
self.auto_hist = val;
|
|
}
|
|
"bell_enabled" => {
|
|
let Ok(val) = val.parse::<bool>() else {
|
|
return Err(
|
|
ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected 'true' or 'false' for bell_enabled value",
|
|
),
|
|
);
|
|
};
|
|
self.bell_enabled = val;
|
|
}
|
|
"max_recurse_depth" => {
|
|
let Ok(val) = val.parse::<usize>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected a positive integer for max_recurse_depth value",
|
|
));
|
|
};
|
|
self.max_recurse_depth = val;
|
|
}
|
|
_ => {
|
|
return Err(
|
|
ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
format!("shopt: Unexpected 'core' option '{opt}'"),
|
|
)
|
|
.with_note(Note::new("options can be accessed like 'core.option_name'"))
|
|
.with_note(
|
|
Note::new("'core' contains the following options").with_sub_notes(vec![
|
|
"dotglob",
|
|
"autocd",
|
|
"hist_ignore_dupes",
|
|
"max_hist",
|
|
"interactive_comments",
|
|
"auto_hist",
|
|
"bell_enabled",
|
|
"max_recurse_depth",
|
|
]),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
pub fn get(&self, query: &str) -> ShResult<Option<String>> {
|
|
if query.is_empty() {
|
|
return Ok(Some(format!("{self}")));
|
|
}
|
|
|
|
match query {
|
|
"dotglob" => {
|
|
let mut output = String::from("Include hidden files in glob patterns\n");
|
|
output.push_str(&format!("{}", self.dotglob));
|
|
Ok(Some(output))
|
|
}
|
|
"autocd" => {
|
|
let mut output = String::from(
|
|
"Allow navigation to directories by passing the directory as a command directly\n",
|
|
);
|
|
output.push_str(&format!("{}", self.autocd));
|
|
Ok(Some(output))
|
|
}
|
|
"hist_ignore_dupes" => {
|
|
let mut output = String::from("Ignore consecutive duplicate command history entries\n");
|
|
output.push_str(&format!("{}", self.hist_ignore_dupes));
|
|
Ok(Some(output))
|
|
}
|
|
"max_hist" => {
|
|
let mut output = String::from(
|
|
"Maximum number of entries in the command history file (default '.fernhist')\n",
|
|
);
|
|
output.push_str(&format!("{}", self.max_hist));
|
|
Ok(Some(output))
|
|
}
|
|
"interactive_comments" => {
|
|
let mut output = String::from("Whether or not to allow comments in interactive mode\n");
|
|
output.push_str(&format!("{}", self.interactive_comments));
|
|
Ok(Some(output))
|
|
}
|
|
"auto_hist" => {
|
|
let mut output = String::from(
|
|
"Whether or not to automatically save commands to the command history file\n",
|
|
);
|
|
output.push_str(&format!("{}", self.auto_hist));
|
|
Ok(Some(output))
|
|
}
|
|
"bell_enabled" => {
|
|
let mut output = String::from("Whether or not to allow fern to trigger the terminal bell");
|
|
output.push_str(&format!("{}", self.bell_enabled));
|
|
Ok(Some(output))
|
|
}
|
|
"max_recurse_depth" => {
|
|
let mut output = String::from("Maximum limit of recursive shell function calls\n");
|
|
output.push_str(&format!("{}", self.max_recurse_depth));
|
|
Ok(Some(output))
|
|
}
|
|
_ => Err(
|
|
ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
format!("shopt: Unexpected 'core' option '{query}'"),
|
|
)
|
|
.with_note(Note::new("options can be accessed like 'core.option_name'"))
|
|
.with_note(
|
|
Note::new("'core' contains the following options").with_sub_notes(vec![
|
|
"dotglob",
|
|
"autocd",
|
|
"hist_ignore_dupes",
|
|
"max_hist",
|
|
"interactive_comments",
|
|
"auto_hist",
|
|
"bell_enabled",
|
|
"max_recurse_depth",
|
|
]),
|
|
),
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for ShOptCore {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
let mut output = vec![];
|
|
output.push(format!("dotglob = {}", self.dotglob));
|
|
output.push(format!("autocd = {}", self.autocd));
|
|
output.push(format!("hist_ignore_dupes = {}", self.hist_ignore_dupes));
|
|
output.push(format!("max_hist = {}", self.max_hist));
|
|
output.push(format!(
|
|
"interactive_comments = {}",
|
|
self.interactive_comments
|
|
));
|
|
output.push(format!("auto_hist = {}", self.auto_hist));
|
|
output.push(format!("bell_enabled = {}", self.bell_enabled));
|
|
output.push(format!("max_recurse_depth = {}", self.max_recurse_depth));
|
|
|
|
let final_output = output.join("\n");
|
|
|
|
writeln!(f, "{final_output}")
|
|
}
|
|
}
|
|
|
|
impl Default for ShOptCore {
|
|
fn default() -> Self {
|
|
ShOptCore {
|
|
dotglob: false,
|
|
autocd: false,
|
|
hist_ignore_dupes: true,
|
|
max_hist: 1000,
|
|
interactive_comments: true,
|
|
auto_hist: true,
|
|
bell_enabled: true,
|
|
max_recurse_depth: 1000,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct ShOptPrompt {
|
|
pub trunc_prompt_path: usize,
|
|
pub edit_mode: FernEditMode,
|
|
pub comp_limit: usize,
|
|
pub highlight: bool,
|
|
pub auto_indent: bool
|
|
}
|
|
|
|
impl ShOptPrompt {
|
|
pub fn set(&mut self, opt: &str, val: &str) -> ShResult<()> {
|
|
match opt {
|
|
"trunc_prompt_path" => {
|
|
let Ok(val) = val.parse::<usize>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected a positive integer for trunc_prompt_path value",
|
|
));
|
|
};
|
|
self.trunc_prompt_path = val;
|
|
}
|
|
"edit_mode" => {
|
|
let Ok(val) = val.parse::<FernEditMode>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected 'vi' or 'emacs' for edit_mode value",
|
|
));
|
|
};
|
|
self.edit_mode = val;
|
|
}
|
|
"comp_limit" => {
|
|
let Ok(val) = val.parse::<usize>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected a positive integer for comp_limit value",
|
|
));
|
|
};
|
|
self.comp_limit = val;
|
|
}
|
|
"highlight" => {
|
|
let Ok(val) = val.parse::<bool>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected 'true' or 'false' for highlight value",
|
|
));
|
|
};
|
|
self.highlight = val;
|
|
}
|
|
"auto_indent" => {
|
|
let Ok(val) = val.parse::<bool>() else {
|
|
return Err(ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
"shopt: expected 'true' or 'false' for auto_indent value",
|
|
));
|
|
};
|
|
self.auto_indent = val;
|
|
}
|
|
"custom" => {
|
|
todo!()
|
|
}
|
|
_ => {
|
|
return Err(
|
|
ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
format!("shopt: Unexpected 'prompt' option '{opt}'"),
|
|
)
|
|
.with_note(Note::new(
|
|
"options can be accessed like 'prompt.option_name'",
|
|
))
|
|
.with_note(
|
|
Note::new("'prompt' contains the following options").with_sub_notes(vec![
|
|
"trunc_prompt_path",
|
|
"edit_mode",
|
|
"comp_limit",
|
|
"highlight",
|
|
"auto_indent",
|
|
"custom",
|
|
]),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
pub fn get(&self, query: &str) -> ShResult<Option<String>> {
|
|
if query.is_empty() {
|
|
return Ok(Some(format!("{self}")));
|
|
}
|
|
|
|
match query {
|
|
"trunc_prompt_path" => {
|
|
let mut output = String::from(
|
|
"Maximum number of path segments used in the '\\W' prompt escape sequence\n",
|
|
);
|
|
output.push_str(&format!("{}", self.trunc_prompt_path));
|
|
Ok(Some(output))
|
|
}
|
|
"edit_mode" => {
|
|
let mut output =
|
|
String::from("The style of editor shortcuts used in the line-editing of the prompt\n");
|
|
output.push_str(&format!("{}", self.edit_mode));
|
|
Ok(Some(output))
|
|
}
|
|
"comp_limit" => {
|
|
let mut output =
|
|
String::from("Maximum number of completion candidates displayed upon pressing tab\n");
|
|
output.push_str(&format!("{}", self.comp_limit));
|
|
Ok(Some(output))
|
|
}
|
|
"highlight" => {
|
|
let mut output =
|
|
String::from("Whether to enable or disable syntax highlighting on the prompt\n");
|
|
output.push_str(&format!("{}", self.highlight));
|
|
Ok(Some(output))
|
|
}
|
|
"auto_indent" => {
|
|
let mut output = String::from("Whether to automatically indent new lines in multiline commands\n");
|
|
output.push_str(&format!("{}", self.auto_indent));
|
|
Ok(Some(output))
|
|
}
|
|
_ => Err(
|
|
ShErr::simple(
|
|
ShErrKind::SyntaxErr,
|
|
format!("shopt: Unexpected 'prompt' option '{query}'"),
|
|
)
|
|
.with_note(Note::new(
|
|
"options can be accessed like 'prompt.option_name'",
|
|
))
|
|
.with_note(
|
|
Note::new("'prompt' contains the following options").with_sub_notes(vec![
|
|
"trunc_prompt_path",
|
|
"edit_mode",
|
|
"comp_limit",
|
|
"highlight",
|
|
"auto_indent",
|
|
]),
|
|
),
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for ShOptPrompt {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
let mut output = vec![];
|
|
|
|
output.push(format!("trunc_prompt_path = {}", self.trunc_prompt_path));
|
|
output.push(format!("edit_mode = {}", self.edit_mode));
|
|
output.push(format!("comp_limit = {}", self.comp_limit));
|
|
output.push(format!("highlight = {}", self.highlight));
|
|
output.push(format!("auto_indent = {}", self.auto_indent));
|
|
|
|
let final_output = output.join("\n");
|
|
|
|
writeln!(f, "{final_output}")
|
|
}
|
|
}
|
|
|
|
impl Default for ShOptPrompt {
|
|
fn default() -> Self {
|
|
ShOptPrompt {
|
|
trunc_prompt_path: 4,
|
|
edit_mode: FernEditMode::Vi,
|
|
comp_limit: 100,
|
|
highlight: true,
|
|
auto_indent: true
|
|
}
|
|
}
|
|
}
|