use tatara_lisp::{Atom, Sexp};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum CaixaDialeto {
Pacote,
Molde,
MoldePosicional,
Desconhecido,
}
impl CaixaDialeto {
pub const ALL: &'static [Self] = &[
Self::Pacote,
Self::Molde,
Self::MoldePosicional,
Self::Desconhecido,
];
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Pacote => "Pacote",
Self::Molde => "Molde",
Self::MoldePosicional => "MoldePosicional",
Self::Desconhecido => "Desconhecido",
}
}
#[must_use]
pub const fn palavra_canonica(self) -> &'static str {
match self {
Self::Pacote => "defcaixa",
Self::Molde | Self::MoldePosicional => "defmolde",
Self::Desconhecido => "?",
}
}
#[must_use]
pub const fn consumidor(self) -> &'static str {
match self {
Self::Pacote => "caixa-core / feira",
Self::Molde | Self::MoldePosicional => "pleme-doc-gen",
Self::Desconhecido => "nobody known",
}
}
#[must_use]
pub const fn descricao(self) -> &'static str {
match self {
Self::Pacote => "tatara-lisp package manifest (:nome :versao :kind :deps …)",
Self::Molde => "repo-surface declaration (:name :ecosystem :package {…} …)",
Self::MoldePosicional => {
"repo-surface declaration, positional name (defcaixa <nome> :kind …)"
}
Self::Desconhecido => "unrecognised — matches no known defcaixa schema",
}
}
#[must_use]
pub const fn is_molde_family(self) -> bool {
matches!(self, Self::Molde | Self::MoldePosicional)
}
}
impl std::fmt::Display for CaixaDialeto {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum DialetoError {
#[error("source has no top-level form")]
Vazio,
#[error("top-level form is not a list — a manifest is `(defcaixa …)`")]
NaoEhLista,
#[error(
"top-level form is headed by `{encontrado}`, not `defcaixa` or `defmolde` \
(a manifest's first form must be the declaration itself)"
)]
CabecaErrada { encontrado: String },
#[error("manifest does not parse as tatara-lisp: {0}")]
Leitura(String),
}
pub fn classify(src: &str) -> Result<CaixaDialeto, DialetoError> {
let forms = tatara_lisp::read(src).map_err(|e| DialetoError::Leitura(e.to_string()))?;
let first = forms.first().ok_or(DialetoError::Vazio)?;
classify_form(first)
}
pub fn classify_form(form: &Sexp) -> Result<CaixaDialeto, DialetoError> {
let list = form.as_list().ok_or(DialetoError::NaoEhLista)?;
let head = list
.first()
.and_then(Sexp::as_symbol)
.ok_or(DialetoError::NaoEhLista)?;
match head {
"defmolde" => {
return Ok(if starts_with_positional_name(&list[1..]) {
CaixaDialeto::MoldePosicional
} else {
CaixaDialeto::Molde
});
}
"defcaixa" => {}
other => {
return Err(DialetoError::CabecaErrada {
encontrado: other.to_string(),
});
}
}
let args = &list[1..];
if starts_with_positional_name(args) {
return Ok(CaixaDialeto::MoldePosicional);
}
let keys = top_level_keywords(args);
let has = |k: &str| keys.iter().any(|s| s == k);
if has("nome") {
return Ok(CaixaDialeto::Pacote);
}
if has("name") || has("ecosystem") || has("package") {
return Ok(CaixaDialeto::Molde);
}
Ok(CaixaDialeto::Desconhecido)
}
fn starts_with_positional_name(args: &[Sexp]) -> bool {
matches!(args.first(), Some(Sexp::Atom(Atom::Symbol(_))))
}
fn top_level_keywords(args: &[Sexp]) -> Vec<String> {
let mut out = Vec::new();
let mut i = 0;
while i < args.len() {
if let Sexp::Atom(Atom::Keyword(k)) = &args[i] {
out.push(k.clone());
i += 2;
} else {
i += 1;
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
const PACOTE: &str = r#"
(defcaixa
:nome "checkout"
:versao "0.1.0"
:kind Servico
:deps ((:nome "caixa-teia" :versao "^0.1")))
"#;
const MOLDE: &str = r#"
(defcaixa
:name "base64"
:kind :Biblioteca
:ecosystem :rust-single-crate
:package {:name "base64" :version "0.22.1"}
:workflows [:auto-release])
"#;
const MOLDE_POSICIONAL: &str = r#"
(defcaixa todoku-go
:kind :Biblioteca
:ecosystem :go
:package {:name "todoku-go" :version "0.3.0"})
"#;
#[test]
fn the_package_dialect_is_recognised() {
assert_eq!(classify(PACOTE), Ok(CaixaDialeto::Pacote));
}
#[test]
fn the_repo_surface_dialect_is_recognised() {
assert_eq!(classify(MOLDE), Ok(CaixaDialeto::Molde));
}
#[test]
fn the_positional_arity_is_recognised() {
assert_eq!(
classify(MOLDE_POSICIONAL),
Ok(CaixaDialeto::MoldePosicional)
);
}
#[test]
fn defmolde_classifies_without_inference() {
let src = r#"(defmolde :name "x" :kind :Biblioteca :ecosystem :go)"#;
assert_eq!(classify(src), Ok(CaixaDialeto::Molde));
let pos = r"(defmolde todoku-go :kind :Biblioteca :ecosystem :go)";
assert_eq!(classify(pos), Ok(CaixaDialeto::MoldePosicional));
}
#[test]
fn a_nested_nome_does_not_make_a_repo_surface_look_like_a_package() {
let src = r#"
(defcaixa
:name "x"
:ecosystem :rust-single-crate
:deps ((:nome "inner" :versao "^0.1")))
"#;
assert_eq!(classify(src), Ok(CaixaDialeto::Molde));
}
#[test]
fn a_keyword_in_value_position_is_not_a_slot() {
let src = r#"(defcaixa :kind :Biblioteca :name "x")"#;
assert_eq!(classify(src), Ok(CaixaDialeto::Molde));
}
#[test]
fn an_unrecognised_defcaixa_is_reported_not_guessed() {
let src = r#"(defcaixa :licenca "MIT")"#;
assert_eq!(classify(src), Ok(CaixaDialeto::Desconhecido));
}
#[test]
fn a_form_that_is_not_a_manifest_is_an_error_not_a_dialect() {
assert_eq!(
classify("(defflake :nome \"x\")"),
Err(DialetoError::CabecaErrada {
encontrado: "defflake".into()
})
);
assert_eq!(classify(""), Err(DialetoError::Vazio));
}
#[test]
fn every_dialect_names_its_consumer_and_its_canonical_keyword() {
for &d in CaixaDialeto::ALL {
assert!(!d.descricao().is_empty(), "{d}");
assert!(!d.consumidor().is_empty(), "{d}");
}
assert_eq!(CaixaDialeto::Pacote.palavra_canonica(), "defcaixa");
assert_eq!(CaixaDialeto::Molde.palavra_canonica(), "defmolde");
assert_ne!(
CaixaDialeto::Pacote.palavra_canonica(),
CaixaDialeto::Molde.palavra_canonica(),
"the two dialects must not share a canonical keyword — that IS the defect"
);
}
#[test]
fn caixa_dialeto_all_enumerates_every_variant_exactly_once() {
assert_eq!(
CaixaDialeto::ALL.len(),
4,
"ALL must list every arm exactly once; a fifth arm added \
without extending ALL fails this pin — extend ALL alongside \
the new variant"
);
let mut seen: Vec<CaixaDialeto> = Vec::new();
for &d in CaixaDialeto::ALL {
assert!(
!seen.contains(&d),
"ALL contains a duplicate arm: {d}. Every variant appears \
exactly once — a duplicate would double-count in every \
iteration consumer"
);
seen.push(d);
}
for variant in [
CaixaDialeto::Pacote,
CaixaDialeto::Molde,
CaixaDialeto::MoldePosicional,
CaixaDialeto::Desconhecido,
] {
let coverage_probe = match variant {
CaixaDialeto::Pacote
| CaixaDialeto::Molde
| CaixaDialeto::MoldePosicional
| CaixaDialeto::Desconhecido => variant,
};
assert!(
CaixaDialeto::ALL.contains(&coverage_probe),
"ALL is missing variant {coverage_probe} — extend the slice"
);
}
}
#[test]
fn caixa_dialeto_all_is_const_and_matches_iteration_count() {
const ALL: &[CaixaDialeto] = CaixaDialeto::ALL;
assert_eq!(ALL.len(), CaixaDialeto::ALL.len());
#[allow(clippy::iter_count)]
let iterated = ALL.iter().count();
assert_eq!(iterated, CaixaDialeto::ALL.len());
}
#[test]
fn caixa_dialeto_all_covers_every_variant_by_display_probe() {
for &d in CaixaDialeto::ALL {
let display_form = d.to_string();
assert!(
!display_form.is_empty(),
"Display must render a non-empty byte-string for every \
arm; empty: {d:?}"
);
assert!(!d.palavra_canonica().is_empty(), "{d}");
assert!(!d.consumidor().is_empty(), "{d}");
assert!(!d.descricao().is_empty(), "{d}");
}
}
#[test]
fn caixa_dialeto_as_str_returns_pascal_case_variant_name() {
for (variant, expected) in [
(CaixaDialeto::Pacote, "Pacote"),
(CaixaDialeto::Molde, "Molde"),
(CaixaDialeto::MoldePosicional, "MoldePosicional"),
(CaixaDialeto::Desconhecido, "Desconhecido"),
] {
assert_eq!(
variant.as_str(),
expected,
"CaixaDialeto::{variant:?}.as_str() must return the \
canonical `PascalCase` variant-name byte-string; drift here \
splits the census-facing text from the substrate \
primitive every downstream consumer will read"
);
}
}
#[test]
fn caixa_dialeto_display_routes_through_as_str_helper() {
for &variant in CaixaDialeto::ALL {
assert_eq!(
variant.to_string(),
variant.as_str(),
"CaixaDialeto::{variant:?} Display must route through \
CaixaDialeto::as_str (single source of truth: the \
lifted per-arm `PascalCase` variant-name byte-string)"
);
}
}
#[test]
fn caixa_dialeto_is_molde_family_returns_true_on_molde_and_positional_arms() {
assert!(
CaixaDialeto::Molde.is_molde_family(),
"CaixaDialeto::Molde.is_molde_family() must return true — \
Molde is the primary `defmolde` arm"
);
assert!(
CaixaDialeto::MoldePosicional.is_molde_family(),
"CaixaDialeto::MoldePosicional.is_molde_family() must return \
true — MoldePosicional is the positional-arity form of the \
same `defmolde` declaration Molde carries"
);
}
#[test]
fn caixa_dialeto_is_molde_family_returns_false_on_pacote_and_desconhecido_arms() {
assert!(
!CaixaDialeto::Pacote.is_molde_family(),
"CaixaDialeto::Pacote.is_molde_family() must return false — \
Pacote is the `defcaixa` tatara-lisp package manifest, not \
the `defmolde` repo-surface declaration"
);
assert!(
!CaixaDialeto::Desconhecido.is_molde_family(),
"CaixaDialeto::Desconhecido.is_molde_family() must return \
false — the residue arm names no known declaration; it is \
not silently promoted into the `defmolde` family"
);
}
#[test]
fn caixa_dialeto_is_molde_family_agrees_with_palavra_canonica_defmolde_projection() {
for &d in CaixaDialeto::ALL {
let via_palavra_canonica = d.palavra_canonica() == "defmolde";
let via_is_molde_family = d.is_molde_family();
assert_eq!(
via_is_molde_family, via_palavra_canonica,
"CaixaDialeto::{d:?}.is_molde_family() ({via_is_molde_family}) \
must agree with CaixaDialeto::{d:?}.palavra_canonica() == \
\"defmolde\" ({via_palavra_canonica}) — a split between the \
typed predicate and the sibling keyword projection would let \
a future arm addition land at one path and drift at the other, \
which is exactly the drift this pin refuses"
);
}
}
#[test]
fn caixa_dialeto_is_molde_family_is_const_fn() {
const ARMS: [(CaixaDialeto, bool); 4] = [
(CaixaDialeto::Pacote, CaixaDialeto::Pacote.is_molde_family()),
(CaixaDialeto::Molde, CaixaDialeto::Molde.is_molde_family()),
(
CaixaDialeto::MoldePosicional,
CaixaDialeto::MoldePosicional.is_molde_family(),
),
(
CaixaDialeto::Desconhecido,
CaixaDialeto::Desconhecido.is_molde_family(),
),
];
assert_eq!(
ARMS,
[
(CaixaDialeto::Pacote, false),
(CaixaDialeto::Molde, true),
(CaixaDialeto::MoldePosicional, true),
(CaixaDialeto::Desconhecido, false),
],
"CaixaDialeto::is_molde_family() must evaluate in const context \
for every arm and land on the {{false, true, true, false}} \
partition — a future accidental downgrade to non-`const` \
would trip the const-context array-initializer here"
);
}
#[test]
fn caixa_dialeto_as_str_is_const_fn() {
const PACOTE: &str = CaixaDialeto::Pacote.as_str();
const MOLDE: &str = CaixaDialeto::Molde.as_str();
const MOLDE_POSICIONAL: &str = CaixaDialeto::MoldePosicional.as_str();
const DESCONHECIDO: &str = CaixaDialeto::Desconhecido.as_str();
assert_eq!(PACOTE, "Pacote");
assert_eq!(MOLDE, "Molde");
assert_eq!(MOLDE_POSICIONAL, "MoldePosicional");
assert_eq!(DESCONHECIDO, "Desconhecido");
}
}