fix: allow more flexible entrypoint definition

Entrypoints can now be forced by using the class `entry` or by
specifying an attribute `path`.

Compatibility with previous versions is maintained and any identifier
that actually looks like a file is considered as such.

1 files changed, 33 insertions, 12 deletions

diff --git a/src/main.rs b/src/main.rs
index 02fbcd4..7d2f786 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -27,7 +27,22 @@ struct Config {
   input: Vec<PathBuf>,
 }
 
-type Blocks<'a> = HashMap<String,Cow<'a,str>>;
+#[derive(Eq, Hash, PartialEq)]
+enum Key {
+  Macro(String),
+  Entry(PathBuf)
+}
+
+impl Key {
+  fn get_path(&self) -> Option<&PathBuf> {
+    match self {
+      Self::Entry(s) => Some(&s),
+      Self::Macro(_) => None
+    }
+  }
+}
+
+type Blocks<'a> = HashMap<Key,Cow<'a,str>>;
 
 fn build(
   base: &Option<PathBuf>,
@@ -35,10 +50,6 @@ fn build(
   max_depth: u32
 ) {
   lazy_static! {
-    static ref PATH: Regex =
-      Regex::new(
-        r"^(?:[[:word:]\.-]+/)*[[:word:]\.-]+\.[[:alpha:]]+$"
-      ).unwrap();
     static ref MACRO: Regex =
       Regex::new(
         r"(?m)^([[:blank:]]*)<<([^>\s]+)>>"
@@ -46,7 +57,8 @@ fn build(
   }
   blocks
     .iter()
-    .for_each(|(path,code)| if PATH.is_match(path) { 
+    .filter_map(|(key,code)| { key.get_path().map(|k| (k,code)) })
+    .for_each(|(path,code)| {
       let mut current_depth = 0;
       let mut code = code.clone();
       while let Cow::Owned(new_code) = MACRO.replace_all(
@@ -54,7 +66,7 @@ fn build(
         |caps: &Captures| {
           if current_depth < max_depth {
             let block = blocks
-              .get(&caps[2])
+              .get(&Key::Macro(caps[2].to_string()))
               .expect("Block not present")
               .clone();
             indent(block, caps[1].len())
@@ -132,11 +144,20 @@ fn main() -> Result<()> {
           if let Block::CodeBlock((id,clss,attrs), code) = block {
             if !id.is_empty() {
               let key = {
-                let path = attrs.iter().find(|(k,_)| k == "path");
-                if let Some(path) = path {
-                  format!("{}{}", path.1, id) 
+                lazy_static! {
+                  static ref PATH: Regex =
+                    Regex::new(
+                      r"^(?:[[:word:]\.-]+/)*[[:word:]\.-]+\.[[:alpha:]]+$"
+                    ).unwrap();
+                }
+                let entry = clss.contains(&String::from("entry"));
+                let path = attrs
+                  .into_iter()
+                  .find_map(|(k,p)| if k == "path" { Some(p.clone()) } else { None });
+                if entry || path.is_some() || PATH.is_match(id) {
+                  Key::Entry(PathBuf::from(path.unwrap_or_default()).join(id)) 
                 } else {
-                  id.to_string()
+                  Key::Macro(id.to_string())
                 }
               };
               if clss.iter().any(|c| c == "override") {
@@ -162,4 +183,4 @@ fn main() -> Result<()> {
   );
   pandoc.execute().unwrap();
   Ok(())
-}
\ No newline at end of file
+}