cargo-msrv 0.9.0

Find your minimum supported Rust version (MSRV)!
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 crate::command::command_with_output;
use crate::errors::{CargoMSRVError, TResult};

pub type ToolchainSpecifier = String;

/// Verify that the given toolchain is installed.
/// with `rustup toolchain list`
pub fn is_toolchain_installed<S: AsRef<str>>(name: S) -> TResult<()> {
    let toolchain = name.as_ref();
    command_with_output(&["toolchain", "list"]).and_then(|child| {
        let output = child.wait_with_output()?;

        String::from_utf8(output.stdout)
            .map_err(From::from)
            .and_then(|string| {
                let mut lines = string.lines();

                // the default toolchain is formatted like so:
                // <toolchain> (default)
                if let Some(first) = lines.next() {
                    if let Some(default) = first.split_ascii_whitespace().next() {
                        if default == toolchain {
                            return Ok(());
                        }
                    }
                }

                // after the default toolchain, all other installed toolchains are listed
                // one per line
                for line in lines {
                    if line == toolchain {
                        return Ok(());
                    }
                }

                Err(CargoMSRVError::ToolchainNotInstalled)
            })
    })
}

/// Check if the given target is available.
/// with `rustup target list`
pub fn is_target_available<S: AsRef<str>>(name: S) -> TResult<()> {
    let toolchain = name.as_ref();
    command_with_output(&["target", "list"]).and_then(|child| {
        let output = child.wait_with_output()?;

        String::from_utf8(output.stdout)
            .map_err(From::from)
            .and_then(|string| {
                // Each target is listed on a single line.
                // If a target is installed, it is listed as <target> (installed).
                // If a target is the default, it is listed as <target> (default).
                for line in string.lines() {
                    if let Some(it) = line.split_ascii_whitespace().next() {
                        if it == toolchain {
                            return Ok(());
                        }
                    }
                }

                Err(CargoMSRVError::UnknownTarget)
            })
    })
}

/// Uses the `.rustup/settings.toml` file to determine the default target (aka the
/// `default_host_triple`) if not set by a user.
pub fn default_target() -> TResult<String> {
    command_with_output(&["show"]).and_then(|child| {
        let output = child.wait_with_output()?;

        String::from_utf8(output.stdout)
            .map_err(From::from)
            .and_then(|string| {
                // the first line contains the default target
                // e.g. `Default host: x86_64-unknown-linux-gnu`

                string
                    .lines()
                    .next()
                    .ok_or(CargoMSRVError::DefaultHostTripleNotFound)
                    .and_then(|line| {
                        line.split_ascii_whitespace()
                            .nth(2)
                            .ok_or(CargoMSRVError::DefaultHostTripleNotFound)
                            .map(String::from)
                    })
            })
    })
}