use std::str::FromStr;
use crate::error::Error;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CopyrightPrefix {
#[default]
Spdx,
SpdxC,
SpdxSymbol,
SpdxString,
SpdxStringC,
SpdxStringSymbol,
Snippet,
SnippetC,
SnippetSymbol,
SnippetString,
SnippetStringC,
SnippetStringSymbol,
String,
StringC,
StringSymbol,
Symbol,
}
impl CopyrightPrefix {
pub const VALUES: [&'static str; 16] = [
"spdx",
"spdx-c",
"spdx-symbol",
"spdx-string",
"spdx-string-c",
"spdx-string-symbol",
"snippet",
"snippet-c",
"snippet-symbol",
"snippet-string",
"snippet-string-c",
"snippet-string-symbol",
"string",
"string-c",
"string-symbol",
"symbol",
];
#[must_use]
pub const fn tag(self) -> &'static str {
match self {
Self::Spdx => "SPDX-FileCopyrightText: ",
Self::SpdxC => "SPDX-FileCopyrightText: (C) ",
Self::SpdxSymbol => "SPDX-FileCopyrightText: \u{a9} ",
Self::SpdxString => "SPDX-FileCopyrightText: Copyright ",
Self::SpdxStringC => "SPDX-FileCopyrightText: Copyright (C) ",
Self::SpdxStringSymbol => "SPDX-FileCopyrightText: Copyright \u{a9} ",
Self::Snippet => "SPDX-SnippetCopyrightText: ",
Self::SnippetC => "SPDX-SnippetCopyrightText: (C) ",
Self::SnippetSymbol => "SPDX-SnippetCopyrightText: \u{a9} ",
Self::SnippetString => "SPDX-SnippetCopyrightText: Copyright ",
Self::SnippetStringC => "SPDX-SnippetCopyrightText: Copyright (C) ",
Self::SnippetStringSymbol => "SPDX-SnippetCopyrightText: Copyright \u{a9} ",
Self::String => "Copyright ",
Self::StringC => "Copyright (C) ",
Self::StringSymbol => "Copyright \u{a9} ",
Self::Symbol => "\u{a9} ",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CopyrightNotice<'a> {
text: &'a str,
prefix: CopyrightPrefix,
}
impl<'a> CopyrightNotice<'a> {
#[must_use]
pub const fn new(text: &'a str) -> Self {
Self {
text,
prefix: CopyrightPrefix::Spdx,
}
}
#[must_use]
pub const fn with_prefix(self, prefix: CopyrightPrefix) -> Self {
Self { prefix, ..self }
}
#[must_use]
pub const fn with_text(self, text: &'a str) -> Self {
Self { text, ..self }
}
#[must_use]
pub const fn text(self) -> &'a str {
self.text
}
#[must_use]
pub const fn prefix(self) -> CopyrightPrefix {
self.prefix
}
}
impl<'a> From<&'a str> for CopyrightNotice<'a> {
fn from(text: &'a str) -> Self {
Self::new(text)
}
}
impl FromStr for CopyrightPrefix {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"spdx" => Ok(Self::Spdx),
"spdx-c" => Ok(Self::SpdxC),
"spdx-symbol" => Ok(Self::SpdxSymbol),
"spdx-string" => Ok(Self::SpdxString),
"spdx-string-c" => Ok(Self::SpdxStringC),
"spdx-string-symbol" => Ok(Self::SpdxStringSymbol),
"snippet" => Ok(Self::Snippet),
"snippet-c" => Ok(Self::SnippetC),
"snippet-symbol" => Ok(Self::SnippetSymbol),
"snippet-string" => Ok(Self::SnippetString),
"snippet-string-c" => Ok(Self::SnippetStringC),
"snippet-string-symbol" => Ok(Self::SnippetStringSymbol),
"string" => Ok(Self::String),
"string-c" => Ok(Self::StringC),
"string-symbol" => Ok(Self::StringSymbol),
"symbol" => Ok(Self::Symbol),
other => Err(Error::InvalidCopyrightPrefix(other.to_string())),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const ORACLE: [(&str, &str); 16] = [
("spdx", "SPDX-FileCopyrightText: 2026 Jane Doe"),
("spdx-c", "SPDX-FileCopyrightText: (C) 2026 Jane Doe"),
(
"spdx-symbol",
"SPDX-FileCopyrightText: \u{a9} 2026 Jane Doe",
),
(
"spdx-string",
"SPDX-FileCopyrightText: Copyright 2026 Jane Doe",
),
(
"spdx-string-c",
"SPDX-FileCopyrightText: Copyright (C) 2026 Jane Doe",
),
(
"spdx-string-symbol",
"SPDX-FileCopyrightText: Copyright \u{a9} 2026 Jane Doe",
),
("snippet", "SPDX-SnippetCopyrightText: 2026 Jane Doe"),
("snippet-c", "SPDX-SnippetCopyrightText: (C) 2026 Jane Doe"),
(
"snippet-symbol",
"SPDX-SnippetCopyrightText: \u{a9} 2026 Jane Doe",
),
(
"snippet-string",
"SPDX-SnippetCopyrightText: Copyright 2026 Jane Doe",
),
(
"snippet-string-c",
"SPDX-SnippetCopyrightText: Copyright (C) 2026 Jane Doe",
),
(
"snippet-string-symbol",
"SPDX-SnippetCopyrightText: Copyright \u{a9} 2026 Jane Doe",
),
("string", "Copyright 2026 Jane Doe"),
("string-c", "Copyright (C) 2026 Jane Doe"),
("string-symbol", "Copyright \u{a9} 2026 Jane Doe"),
("symbol", "\u{a9} 2026 Jane Doe"),
];
#[test]
fn every_value_renders_what_the_reference_tool_renders() {
for (value, expected) in ORACLE {
let prefix: CopyrightPrefix = value.parse().unwrap();
assert_eq!(
format!("{}{}", prefix.tag(), "2026 Jane Doe"),
expected,
"`--copyright-prefix {value}` must match reuse byte for byte"
);
}
}
#[test]
fn the_accepted_values_are_exactly_those_the_parser_takes() {
assert_eq!(
CopyrightPrefix::VALUES.len(),
ORACLE.len(),
"VALUES drives the CLI's accepted set; it must list every form"
);
for value in CopyrightPrefix::VALUES {
assert!(
value.parse::<CopyrightPrefix>().is_ok(),
"`{value}` is offered by the CLI but the parser rejects it"
);
}
}
#[test]
fn an_unknown_value_is_rejected_rather_than_ignored() {
let err = "spdx-c-symbol".parse::<CopyrightPrefix>().unwrap_err();
assert!(
err.to_string().contains("spdx-c-symbol"),
"the message must name the offending value, got: {err}"
);
}
#[test]
fn the_default_is_the_plain_file_tag() {
assert_eq!(CopyrightPrefix::default(), CopyrightPrefix::Spdx);
}
}