use std::collections::BTreeMap;
use crate::error::{err, ErrorCode, Result};
use crate::json::Value;
use crate::lexical;
use crate::model::{self, Scalar, Type};
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum KeyValue {
Scalar(Scalar),
Object(ObjectKey),
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct ObjectKey {
pub class: String,
pub keys: BTreeMap<String, KeyValue>,
}
pub fn parse_object_key(text: &str) -> Result<ObjectKey> {
if let Err(e) = lexical::check_string(text, "$") {
return err(ErrorCode::KeyEncoding, "$", format!("the encoding is not one string value: {}", e.detail()));
}
let mut p = Parser { s: text, i: 0 };
let key = p.object()?;
if p.i != text.len() {
return p.fail("trailing text after the encoding");
}
if format_object_key(&key) != text {
return p.fail("not the canonical encoding");
}
Ok(key)
}
struct Parser<'a> {
s: &'a str,
i: usize,
}
impl Parser<'_> {
fn fail<T>(&self, why: &str) -> Result<T> {
err(ErrorCode::KeyEncoding, "$", format!("{why} (at byte {})", self.i))
}
fn peek(&self) -> Option<char> {
self.s[self.i..].chars().next()
}
fn object(&mut self) -> Result<ObjectKey> {
let rest = &self.s[self.i..];
let Some(open) = rest.find('(') else {
return self.fail("a key encoding has an opening parenthesis");
};
let class = &rest[..open];
if lexical::check_function_name(class, "$").is_err() {
return self.fail("the class name is not a full name");
}
self.i += open + 1;
let mut keys = BTreeMap::new();
let mut prev: Option<String> = None;
if self.peek() == Some(')') {
self.i += 1;
return Ok(ObjectKey { class: class.into(), keys });
}
loop {
let rest = &self.s[self.i..];
let Some(colon) = rest.find(':') else {
return self.fail("a key has a label");
};
let name = &rest[..colon];
if lexical::check_arg_name(name, "$").is_err() {
return self.fail("a key label is an argument name");
}
if prev.as_deref().is_some_and(|p| p >= name) {
return self.fail("key labels are strictly ascending");
}
self.i += colon + 1;
let value = self.value()?;
keys.insert(name.to_string(), value);
prev = Some(name.to_string());
match self.peek() {
Some(',') => self.i += 1,
Some(')') => {
self.i += 1;
break;
}
_ => return self.fail("a key is followed by a comma or the closing parenthesis"),
}
}
Ok(ObjectKey { class: class.into(), keys })
}
fn value(&mut self) -> Result<KeyValue> {
if self.peek() == Some('"') {
self.i += 1;
let mut out = String::new();
loop {
let Some(c) = self.peek() else {
return self.fail("an unterminated string");
};
self.i += c.len_utf8();
if c == '"' {
if self.peek() == Some('"') {
self.i += 1;
out.push('"');
} else {
break;
}
} else {
out.push(c);
}
}
if lexical::check_string(&out, "$").is_err() {
return self.fail("a string is not a valid string value");
}
return Ok(KeyValue::Scalar(Scalar::String(out)));
}
let rest = &self.s[self.i..];
let stop = rest.find([',', ')', '(']).unwrap_or(rest.len());
if rest[stop..].starts_with('(') {
return Ok(KeyValue::Object(self.object()?));
}
let token = &rest[..stop];
self.i += stop;
let scalar = if token == "true" {
Scalar::Boolean(true)
} else if token == "false" {
Scalar::Boolean(false)
} else if token.len() == 10 && lexical::check_date(token, "$").is_ok() {
Scalar::Date(token.into())
} else if lexical::check_instant(token, "$").is_ok() {
Scalar::Instant(token.into())
} else if lexical::check_number(token, "$").is_ok() {
Scalar::Number(token.into())
} else {
return self.fail("a key value is a string, boolean, number, date, instant or key encoding");
};
Ok(KeyValue::Scalar(scalar))
}
}
fn quoted(s: &str) -> String {
let mut out = String::with_capacity(s.len() + 2);
out.push('"');
for c in s.chars() {
if c == '"' {
out.push('"');
}
out.push(c);
}
out.push('"');
out
}
pub fn format_object_key(key: &ObjectKey) -> String {
let mut out = String::with_capacity(key.class.len() + 2);
out.push_str(&key.class);
out.push('(');
for (i, (name, value)) in key.keys.iter().enumerate() {
if i > 0 {
out.push(',');
}
out.push_str(name);
out.push(':');
match value {
KeyValue::Scalar(Scalar::String(s)) => out.push_str("ed(s)),
KeyValue::Scalar(other) => out.push_str(other.lexical()),
KeyValue::Object(inner) => out.push_str(&format_object_key(inner)),
}
}
out.push(')');
out
}
impl ObjectKey {
pub fn new(class: &str, keys: impl IntoIterator<Item = (String, KeyValue)>) -> Result<ObjectKey> {
lexical::check_function_name(class, "$.class")?;
let mut map = BTreeMap::new();
for (name, value) in keys {
lexical::check_arg_name(&name, "$.keys")?;
if let KeyValue::Scalar(scalar) = &value {
if scalar.ty() == Type::Blob {
return err(ErrorCode::CanonType, &name, "a key is never a blob");
}
model::check_lexical(scalar.ty(), scalar.lexical(), &name)?;
}
if map.contains_key(&name) {
return err(ErrorCode::CanonArgDuplicate, &name, "a key is bound twice");
}
map.insert(name, value);
}
Ok(ObjectKey { class: class.into(), keys: map })
}
pub fn to_value(&self) -> Value {
Value::Object(vec![
("class".into(), Value::String(self.class.clone())),
(
"keys".into(),
Value::Object(
self.keys
.iter()
.map(|(k, v)| {
let value = match v {
KeyValue::Scalar(s) => s.to_value(),
KeyValue::Object(o) => o.to_value(),
};
(k.clone(), value)
})
.collect(),
),
),
])
}
pub fn object_value(&self, class_hash: &str) -> Result<Value> {
lexical::check_hex(class_hash, 64, "$.class_hash")?;
let keys = self
.keys
.iter()
.map(|(k, v)| {
let scalar = match v {
KeyValue::Scalar(s) => s.clone(),
KeyValue::Object(o) => Scalar::String(format_object_key(o)),
};
(k.clone(), scalar.to_value())
})
.collect();
Ok(Value::Object(vec![
("class".into(), Value::String(self.class.clone())),
("class_hash".into(), Value::String(class_hash.into())),
("keys".into(), Value::Object(keys)),
]))
}
pub fn object_id(&self, class_hash: &str) -> Result<String> {
Ok(crate::crypto::sha256_hex(&self.object_value(class_hash)?.to_jcs()))
}
pub fn call_form(&self) -> String {
let mut out = String::with_capacity(self.class.len() + 2);
out.push_str(&self.class);
out.push('(');
for (i, (name, value)) in self.keys.iter().enumerate() {
if i > 0 {
out.push_str(", ");
}
out.push_str(name);
out.push_str(": ");
match value {
KeyValue::Scalar(Scalar::String(s)) => out.push_str("ed(s)),
KeyValue::Scalar(other) => out.push_str(other.lexical()),
KeyValue::Object(inner) => out.push_str("ed(&format_object_key(inner))),
}
}
out.push(')');
out
}
}
pub fn short_id(id: &str) -> Result<String> {
lexical::check_hex(id, 64, "$.id")?;
Ok(id[..12].to_string())
}