Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rusty-tasks"
-version = "0.1.3"
+version = "0.1.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -8,12 +8,9 @@ edition = "2021"
 [dependencies]
 chrono = "0.4.26"
 clap = { version = "4.5.1", features = ["derive"] }
-comrak = "0.24.1"
+comrak = "0.18.0"
 figment = { version = "0.10.10", features = ["env", "serde_json", "json"] }
 regex = "1.8.4"
 serde = { version = "1.0.164", features = ["serde_derive"] }
 serde_json = "1.0.97"
 resolve-path = "0.1.0"
-simple_logger = "4.3.3"
-log = "0.4.21"
-indexmap = "2.2.6"

README.md

@@ -1,111 +1,26 @@
 # Rusty-tasks
+A rewrite of an older CLI todo system without python and regex
 
-A personal task management system built on plain text and works in your favorite editor
+## Goals
 
+- [ ] BLAZING FAST!
+- [ ] replace python with rust
+- [ ] replace regex with a markdown parsing library
+- [ ] learn some rust along the way
 
-## The General Idea
+## Ideas
 
-If you've used the bullet journal technique before, think of this as the
+If you've used the bullet journal technique before, think if this as the
 digital, automated version of that.
 
-- Accessible from anywhere in the terminal (TMUX, bare shell, etc.)
+- Accessible from anywhere in the terminal (TMUX, bare shell, etc)
     * works really well with a drop-down terminal
-- Take advantage of your favorite editor (vim, Emacs, etc.)
+- Takes advantage of default editor (vim, emacs, etc)
-- Take advantage of plain text formats (Markdown)
+- Take advantage of Markdown for formatting
 - Organize tasks at different levels of urgency
     * Daily - Must get done now
     * Weekly - Must get done in the near future
-    * Monthly - I'm going to forget if I don't write it down, but It's a ways away
+    * Monthly - I'm going to forget if I don't write it down but It's a ways away
 - Every day start a new file 
     * files should be dated
