kind.rs.html -- source

use std::str::FromStr;
use std::fmt::{self, Display, Formatter};
use std::ffi::OsStr;

use aho_corasick::{Automaton, AcAutomaton, Dense};

use {Agpl3, Apache2, Cc01, Gpl3, Lgpl3, License, Mit, Mpl2, Unknown, Unlicense};
use conditions::*;
use limitations::*;
use permissions::*;

/// Enum containing all supported licenses.
///
/// # Examples
/// ```
/// use std::str::FromStr;
/// use license::{Apache2, Gpl3, LicenseKind};
///
/// // From text:
/// let apache2 = LicenseKind::from_str(include_str!("files/APACHE-2"));
/// assert_eq!(apache2, Ok(LicenseKind::Apache2(Apache2)));
///
/// // From identity:
/// let gpl3 = LicenseKind::from_str("GPL-3.0");
/// assert_eq!(gpl3, Ok(LicenseKind::Gpl3(Gpl3)));
/// ```
#[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
pub enum LicenseKind {
    Agpl3(Agpl3),
    Apache2(Apache2),
    Cc01(Cc01),
    Gpl3(Gpl3),
    Lgpl3(Lgpl3),
    Mit(Mit),
    Mpl2(Mpl2),
    Unlicense(Unlicense),
}

impl License for LicenseKind {
    #[inline]
    fn name(&self) -> &str {
        match *self {
            LicenseKind::Agpl3(ref agpl3) => agpl3.name(),
            LicenseKind::Apache2(ref apache2) => apache2.name(),
            LicenseKind::Cc01(ref cc01) => cc01.name(),
            LicenseKind::Gpl3(ref gpl3) => gpl3.name(),
            LicenseKind::Lgpl3(ref lgpl3) => lgpl3.name(),
            LicenseKind::Mit(ref mit) => mit.name(),
            LicenseKind::Mpl2(ref mpl2) => mpl2.name(),
            LicenseKind::Unlicense(ref unlicense) => unlicense.name(),
        }
    }

    #[inline]
    fn id(&self) -> &str {
        match *self {
            LicenseKind::Agpl3(ref agpl3) => agpl3.id(),
            LicenseKind::Apache2(ref apache2) => apache2.id(),
            LicenseKind::Cc01(ref cc01) => cc01.id(),
            LicenseKind::Gpl3(ref gpl3) => gpl3.id(),
            LicenseKind::Lgpl3(ref lgpl3) => lgpl3.id(),
            LicenseKind::Mit(ref mit) => mit.id(),
            LicenseKind::Mpl2(ref mpl2) => mpl2.id(),
            LicenseKind::Unlicense(ref unlicense) => unlicense.id(),
        }
    }

    #[inline]
    fn is_osi_approved(&self) -> bool {
        match *self {
            LicenseKind::Agpl3(agpl3) => agpl3.is_osi_approved(),
            LicenseKind::Apache2(apache2) => apache2.is_osi_approved(),
            LicenseKind::Cc01(cc01) => cc01.is_osi_approved(),
            LicenseKind::Gpl3(gpl3) => gpl3.is_osi_approved(),
            LicenseKind::Lgpl3(lgpl3) => lgpl3.is_osi_approved(),
            LicenseKind::Mit(ref mit) => mit.is_osi_approved(),
            LicenseKind::Mpl2(mpl2) => mpl2.is_osi_approved(),
            LicenseKind::Unlicense(unlicense) => unlicense.is_osi_approved(),
        }
    }

    #[inline]
    fn text(&self) -> &str {
        match *self {
            LicenseKind::Agpl3(ref agpl3) => agpl3.text(),
            LicenseKind::Apache2(ref apache2) => apache2.text(),
            LicenseKind::Cc01(ref cc01) => cc01.text(),
            LicenseKind::Gpl3(ref gpl3) => gpl3.text(),
            LicenseKind::Lgpl3(ref lgpl3) => lgpl3.text(),
            LicenseKind::Mit(ref mit) => mit.text(),
            LicenseKind::Mpl2(ref mpl2) => mpl2.text(),
            LicenseKind::Unlicense(ref unlicense) => unlicense.text(),
        }
    }

