knave-expand 0.11.2

The reading, scoping and expansion stages of knave
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

mod crate_set;
mod dependency_reader;
mod fields;
mod name;
mod problems;
mod project_editor;
mod reader;

use std::path::PathBuf;

pub use crate_set::CrateSet;
pub use dependency_reader::Section;
pub use name::ProjectName;
pub use problems::ProjectProblems;
pub use project_editor::{CrateEntry, ProjectEditor};
pub use reader::ProjectReader;

use crate::diagnostic::Diagnostics;
use crate::source::Span;

#[derive(Debug)]
pub struct Project {
    pub name: String,
    pub version: String,
    pub entry: PathBuf,
    pub library_root: PathBuf,
    pub edition: i128,
    pub libraries: Vec<LibraryDependency>,
    pub dependencies: Vec<CrateDependency>,
    pub dev_dependencies: Vec<CrateDependency>,
    pub sections: Vec<SectionHead>,
}

#[derive(Debug)]
pub struct SectionHead {
    pub section: Section,
    pub span: Span,
    pub has_entries: bool,
}

#[derive(Debug)]
pub struct LibraryDependency {
    pub name: String,
    pub name_span: Span,
    pub source: LibrarySource,
}

#[derive(Debug)]
pub enum LibrarySource {
    Path(PathBuf),
    Git { url: String, commit: String },
}

impl LibrarySource {
    pub const FULL_COMMIT_LENGTH: usize = 40;
}

#[derive(Clone, Debug)]
pub struct CrateDependency {
    pub name: String,
    pub name_span: Span,
    pub version: Option<String>,
    pub features: Vec<String>,
    pub path: Option<PathBuf>,
}

impl CrateDependency {
    pub fn same_request(&self, other: &Self) -> bool {
        self.version == other.version
            && self.path == other.path
            && Self::covers(&self.features, &other.features)
            && Self::covers(&other.features, &self.features)
    }

    fn covers(features: &[String], others: &[String]) -> bool {
        others.iter().all(|feature| features.contains(feature))
    }

    pub fn resolved_from(&self, root: &std::path::Path) -> Self {
        Self {
            path: self.path.as_ref().map(|path| root.join(path)),
            ..self.clone()
        }
    }
}

impl Project {
    pub fn unbuilt_sections(&self) -> Diagnostics {
        let mut problems = Diagnostics::default();
        self.sections
            .iter()
            .filter(|head| head.has_entries && !head.section.is_built())
            .for_each(|head| {
                problems.push(ProjectProblems::unbuilt_section(
                    head.section.name(),
                    head.span,
                ))
            });
        problems
    }
}