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

use alloc::{
    string::{String, ToString},
};

use core::{
    cmp::Ordering,
    fmt,
    hash::{Hash, Hasher},
    iter::Skip,
    str::{CharIndices, FromStr},
};

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

/// # Result type used in this crate
pub type Result<T> = core::result::Result<T, ParseSemverError>;

/// # Max string length of a version number
const MAX_STR_LEN_OF_A_VERSION_NUMBER: u8 = 39;

/// # Starter for pre-release
const PRE_RELEASE_STARTER: char = '-';

/// # Starter for build metadata
const BUILD_METADATA_STARTER: char = '+';

/// # Semver.
///
/// ## Concepts
///
/// ### Strict parser
///
/// - Does not allow leading/trailing white spaces.
/// - All 3 version numbers are required: major, minor, patch.
///
/// ### Tolerant parser
///
/// - Ignores leading/trailing white spaces.
/// - Minor and patch version numbers are optional.
///
/// This mode is added by the crate author, it's not described in official specification.
///
/// ### Usage
///
/// A semver instance should always be valid. For this reason, it does not expose internal fields (where the user can make new instance
/// directly). Instead, it provides helper functions:
///
/// - [`new()`][::new()] makes new instance from raw input version numbers.
/// - [`parse()`][::parse()] and `::parse_*()` use strict parser, while `::from_*()` are more tolerant.
///
/// Since Rust encourages the use of [immutable variables][book::ch03-01], a semver instance should _not_ be changed. Once made, there are no
/// functions which help you change its fields. So `let mut` _is discouraged_. However there are useful functions to help you make new semver
/// from an existing one: [`new_major()`][::new_major()], [`new_minor()`][::new_minor()], [`new_patch()`][::new_patch()]...
///
/// Others might also come in handy: [`is_stable()`][::is_stable()], [`is_early()`][::is_early()].
///
/// [book::ch03-01]: https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html
/// [`Semver`]: struct.Semver.html
/// [::new()]: #method.new
/// [::parse()]: #method.parse
/// [::is_stable()]: #method.is_stable
/// [::is_early()]: #method.is_early
/// [::parse_pre_release()]: #method.parse_pre_release
/// [::new_major()]: #method.new_major
/// [::new_minor()]: #method.new_minor
/// [::new_patch()]: #method.new_patch
#[derive(Debug, Default, Clone, Eq)]
pub struct Semver {

    /// # Major
    major: u128,

    /// # Minor
    minor: u128,

    /// # Patch
    patch: u128,

    /// # Pre-release
    ///
    /// This does **not** contain the leading character `-`. However calling [`Semver.to_string()`][ToString.to_string()] will always have that
    /// character displayed.
    ///
    /// [ToString.to_string()]: https://doc.rust-lang.org/std/string/trait.ToString.html#tymethod.to_string
    pre_release: Option<String>,

    /// # Build metadata
    ///
    /// This does **not** contain the leading character `+`. However calling [`Semver.to_string()`][ToString.to_string()] will always have that
    /// character displayed.
    ///
    /// [ToString.to_string()]: https://doc.rust-lang.org/std/string/trait.ToString.html#tymethod.to_string
    build_metadata: Option<String>,

}

/// # 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 fmt::Display for ParseSemverError {

    fn fmt(&self, f: &mut fmt::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,

}

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",
        }
    }

}

/// # Pre-release.
///
/// Some common pre-release phrases. Note that their string representation is in _lower-case_.
///
/// You can get this by [`Semver::parse_pre_release()`][Semver::parse_pre_release()].
///
/// [Semver::parse_pre_release()]: struct.Semver.html#method.parse_pre_release
#[derive(Debug, PartialEq, Eq)]
pub enum PreRelease {

    /// # Alpha
    Alpha,

    /// # Beta
    Beta,

    /// # RC
    RC,

    /// # Other
    Other,

}

impl PreRelease {

    /// # Parses a string to get a pre-release
    ///
    /// Notes:
    ///
    /// - The string should be passed from a **parsed** semver.
    /// - Case is ignored.
    fn parse<S>(parsed_pre_release: S) -> Self where S: AsRef<str> {
        let parsed_pre_release = parsed_pre_release.as_ref();

        // Note: do NOT trim the string
        let parsed_pre_release = parsed_pre_release.to_lowercase();
        if parsed_pre_release.starts_with("alpha") { return PreRelease::Alpha; }
        if parsed_pre_release.starts_with("beta") { return PreRelease::Beta; }
        if parsed_pre_release.starts_with("rc") { return PreRelease::RC; }

        PreRelease::Other
    }

}

