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

// License: see LICENSE file at root directory of `master` branch

use {
    alloc::string::String,
    core::fmt::{self, Display, Formatter},
};

#[cfg(feature="std")]
use {
    std::{
        error::Error,
        io::{self, ErrorKind},
    },
};

/// # Error while parsing semver.
#[derive(Debug, PartialEq, Eq)]
pub struct ParseSemverError {

    /// # Error kind
    pub kind: SemverErrorKind,

}

#[cfg(feature="std")]
impl Error for ParseSemverError {

    fn description(&self) -> &str {
        self.kind.description()
    }

}

impl Display for ParseSemverError {

    fn fmt(&self, f: &mut Formatter) -> core::result::Result<(), fmt::Error> {
        f.write_str(self.kind.description())
    }

}

#[cfg(feature="std")]
impl From<ParseSemverError> for io::Error {

    /// # Converts `ParseSemverError` into `io::Error`
    ///
    /// [`ErrorKind::InvalidInput`] will be used.
    ///
    /// [`ErrorKind::InvalidInput`]: https://doc.rust-lang.org/std/io/enum.ErrorKind.html#variant.InvalidInput
    fn from(err: ParseSemverError) -> io::Error {
        io::Error::new(ErrorKind::InvalidInput, err)
    }

}

/// # Semver error kind.
#[derive(Debug, PartialEq, Eq)]
pub enum SemverErrorKind {

    /// # Empty string
    Empty,

    /// # Invalid major version number
    InvalidMajor,

    /// # Invalid minor version number
    InvalidMinor,

    /// # Missing minor version number
    MissingMinor,

    /// # Invalid patch version number
    InvalidPatch,

    /// # Missing patch version number
    MissingPatch,

    /// # Invalid token
    InvalidToken,

    /// # Invalid pre-release
    InvalidPreRelease,

    /// # Invalid build metadata
    InvalidBuildMetadata,

    /// # Too large
    TooLarge,

    /// # Parser error
    ParserError,

    /// # Other
    Other(String),

}

impl SemverErrorKind {

    fn description(&self) -> &str {
        match self {
            SemverErrorKind::Empty => "Empty string",
            SemverErrorKind::InvalidMajor => "Invalid major version number",
            SemverErrorKind::InvalidMinor => "Invalid minor version number",
            SemverErrorKind::MissingMinor => "Missing minor version number",
            SemverErrorKind::InvalidPatch => "Invalid patch version number",
            SemverErrorKind::MissingPatch => "Missing patch version number",
            SemverErrorKind::InvalidToken => "Invalid token",
            SemverErrorKind::InvalidPreRelease => "Invalid pre-release",
            SemverErrorKind::InvalidBuildMetadata => "Invalid build metadata",
            SemverErrorKind::TooLarge => "Too large",
            SemverErrorKind::ParserError => "Parser error",
            SemverErrorKind::Other(s) => &s,
        }
    }

}