Cleans up: removes unused code and unnecessary pub

src/lib.rs

@@ -1,63 +1,16 @@
 mod model;
-mod parser;
 mod reader;
 mod tokenizer;
 
-use std::path::PathBuf;
-
 use anyhow::Result;
 
-use crate::parser::Parser;
-use crate::{
-    model::{
-        AutoGeneratedVariable, Block, Comment, SimpleVariable, VariableType,
-        VariableWithRandomValue,
-    },
-    tokenizer::Tokenizer,
-};
+use crate::model::model_to_text_cli;
+use crate::tokenizer::tokenize_cli;
 
 pub fn tokenize(path: &String) -> Result<()> {
-    let mut tokenizer = Tokenizer::new(PathBuf::from(path))?;
-    for token in tokenizer.tokenize()? {
-        println!("{}: {:?}", token.error_prefix(path), token);
-    }
-
-    Ok(())
-}
-
-pub fn parse(path: &String) -> Result<()> {
-    let mut parser = Parser::new(PathBuf::from(path))?;
-    for block in parser.parse()? {
-        println!("{block}");
-    }
-
-    Ok(())
+    tokenize_cli(path)
 }
 
 pub fn model_to_text() -> Result<()> {
-    let title = Comment::new("42");
-    let description = Some(Comment::new("Fourty-two"));
-
-    let mut variable1 = SimpleVariable::new("ANSWER", None, None);
-    variable1.user_input("42");
-    let mut variable2 = SimpleVariable::new("AS_TEXT", None, None);
-    variable2.user_input("fourty two");
-    let variable3 = SimpleVariable::new("DEFAULT_VALUE_ONE", Some("default value"), None);
-    let mut variable4 = SimpleVariable::new("DEFAULT_VALUE_TWO", Some("default"), None);
-    variable4.user_input("custom");
-    let variable5 = VariableWithRandomValue::new("SECRET_KEY", None);
-    let variable6 = AutoGeneratedVariable::new("AUTO_GENERATED", "{ANSWER}-{DEFAULT_VALUE_ONE}");
-
-    let variables = vec![
-        VariableType::Input(variable1),
-        VariableType::Input(variable2),
-        VariableType::Input(variable3),
-        VariableType::Input(variable4),
-        VariableType::Random(variable5),
-        VariableType::AutoGenerated(variable6),
-    ];
-    let block = Block::new(title, description, variables);
-    println!("{block}");
-
-    Ok(())
+    model_to_text_cli()
 }

src/main.rs

@@ -1,11 +1,10 @@
 use std::env::args;
 
 use anyhow::Result;
