use crate::date::now_iso;
use serde::{Deserialize, Serialize};
use serde_json::Value;
pub const CONTRACT_VERSION: u32 = 1;
pub const PRECEDENCE: &[&str] = &["arg", "env", "default"];
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[cfg_attr(feature = "contract", derive(schemars::JsonSchema))]
pub struct EnvBinding {
pub name: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub aliases: Vec<String>,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[cfg_attr(feature = "contract", derive(schemars::JsonSchema))]
pub struct ArgBinding {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub long: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub short: Option<String>,
pub arity: u8,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub value_name: Option<String>,
#[serde(default)]
pub negatable: bool,
#[serde(default)]
pub repeatable: bool,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[cfg_attr(feature = "contract", derive(schemars::JsonSchema))]
pub struct Record {
pub key: String,
#[serde(rename = "type")]
pub ty: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub default: Option<Value>,
#[serde(default)]
pub allowed: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub separators: Vec<String>,
#[serde(default)]
pub required: bool,
#[serde(default = "unknown_stability")]
pub stability: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub since: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub deprecation: Option<Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub group: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub maps_to: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub example: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub observe: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reviewed: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub summary: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub modified: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub env: Option<EnvBinding>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub arg: Option<ArgBinding>,
}
fn unknown_stability() -> String {
"unknown".to_string()
}
impl Record {
pub fn env_names(&self) -> Vec<&str> {
match &self.env {
None => Vec::new(),
Some(e) => std::iter::once(e.name.as_str())
.chain(e.aliases.iter().map(String::as_str))
.collect(),
}
}
pub fn arg_labels(&self) -> Vec<String> {
let mut v = Vec::new();
if let Some(a) = &self.arg {
if let Some(s) = &a.short {
v.push(format!("-{s}"));
}
if let Some(l) = &a.long {
v.push(format!("--{l}"));
if a.negatable {
v.push(format!("--no-{l}"));
}
}
}
v
}
pub fn usage(&self) -> String {
let Some(a) = &self.arg else {
return String::new();
};
let mut parts = Vec::new();
if let Some(s) = &a.short {
parts.push(format!("-{s}"));
}
if let Some(l) = &a.long {
parts.push(format!("--{l}"));
}
let mut out = parts.join(", ");
if a.arity > 0 {
let placeholder = a.value_name.clone().unwrap_or_else(|| "VALUE".to_string());
out.push_str(&format!(" <{placeholder}>"));
}
out
}
pub fn accepts(&self, raw: &str) -> Result<(), String> {
let v = raw.trim();
match self.ty.as_str() {
"bool" => match v {
"1" | "0" | "true" | "false" | "True" | "False" | "on" | "off" | "yes" | "no"
| "" => Ok(()),
_ => Err("expected a boolean".into()),
},
"uint" => v
.parse::<u64>()
.map(|_| ())
.map_err(|_| "expected a non-negative integer".to_string()),
"int" => v
.parse::<i64>()
.map(|_| ())
.map_err(|_| "expected an integer".to_string()),
"float" => v
.parse::<f64>()
.map(|_| ())
.map_err(|_| "expected a number".to_string()),
"enum" => {
if self.allowed.iter().any(|a| a == v) {
Ok(())
} else {
Err(format!("accepted: {}", self.allowed.join(", ")))
}
}
"list" | "path" | "string" => Ok(()),
other => Err(format!("unknown declared type `{other}`")),
}
}
pub fn tokens<'a>(&self, raw: &'a str) -> Vec<&'a str> {
if self.ty != "list" || self.separators.is_empty() {
return Vec::new();
}
let seps: Vec<char> = self
.separators
.iter()
.filter_map(|s| s.chars().next())
.collect();
raw.split(|c| seps.contains(&c))
.map(str::trim)
.filter(|t| !t.is_empty())
.collect()
}
}
pub fn document(source: &str, records: &[Record]) -> Value {
serde_json::json!({
"contract_version": CONTRACT_VERSION,
"source": source,
"generated": now_iso(),
"precedence": PRECEDENCE,
"inputs": records,
})
}
pub fn check_unique(records: &[Record]) -> Vec<String> {
use std::collections::BTreeMap;
let mut problems = Vec::new();
let mut claim = |space: &str, what: String, by: &str, seen: &mut BTreeMap<String, String>| {
if let Some(first) = seen.get(&what) {
problems.push(format!(
"{space} `{what}` is claimed by both `{first}` and `{by}`"
));
} else {
seen.insert(what, by.to_string());
}
};
let mut keys = BTreeMap::new();
let mut envs = BTreeMap::new();
let mut args = BTreeMap::new();
for r in records {
claim("key", r.key.clone(), &r.key, &mut keys);
for n in r.env_names() {
claim("env name", n.to_string(), &r.key, &mut envs);
}
for l in r.arg_labels() {
claim("flag", l, &r.key, &mut args);
}
}
problems
}