fn collect_data()

in src/data/kernel_config.rs [99:187]
86 lines of code
16 McCabe index (conditional complexity)

    fn collect_data(&mut self, _params: &CollectorParams) -> Result<()> {
        let time_now = Utc::now();
        let mut kernel_data_processed: Vec<KernelConfigEntryGroup> = Vec::new();
        let mut comments = Vec::new();

        /* Get kernel config data from file */
        let kernel_data = get_kernel_config_data()?;

        let mut first_group = KernelConfigEntryGroup::new();
        first_group.name = "".to_string();
        kernel_data_processed.push(first_group);

        for line in kernel_data.lines() {
            let line = line?;
            if line.starts_with('#')
                && !line.contains("is not set")
                && !line.contains("NOTE")
                && !line.contains("also be needed")
                && !line.contains("end of")
            {
                comments.push(line);
                continue;
            } else {
                if comments.len() == 3 {
                    let mut group = KernelConfigEntryGroup::new();
                    group.name = comments[1].clone()[2..].to_string();
                    kernel_data_processed.push(group.clone());
                }
                comments.clear();
            }
            if line.contains('=') {
                let mut s = line.splitn(2, '=');
                let name = s.next().ok_or(PDError::CollectorLineNameError)?.to_owned();
                let value = s.next().ok_or(PDError::CollectorLineValueError)?;
                let entry = KernelConfigEntry {
                    name: name.clone(),
                    value: value.to_string(),
                };
                kernel_data_processed
                    .last_mut()
                    .unwrap()
                    .add_entry(Entry::ConfigEntry(entry));
                comments.clear();
            }
            if line.contains("is not set") {
                let mut s = line.splitn(3, ' ');
                s.next();
                let name = s.next().ok_or(PDError::CollectorLineNameError)?.to_owned();
                let value = "not set";
                let entry = KernelConfigEntry {
                    name: name.clone(),
                    value: value.to_string(),
                };
                kernel_data_processed
                    .last_mut()
                    .unwrap()
                    .add_entry(Entry::ConfigEntry(entry));
                comments.clear();
            }
            if line.contains("end of") {
                let s = line.splitn(4, ' ');
                let name = s.last().ok_or(PDError::CollectorLineNameError)?.to_owned();
                if name == kernel_data_processed.last_mut().unwrap().name {
                    continue;
                }
                let mut group_to_add_index = 0;
                let mut start_appending: bool = false;
                for (i, group) in kernel_data_processed.clone().iter().enumerate() {
                    if group.name == name {
                        group_to_add_index = i;
                        start_appending = true;
                        continue;
                    }
                    if start_appending {
                        kernel_data_processed[group_to_add_index]
                            .add_entry(Entry::ConfigGroup(group.clone()));
                    }
                }
                if start_appending {
                    kernel_data_processed =
                        kernel_data_processed[..group_to_add_index + 1].to_vec();
                }
            }
        }
        self.set_time(TimeEnum::DateTime(time_now));
        self.set_data(kernel_data_processed);
        trace!("KernelConfig data: {:#?}", self);
        Ok(())
    }