use std::fmt;
use crate::error_kinds::ErrorKind;
use crate::typename::bare_type_name;
use crate::{Error, Value};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DynamicNameToken {
PropertyKey,
Label,
}
impl DynamicNameToken {
pub const fn as_str(self) -> &'static str {
match self {
Self::PropertyKey => "property key",
Self::Label => "label",
}
}
pub const fn position(self) -> &'static str {
match self {
Self::PropertyKey => "node or relationship property key",
Self::Label => "dynamic label",
}
}
pub const fn expected(self) -> &'static str {
match self {
Self::PropertyKey => "STRING",
Self::Label => "STRING or LIST<STRING>",
}
}
pub fn accepts_type(self, type_name: &str) -> bool {
match self {
Self::PropertyKey => type_name == "STRING",
Self::Label => type_name == "STRING" || type_name == "LIST",
}
}
pub fn check(self, value: &Value) -> Result<(), DynamicAccessError> {
match self {
Self::PropertyKey => dynamic_property_key(value).map(|_| ()),
Self::Label => dynamic_label_names(value).map(|_| ()),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DynamicAccessError {
WrongType {
token: DynamicNameToken,
type_name: String,
},
InvalidName {
token: DynamicNameToken,
input: String,
},
}
impl DynamicAccessError {
pub fn wrong_type(token: DynamicNameToken, type_name: impl Into<String>) -> Self {
Self::WrongType {
token,
type_name: type_name.into(),
}
}
pub fn kind(&self) -> ErrorKind {
match self {
Self::WrongType { .. } => ErrorKind::InvalidArgumentType,
Self::InvalidName { .. } => ErrorKind::SyntaxError,
}
}
}
impl fmt::Display for DynamicAccessError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::WrongType { token, type_name } => write!(
f,
"Invalid input '{type_name}' for {}. Expected to be {}.",
token.position(),
token.expected()
),
Self::InvalidName { token, input } => write!(
f,
"invalid name. A {} name cannot be empty or contain any null-bytes: '{}'.",
token.as_str(),
escape_for_message(input)
),
}
}
}
impl From<DynamicAccessError> for Error {
fn from(error: DynamicAccessError) -> Self {
let detail = error.to_string();
match error {
DynamicAccessError::WrongType { .. } => Error::invalid_argument_type(detail),
DynamicAccessError::InvalidName { .. } => Error::syntax(detail),
}
}
}
pub fn dynamic_property_key(value: &Value) -> Result<String, DynamicAccessError> {
match value {
Value::String(key) => validated_name(DynamicNameToken::PropertyKey, key),
other => Err(DynamicAccessError::wrong_type(
DynamicNameToken::PropertyKey,
bare_type_name(other),
)),
}
}
pub fn dynamic_label_names(value: &Value) -> Result<Vec<String>, DynamicAccessError> {
match value {
Value::List(items) => items.iter().map(label_name).collect(),
other => label_name(other).map(|name| vec![name]),
}
}
fn label_name(item: &Value) -> Result<String, DynamicAccessError> {
match item {
Value::String(name) => validated_name(DynamicNameToken::Label, name),
other => Err(DynamicAccessError::wrong_type(
DynamicNameToken::Label,
bare_type_name(other),
)),
}
}
fn validated_name(token: DynamicNameToken, name: &str) -> Result<String, DynamicAccessError> {
if name.is_empty() || name.contains('\0') {
Err(DynamicAccessError::InvalidName {
token,
input: name.to_string(),
})
} else {
Ok(name.to_string())
}
}
fn escape_for_message(input: &str) -> String {
input.chars().flat_map(char::escape_default).collect()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::temporal::Temporal;
#[test]
fn string_property_key_is_accepted_by_reference() {
assert_eq!(
dynamic_property_key(&Value::String("name".into())).unwrap(),
"name"
);
}
#[test]
fn wrong_property_key_type_names_the_input_and_the_expected_type() {
let error = dynamic_property_key(&Value::Int(1)).unwrap_err();
assert_eq!(error.kind(), ErrorKind::InvalidArgumentType);
assert_eq!(
error.to_string(),
"Invalid input 'INTEGER' for node or relationship property key. Expected to be STRING."
);
}
#[test]
fn empty_and_nul_property_keys_are_invalid_names() {
for key in ["", "a\0b"] {
let error = dynamic_property_key(&Value::String(key.into())).unwrap_err();
assert_eq!(error.kind(), ErrorKind::SyntaxError);
assert!(error.to_string().starts_with(
"invalid name. A property key name cannot be empty or contain any null-bytes: '"
));
}
}
#[test]
fn label_names_accept_a_string_and_a_string_list() {
assert_eq!(
dynamic_label_names(&Value::String("A".into())).unwrap(),
vec!["A".to_string()]
);
let list = Value::List(vec![Value::String("A".into()), Value::String("B".into())].into());
assert_eq!(
dynamic_label_names(&list).unwrap(),
vec!["A".to_string(), "B".to_string()]
);
}
#[test]
fn label_names_reject_non_string_and_invalid_elements() {
let wrong = dynamic_label_names(&Value::Int(1)).unwrap_err();
assert_eq!(
wrong.to_string(),
"Invalid input 'INTEGER' for dynamic label. Expected to be STRING or LIST<STRING>."
);
let mixed = Value::List(vec![Value::String("A".into()), Value::Int(1)].into());
assert_eq!(dynamic_label_names(&mixed).unwrap_err(), wrong);
assert!(dynamic_label_names(&Value::String("".into())).is_err());
}
#[test]
fn token_check_is_the_shared_validation_entry() {
DynamicNameToken::PropertyKey
.check(&Value::String("name".into()))
.unwrap();
DynamicNameToken::Label
.check(&Value::List(vec![Value::String("A".into())].into()))
.unwrap();
assert_eq!(
DynamicNameToken::PropertyKey
.check(&Value::Int(1))
.unwrap_err()
.kind(),
ErrorKind::InvalidArgumentType
);
assert_eq!(
DynamicNameToken::Label
.check(&Value::String("".into()))
.unwrap_err()
.kind(),
ErrorKind::SyntaxError
);
}
#[test]
fn accepts_type_is_the_type_half_of_check() {
assert!(DynamicNameToken::PropertyKey.accepts_type("STRING"));
assert!(!DynamicNameToken::PropertyKey.accepts_type("LIST"));
assert!(!DynamicNameToken::PropertyKey.accepts_type("INTEGER"));
assert!(DynamicNameToken::Label.accepts_type("STRING"));
assert!(DynamicNameToken::Label.accepts_type("LIST"));
assert!(!DynamicNameToken::Label.accepts_type("MAP"));
}
#[test]
fn error_conversion_follows_the_shared_classification() {
assert!(matches!(
Error::from(dynamic_property_key(&Value::Int(1)).unwrap_err()),
Error::InvalidArgumentType(_)
));
assert!(matches!(
Error::from(dynamic_property_key(&Value::String("".into())).unwrap_err()),
Error::Syntax(_)
));
}
#[test]
fn wrong_type_detail_orders_numerics_by_cip100_not_lexicographically() {
let mixed = Value::List(vec![Value::Float(1.5), Value::Int(1)].into());
assert_eq!(
dynamic_property_key(&mixed).unwrap_err().to_string(),
"Invalid input 'LIST<INTEGER | FLOAT>' for node or relationship property key. \
Expected to be STRING."
);
}
#[test]
fn wrong_type_detail_renders_the_temporal_spelling() {
let duration = Value::Temporal(Temporal::Duration {
months: 0,
days: 0,
nanos: 0,
});
assert_eq!(
dynamic_property_key(&duration).unwrap_err().to_string(),
"Invalid input 'DURATION' for node or relationship property key. \
Expected to be STRING."
);
let date = Value::Temporal(Temporal::CivilDate {
year: 2020,
month: 1,
day: 1,
});
assert_eq!(
dynamic_label_names(&date).unwrap_err().to_string(),
"Invalid input 'DATE' for dynamic label. Expected to be STRING or LIST<STRING>."
);
}
}