use indexmap::IndexMap;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
#[derive(
Debug, Clone, Serialize, Deserialize, PartialEq, JsonSchema, arbitrary::Arbitrary,
)]
#[schemars(rename = "agent.Plugin")]
pub struct Plugin {
pub owner: String,
pub name: String,
pub version: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
#[arbitrary(with = crate::arbitrary_util::arbitrary_option_indexmap_string_json_value)]
pub arguments: Option<IndexMap<String, serde_json::Value>>,
}
impl Plugin {
fn sort_key(&self) -> String {
let arguments = self
.arguments
.as_ref()
.and_then(|arguments| serde_json::to_string(arguments).ok())
.unwrap_or_default();
format!(
"{}\0{}\0{}\0{arguments}",
self.owner, self.name, self.version,
)
}
pub fn validate(&self) -> Result<(), String> {
if self.owner.is_empty() {
return Err("`owner` cannot be empty".into());
}
if self.name.is_empty() {
return Err("`name` cannot be empty".into());
}
if self.version.is_empty() {
return Err("`version` cannot be empty".into());
}
if !self.version.starts_with('v') {
return Err(format!(
"`version` {:?} must start with 'v' — it is the plugin repo's git tag, Go-modules style (v1.2.3)",
self.version,
));
}
if let Some(args) = self.arguments.as_ref() {
for (k, _) in args {
if k.is_empty() {
return Err("`arguments` key cannot be empty".into());
}
}
}
Ok(())
}
}
pub fn validate(plugins: &[Plugin]) -> Result<(), String> {
for plugin in plugins {
plugin.validate()?;
}
for (i, a) in plugins.iter().enumerate() {
for b in &plugins[i + 1..] {
if a.owner == b.owner && a.name == b.name && a.version == b.version
{
return Err(format!(
"`plugins` contains duplicate entry: \"{}/{}@{}\"",
a.owner, a.name, a.version,
));
}
}
}
Ok(())
}
fn sort_object_keys(value: &mut serde_json::Value) {
match value {
serde_json::Value::Object(map) => {
for (_, nested) in map.iter_mut() {
sort_object_keys(nested);
}
map.sort_keys();
}
serde_json::Value::Array(items) => {
for item in items {
sort_object_keys(item);
}
}
_ => {}
}
}
pub fn prepare(mut plugins: Vec<Plugin>) -> Vec<Plugin> {
for plugin in &mut plugins {
plugin.owner = plugin.owner.to_lowercase();
plugin.name = plugin.name.to_lowercase();
let drop_empty = match plugin.arguments.as_mut() {
Some(args) => {
for (_, v) in args.iter_mut() {
if v.as_str() == Some("") {
*v = serde_json::Value::Null;
}
sort_object_keys(v);
}
args.sort_keys();
args.is_empty()
}
None => false,
};
if drop_empty {
plugin.arguments = None;
}
}
plugins.sort_by_cached_key(Plugin::sort_key);
plugins
}
#[cfg(test)]
mod tests {
use super::*;
fn json_value(v: Option<&str>) -> serde_json::Value {
match v {
Some(s) => serde_json::Value::String(s.to_string()),
None => serde_json::Value::Null,
}
}
fn plugin(
owner: &str,
name: &str,
version: &str,
args: &[(&str, Option<&str>)],
) -> Plugin {
let arguments = if args.is_empty() {
None
} else {
let mut m = IndexMap::new();
for (k, v) in args {
m.insert(k.to_string(), json_value(*v));
}
Some(m)
};
Plugin {
owner: owner.into(),
name: name.into(),
version: version.into(),
arguments,
}
}
#[test]
fn prepare_canonicalizes_arguments_and_sorts() {
let a = prepare(vec![
plugin("b", "x", "1", &[]),
plugin("a", "x", "1", &[("z", Some("1")), ("a", Some(""))]),
]);
assert_eq!(a[0].owner, "a");
let args = a[0].arguments.as_ref().unwrap();
assert_eq!(
args.iter().map(|(k, _)| k.as_str()).collect::<Vec<_>>(),
vec!["a", "z"],
);
assert_eq!(args.get("a").unwrap(), &serde_json::Value::Null);
}
#[test]
fn arguments_carry_arbitrary_json() {
let mut arguments = IndexMap::new();
arguments.insert("retries".to_string(), serde_json::json!(3));
arguments.insert("verbose".to_string(), serde_json::json!(true));
arguments.insert("hosts".to_string(), serde_json::json!(["a", "b"]));
arguments.insert("nested".to_string(), serde_json::json!({"k": "v"}));
let prepared = prepare(vec![Plugin {
owner: "o".into(),
name: "n".into(),
version: "v1".into(),
arguments: Some(arguments),
}]);
let args = prepared[0].arguments.as_ref().unwrap();
assert_eq!(args.get("retries").unwrap(), &serde_json::json!(3));
assert_eq!(args.get("hosts").unwrap(), &serde_json::json!(["a", "b"]));
assert_eq!(args.get("nested").unwrap(), &serde_json::json!({"k": "v"}));
assert_eq!(
args.iter().map(|(k, _)| k.as_str()).collect::<Vec<_>>(),
vec!["hosts", "nested", "retries", "verbose"],
);
}
#[test]
fn prepare_sorts_object_keys_at_every_depth() {
let mut arguments = IndexMap::new();
arguments.insert(
"opts".to_string(),
serde_json::json!({"z": 1, "a": {"y": 2, "b": 3}}),
);
arguments.insert(
"list".to_string(),
serde_json::json!([{"q": 1, "p": 2}]),
);
let prepared = prepare(vec![Plugin {
owner: "o".into(),
name: "n".into(),
version: "v1".into(),
arguments: Some(arguments),
}]);
let args = prepared[0].arguments.as_ref().unwrap();
assert_eq!(
serde_json::to_string(args).unwrap(),
r#"{"list":[{"p":2,"q":1}],"opts":{"a":{"b":3,"y":2},"z":1}}"#,
);
}
#[test]
fn deeply_nested_orderings_canonicalize_identically() {
let build = |value: serde_json::Value| {
let mut arguments = IndexMap::new();
arguments.insert("k".to_string(), value);
prepare(vec![Plugin {
owner: "o".into(),
name: "n".into(),
version: "v1".into(),
arguments: Some(arguments),
}])
};
let a = build(serde_json::json!({"outer": [{"b": 1, "a": {"d": 2, "c": 3}}]}));
let b = build(serde_json::json!({"outer": [{"a": {"c": 3, "d": 2}, "b": 1}]}));
assert_eq!(
serde_json::to_string(&a).unwrap(),
serde_json::to_string(&b).unwrap(),
);
}
#[test]
fn prepare_preserves_array_element_order() {
let mut arguments = IndexMap::new();
arguments.insert("hosts".to_string(), serde_json::json!(["c", "a", "b"]));
let prepared = prepare(vec![Plugin {
owner: "o".into(),
name: "n".into(),
version: "v1".into(),
arguments: Some(arguments),
}]);
assert_eq!(
prepared[0].arguments.as_ref().unwrap().get("hosts").unwrap(),
&serde_json::json!(["c", "a", "b"]),
);
}
#[test]
fn prepare_orders_same_coordinates_by_arguments() {
let a = prepare(vec![
plugin("o", "n", "v1", &[("k", Some("b"))]),
plugin("o", "n", "v1", &[("k", Some("a"))]),
]);
let values: Vec<_> = a
.iter()
.map(|p| p.arguments.as_ref().unwrap().get("k").unwrap().clone())
.collect();
assert_eq!(values, vec![serde_json::json!("a"), serde_json::json!("b")]);
}
#[test]
fn prepare_collapses_empty_arguments_to_none() {
let a = prepare(vec![Plugin {
owner: "o".into(),
name: "n".into(),
version: "1".into(),
arguments: Some(IndexMap::new()),
}]);
assert!(a[0].arguments.is_none());
}
#[test]
fn equivalent_declarations_canonicalize_identically() {
let a = prepare(vec![plugin(
"o",
"n",
"1",
&[("b", Some("1")), ("a", Some("2"))],
)]);
let b = prepare(vec![plugin(
"o",
"n",
"1",
&[("a", Some("2")), ("b", Some("1"))],
)]);
assert_eq!(
serde_json::to_string(&a).unwrap(),
serde_json::to_string(&b).unwrap(),
);
}
#[test]
fn prepare_lowercases_owner_and_name_but_not_version() {
let a = prepare(vec![plugin("Acme", "Widgets", "v1.2.3-RC1", &[])]);
let b = prepare(vec![plugin("acme", "widgets", "v1.2.3-RC1", &[])]);
assert_eq!(a[0].owner, "acme");
assert_eq!(a[0].name, "widgets");
assert_eq!(a[0].version, "v1.2.3-RC1");
assert_eq!(
serde_json::to_string(&a).unwrap(),
serde_json::to_string(&b).unwrap(),
);
}
#[test]
fn validate_rejects_duplicate_coordinates() {
let err = validate(&[
plugin("o", "n", "v1", &[]),
plugin("o", "n", "v1", &[("k", Some("v"))]),
])
.expect_err("duplicate coordinates must be rejected");
assert!(err.contains("duplicate"), "unexpected error: {err}");
}
#[test]
fn validate_rejects_empty_fields() {
assert!(validate(&[plugin("", "n", "v1", &[])]).is_err());
assert!(validate(&[plugin("o", "", "v1", &[])]).is_err());
assert!(validate(&[plugin("o", "n", "", &[])]).is_err());
assert!(validate(&[plugin("o", "n", "v1", &[("", Some("v"))])]).is_err());
}
#[test]
fn validate_requires_v_prefixed_version() {
assert!(validate(&[plugin("o", "n", "1.2.3", &[])]).is_err());
assert!(validate(&[plugin("o", "n", "V1.2.3", &[])]).is_err());
assert!(validate(&[plugin("o", "n", "v1.2.3", &[])]).is_ok());
assert!(validate(&[plugin("o", "n", "v1.2.3-RC1", &[])]).is_ok());
}
}