impl fmt::Display for PreRelease {

    fn fmt(&self, f: &mut fmt::Formatter) -> core::result::Result<(), fmt::Error> {
        f.write_str(match self {
            PreRelease::Alpha => "alpha",
            PreRelease::Beta => "beta",
            PreRelease::RC => "rc",
            PreRelease::Other => "other",
        })
    }

}

/// # Parser
struct Parser<'a> {

    /// # String to be parsed
    src: &'a str,

    /// # Strict mode
    strict: bool,

    /// # Chars of source string
    chars: Skip<CharIndices<'a>>,

}

impl<'a> Parser<'a> {

    /// # Parses input string
    fn parse(src: &'a str, strict: bool) -> Result<Semver> {
        let src = match strict {
            true => src,
            false => src.trim(),
        };

        match src.len() {
            0 => return Err(ParseSemverError { kind: SemverErrorKind::Empty }),
            other => if other.cmp(&Semver::MAX_INPUT_STR_LEN.into()) == Ordering::Greater {
                return Err(ParseSemverError { kind: SemverErrorKind::TooLarge });
            },
        };

        let mut parser = Self {
            src: src,
            strict,
            chars: src.char_indices().skip(0),
        };

        // Major, minor, patch
        let major = parser.parse_major_minor_patch_version(SemverErrorKind::InvalidMajor)?;
        let minor = parser.parse_major_minor_patch_version(SemverErrorKind::InvalidMinor)?;
        let patch = parser.parse_major_minor_patch_version(SemverErrorKind::InvalidPatch)?;

        // Pre-release (optional)
        let pre_release = parser.parse_pre_release_or_build_metadata(self::PRE_RELEASE_STARTER);
        match pre_release {
            Ok(_) => (),
            // Starter can be BUILD_METADATA_STARTER, we'll handle this error later
            Err(ParseSemverError { kind: SemverErrorKind::InvalidToken }) => (),
            Err(err) => return Err(err),
        };

        // Build metadata (optional)
        let build_metadata = parser.parse_pre_release_or_build_metadata(self::BUILD_METADATA_STARTER)?;

        // Pre-release
        let pre_release = {
            match pre_release {
                Ok(pre_release) => pre_release,
                // If there's no build metadata, pre-release must be some string or None -- otherwise it's invalid.
                Err(ParseSemverError { kind: SemverErrorKind::InvalidToken }) => match build_metadata {
                    Some(_) => None,
                    None => return Err(ParseSemverError { kind: SemverErrorKind::InvalidToken }),
                },
                Err(err) => return Err(err),
            }
        };

        Ok(Semver {
            major: major, minor: minor, patch: patch,
            pre_release: pre_release, build_metadata: build_metadata,
        })
    }

