use std::borrow::Borrow;
use std::borrow::Cow;
use std::fmt;
#[derive(Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TokenId(Cow<'static, str>);
impl TokenId {
pub const fn from_static(value: &'static str) -> Self {
if !valid_static_token(value) {
panic!("invalid static console token identifier");
}
Self(Cow::Borrowed(value))
}
pub fn parse(value: impl Into<String>) -> Result<Self, TokenIdError> {
let value = value.into();
validate_token(&value)?;
Ok(Self(Cow::Owned(value)))
}
pub fn as_str(&self) -> &str {
&self.0
}
pub fn ancestors(&self) -> TokenAncestors<'_> {
TokenAncestors {
value: self.as_str(),
next_end: Some(self.as_str().len()),
}
}
pub fn child(&self, segment: &str) -> Result<Self, TokenIdError> {
let mut value = String::with_capacity(self.as_str().len() + 1 + segment.len());
value.push_str(self.as_str());
value.push('.');
value.push_str(segment);
Self::parse(value)
}
pub fn parent(&self) -> Option<&str> {
self.as_str().rsplit_once('.').map(|(parent, _)| parent)
}
pub fn segments(&self) -> impl DoubleEndedIterator<Item = &str> {
self.as_str().split('.')
}
pub fn is_descendant_of(&self, ancestor: &Self) -> bool {
self.as_str()
.strip_prefix(ancestor.as_str())
.is_some_and(|suffix| suffix.starts_with('.'))
}
}
impl fmt::Debug for TokenId {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_tuple("TokenId")
.field(&self.as_str())
.finish()
}
}
impl fmt::Display for TokenId {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
impl Borrow<str> for TokenId {
fn borrow(&self) -> &str {
self.as_str()
}
}
pub struct TokenAncestors<'a> {
value: &'a str,
next_end: Option<usize>,
}
impl<'a> Iterator for TokenAncestors<'a> {
type Item = &'a str;
fn next(&mut self) -> Option<Self::Item> {
let end = self.next_end?;
let current = &self.value[..end];
self.next_end = current.rfind('.');
Some(current)
}
}
#[derive(Clone, Debug, Eq, PartialEq, thiserror::Error)]
pub enum TokenIdError {
#[error("token identifier is empty")]
Empty,
#[error("token identifier is {length} bytes; maximum is 255")]
TooLong { length: usize },
#[error("token identifier has an empty segment at byte {byte_offset}")]
EmptySegment { byte_offset: usize },
#[error("token segment starts with {found:?} at byte {byte_offset}")]
InvalidSegmentStart { byte_offset: usize, found: char },
#[error("token identifier contains {found:?} at byte {byte_offset}")]
InvalidCharacter { byte_offset: usize, found: char },
#[error("token segment ends with a hyphen at byte {byte_offset}")]
TrailingHyphen { byte_offset: usize },
}
pub(crate) fn validate_token(value: &str) -> Result<(), TokenIdError> {
if value.is_empty() {
return Err(TokenIdError::Empty);
}
if value.len() > 255 {
return Err(TokenIdError::TooLong {
length: value.len(),
});
}
let bytes = value.as_bytes();
let mut segment_start = 0usize;
for (offset, character) in value.char_indices() {
if character == '.' {
if offset == segment_start {
return Err(TokenIdError::EmptySegment {
byte_offset: offset,
});
}
if bytes[offset - 1] == b'-' {
return Err(TokenIdError::TrailingHyphen {
byte_offset: offset - 1,
});
}
segment_start = offset + 1;
continue;
}
if offset == segment_start {
if !character.is_ascii_lowercase() {
return Err(TokenIdError::InvalidSegmentStart {
byte_offset: offset,
found: character,
});
}
} else if !(character.is_ascii_lowercase()
|| character.is_ascii_digit()
|| character == '-')
{
return Err(TokenIdError::InvalidCharacter {
byte_offset: offset,
found: character,
});
}
}
if segment_start == value.len() {
return Err(TokenIdError::EmptySegment {
byte_offset: value.len(),
});
}
if bytes.last() == Some(&b'-') {
return Err(TokenIdError::TrailingHyphen {
byte_offset: value.len() - 1,
});
}
Ok(())
}
pub(crate) const fn valid_static_token(value: &str) -> bool {
let bytes = value.as_bytes();
if bytes.is_empty() || bytes.len() > 255 {
return false;
}
let mut index = 0usize;
let mut segment_start = true;
let mut previous_hyphen = false;
while index < bytes.len() {
let byte = bytes[index];
if byte == b'.' {
if segment_start || previous_hyphen {
return false;
}
segment_start = true;
previous_hyphen = false;
} else if segment_start {
if !(byte >= b'a' && byte <= b'z') {
return false;
}
segment_start = false;
previous_hyphen = false;
} else if (byte >= b'a' && byte <= b'z') || (byte >= b'0' && byte <= b'9') {
previous_hyphen = false;
} else if byte == b'-' {
previous_hyphen = true;
} else {
return false;
}
index += 1;
}
!segment_start && !previous_hyphen
}
#[cfg(feature = "serde")]
impl serde::Serialize for TokenId {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for TokenId {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Self::parse(value).map_err(serde::de::Error::custom)
}
}
pub mod tokens {
use super::TokenId;
pub const TEXT: TokenId = TokenId::from_static("text");
pub const TEXT_HEADING: TokenId = TokenId::from_static("text.heading");
pub const TEXT_SUBHEADING: TokenId = TokenId::from_static("text.subheading");
pub const TEXT_EMPHASIS: TokenId = TokenId::from_static("text.emphasis");
pub const TEXT_LINK: TokenId = TokenId::from_static("text.link");
pub const TEXT_LABEL: TokenId = TokenId::from_static("text.label");
pub const TEXT_MUTED: TokenId = TokenId::from_static("text.muted");
pub const TEXT_COMMENT: TokenId = TokenId::from_static("text.comment");
pub const LIST: TokenId = TokenId::from_static("list");
pub const LIST_ORDERED: TokenId = TokenId::from_static("list.ordered");
pub const LIST_UNORDERED: TokenId = TokenId::from_static("list.unordered");
pub const LIST_ITEM: TokenId = TokenId::from_static("list.item");
pub const LIST_MARKER: TokenId = TokenId::from_static("list.marker");
pub const TABLE: TokenId = TokenId::from_static("table");
pub const TABLE_HEADER: TokenId = TokenId::from_static("table.header");
pub const TABLE_ROW: TokenId = TokenId::from_static("table.row");
pub const TABLE_HEADER_ROW: TokenId = TokenId::from_static("table.row.header");
pub const TABLE_CELL: TokenId = TokenId::from_static("table.cell");
pub const TABLE_HEADER_CELL: TokenId = TokenId::from_static("table.cell.header");
pub const TABLE_SEPARATOR: TokenId = TokenId::from_static("table.separator");
pub const PAIR: TokenId = TokenId::from_static("pair");
pub const PAIR_KEY_VALUE: TokenId = TokenId::from_static("pair.key-value");
pub const PAIR_LABEL_VALUE: TokenId = TokenId::from_static("pair.label-value");
pub const PAIR_KEY: TokenId = TokenId::from_static("pair.key");
pub const PAIR_LABEL: TokenId = TokenId::from_static("pair.label");
pub const PAIR_SEPARATOR: TokenId = TokenId::from_static("pair.separator");
pub const PAIR_VALUE: TokenId = TokenId::from_static("pair.value");
pub const DIAGNOSTIC: TokenId = TokenId::from_static("diagnostic");
pub const DIAGNOSTIC_NOTE: TokenId = TokenId::from_static("diagnostic.note");
pub const DIAGNOSTIC_INFO: TokenId = TokenId::from_static("diagnostic.info");
pub const DIAGNOSTIC_WARNING: TokenId = TokenId::from_static("diagnostic.warning");
pub const DIAGNOSTIC_ERROR: TokenId = TokenId::from_static("diagnostic.error");
pub const DIAGNOSTIC_LABEL: TokenId = TokenId::from_static("diagnostic.label");
pub const DIAGNOSTIC_MESSAGE: TokenId = TokenId::from_static("diagnostic.message");
pub const DIAGNOSTIC_CODE: TokenId = TokenId::from_static("diagnostic.code");
pub const DIAGNOSTIC_DETAIL: TokenId = TokenId::from_static("diagnostic.detail");
pub const DIAGNOSTIC_HINT: TokenId = TokenId::from_static("diagnostic.hint");
pub const LANGUAGE: TokenId = TokenId::from_static("language");
pub const LANGUAGE_JSON: TokenId = TokenId::from_static("language.json");
pub const SYNTAX_CODE: TokenId = TokenId::from_static("syntax.code");
pub const SYNTAX_ATTRIBUTE: TokenId = TokenId::from_static("syntax.attribute");
pub const SYNTAX_BOOLEAN: TokenId = TokenId::from_static("syntax.boolean");
pub const SYNTAX_CHARACTER: TokenId = TokenId::from_static("syntax.character");
pub const SYNTAX_KEYWORD: TokenId = TokenId::from_static("syntax.keyword");
pub const SYNTAX_KEYWORD_FUNCTION: TokenId = TokenId::from_static("syntax.keyword.function");
pub const SYNTAX_KEYWORD_OPERATOR: TokenId = TokenId::from_static("syntax.keyword.operator");
pub const SYNTAX_COMMENT: TokenId = TokenId::from_static("syntax.comment");
pub const SYNTAX_CONDITIONAL: TokenId = TokenId::from_static("syntax.conditional");
pub const SYNTAX_CONSTANT: TokenId = TokenId::from_static("syntax.constant");
pub const SYNTAX_CONSTANT_BUILTIN: TokenId = TokenId::from_static("syntax.constant.builtin");
pub const SYNTAX_CONSTRUCTOR: TokenId = TokenId::from_static("syntax.constructor");
pub const SYNTAX_EMBEDDED: TokenId = TokenId::from_static("syntax.embedded");
pub const SYNTAX_EXCEPTION: TokenId = TokenId::from_static("syntax.exception");
pub const SYNTAX_FIELD: TokenId = TokenId::from_static("syntax.field");
pub const SYNTAX_FLOAT: TokenId = TokenId::from_static("syntax.float");
pub const SYNTAX_FUNCTION: TokenId = TokenId::from_static("syntax.function");
pub const SYNTAX_FUNCTION_BUILTIN: TokenId = TokenId::from_static("syntax.function.builtin");
pub const SYNTAX_FUNCTION_CALL: TokenId = TokenId::from_static("syntax.function.call");
pub const SYNTAX_FUNCTION_MACRO: TokenId = TokenId::from_static("syntax.function.macro");
pub const SYNTAX_INCLUDE: TokenId = TokenId::from_static("syntax.include");
pub const SYNTAX_LABEL: TokenId = TokenId::from_static("syntax.label");
pub const SYNTAX_METHOD: TokenId = TokenId::from_static("syntax.method");
pub const SYNTAX_METHOD_CALL: TokenId = TokenId::from_static("syntax.method.call");
pub const SYNTAX_NAMESPACE: TokenId = TokenId::from_static("syntax.namespace");
pub const SYNTAX_NUMBER: TokenId = TokenId::from_static("syntax.number");
pub const SYNTAX_OPERATOR: TokenId = TokenId::from_static("syntax.operator");
pub const SYNTAX_PARAMETER: TokenId = TokenId::from_static("syntax.parameter");
pub const SYNTAX_PROPERTY: TokenId = TokenId::from_static("syntax.property");
pub const SYNTAX_PUNCTUATION: TokenId = TokenId::from_static("syntax.punctuation");
pub const SYNTAX_PUNCTUATION_BRACKET: TokenId =
TokenId::from_static("syntax.punctuation.bracket");
pub const SYNTAX_PUNCTUATION_DELIMITER: TokenId =
TokenId::from_static("syntax.punctuation.delimiter");
pub const SYNTAX_PUNCTUATION_SPECIAL: TokenId =
TokenId::from_static("syntax.punctuation.special");
pub const SYNTAX_REPEAT: TokenId = TokenId::from_static("syntax.repeat");
pub const SYNTAX_STRING: TokenId = TokenId::from_static("syntax.string");
pub const SYNTAX_STRING_ESCAPE: TokenId = TokenId::from_static("syntax.string.escape");
pub const SYNTAX_STRING_REGEXP: TokenId = TokenId::from_static("syntax.string.regexp");
pub const SYNTAX_TAG: TokenId = TokenId::from_static("syntax.tag");
pub const SYNTAX_TYPE: TokenId = TokenId::from_static("syntax.type");
pub const SYNTAX_TYPE_BUILTIN: TokenId = TokenId::from_static("syntax.type.builtin");
pub const SYNTAX_VARIABLE: TokenId = TokenId::from_static("syntax.variable");
pub const SYNTAX_VARIABLE_BUILTIN: TokenId = TokenId::from_static("syntax.variable.builtin");
pub const PROMPT: TokenId = TokenId::from_static("prompt");
pub const ENTITY: TokenId = TokenId::from_static("entity");
pub const ENTITY_IDENTIFIER: TokenId = TokenId::from_static("entity.identifier");
pub const ENTITY_PATH: TokenId = TokenId::from_static("entity.path");
pub const ENTITY_URL: TokenId = TokenId::from_static("entity.url");
pub const ENTITY_REVISION: TokenId = TokenId::from_static("entity.revision");
pub const ENTITY_CAPABILITY: TokenId = TokenId::from_static("entity.capability");
pub const ENTITY_RUNTIME: TokenId = TokenId::from_static("entity.runtime");
pub const ENTITY_PROFILE: TokenId = TokenId::from_static("entity.profile");
pub const DATA: TokenId = TokenId::from_static("data");
pub const DATA_STRING: TokenId = TokenId::from_static("data.string");
pub const DATA_BOOLEAN: TokenId = TokenId::from_static("data.boolean");
pub const DATA_NULL: TokenId = TokenId::from_static("data.null");
pub const DATA_FORMAT: TokenId = TokenId::from_static("data.format");
pub const DATA_NUMBER: TokenId = TokenId::from_static("data.number");
pub const DATA_COUNT: TokenId = TokenId::from_static("data.count");
pub const DATA_SIZE: TokenId = TokenId::from_static("data.size");
pub const DATA_DURATION: TokenId = TokenId::from_static("data.duration");
pub const STATUS: TokenId = TokenId::from_static("status");
pub const STATUS_SUCCESS: TokenId = TokenId::from_static("status.success");
pub const STATUS_INFO: TokenId = TokenId::from_static("status.info");
pub const STATUS_WARNING: TokenId = TokenId::from_static("status.warning");
pub const STATUS_ERROR: TokenId = TokenId::from_static("status.error");
pub const PROGRESS: TokenId = TokenId::from_static("progress");
}