    #[inline]
    fn permissions(&self) -> Permissions {
        match *self {
            LicenseKind::Agpl3(agpl3) => agpl3.permissions(),
            LicenseKind::Apache2(apache2) => apache2.permissions(),
            LicenseKind::Cc01(cc01) => cc01.permissions(),
            LicenseKind::Gpl3(gpl3) => gpl3.permissions(),
            LicenseKind::Lgpl3(lgpl3) => lgpl3.permissions(),
            LicenseKind::Mit(ref mit) => mit.permissions(),
            LicenseKind::Mpl2(mpl2) => mpl2.permissions(),
            LicenseKind::Unlicense(unlicense) => unlicense.permissions(),
        }
    }

    #[inline]
    fn conditions(&self) -> Conditions {
        match *self {
            LicenseKind::Agpl3(agpl3) => agpl3.conditions(),
            LicenseKind::Apache2(apache2) => apache2.conditions(),
            LicenseKind::Cc01(cc01) => cc01.conditions(),
            LicenseKind::Gpl3(gpl3) => gpl3.conditions(),
            LicenseKind::Lgpl3(lgpl3) => lgpl3.conditions(),
            LicenseKind::Mit(ref mit) => mit.conditions(),
            LicenseKind::Mpl2(mpl2) => mpl2.conditions(),
            LicenseKind::Unlicense(unlicense) => unlicense.conditions(),
        }
    }

    #[inline]
    fn limitations(&self) -> Limitations {
        match *self {
            LicenseKind::Agpl3(agpl3) => agpl3.limitations(),
            LicenseKind::Apache2(apache2) => apache2.limitations(),
            LicenseKind::Cc01(cc01) => cc01.limitations(),
            LicenseKind::Gpl3(gpl3) => gpl3.limitations(),
            LicenseKind::Lgpl3(lgpl3) => lgpl3.limitations(),
            LicenseKind::Mit(ref mit) => mit.limitations(),
            LicenseKind::Mpl2(mpl2) => mpl2.limitations(),
            LicenseKind::Unlicense(unlicense) => unlicense.limitations(),
        }
    }

    #[inline]
    fn homepage(&self) -> Option<&str> {
        match *self {
            LicenseKind::Agpl3(ref agpl3) => agpl3.homepage(),
            LicenseKind::Apache2(ref apache2) => apache2.homepage(),
            LicenseKind::Cc01(ref cc01) => cc01.homepage(),
            LicenseKind::Gpl3(ref gpl3) => gpl3.homepage(),
            LicenseKind::Lgpl3(ref lgpl3) => lgpl3.homepage(),
            LicenseKind::Mit(ref mit) => mit.homepage(),
            LicenseKind::Mpl2(ref mpl2) => mpl2.homepage(),
            LicenseKind::Unlicense(ref unlicense) => unlicense.homepage(),
        }
    }
}

impl FromStr for LicenseKind {
    type Err = Unknown;

    #[inline]
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "AGPL-3.0" => Ok(LicenseKind::Agpl3(Agpl3)),
            "Apache-2.0" => Ok(LicenseKind::Apache2(Apache2)),
            "CC0-1.0" => Ok(LicenseKind::Cc01(Cc01)),
            "GPL-3.0" => Ok(LicenseKind::Gpl3(Gpl3)),
            "LGPL-3.0" => Ok(LicenseKind::Lgpl3(Lgpl3)),
            "MIT" => Ok(LicenseKind::Mit(Mit::default())),
            "MPL-2.0" => Ok(LicenseKind::Mpl2(Mpl2)),
            "Unlicense" => Ok(LicenseKind::Unlicense(Unlicense)),
            s => {
                lazy_static! {
                    static ref AHO: AcAutomaton<&'static &'static str, Dense> = {
                        const PATS: &[&str] = &[
                            "MIT License",                                                              // 0
                            "Apache License",                                                           // 1
                            "Version 2.0",                                                              // 2
                            "GNU GENERAL PUBLIC LICENSE",                                               // 3
                            "Version 3",                                                                // 4
                            "Mozilla Public License",                                                   // 5
                            "This is free and unencumbered software released into the public domain.",  // 6
                            "GNU LESSER GENERAL PUBLIC LICENSE",                                        // 7
                            "GNU AFFERO GENERAL PUBLIC LICENSE",                                        // 8
                            "CC0 1.0 Universal",                                                        // 9
                        ];
                        AcAutomaton::new(PATS)
                    };
                }
                let mut it = AHO.find(s);
                match it.next() {
                    Some(m) => {
                        match m.pati {
                            0 => Ok(LicenseKind::Mit(Mit(s.to_string()))),
                            1 => {
                                match it.next() {
                                    Some(m) if m.pati == 2 => Ok(LicenseKind::Apache2(Apache2)),
                                    _ => Err(Unknown),
                                }
                            }
                            3 => {
                                match it.next() {
                                    Some(m) if m.pati == 4 => Ok(LicenseKind::Gpl3(Gpl3)),
                                    _ => Err(Unknown),
                                }
                            }
                            5 => {
                                match it.next() {
                                    Some(m) if m.pati == 2 => Ok(LicenseKind::Mpl2(Mpl2)),
                                    _ => Err(Unknown),
                                }
                            }
                            6 => Ok(LicenseKind::Unlicense(Unlicense)),
                            7 => {
                                match it.next() {
                                    Some(m) if m.pati == 4 => Ok(LicenseKind::Lgpl3(Lgpl3)),
                                    _ => Err(Unknown),
                                }
                            }
                            8 => {
                                match it.next() {
                                    Some(m) if m.pati == 4 => Ok(LicenseKind::Agpl3(Agpl3)),
                                    _ => Err(Unknown),
                                }
                            }
                            9 => Ok(LicenseKind::Cc01(Cc01)),
                            _ => Err(Unknown),
                        }
                    }
                    None => Err(Unknown),
                }
            }
        }
    }
}

