rustfmt + save the note content

src/main.rs

@@ -1,11 +1,10 @@
+use slug::slugify;
 use std::env;
-use xml::{Event, Parser};
 use std::fs::File;
 use std::io::prelude::*;
 use std::path::Path;
 use std::vec::Vec;
-use slug::slugify;
+use xml::{Event, Parser};
-use base64::decode;
 
 #[derive(Debug)]
 enum CurrentTag {
@@ -14,7 +13,7 @@ enum CurrentTag {
     Resource,
     ResourceData,
     ResourceAttributes,
-    ResourceAttributesFilename
+    ResourceAttributesFilename,
 }
 
 #[derive(Debug)]
@@ -22,42 +21,69 @@ struct State {
     tag: Option<CurrentTag>,
     title: Option<String>,
     filename: Option<String>,
-    data: Vec<u8>
+    data: Vec<u8>,
+    content: Vec<u8>,
 }
 
 impl State {
     pub fn new() -> Self {
-        Self { tag: None, title: None, filename: None, data: Vec::new() }
+        Self {
+            tag: None,
+            title: None,
+            filename: None,
+            data: Vec::new(),
+            content: Vec::new(),
+        }
     }
 
-    pub fn with_title(self, title:String) -> Self {
+    pub fn with_title(self, title: String) -> Self {
-        Self { title: Some(title.to_string()),
+        Self {
-               ..self }
+            title: Some(title.to_string()),
+            ..self
+        }
     }
 
     pub fn with_filename(self, filename: String) -> Self {
-        Self { filename: Some(filename),
+        Self {
-               ..self }
+            filename: Some(filename),
+            ..self
+        }
     }
 
-    pub fn with_tag(self, tag:CurrentTag) -> Self {
+    pub fn with_tag(self, tag: CurrentTag) -> Self {
-        Self { tag: Some(tag),
+        Self {
-               ..self }
+            tag: Some(tag),
+            ..self
+        }
     }
 
-    pub fn with_data(self, data:Vec<u8>) -> Self {
+    pub fn with_data(self, data: Vec<u8>) -> Self {
-        Self { data: data,
+        Self { data: data, ..self }
-               ..self }
+    }
+
+    pub fn with_content(self, content: Vec<u8>) -> Self {
+        Self {
+            content: content,
+            ..self
+        }
     }
 
     pub fn remove_tag(self) -> Self {
-        Self { tag: None,
+        Self { tag: None, ..self }
-               ..self }
     }
 
     pub fn remove_data(self) -> Self {
-        Self { data: Vec::new(),
+        Self {
-               ..self }
+            data: Vec::new(),
+            ..self
+        }
+    }
+
+    pub fn remove_content(self) -> Self {
+        Self {
+            content: Vec::new(),
+            ..self
+        }
     }
 }
 
@@ -76,7 +102,7 @@ fn open_tag(current_state: State, tag: &str) -> State {
         "resource-attributes" => current_state.with_tag(CurrentTag::ResourceAttributes),
         "file-name" => current_state.with_tag(CurrentTag::ResourceAttributesFilename),
         "note" => State::new(),
-        _ => current_state
+        _ => current_state,
     }
 }
 
@@ -93,18 +119,30 @@ fn dump_resource(current_state: &State) -> () {
     target.write_all(&content).unwrap();
 }
 
+fn dump_note_contents(current_state: &State) -> () {
+    let filename = Path::new("data")
+        .join(current_state.title.as_ref().unwrap())
+        .join("content.md");
+    let mut target = File::create(filename).unwrap();
+    target.write_all(&current_state.content).unwrap();
+}
+
 fn close_tag(current_state: State, tag: &str) -> State {
     match tag {
         "resource" => {
             dump_resource(&current_state);
             current_state.remove_data()
         },
-        _ => current_state.remove_tag()
+        "content" => {
+            dump_note_contents(&current_state);
+            current_state.remove_content()
+        },
+        _ => current_state.remove_tag(),
     }
 }
 
 fn main() {
-    let args:Vec<_> = env::args().collect();
+    let args: Vec<_> = env::args().collect();
     if args.len() != 2 {
         println!("Required: filename.");
         std::process::exit(2);
@@ -124,7 +162,8 @@ fn main() {
     let mut parser = Parser::new();
     parser.feed_str(&contents);
 
-    parser.fold(State::new(), {|state:State, element| {
+    parser.fold(State::new(), {
+        |state: State, element| {
             println!("State: {:?}", state);
 
             match element.unwrap() {
@@ -134,18 +173,19 @@ fn main() {
                     match state.tag {
                         Some(CurrentTag::Title) => state.with_title(create_note_storage(&data)),
                         Some(CurrentTag::ResourceData) => state.with_data(
-                        data
+                            data.into_bytes()
-                            .into_bytes()
                                 .iter()
                                 .filter(|&x| *x != 13 && *x != 10) // remove new lines, it is base 64, after all
                                 .map(|&x| x)
-                            .collect()
+                                .collect(),
                         ),
+                        Some(CurrentTag::Content) => state.with_content(data.into_bytes()),
                         Some(CurrentTag::ResourceAttributesFilename) => state.with_filename(data),
-                    _ => state
+                        _ => state,
+                    }
+                }
+                _ => state,
             }
-            },
-            _ => state
         }
-    }});
+    });
 }