release: V1 ready

src/main.rs

@@ -1,11 +1,14 @@
 mod files;
 mod parsers;
 
-use std::fs;
+use std::{
+    fs::{self, File},
+    io::Write,
+};
 
 use files::*;
 use inquire::{Select, Text};
-use parsers::apply_name_template;
+use parsers::{apply_all_templates_to_string, apply_name_template};
 use regex::Regex;
 
 #[cfg(test)]
@@ -37,6 +40,7 @@ fn main() {
     }
 }
 
+// TODO: clean up the mess, should encapsulate parsing and regex into specific functions to improve readability
 fn create_template(
     template_path: String,
     target_name: String,
@@ -49,6 +53,7 @@ fn create_template(
 
         to_create_path.replace_range(0..template_path.len(), &target_path);
 
+        // TODO: migrate to new "apply all templates to string" strategy (change the function to allow for filename type of expressions)
         let get_path_names_regex = Regex::new(r"\/(__.*__)").unwrap();
         to_create_path = get_path_names_regex
             .replace_all(&to_create_path, |captured: &regex::Captures| {
@@ -57,15 +62,32 @@ fn create_template(
             .into_owned();
 
         if path.is_dir() {
-            // Create path
+            let dir_create_result = fs::create_dir(&to_create_path);
-            create_template(
+            match dir_create_result {
-                path.display().to_string(),
+                Ok(_) => {
-                target_name.clone(),
+                    create_template(
-                to_create_path,
+                        path.display().to_string(),
-            )
+                        target_name.clone(),
-            .unwrap();
+                        to_create_path,
+                    )
+                    .unwrap();
+                }
+                Err(_) => return Err(()),
+            }
         } else {
-            // Create file
+            let template_file_content = fs::read_to_string(path).unwrap();
+            let target_file_content =
+                apply_all_templates_to_string(template_file_content, &target_name);
+            let file_result = File::create(to_create_path);
+            match file_result {
+                Ok(mut file) => {
+                    let write_result = file.write_all(target_file_content.as_bytes());
+                    if let Err(_) = write_result {
+                        return Err(());
+                    }
+                }
+                Err(_) => return Err(()),
+            }
         }
     }
 

src/parsers/expressions.rs

@@ -1,23 +0,0 @@
-pub const FILENAME_EXPRESSIONS: [&str; 9] = [
-    "__name__",
-    "__upperCase_name__",
-    "__lowerCase_name__",
-    "__camelCase_name__",
-    "__pascalCase_name__",
-    "__snakeCase_name__",
-    "__upperSnakeCase_name__",
-    "__kebabCase_name__",
-    "__lowerDotCase_name__",
-];
-
-pub const TEMPLATE_EXPRESSIONS: [&str; 9] = [
-    "{{name}}",
-    "{{upperCase name}}",
-    "{{lowerCase name}}",
-    "{{camelCase name}}",
-    "{{pascalCase name}}",
-    "{{snakeCase name}}",
-    "{{upperSnakeCase name}}",
-    "{{kebabCase name}}",
-    "{{lowerDotCase name}}",
-];

src/parsers/mod.rs

@@ -1,22 +1,35 @@
 use regex::Regex;
 
-pub mod expressions;
-
 pub fn apply_name_template(template: &str, filename: &str) -> String {
     match template {
-        "__name__" => filename.to_string(),
+        "__name__" | "{{name}}" => filename.to_string(),
-        "__upperCase_name__" => filename.to_uppercase().to_string(),
+        "__upperCase_name__" | "{{upperCase name}}" => filename.to_uppercase().to_string(),
-        "__lowerCase_name__" => filename.to_lowercase().to_string(),
+        "__lowerCase_name__" | "{{lowerCase name}}" => filename.to_lowercase().to_string(),
-        "__camelCase_name__" => parse_camel_case(filename),
+        "__camelCase_name__" | "{{camelCase name}}" => parse_camel_case(filename),
-        "__pascalCase_name__" => parse_pascal_case(filename),
+        "__pascalCase_name__" | "{{pascalCase name}}" => parse_pascal_case(filename),
-        "__snakeCase_name__" => parse_snake_case(filename),
+        "__snakeCase_name__" | "{{snakeCase name}}" => parse_snake_case(filename),
-        "__upperSnakeCase_name__" => parse_snake_case(filename).to_uppercase(),
+        "__upperSnakeCase_name__" | "{{upperSnakeCase name}}" => {
-        "__kebabCase_name__" => parse_snake_case(filename).replace("_", "-"),
+            parse_snake_case(filename).to_uppercase()
-        "__lowerDotCase_name__" => parse_snake_case(filename).replace("_", "."),
+        }
+        "__kebabCase_name__" | "{{kebabCase name}}" => parse_snake_case(filename).replace("_", "-"),
+        "__lowerDotCase_name__" | "{{lowerDotCase name}}" => {
+            parse_snake_case(filename).replace("_", ".")
+        }
         _ => filename.to_string(),
     }
 }
 
+pub fn apply_all_templates_to_string(mut input: String, replacement: &str) -> String {
+    let get_template_names_regex = Regex::new(r"(\{\{(name|upperCase name|lowerCase name|camelCase name|pascalCase name|snakeCase name|upperSnakeCase name|kebabCase name|lowerDotCase name)\}\})").unwrap();
+    input = get_template_names_regex
+        .replace_all(&input, |captured: &regex::Captures| {
+            format!("{}", apply_name_template(&captured[1], replacement),)
+        })
+        .into_owned();
+
+    input
+}
+
 fn parse_camel_case(filename: &str) -> String {
     let first_char_regex = Regex::new(r"^[A-Z]").unwrap();
     let filename = parse_pascal_case(filename);

src/parsers/test/parsers_tests.rs

@@ -1,6 +1,30 @@
 #[cfg(test)]
 pub mod tests {
-    use crate::parsers::{apply_name_template, expressions::FILENAME_EXPRESSIONS};
+    use crate::parsers::{apply_all_templates_to_string, apply_name_template};
+
+    pub const FILENAME_EXPRESSIONS: [&str; 9] = [
+        "__name__",
+        "__upperCase_name__",
+        "__lowerCase_name__",
+        "__camelCase_name__",
+        "__pascalCase_name__",
+        "__snakeCase_name__",
+        "__upperSnakeCase_name__",
+        "__kebabCase_name__",
+        "__lowerDotCase_name__",
+    ];
+
+    pub const _TEMPLATE_EXPRESSIONS: [&str; 9] = [
+        "{{name}}",
+        "{{upperCase name}}",
+        "{{lowerCase name}}",
+        "{{camelCase name}}",
+        "{{pascalCase name}}",
+        "{{snakeCase name}}",
+        "{{upperSnakeCase name}}",
+        "{{kebabCase name}}",
+        "{{lowerDotCase name}}",
+    ];
 
     #[test]
     fn test_apply_filename_template() {
@@ -23,4 +47,13 @@ pub mod tests {
             assert_eq!(output, expected_filename_output[i])
         }
     }
+
+    #[test]
+    fn test_apply_all_templates_to_string() {
+        const NAME: &str = "this_is a-TeSt";
+        const INPUT: &str = "{{name}} {{upperCase name}}{{lowerCase name}} {{camelCase name}}{{pascalCase name}} {{snakeCase name}}{{upperSnakeCase name}} {{kebabCase name}}{{lowerDotCase name}}";
+        const EXPECTED_OUTPUT: &str = "this_is a-TeSt THIS_IS A-TESTthis_is a-test thisIsATeStThisIsATeSt this_is_a_te_stTHIS_IS_A_TE_ST this-is-a-te-stthis.is.a.te.st";
+        let output = apply_all_templates_to_string(INPUT.to_string(), NAME);
+        assert_eq!(output, EXPECTED_OUTPUT);
+    }
 }