-- Carry over uncompleted tasks from the previous day
+- Carry over uncompleted tasks from previous day
-
-
-## Installing 
-
-```bash
-git clone https://github.com/andrei-stoica/rusty-tasks.git
-cd rusty-task cargo install --path .
-```
-
-Alternatively, there is a binary download for AMD64 Linux machines available 
-on the [releases page](https://github.com/andrei-stoica/rusty-tasks/releases).
-Just drop that anywhere on your PATH. I recommend adding `~/bin` to your PATH
-and dropping the executable there.
-
-If you are not on an AMD64 Linux machine, you will need to build from source.
-I have not tested this on other platforms, so I hesitate to provide binaries
-for them.
-
-## Usage
-***WARNING:*** *This documentation can be ahead of the releases on the GH release page*
-```help
-Usage: rusty-tasks [OPTIONS]
-
-Options:
-  -c, --config <FILE>        set config file to use
-  -C, --current-config       show current config file
-  -d, --date <DATE>          view a specific date's file (format: YYYY-MM-DD)
-  -p, --previous <PREVIOUS>  view previous day's notes [default: 0]
-  -l, --list                 list closest files to date
-  -n, --number <NUMBER>      number of files to list [default: 5]
-  -L, --list-all             list closest files to date
-  -v, --verbose...           increase logging level
-  -h, --help                 Print help
-  -V, --version              Print version
-```
-
-Just use `rust-task` to access today's notes file.
-
-Use `rust-task -p <n>` to access a previous day's file where `<n>` is the number
-of days back you want to go. If a file does not exist for that day, it will
-default to the closest to that date. A value of 0 represents today's file.
-
-Alternatively, use `--date` or `-d` to specify a date specifically. Preferably
-in the format year-month-day, padding with zero is optional. However, if the
-year, or, year and month are omitted they will be filled in with the current
-date's year and month. For example, If the current date is `2024-2-30`, the
-string `4` will resolve to `2024-2-4`, and `1-4` will resolve to `2024-1-4`.
-
-Specify a custom config location with `-c`, otherwise, it will scan for a config
-in the locations specified in the [config section](#config). If no config
-exists it will create one. To see what config is being loaded you can use `-C`.
-
-To list your existing notes you can use `-L`. For a subset of these use
-`-l` combined with `-n` to specify the number of files to list. This will be
-the closest `n` files to the specified date, which is today by default. Specify
-the target date using the `-p` as mentioned earlier
-
-## Config
-
-The config should be located in the following locations:
-
-- `~/.config/rusty_task.json`
-- `~/.rusty_task.json`
-- `$PWD/.rusty_task.json`
-
-If there is no config it will be created at `~/.config/rusty_task.json`.
-
-Example config:
-```
-{
-  "editor": "nano",
-  "sections": [
-    "Daily",
-    "Weekly",
-    "Monthly"
-  ],
-  "notes_dir": "~/notes"
-}
-```
-
-- `editor` is the executable that will be launched to modify the notes file
-- `sections` is a list of Sections that will be carried over from the previous
-day's notes
-    * only uncompleted tasks are carried over
-    * You can use other sections for scratch space and other journaling tasks
-- `notes_dir` is the directory that stores your daily notes 
-    * this could be set to your obsidian vault if you want it to work with
-      all of your other notes (I recommend checking out [obsidian.nvim](https://github.com/epwalsh/obsidian.nvim)
-      if you want to interact with an obsidian vault in neovim)
-

TODO.md

@@ -1,8 +0,0 @@
-- [ ] Obsidian properties
-     - [ ] encoding in YAML (using Serde)
-     - [ ] config for default properties
-     - [ ] formatting for properties such as dates
-- [ ] update rendering to use comrak (it's been update)
-
-
-

src/cli/mod.rs

@@ -1,4 +1,3 @@
-use chrono::{Datelike, NaiveDate};
 use clap::Parser;
 
 #[derive(Parser, Debug)]
@@ -7,98 +6,18 @@ pub struct Args {
     /// set config file to use
     #[arg(short, long, value_name = "FILE")]
     pub config: Option<String>,
+
     /// show current config file
     #[arg(short = 'C', long)]
     pub current_config: bool,
 
-    /// view a specific date's file (YYYY-MM-DD)
-    #[arg(short, long)]
-    pub date: Option<String>,
     /// view previous day's notes
     #[arg(short = 'p', long, default_value_t = 0)]
     pub previous: u16,
     /// list closest files to date
     #[arg(short, long)]
     pub list: bool,
-    /// number of files to list
-    #[arg(short, long, default_value_t = 5)]
-    pub number: usize,
     /// list closest files to date
     #[arg(short = 'L', long)]
     pub list_all: bool,
-
-    /// increase logging level
-    #[arg(short, long, action = clap::ArgAction::Count)]
-    pub verbose: u8,
-}
-
-pub fn smart_parse_date(date_str: &str, cur_date: &NaiveDate) -> Option<NaiveDate> {
-    let full_date_fmt = "%Y-%m-%d";
-
-    if let Ok(date) = NaiveDate::parse_from_str(date_str, &full_date_fmt) {
-        return Some(date);
-    }
-    let parts: Vec<&str> = date_str.split('-').collect();
-
-    match parts.len() {
-        1 => cur_date.with_day(parts[0].parse().unwrap_or(cur_date.day())),
-        2 => cur_date
-            .with_day(parts[1].parse().unwrap_or(cur_date.day()))?
-            .with_month(parts[0].parse().unwrap_or(cur_date.month())),
-        3 => NaiveDate::from_ymd_opt(
-            parts[0].parse().ok()?,
-            parts[1].parse().ok()?,
-            parts[2].parse().ok()?,
-        ),
-        _ => None,
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_smart_parse_date() {
-        let good_date = NaiveDate::from_ymd_opt(2024, 01, 03).expect("Invalid date specified");
-        let good_date_str = good_date.format("%Y-%m-%d").to_string();
-
-        assert_eq!(
-            Some(good_date),
-            smart_parse_date(&good_date_str, &good_date)
-        );
-        let no_padding_date_str = "2024-1-3";
-        assert_eq!(
-            Some(good_date),
-            smart_parse_date(no_padding_date_str, &good_date)
-        );
-
-        let bad_day_str = "2024-01-99";
-        assert_eq!(None, smart_parse_date(bad_day_str, &good_date));
-        let no_day_str = "2024-01";
-        assert_eq!(None, smart_parse_date(no_day_str, &good_date));
-
-        let bad_month_str = "2024-25-01";
-        assert_eq!(None, smart_parse_date(bad_month_str, &good_date));
-        let no_month_str = "2024-14";
-        assert_eq!(None, smart_parse_date(no_month_str, &good_date));
-
-        let no_year_str = "01-03";
-        assert_eq!(Some(good_date), smart_parse_date(no_year_str, &good_date));
-        let bad_month_no_year_str = "25-01";
-        assert_eq!(None, smart_parse_date(bad_month_no_year_str, &good_date));
-        let bad_day_no_year_str = "01-35";
-        assert_eq!(None, smart_parse_date(bad_day_no_year_str, &good_date));
-
-        let no_year_month_str = "03";
-        assert_eq!(
-            Some(good_date),
-            smart_parse_date(no_year_month_str, &good_date)
-        );
-        let bad_day_no_year_month_str = "35";
-        assert_eq!(
-            None,
-            smart_parse_date(bad_day_no_year_month_str, &good_date)
-        );
-    }
 }

src/file/mod.rs

@@ -2,12 +2,9 @@ use crate::todo::{File as TodoFile, Status as TaskStatus};
 use crate::NaiveDate;
 use crate::TaskGroup;
 use chrono::Datelike;
-use comrak::nodes::{Ast, AstNode, LineColumn, NodeHeading, NodeValue};
+use comrak::nodes::{AstNode, NodeValue};
-use comrak::{
+use comrak::parse_document;
-    format_commonmark, parse_document, Arena, ComrakOptions, ExtensionOptions, ParseOptions,
+use comrak::{Arena, ComrakExtensionOptions, ComrakOptions, ComrakParseOptions};
-};
-use indexmap::IndexMap;
-use regex::Regex;
 use std::collections::HashMap;
 use std::fs::{read, File};
 use std::io::Write;
@@ -27,9 +24,7 @@ pub fn get_filepath(data_dir: &PathBuf, date: &NaiveDate) -> PathBuf {
     file_path
 }
 
-/// generate strings from TaskGroups and date
 pub fn generate_file_content(data: &Vec<TaskGroup>, date: &NaiveDate) -> String {
-    // TODO: This should be a type and then I can implement it with From<>
     let mut content = format!(
         "# Today's tasks {}-{:02}-{:02}\n",
         date.year(),
@@ -47,9 +42,7 @@ pub fn write_file(path: &PathBuf, content: &String) {
     write!(new_file, "{}", content).expect("Could not write to file: {today_file_path}");
 }
 
-/// Load in text file as String
 pub fn load_file(file: &TodoFile) -> String {
-    // TODO: This could be a TryFrom<>
     let contents_utf8 = read(file.file.clone())
         .expect(format!("Could not read file {}", file.file.to_string_lossy()).as_str());
     str::from_utf8(&contents_utf8)
@@ -63,17 +56,16 @@ pub fn load_file(file: &TodoFile) -> String {
         .to_string()
 }
 
-/// Parse contents of markdown file with Comrak ( relaxed tasklist matching is enabled)
 pub fn parse_todo_file<'a>(contents: &String, arena: &'a Arena<AstNode<'a>>) -> &'a AstNode<'a> {
-    let mut extension_options = ExtensionOptions::default();
-    extension_options.tasklist = true;
-
-    let mut parse_options = ParseOptions::default();
-    parse_options.relaxed_tasklist_matching = true;
-
     let options = &ComrakOptions {
-        extension: extension_options,
+        extension: ComrakExtensionOptions {
-        parse: parse_options,
+            tasklist: true,
+            ..ComrakExtensionOptions::default()
+        },
+        parse: ComrakParseOptions {
+            relaxed_tasklist_matching: true,
+            ..ComrakParseOptions::default()
+        },
         ..ComrakOptions::default()
     };
     parse_document(arena, contents, options)
@@ -119,421 +111,3 @@ pub fn extract_secitons<'a>(
     }
     groups
 }
-
-fn remove_heading<'a>(node: &'a AstNode<'a>, level: u8) {
-    let mut following = node.following_siblings();
-    let _ = following.next().unwrap();
-    for sib in following {
-        let node_ref = sib.data.borrow();
-        if let NodeValue::Heading(heading) = node_ref.value {
-            if heading.level == level {
-                break;
-            }
-        } else {
-            sib.detach();
-        }
-    }
-    node.detach();
-}
-
-/// recursively removes nodes from List
-fn remove_task_nodes<'a>(root: &'a AstNode<'a>) {
-    for node in root.children() {
-        for child_node in node.children() {
-            remove_task_nodes(child_node)
-        }
-        match node.data.borrow().value {
-            NodeValue::TaskItem(Some(status)) if status == 'x' || status == 'X' => node.detach(),
-            _ => continue,
-        }
-    }
-}
-
-fn create_title<'a>(arena: &'a Arena<AstNode<'a>>, date: &str) -> &'a AstNode<'a> {
-    let mut text = String::new();
-    text.push_str("Today's tasks ");
-    text.push_str(date);
-
-    create_heading(arena, 1, &text)
-}
-
-fn create_heading<'a>(arena: &'a Arena<AstNode<'a>>, level: u8, text: &str) -> &'a AstNode<'a> {
-    let heading_node = arena.alloc(AstNode::new(
-        Ast::new(
-            NodeValue::Heading(NodeHeading {
-                level,
-                setext: false,
-            }),
-            LineColumn { line: 0, column: 0 },
-        )
-        .into(),
-    ));
-    let text_node = arena.alloc(AstNode::new(
-        Ast::new(
-            NodeValue::Text(text.to_string()),
-            LineColumn { line: 0, column: 2 },
-        )
-        .into(),
-    ));
-
-    heading_node.append(text_node);
-
-    heading_node
-}
-
-pub fn create_new_doc<'a>(
-    arena: &'a Arena<AstNode<'a>>,
-    new_date: &str,
-    sections: IndexMap<String, Option<Vec<&'a AstNode<'a>>>>,
-) -> &'a AstNode<'a> {
-    let doc = arena.alloc(AstNode::new(
-        Ast::new(NodeValue::Document, LineColumn { line: 0, column: 0 }).into(),
-    ));
-    let title = create_title(&arena, new_date);
-    doc.append(title);
-
-    for (section, value) in sections.iter() {
-        let heading = create_heading(arena, 2, &section);
-        doc.append(heading);
-        match value {
-            Some(nodes) => {
-                for node in nodes.iter() {
-                    doc.append(node);
-                }
-            }
-            _ => (),
-        }
-    }
-    doc
-}
-
-pub fn extract_sections<'a>(
-    root: &'a AstNode<'a>,
-    sections: &Vec<String>,
-) -> IndexMap<String, Option<Vec<&'a AstNode<'a>>>> {
-    let mut section_map: IndexMap<String, Option<Vec<&'a AstNode<'a>>>> = IndexMap::new();
-    sections.iter().for_each(|section| {
-        section_map.insert(section.to_string(), None);
-    });
-
-    for node in root.reverse_children() {
-        let node_ref = node.data.borrow();
-        match node_ref.value {
-            NodeValue::Heading(heading) => {
-                let heading_content_node = if let Some(child) = node.first_child() {
-                    child
-                } else {
-                    continue;
-                };
-
-                let mut heading_content_ref = heading_content_node.data.borrow_mut();
-                if let NodeValue::Text(text) = &mut heading_content_ref.value {
-                    if sections.contains(text) {
-                        let mut content = Vec::new();
-                        let mut following = node.following_siblings();
-                        let _ = following.next().unwrap();
-
-                        for sib in following {
-                            remove_task_nodes(sib);
-                            let node_ref = sib.data.borrow();
-                            if let NodeValue::Heading(inner_heading) = node_ref.value {
-                                if heading.level == inner_heading.level {
-                                    break;
-                                }
-                            } else {
-                                content.push(sib);
-                            }
-                        }
-                        section_map.insert(text.to_string(), Some(content));
-                        remove_heading(node, heading.level);
-                    };
-                }
-            }
-            _ => continue,
-        }
-    }
-
-    section_map
-}
-
-pub fn process_doc_tree<'a>(root: &'a AstNode<'a>, new_date: &str, sections: &Vec<String>) {
-    for node in root.reverse_children() {
-        let node_ref = node.data.borrow();
-        match node_ref.value {
-            NodeValue::Heading(heading) => {
-                let heading_content_node = if let Some(child) = node.first_child() {
-                    child
-                } else {
-                    continue;
-                };
-
-                let mut heading_content_ref = heading_content_node.data.borrow_mut();
-                if let NodeValue::Text(text) = &mut heading_content_ref.value {
-                    let re = Regex::new(r"Today's tasks \d+-\d+-\d+")
-                        .expect("title regex is not parsable");
-                    if matches!(re.find(text), Some(_)) {
-                        text.clear();
-                        text.push_str("Today's tasks ");
-                        text.push_str(new_date);
-                    } else if !sections.contains(text) {
-                        remove_heading(node, heading.level);
-                    };
-                }
-            }
-            NodeValue::List(_list) => remove_task_nodes(node),
-            _ => continue,
-        }
-    }
-    eprintln!("{:#?}", root);
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::todo::{Status, Task};
-    use std::io::BufWriter;
-
-    #[test]
-    fn test_extract_sections() {
-        let test_md = "\
-# Test
-## Content
- - [ ] something
- - [x] done
- - [!] other
-## Unused
-### Sub section
- - [ ] task
-## Unrealated Stuff
- - [ ] something else
-    + [ ] subtask";
-
-        let arena = Arena::new();
-        let root = parse_todo_file(&test_md.to_string(), &arena);
-
-        let result = extract_secitons(root, &vec![]);
-        assert_eq!(result.keys().count(), 0);
-
-        let result = extract_secitons(root, &vec!["Not There".to_string()]);
-        assert_eq!(result.keys().count(), 0);
-
-        let sections = vec!["Unused".to_string()];
-        let result = extract_secitons(root, &sections);
-        assert_eq!(result.keys().count(), 0);
-
-        let sections = vec!["Sub section".to_string()];
-        let result = extract_secitons(root, &sections);
-        assert_eq!(result.keys().count(), 1);
-        assert!(result.get(sections.first().unwrap()).is_some());
-        assert_eq!(result.get(sections.first().unwrap()).unwrap().level, 3);
-
-        let sections = vec!["Content".to_string()];
-        let result = extract_secitons(root, &sections);
-        assert_eq!(result.keys().count(), 1);
-        assert!(result.get(sections.first().unwrap()).is_some());
-        assert_eq!(
-            result
-                .get(sections.first().unwrap())
-                .expect("No Value for \"Content\""),
-            &TaskGroup {
-                name: sections.first().unwrap().clone(),
-                tasks: vec![
-                    Task {
-                        status: TaskStatus::Empty,
-                        text: "something".to_string(),
-                        subtasks: None
-                    },
-                    Task {
-                        status: TaskStatus::Todo('!'),
-                        text: "other".to_string(),
-                        subtasks: None
-                    },
-                ],
-                level: 2
-            }
-        );
-
-        let sections = vec!["Unrealated Stuff".to_string()];
-        let result = extract_secitons(root, &sections);
-        assert_eq!(result.keys().count(), 1);
-        assert!(result.get(sections.first().unwrap()).is_some());
-        assert_eq!(
-            result
-                .get(sections.first().unwrap())
-                .expect("No Value for \"Content\""),
-            &TaskGroup {
-                name: sections.first().unwrap().clone(),
-                tasks: vec![Task {
-                    status: TaskStatus::Empty,
-                    text: "something else".to_string(),
-                    subtasks: Some(vec![Task {
-                        status: TaskStatus::Empty,
-                        text: "subtask".to_string(),
-                        subtasks: None
-                    }]),
-                }],
-                level: 2
-            }
-        );
-
-        let result = extract_secitons(
-            root,
-            &vec!["Content".to_string(), "Sub section".to_string()],
-        );
-        assert_eq!(result.keys().count(), 2);
-    }
-
-    #[test]
-    fn test_generate_file_content() {
-        let date = NaiveDate::from_ymd_opt(2024, 1, 1).unwrap();
-        let mut content: Vec<TaskGroup> = vec![];
-
-        let result = generate_file_content(&content, &date);
-        let expected = "# Today's tasks 2024-01-01\n";
-        assert_eq!(result, expected);
-
-        content.push(TaskGroup {
-            name: "Empty".into(),
-            tasks: vec![],
-            level: 2,
-        });
-
-        let result = generate_file_content(&content, &date);
-        let expected = "# Today's tasks 2024-01-01\n\n## Empty\n";
-        assert_eq!(result, expected);
-
-        content.push(TaskGroup {
-            name: "Subgroup".into(),
-            tasks: vec![],
-            level: 3,
-        });
-
-        let result = generate_file_content(&content, &date);
-        let expected = "# Today's tasks 2024-01-01\n\n## Empty\n\n### Subgroup\n";
-        assert_eq!(result, expected);
-
-        content.push(TaskGroup {
-            name: "Tasks".into(),
-            tasks: vec![
-                Task {
-                    status: Status::Empty,
-                    text: "task 1".into(),
-                    subtasks: None,
-                },
-                Task {
-                    status: Status::Done('x'),
-                    text: "task 2".into(),
-                    subtasks: None,
-                },
-                Task {
-                    status: Status::Todo('>'),
-                    text: "task 3".into(),
-                    subtasks: None,
-                },
-            ],
-            level: 2,
-        });
-
-        let result = generate_file_content(&content, &date);
-        let expected = "\
-# Today's tasks 2024-01-01
-
-## Empty
-
-### Subgroup
-
-## Tasks
-- [ ] task 1
-- [x] task 2
-- [>] task 3
-";
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_node_removal() {
-        let md = "
-# Today's tasks 2024-01-01
-
-## Tasks
-
-- [ ] task 1
-- [X] task 2
-- [x] task 2
-- [>] task 3
-- [!] task 3
-
-## Long Term
-
-- [ ] task 1
-- [X] task 2
-    - [ ] all of these subtasks should be removed
-        - [x] subtasks
-    - [x] sub task to remove
-- [!] task 3
-    - [ ] sub task to keep
-    - [x] sub task to remove
-
-## Todays Notes
-
-- some notes here
-- these can go
-";
-        let new_date = "2024-01-02";
-        let groups = vec![
-            "Tasks".to_string(),
-            "Other".to_string(),
-            "Long Term".to_string(),
-            "Last".to_string(),
-        ];
-        let arena = Arena::new();
-        let mut extension_options = ExtensionOptions::default();
-        extension_options.tasklist = true;
-
-        let mut parse_options = ParseOptions::default();
-        parse_options.relaxed_tasklist_matching = true;
-
-        let options = &ComrakOptions {
-            extension: extension_options,
-            parse: parse_options,
-            ..ComrakOptions::default()
-        };
-
-        let ast = parse_document(&arena, md, options);
-
-        let sections = extract_sections(ast, &groups);
-
-        let new_doc = create_new_doc(&arena, new_date, sections);
-
-        process_doc_tree(ast, new_date, &groups);
-
-        let mut output = BufWriter::new(Vec::new());
-
-        assert!(format_commonmark(new_doc, options, &mut output).is_ok());
-
-        let bytes = output.into_inner().expect("should be a vec");
-        let text = String::from_utf8(bytes).expect("should be convertable to string");
-        assert_eq!(
-            "\
-# Today's tasks 2024-01-02
-
-## Tasks
-
-- [ ] task 1
-- [>] task 3
-- [!] task 3
-
-## Other
-
-## Long Term
-
-- [ ] task 1
-- [!] task 3
-  - [ ] sub task to keep
-
-## Last
-",
-            text
-        );
-    }
-}

