vize_l0 0.510.0

L0 - the Davinci foundation level: ids, side tables, keys, dumps, diagnostics, passes and facts
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! Ordered entry projections from an already-deserialized document.

use super::ConfigDocument;
use crate::config::{CompilerConfigEntry, ConfigEntryFiles, ConfigEntryIgnore};

impl ConfigDocument {
    /// Compiler override scopes in declaration order.
    pub fn compiler_entries(&self) -> Vec<CompilerConfigEntry> {
        self.0
            .entries
            .as_deref()
            .unwrap_or_default()
            .iter()
            .map(CompilerConfigEntry::from_raw)
            .filter(CompilerConfigEntry::has_overrides)
            .collect()
    }

    /// Top-level ignores precede entry-local ignores, retaining each base path.
    pub fn entry_ignores(&self) -> Vec<ConfigEntryIgnore> {
        let top_level_ignores = self
            .0
            .ignores
            .as_deref()
            .unwrap_or_default()
            .iter()
            .cloned()
            .map(|pattern| ConfigEntryIgnore {
                base_path: self.0.project_root.clone(),
                pattern,
            });
        let entry_ignores = self
            .0
            .entries
            .as_deref()
            .unwrap_or_default()
            .iter()
            .flat_map(|entry| {
                entry
                    .ignores
                    .as_deref()
                    .unwrap_or_default()
                    .iter()
                    .cloned()
                    .map(|pattern| ConfigEntryIgnore {
                        base_path: entry.base_path.clone(),
                        pattern,
                    })
            })
            .collect::<Vec<_>>();
        top_level_ignores.chain(entry_ignores).collect()
    }

    /// Consume nonempty file entries in their original declaration order.
    pub fn into_entry_files(self) -> Vec<ConfigEntryFiles> {
        let mut entries = Vec::new();
        if let Some(files) = self.0.files.filter(|files| !files.is_empty()) {
            entries.push(ConfigEntryFiles {
                base_path: self.0.base_path,
                files,
            });
        }
        entries.extend(
            self.0
                .entries
                .unwrap_or_default()
                .into_iter()
                .filter_map(|entry| {
                    entry
                        .files
                        .filter(|files| !files.is_empty())
                        .map(|files| ConfigEntryFiles {
                            base_path: entry.base_path,
                            files,
                        })
                }),
        );
        entries
    }
}