use chrono::NaiveDate;
use std::path::Path;
fn fti_digits(s: &str) -> bool {
    s.len() >= 2 && s.chars().take(2).all(|i| i.is_ascii_digit())
}
pub fn parse_diary_date(par: &str, fin: &str) -> Option<NaiveDate> {
    if !fti_digits(fin) || par.len() < 4 {
        return None;
    }
    let y = par.parse::<i32>().ok()?;
    let m = fin[..2].parse::<u32>().unwrap();
    // verify the day info
    let mut dayinf = &fin[2..];
    if dayinf.starts_with(|i| matches!(i, '-' | '_')) {
        dayinf = &dayinf[1..];
    }
    if !fti_digits(dayinf) {
        return None;
    }
    let d = dayinf[..2].parse::<u32>().unwrap();
    chrono::NaiveDate::from_ymd_opt(y, m, d)
}
/// tries to parse a diary entry path to extract the reference date
/// should be usually given a path containing at least 2 components
pub fn parse_diary_date_from_path(x: &Path) -> Option<NaiveDate> {
    let mut fin = x;
    let mut fins = fin.file_name()?.to_str()?;
    // we allow 1 additional path component after the date part
    if !fti_digits(fins) {
        fin = x.parent()?;
        fins = fin.file_name()?.to_str()?;
        if !fti_digits(fins) {
            return None;
        }
    }
    let par = fin.parent()?.file_name()?.to_str()?;
    parse_diary_date(par, fins)
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn diary_standard() {
        assert_eq!(parse_diary_date_from_path(Path::new("201/01_01")), None);
        assert_eq!(parse_diary_date_from_path(Path::new("2016/0")), None);
        assert_eq!(
            parse_diary_date_from_path(Path::new("2016/08_28")),
            Some(NaiveDate::from_ymd(2016, 08, 28))
        );
        assert_eq!(
            parse_diary_date_from_path(Path::new("teller/2016/08_28")),
            Some(NaiveDate::from_ymd(2016, 08, 28))
        );
        assert_eq!(
            parse_diary_date_from_path(Path::new("teller/2016/08_28nox/fluppig.jpg")),
            Some(NaiveDate::from_ymd(2016, 08, 28))
        );
        assert_eq!(
            parse_diary_date_from_path(Path::new("/blog/2017/1124y_vf.html")),
            Some(NaiveDate::from_ymd(2017, 11, 24))
        );
    }
}

                    ret.insert(&x[..p], vec![x[p+2..].trim_start()]);

                    ret.insert(&x[..p], vec![x[p + 2..].trim_start()]);

        assert_eq!(parse(r#"

        assert_eq!(
            parse(
                r#"

"#, &trtab), res);

"#,
                &trtab
            ),
            res
        );

mod date;
pub use crate::date::*;

pub use crate::tgs::{parse as parse_tgs};

pub use crate::tgs::parse as parse_tgs;

type Branch<'a> = HashMap<&'a str, Node<'a>>;

    Branch(HashMap<&'a str, Node<'a>>),

    Branch(Branch<'a>),

pub fn parse(s: &str) -> Option<Node<'_>> {

pub fn parse(s: &str) -> Option<Branch<'_>> {

fn parse_colsv<'a>(it: impl Iterator<Item = &'a str>) -> Option<Node<'a>> {
    let mut ret = Node::Branch(HashMap::new());

fn parse_colsv<'a>(it: impl Iterator<Item = &'a str>) -> Option<Branch<'a>> {
    let mut ret = HashMap::new();

        let sel = ret.select(obj)?;

        let sel = select(&mut ret, obj)?;

fn parse_groups<'a>(it: impl Iterator<Item = &'a str>) -> Option<Node<'a>> {
    let mut ret = Node::Branch(HashMap::new());
    let mut selobj = None;

#[derive(Default)]
struct GroupParser<'a> {
    ret: Branch<'a>,
    selobj: Option<(&'a str, HashMap<&'a str, &'a str>)>,
}

    macro_rules! finish_selobj {
        () => {{
            if let Some((oname, okvm)) = selobj.take() {
                if !ret.push_to_leaves(oname, okvm) {
                    return None;
                }
            }
        }};
    }

fn parse_groups<'a>(it: impl Iterator<Item = &'a str>) -> Option<Branch<'a>> {
    let mut gp = GroupParser::default();

            finish_selobj!();
            selobj = Some((&i[1..], HashMap::new()));
        } else if let Some((_, ref mut kvm)) = &mut selobj {

            if !gp.finish_selobj() {
                return None;
            }
            gp.selobj = Some((&i[1..], HashMap::new()));
        } else if let Some((_, ref mut kvm)) = &mut gp.selobj {

    finish_selobj!();
    Some(ret)

    if gp.finish_selobj() {
        Some(gp.ret)
    } else {
        None
    }

fn final_leaf_push<'a>(sel: &mut HashMap<&'a str, Node<'a>>, key: &'a str, value: &'a str) -> bool {

impl<'a> GroupParser<'a> {
    fn finish_selobj(&mut self) -> bool {
        if let Some((oname, okvm)) = self.selobj.take() {
            if let Some(sel) = select(&mut self.ret, oname) {
                okvm.into_iter()
                    .all(|(key, value)| final_leaf_push(sel, key, value))
            } else {
                false
            }
        } else {
            true
        }
    }
}
fn final_leaf_push<'a>(sel: &mut Branch<'a>, key: &'a str, value: &'a str) -> bool {

}
fn select<'s, 'a>(ret: &'s mut Branch<'a>, obj: &'a str) -> Option<&'s mut Branch<'a>> {
    obj.split('/')
        .filter(|i| !i.is_empty())
        .try_fold(ret, |sel, i| {
            sel.entry(i)
                .or_insert_with(|| Node::Branch(HashMap::new()))
                .branch_mut()
        })

    fn branch_mut<'s>(&'s mut self) -> Option<&'s mut HashMap<&'a str, Node<'a>>> {

    fn branch_mut<'s>(&'s mut self) -> Option<&'s mut Branch<'a>> {

        }
    }
    fn select<'s>(&'s mut self, obj: &'a str) -> Option<&'s mut HashMap<&'a str, Node<'a>>> {
        obj.split('/')
            .filter(|i| !i.is_empty())
            .try_fold(self.branch_mut()?, |sel, i| {
                sel.entry(i)
                    .or_insert_with(|| Node::Branch(HashMap::new()))
                    .branch_mut()
            })
    }
    fn push_to_leaves(&mut self, obj: &'a str, kvm: HashMap<&'a str, &'a str>) -> bool {
        if let Some(sel) = self.select(obj) {
            kvm.into_iter()
                .all(|(key, value)| final_leaf_push(sel, key, value))
        } else {
            false

    fn ex0() -> Node<'static> {

    fn ex0() -> HashMap<&'static str, Node<'static>> {

        Node::Branch(inner1)

        inner1

[dependencies.chrono]
version = "0.4"
default-features = false

dependencies = [
 "chrono",
]