jsonx 0.1.0

//! Newtype-struct "tokens" used to smuggle JSONX extended types through serde's
//! data model.
//!
//! serde's data model has no native concept of a datetime, IP address, or a
//! distinct machine-width `int`/`uint`, nor of any user-defined `type(value)`
//! constructor. To represent these losslessly when a value flows through serde
//! (e.g. `Serialize for Value`, the wrapper types in [`crate::wrappers`], or a
//! caller's own [`JsonxConstructor`](crate::JsonxConstructor) type), we
//! serialize them as `serialize_newtype_struct` calls whose *name* begins with
//! [`CTOR_SENTINEL`] followed by the constructor name.
//!
//! Our own [`crate::ser::Serializer`] and [`crate::de::Deserializer`] recognize
//! the sentinel (via [`strip_ctor`]) and emit/parse the proper `type(value)`
//! syntax; every other serde format simply sees a transparent newtype and
//! renders the inner value plainly. The public [`ctor!`](crate::ctor) macro
//! produces the same encoding for third-party types.
//!
//! The sentinel uses control characters so it can never collide with a real
//! Rust type name (the usual newtype-struct name) or a JSONX identifier.

/// Prefix that marks a newtype-struct name as a JSONX constructor request. The
/// bytes after it are the constructor name (`ip`, `datetime`, a user name, ...).
pub(crate) const CTOR_SENTINEL: &str = "\u{1}jx\u{1}";

pub(crate) const TOKEN_INT: &str = "\u{1}jx\u{1}int";
pub(crate) const TOKEN_UINT: &str = "\u{1}jx\u{1}uint";
pub(crate) const TOKEN_DATETIME: &str = "\u{1}jx\u{1}datetime";
pub(crate) const TOKEN_IP: &str = "\u{1}jx\u{1}ip";
pub(crate) const TOKEN_IPPORT: &str = "\u{1}jx\u{1}ipport";

/// Marks a newtype-struct name as a *dynamic-named* constructor request
/// ([`Value::Constructor`](crate::Value)). Unlike the tokens above, the
/// constructor name is not known at compile time, so it travels inside the value
/// (as a single-entry map `{name: arg}`) rather than in the token name. The
/// trailing control byte keeps it distinct from any [`CTOR_SENTINEL`]-encoded
/// name, whose suffix is always a JSONX identifier.
pub(crate) const TOKEN_CTOR: &str = "\u{1}jx\u{1}\u{1}";

/// If `name` is a sentinel-encoded constructor token, returns the bare
/// constructor name (e.g. `"ip"`); otherwise `None`.
#[inline]
pub(crate) fn strip_ctor(name: &str) -> Option<&str> {
    name.strip_prefix(CTOR_SENTINEL)
}

/// Returns `true` if `s` is a legal bare JSONX identifier — the form a
/// constructor name (and an unquoted object key) must take: a leading ASCII
/// letter or `_`, then ASCII alphanumerics or `_`, and never empty.
///
/// This is the exact set the deserializer's `is_ident_start`/`is_ident_continue`
/// scanner accepts, so a name passing this check renders to JSONX that parses
/// back to the same constructor.
#[inline]
pub(crate) fn is_ident(s: &str) -> bool {
    let mut bytes = s.bytes();
    match bytes.next() {
        Some(b) if b.is_ascii_alphabetic() || b == b'_' => {}
        _ => return false,
    }
    bytes.all(|b| b.is_ascii_alphanumeric() || b == b'_')
}