cleaned up stdout significantly, removed unnecessary delay

404salad · 404salad · commit 8e922f683b3e · 2024-09-05T19:52:06.000+05:30
diff --git a/config.toml b/config.toml
@@ -1,5 +1,6 @@
-# Hi! this is a minimal config file for pond
-
-author_name = 'Sahil Upasane'
-blog_name = '404salad'
-
+author_name = """
+sahil
+"""
+blog_name = """
+404salad
+"""
diff --git a/dist/index.html b/dist/index.html
@@ -2,7 +2,8 @@
         <html lang="en">
         <head>
             <meta charset="UTF-8">
-            <title>404salad</title>
+            <title>404salad
+</title>
             <link rel="stylesheet" href="style.css">
             <script>
                 function filterArticles() { 
@@ -28,8 +29,10 @@
         </head>
         <body class="container">
             <br>
-            <h1>404salad</h1>
-            <h6>Sahil Upasane</h6>
+            <h1>404salad
+</h1>
+            <h6>sahil
+</h6>
             <input type="search" id="search" name="search" placeholder="Type to search..." onkeyup="filterArticles()">
             <br>
             <br>
diff --git a/src/config.rs b/src/config.rs
@@ -1,9 +1,10 @@
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::fmt;
-use std::fs::read_to_string;
+use std::fs::{read_to_string, File};
 use std::io::{self, Write};
+use std::path::Path;
 
-#[derive(Deserialize, Clone)]
+#[derive(Deserialize, Clone, Serialize)]
 pub struct UserConfig {
     pub author_name: String,
     pub blog_name: String,
@@ -20,28 +21,49 @@ impl fmt::Display for UserConfig {
     }
 }
 
-/*
-pub fn initial_config () {
-    print!("enter your name > " );
+pub fn initial_config() {
+    // only run config setup if the config file doesnt exists
+    if Path::new("config.toml").exists() {
+        return;
+    }
+
+    // taking user input
+    print!("enter your name > ");
     io::stdout().flush().expect("flush failed");
     let mut author_name = String::new();
     io::stdin()
         .read_line(&mut author_name)
         .expect("readline failed");
 
-    print!("enter blog name > " );
+    print!("enter blog name > ");
     io::stdout().flush().expect("flush failed");
     let mut blog_name = String::new();
     io::stdin()
         .read_line(&mut blog_name)
         .expect("readline failed");
 
-    let user = UserConfig{
+    let user = UserConfig {
         author_name,
         blog_name,
     };
+    let toml_config: String = match toml::to_string(&user) {
+        Ok(config_str) => config_str,
+        Err(why) => panic!("invalid config file due to {why}"),
+    };
+
+    // writing to config file
+    let config_path = Path::new("config.toml");
+
+    let mut config_file = match File::create(&config_path) {
+        Err(why) => panic!("cant create config file because {}", why),
+        Ok(file) => file,
+    };
+
+    match config_file.write_all(toml_config.as_bytes()) {
+        Err(why) => panic!("cant write to config file because {}", why),
+        Ok(_) => println!("succesfully created config file"),
+    }
 }
-*/
 
 pub fn read_config() -> Result<UserConfig, toml::de::Error> {
     let config_file_data = match read_to_string("config.toml") {
diff --git a/src/consolidate_into_homepage.rs b/src/consolidate_into_homepage.rs
@@ -1,10 +1,10 @@
+use super::config;
 use std::fs;
 use std::fs::File;
-use std::io::{Write};
-use super::config;
+use std::io::Write;
 
-pub fn read_directory_content() -> Vec<String>{
-    let mut article_names:Vec<String> = vec![];
+pub fn read_directory_content() -> Vec<String> {
+    let mut article_names: Vec<String> = vec![];
     let paths_result = fs::read_dir("content");
     // iterating through paths
     match paths_result {
@@ -13,10 +13,12 @@ pub fn read_directory_content() -> Vec<String>{
                 match path_result {
                     Ok(path) => {
                         if let Some(path_str) = path.path().to_str() {
-                            article_names.push(path_str
-                                               .trim_start_matches("content/")
-                                               .trim_end_matches(".md")
-                                               .to_string());
+                            article_names.push(
+                                path_str
+                                    .trim_start_matches("content/")
+                                    .trim_end_matches(".md")
+                                    .to_string(),
+                            );
                         } else {
                             eprintln!("Error converting path to string");
                         }
@@ -80,21 +82,23 @@ pub fn create_homepage(user_config: &config::UserConfig) -> std::io::Result<()>
             user_config.blog_name, user_config.blog_name, user_config.author_name
                 ));
 
-            for article_name in article_names {
-                document.push_str(&format!(
-                        "<article>
+    for article_name in article_names {
+        document.push_str(&format!(
+            "<article>
                 <a href=\"articles/{article_name}.html\"> {article_name} </a>
             </article>",
             article_name = article_name
-            ));
-            }
+        ));
+    }
 
-            document.push_str("
+    document.push_str(
+        "
             </section>
         </body>
-        </html>");
+        </html>",
+    );
 
-            let mut file = File::create(output_path)?;
-            write!(file, "{}", document)?;
-            Ok(())
+    let mut file = File::create(output_path)?;
+    write!(file, "{}", document)?;
+    Ok(())
 }
diff --git a/src/main.rs b/src/main.rs
@@ -5,15 +5,13 @@ pub mod utils;
 
 use rayon::prelude::*;
 use std::fs;
-use std::thread;
-use std::time::Duration;
 
 use console::Term;
 
 fn main() {
     let term = Term::stdout();
-    term.clear_screen();
-    term.write_line(
+    let _ = term.clear_screen();
+    let _ = term.write_line(
         "
     ██████   ██████  ███    ██ ██████      ███████ ███████  ██████  
     ██   ██ ██    ██ ████   ██ ██   ██     ██      ██      ██       
@@ -22,38 +20,36 @@ fn main() {
     ██       ██████  ██   ████ ██████      ███████ ███████  ██████  
                     ",
     );
-    thread::sleep(Duration::from_millis(200));
-    term.write_line("       A simple cli tool to convert markdown to blog");
+    let _ = term.write_line("       A simple cli tool to convert markdown to blog");
 
-    // TODO: only run this function if config toml doesnt exist
-    //config::initial_config();
+    config::initial_config();
 
     let user_config = config::read_config().unwrap();
-    println!("{}", user_config);
+    //println!("{}", user_config);
 
     // Remove previous content (clean)
     let article_dir = fs::read_dir("dist/articles");
     utils::delete_dir_contents(article_dir);
 
     let article_names = consolidate_into_homepage::read_directory_content();
-    println!("{:?}", article_names);
+    // println!("{:?}", article_names);
 
     // rebuilding all the articles in content directory (parallely)
 
     article_names.par_iter().for_each(|article_name| {
         let user_config_for_threads = user_config.clone();
         match parse_one_article::markdown_to_styled_html(&article_name, &user_config_for_threads) {
-            Ok(_) => {
-                println!("succesful parse")
-            }
+            Ok(_) => {}
             Err(e) => {
                 eprintln!("unsuccesful parse {}", e)
             }
         }
     });
+    println!("generated all blogs");
+
     match consolidate_into_homepage::create_homepage(&user_config) {
         Ok(_) => {
-            println!("succesfully created homepage")
+            println!("added all blogs to homepage, view in dist/index.html")
         }
         Err(e) => {
             eprintln!("unsuccesful in creating homepage {}", e)
diff --git a/src/parse_one_article.rs b/src/parse_one_article.rs
@@ -1,9 +1,9 @@
+use super::config;
+use pulldown_cmark::{html, Options, Parser};
 use std::fs::File;
-use std::path::Path;
 use std::io::prelude::*;
-use std::io::{Write, BufReader, Error};
-use pulldown_cmark::{Parser, Options, html};
-use super::config;
+use std::io::{BufReader, Error, Write};
+use std::path::Path;
 
 // parse markdown to html
 fn parse_markdown(input: &str) -> String {
@@ -23,9 +23,10 @@ fn read_markdown<P: AsRef<Path>>(path: P) -> Result<String, Error> {
 }
 
 // wrapper for input so that standard html and styles can be injected after converting to html
-fn wrap_html(markdown_output: &str, article: &str, user_config: &config::UserConfig) -> String {
+fn wrap_html(markdown_output: &str, article: &str, _user_config: &config::UserConfig) -> String {
     let mut wrapped_html = String::from(markdown_output);
-    wrapped_html=format!("
+    wrapped_html = format!(
+        "
 <!DOCTYPE html>
     <html lang=\"en\">
     <head>
@@ -38,25 +39,28 @@ fn wrap_html(markdown_output: &str, article: &str, user_config: &config::UserCon
 <a href='../index.html'>home</a>
 <h1>  {article}  </h1>
 <hr>
-") + &wrapped_html +
 "
+    ) + &wrapped_html
+        + "
 </body>
 </html>
 ";
     wrapped_html
 }
 
 /// convert a single .md file to html
-pub fn markdown_to_styled_html(article: &str, user_config: &config::UserConfig) -> std::io::Result<()>{
+pub fn markdown_to_styled_html(
+    article: &str,
+    user_config: &config::UserConfig,
+) -> std::io::Result<()> {
+    println!("parsing - {article}");
     let mut input_path = String::from("content/") + &article.to_owned();
-    let mut output_path =String::from("dist/articles/")+ &article.to_owned();
+    let mut output_path = String::from("dist/articles/") + &article.to_owned();
     input_path.push_str(".md");
     output_path.push_str(".html");
-    println!("{input_path} => {output_path}");
     let html_from_md = parse_markdown(&read_markdown(input_path)?);
     let mut file = File::create(output_path)?;
     let wrapped_html = wrap_html(&html_from_md, article, user_config);
-    write!(file,"{wrapped_html}")?;
+    write!(file, "{wrapped_html}")?;
     Ok(())
 }
-
diff --git a/src/utils.rs b/src/utils.rs
@@ -12,8 +12,8 @@ pub fn delete_dir_contents(read_dir_res: Result<ReadDir, Error>) {
                 } else {
                     fs::remove_file(path).expect("Failed to remove a file");
                 }
-                println!("removed {:?}", entry);
             };
         }
     };
+    println!("successfully removed previous content");
 }

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@ pub fn delete_dir_contents(read_dir_res: Result<ReadDir, Error>) {`
`12`	`12`	`} else {`
`13`	`13`	`fs::remove_file(path).expect("Failed to remove a file");`
`14`	`14`	`}`
`15`		`- println!("removed {:?}", entry);`
`16`	`15`	`};`
`17`	`16`	`}`
`18`	`17`	`};`
	`18`	`+ println!("successfully removed previous content");`
`19`	`19`	`}`