    /// # Parses major/minor/patch version
    fn parse_major_minor_patch_version(&mut self, err_kind: SemverErrorKind) -> Result<u128> {
        let err = |err_kind| Err(ParseSemverError { kind: err_kind });

        let mut skip_last_char = false;
        let mut start_index: Option<usize> = None;
        let mut end_index: Option<usize> = None;
        let mut invalid_char_index: Option<usize> = None;
        let mut first_char_is_zero = false;

        for (index, chr) in &mut self.chars {
            match chr {
                '.' => match start_index {
                    Some(_) => { skip_last_char = true; break; },
                    None => return err(err_kind),
                },
                '0'..='9' => {
                    if let Some(start_index) = start_index {
                        if let Some(gap) = index.checked_sub(start_index) {
                            if (gap > 0 && first_char_is_zero) || gap.cmp(&self::MAX_STR_LEN_OF_A_VERSION_NUMBER.into()) != Ordering::Less {
                                return err(err_kind);
                            }
                        }
                    } else {
                        start_index = Some(index);
                        first_char_is_zero = chr == '0';
                    }
                    end_index = Some(index);
                },
                _ => {
                    invalid_char_index = Some(index);
                    break;
                },
            };
        }

        match (start_index, end_index) {
            (Some(start_index), Some(end_index)) if end_index >= start_index => match u128::from_str(&self.src[start_index..=end_index]) {
                Ok(v) => {
                    self.chars = self.src.char_indices().skip(
                        end_index.checked_add(if skip_last_char { 2 } else { 1 }).unwrap_or(usize::max_value())
                    );
                    Ok(v)
                },
                Err(_) => err(err_kind),
            },
            _ => {
                if let Some(index) = invalid_char_index { self.chars = self.src.char_indices().skip(index); }
                match err_kind {
                    SemverErrorKind::InvalidMinor => match self.strict {
                        true => match invalid_char_index {
                            Some(_) => err(err_kind),
                            None => Err(ParseSemverError { kind: SemverErrorKind::MissingMinor }),
                        },
                        false => Ok(0),
                    },
                    SemverErrorKind::InvalidPatch => match self.strict {
                        true => match invalid_char_index {
                            Some(_) => err(err_kind),
                            None => Err(ParseSemverError { kind: SemverErrorKind::MissingPatch }),
                        },
                        false => Ok(0),
                    },
                    _ => err(err_kind),
                }
            },
        }
    }

    /// # Parses pre-release or build metadata
    ///
    /// `starter`: can be [`PRE_RELEASE_STARTER`][::PRE_RELEASE_STARTER] or [`BUILD_METADATA_STARTER`][::BUILD_METADATA_STARTER].
    ///
    /// [::PRE_RELEASE_STARTER]: constant.PRE_RELEASE_STARTER.html
    /// [::BUILD_METADATA_STARTER]: constant.BUILD_METADATA_STARTER.html
    fn parse_pre_release_or_build_metadata(&mut self, starter: char) -> Result<Option<String>> {
        // Check starter and setup error kind
        let err_kind = match starter {
            self::PRE_RELEASE_STARTER => SemverErrorKind::InvalidPreRelease,
            self::BUILD_METADATA_STARTER => SemverErrorKind::InvalidBuildMetadata,
            _ => return Err(ParseSemverError{ kind: SemverErrorKind::ParserError }),
        };
        let err = || Err(ParseSemverError { kind: err_kind });

        let mut start_index: Option<usize> = None;
        let mut end_index: Option<usize> = None;
        let mut first_char_is_zero: Option<bool> = None;
        let mut last_char: Option<char> = None;
        let mut all_are_numbers = false;

        // Check token
        match self.chars.next() {
            Some((index, chr)) => if chr != starter {
                self.chars = self.src.char_indices().skip(index);
                return Err(ParseSemverError{ kind: SemverErrorKind::InvalidToken });
            },
            None => return Ok(None),
        };

        for (index, chr) in &mut self.chars {
            if start_index.is_none() { start_index = Some(index); }

            // This is for section 9: a pre-release numeric identifier MUST NOT include leading zeroes
            if starter == self::PRE_RELEASE_STARTER && first_char_is_zero.is_none() {
                if chr == '.' { return err(); }
                first_char_is_zero = Some(chr == '0');
                all_are_numbers = true;
            }

            match chr {
                'a'..='z' | 'A'..='Z' | '-' => {
                    end_index = Some(index);
                    all_are_numbers = false;
                },
                '0'..='9' => end_index = Some(index),
                // Pre-release is allowed to have build metadata go after it. But build metadata is not.
                self::BUILD_METADATA_STARTER => if starter == self::PRE_RELEASE_STARTER { break; } else { return err(); },
                '.' => {
                    if let Some(true) = first_char_is_zero {
                        if all_are_numbers { return err(); }
                        first_char_is_zero = None;
                    }
                    match last_char {
                        Some(c) => match c {
                            '.' | '-' => return err(),
                            _ => last_char = None,
                        },
                        None => return err(),
                    };
                    continue;
                },
                _ => return err(),
            };

            last_char = Some(chr);
        }

        match (last_char, start_index, end_index) {
            (Some(last_char), Some(start_index), Some(end_index)) if last_char.is_ascii_alphanumeric() => {
                self.chars = self.src.char_indices().skip(end_index.checked_add(1).unwrap_or(usize::max_value()));
                Ok(Some(self.src[start_index..=end_index].to_string()))
            },
            _ => err(),
        }
    }

}

