semver-common 1.2.2

Common library to use for semantic release core and plugins.
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

use chrono::ParseError;
use regex::Error as RegexError;
use serde_json::Error as SerdeJsonError;
use std::{
    convert::From, fmt::Display, io::Error as IOError, num::ParseIntError, str::ParseBoolError,
    string::FromUtf8Error,
};
use yaml_serde::Error as SerdeYamlError;

/// Alert is a wrapper for all the various error types that may be returned by various
/// crate functions.
#[derive(Debug, Clone, PartialEq)]
pub struct Alert {
    val: String,
}

impl From<ParseError> for Alert {
    /// chrono::ParseError
    fn from(value: ParseError) -> Self {
        Alert {
            val: format!("chrono::ParseError: {}", value),
        }
    }
}

impl From<ParseBoolError> for Alert {
    /// str::ParseBoolError
    fn from(value: ParseBoolError) -> Self {
        Alert {
            val: format!("str::ParseBoolError: {}", value),
        }
    }
}

impl From<RegexError> for Alert {
    /// regex::Error
    fn from(value: RegexError) -> Self {
        Alert {
            val: format!("regex::Error: {}", value),
        }
    }
}

impl From<IOError> for Alert {
    /// io::error
    fn from(value: IOError) -> Self {
        Alert {
            val: format!("io::Error: {}", value),
        }
    }
}

impl From<ParseIntError> for Alert {
    /// num::ParseIntError
    fn from(value: ParseIntError) -> Self {
        Alert {
            val: format!("num::ParseIntError: {}", value),
        }
    }
}

impl From<SerdeJsonError> for Alert {
    /// serde_json::Error
    fn from(value: SerdeJsonError) -> Self {
        Alert {
            val: format!("serde_json::Error: {}", value),
        }
    }
}

impl From<SerdeYamlError> for Alert {
    /// yaml_serde::Error
    fn from(value: SerdeYamlError) -> Self {
        Alert {
            val: format!("yaml_serde::Error: {}", value),
        }
    }
}

impl From<FromUtf8Error> for Alert {
    /// string::FromUtf8Error
    fn from(value: FromUtf8Error) -> Self {
        Alert {
            val: format!("string::FromUtf8Error: {}", value),
        }
    }
}

impl From<&str> for Alert {
    /// &str
    fn from(value: &str) -> Self {
        Alert {
            val: String::from(value),
        }
    }
}

impl From<String> for Alert {
    /// String
    fn from(value: String) -> Self {
        Alert { val: value }
    }
}

impl From<&String> for Alert {
    /// &String
    fn from(value: &String) -> Self {
        Alert { val: value.clone() }
    }
}

impl Display for Alert {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "{}", self.val)
    }
}