src/logging/mod.rs

@@ -1,26 +0,0 @@
-use log::Level;
-
-pub fn get_logging_level(verbose_level: u8) -> Level {
-    match verbose_level {
-        ..=0 => Level::Error,
-        1 => Level::Warn,
-        2 => Level::Info,
-        3 => Level::Debug,
-        4.. => Level::Trace,
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_get_logging_level() {
-        assert_eq!(get_logging_level(0), Level::Error);
-        assert_eq!(get_logging_level(1), Level::Warn);
-        assert_eq!(get_logging_level(2), Level::Info);
-        assert_eq!(get_logging_level(3), Level::Debug);
-        assert_eq!(get_logging_level(4), Level::Trace);
-        assert_eq!(get_logging_level(5), Level::Trace);
-    }
-}

src/main.rs

@@ -1,48 +1,36 @@
 mod cli;
 mod config;
 mod file;
-mod logging;
 mod todo;
 
+use crate::cli::Args;
+use crate::config::Config;
+use crate::todo::{File as TodoFile, TaskGroup};
 use chrono::naive::NaiveDate;
-use chrono::{Datelike, Local, TimeDelta};
+use chrono::{Local, TimeDelta};
 use clap::Parser;
-use cli::Args;
+use comrak::Arena;
-use comrak::{format_commonmark, Arena, ComrakOptions, ExtensionOptions, ParseOptions};
-use config::Config;
-use log;
-use logging::get_logging_level;
 use resolve_path::PathResolveExt;
-use simple_logger::init_with_level;
 use std::fs;
-use std::io::BufWriter;
 use std::path::Path;
 use std::process::Command;
-use todo::{File as TodoFile, TaskGroup};
-
-use crate::file::{create_new_doc, extract_sections, process_doc_tree};
 
 fn main() {
-    // setup
     let args = Args::parse();
-    let _logger = init_with_level(get_logging_level(args.verbose)).unwrap();
+    println!("{:?}", args);
-    log::debug!("{:?}", args);
 
-    // getting config location
     let expected_cfg_files = match Config::expected_locations() {
         Ok(cfg_files) => cfg_files,
         Err(e) => panic!("{:?}", e),
     };
 
-    // getting exising config files
     let cfg_files: Vec<&Path> = expected_cfg_files
         .iter()
         .map(|file| Path::new(file))
         .filter(|file| file.exists())
         .collect();
 
-    // writing default config if non exist
+    if cfg_files.len() <= 0 {
-    if cfg_files.len() <= 0 && args.config.is_none() {
         if let Err(e) = Config::write_default(match expected_cfg_files[0].to_str() {
             Some(s) => s,
             None => panic!("Could not resolve expected cfg file paths"),
@@ -51,7 +39,6 @@ fn main() {
         }
     }
 
-    // set witch config file to load
     let cfg_file = match args.config {
         Some(file) => file,
         None => match cfg_files.last() {
@@ -60,36 +47,29 @@ fn main() {
         },
     };
 
-    // show current config file or just log it based on args
     if args.current_config {
-        print!("{}", &cfg_file);
+        println!("{}", &cfg_file);
         return;
-    } else {
-        log::debug!("config file: {}", &cfg_file);
     }
 
-    // load config file
     let cfg = match Config::load(&cfg_file) {
         Ok(cfg) => cfg,
         Err(_e) => panic!("could not load config: {}", cfg_file),
     };
-    log::debug!("{:#?}", cfg);
 
-    // resolve data directory and create it if it does not exisit
     let data_dir = cfg.notes_dir.resolve().to_path_buf();
+
     if !fs::metadata(&data_dir).is_ok() {
         match fs::create_dir_all(&data_dir) {
             Err(_e) => panic!("Could not create default directory: {:?}", &data_dir),
-            _ => log::info!("created dir {}", &data_dir.to_string_lossy()),
+            _ => (),
         };
     }
 
-    // get file paths of notes
     let files = fs::read_dir(&data_dir)
         .expect(format!("Could not find notes folder: {:?}", &data_dir).as_str())
         .filter_map(|f| f.ok())
         .map(|file| file.path());
-    // list all notes
     if args.list_all {
         files
             .into_iter()
@@ -97,86 +77,45 @@ fn main() {
         return ();
     }
 
-    // get clossest files to specified date
     let today = Local::now().date_naive();
-    let target = if let Some(date_str) = args.date {
+    let target = today - TimeDelta::try_days(args.previous.into()).unwrap();
-        cli::smart_parse_date(&date_str, &today).expect("Could not parse date")
+    let closest_files = TodoFile::get_closest_files(files.collect(), target, 5);
-    } else {
-        today - TimeDelta::try_days(args.previous.into()).unwrap()
-    };
-    let closest_files = TodoFile::get_closest_files(files.collect(), target, args.number);
-    // list files
     if args.list {
-        println!("Today - n\tFile");
+        closest_files
-        closest_files.into_iter().for_each(|f| {
+            .into_iter()
-            println!(
+            .for_each(|f| println!("{}", f.file.canonicalize().unwrap().to_string_lossy()));
-                "{}\t\t{}",
-                (today - f.date).num_days(),
-                f.file.canonicalize().unwrap().to_string_lossy(),
-            )
-        });
         return ();
     }
-    // TODO: If the user did not pick a date that exist they should have the
-    // option to updated their choice
 
     let latest_file = closest_files.first();
     let current_file = match latest_file {
-        // copy old file if the user specifies today's notes but it does not exist
         Some(todo_file) if todo_file.date < today && args.previous == 0 => {
-            let mut extension_options = ExtensionOptions::default();
-            extension_options.tasklist = true;
-
-            let mut parse_options = ParseOptions::default();
-            parse_options.relaxed_tasklist_matching = true;
-
-            let options = &ComrakOptions {
-                extension: extension_options,
-                parse: parse_options,
-                ..ComrakOptions::default()
-            };
             let sections = &cfg.sections;
-            log::info!("looking for sections: {:?}", sections);
             let arena = Arena::new();
 
-            // attempt to load file
             let root = {
-                log::info!(
-                    "loading and parsing file: {}",
-                    todo_file.file.to_string_lossy()
-                );
-
                 let contents = file::load_file(&todo_file);
-                let root = comrak::parse_document(&arena, &contents, options);
+                let root = file::parse_todo_file(&contents, &arena);
                 root
             };
-            log::trace!("file loaded");
+            let groups = file::extract_secitons(root, sections);
-
+            let level = groups.values().map(|group| group.level).min().unwrap_or(2);
-            let sect = extract_sections(root, &sections);
+            let data = sections
-            let date = format!("{}-{:02}-{:02}", today.year(), today.month(), today.day());
+                .iter()
-
+                .map(|section| match groups.get(section) {
-            // generate string for new file and write to filesystem
+                    Some(group) => group.clone(),
-            let new_doc = file::create_new_doc(&arena, &date, sect);
+                    None => TaskGroup::empty(section.to_string(), level),
-
+                })
-            process_doc_tree(root, &date, &sections);
+                .collect();
-
-            let mut new_content = BufWriter::new(Vec::new());
-            format_commonmark(new_doc, options, &mut new_content);
-            let text = String::from_utf8(new_content.into_inner().expect(""));
 
+            let content = file::generate_file_content(&data, &today);
             let file_path = file::get_filepath(&data_dir, &today);
-            log::info!("writing to file: {}", file_path.to_string_lossy());
+            file::write_file(&file_path, &content);
-            file::write_file(&file_path, &text.expect(""));
-            // return file name
             file_path
         }
-        // returning the selected file
+        Some(todo_file) => todo_file.file.clone(),
-        Some(todo_file) => todo_file.file.to_owned(),
-        // no note files exist creating based on template from config
         None => {
-            // generate empty file
             let sections = &cfg.sections;
-            log::info!("creating new empty file with sections: {:?}", sections);
             let data = sections
                 .iter()
                 .map(|sec| TaskGroup::empty(sec.clone(), 2))
@@ -184,18 +123,10 @@ fn main() {
             let content = file::generate_file_content(&data, &today);
             let file_path = file::get_filepath(&data_dir, &today);
             file::write_file(&file_path, &content);
-            log::info!("writing to file: {}", file_path.to_string_lossy());
-            // return file name
             file_path
         }
     };
 
-    // opening file
-    log::info!(
-        "Opening {} in {}",
-        current_file.to_string_lossy(),
-        cfg.editor
-    );
     Command::new(&cfg.editor)
         .args([current_file])
         .status()

src/todo/file.rs

@@ -1,7 +1,10 @@
 use chrono::naive::NaiveDate;
+use regex::Regex;
 use std::cmp::min;
 use std::convert::TryFrom;
+use std::fs::DirEntry;
 use std::path::PathBuf;
+use std::str::FromStr;
 
 use crate::file::FileNameParseError;
 
@@ -11,6 +14,56 @@ pub struct File {
     pub date: NaiveDate,
 }
 
+pub enum FileError {
+    //IOError(&'static str),
+    ParseError(&'static str),
+}
+
+impl File {
+    fn capture_as_number<T: FromStr>(capture: &regex::Captures, name: &str) -> Result<T, String> {
+        Ok(capture
+            .name(name)
+            .unwrap()
+            .as_str()
+            .parse::<T>()
+            .ok()
+            .ok_or("Something went wrong".to_owned())?)
+    }
+
+    fn get_file_regex() -> Regex {
+        //TODO This would ideally be configurable
+        Regex::new(r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2}).md")
+            .expect("could not create regex")
+    }
+}
+
+impl TryFrom<DirEntry> for File {
+    type Error = FileError;
+
+    fn try_from(direntry: DirEntry) -> Result<Self, Self::Error> {
+        let re = File::get_file_regex();
+        //        println!("{:?}", re);
+        let file_name = direntry.file_name();
+        let file_name_str = match file_name.to_str() {
+            Some(name) => name,
+            _ => "",
+        };
+        //        println!("{:?}", file_name_str);
+
+        if let Some(caps) = re.captures(file_name_str) {
+            let year: i32 = Self::capture_as_number(&caps, "year").unwrap();
+            let month: u32 = Self::capture_as_number(&caps, "month").unwrap();
+            let day: u32 = Self::capture_as_number(&caps, "day").unwrap();
+
+            return Ok(Self {
+                file: direntry.path(),
+                date: NaiveDate::from_ymd_opt(year, month, day).unwrap(),
+            });
+        };
+        Err(FileError::ParseError("Could not parse file name"))
+    }
+}
+
 fn try_get_date(file: &PathBuf) -> Result<NaiveDate, FileNameParseError> {
     let file_name = file
         .file_name()

src/todo/mod.rs

@@ -2,4 +2,5 @@ mod file;
 mod tasks;
 
 pub use file::File;
-pub use tasks::{Status, Task, TaskGroup};
+pub use tasks::{Status, TaskGroup};
+

src/todo/tasks.rs

@@ -3,7 +3,7 @@ use std::borrow::Borrow;
 use comrak::nodes::AstNode;
 use comrak::nodes::NodeValue;
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone)]
 pub struct TaskGroup {
     pub name: String,
     pub tasks: Vec<Task>,
@@ -11,7 +11,7 @@ pub struct TaskGroup {
 }
 
 // This does not support subtasks, need to figure out best path forward
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone)]
 pub struct Task {
     pub status: Status,
     pub text: String,
@@ -81,7 +81,7 @@ impl ToString for Task {
                 .map(|task| task.to_string())
                 .collect::<Vec<_>>()
                 .join("\n");
-            format!("\n{}", text).trim_end().replace("\n", "\n  ")
+            format!("\n{}", text).trim_end().replace("\n",  "\n  ")
         } else {
             "".into()
         };
@@ -92,7 +92,6 @@ impl ToString for Task {
 
 impl<'a> TryFrom<&'a AstNode<'a>> for Task {
     type Error = TaskError;
-
     fn try_from(node: &'a AstNode<'a>) -> Result<Self, Self::Error> {
         let data_ref = &node.data.borrow();
         if let NodeValue::TaskItem(ch) = data_ref.value {
@@ -159,23 +158,25 @@ impl ToString for TaskGroup {
 
 impl<'a> TryFrom<&'a AstNode<'a>> for TaskGroup {
     type Error = TaskError;
-
     fn try_from(node: &'a AstNode<'a>) -> Result<Self, Self::Error> {
         let node_ref = &node.data.borrow();
         if let NodeValue::Heading(heading) = node_ref.value {
             let level = heading.level;
-            let first_child = node
+            let first_child_ref = &node.first_child();
-                .first_child()
+            let first_child = if let Some(child) = first_child_ref {
-                .ok_or(TaskError::ParsingError("Node has no children"))?;
+                child
-
-            let data_ref = first_child.data.borrow();
-            let name = if let NodeValue::Text(value) = &data_ref.value {
-                Ok(value.to_string())
             } else {
-                Err(TaskError::ParsingError(
+                return Err(TaskError::ParsingError("Node has no children"));
+            };
+
+            let data_ref = &first_child.data.borrow();
+            let name = if let NodeValue::Text(value) = &data_ref.value {
+                value.to_string()
+            } else {
+                return Err(TaskError::ParsingError(
                     "Could not get title from heading node",
-                ))
+                ));
-            }?;
+            };
 
             let next_sib = node
                 .next_sibling()