Run cargo-fmt

src/lib.rs

@@ -1,6 +1,6 @@
 use pulldown_cmark::{Event, Parser, Tag};
 
-pub const LATEX_HEADER:&str = r#"\documentclass{scrartcl}
+pub const LATEX_HEADER: &str = r#"\documentclass{scrartcl}
 \usepackage{graphicx}
 \usepackage{hyperref}
 \usepackage{listings}
@@ -50,11 +50,11 @@ pub fn markdown_to_latex(markdown: String) -> String {
         match event {
             Event::Start(Tag::Header(level)) => {
                 output.push_str("\\");
-                for _ in 1 .. level {
+                for _ in 1..level {
                     output.push_str("sub");
                 }
                 output.push_str("section{");
-            },
+            }
             Event::End(Tag::Header(_)) => output.push_str("}\n"),
 
             Event::Start(Tag::Emphasis) => output.push_str("\\emph{"),
@@ -73,11 +73,11 @@ pub fn markdown_to_latex(markdown: String) -> String {
                 output.push_str("\\href{");
                 output.push_str(&*url);
                 output.push_str("}{");
-            },
+            }
 
             Event::End(Tag::Link(_, _, _)) => {
                 output.push_str("}");
-            },
+            }
 
             Event::Start(Tag::Image(_, path, title)) => {
                 output.push_str("\\begin{figure}\n");
@@ -88,32 +88,32 @@ pub fn markdown_to_latex(markdown: String) -> String {
                 output.push_str("\\caption{");
                 output.push_str(&*title);
                 output.push_str("}\n\\end{figure}\n");
-            },
+            }
 
             Event::Start(Tag::Item) => output.push_str("\\item "),
             Event::End(Tag::Item) => output.push_str("\n"),
 
             Event::Start(Tag::CodeBlock(lang)) => {
-                if ! lang.is_empty() {
+                if !lang.is_empty() {
                     output.push_str("\\begin{lstlisting}[language=");
                     output.push_str(&*lang);
                     output.push_str("]\n");
                 } else {
                     output.push_str("\\begin{lstlisting}\n");
                 }
-            },
+            }
 
             Event::End(Tag::CodeBlock(_)) => {
                 output.push_str("\n\\end{lstlisting}\n");
-            },
+            }
 
             Event::Text(t) => {
                 output.push_str(&*t);
-            },
+            }
 
             Event::SoftBreak => {
                 output.push('\n');
-            },
+            }
 
             _ => (),
         }
@@ -131,9 +131,9 @@ pub fn markdown_to_pdf(markdown: String) -> Result<Vec<u8>, tectonic::Error> {
 #[cfg(test)]
 mod tests {
     use super::{markdown_to_latex, markdown_to_pdf};
+    use lopdf::Document;
     use pretty_assertions::assert_eq;
     use std::io::Cursor;
-    use lopdf::Document;
 
     const MARKDOWN_IN: &str = r#"# First title
 Some content
@@ -202,14 +202,14 @@ Text
         match output {
             Ok(data) => {
                 let mut file = Cursor::new(data);
-                match Document::load_from(&mut file){
+                match Document::load_from(&mut file) {
                     Ok(doc) => {
                         assert_eq!("1.5", doc.version);
-                    },
-                    Err(_) => assert!(true)
                     }
-            },
+                    Err(_) => assert!(true),
-            Err(_) => assert!(true)
+                }
+            }
+            Err(_) => assert!(true),
         }
     }
 }

src/main.rs

@@ -1,10 +1,10 @@
+use std::ffi::OsStr;
 use std::fs::File;
 use std::io::{Read, Write};
-use std::process::exit;
 use std::path::PathBuf;
-use std::ffi::OsStr;
+use std::process::exit;
 
-use clap::{crate_authors, crate_description, crate_name, crate_version, Command, Arg};
+use clap::{crate_authors, crate_description, crate_name, crate_version, Arg, Command};
 
 use md2pdf::{markdown_to_latex, markdown_to_pdf};
 
@@ -17,36 +17,40 @@ macro_rules! unwrap {
                 exit(1);
             }
         }
-    }
+    };
 }
 
 fn main() {
-
     let matches = Command::new(crate_name!())
         .bin_name(crate_name!())
         .version(crate_version!())
         .author(crate_authors!("\n"))
         .about(crate_description!())
-        .arg(Arg::new("INPUT")
+        .arg(
+            Arg::new("INPUT")
                 .long("input")
                 .short('i')
                 .help("Input markdown files")
                 .required(true)
-             .value_parser(clap::value_parser!(PathBuf))
+                .value_parser(clap::value_parser!(PathBuf)),
         )
-        .arg(Arg::new("OUTPUT")
+        .arg(
+            Arg::new("OUTPUT")
                 .long("output")
                 .short('o')
                 .help("Output tex or pdf file")
                 .required(true)
-             .value_parser(clap::value_parser!(PathBuf))
+                .value_parser(clap::value_parser!(PathBuf)),
         )
         .get_matches();
 
     let input_path = matches.get_one::<PathBuf>("INPUT").unwrap();
     let mut content = String::new();
     let mut input = unwrap!(File::open(input_path), "couldn't open input file");
-    unwrap!(input.read_to_string(&mut content), "couldn't read file content");
+    unwrap!(
+        input.read_to_string(&mut content),
+        "couldn't read file content"
+    );
 
     let output_path = matches.get_one::<PathBuf>("OUTPUT").unwrap();
     let output_path_ext = output_path.extension().and_then(OsStr::to_str);
@@ -56,37 +60,33 @@ fn main() {
         Some("tex") => {
             let tex = markdown_to_latex(content);
             unwrap!(output.write(tex.as_bytes()), "couldn't write output file");
-        },
+        }
-        Some("pdf") => {
+        Some("pdf") => match markdown_to_pdf(content) {
-            match markdown_to_pdf(content) {
+            Ok(data) => match output.write(&data) {
-                Ok(data) => {
-                    match output.write(&data) {
                 Ok(_) => {
                     exit(0);
-                        },
+                }
                 Err(error) => {
-                            eprintln!(
+                    eprintln!("error while writing file: {}", error);
-                                "error while writing file: {}", error
-                            );
                     exit(1);
-                        },
                 }
             },
             Err(error) => {
-                    eprintln!(
+                eprintln!("error while compiling latex: {}", error.description());
-                        "error while compiling latex: {}", error.description()
-                    );
                 exit(1);
             }
-            }
         },
         Some(ext) => {
-            eprintln!("unknown file format ({}) for output: {}", ext, output_path.display());
+            eprintln!(
+                "unknown file format ({}) for output: {}",
+                ext,
+                output_path.display()
+            );
             exit(1);
-        },
+        }
         None => {
             eprintln!("unknown file format for output: {}", output_path.display());
             exit(1);
-        },
+        }
     }
 }