devrc 0.6.0

devrc is an easy to use task runner tool on steroids for developers
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

use std::{convert::TryFrom, fs};

use netrc_rs::{Machine, Netrc};

use crate::{
    errors::DevrcError,
    netrc::get_user_defined_netrc_path,
    raw::auth::{NetrcAuth, NetrcAuthHeader},
};

pub const HEADER_AUTHORIZATION: &str = "Authorization";

#[derive(Debug, Clone, Default)]
pub enum AuthType {
    #[default]
    None,
    Bearer,
    BasicAuth,
    Header(String),
}

#[derive(Debug, Clone, Default)]
pub enum Auth {
    #[default]
    Empty,
    Loaded {
        machine: Machine,
        auth_type: AuthType,
    },
}

impl TryFrom<crate::raw::auth::Auth> for Auth {
    type Error = DevrcError;

    fn try_from(value: crate::raw::auth::Auth) -> Result<Self, Self::Error> {
        let file = get_user_defined_netrc_path().ok_or(DevrcError::NetrcNotFound)?;
        let content = fs::read_to_string(file).map_err(DevrcError::IoError)?;
        let netrc = Netrc::parse(content, false).map_err(DevrcError::NetrcParsingError)?;

        match value {
            crate::raw::auth::Auth::Empty => Ok(Auth::Empty),
            crate::raw::auth::Auth::NetrcAuth(NetrcAuth {
                host,
                login,
                auth_type,
            }) => match get_machine(&netrc, &host, &login) {
                Some(machine) => Ok(Auth::Loaded {
                    machine,
                    auth_type: auth_type.into(),
                }),
                None => Ok(Auth::Empty),
            },
            crate::raw::auth::Auth::NetrcAuthHeader(NetrcAuthHeader {
                host,
                login,
                header,
            }) => match get_machine(&netrc, &host, &login) {
                Some(machine) => Ok(Auth::Loaded {
                    machine,
                    auth_type: AuthType::Header(header),
                }),
                None => Ok(Auth::Empty),
            },
        }
    }
}

impl From<crate::raw::auth::AuthType> for AuthType {
    fn from(value: crate::raw::auth::AuthType) -> Self {
        match value {
            crate::raw::auth::AuthType::Empty => AuthType::None,
            crate::raw::auth::AuthType::Bearer => AuthType::Bearer,
            crate::raw::auth::AuthType::BasicAuth => AuthType::BasicAuth,
        }
    }
}

fn get_machine(netrc: &Netrc, host: &str, login: &str) -> Option<Machine> {
    let mut default: Option<Machine> = None;

    for machine in &netrc.machines {
        match (machine.name.as_ref(), machine.login.as_ref()) {
            (Some(record_host), Some(record_login))
                if record_host.as_str() == host && record_login.as_str() == login =>
            {
                return Some(machine.clone())
            }
            (None, Some(record_login)) if record_login.as_str() == login => {
                default = Some(machine.clone())
            }
            (_, _) => {}
        }
    }

    default
}

impl Auth {
    pub fn get_header(&self) -> Option<(String, String)> {
        if let Auth::Loaded { machine, auth_type } = self {
            let password = match &machine.password {
                Some(password) => password,
                None => return None,
            };
            let login = match &machine.login {
                Some(login) => login,
                None => return None,
            };

            return match auth_type {
                AuthType::Bearer => Some((
                    HEADER_AUTHORIZATION.to_string(),
                    format!("Bearer {}", password),
                )),
                AuthType::BasicAuth => {
                    let creds = format!("{:}:{:}", login, password);
                    let b64 =
                        base64::Engine::encode(&base64::engine::general_purpose::STANDARD, creds);
                    Some((HEADER_AUTHORIZATION.to_string(), format!("Basic {}", b64)))
                }
                AuthType::Header(header) => Some((header.to_owned(), password.to_owned())),
                AuthType::None => None,
            };
        }
        None
    }
}