proto_core 0.56.0

Core proto APIs.
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

#![allow(unused_assignments)]

use crate::config_error::ProtoConfigError;
use crate::flow::lock::ProtoLockError;
use crate::id::IdError;
use crate::layout::ProtoLayoutError;
use starbase_styles::{Style, Stylize};
use starbase_utils::fs::FsError;
use std::path::PathBuf;
use thiserror::Error;
use warpgate::{WarpgateHttpClientError, WarpgatePluginError};

#[derive(Error, Debug, miette::Diagnostic)]
pub enum ProtoResolveError {
    #[diagnostic(transparent)]
    #[error(transparent)]
    Config(#[from] Box<ProtoConfigError>),

    #[diagnostic(transparent)]
    #[error(transparent)]
    Fs(#[from] Box<FsError>),

    #[diagnostic(transparent)]
    #[error(transparent)]
    HttpClient(#[from] Box<WarpgateHttpClientError>),

    #[diagnostic(transparent)]
    #[error(transparent)]
    Id(#[from] Box<IdError>),

    #[diagnostic(transparent)]
    #[error(transparent)]
    Layout(#[from] Box<ProtoLayoutError>),

    #[diagnostic(transparent)]
    #[error(transparent)]
    Lock(#[from] Box<ProtoLockError>),

    #[diagnostic(transparent)]
    #[error(transparent)]
    Plugin(#[from] Box<WarpgatePluginError>),

    #[diagnostic(code(proto::resolve::offline::version_required))]
    #[error(
        "Internet connection required to load and resolve a valid version. To work around this:\n - Pass a fully-qualified version explicitly: {}\n - Execute the non-shim binaries instead: {}",
        .command.style(Style::Shell),
        .bin_dir.style(Style::Path)
    )]
    RequiredInternetConnectionForVersion { command: String, bin_dir: PathBuf },

    #[diagnostic(code(proto::resolve::invalid_version))]
    #[error("Invalid version or requirement in tool specification {}.", .version.style(Style::Hash))]
    InvalidVersionSpec {
        version: String,
        #[source]
        error: Box<version_spec::SpecError>,
    },

    #[diagnostic(
        code(proto::resolve::undetected_version),
        help = "Has the tool been installed?"
    )]
    #[error(
        "Failed to detect an applicable version to run {tool} with. Try pinning a version with {} or explicitly passing the version as an argument or environment variable.",
        "proto pin".style(Style::Shell),
    )]
    FailedVersionDetect { tool: String },

    #[diagnostic(
        code(proto::resolve::unresolved_version),
        help = "Does this version exist and has it been released?"
    )]
    #[error(
        "Failed to resolve {} to a valid supported version for {tool}.",
        .version.style(Style::Hash),
    )]
    FailedVersionResolve { tool: String, version: String },
}

impl From<WarpgateHttpClientError> for ProtoResolveError {
    fn from(e: WarpgateHttpClientError) -> ProtoResolveError {
        ProtoResolveError::HttpClient(Box::new(e))
    }
}

impl From<ProtoConfigError> for ProtoResolveError {
    fn from(e: ProtoConfigError) -> ProtoResolveError {
        ProtoResolveError::Config(Box::new(e))
    }
}

impl From<FsError> for ProtoResolveError {
    fn from(e: FsError) -> ProtoResolveError {
        ProtoResolveError::Fs(Box::new(e))
    }
}

impl From<ProtoLayoutError> for ProtoResolveError {
    fn from(e: ProtoLayoutError) -> ProtoResolveError {
        ProtoResolveError::Layout(Box::new(e))
    }
}

impl From<ProtoLockError> for ProtoResolveError {
    fn from(e: ProtoLockError) -> ProtoResolveError {
        ProtoResolveError::Lock(Box::new(e))
    }
}

impl From<WarpgatePluginError> for ProtoResolveError {
    fn from(e: WarpgatePluginError) -> ProtoResolveError {
        ProtoResolveError::Plugin(Box::new(e))
    }
}

impl From<IdError> for ProtoResolveError {
    fn from(e: IdError) -> ProtoResolveError {
        ProtoResolveError::Id(Box::new(e))
    }
}