1 files changed, 18 insertions, 16 deletions

diff --git a/src/main.rs b/src/main.rs
index cf2b551..14e3f22 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -18,7 +18,9 @@ fn write_to_file<P: AsRef<Path>>(path: P, content: &str) -> std::io::Result<()>
         /* There is always *at least* the base directory as a parent */
         fs::create_dir_all(path.parent().unwrap())?;
         fs::write(path, content)?;
-    } else { }
+    } else { 
+        /* Print error on stderr */
+    }
     Ok(())
 }
 
@@ -30,6 +32,9 @@ fn write_to_file<P: AsRef<Path>>(path: P, content: &str) -> std::io::Result<()>
  *      }
  *
  *      let mut text = Cow::from("This is some text...");
+ *      while MACRO.is_match(&text) {
+ *          text = MACRO.replace_all(&text, _closure);
+ *      }
  *
  * The problem with this version is that due to how `Cow` works, the value returned by
  * `replace_all` cannot live more than the borrowed `text` passed as a parameter. This is
@@ -42,10 +47,6 @@ fn write_to_file<P: AsRef<Path>>(path: P, content: &str) -> std::io::Result<()>
  * the `replace_all` function is applied as long as some replacement is possible (`while`
  * condition). In other words, all calls to `replace_all` always return an `Cow::Owned` value.
  * 
- *      while MACRO.is_match(&text) {
- *          text = MACRO.replace_all(&text, _closure);
- *      }
- *
  * This is how you would solve the problem instead:
  *
  *      while let Cow::Owned(new_text) = MACRO.replace_all(&text, _closure) {
@@ -55,9 +56,6 @@ fn write_to_file<P: AsRef<Path>>(path: P, content: &str) -> std::io::Result<()>
  * In this case, the matched `Cow::Owned` is not concerned by any lifetime (type is `Cow<'_,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.
- *
- *      println!("{}", text)
- *
  */
 fn build(blocks: &Blocks) {
     lazy_static! {
@@ -98,14 +96,19 @@ fn main() -> Result<()> {
         let mut blocks: Blocks = HashMap::new();
         pandoc.blocks.iter().for_each(|block|
             if let Block::CodeBlock((id,classes,attrs), code) = block {
-                // dbg!(block);
+                /* Only process blocks with an ID */
                 if !id.is_empty() {
-                    // TODO: si puo' migliorare
-                    let mut key = attrs.iter()
-                        .find_map(|(k,v)| if k == "path" { Some(v.clone()) } else { None })
-                        .unwrap_or(String::from(""));
-                    key.push_str(id);
-                    /* Insert (or replace) block of code. */
+                    let key = {
+                        if let Some(path) = attrs.iter().find(|(k,_)| k == "path") {
+                            format!("{}{}", path.1, id) 
+                        } else {
+                            id.to_string()
+                        }
+                    };
+                    /* Insert (or replace) block of code. In case of ID clash, the standard
+                     * behaviour is to append the new code to the existing snippet. Use the class
+                     * `.override` to override the previously encountered snippets.
+                     */
                     if classes.iter().any(|c| c == "override") {
                         blocks.insert(key, Cow::from(code));
                     } else {
@@ -125,4 +128,3 @@ fn main() -> Result<()> {
     pandoc.execute().unwrap();
     Ok(())
 }
-