fn load_docs()

in resctl-demo/src/doc.rs [34:116]
74 lines of code
11 McCabe index (conditional complexity)

fn load_docs() -> BTreeMap<String, &'static str> {
    let mut docs = BTreeMap::new();
    let mut graphs = HashSet::new();
    let mut targets = HashSet::new();

    for i in 0..index::SOURCES.len() {
        let src = index::SOURCES[i];
        info!("Loading doc {}", i);
        let doc = match RdDoc::parse(src.as_bytes()) {
            Ok(v) => v,
            Err(e) => panic!("Failed to load {:?}... ({:?})", &src[..100], &e),
        };

        let mut register_one_cmd = |cmd: &RdCmd| match cmd {
            RdCmd::On(sw) | RdCmd::Toggle(sw) => match sw {
                RdSwitch::Sideload(tag, _id) => {
                    SIDELOAD_NAMES.lock().unwrap().insert(tag.into());
                }
                RdSwitch::Sysload(tag, _id) => {
                    SYSLOAD_NAMES.lock().unwrap().insert(tag.into());
                }
                _ => {}
            },
            RdCmd::Graph(tag) => {
                if tag.len() > 0 {
                    graphs.insert(tag.clone());
                }
            }
            RdCmd::Jump(t) => {
                targets.insert(t.to_string());
            }
            _ => {}
        };

        for cmd in doc
            .pre_cmds
            .iter()
            .chain(doc.body.iter().filter_map(|para| {
                if let RdPara::Prompt(_, cmd) = para {
                    Some(cmd)
                } else {
                    None
                }
            }))
            .chain(doc.post_cmds.iter())
        {
            if let RdCmd::Group(group) = cmd {
                for cmd in group {
                    register_one_cmd(cmd);
                }
            } else {
                register_one_cmd(cmd);
            }
        }

        docs.insert(doc.id.clone(), src);
    }

    info!("SIDELOAD_NAMES: {:?}", &SIDELOAD_NAMES.lock().unwrap());
    info!("SYSLOAD_NAMES: {:?}", &SYSLOAD_NAMES.lock().unwrap());

    let mut nr_missing = 0;

    let graph_tags: HashSet<String> = GraphTag::into_enum_iter()
        .map(|x| format!("{:?}", x))
        .collect();
    for tag in graphs.iter() {
        if !graph_tags.contains(tag) {
            error!("doc: invalid graph tag {:?}", tag);
            nr_missing += 1;
        }
    }

    for t in targets {
        if !docs.contains_key(&t) {
            error!("doc: invalid jump target {:?}", t);
            nr_missing += 1;
        }
    }

    assert!(nr_missing == 0);
    docs
}