impl Semver {

    /// # Max input string length allowed to be parsed
    pub const MAX_INPUT_STR_LEN: u16 = 2048;

    /// # Makes new semver from raw input version numbers
    ///
    /// This function does not support pre-release and build metadata -- which are required to be parsed. For convenience, it returns a direct
    /// instance, not a `Result<Semver>`. If you need pre-release and/or build metadata, you can use [`parse()`][::parse()].
    ///
    /// [::parse()]: #method.parse
    pub const fn new(major: u128, minor: u128, patch: u128) -> Semver {
        Semver {
            major, minor, patch,
            pre_release: None, build_metadata: None,
        }
    }

    /// # Parses input string to make a new semver
    ///
    /// - Minor and patch version numbers are **required**.
    /// - Leading/trailing white spaces are **not** allowed.
    ///
    /// For convenience, you can use [`from_str()`][::from_str()] implemented from [`FromStr`][std::str::FromStr] trait. It uses _tolerant_
    /// parser, in which:
    ///
    /// - Minor and patch version numbers are optional.
    /// - Leading/trailing white spaces are ignored.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::str::FromStr;
    /// use dia_semver::Semver;
    ///
    /// assert_eq!(Semver::parse("1.2.3").unwrap().to_string(), "1.2.3");
    /// assert_eq!(Semver::from_str("\t     1-a.b.c     \r\n").unwrap().to_string(), "1.0.0-a.b.c");
    /// ```
    ///
    /// [::from_str()]: #method.from_str
    /// [std::str::FromStr]: https://doc.rust-lang.org/std/str/trait.FromStr.html
    pub fn parse<S>(s: S) -> Result<Semver> where S: AsRef<str> {
        Parser::parse(s.as_ref(), true)
    }

    /// # Parses an [`&OsStr`][std::ffi::OsStr]
    ///
    /// _See [`Parser`] for details_.
    ///
    /// [`Parser`]: struct.Parser.html
    /// [std::ffi::OsStr]: https://doc.rust-lang.org/std/ffi/struct.OsStr.html
    #[cfg(feature="std")]
    fn parse_os_str_with_options<S>(s: S, strict: bool) -> Result<Semver> where S: AsRef<OsStr> {
        match s.as_ref().to_str() {
            Some(s) => Parser::parse(s.as_ref(), strict),
            None => Err(ParseSemverError { kind: SemverErrorKind::InvalidToken }),
        }
    }

    /// # Parses an [`&OsStr`][std::ffi::OsStr]
    ///
    /// This function uses strict parser.
    ///
    /// [std::ffi::OsStr]: https://doc.rust-lang.org/std/ffi/struct.OsStr.html
    #[cfg(feature="std")]
    pub fn parse_os_str<S>(s: S) -> Result<Semver> where S: AsRef<OsStr> {
        Self::parse_os_str_with_options(s, true)
    }

    /// # Parses an [`&OsStr`][std::ffi::OsStr]
    ///
    /// This function uses tolerant parser.
    ///
    /// [std::ffi::OsStr]: https://doc.rust-lang.org/std/ffi/struct.OsStr.html
    #[cfg(feature="std")]
    pub fn from_os_str<S>(s: S) -> Result<Semver> where S: AsRef<OsStr> {
        Self::parse_os_str_with_options(s, false)
    }

    /// # Parses a [`&CStr`][std::ffi::CStr]
    ///
    /// _See [`Parser`] for details_.
    ///
    /// [`Parser`]: struct.Parser.html
    /// [std::ffi::CStr]: https://doc.rust-lang.org/std/ffi/struct.CStr.html
    #[cfg(feature="std")]
    fn parse_c_str_with_options<S>(s: S, strict: bool) -> Result<Semver> where S: AsRef<CStr> {
        match s.as_ref().to_str() {
            Ok(s) => Parser::parse(s.as_ref(), strict),
            _ => Err(ParseSemverError { kind: SemverErrorKind::InvalidToken }),
        }
    }

    /// # Parses a [`&CStr`][std::ffi::CStr]
    ///
    /// This function uses strict parser.
    ///
    /// [std::ffi::CStr]: https://doc.rust-lang.org/std/ffi/struct.CStr.html
    #[cfg(feature="std")]
    pub fn parse_c_str<S>(s: S) -> Result<Semver> where S: AsRef<CStr> {
        Self::parse_c_str_with_options(s, true)
    }

