uv-distribution-types 0.0.6

This is an internal component crate of uv
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

use std::collections::{BTreeMap, BTreeSet};

use uv_fs::Simplified;
use uv_normalize::PackageName;
use uv_pep508::RequirementOrigin;

/// Source of a dependency, e.g., a `-r requirements.txt` file.
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum SourceAnnotation {
    /// A `-c constraints.txt` file.
    Constraint(RequirementOrigin),
    /// An `--override overrides.txt` file.
    Override(RequirementOrigin),
    /// A `-r requirements.txt` file.
    Requirement(RequirementOrigin),
}

impl std::fmt::Display for SourceAnnotation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Requirement(origin) => match origin {
                RequirementOrigin::File(path) => {
                    write!(f, "-r {}", path.portable_display())
                }
                RequirementOrigin::Project(path, project_name) => {
                    write!(f, "{project_name} ({})", path.portable_display())
                }
                RequirementOrigin::Group(path, project_name, group) => {
                    if let Some(project_name) = project_name {
                        write!(f, "{project_name} ({}:{group})", path.portable_display())
                    } else {
                        write!(f, "({}:{group})", path.portable_display())
                    }
                }
                RequirementOrigin::Workspace => {
                    write!(f, "(workspace)")
                }
            },
            Self::Constraint(origin) => {
                write!(f, "-c {}", origin.path().portable_display())
            }
            Self::Override(origin) => match origin {
                RequirementOrigin::File(path) => {
                    write!(f, "--override {}", path.portable_display())
                }
                RequirementOrigin::Project(path, project_name) => {
                    // Project is not used for override
                    write!(f, "--override {project_name} ({})", path.portable_display())
                }
                RequirementOrigin::Group(path, project_name, group) => {
                    // Group is not used for override
                    if let Some(project_name) = project_name {
                        write!(
                            f,
                            "--override {project_name} ({}:{group})",
                            path.portable_display()
                        )
                    } else {
                        write!(f, "--override ({}:{group})", path.portable_display())
                    }
                }
                RequirementOrigin::Workspace => {
                    write!(f, "--override (workspace)")
                }
            },
        }
    }
}

/// A collection of source annotations.
#[derive(Default, Debug, Clone)]
pub struct SourceAnnotations(BTreeMap<PackageName, BTreeSet<SourceAnnotation>>);

impl SourceAnnotations {
    /// Add a source annotation to the collection for the given package.
    pub fn add(&mut self, package: &PackageName, annotation: SourceAnnotation) {
        self.0
            .entry(package.clone())
            .or_default()
            .insert(annotation);
    }

    /// Return the source annotations for a given package.
    pub fn get(&self, package: &PackageName) -> Option<&BTreeSet<SourceAnnotation>> {
        self.0.get(package)
    }
}