//! Parsing and comparison for Tor versions

//!

//! Tor versions use a slightly unusual encoding described in Tor's

//! [version-spec.txt](https://spec.torproject.org/version-spec).

//! Briefly, version numbers are of the form

//!

//! `MAJOR.MINOR.MICRO[.PATCHLEVEL][-STATUS_TAG][ (EXTRA_INFO)]*`

//!

//! Here we parse everything up to the first space, but ignore the

//! "EXTRA_INFO" component.

//!

//! Why does Arti have to care about Tor versions?  Sometimes a given

//! Tor version is broken for one purpose or another, and it's

//! important to avoid using them for certain kinds of traffic.  (For

//! planned incompatibilities, you should use protocol versions

//! instead.)

//!

//! # Examples

//!

//! ```

//! use tor_netdoc::types::version::TorVersion;

//! let older: TorVersion = "0.3.5.8".parse()?;

//! let latest: TorVersion = "0.4.3.4-rc".parse()?;

//! assert!(older < latest);

//!

//! # tor_netdoc::Result::Ok(())

//! ```

//!

//! # Limitations

//!

//! This module handles the version format which Tor has used ever

//! since 0.1.0.1-rc.  Earlier versions used a different format, also

//! documented in

//! [version-spec.txt](https://spec.torproject.org/version-spec).

//! Fortunately, those versions are long obsolete, and there's not

//! much reason to parse them.

//!

//! TODO: Possibly, this module should be extracted into a crate of

//! its own.  I'm not 100% sure though -- does anything need versions

//! but not network docs?

use std::fmt::{self, Display, Formatter};

use std::str::FromStr;

use crate::{NetdocErrorKind as EK, Pos};

/// Represents the status tag on a Tor version number

///

/// Status tags indicate that a release is alpha, beta (seldom used),

/// a release candidate (rc), or stable.

///

/// We accept unrecognized tags, and store them as "Other".

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]

#[repr(u8)]

enum TorVerStatus {

    /// An unknown release status

    Other,

    /// An alpha release

    Alpha,

    /// A beta release

    Beta,

    /// A release candidate

    Rc,

    /// A stable release

    Stable,

}

impl TorVerStatus {

    /// Helper for encoding: return the suffix that represents a version.

        use TorVerStatus::*;

        }

}

/// A parsed Tor version number.

#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]

pub struct TorVersion {

    /// Major version number.  This has been zero since Tor was created.

    major: u8,

    /// Minor version number.

    minor: u8,

    /// Micro version number.  The major, minor, and micro version numbers

    /// together constitute a "release series" that starts as an alpha

    /// and eventually becomes stable.

    micro: u8,

    /// Patchlevel within a release series

    patch: u8,

    /// Status of a given release

    status: TorVerStatus,

    /// True if this version is given the "-dev" tag to indicate that it

    /// isn't a real Tor release, but rather indicates the state of Tor

    /// within some git repository.

    dev: bool,

}

impl Display for TorVersion {

            self.major,

            self.minor,

            self.micro,

            self.patch,

            devsuffix

        )

}

impl FromStr for TorVersion {

    type Err = crate::Error;

        // Split the string on "-" into "version", "status", and "dev."

        // Note that "dev" may actually be in the "status" field if

        // the version is stable; we'll handle that later.

            // NOTE: If `dev_part` cannot be unwrapped then there are bigger

            // problems with `s` input

            #[allow(clippy::unwrap_used)]

        // Split the version on "." into 3 or 4 numbers.

        // Compute real status and version.

        };

            }

        };

}

#[cfg(test)]

mod test {

    // @@ begin test lint list maintained by maint/add_warning @@

    #![allow(clippy::bool_assert_comparison)]

    #![allow(clippy::clone_on_copy)]

    #![allow(clippy::dbg_macro)]

    #![allow(clippy::mixed_attributes_style)]

    #![allow(clippy::print_stderr)]

    #![allow(clippy::print_stdout)]

    #![allow(clippy::single_char_pattern)]

    #![allow(clippy::unwrap_used)]

    #![allow(clippy::unchecked_time_subtraction)]

    #![allow(clippy::useless_vec)]

    #![allow(clippy::needless_pass_by_value)]

    //! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

    use super::*;

    #[test]

    fn parse_good() {

        let mut lastver = None;

        for (s1, s2) in &[

            ("0.1.2", "0.1.2.0"),

            ("0.1.2.0-dev", "0.1.2.0-dev"),

            ("0.4.3.1-bloop", "0.4.3.1-???"),

            ("0.4.3.1-alpha", "0.4.3.1-alpha"),

            ("0.4.3.1-alpha-dev", "0.4.3.1-alpha-dev"),

            ("0.4.3.1-beta", "0.4.3.1-beta"),

            ("0.4.3.1-rc", "0.4.3.1-rc"),

            ("0.4.3.1", "0.4.3.1"),

        ] {

            let t: TorVersion = s1.parse().unwrap();

            assert_eq!(&t.to_string(), s2);

            if let Some(v) = lastver {

                assert!(v < t);

            }

            lastver = Some(t);

        }

    }

    #[test]

    fn parse_bad() {

        for s in &[

            "fred.and.bob",

            "11",

            "11.22",

            "0x2020",

            "1.2.3.marzipan",

            "0.1.2.5-alpha-deeev",

            "0.1.2.5-alpha-dev-turducken",

        ] {

            assert!(s.parse::<TorVersion>().is_err());

        }

    }

}