    /// # Parses a [`&CStr`][std::ffi::CStr]
    ///
    /// This function uses tolerant parser.
    ///
    /// [std::ffi::CStr]: https://doc.rust-lang.org/std/ffi/struct.CStr.html
    #[cfg(feature="std")]
    pub fn from_c_str<S>(s: S) -> Result<Semver> where S: AsRef<CStr> {
        Self::parse_c_str_with_options(s, false)
    }

    /// # Major
    pub fn major(&self) -> u128 {
        self.major
    }

    /// # Minor
    pub fn minor(&self) -> u128 {
        self.minor
    }

    /// # Patch
    pub fn patch(&self) -> u128 {
        self.patch
    }

    /// # Build metadata
    pub fn build_metadata(&self) -> Option<&str> {
        self.build_metadata.as_ref().map(|bm| bm.as_str())
    }

    /// # Pre-release
    pub fn pre_release(&self) -> Option<&str> {
        self.pre_release.as_ref().map(|pr| pr.as_str())
    }

    /// # Checks to see if the semver is stable
    ///
    /// A semver is stable if:
    ///
    /// - It's not a pre-release.
    /// - Its major version is larger than zero.
    pub fn is_stable(&self) -> bool {
        self.major > 0 && self.pre_release.is_none()
    }

    /// # Checks to see if the semver is in early development state, in which major version is zero
    pub fn is_early(&self) -> bool {
        self.major == 0
    }

    /// # Parses pre-release to see if it starts with some common phrases
    ///
    /// Notes:
    ///
    /// - Case is ignored.
    /// - If it returns `None`, it means the semver doesn't have a pre-release.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::str::FromStr;
    /// use dia_semver::{Semver, PreRelease};
    ///
    /// match Semver::from_str("1.2.3-hola").unwrap().parse_pre_release() {
    ///     Some(PreRelease::Alpha) => println!("Alpha"),
    ///     Some(PreRelease::Beta) => println!("Beta"),
    ///     Some(PreRelease::RC) => println!("RC"),
    ///     Some(PreRelease::Other) => println!("Other"),
    ///     None => println!("Not available"),
    /// };
    /// ```
    pub fn parse_pre_release(&self) -> Option<PreRelease> {
        self.pre_release.as_ref().map(|pre_release| PreRelease::parse(pre_release))
    }

    /// # Checks to see if this semver is compatible with one other
    ///
    /// Two semvers are compatible with each other if one of these conditions is true:
    ///
    /// - They have same major version, which must be larger than `0`.
    /// - If both major versions are `0`, they must have _exactly_ these same components: major, minor, patch, pre-release.
    ///
    /// # Examples
    /// ```
    /// use std::str::FromStr;
    /// use dia_semver::Semver;
    ///
    /// assert!(Semver::new(1, 0, 1).compatible_with(&Semver::new(1, 2, 3)));
    /// assert!(Semver::new(1, 0, 1).compatible_with(&Semver::new(1, 99, 9)));
    /// assert!(Semver::new(1, 0, 1).compatible_with(&Semver::new(2, 0, 0)) == false);
    /// assert!(Semver::new(0, 0, 1).compatible_with(Semver::new(0, 2, 0)) == false);
    /// assert!(Semver::new(0, 0, 1).compatible_with(Semver::from_str("0.0.1-abc").unwrap()) == false);
    /// assert!(Semver::new(0, 0, 1).compatible_with(Semver::from_str("0.0.1+abc").unwrap()));
    /// ```
    pub fn compatible_with<T>(&self, other: T) -> bool where T: AsRef<Semver> {
        let other = other.as_ref();

        if self.major != other.major { return false; }
        if self.major > 0 { return true; }
        if self.minor != other.minor || self.patch != other.patch { return false; }

        match (self.pre_release.as_ref(), other.pre_release.as_ref()) {
            (Some(self_pre_release), Some(other_pre_release)) => self_pre_release == other_pre_release,
            (None, None) => true,
            _ => false,
        }
    }

