elba 0.3.0

elba is a package manager for Idris
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

use crate::{
    retrieve::cache::Cache,
    util::{config::Backend, errors::Res, fmt_output},
};
use failure::{format_err, ResultExt};
use std::{
    path::{Path, PathBuf},
    process::Command,
};

// TODO: triple target
#[derive(Debug)]
pub struct BuildContext<'a> {
    pub backend: &'a Backend,
    /// Whether to actually generate code or only check for errors
    pub codegen: bool,
    pub compiler: Compiler,
    /// The global cache to use.
    pub cache: &'a Cache,
    pub threads: u32,
    pub opts: &'a [String],
}

/// Information on the compiler executable
#[derive(Debug)]
pub struct Compiler {
    /// The location of the exe
    path: PathBuf,
    flavor: CompilerFlavor,
}

impl Compiler {
    /// Run the compiler at `path` to learn various pieces of information about it.
    pub fn new(name: &str) -> Res<Compiler> {
        let c = Compiler {
            path: PathBuf::from(name),
            flavor: CompilerFlavor::Idris1,
        };

        let flavor = if c.version()?.starts_with("Blodwen") {
            CompilerFlavor::Idris2
        } else {
            CompilerFlavor::Idris1
        };

        Ok(Compiler { flavor, ..c })
    }

    /// Get a process set up to use the found compiler
    pub fn process(&self) -> Command {
        Command::new(&self.path)
    }

    pub fn path(&self) -> &Path {
        &self.path
    }

    pub fn flavor(&self) -> CompilerFlavor {
        self.flavor
    }

    /// Get the version of the compiler
    pub fn version(&self) -> Res<String> {
        let out = Command::new(&self.path)
            .arg("--version")
            .output()
            .with_context(|e| format!("couldn't retrieve Idris compiler version: {}", e))?;
        if out.status.success() {
            Ok(String::from_utf8_lossy(&out.stdout).trim().to_string())
        } else {
            Err(format_err!(
                "couldn't get idris version:\n{}",
                fmt_output(&out)
            ))
        }
    }
}

impl Default for Compiler {
    fn default() -> Self {
        Compiler {
            path: PathBuf::from("idris"),
            flavor: CompilerFlavor::Idris1,
        }
    }
}

/// The type of compiler we're dealing with.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum CompilerFlavor {
    Idris1,
    Idris2,
}

impl CompilerFlavor {
    pub fn is_idris1(self) -> bool {
        match self {
            CompilerFlavor::Idris1 => true,
            _ => false,
        }
    }

    pub fn is_idris2(self) -> bool {
        match self {
            CompilerFlavor::Idris2 => true,
            _ => false,
        }
    }
}