impl Display for LicenseKind {
    #[inline]
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        match *self {
            LicenseKind::Agpl3(agpl3) => write!(f, "{}", agpl3),
            LicenseKind::Apache2(apache2) => write!(f, "{}", apache2),
            LicenseKind::Cc01(cc01) => write!(f, "{}", cc01),
            LicenseKind::Gpl3(gpl3) => write!(f, "{}", gpl3),
            LicenseKind::Lgpl3(lgpl3) => write!(f, "{}", lgpl3),
            LicenseKind::Mit(ref mit) => write!(f, "{}", mit),
            LicenseKind::Mpl2(mpl2) => write!(f, "{}", mpl2),
            LicenseKind::Unlicense(unlicense) => write!(f, "{}", unlicense),
        }
    }
}

impl AsRef<str> for LicenseKind {
    #[inline]
    fn as_ref(&self) -> &str {
        match *self {
            LicenseKind::Agpl3(ref agpl3) => agpl3.as_ref(),
            LicenseKind::Apache2(ref apache2) => apache2.as_ref(),
            LicenseKind::Cc01(ref cc01) => cc01.as_ref(),
            LicenseKind::Gpl3(ref gpl3) => gpl3.as_ref(),
            LicenseKind::Lgpl3(ref lgpl3) => lgpl3.as_ref(),
            LicenseKind::Mit(ref mit) => mit.as_ref(),
            LicenseKind::Mpl2(ref mpl2) => mpl2.as_ref(),
            LicenseKind::Unlicense(ref unlicense) => unlicense.as_ref(),
        }
    }
}

impl AsRef<OsStr> for LicenseKind {
    #[inline]
    fn as_ref(&self) -> &OsStr {
        match *self {
            LicenseKind::Agpl3(ref agpl3) => agpl3.as_ref(),
            LicenseKind::Apache2(ref apache2) => apache2.as_ref(),
            LicenseKind::Cc01(ref cc01) => cc01.as_ref(),
            LicenseKind::Gpl3(ref gpl3) => gpl3.as_ref(),
            LicenseKind::Lgpl3(ref lgpl3) => lgpl3.as_ref(),
            LicenseKind::Mit(ref mit) => mit.as_ref(),
            LicenseKind::Mpl2(ref mpl2) => mpl2.as_ref(),
            LicenseKind::Unlicense(ref unlicense) => unlicense.as_ref(),
        }
    }
}

impl AsRef<[u8]> for LicenseKind {
    #[inline]
    fn as_ref(&self) -> &[u8] {
        match *self {
            LicenseKind::Agpl3(ref agpl3) => agpl3.as_ref(),
            LicenseKind::Apache2(ref apache2) => apache2.as_ref(),
            LicenseKind::Cc01(ref cc01) => cc01.as_ref(),
            LicenseKind::Gpl3(ref gpl3) => gpl3.as_ref(),
            LicenseKind::Lgpl3(ref lgpl3) => lgpl3.as_ref(),
            LicenseKind::Mit(ref mit) => mit.as_ref(),
            LicenseKind::Mpl2(ref mpl2) => mpl2.as_ref(),
            LicenseKind::Unlicense(ref unlicense) => unlicense.as_ref(),
        }
    }
}

