use std::fmt;
use serde::{Deserialize, Serialize};
use crate::error::{VcpError, VcpResult};
const MAX_SITUATIONAL_WIRE_CHARS: usize = 8_192;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SituationalDimension {
Time,
Space,
Company,
Culture,
Occasion,
Environment,
Agency,
Constraints,
SystemContext,
Embodiment,
Proximity,
Relationship,
Formality,
}
impl SituationalDimension {
pub fn symbol(self) -> &'static str {
match self {
Self::Time => "\u{23F0}", Self::Space => "\u{1F4CD}", Self::Company => "\u{1F465}", Self::Culture => "\u{1F30D}", Self::Occasion => "\u{1F3AD}", Self::Environment => "\u{1F321}\u{FE0F}", Self::Agency => "\u{1F537}", Self::Constraints => "\u{1F536}", Self::SystemContext => "\u{1F4E1}", Self::Embodiment => "\u{1F9CD}", Self::Proximity => "\u{2194}\u{FE0F}", Self::Relationship => "\u{1FAA2}", Self::Formality => "\u{1F3A9}", }
}
pub fn position(self) -> u8 {
match self {
Self::Time => 1,
Self::Space => 2,
Self::Company => 3,
Self::Culture => 4,
Self::Occasion => 5,
Self::Environment => 6,
Self::Agency => 7,
Self::Constraints => 8,
Self::SystemContext => 9,
Self::Embodiment => 10,
Self::Proximity => 11,
Self::Relationship => 12,
Self::Formality => 13,
}
}
pub fn is_vep_0004(self) -> bool {
matches!(
self,
Self::Embodiment | Self::Proximity | Self::Relationship | Self::Formality
)
}
pub fn is_free_form(self) -> bool {
matches!(self, Self::Relationship)
}
pub fn from_symbol(s: &str) -> Option<Self> {
if s == "\u{1F321}\u{FE0F}" || s.starts_with("\u{1F321}\u{FE0F}") {
return Some(Self::Environment);
}
if s == "\u{1F321}" || s.starts_with("\u{1F321}") {
return Some(Self::Environment);
}
if s == "\u{2194}\u{FE0F}" || s.starts_with("\u{2194}\u{FE0F}") {
return Some(Self::Proximity);
}
if s == "\u{2194}" || s.starts_with("\u{2194}") {
return Some(Self::Proximity);
}
match s {
"\u{23F0}" => Some(Self::Time),
"\u{1F4CD}" => Some(Self::Space),
"\u{1F465}" => Some(Self::Company),
"\u{1F30D}" => Some(Self::Culture),
"\u{1F3AD}" => Some(Self::Occasion),
"\u{1F537}" => Some(Self::Agency),
"\u{1F536}" => Some(Self::Constraints),
"\u{1F4E1}" => Some(Self::SystemContext),
"\u{1F9CD}" => Some(Self::Embodiment),
"\u{1FAA2}" => Some(Self::Relationship),
"\u{1F3A9}" => Some(Self::Formality),
_ => None,
}
}
pub fn all() -> &'static [SituationalDimension] {
&[
Self::Time,
Self::Space,
Self::Company,
Self::Culture,
Self::Occasion,
Self::Environment,
Self::Agency,
Self::Constraints,
Self::SystemContext,
Self::Embodiment,
Self::Proximity,
Self::Relationship,
Self::Formality,
]
}
}
impl fmt::Display for SituationalDimension {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let label = match self {
Self::Time => "time",
Self::Space => "space",
Self::Company => "company",
Self::Culture => "culture",
Self::Occasion => "occasion",
Self::Environment => "environment",
Self::Agency => "agency",
Self::Constraints => "constraints",
Self::SystemContext => "system_context",
Self::Embodiment => "embodiment",
Self::Proximity => "proximity",
Self::Relationship => "relationship",
Self::Formality => "formality",
};
f.write_str(label)
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct SituationalContext {
#[serde(skip_serializing_if = "Option::is_none")]
pub time: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub space: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub company: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub culture: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub occasion: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub agency: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub constraints: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub system_context: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub embodiment: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub proximity: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub relationship: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub formality: Option<Vec<String>>,
}
impl SituationalContext {
pub fn has_any(&self) -> bool {
self.time.is_some()
|| self.space.is_some()
|| self.company.is_some()
|| self.culture.is_some()
|| self.occasion.is_some()
|| self.environment.is_some()
|| self.agency.is_some()
|| self.constraints.is_some()
|| self.system_context.is_some()
|| self.embodiment.is_some()
|| self.proximity.is_some()
|| self.relationship.is_some()
|| self.formality.is_some()
}
pub fn has_vep_0004(&self) -> bool {
self.embodiment.is_some()
|| self.proximity.is_some()
|| self.relationship.is_some()
|| self.formality.is_some()
}
pub fn to_wire(&self) -> String {
let mut parts = Vec::new();
let dims: [(SituationalDimension, &Option<Vec<String>>); 13] = [
(SituationalDimension::Time, &self.time),
(SituationalDimension::Space, &self.space),
(SituationalDimension::Company, &self.company),
(SituationalDimension::Culture, &self.culture),
(SituationalDimension::Occasion, &self.occasion),
(SituationalDimension::Environment, &self.environment),
(SituationalDimension::Agency, &self.agency),
(SituationalDimension::Constraints, &self.constraints),
(SituationalDimension::SystemContext, &self.system_context),
(SituationalDimension::Embodiment, &self.embodiment),
(SituationalDimension::Proximity, &self.proximity),
(SituationalDimension::Relationship, &self.relationship),
(SituationalDimension::Formality, &self.formality),
];
for (dim, tags_opt) in &dims {
if let Some(tags) = tags_opt {
if !tags.is_empty() {
let mut s = String::from(dim.symbol());
for tag in tags {
s.push_str(tag);
}
parts.push(s);
}
}
}
parts.join("|")
}
pub fn from_wire(wire: &str) -> VcpResult<Self> {
let mut ctx = SituationalContext::default();
if wire.is_empty() {
return Ok(ctx);
}
if wire.chars().count() > MAX_SITUATIONAL_WIRE_CHARS {
return Err(VcpError::ParseError(format!(
"situational context exceeds {MAX_SITUATIONAL_WIRE_CHARS} characters"
)));
}
if wire
.chars()
.any(|character| character.is_whitespace() || character.is_control())
{
return Err(VcpError::ParseError(
"situational context contains whitespace or control characters".to_string(),
));
}
for segment in wire.split('|') {
if segment.is_empty() {
return Err(VcpError::ParseError(
"situational context contains an empty dimension segment".to_string(),
));
}
let (dim, rest) = split_situational_symbol(segment)?;
if rest.is_empty() {
return Err(VcpError::ParseError(format!(
"situational dimension {dim} has no value"
)));
}
let tags = vec![rest.to_string()];
let slot = match dim {
SituationalDimension::Time => &mut ctx.time,
SituationalDimension::Space => &mut ctx.space,
SituationalDimension::Company => &mut ctx.company,
SituationalDimension::Culture => &mut ctx.culture,
SituationalDimension::Occasion => &mut ctx.occasion,
SituationalDimension::Environment => &mut ctx.environment,
SituationalDimension::Agency => &mut ctx.agency,
SituationalDimension::Constraints => &mut ctx.constraints,
SituationalDimension::SystemContext => &mut ctx.system_context,
SituationalDimension::Embodiment => &mut ctx.embodiment,
SituationalDimension::Proximity => &mut ctx.proximity,
SituationalDimension::Relationship => &mut ctx.relationship,
SituationalDimension::Formality => &mut ctx.formality,
};
if slot.is_some() {
return Err(VcpError::ParseError(format!(
"duplicate situational dimension: {dim}"
)));
}
*slot = Some(tags);
}
Ok(ctx)
}
pub fn get(&self, dim: SituationalDimension) -> Option<&Vec<String>> {
match dim {
SituationalDimension::Time => self.time.as_ref(),
SituationalDimension::Space => self.space.as_ref(),
SituationalDimension::Company => self.company.as_ref(),
SituationalDimension::Culture => self.culture.as_ref(),
SituationalDimension::Occasion => self.occasion.as_ref(),
SituationalDimension::Environment => self.environment.as_ref(),
SituationalDimension::Agency => self.agency.as_ref(),
SituationalDimension::Constraints => self.constraints.as_ref(),
SituationalDimension::SystemContext => self.system_context.as_ref(),
SituationalDimension::Embodiment => self.embodiment.as_ref(),
SituationalDimension::Proximity => self.proximity.as_ref(),
SituationalDimension::Relationship => self.relationship.as_ref(),
SituationalDimension::Formality => self.formality.as_ref(),
}
}
pub fn set(&mut self, dim: SituationalDimension, tags: Vec<String>) {
match dim {
SituationalDimension::Time => self.time = Some(tags),
SituationalDimension::Space => self.space = Some(tags),
SituationalDimension::Company => self.company = Some(tags),
SituationalDimension::Culture => self.culture = Some(tags),
SituationalDimension::Occasion => self.occasion = Some(tags),
SituationalDimension::Environment => self.environment = Some(tags),
SituationalDimension::Agency => self.agency = Some(tags),
SituationalDimension::Constraints => self.constraints = Some(tags),
SituationalDimension::SystemContext => self.system_context = Some(tags),
SituationalDimension::Embodiment => self.embodiment = Some(tags),
SituationalDimension::Proximity => self.proximity = Some(tags),
SituationalDimension::Relationship => self.relationship = Some(tags),
SituationalDimension::Formality => self.formality = Some(tags),
}
}
}
impl fmt::Display for SituationalContext {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_wire())
}
}
fn split_situational_symbol(s: &str) -> VcpResult<(SituationalDimension, &str)> {
static SYMBOLS: &[(SituationalDimension, &str)] = &[
(SituationalDimension::Space, "\u{1F4CD}"),
(SituationalDimension::Company, "\u{1F465}"),
(SituationalDimension::Culture, "\u{1F30D}"),
(SituationalDimension::Occasion, "\u{1F3AD}"),
(SituationalDimension::Agency, "\u{1F537}"),
(SituationalDimension::Constraints, "\u{1F536}"),
(SituationalDimension::SystemContext, "\u{1F4E1}"),
(SituationalDimension::Embodiment, "\u{1F9CD}"),
(SituationalDimension::Relationship, "\u{1FAA2}"),
(SituationalDimension::Formality, "\u{1F3A9}"),
(SituationalDimension::Time, "\u{23F0}"),
];
let env_sym = "\u{1F321}\u{FE0F}";
if let Some(rest) = s.strip_prefix(env_sym) {
return Ok((SituationalDimension::Environment, rest));
}
let prox_sym = "\u{2194}\u{FE0F}";
if let Some(rest) = s.strip_prefix(prox_sym) {
return Ok((SituationalDimension::Proximity, rest));
}
let env_bare = "\u{1F321}";
if let Some(rest) = s.strip_prefix(env_bare) {
return Ok((SituationalDimension::Environment, rest));
}
let prox_bare = "\u{2194}";
if let Some(rest) = s.strip_prefix(prox_bare) {
return Ok((SituationalDimension::Proximity, rest));
}
for (dim, sym) in SYMBOLS {
if let Some(rest) = s.strip_prefix(sym) {
return Ok((*dim, rest));
}
}
Err(VcpError::ParseError(format!(
"unrecognised situational dimension symbol in: {s}"
)))
}
#[cfg(test)]
mod tests {
use super::*;
use pretty_assertions::assert_eq;
#[test]
fn dimension_symbols_roundtrip() {
for dim in SituationalDimension::all() {
let sym = dim.symbol();
assert_eq!(
SituationalDimension::from_symbol(sym),
Some(*dim),
"symbol roundtrip failed for {dim}"
);
}
}
#[test]
fn thirteen_dimensions_unique_positions() {
let mut positions: Vec<u8> = SituationalDimension::all()
.iter()
.map(|d| d.position())
.collect();
positions.sort_unstable();
assert_eq!(positions, (1u8..=13).collect::<Vec<_>>());
}
#[test]
fn vep_0004_flags() {
for dim in SituationalDimension::all() {
let expected = matches!(
dim,
SituationalDimension::Embodiment
| SituationalDimension::Proximity
| SituationalDimension::Relationship
| SituationalDimension::Formality
);
assert_eq!(dim.is_vep_0004(), expected, "is_vep_0004 wrong for {dim}");
}
}
#[test]
fn relationship_is_free_form_others_are_not() {
assert!(SituationalDimension::Relationship.is_free_form());
for dim in SituationalDimension::all() {
if *dim != SituationalDimension::Relationship {
assert!(!dim.is_free_form(), "unexpected free-form for {dim}");
}
}
}
#[test]
fn empty_context() {
let ctx = SituationalContext::default();
assert!(!ctx.has_any());
assert!(!ctx.has_vep_0004());
assert_eq!(ctx.to_wire(), "");
}
#[test]
fn wire_roundtrip_single() {
let ctx = SituationalContext {
time: Some(vec!["\u{1F305}".to_string()]), space: Some(vec!["\u{1F3E1}".to_string()]), ..Default::default()
};
let wire = ctx.to_wire();
assert!(wire.contains("\u{23F0}\u{1F305}"));
assert!(wire.contains("\u{1F4CD}\u{1F3E1}"));
}
#[test]
fn from_wire_basic() {
let wire = "\u{23F0}\u{1F305}|\u{1F4CD}\u{1F3E1}";
let ctx = SituationalContext::from_wire(wire).unwrap();
assert!(ctx.time.is_some());
assert!(ctx.space.is_some());
assert!(ctx.company.is_none());
}
#[test]
fn from_wire_empty() {
let ctx = SituationalContext::from_wire("").unwrap();
assert!(!ctx.has_any());
}
#[test]
fn from_wire_rejects_ambiguous_or_noncanonical_segments() {
for malformed in [
"|",
"\u{23F0}\u{1F305}|",
"\u{23F0}",
"\u{23F0}\u{1F305}|\u{23F0}\u{1F319}",
"\u{23F0}\u{1F305} ",
] {
assert!(
SituationalContext::from_wire(malformed).is_err(),
"accepted {malformed:?}"
);
}
let oversized = format!("β°{}", "a".repeat(MAX_SITUATIONAL_WIRE_CHARS));
assert!(SituationalContext::from_wire(&oversized)
.unwrap_err()
.to_string()
.contains("8192 characters"));
}
#[test]
fn get_and_set() {
let mut ctx = SituationalContext::default();
assert!(ctx.get(SituationalDimension::Culture).is_none());
ctx.set(
SituationalDimension::Culture,
vec!["\u{1F1EC}\u{1F1E7}".to_string()],
);
assert!(ctx.get(SituationalDimension::Culture).is_some());
}
#[test]
fn serde_roundtrip() {
let ctx = SituationalContext {
time: Some(vec!["morning".to_string()]),
company: Some(vec!["alone".to_string()]),
..Default::default()
};
let json = serde_json::to_string(&ctx).unwrap();
let parsed: SituationalContext = serde_json::from_str(&json).unwrap();
assert_eq!(ctx, parsed);
}
#[test]
fn vep_0004_symbols_encode_and_parse() {
let ctx = SituationalContext {
embodiment: Some(vec!["\u{270B}".to_string()]), proximity: Some(vec!["\u{1F90F}".to_string()]), relationship: Some(vec!["colleague:professional".to_string()]),
formality: Some(vec!["\u{1F4BC}".to_string()]), ..Default::default()
};
let wire = ctx.to_wire();
assert!(wire.contains("\u{1F9CD}\u{270B}"));
assert!(wire.contains("\u{2194}\u{FE0F}\u{1F90F}"));
assert!(wire.contains("\u{1FAA2}colleague:professional"));
assert!(wire.contains("\u{1F3A9}\u{1F4BC}"));
let parsed = SituationalContext::from_wire(&wire).unwrap();
assert_eq!(
parsed.embodiment.as_deref(),
Some(&["\u{270B}".to_string()][..])
);
assert_eq!(
parsed.proximity.as_deref(),
Some(&["\u{1F90F}".to_string()][..])
);
assert_eq!(
parsed.relationship.as_deref(),
Some(&["colleague:professional".to_string()][..])
);
assert_eq!(
parsed.formality.as_deref(),
Some(&["\u{1F4BC}".to_string()][..])
);
}
#[test]
fn has_vep_0004_is_true_when_vep_dim_set() {
let mut ctx = SituationalContext {
time: Some(vec!["\u{1F305}".to_string()]),
..Default::default()
};
assert!(!ctx.has_vep_0004());
ctx.formality = Some(vec!["\u{1F4BC}".to_string()]);
assert!(ctx.has_vep_0004());
}
#[test]
fn canonical_thirteen_dim_example_encodes() {
let ctx = SituationalContext {
time: Some(vec!["\u{1F305}".to_string()]), space: Some(vec!["\u{1F3E2}".to_string()]), company: Some(vec!["\u{1F454}".to_string()]), occasion: Some(vec!["\u{1F4BC}".to_string()]), embodiment: Some(vec!["\u{270B}".to_string()]), proximity: Some(vec!["\u{1F90F}".to_string()]), relationship: Some(vec!["colleague:professional".to_string()]),
formality: Some(vec!["\u{1F4BC}".to_string()]), ..Default::default()
};
let expected = "\u{23F0}\u{1F305}\
|\u{1F4CD}\u{1F3E2}\
|\u{1F465}\u{1F454}\
|\u{1F3AD}\u{1F4BC}\
|\u{1F9CD}\u{270B}\
|\u{2194}\u{FE0F}\u{1F90F}\
|\u{1FAA2}colleague:professional\
|\u{1F3A9}\u{1F4BC}";
assert_eq!(ctx.to_wire(), expected);
}
}