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

use super::error::Error;
use crate::parsers::hcl::{
    Pair, Rule,
    ast::{Attribute, Block},
};

#[derive(Debug, Clone)]
pub struct Body<'i> {
    pub attributes: Vec<Attribute<'i>>,
    pub blocks: Vec<Block<'i>>,
}

impl<'i> Body<'i> {
    pub fn find_blocks<'s, 'j>(&'s self, id: &'j str) -> impl Iterator<Item = &'s Block<'i>> + 'j
    where
        's: 'j,
    {
        self.blocks.iter().filter(|block| block.id == id)
    }

    pub fn get_block(&self, id: &str, args: Option<&[&str]>) -> Option<&Block<'i>> {
        self.find_blocks(id)
            .find(|block| args.is_none_or(|args| block.args == args))
    }

    pub fn get_attribute(&self, name: &str) -> Option<&Attribute<'i>> {
        self.attributes.iter().find(|attr| attr.name == name)
    }

    pub fn get_attributes_with_inline_hints(&self) -> Vec<&Attribute<'i>> {
        self.attributes
            .iter()
            .filter(|attr| attr.hint.is_some())
            .collect()
    }
}

impl<'i> Body<'i> {
    pub(super) fn process(pair: Pair<'i>) -> (Self, Vec<Error>) {
        let mut attributes = vec![];
        let mut blocks = vec![];
        let mut errors = vec![];

        for item in pair.into_inner() {
            match item.as_rule() {
                Rule::Attribute => match Attribute::process(item) {
                    Ok(processed_item) => attributes.push(processed_item),
                    Err(e) => errors.push(e),
                },
                Rule::AttributeError => {
                    let (l, _) = item.line_col();
                    errors.push(Error::MultipleInlineHint {
                        hint: item.as_str().to_string(),
                        line: l.to_string(),
                    });
                }
                Rule::Block => {
                    let (block, errs) = Block::process(item);
                    blocks.push(block);
                    errors.extend(errs);
                }
                rule => unreachable!("{rule:?}"),
            }
        }

        (Self { attributes, blocks }, errors)
    }
}