Method process

src/content.rs:214–295

(&self, content: &str, mut old_nodes: BTreeMap<String, Node>)

    }

    pub fn process(&self, content: &str, mut old_nodes: BTreeMap<String, Node>) -> Result<(BTreeMap<String, Node>, BTreeMap<usize, FoldInner>, Vec<usize>, bool)> {
        // put new lines into a btree map for later
        let (_, mut new_lines) = self.newlines.find_iter(content)
            .map(|x| x.start())
            .fold((1, BTreeMap::new()), |(mut nr, mut map): (usize, BTreeMap<usize, usize>), idx| {
                nr += 1;
                map.insert(idx, nr);

                (nr, map)
            });
        new_lines.insert(1, 1);

        let folds = self.header_regex.find_iter(content)
            .filter_map(|x| new_lines.get(&x.start()))
            .copied()
            .collect::<Vec<_>>();

        let mut nodes = BTreeMap::new();
        let mut any_changed = false;

        let maths = self.fences_regex.captures_iter(content)
            .map(|x| {
                let kind = x.name("name").unwrap().as_str();
                let content = x.name("inner").map_or("", |x| x.as_str()).to_string();
                let height = x.name("height")
                    .and_then(|x| x.as_str().parse::<usize>().ok())
                    .unwrap_or_else(|| content.matches('\n').count() + 1);
                let line = new_lines.get(&(x.get(0).unwrap().start() - 1)).unwrap();
                let id = utils::hash(&content);

                ContentType::from_fence(kind).map(|c|
                    (height, *line, content, id, c)
                )
            });

        let files = self.file_regex.captures_iter(content)
            .map(|x| {
                let file_name = x.name("file_name").unwrap().as_str().to_string();
                let height = x.name("new_lines").unwrap().as_str().len() - 1;
                let line = new_lines.get(&x.get(0).unwrap().start()).unwrap() + 1;
                let id = utils::hash(&file_name);

                Ok((height, line, file_name, id, ContentType::File))
            });


        let strcts_gen = maths.chain(files)
            .map(|x| x.map(|(height, line, content, id, kind)| {
                let new_range = (line, line + height);

                // try to load from existing structures
                if let Some(mut node) = old_nodes.remove(&id) {
                    if new_range != node.range {
                        any_changed = true;
                    }
                    node.range = new_range;

                    nodes.insert(id.clone(), node);