dotenv-shell 1.0.1

Launch a new shell (or another program) with your loaded dotenv
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

#[macro_use]
extern crate log;
extern crate env_logger;
extern crate dotenv;
extern crate libc;

use std::{env, ptr, process};
use std::ffi::CString;
use libc::c_char;
use dotenv::{dotenv, DotenvError};

/// Literally taken from the libstd
/// (sys/unix/process.rs that is)
fn make_argv(prog: &CString, args: &[CString])
             -> *const *const libc::c_char
{
    let mut ptrs: Vec<*const libc::c_char> = Vec::with_capacity(args.len()+1);

    // Convert the CStrings into an array of pointers. Also return the
    // vector that owns the raw pointers, to ensure they live long
    // enough.
    ptrs.push(prog.as_ptr());
    ptrs.extend(args.iter().map(|tmp| {
        tmp.as_ptr()
    }));

    // Add a terminating null pointer (required by libc).
    ptrs.push(ptr::null());

    ptrs.as_ptr()
}

fn exec(prog: &str, args: &[String]) -> ! {
    let prog = CString::new(prog).expect("Convertable to CString");
    let args = args.iter()
        .map(|tmp| CString::new(&tmp[..]).expect("Convertable to CString"))
        .collect::<Vec<_>>();

    let argv = make_argv(&prog, &args);

    unsafe {
        let exit_code = libc::execvp(*argv, argv);
        process::exit(exit_code);
    }
}

fn main() {
    env_logger::init().expect("Setup env_logger failed");

    info!("Loading dotenv");
    match dotenv() {
        Ok(()) => {},
        Err(DotenvError::Io) => {
            warn!("No dotenv file found. Skipping.");
        },
        Err(e) => {
            error!("Can't initialize dotenv.");
            error!("Error: {:?}", e);
            process::exit(1);
        }
    }

    let shell = env::var("SHELL").unwrap_or("/bin/sh".into());

    let args = env::args().skip(1).collect::<Vec<String>>();
    info!("args: {:?}", args);

    match args.len() {
        0 =>  {
            info!("Starting '{}' as shell", shell);
            exec(&shell, &[]);
        },
        _ => {
            let program = &args[0];
            info!("Starting '{}' with arguments: {:?}", program, &args[1..]);
            exec(program, &args[1..]);
        }
    }
}