use std::borrow::Cow;
use std::collections::BTreeMap;
use astrs_data::TypeUrn;
use astrs_manifest::{TypeRule, Urn};
use serde::{Deserialize, Serialize};
use crate::diagnostic::{Diagnostic, DiagnosticKind, Severity};
use crate::edge::{Edge, EdgeKey, EdgeSource};
use crate::ids::NodeId;
use crate::node::GraphNode;
#[must_use]
fn canonical_form(urn: &Urn) -> Cow<'_, str> {
match TypeUrn::parse(urn.as_str()) {
Ok(parsed) if parsed.as_str() == urn.as_str() => Cow::Borrowed(urn.as_str()),
Ok(parsed) => Cow::Owned(parsed.as_str().to_owned()),
Err(_) => Cow::Borrowed(urn.as_str()),
}
}
#[must_use]
fn urns_equivalent(a: &Urn, b: &Urn) -> bool {
canonical_form(a) == canonical_form(b)
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum EdgeTypeStatus {
AnyOrAbsent,
Compatible,
Mismatch {
expected: Urn,
found: Urn,
},
}
fn producer_output_type<'a>(
nodes: &'a BTreeMap<NodeId, GraphNode>,
source: &EdgeSource,
) -> Option<&'a Urn> {
match source {
EdgeSource::NodeOutput { node, output } => nodes.get(node)?.output_type(output),
EdgeSource::Virtual(_) => None,
}
}
fn rule_allows(type_rules: &[TypeRule], found: &Urn, expected: &Urn) -> bool {
type_rules
.iter()
.any(|rule| urns_equivalent(&rule.from, found) && urns_equivalent(&rule.to, expected))
}
pub(crate) fn edge_status(
nodes: &BTreeMap<NodeId, GraphNode>,
consumer: &NodeId,
input: &crate::ids::PortName,
edge: &Edge,
type_rules: &[TypeRule],
) -> EdgeTypeStatus {
let expected = nodes.get(consumer).and_then(|n| n.input_type(input));
let found = producer_output_type(nodes, &edge.from);
match (expected, found) {
(Some(expected), Some(found)) => {
if urns_equivalent(expected, found) || rule_allows(type_rules, found, expected) {
EdgeTypeStatus::Compatible
} else {
EdgeTypeStatus::Mismatch {
expected: expected.clone(),
found: found.clone(),
}
}
}
_ => EdgeTypeStatus::AnyOrAbsent,
}
}
pub(crate) fn check_types(
nodes: &BTreeMap<NodeId, GraphNode>,
edges: &BTreeMap<EdgeKey, Edge>,
type_rules: &[TypeRule],
strict_types: bool,
) -> Vec<Diagnostic> {
let mut diagnostics = Vec::new();
for (key, edge) in edges {
let status = edge_status(nodes, &key.consumer, &key.input, edge, type_rules);
if let EdgeTypeStatus::Mismatch { expected, found } = status {
let severity = if strict_types {
Severity::Error
} else {
Severity::Warning
};
diagnostics.push(Diagnostic::new(
severity,
DiagnosticKind::TypeMismatch {
edge: key.clone(),
expected,
found,
},
));
}
}
diagnostics
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::collections::BTreeMap;
use super::*;
use crate::edge::QueueConfig;
use crate::ids::{MachineId, PortName};
use crate::node::{InputPort, OutputPort};
fn producer(output: &str, urn: Option<&str>) -> GraphNode {
let mut outputs = BTreeMap::new();
outputs.insert(
PortName::new(output),
OutputPort {
type_urn: urn.map(Urn::new),
},
);
GraphNode {
id: NodeId::new("producer"),
outputs,
inputs: BTreeMap::new(),
pattern: None,
machine: MachineId::CoordinatorLocal,
spawns_process: true,
}
}
fn consumer(input: &str, urn: Option<&str>) -> GraphNode {
let mut inputs = BTreeMap::new();
inputs.insert(
PortName::new(input),
InputPort {
type_urn: urn.map(Urn::new),
},
);
GraphNode {
id: NodeId::new("consumer"),
outputs: BTreeMap::new(),
inputs,
pattern: None,
machine: MachineId::CoordinatorLocal,
spawns_process: true,
}
}
fn wired(
producer_urn: Option<&str>,
consumer_urn: Option<&str>,
) -> (BTreeMap<NodeId, GraphNode>, BTreeMap<EdgeKey, Edge>) {
let p = producer("out", producer_urn);
let c = consumer("in", consumer_urn);
let mut nodes = BTreeMap::new();
nodes.insert(NodeId::new("producer"), p);
nodes.insert(NodeId::new("consumer"), c);
let mut edges = BTreeMap::new();
edges.insert(
EdgeKey::new(NodeId::new("consumer"), PortName::new("in")),
Edge {
from: EdgeSource::NodeOutput {
node: NodeId::new("producer"),
output: PortName::new("out"),
},
queue: QueueConfig::default(),
},
);
(nodes, edges)
}
#[test]
fn matching_types_are_compatible() {
let (nodes, edges) = wired(
Some("std/vision/v1/Detections"),
Some("std/vision/v1/Detections"),
);
let diags = check_types(&nodes, &edges, &[], false);
assert!(diags.is_empty());
}
#[test]
fn absent_types_flow_silently() {
let (nodes, edges) = wired(None, None);
let diags = check_types(&nodes, &edges, &[], true);
assert!(diags.is_empty());
}
#[test]
fn one_side_absent_flows_silently() {
let (nodes, edges) = wired(Some("std/vision/v1/Detections"), None);
let diags = check_types(&nodes, &edges, &[], true);
assert!(diags.is_empty());
}
#[test]
fn mismatch_is_warning_when_not_strict() {
let (nodes, edges) = wired(Some("std/core/v1/Float32"), Some("std/core/v1/Float64"));
let diags = check_types(&nodes, &edges, &[], false);
assert_eq!(diags.len(), 1);
assert_eq!(diags[0].severity, Severity::Warning);
}
#[test]
fn mismatch_is_error_when_strict() {
let (nodes, edges) = wired(Some("std/core/v1/Float32"), Some("std/core/v1/Float64"));
let diags = check_types(&nodes, &edges, &[], true);
assert_eq!(diags.len(), 1);
assert_eq!(diags[0].severity, Severity::Error);
}
#[test]
fn type_rule_bridges_mismatch_even_when_strict() {
let (nodes, edges) = wired(Some("std/core/v1/Float32"), Some("std/core/v1/Float64"));
let rules = vec![TypeRule {
from: Urn::new("std/core/v1/Float32"),
to: Urn::new("std/core/v1/Float64"),
}];
let diags = check_types(&nodes, &edges, &rules, true);
assert!(diags.is_empty());
}
#[test]
fn type_rule_is_directional() {
let (nodes, edges) = wired(Some("std/core/v1/Float64"), Some("std/core/v1/Float32"));
let rules = vec![TypeRule {
from: Urn::new("std/core/v1/Float32"),
to: Urn::new("std/core/v1/Float64"),
}];
let diags = check_types(&nodes, &edges, &rules, false);
assert_eq!(diags.len(), 1);
}
#[test]
fn virtual_source_edge_is_any_or_absent() {
let c = consumer("tick", Some("std/time/v1/Timestamp"));
let mut nodes = BTreeMap::new();
nodes.insert(NodeId::new("consumer"), c);
let mut edges = BTreeMap::new();
edges.insert(
EdgeKey::new(NodeId::new("consumer"), PortName::new("tick")),
Edge {
from: EdgeSource::Virtual("astrs/timer/hz/50".to_string()),
queue: QueueConfig::default(),
},
);
let status = edge_status(
&nodes,
&NodeId::new("consumer"),
&PortName::new("tick"),
edges.values().next().expect("one edge"),
&[],
);
assert_eq!(status, EdgeTypeStatus::AnyOrAbsent);
}
#[test]
fn canonical_form_reorders_std_params() {
let width_first = Urn::new("std/media/v1/Image[width=640,pixel=rgb8]");
let pixel_first = Urn::new("std/media/v1/Image[pixel=rgb8,width=640]");
assert_eq!(canonical_form(&width_first), canonical_form(&pixel_first));
assert!(urns_equivalent(&width_first, &pixel_first));
}
#[test]
fn canonical_form_falls_back_to_raw_text_for_non_std_namespace() {
let urn = Urn::new("vendor/thing/v1/Widget");
assert_eq!(
canonical_form(&urn),
Cow::Borrowed("vendor/thing/v1/Widget")
);
}
#[test]
fn param_reordering_is_compatible_even_when_strict() {
let (nodes, edges) = wired(
Some("std/media/v1/Image[width=640,pixel=rgb8]"),
Some("std/media/v1/Image[pixel=rgb8,width=640]"),
);
let diags = check_types(&nodes, &edges, &[], true);
assert!(diags.is_empty(), "diagnostics: {diags:?}");
}
#[test]
fn different_param_values_still_mismatch() {
let (nodes, edges) = wired(
Some("std/media/v1/Image[pixel=rgb8]"),
Some("std/media/v1/Image[pixel=bgr8]"),
);
let diags = check_types(&nodes, &edges, &[], false);
assert_eq!(diags.len(), 1, "diagnostics: {diags:?}");
}
#[test]
fn non_std_namespace_param_reordering_is_not_bridged() {
let (nodes, edges) = wired(
Some("vendor/thing/v1/Widget[b=2,a=1]"),
Some("vendor/thing/v1/Widget[a=1,b=2]"),
);
let diags = check_types(&nodes, &edges, &[], false);
assert_eq!(diags.len(), 1, "diagnostics: {diags:?}");
}
#[test]
fn type_rule_bridges_across_param_order() {
let (nodes, edges) = wired(
Some("std/geometry/v1/Vector3[unit=m]"),
Some("std/geometry/v1/Vector3[frame=base,unit=m]"),
);
let rules = vec![TypeRule {
from: Urn::new("std/geometry/v1/Vector3[unit=m]"),
to: Urn::new("std/geometry/v1/Vector3[unit=m,frame=base]"),
}];
let diags = check_types(&nodes, &edges, &rules, true);
assert!(diags.is_empty(), "diagnostics: {diags:?}");
}
}