oseda-cli 3.0.2

OSEDA project scaffolding
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

use serde::{Deserialize, Serialize};
use strum_macros::{EnumIter, EnumString, IntoStaticStr};

/// OSI approved license categorized as (popular / strong community)
#[derive(
    Debug, Clone, PartialEq, Eq, Hash, EnumIter, IntoStaticStr, EnumString, Serialize, Deserialize,
)]
#[serde(into = "&'static str", try_from = "String")]
pub enum License {
    // strum serialize is compatible with serde trait here
    // this will basically allow a complex internal license representation
    // but with ease of de/serialization with just the spdx id
    #[strum(serialize = "Apache-2.0", ascii_case_insensitive)]
    Apache2_0,
    #[strum(serialize = "MIT", ascii_case_insensitive)]
    Mit,
    #[strum(serialize = "CDDL-1.0", ascii_case_insensitive)]
    Cddl1_0,
    #[strum(serialize = "EPL-2.0", ascii_case_insensitive)]
    Epl2_0,
    #[strum(serialize = "GPL-2.0", ascii_case_insensitive)]
    Gpl2_0,
    #[strum(serialize = "GPL-3.0", ascii_case_insensitive)]
    Gpl3_0,
    #[strum(serialize = "LGPL-2.1", ascii_case_insensitive)]
    Lgpl2_1,
    #[strum(serialize = "LGPL-3.0", ascii_case_insensitive)]
    Lgpl3_0,
    #[strum(serialize = "LGPL-2.0", ascii_case_insensitive)]
    Lgpl2_0,
    #[strum(serialize = "MPL-2.0", ascii_case_insensitive)]
    Mpl2_0,
    #[strum(serialize = "BSD-2-Clause", ascii_case_insensitive)]
    Bsd2Clause,
    #[strum(serialize = "BSD-3-Clause", ascii_case_insensitive)]
    Bsd3Clause,
}

impl License {
    /// Get the full name of license. I'm not sure if this really ever be useful, but i figured its best to include it
    pub const fn name(&self) -> &str {
        match self {
            Self::Apache2_0 => "Apache License, Version 2.0",
            Self::Mit => "The MIT License",
            Self::Cddl1_0 => "Common Development and Distribution License 1.0",
            Self::Epl2_0 => "Eclipse Public License version 2.0",
            Self::Gpl2_0 => "GNU General Public License version 2",
            Self::Gpl3_0 => "GNU General Public License version 3",
            Self::Lgpl2_1 => "GNU Lesser General Public License version 2.1",
            Self::Lgpl3_0 => "GNU Lesser General Public License version 3",
            Self::Lgpl2_0 => "GNU Library General Public License version 2",
            Self::Mpl2_0 => "Mozilla Public License 2.0",
            Self::Bsd2Clause => "The 2-Clause BSD License",
            Self::Bsd3Clause => "The 3-Clause BSD License",
        }
    }

    /// Get the SPDX id associated with a license.
    /// Internally, `oseda check` will recognize one of these strings
    pub const fn spdx_id(&self) -> &'static str {
        match self {
            Self::Apache2_0 => "Apache-2.0",
            Self::Mit => "MIT",
            Self::Cddl1_0 => "CDDL-1.0",
            Self::Epl2_0 => "EPL-2.0",
            Self::Gpl2_0 => "GPL-2.0",
            Self::Gpl3_0 => "GPL-3.0",
            Self::Lgpl2_1 => "LGPL-2.1",
            Self::Lgpl3_0 => "LGPL-3.0",
            Self::Lgpl2_0 => "LGPL-2.0",
            Self::Mpl2_0 => "MPL-2.0",
            Self::Bsd2Clause => "BSD-2-Clause",
            Self::Bsd3Clause => "BSD-3-Clause",
        }
    }
}

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

// useful for oseda check attempting to parse a license spdx id
impl TryFrom<String> for License {
    type Error = String;

    fn try_from(s: String) -> Result<Self, Self::Error> {
        s.parse::<Self>()
            .map_err(|_| format!("'{}' is not a supported SPDX license identifier", s))
    }
}