diff --git a/.gitignore b/.gitignore index 193d30e..d9773dc 100644 --- a/.gitignore +++ b/.gitignore @@ -19,3 +19,6 @@ Cargo.lock # Added by cargo /target +/coverage +/llvm +tarpaulin-report.html \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index d9ab9a6..9479535 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,11 +1,18 @@ [package] name = "snp" -version = "0.1.0" +author = "Dandaedre" +version = "1.0.1" edition = "2021" +[features] +test = [] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - +[profile.test] +opt-level = 0 + [dependencies] clap = { version = "4.2.7", features = ["derive"] } +edit = "0.1.4" +regex = "1.8.1" serde = { version = "1.0.163", features = ["derive"] } serde_yaml = "0.9.21" diff --git a/Makefile.toml b/Makefile.toml new file mode 100644 index 0000000..ae00fbc --- /dev/null +++ b/Makefile.toml @@ -0,0 +1,32 @@ +[tasks.testcov] +script_runner = "@shell" +ignore_errors = true +script = [ +"mkdir -p coverage", +"mkdir -p coverage/html", +"mkdir -p coverage/", +"CARGO_INCREMENTAL=0 RUSTFLAGS='-Cinstrument-coverage -Ccodegen-units=1 -Copt-level=0 -Coverflow-checks=off' LLVM_PROFILE_FILE='llvm/cargo-test-%p-%m.profraw' cargo test --features test", +"grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore '/*' --ignore '*/main.rs' --ignore '*/errors.rs' -o coverage/html/", +] + +[tasks.testing] +script_runner = "@shell" +ignore_errors = true +script = [ +"cargo test --features \"test\"", +] + +[tasks.win_build] +script_runner = "@shell" +ignore_errors = true +script = [ + "CROSS_CONTAINER_ENGINE=podman cross build --target x86_64-pc-windows-gnu" +] + +[tasks.win_test] +script_runner = "@shell" +ignore_errors = true +script = [ + "CROSS_CONTAINER_ENGINE=podman cross test --features test --target x86_64-pc-windows-gnu" +] + diff --git a/README.md b/README.md index bfc62bd..bdfbe18 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,29 @@ # snp - +![coverage/html/badges/flat.svg](coverage/html/badges/flat.svg) drawing -A simple cli utility to manage snippet +A simple cli utility to manage snippets, while it was created to be used with Helix, it can work with any tool integrating input from stdout +## Usage + +```sh +To create a new snippet and edit it immediately +$ snp snippet_name -c -e list of default tokens + +To edit the content of a snippet +$ snp snippet_name -e + +To edit the whole snippet (allow for editing of name and list of args) +$ snp snippet_name -E + +To delete a snippet +$ snp snippet_name -d + +To use a snippet +$ snp snippet_name +``` + +## Testing + +For reasons too long to explain here, test must be run with the optional feature ``--feature "test"`. +Failure to do so will result in the editor popping in during tests. diff --git a/TODO.md b/TODO.md index 635ade8..03757a7 100644 --- a/TODO.md +++ b/TODO.md @@ -1,15 +1,36 @@ -## Features -### --new (name) -- Create a new snippet with given name at the default location (where tho ?) - -### name args -- Use the snippet name with one or more args -- Args must be split up -- - ## TODO -- Make a lib for dynamic_format -- Make custom errors -- Transform all panic in errors -- Make functions into methods -- Have identical attributes with {0} {1} {0} (^^^^^) \ No newline at end of file + [ ] Benchmarks + [ ] Better use of file modes + [ ] Document non coverage + [ ] Have the the EditWhole save under a different path if name was changed (and edit too) + [ ] Find a solution for the .badpocalypse + +### Currently working on + +## Finished + [*] Make custom errors + [*] Transform all panic in errors + [*] Make functions into methods + [*] Remake all helper functions + [*] locate_snippet + [*] create_snippet + [*] edit_snippet + [*] edit_whole_snippet + [*] print_snippet + [*] Finish tests on + [*] locate_snippet + [*] create_snippet + [*] edit_snippet + [*] edit_whole_snippet + [*] print_snippet + [*] delete snippet + [*] Have identical attributes with {0} {1} {0} (^^^^^) + [*] Add an option to delete a snippet + [*] Coverage + [*] Test populate_actions + +## Posponed or rendered useless + [x] Chain the methods when possible with result ? + [ ] Make a lib for dynamic_format and snippets (impl make a trait for have .id() and other future t) + [ ] Change all uncatchables errors to expect to be more helpful or change them to better errors + diff --git a/coverage/html/badges/flat.svg b/coverage/html/badges/flat.svg new file mode 100644 index 0000000..a43354b --- /dev/null +++ b/coverage/html/badges/flat.svg @@ -0,0 +1,23 @@ + + coverage: 99% + + + + + + + + + + + + + + + coverage + + 99% + + + \ No newline at end of file diff --git a/src/actions.rs b/src/actions.rs new file mode 100644 index 0000000..0a734b8 --- /dev/null +++ b/src/actions.rs @@ -0,0 +1,145 @@ +//! The action module, including all the logic to jump to a specific action +//! depending on the CLI arguments + +use std::error::Error; + +use crate::{errors, wrapper_functions, Cli}; + +/// List of all possible actions, some are mutually exclusive +#[derive(Debug)] +#[cfg_attr(test, derive(PartialEq))] +pub enum Actions { + /// Edit the content of the snippet only + Edit, + /// Edit the whole snippet + EditAll, + /// Locate the snippet and show the position + Locate, + /// Show the snippet (with replacement done) + Show, + /// Create the snippet with the given name and arguments + Create, + /// Deletes the snippet + Delete, +} + +/// The main worker, execute all commands given as Args +pub fn execute_parsed_cli(cli: Cli) -> Result<(), errors::SnippetError> { + let list_actions = populate_actions(&cli); + for action in list_actions.iter() { + if let Err(e) = match action { + Actions::Locate => wrapper_functions::locate_snippet(&cli), + Actions::Create => wrapper_functions::create_snippet(&cli), + Actions::Show => wrapper_functions::print_snippet(&cli), + Actions::Edit => wrapper_functions::edit_snippet(&cli), + Actions::EditAll => wrapper_functions::edit_whole_snippet(&cli), + Actions::Delete => wrapper_functions::delete_snippet(&cli), + } { + println!("An error occured during runtime:\n\t{}", e); + if let Some(e) = e.source() { + println!("This error was caused by: \n\t{}", e); + } + return Err(e); + }; + } + Ok(()) +} + +/// Populate a logical vec of succesive actions to perform depending on arguments +/// even when the arguments don't make sense +fn populate_actions(cli: &Cli) -> Vec { + let mut actions = Vec::new(); + match (cli.locate, cli.create, cli.edit, cli.edit_all, cli.delete) { + (true, _, _, _, false) => actions.push(Actions::Locate), + (_, false, false, true, false) => actions.push(Actions::EditAll), + (_, true, _, true, false) => actions.push(Actions::EditAll), + (_, true, false, false, false) => actions.push(Actions::Create), + (_, false, true, _, false) => actions.push(Actions::Edit), + (_, true, true, false, false) => actions.push(Actions::Edit), + (false, false, false, false, false) => actions.push(Actions::Show), + (_, _, _, _, true) => actions.push(Actions::Delete), + } + actions +} + +#[cfg(test)] +mod test { + use super::*; + use clap::Parser; + + macro_rules! false_cli { + ($($arg:expr),+) => { + Cli::parse_from(vec![$($arg),+]) + }; + } + + macro_rules! group_actions{ + ($(($cli:expr, $expect:expr),)*) => { + vec![$(($cli,$expect)),+] + }; + } + + #[test] + fn test_populate_actions() { + // false_cli!("snp", "name", "-l"), Actions::Locate + let group = group_actions!( + ( + false_cli!("snp", "name", "-l", "-c", "-e", "-E"), + vec![Actions::Locate] + ), + (false_cli!("snp", "name", "-l"), vec![Actions::Locate]), + (false_cli!("snp", "name", "-d"), vec![Actions::Delete]), + ( + false_cli!("snp", "name", "-d", "-e", "e", "-E", "-l"), + vec![Actions::Delete] + ), + (false_cli!("snp", "name", "-E"), vec![Actions::EditAll]), + (false_cli!("snp", "name", "-E", "-e"), vec![Actions::Edit]), + ( + false_cli!("snp", "name", "-E", "-e", "-c"), + vec![Actions::EditAll] + ), + (false_cli!("snp", "name", "-e"), vec![Actions::Edit]), + (false_cli!("snp", "name", "-e", "-c"), vec![Actions::Edit]), + (false_cli!("snp", "name", "-l"), vec![Actions::Locate]), + (false_cli!("snp", "name", "-c"), vec![Actions::Create]), + (false_cli!("snp", "name"), vec![Actions::Show]), + (false_cli!("snp", "name", "-d"), vec![Actions::Delete]), + ( + false_cli!("snp", "name", "-d", "-c", "-E", "-e", "-l"), + vec![Actions::Delete] + ), + ); + for (cli, res) in group.iter() { + println!("Testing {:?}..actions expected {:?}", cli, res); + let fnd = populate_actions(cli); + println!("... found {:?}", fnd); + assert!(res.iter().zip(fnd).all(|(a, b)| *a == b)); + } + } + #[test] + fn test_execute_parsed_cli() { + let list_cli = vec![ + false_cli!("snp", "parsed_cli", "-e", "-c"), + false_cli!("snp", "parsed_cli", "-c", "-f"), + false_cli!("snp", "parsed_cli"), + false_cli!("snp", "parsed_cli", "-E", "-f"), + false_cli!("snp", "parsed_cli", "-d"), + ]; + + let bad_cli = vec![ + false_cli!("snp", "parsed_cli_bad", "-l"), + false_cli!("snp", "-d", "parsed_cli_bad"), + ]; + + for cl in list_cli { + println!("Testing {:?} expecting success", cl); + assert!(execute_parsed_cli(cl).is_ok()); + } + + for cl in bad_cli { + println!("Testing {:?} expecting failure", cl); + assert!(execute_parsed_cli(cl).is_err()); + } + } +} diff --git a/src/dynamic_formatter.rs b/src/dynamic_formatter.rs new file mode 100644 index 0000000..b7d37ac --- /dev/null +++ b/src/dynamic_formatter.rs @@ -0,0 +1,99 @@ +//! A lib of vector operators +//! Allow for replacement and formatting of strings + +use crate::{errors::SnippetError, tokenizer}; + +/// A dynamic formatter, formatting a string with any number of +/// {} with element of a Vec, by default the search doen't need to +/// be exhaustive and wont fail if either the array or format string don't +/// match up in length, use dynamic_format_strict for this behaviour + +/// A pseudo dynamic formatter, tries to fill all {} in a string with the values +/// in a vector +pub fn dynamic_format(format_string: &str, vector: Vec) -> Result +where + T: std::fmt::Display, +{ + let token_list = tokenizer::create_tokens_from_string(format_string)?; + + let cap = format_string.len() + 5 * vector.len(); + let mut final_string = String::with_capacity(cap); + let mut moving_index = 0; + for tok in token_list { + match tok { + tokenizer::SnippetToken::Substitution(s) => { + let index; + match s.id() { + Some(i) => index = i, + None => { + index = moving_index; + moving_index += 1 + } + }; + if let Some(text) = vector.get(index) { + final_string.push_str(&text.to_string()) + } else { + return Err(SnippetError::IndexError(index)); + } + } + tokenizer::SnippetToken::Text(t) => final_string.push_str(t), + } + } + Ok(final_string) +} + +/// Fill the argument vector with a list of defaults values if needed +pub fn complete_vec(to_fill: &Vec, defaults: &Vec) -> Result, SnippetError> +where + T: Clone, +{ + let size_o = to_fill.len(); + let size_d = defaults.len(); + match size_o.cmp(&size_d) { + std::cmp::Ordering::Greater => Err(SnippetError::Unknown), //TODO: Fix this error + std::cmp::Ordering::Equal => Ok(to_fill.clone()), + std::cmp::Ordering::Less => { + let mut output = to_fill.clone(); + (size_o..size_d).for_each(|i| { + output.push(defaults[i].clone()); + }); + Ok(output) + } + } +} + +#[cfg(test)] +mod test { + use super::*; + #[test] + fn test_dynamic_format() { + let res = dynamic_format( + "big str {} with many {} formatters", + vec!["aaa", "bbb", "ccc", "dddd"], + ) + .unwrap(); + assert_eq!(res, ("big str aaa with many bbb formatters".to_string())); + let res = + dynamic_format("{} {0} {0} {2} {d} {1}", vec!["aaa", "bbb", "ccc", "dddd"]).unwrap(); + assert_eq!(res, ("aaa aaa aaa ccc {d} bbb".to_string())); + let res = dynamic_format("{100}", vec!["a"]); + assert!(res.is_err()); + + let res = dynamic_format("", vec!["a"]).unwrap(); + assert_eq!(res, "".to_string()); + } + + #[test] + fn test_complete_vec() { + let smol = vec!["A"]; + let big = vec!["a", "b", "c", "d", "e", "f"]; + let eq = vec!["T", "U", "I", "O"]; + let deff = vec!["AA", "BB", "CC", "DD"]; + assert_eq!( + complete_vec(&smol, &deff).unwrap(), + vec!["A", "BB", "CC", "DD"] + ); + assert_eq!(complete_vec(&eq, &deff).unwrap(), eq); + assert!(complete_vec(&big, &deff).is_err()); + } +} diff --git a/src/errors.rs b/src/errors.rs new file mode 100644 index 0000000..ca4ee10 --- /dev/null +++ b/src/errors.rs @@ -0,0 +1,97 @@ +//! A general error module for the snp program +#![cfg(not(tarpaulin_include))] +use std::{error, fmt, path::PathBuf}; + +/// Snippet error, general error wrapper for the Snippet module +/// All error are wrapper with more information available with the source() method +#[derive(Debug)] +#[allow(dead_code)] +pub enum SnippetError { + /// A supposedly impossible to trigger error + #[allow(dead_code)] + Unknown, + /// Clap error, originating from the Cli parser + ClapError(clap::error::Error), + /// A generic IOError, the source is mandatory to get the specifics + IOError(std::io::Error), + /// Yaml error, generated during serialisation of snippets + YAMLError(serde_yaml::Error), + /// The file doesn't exits and can't be used + NotFound(PathBuf), + /// The file doen't exist and no creation was asked + NotFoundNoRetryError(PathBuf), + /// The snippet was found but shouldn't be erased because of flags + FoundNoEraseError(PathBuf), + /// The snippet couldn't be reparsed + ReparsingError, + /// The custom formatter coulnd't access an index + IndexError(usize), +} + +impl fmt::Display for SnippetError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + SnippetError::Unknown => write!(f, "An unknonw error occured"), + SnippetError::ClapError(..) => write!(f, "An error occured while parsing the input"), + SnippetError::IOError(..) => write!(f, "An error occured while editing the file"), + SnippetError::YAMLError(..) => { + write!(f, "Couldn't convert the given arguments into a yaml") + } + SnippetError::NotFound(ref p) => write!( + f, + "The file {:?} doesn't exists",p.file_name().unwrap(), + ), + SnippetError::NotFoundNoRetryError(ref p) => { + write!( + f, + "The config {:?} doen't exists. Use -c to create it.", + p.file_name(), + ) + } + SnippetError::FoundNoEraseError(ref p) => write!( + f, + "The snippet {:?} already exists. Use -f/--force to overwrite it.", + p.file_name().unwrap(), + ), + SnippetError::ReparsingError => write!(f,"The snipped couldn't be re-parsed, it might be caused by a bad value in your edit. \nThe snipped was saved as a raw file instead but cant be used as is."), + SnippetError::IndexError(ref i) => write!(f,"An error occured while trying to access the index {} of the given arguments.\nThe default arguments for this command likely do not support {0} arguments",i), + } + } +} + +impl error::Error for SnippetError { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + match *self { + SnippetError::Unknown => None, + // The cause is the underlying implementation error type. Is implicitly + // cast to the trait object `&error::Error`. This works because the + // underlying type already implements the `Error` trait. + SnippetError::ClapError(ref e) => Some(e), + SnippetError::IOError(ref e) => Some(e), + SnippetError::YAMLError(ref e) => Some(e), + SnippetError::NotFound(_) => None, + SnippetError::NotFoundNoRetryError(_) => None, + SnippetError::FoundNoEraseError(_) => None, + SnippetError::ReparsingError => None, + SnippetError::IndexError(_) => None, + } + } +} + +impl From for SnippetError { + fn from(err: clap::error::Error) -> SnippetError { + SnippetError::ClapError(err) + } +} + +impl From for SnippetError { + fn from(err: std::io::Error) -> SnippetError { + SnippetError::IOError(err) + } +} + +impl From for SnippetError { + fn from(err: serde_yaml::Error) -> SnippetError { + SnippetError::YAMLError(err) + } +} diff --git a/src/main.rs b/src/main.rs index a705de5..63a7e9b 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,23 +4,20 @@ #![allow(clippy::result_unit_err)] use clap::Parser; -use serde::{Deserialize, Serialize}; - -use std::{ - env, - fs::{create_dir_all, File}, - io::{self, Write}, - path::PathBuf, -}; -// use serde_yaml; +mod actions; +mod dynamic_formatter; +mod errors; +mod snippet; +mod tokenizer; +mod wrapper_functions; /// The cli arguments to give to the utility #[derive(Parser, Debug)] #[command(author, version, about)] -struct Cli { +pub struct Cli { /// The snippet name (and therefore his path) #[arg()] - snipplet: String, + snippet: String, /// Wether to try to load or instead create a new one #[arg(short, long, default_value_t = false)] @@ -30,208 +27,30 @@ struct Cli { #[arg(short, long, default_value_t = false)] locate: bool, + /// Launch the editor and edit the snippet + #[arg(short, long, default_value_t = false)] + edit: bool, + + /// Launch the editor and edit the whole snippet + #[arg(short = 'E', long = "Edit", default_value_t = false)] + edit_all: bool, + /// The list of arguments to give to the snippet /// if the -c flag is used, it's used to create the default arguments #[arg(help = "List of args to give to the snipplet")] args: Vec, + + /// Wether to force the creation or save and overwrite existing data + #[arg(short, long, default_value_t = false)] + force: bool, + + /// Wether to delete a snippet, takes precedence over everything + #[arg(short, long, default_value_t = false)] + delete: bool, } -fn main() { +/// Main entry point, everything is defered for testing and coverage +fn main() -> Result<(), errors::SnippetError> { let cli = Cli::parse(); - match cli.create { - true => create_snippet(cli), - false => print_snippet(&cli), - } -} - -/// Create a new snippet with the given cli args -/// * Find if the snippet exists -/// * Create a snippet with the given data -/// * Write the snippet -fn create_snippet(args: Cli) { - // Find if the snippet exists - let mut save_path = match config_folder() { - Ok(path) => path, - Err(e) => panic!( - "The OS couldn't locate a place to save the snippets.\n {}", - e - ), - }; - // if args.verbose println!("{}",save_path); - - // Create a snippet with the given data - let snp = Snippet::new(args.snipplet.clone(), args.args, String::from("")); - // println!("{}", serde_yaml::to_string(&snp).unwrap()); - - let mut file = match create_dir_all(&save_path) { - Ok(()) => { - save_path.push(format!("{}.yaml", args.snipplet)); - if args.locate { - println!("Saving snippet to {:?}", save_path); - } - File::create(&save_path).unwrap_or_else(|e| { - panic!("Couldn't create snippet file at {:?} {:}", save_path, e) - }) - } - Err(e) => panic!("Couldn't write to path {:?}. {}", save_path, e), - }; - - // Write the snippet - write!( - file, - "{}", - serde_yaml::to_string(&snp).expect("Couldn't convert the given arguments into a yaml") - ) - .unwrap_or_else(|_| panic!("Couldn't write yaml to file {:?}", save_path)); -} - -/// Find a configuration folder/name for the given snippet name -fn config_folder() -> io::Result { - let exe = env::current_exe()?; - let dir = exe.parent().expect("Executable must be in some directory"); - let mut dir = dir.join(".config"); - dir.push("snp_config"); - // dir.push(format!("{}.yaml", name)); - Ok(dir) -} - -/// Print the snippet to stdout -fn print_snippet(args: &Cli) { - // Try to load the snippet - let mut path = config_folder().expect("Coudln't open config folder"); - path.push(format!("{}.yaml", args.snipplet)); - let f = std::fs::File::open(&path).expect("Could not open snippet file."); - let snp: Snippet = serde_yaml::from_reader(f).expect("Couldn't parse values"); - - // Add the given arguments to the snippet - let final_args = match complete_vec(&args.args, &snp.arguments) { - Err(_) => panic!("Too many arguments given to the snippet, aborting"), - Ok(argg) => argg, - }; - - // Print the snippet - let f_str = match dynamic_format(&snp.content, final_args) { - Err(_) => panic!("Couldn't format the snippet !"), - Ok(sn) => sn, - }; - if args.locate { - println!("{}", path.to_string_lossy()); - } else { - println!("{}", f_str); - } -} - -/// A snippet ready to be Serialized/Deserialized -#[derive(Deserialize, Serialize, Debug)] -pub struct Snippet { - /// Akin to path, the name of the snippet is where to store it - name: String, - - /// The default value of all args - arguments: Vec, - - /// The base string to format - content: String, -} - -impl Snippet { - /// Create a new snippet - pub fn new(name: String, arguments: Vec, content: String) -> Self { - Snippet { - name, - arguments, - content, - } - } - - // /// Save the snippet at the default location under it's name - // pub fn save(&self) -> Result<(), ()> { - // Ok(()) - // } - - /// Tries to load a path and return a snippet - // pub fn load(path: String) -> Result { - // Err(()) - // } - - /// Write to stdout the snipped with either default arguments or given arguments - pub fn print(&self) -> Result<(), ()> { - Ok(()) - } -} - -// pub struct AccessError{ - -// } - -/// A dynamic formatter, formatting a string with any number of -/// {} with element of a Vec, by default the search doen't need to -/// be exhaustive and wont fail if either the array or format string don't -/// match up in length, use dynamic_format_strict for this behaviour -pub fn dynamic_format(format_string: &str, vector: Vec) -> Result -where - T: std::fmt::Display, -{ - let collected_format_string: Vec<&str> = format_string.split/*_inclusive*/("{}").collect(); - // println!("{:?}", collected_format_string); - let size_str = collected_format_string.len(); - let size_vec = vector.len(); - - let mut fmt_vec = Vec::new(); - for (i, text) in collected_format_string.iter().enumerate() { - fmt_vec.push(text.to_string()); - if i < size_vec && i < size_str - 1 { - fmt_vec.push(format!("{}", vector[i])); - } - } - Ok(fmt_vec.join("")) -} - -/// Fill the argument vector with a list of defaults values if needed -pub fn complete_vec(to_fill: &Vec, defaults: &Vec) -> Result, ()> -where - T: Clone, -{ - let size_o = to_fill.len(); - let size_d = defaults.len(); - match size_o.cmp(&size_d) { - std::cmp::Ordering::Greater => Err(()), - std::cmp::Ordering::Equal => Ok(to_fill.clone()), - std::cmp::Ordering::Less => { - let mut output = to_fill.clone(); - (size_o..size_d).for_each(|i| { - output.push(defaults[i].clone()); - }); - Ok(output) - } - } -} - -#[cfg(test)] -mod test { - use super::*; - #[test] - fn test_dynamic_format() { - let res = dynamic_format( - "big str {} with many {} formatters", - vec!["aaa", "bbb", "ccc", "dddd"], - ); - assert_eq!(res, Ok("big str aaa with many bbb formatters".to_string())); - } - - #[test] - fn test_complete_vec() { - let smol = vec!["A"]; - let big = vec!["a", "b", "c", "d", "e", "f"]; - let eq = vec!["T", "U", "I", "O"]; - let deff = vec!["AA", "BB", "CC", "DD"]; - assert_eq!( - complete_vec(&smol, &deff).unwrap(), - vec!["A", "BB", "CC", "DD"] - ); - assert_eq!(complete_vec(&eq, &deff).unwrap(), eq); - if let Ok(x) = complete_vec(&big, &deff) { - panic!("Complete vec should return an error ob bigger vecs") - }; - } + actions::execute_parsed_cli(cli) } diff --git a/src/snippet.rs b/src/snippet.rs new file mode 100644 index 0000000..1e3046b --- /dev/null +++ b/src/snippet.rs @@ -0,0 +1,78 @@ +//! Snippet module, holding most of the logic of the snippet +//! +//! Saving, loading, writing etc... + +use clap::error::Result; +use serde::{Deserialize, Serialize}; +use std::{fs::File, io::Write}; + +use crate::errors::SnippetError; + +/// A snippet ready to be Serialized/Deserialized +/// +/// No conditionnal behaviour is handle by this module, +/// all calls will force, override and delete by default +#[derive(Deserialize, Serialize, Debug)] +pub struct Snippet { + /// Akin to path, the name of the snippet is where to store it + pub name: String, + + /// The default value of all args + pub default_values: Vec, + + /// The base string to format + pub content: String, +} + +impl Snippet { + /// Create a new snippet + pub fn new(name: String, default_values: Vec, content: String) -> Self { + Snippet { + name, + default_values, + content, + } + } + + /// Save the snippet in a file, errors on write error + pub fn save_in(&self, mut file: &std::fs::File) -> Result<(), SnippetError> { + write!(file, "{}", serde_yaml::to_string(self)?)?; + Ok(()) + } + + /// Mutate the contents in place + pub fn edit(&mut self) -> Result<(), SnippetError> { + self.content = edit::edit(self.content.clone())?; + Ok(()) + } + + /// Create snippet from file buffer (deserialize) + pub fn from_file(f: &File) -> Result { + let snp: Snippet = serde_yaml::from_reader(f)?; + Ok(snp) + } + + /// Create a snippet from a String reference (typically used for edits) + pub fn from_string(buffer: &str) -> std::result::Result { + let snp: Snippet = serde_yaml::from_str(buffer)?; + Ok(snp) + } + + /// Forcefully save a snippet, will erase the file if already existing + pub fn write_over(&self, path: &std::path::PathBuf) -> Result<(), SnippetError> { + let mut f = File::create(path)?; + write!(f, "{}", serde_yaml::to_string(self)?)?; + Ok(()) + } + + /// Create an empty snippet and immediately serialize it + pub fn empty(name: String, default_values: Vec) -> String { + serde_yaml::to_string(&Snippet { + name, + default_values, + content: String::new(), + //..Snippet::default(), + }) + .unwrap() + } +} diff --git a/src/tokenizer.rs b/src/tokenizer.rs new file mode 100644 index 0000000..598738a --- /dev/null +++ b/src/tokenizer.rs @@ -0,0 +1,151 @@ +//! Tokenizer module, tasked to parse a string and return a list of tokens +//! +//! As the dynamic formatter, the tokenizer is supposedly format agnostic + +use regex::Regex; + +use crate::errors::SnippetError; + +/// A formatter, containing (or not) an argument to be subsitued with +#[derive(Debug)] +#[cfg_attr(test, derive(PartialEq))] +pub struct CustFormatter { + /// The positional id of the element to replace with + pub id: Option, +} + +impl CustFormatter { + /// Create a CustomFormatter from a string, either void (positional) with a parsable (fixed) + fn new(text: &str) -> CustFormatter { + if text.is_empty() { + return CustFormatter { id: None }; + } + CustFormatter { + id: Some(text.parse::().unwrap()), + } + } + + /// Return an option of the Id + pub fn id(&self) -> Option { + self.id + } +} + +/// The parsed snippet +#[derive(Debug)] +#[cfg_attr(test, derive(PartialEq))] +pub enum SnippetToken<'a> { + /// A subsitution token, containing either an index or nothing (and being "positional") + Substitution(CustFormatter), + /// A text token, the inbetween + Text(&'a str), +} + +/// Assert where the read head is +enum Status { + /// Read head in inside a formatter + Formater, + /// Read head is outside a formatter + Text, +} + +/// Add not empty values only +macro_rules! push_if_some { + ($vec:ident, $val:expr) => { + if let Some(x) = $val { + $vec.push(x); + }; + }; +} + +/// Create a Token list from the snippet given and return it as a vector of token +pub fn create_tokens_from_string(snippet: &str) -> Result, SnippetError> { + let re = Regex::new(r"\{\d*\}").unwrap(); + let matches = re.find_iter(snippet); + let mut readhead = 0; // Starting to read at zero + let mut token_list = Vec::new(); + for r in matches { + // Assume we matched text from read to here + push_if_some!( + token_list, + create_token_from_pos(snippet, Status::Text, readhead, Some(r.start())) + ); + push_if_some!( + token_list, + create_token_from_pos(snippet, Status::Formater, r.start(), Some(r.end()),) + ); + readhead = r.end(); + } + push_if_some!( + token_list, + create_token_from_pos(snippet, Status::Text, readhead, None) + ); + + Ok(token_list) +} + +/// Create a single Token from the current positions +fn create_token_from_pos( + text: &str, + status: Status, + start: usize, + stop: Option, +) -> Option { + let text = match (stop, status) { + (None, Status::Formater) => { + SnippetToken::Substitution(CustFormatter::new(&text[start + 1..])) + } + (None, Status::Text) => SnippetToken::Text(&text[start..]), + (Some(stop), Status::Formater) => { + SnippetToken::Substitution(CustFormatter::new(&text[start + 1..stop - 1])) + } + (Some(stop), Status::Text) => SnippetToken::Text(&text[start..stop]), + }; + + Some(text) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn test_create_token_from_pos() { + // All calls + let text = String::from("0123456789"); + assert_eq!( + create_token_from_pos(&text, Status::Formater, 5, None), + Some(SnippetToken::Substitution(CustFormatter::new("6789"))) + ); + assert_eq!( + create_token_from_pos(&text, Status::Text, 7, None), + Some(SnippetToken::Text("789")) + ); + assert_eq!( + create_token_from_pos(&text, Status::Formater, 2, Some(5)), //Need at least 2 digits + Some(SnippetToken::Substitution(CustFormatter::new("3"))) + ); + + assert_eq!( + create_token_from_pos(&text, Status::Text, 0, Some(1)), + Some(SnippetToken::Text("0")) + ); + } + + #[test] + fn test_create_token_from_string() { + let v = create_tokens_from_string("{} {1} { {{}}").unwrap(); + assert_eq!( + v, + vec![ + SnippetToken::Text(""), + SnippetToken::Substitution(CustFormatter { id: None }), + SnippetToken::Text(" "), + SnippetToken::Substitution(CustFormatter { id: Some(1) }), + SnippetToken::Text(" { {"), + SnippetToken::Substitution(CustFormatter { id: None }), + SnippetToken::Text("}"), + ] + ); + } +} diff --git a/src/wrapper_functions.rs b/src/wrapper_functions.rs new file mode 100644 index 0000000..f42480d --- /dev/null +++ b/src/wrapper_functions.rs @@ -0,0 +1,346 @@ +//! Module holding the wrapper function called from the main functions +//! +//! All functions included should either take a Cli object and return a SnippetError +//! or be a helper function for such a function + +#[allow(unused)] // Mandatory because of how test and rust-analyser work +use edit::edit; + +use std::fs::create_dir_all; +use std::io::{read_to_string, Write}; +use std::{env, fs::File, path::PathBuf}; + +use crate::errors::SnippetError; +use crate::snippet::Snippet; +use crate::{dynamic_formatter, Cli}; + +// Potential way to chain all actions without re-opening +// /// The status of the snippet in memory +// pub enum PotentialSnippet { +// /// The snippet wasn't loaded +// FileDest(File), +// /// The snippet was loaded +// LoadedSnippet(Snippet), +// /// No snippet currently exists +// None, +// } + +/// Locate and print a snippet location +/// +/// Will error on snippet not existing +pub fn locate_snippet(cli: &Cli) -> Result<(), SnippetError> { + let status = check_dir_and_open(&cli.snippet)?; + match status { + FileStatus::Opened((p, _)) => { + println!("{:?}", p.as_os_str()); + Ok(()) + } + FileStatus::NotFound(p) => Err(SnippetError::NotFoundNoRetryError(p)), + } +} + +/// Create a new snippet with the given cli args +pub fn create_snippet(cli: &Cli) -> Result<(), SnippetError> { + // Create a snippet with the given data + let snp = Snippet::new(cli.snippet.clone(), cli.args.clone(), String::from("")); + let status = check_dir_and_open(&cli.snippet)?; + let (f, p) = match status { + FileStatus::Opened((p, _)) => { + if cli.force { + // Overwrite the snippet + (File::create(&p)?, p) + } else { + // Do not overrite and return an error + return Err(SnippetError::FoundNoEraseError(p)); + } + } + FileStatus::NotFound(p) => (File::create(&p)?, p), // Create a new snippet + }; + snp.save_in(&f)?; + println!("The snippet {:?} was created successfully", p); + Ok(()) +} + +/// Open and load snippet and edit it +pub fn edit_snippet(cli: &Cli) -> Result<(), SnippetError> { + // Try loading, if not existant check if create or error + let status = check_dir_and_open(&cli.snippet)?; + let (mut snp, _, p) = match status { + FileStatus::Opened((p, f)) => (Snippet::from_file(&f)?, f, p), + FileStatus::NotFound(p) => { + if cli.create { + ( + Snippet::new(cli.snippet.clone(), cli.args.clone(), String::from("")), + File::create(&p)?, + p, + ) + } else { + return Err(SnippetError::NotFoundNoRetryError(p)); + } + } + }; + + // During tests, the editor cannot be tested + #[cfg(not(feature = "test"))] + snp.edit()?; + + snp.write_over(&p)?; + println!( + "The snippet {:?} was succesfully saved", + p.file_name().unwrap() + ); + Ok(()) +} + +/// Edit the whole snippet and save it where neededi +/// Note that the snippet can be saved with another name and might trigger +/// a creation or an override +pub fn edit_whole_snippet(cli: &Cli) -> Result<(), SnippetError> { + // Try loading the snippet + let status = check_dir_and_open(&cli.snippet); + let (buf, mut p) = match status? { + FileStatus::Opened((p, f)) => (read_to_string(f)?, p), + FileStatus::NotFound(p) => { + if cli.create { + File::create(&p)?; + (Snippet::empty(cli.snippet.clone(), cli.args.clone()), p) + } else { + return Err(SnippetError::NotFoundNoRetryError(p)); + } + } + }; + + // During tests, the editor cannot be tested + #[cfg(not(feature = "test"))] + let buf = edit::edit(buf)?; + + // Try reparsing, on error no modifications will be made + match Snippet::from_string(&buf) { + Ok(snp) => { + snp.write_over(&p)?; // TODO: Consider not giving a path, as name can be changed in config + println!( + "The snippet {:?} was succesfully saved", + p.file_name().unwrap() + ); + Ok(()) + } + + Err(_) => { + // The snippet is incorrect, however it should still be saved, just under another name ? + p.set_extension("bad.yaml"); + let mut failover = File::create(&p)?; + write!(failover, "{}", &buf)?; + + println!( + "The snippet was saved under {:?} in your config", + p.file_name().unwrap() + ); + Err(SnippetError::ReparsingError) + } + } +} + +// This code is used to check if the name changed but should be moved to a separate function +// let old_name = snp.name.clone(); +// // During tests, the editor cannot be tested +// #[cfg(not(feature = "test"))] +// snp.edit()?; + +// if snp.name == old_name { +// snp.write_over(&p) +// } else { +// match check_dir_and_open(&snp.name)? { +// FileStatus::Opened((p, _f)) => { +// if cli.force { +// std::fs::remove_file(&p)?; +// snp.write_over(&p) +// } else { +// Err(SnippetError::NotFoundNoRetryError(p)) +// } +// } +// FileStatus::NotFound(p) => snp.write_over(&p), +// } +// } + +/// Print the snippet to stdout +pub fn print_snippet(cli: &Cli) -> Result<(), SnippetError> { + // Try to load the snippet + let (_, f) = match check_dir_and_open(&cli.snippet)? { + FileStatus::Opened((p, f)) => (p, f), + FileStatus::NotFound(p) => return Err(SnippetError::NotFound(p)), + }; + + let snp = Snippet::from_file(&f)?; + + // Add the given arguments to the snippet + let final_args = dynamic_formatter::complete_vec(&cli.args, &snp.default_values)?; + + // Print the snippet + let f_str = dynamic_formatter::dynamic_format(&snp.content, final_args)?; + + println!("{}", f_str); + Ok(()) +} + +/// Delete a given snippet, errors if the snippet doesn't exists +pub fn delete_snippet(cli: &Cli) -> Result<(), SnippetError> { + let mut path = config_folder()?; + path.push(format!("{}.yaml", cli.snippet)); + std::fs::remove_file(path)?; + Ok(()) +} +/// The status of the request after the path was attempted to be opened +pub enum FileStatus { + /// The file was opened with success a tuple is returned + /// because the path is sometimes usefull to know, but may be dropped + /// when not + Opened((PathBuf, File)), + /// The file didn't exists and might need to be created + NotFound(PathBuf), +} + +/// Full wrapper function, tries to open the config +/// Create the folder and tries to open the file +/// On sucess return a FileStatus::File and a FileStatus::Path or error +/// The rest of the logic is handled by the caller +pub fn check_dir_and_open(name: &str) -> Result { + let mut dir_path = config_folder()?; + create_dir_all(&dir_path)?; + dir_path.push(format!("{}.yaml", name)); + match File::open(&dir_path) { + Ok(f) => Ok(FileStatus::Opened((dir_path, f))), + Err(_e) => Ok(FileStatus::NotFound(dir_path)), + } +} + +/// Find a configuration folder/name for the given snippet name +pub fn config_folder() -> Result { + let exe = env::current_exe()?; + let dir = exe.parent().expect("Executable must be in some directory"); + let mut dir = dir.join(".config"); + dir.push("snp_config"); + Ok(dir) +} + +#[cfg(test)] +pub mod test { + use super::*; + use clap::Parser; + use std::io::Write; + + macro_rules! false_cli { + ($($arg:expr),+) => { + &Cli::parse_from(vec![$($arg),+]) + }; + } + + /// Find the path of the given snippet + /// This function should suceed in every situation where a config folder can be set + fn snippet_path(snp: &str) -> Result { + let mut dir = config_folder()?; + dir.push(format!("{}.yaml", snp)); + Ok(dir) + } + + #[test] + fn test_config_creation() { + // Try to locate where to set the config + let path: PathBuf = snippet_path("test_config_creation").unwrap(); + create_dir_all(path.parent().unwrap()).unwrap(); + let _f = File::create(path).unwrap(); + assert!(matches!( + check_dir_and_open("test_config_creation").expect("Can't open config"), + FileStatus::Opened(_) + )); + } + + #[test] + fn test_delete_snippet() { + assert!(create_snippet(false_cli!("-c", "delete_snippet")).is_ok()); + assert!(delete_snippet(false_cli!("-d", "delete_snippet")).is_ok()); + } + + #[test] + fn test_locate() { + // Try to locate an unexisting snippet + let theorical_path = snippet_path("test_locate").expect("Can't find config path"); + _ = std::fs::remove_file(&theorical_path); + + // Locating the snippet should fail + assert!(locate_snippet(false_cli!("-l", "test_locate")).is_err()); + + let mut f = File::create(&theorical_path).expect("Couldn't create file"); + write!(f, "N").expect("Couldn't write on the new file"); + f.sync_data().expect("Can't sync file"); + + // Locating the snippet should now suceed + assert!(locate_snippet(false_cli!("-l", "test_locate")).is_ok()); + } + + #[test] + fn test_print_snippet() { + let theorical_path = snippet_path("test_print").expect("Can't find config path"); + _ = std::fs::remove_file(theorical_path); + + // Print non existing snippet + assert!(print_snippet(false_cli!("snp", "test_print")).is_err()); + + // Create snippet + assert!(create_snippet(false_cli!("-c", "test_print")).is_ok()); + assert!(print_snippet(false_cli!("snp", "test_print")).is_ok()); + // assert!(print_snippet(false_cli!("-l", "test_print")).is_ok()); + } + + #[test] + fn test_create() { + _ = std::fs::remove_file(snippet_path("create_snippet").unwrap()); + // Test to create empty + assert!(create_snippet(false_cli!("-c", "create_snippet")).is_ok()); + + // Test to create again + assert!(create_snippet(false_cli!("-c", "create_snippet")).is_err()); + + // Test to create with force + assert!(create_snippet(false_cli!("-c", "-f", "create_snippet")).is_ok()); + } + + #[test] + fn test_edit() { + _ = std::fs::remove_file(snippet_path("edit_content").unwrap()); + // Open unnexitant + assert!(edit_snippet(false_cli!("-e", "edit_content")).is_err()); + + // Force creation + assert!(edit_snippet(false_cli!("-e", "-c", "edit_content")).is_ok()); + + // Edit when created + + println!("{:?}", edit_snippet(false_cli!("-e", "edit_content"))); + assert!(edit_snippet(false_cli!("-e", "edit_content")).is_ok()); + } + + #[test] + fn test_edit_whole() { + _ = std::fs::remove_file(snippet_path("edit_whole").unwrap()); + // Open unnexitant + assert!(edit_whole_snippet(false_cli!("-E", "edit_whole")).is_err()); + + // Force creation + assert!(edit_whole_snippet(false_cli!("-E", "-c", "edit_whole")).is_ok()); + + // Edit when created + assert!(edit_whole_snippet(false_cli!("-E", "edit_whole")).is_ok()); + + // Create a badly formatted file + if let FileStatus::Opened((p, _)) = check_dir_and_open("edit_whole").unwrap() { + let mut f = File::create(p).unwrap(); + write!(f, "badly formatter yaml").unwrap(); + + assert!(edit_whole_snippet(false_cli!("-E", "edit_whole")).is_err()); + assert!(matches!( + check_dir_and_open("edit_whole.bad").unwrap(), + FileStatus::Opened(_) + )); + }; + } +}