impl From<Agpl3> for LicenseKind {
    #[inline]
    fn from(agpl3: Agpl3) -> Self {
        LicenseKind::Agpl3(agpl3)
    }
}

impl From<Apache2> for LicenseKind {
    #[inline]
    fn from(apache2: Apache2) -> Self {
        LicenseKind::Apache2(apache2)
    }
}

impl From<Cc01> for LicenseKind {
    #[inline]
    fn from(cc01: Cc01) -> Self {
        LicenseKind::Cc01(cc01)
    }
}

impl From<Gpl3> for LicenseKind {
    #[inline]
    fn from(gpl3: Gpl3) -> Self {
        LicenseKind::Gpl3(gpl3)
    }
}

impl From<Lgpl3> for LicenseKind {
    #[inline]
    fn from(lgpl3: Lgpl3) -> Self {
        LicenseKind::Lgpl3(lgpl3)
    }
}

impl From<Mit> for LicenseKind {
    #[inline]
    fn from(mit: Mit) -> Self {
        LicenseKind::Mit(mit)
    }
}

impl From<Mpl2> for LicenseKind {
    #[inline]
    fn from(mpl2: Mpl2) -> Self {
        LicenseKind::Mpl2(mpl2)
    }
}

impl From<Unlicense> for LicenseKind {
    #[inline]
    fn from(unlicense: Unlicense) -> Self {
        LicenseKind::Unlicense(unlicense)
    }
}

#[cfg(test)]
mod test {
    use std::str::FromStr;
    use ::*;

    #[test]
    fn from_id() {
        let agpl3 = LicenseKind::from_str("AGPL-3.0");
        assert_eq!(agpl3, Ok(LicenseKind::Agpl3(Agpl3)));

        let apache2 = LicenseKind::from_str("Apache-2.0");
        assert_eq!(apache2, Ok(LicenseKind::Apache2(Apache2)));

        let cc01 = LicenseKind::from_str("CC0-1.0");
        assert_eq!(cc01, Ok(LicenseKind::Cc01(Cc01)));

        let gpl3 = LicenseKind::from_str("GPL-3.0");
        assert_eq!(gpl3, Ok(LicenseKind::Gpl3(Gpl3)));

        let lgpl3 = LicenseKind::from_str("LGPL-3.0");
        assert_eq!(lgpl3, Ok(LicenseKind::Lgpl3(Lgpl3)));

        let mit = LicenseKind::from_str("MIT");
        assert_eq!(mit, Ok(LicenseKind::Mit(Mit::default())));

        let mpl2 = LicenseKind::from_str("MPL-2.0");
        assert_eq!(mpl2, Ok(LicenseKind::Mpl2(Mpl2)));

        let unlicense = LicenseKind::from_str("Unlicense");
        assert_eq!(unlicense, Ok(LicenseKind::Unlicense(Unlicense)));
    }

    #[test]
    fn from_text() {
        let agpl3 = LicenseKind::from_str(include_str!("../files/AGPL-3"));
        assert_eq!(agpl3, Ok(LicenseKind::Agpl3(Agpl3)));

        let apache2 = LicenseKind::from_str(include_str!("../files/APACHE-2"));
        assert_eq!(apache2, Ok(LicenseKind::Apache2(Apache2)));

        let cc01 = LicenseKind::from_str(include_str!("../files/CC0-1"));
        assert_eq!(cc01, Ok(LicenseKind::Cc01(Cc01)));

        let gpl3 = LicenseKind::from_str(include_str!("../files/GPL-3"));
        assert_eq!(gpl3, Ok(LicenseKind::Gpl3(Gpl3)));

        let lgpl3 = LicenseKind::from_str(include_str!("../files/LGPL-3"));
        assert_eq!(lgpl3, Ok(LicenseKind::Lgpl3(Lgpl3)));

        let mit =
            LicenseKind::from_str(&format!(include_str!("../files/MIT"), 2017, "Mr. Foo Bar"));
        assert_eq!(mit, Ok(LicenseKind::Mit(Mit::new(2017, "Mr. Foo Bar"))));

        let mpl2 = LicenseKind::from_str(include_str!("../files/MPL-2"));
        assert_eq!(mpl2, Ok(LicenseKind::Mpl2(Mpl2)));

        let unlicense = LicenseKind::from_str(include_str!("../files/UNLICENSE"));
        assert_eq!(unlicense, Ok(LicenseKind::Unlicense(Unlicense)));
    }
}