    /// # Makes new semver with major version incremented by `1`
    ///
    /// ## Notes
    ///
    /// - Pre-release and build metadata will be dropped.
    /// - `checked_add()` will be used. So if overflow happens, `None` is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::str::FromStr;
    /// use dia_semver::Semver;
    ///
    /// assert_eq!(Semver::from_str("1.2.3-abc+xyz").unwrap().new_major().unwrap().to_string(), "2.0.0");
    /// ```
    pub fn new_major(&self) -> Option<Semver> {
        match self.major.checked_add(1) {
            Some(new_major) => Some(Self::new(new_major, 0, 0)),
            None => None,
        }
    }

    /// # Makes new semver with minor version incremented by `1`
    ///
    /// ## Notes
    ///
    /// - Pre-release and build metadata will be dropped.
    /// - `checked_add()` will be used. So if overflow happens, `None` is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::str::FromStr;
    /// use dia_semver::Semver;
    ///
    /// assert_eq!(Semver::from_str("1.2.3-abc+xyz").unwrap().new_minor().unwrap().to_string(), "1.3.0");
    /// ```
    pub fn new_minor(&self) -> Option<Semver> {
        match self.minor.checked_add(1) {
            Some(new_minor) => Some(Self::new(self.major, new_minor, 0)),
            None => None,
        }
    }

    /// # Makes new semver with patch version incremented by `1`
    ///
    /// ## Notes
    ///
    /// - Pre-release and build metadata will be dropped.
    /// - `checked_add()` will be used. So if overflow happens, `None` is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::str::FromStr;
    /// use dia_semver::Semver;
    ///
    /// assert_eq!(Semver::from_str("1.2.3-abc+xyz").unwrap().new_patch().unwrap().to_string(), "1.2.4");
    /// ```
    pub fn new_patch(&self) -> Option<Semver> {
        match self.patch.checked_add(1) {
            Some(new_patch) => Some(Self::new(self.major, self.minor, new_patch)),
            None => None,
        }
    }

    /// # Makes new semver with same version numbers, but new pre-release and/or same build metadata
    ///
    /// `pre_release` should _not_ include leading character `-`; it will be added automatically.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::str::FromStr;
    /// use dia_semver::Semver;
    ///
    /// assert_eq!(
    ///     Semver::from_str("1.2.3-alpha.1+abc").unwrap()
    ///         .new_pre_release("alpha.2", false).unwrap()
    ///         .to_string(),
    ///     "1.2.3-alpha.2"
    /// );
    /// ```
    pub fn new_pre_release<S>(&self, pre_release: S, keep_build_metadata: bool) -> Result<Semver> where S: AsRef<str> {
        let pre_release = pre_release.as_ref();

        // Pre-release
        let mut s = alloc::format!(
            "{major}.{minor}.{patch}{pre_release_starter}{pre_release}",
            major=self.major, minor=self.minor, patch=self.patch, pre_release_starter=self::PRE_RELEASE_STARTER, pre_release=pre_release,
        );

        // Build metadata
        if keep_build_metadata {
            if let Some(build_metadata) = self.build_metadata.as_ref() {
                s.push(self::BUILD_METADATA_STARTER);
                s.push_str(build_metadata);
            }
        }

        Self::parse(s)
    }

    /// # Makes new semver with same version numbers, but new build metadata and/or same pre-release
    ///
    /// `build_metadata` should _not_ include leading character `+`; it will be added automatically.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::str::FromStr;
    /// use dia_semver::Semver;
    ///
    /// assert_eq!(
    ///     Semver::from_str("1.2.3-alpha.1+abc").unwrap()
    ///         .new_build_metadata("xyz", false).unwrap()
    ///         .to_string(),
    ///     "1.2.3+xyz"
    /// );
    /// ```
    pub fn new_build_metadata<S>(&self, build_metadata: S, keep_pre_release: bool) -> Result<Semver> where S: AsRef<str> {
        let build_metadata = build_metadata.as_ref();

        let mut s = alloc::format!("{major}.{minor}.{patch}", major=self.major, minor=self.minor, patch=self.patch);

        // Pre-release
        if keep_pre_release {
            if let Some(pre_release) = self.pre_release.as_ref() {
                s.push(self::PRE_RELEASE_STARTER);
                s.push_str(pre_release);
            }
        }

        // Build metadata
        s.push(self::BUILD_METADATA_STARTER);
        s.push_str(build_metadata);

        Self::parse(s)
    }

}

