aws-unlock 0.1.0

Unlock your AWS profile as needed
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

use anyhow::{bail, Ok, Result};

#[derive(Debug, Clone)]
pub struct EntryLineLexer<'a> {
    lines: Vec<&'a str>,
    index: usize,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum EntryLine<'a> {
    Empty,
    Comment(&'a str),
    ProductionMarker,
    Header(&'a str),
    Option(&'a str, &'a str),
    LockedHeader(&'a str),
    LockedOption(&'a str, &'a str),
}

impl<'a> EntryLineLexer<'a> {
    pub fn new(contents: &'a str) -> Self {
        let lines = contents.lines().collect();
        Self { lines, index: 0 }
    }

    pub fn tokenize(&mut self) -> Result<Vec<EntryLine<'a>>> {
        let mut res = vec![];
        while let Some(line) = self.next_line() {
            if line.trim().starts_with('#') {
                res.push(tokenize_commented(line));
            } else {
                res.push(tokenize_uncommented(line)?);
            }
        }

        Ok(res)
    }

    fn next_line(&mut self) -> Option<&'a str> {
        let res = self.lines.get(self.index).copied();
        if self.index < self.lines.len() {
            self.index += 1;
        }
        res
    }
}

fn tokenize_commented(line: &str) -> EntryLine {
    let trimmed = line.trim()[1..].trim();
    if trimmed == "production" {
        EntryLine::ProductionMarker
    } else if trimmed.starts_with('[') && trimmed.ends_with(']') {
        // Header
        EntryLine::LockedHeader(&trimmed[1..trimmed.len() - 1])
    } else if trimmed.contains('=') {
        // Option
        let [key, value]: [&str; 2] = trimmed
            .splitn(2, '=')
            .collect::<Vec<_>>()
            .try_into()
            .expect("should always be splitted to two entries");
        let key = key.trim_end();
        let value = value.trim_start();
        EntryLine::LockedOption(key, value)
    } else {
        // Simple Comment
        let start = if line.trim().starts_with("# ") { 2 } else { 1 };
        EntryLine::Comment(&line[start..])
    }
}

fn tokenize_uncommented(line: &str) -> Result<EntryLine> {
    if line.starts_with('[') && line.ends_with(']') {
        // Header
        Ok(EntryLine::Header(&line[1..line.len() - 1]))
    } else if line.contains('=') {
        // Option
        let [key, value]: [&str; 2] = line
            .splitn(2, '=')
            .collect::<Vec<_>>()
            .try_into()
            .expect("should always be splitted to two entries");
        let key = key.trim_end();
        let value = value.trim_start();
        Ok(EntryLine::Option(key, value))
    } else if line.trim() == "" {
        Ok(EntryLine::Empty)
    } else {
        bail!("unexpected line: {:?}", line);
    }
}