-use createnv::{model_to_text, parse, tokenize};
+use createnv::{model_to_text, tokenize};
 
 fn main() -> Result<()> {
     if let Some(path) = args().nth(1) {
-        parse(&path)?;
         tokenize(&path)?;
 
         return Ok(());

src/model.rs

@@ -1,17 +1,18 @@
 use std::collections::HashMap;
 use std::fmt;
 
+use anyhow::Result;
 use rand::{thread_rng, Rng};
 
 const DEFAULT_RANDOM_CHARS: &str =
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*(-_=+)";
 
-pub struct Comment {
-    pub contents: String,
+struct Comment {
+    contents: String,
 }
 
 impl Comment {
-    pub fn new(contents: &str) -> Self {
+    fn new(contents: &str) -> Self {
         Self {
             contents: contents.to_string(),
         }
@@ -24,32 +25,32 @@ impl fmt::Display for Comment {
     }
 }
 
-pub trait Variable {
+trait Variable {
     fn key(&self) -> String;
     fn value(&self) -> String;
     fn to_string(&self) -> String {
         format!("{}={}", self.key(), self.value())
     }
 }
 
-pub struct SimpleVariable {
-    pub input: Option<String>,
+struct SimpleVariable {
+    input: Option<String>,
 
     name: String,
     default: Option<String>,
     help: Option<String>,
 }
 
 impl SimpleVariable {
-    pub fn new(name: &str, default: Option<&str>, help: Option<&str>) -> Self {
+    fn new(name: &str, default: Option<&str>, help: Option<&str>) -> Self {
         Self {
             name: name.to_string(),
             default: default.map(|s| s.to_string()),
             help: help.map(|s| s.to_string()),
             input: None,
         }
     }
-    pub fn user_input(&mut self, input: &str) {
+    fn user_input(&mut self, input: &str) {
         if let Some(help) = &self.help {
             println!("{help}");
         }
@@ -72,23 +73,23 @@ impl Variable for SimpleVariable {
     }
 }
 
-pub struct AutoGeneratedVariable {
-    pub name: String,
-    pub pattern: String,
+struct AutoGeneratedVariable {
+    name: String,
+    pattern: String,
 
     context: HashMap<String, String>,
 }
 
 impl AutoGeneratedVariable {
-    pub fn new(name: &str, pattern: &str) -> Self {
+    fn new(name: &str, pattern: &str) -> Self {
         Self {
             name: name.to_string(),
             pattern: pattern.to_string(),
             context: HashMap::new(),
         }
     }
 
-    pub fn load_context(&mut self, ctx: &HashMap<String, String>) {
+    fn load_context(&mut self, ctx: &HashMap<String, String>) {
         for (k, v) in ctx.iter() {
             self.context.insert(k.to_string(), v.to_string());
         }
@@ -109,13 +110,13 @@ impl Variable for AutoGeneratedVariable {
     }
 }
 
-pub struct VariableWithRandomValue {
-    pub name: String,
-    pub length: Option<i32>,
+struct VariableWithRandomValue {
+    name: String,
+    length: Option<i32>,
 }
 
 impl VariableWithRandomValue {
-    pub fn new(name: &str, length: Option<i32>) -> Self {
+    fn new(name: &str, length: Option<i32>) -> Self {
         Self {
             name: name.to_string(),
             length,
@@ -143,22 +144,22 @@ impl Variable for VariableWithRandomValue {
     }
 }
 
-pub enum VariableType {
+enum VariableType {
     Input(SimpleVariable),
     AutoGenerated(AutoGeneratedVariable),
     Random(VariableWithRandomValue),
 }
 
-pub struct Block {
-    pub title: Comment,
-    pub description: Option<Comment>,
-    pub variables: Vec<VariableType>,
+struct Block {
+    title: Comment,
+    description: Option<Comment>,
+    variables: Vec<VariableType>,
 
     context: HashMap<String, String>,
 }
 
 impl Block {
-    pub fn new(title: Comment, description: Option<Comment>, variables: Vec<VariableType>) -> Self {
+    fn new(title: Comment, description: Option<Comment>, variables: Vec<VariableType>) -> Self {
         let context: HashMap<String, String> = HashMap::new();
         let has_auto_generated_variables = variables
             .iter()
@@ -288,3 +289,32 @@ mod tests {
         assert_eq!(got, "# 42\n# Fourty-two\nANSWER=42\nAS_TEXT=fourty two")
     }
 }
+
+// TODO: remove (only written for manual tests & debug)
+pub fn model_to_text_cli() -> Result<()> {
+    let title = Comment::new("42");
+    let description = Some(Comment::new("Fourty-two"));
+
+    let mut variable1 = SimpleVariable::new("ANSWER", None, None);
+    variable1.user_input("42");
+    let mut variable2 = SimpleVariable::new("AS_TEXT", None, None);
+    variable2.user_input("fourty two");
+    let variable3 = SimpleVariable::new("DEFAULT_VALUE_ONE", Some("default value"), None);
+    let mut variable4 = SimpleVariable::new("DEFAULT_VALUE_TWO", Some("default"), None);
+    variable4.user_input("custom");
+    let variable5 = VariableWithRandomValue::new("SECRET_KEY", None);
+    let variable6 = AutoGeneratedVariable::new("AUTO_GENERATED", "{ANSWER}-{DEFAULT_VALUE_ONE}");
+
+    let variables = vec![
+        VariableType::Input(variable1),
+        VariableType::Input(variable2),
+        VariableType::Input(variable3),
+        VariableType::Input(variable4),
+        VariableType::Random(variable5),
+        VariableType::AutoGenerated(variable6),
+    ];
+    let block = Block::new(title, description, variables);
+    println!("{block}");
+
+    Ok(())
+}

src/reader.rs

@@ -4,7 +4,7 @@ use std::{
     path::PathBuf,
 };
 
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 
 #[derive(PartialEq, Eq)]
 pub enum CharType {
@@ -16,7 +16,6 @@ pub enum CharType {
 pub struct CharReader {
     pub line: usize,
     pub column: usize,
-    path: String,
     current_line: Option<String>,
     reader: BufReader<File>,
     done: bool,
@@ -27,25 +26,12 @@ impl CharReader {
         Ok(Self {
             line: 0,
             column: 0,
-            path: path.display().to_string(),
             current_line: None,
             done: false,
             reader: BufReader::new(File::open(path)?),
         })
     }
 
-    pub fn error(&self, character: &CharType, details: Option<String>) -> anyhow::Error {
-        let prefix = format!("{}:{}:{}", self.path, self.line, self.column);
-        let extra = details.map_or("".to_string(), |msg| format!(": {msg}"));
-        let token = match &character {
-            CharType::Char(char) => format!("character `{char}`"),
-            CharType::Eol => "EOL (end of line)".to_string(),
-            CharType::Eof => "EOF (end of file)".to_string(),
-        };
-
-        anyhow!(format!("{prefix}: Unexpected {token}{extra}"))
-    }
-
     pub fn next(&mut self) -> Result<CharType> {
         if self.done {
             return Ok(CharType::Eof);