adnv 1.5.0

CLI that tracks, checks and auto-updates infrastructure dependency versions across Terraform, Helm, Docker, Git and npm
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use core::ops::Deref;

use crate::error::ErrorWithData;
use std::cmp::Ordering;

pub mod data;
pub mod list;
pub mod parse;
pub mod resolve;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Source {
    pub data: data::Source,
    pub loc: Option<parse::Location>,
}

impl Source {
    pub fn new(data: data::Source) -> Self {
        Self { data, loc: None }
    }

    pub fn location(&self) -> Option<&parse::Location> {
        self.loc.as_ref()
    }

    pub fn with_location(self, loc: parse::Location) -> Self {
        Self {
            loc: Some(loc),
            ..self
        }
    }
}

impl Deref for Source {
    type Target = data::Source;

    fn deref(&self) -> &Self::Target {
        &self.data
    }
}

impl<T: Into<data::Source>> From<T> for Source {
    fn from(value: T) -> Self {
        Self::new(value.into())
    }
}

pub type Version = String;
pub type VersionReq = String;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VersionedSource {
    pub source: Source,
    pub current: Option<VersionReq>,
    pub required: Option<VersionReq>,
}

impl VersionedSource {
    pub fn new<T: Into<Source>>(source: T) -> Self {
        Self {
            source: source.into(),
            current: None,
            required: None,
        }
    }

    pub fn with_current(self, current: impl Into<VersionReq>) -> Self {
        Self {
            current: Some(current.into()),
            ..self
        }
    }

    pub fn with_required(self, required: impl Into<VersionReq>) -> Self {
        Self {
            required: Some(required.into()),
            ..self
        }
    }

    pub fn with_location(self, loc: parse::Location) -> Self {
        Self {
            source: self.source.with_location(loc),
            ..self
        }
    }
}

impl PartialOrd for VersionedSource {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for VersionedSource {
    fn cmp(&self, other: &Self) -> Ordering {
        // First compare sources
        let source_cmp = self
            .source
            .data
            .describe()
            .cmp(&other.source.data.describe());
        if source_cmp != Ordering::Equal {
            return source_cmp;
        }

        // Then compare current versions
        let current_cmp = self.current.cmp(&other.current);
        if current_cmp != Ordering::Equal {
            return current_cmp;
        }

        // Finally compare required versions
        self.required.cmp(&other.required)
    }
}
pub fn print_errors(errors: Vec<ErrorWithData<VersionedSource>>) {
    for (err, source) in errors.into_iter().map(ErrorWithData::split) {
        // Sources given on the command line or in the config have no location
        // in a file, only the parsed ones do.
        match source.source.location() {
            Some(loc) => println!(
                "Error at `{}`:\n\t{}\n\t\t{:?}",
                loc,
                source.source.describe(),
                miette::Report::new(err)
            ),
            None => println!(
                "Error for `{}`:\n\t{:?}",
                source.source.describe(),
                miette::Report::new(err)
            ),
        }
    }
}