feat(cli): simple command line interface

2 files changed, 30 insertions, 14 deletions

diff --git a/Cargo.toml b/Cargo.toml
index ccf3662..50660af 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,4 +10,5 @@ lazy_static = "1.4"
 regex = "1.5"
 pandoc = "0.8"
 pandoc_ast = "0.8"
+clap = { version = "3.1", features = ["derive"] }
 
diff --git a/src/main.rs b/src/main.rs
index c28914f..2cfb962 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,20 +1,34 @@
-use std::io::Result;
-use std::fs;
-use std::borrow::Cow;
-use std::path::{Path,PathBuf};
-use std::collections::HashMap;
+use clap::Parser;
 use lazy_static::lazy_static;
-use regex::{Captures,Regex};
 use pandoc::{InputFormat,InputKind,OutputFormat,OutputKind,Pandoc};
 use pandoc_ast::Block;
+use regex::{Captures,Regex};
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::fs;
+use std::io::Result;
+use std::path::{Path,PathBuf};
+
+const BASE: &str = "code";
 
 type Blocks<'a> = HashMap<String,Cow<'a,str>>;
 
+/// A tangler for Literate Programming in Pandoc
+#[derive(Parser, Debug)]
+#[clap(author, version, about, long_about = None)]
+struct Config {
+    /// Base output directory (default: './code')
+    #[clap(short, long)]
+    output: Option<PathBuf>,
+
+    /// Input files
+    input: Vec<PathBuf>,
+}
+
 /* Write code to target file */
-fn write_to_file<P: AsRef<Path>>(path: P, content: &str) -> std::io::Result<()> {
-    let base: PathBuf = PathBuf::from("code");
+fn write_to_file<P: AsRef<Path>>(base: &Option<PathBuf>, path: P, content: &str) -> std::io::Result<()> {
     if path.as_ref().is_relative() {
-        let path = base.join(path);
+        let path = base.clone().unwrap_or(PathBuf::from(BASE)).join(path);
         /* There is always *at least* the base directory as a parent */
         fs::create_dir_all(path.parent().unwrap())?;
         fs::write(path, content)?;
@@ -77,7 +91,7 @@ fn indent<'a>(input: Cow<'a,str>, indent: usize) -> Cow<'a,str> {
  * of the borrowed value `text`. Moreover `text` takes ownership of `new_text: String` using
  * the `Cow::from()` function. No heap allocation is performed, and the string is not copied.
  */
-fn build(blocks: &Blocks) {
+fn build(base: &Option<PathBuf>, blocks: &Blocks) {
     lazy_static! {
         static ref PATH: Regex = Regex::new(r"^(?:[[:word:]\.-]+/)*[[:word:]\.-]+\.[[:alpha:]]+$").unwrap();
         static ref MACRO: Regex = Regex::new(r"(?m)^([[:blank:]]*)<<([^>\s]+)>>").unwrap();
@@ -95,20 +109,21 @@ fn build(blocks: &Blocks) {
         }) {
             code = Cow::from(step);
         }
-        write_to_file(k, &code).expect("Unable to write to file");
+        write_to_file(base, k, &code).expect("Unable to write to file");
     })
 }
 
 fn main() -> Result<()> {
+    let config = Config::parse();
     let mut pandoc = Pandoc::new();
     /* Pandoc input setup */
-    pandoc.set_input(InputKind::Files(vec![PathBuf::from("test.md")]));
+    pandoc.set_input(InputKind::Files(config.input));
     pandoc.set_input_format(InputFormat::Markdown, vec![]);
     /* Pandoc output setup */
     pandoc.set_output(OutputKind::Pipe);
     pandoc.set_output_format(OutputFormat::Json, vec![]);
     /* Process literate program */
-    pandoc.add_filter(|json| pandoc_ast::filter(json, |pandoc| {
+    pandoc.add_filter(move |json| pandoc_ast::filter(json, |pandoc| {
         let mut blocks: Blocks = HashMap::new();
         pandoc.blocks.iter().for_each(|block|
             if let Block::CodeBlock((id,classes,attrs), code) = block {
@@ -138,7 +153,7 @@ fn main() -> Result<()> {
                 }
             }
         );
-        build(dbg!(&blocks));
+        build(&config.output, &blocks);
         pandoc
     }));
     pandoc.execute().unwrap();