impl PartialEq for Semver {

    fn eq(&self, other: &Semver) -> bool {
        self.cmp(&other) == Ordering::Equal
    }

}

impl Ord for Semver {

    fn cmp(&self, other: &Semver) -> Ordering {
        // Major, minor, patch
        match self.major.cmp(&other.major) {
            Ordering::Equal => match self.minor.cmp(&other.minor) {
                Ordering::Equal => match self.patch.cmp(&other.patch) {
                    Ordering::Equal => (),
                    x => return x,
                },
                x => return x,
            },
            x => return x,
        };

        // Comparing pre-releases: see section 11
        match (self.pre_release.as_ref(), other.pre_release.as_ref()) {
            (None, None) => return Ordering::Equal,
            (None, Some(_)) => return Ordering::Greater,
            (Some(_), None) => return Ordering::Less,
            (Some(self_pre_release), Some(other_pre_release)) => {
                let mut self_pre_release = self_pre_release.split('.');
                let mut other_pre_release = other_pre_release.split('.');
                loop {
                    match (self_pre_release.next(), other_pre_release.next()) {
                        (None, None) => return Ordering::Equal,
                        (None, Some(_)) => return Ordering::Less,
                        (Some(_), None) => return Ordering::Greater,
                        (Some(self_field), Some(other_field)) => {
                            let self_field_is_number = self_field.chars().any(|c| c < '0' || c > '9') == false;
                            let other_field_is_number = other_field.chars().any(|c| c < '0' || c > '9') == false;
                            match (self_field_is_number, other_field_is_number) {
                                // Specification just says "numeric identifiers". So they might be large, we don't parse them into integers.
                                // The fields only contain ASCII numbers, so it's ok to use `len()`
                                (true, true) => match self_field.len().cmp(&other_field.len()) {
                                    Ordering::Equal => match self_field.cmp(&other_field) {
                                        Ordering::Equal => (),
                                        x => return x,
                                    },
                                    x => return x,
                                },
                                (true, false) => return Ordering::Less,
                                (false, true) => return Ordering::Greater,
                                (false, false) => match self_field.cmp(&other_field) {
                                    Ordering::Equal => (),
                                    x => return x,
                                },
                            };
                        },
                    };
                }
            },
        };
    }

}

impl PartialOrd for Semver {

    fn partial_cmp(&self, other: &Semver) -> Option<Ordering> {
        Some(self.cmp(other))
    }

}

impl Hash for Semver {

    fn hash<H: Hasher>(&self, state: &mut H) {
        self.major.hash(state);
        self.minor.hash(state);
        self.patch.hash(state);

        if let Some(pre_release) = self.pre_release.as_ref() {
            pre_release.hash(state);
        }
    }

}

impl FromStr for Semver {

    type Err = ParseSemverError;

    /// # Parses input string via _tolerant_ parser to make a new semver
    ///
    /// - Minor and patch version numbers are optional.
    /// - Leading/trailing white spaces are ignored.
    ///
    /// For strict parser, see [`parse()`][::parse()].
    ///
    /// [::parse()]: #method.parse
    fn from_str(s: &str) -> core::result::Result<Self, Self::Err> {
        Parser::parse(s, false)
    }

}

impl fmt::Display for Semver {

    fn fmt(&self, f: &mut fmt::Formatter) -> core::result::Result<(), fmt::Error> {
        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)?;

        if let Some(pre_release) = self.pre_release.as_ref() {
            write!(f, "{}{}", self::PRE_RELEASE_STARTER, pre_release)?;
        }

        if let Some(build_metadata) = self.build_metadata.as_ref() {
            write!(f, "{}{}", self::BUILD_METADATA_STARTER, build_metadata)?;
        }

        Ok(())
    }

}

impl AsRef<Semver> for Semver {

    fn as_ref(&self) -> &Self {
        self
    }

}

#[test]
fn test_semver_internal_stuff() {
    assert_eq!(
        Semver::new(0, 0, 0).major.wrapping_sub(1).to_string().len().cmp(&self::MAX_STR_LEN_OF_A_VERSION_NUMBER.into()),
        Ordering::Equal
    );
}