use std::collections::BTreeMap;
use std::fmt;
use std::sync::Arc;
use crate::{TokenId, tokens};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum AnsiColor {
Black,
Red,
Green,
Yellow,
Blue,
Magenta,
Cyan,
White,
BrightBlack,
BrightRed,
BrightGreen,
BrightYellow,
BrightBlue,
BrightMagenta,
BrightCyan,
BrightWhite,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Color {
Ansi(AnsiColor),
Rgb {
red: u8,
green: u8,
blue: u8,
fallback: AnsiColor,
},
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct TokenStyle {
pub foreground: Option<Color>,
pub bold: bool,
pub dim: bool,
pub underline: bool,
}
impl TokenStyle {
pub const fn foreground(color: Color) -> Self {
Self {
foreground: Some(color),
bold: false,
dim: false,
underline: false,
}
}
pub const fn bold(color: Color) -> Self {
Self {
foreground: Some(color),
bold: true,
dim: false,
underline: false,
}
}
pub const fn emphasized() -> Self {
Self {
foreground: None,
bold: true,
dim: false,
underline: false,
}
}
pub const fn dimmed() -> Self {
Self {
foreground: None,
bold: false,
dim: true,
underline: false,
}
}
pub const fn underlined(color: Color) -> Self {
Self {
foreground: Some(color),
bold: false,
dim: false,
underline: true,
}
}
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum StyleValue<T> {
#[default]
Inherit,
Set(T),
Clear,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct ThemeRule {
foreground: StyleValue<Color>,
bold: Option<bool>,
dim: Option<bool>,
underline: Option<bool>,
}
impl ThemeRule {
pub const fn new() -> Self {
Self {
foreground: StyleValue::Inherit,
bold: None,
dim: None,
underline: None,
}
}
pub const fn with_foreground(mut self, color: Color) -> Self {
self.foreground = StyleValue::Set(color);
self
}
pub const fn clear_foreground(mut self) -> Self {
self.foreground = StyleValue::Clear;
self
}
pub const fn with_bold(mut self, value: bool) -> Self {
self.bold = Some(value);
self
}
pub const fn with_dim(mut self, value: bool) -> Self {
self.dim = Some(value);
self
}
pub const fn with_underline(mut self, value: bool) -> Self {
self.underline = Some(value);
self
}
const fn apply(self, mut style: TokenStyle) -> TokenStyle {
match self.foreground {
StyleValue::Inherit => {}
StyleValue::Set(color) => style.foreground = Some(color),
StyleValue::Clear => style.foreground = None,
}
if let Some(value) = self.bold {
style.bold = value;
}
if let Some(value) = self.dim {
style.dim = value;
}
if let Some(value) = self.underline {
style.underline = value;
}
style
}
}
#[derive(Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ThemeName(String);
impl ThemeName {
pub fn parse(value: impl Into<String>) -> Result<Self, ThemeError> {
let value = value.into();
if valid_theme_name(&value) {
Ok(Self(value))
} else {
Err(ThemeError::InvalidName { value })
}
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for ThemeName {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_tuple("ThemeName")
.field(&self.as_str())
.finish()
}
}
impl fmt::Display for ThemeName {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.as_str())
}
}
fn valid_theme_name(value: &str) -> bool {
let bytes = value.as_bytes();
if bytes.is_empty() || bytes.len() > 64 || !bytes[0].is_ascii_lowercase() {
return false;
}
if bytes.last() == Some(&b'-') {
return false;
}
bytes
.iter()
.all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || *byte == b'-')
}
#[cfg(feature = "serde")]
impl serde::Serialize for ThemeName {
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 ThemeName {
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)
}
}
#[derive(Clone)]
pub struct Theme(Arc<ThemeData>);
struct ThemeData {
name: ThemeName,
rules: BTreeMap<TokenId, ThemeEntry>,
}
#[derive(Clone, Copy, Debug)]
enum ThemeEntry {
Replace(TokenStyle),
Patch(ThemeRule),
}
impl ThemeEntry {
const fn apply(self, style: TokenStyle) -> TokenStyle {
match self {
Self::Replace(replacement) => replacement,
Self::Patch(rule) => rule.apply(style),
}
}
}
impl fmt::Debug for Theme {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Theme")
.field("name", &self.0.name)
.field("rules", &self.0.rules)
.finish()
}
}
impl Theme {
pub fn builder(name: impl Into<String>) -> ThemeBuilder {
ThemeBuilder {
name: name.into(),
rules: BTreeMap::new(),
}
}
pub fn inheriting(name: impl Into<String>, base: &Theme) -> ThemeBuilder {
ThemeBuilder {
name: name.into(),
rules: base.0.rules.clone(),
}
}
pub fn name(&self) -> &ThemeName {
&self.0.name
}
pub fn resolve(&self, token: &TokenId) -> TokenStyle {
self.resolve_stack([token])
}
pub fn resolve_stack<'a>(&self, tokens: impl IntoIterator<Item = &'a TokenId>) -> TokenStyle {
let mut style = TokenStyle::default();
if let Some(rule) = self.0.rules.get(tokens::TEXT.as_str()) {
style = rule.apply(style);
}
for token in tokens {
let value = token.as_str();
for (index, byte) in value.bytes().enumerate() {
if byte == b'.'
&& let Some(rule) = self.0.rules.get(&value[..index])
{
style = rule.apply(style);
}
}
if let Some(rule) = self.0.rules.get(value) {
style = rule.apply(style);
}
}
style
}
}
pub struct ThemeBuilder {
name: String,
rules: BTreeMap<TokenId, ThemeEntry>,
}
impl ThemeBuilder {
pub fn rule(mut self, token: TokenId, style: TokenStyle) -> Result<Self, ThemeError> {
if self.rules.contains_key(&token) {
return Err(ThemeError::DuplicateRule { token });
}
self.rules.insert(token, ThemeEntry::Replace(style));
Ok(self)
}
pub fn patch(mut self, token: TokenId, rule: ThemeRule) -> Result<Self, ThemeError> {
if self.rules.contains_key(&token) {
return Err(ThemeError::DuplicateRule { token });
}
self.rules.insert(token, ThemeEntry::Patch(rule));
Ok(self)
}
pub fn override_rule(mut self, token: TokenId, style: TokenStyle) -> Result<Self, ThemeError> {
let Some(existing) = self.rules.get_mut(&token) else {
return Err(ThemeError::MissingOverrideTarget { token });
};
*existing = ThemeEntry::Replace(style);
Ok(self)
}
pub fn override_patch(mut self, token: TokenId, rule: ThemeRule) -> Result<Self, ThemeError> {
let Some(existing) = self.rules.get_mut(&token) else {
return Err(ThemeError::MissingOverrideTarget { token });
};
*existing = ThemeEntry::Patch(rule);
Ok(self)
}
pub fn build(self) -> Result<Theme, ThemeError> {
let name = ThemeName::parse(self.name)?;
Ok(Theme(Arc::new(ThemeData {
name,
rules: self.rules,
})))
}
}
#[derive(Clone, Debug, Eq, PartialEq, thiserror::Error)]
pub enum ThemeError {
#[error("invalid theme name {value:?}")]
InvalidName { value: String },
#[error("theme already defines token {token}")]
DuplicateRule { token: TokenId },
#[error("theme cannot override absent token {token}")]
MissingOverrideTarget { token: TokenId },
}
#[derive(Clone, Default)]
pub struct ThemeCatalog {
themes: BTreeMap<ThemeName, Theme>,
}
impl ThemeCatalog {
pub fn builder() -> ThemeCatalogBuilder {
ThemeCatalogBuilder {
themes: BTreeMap::new(),
}
}
pub fn get(&self, name: &ThemeName) -> Result<Theme, ThemeCatalogError> {
self.themes
.get(name)
.cloned()
.ok_or_else(|| ThemeCatalogError::ThemeNotFound { name: name.clone() })
}
}
pub struct ThemeCatalogBuilder {
themes: BTreeMap<ThemeName, Theme>,
}
impl ThemeCatalogBuilder {
pub fn theme(mut self, theme: Theme) -> Result<Self, ThemeCatalogError> {
let name = theme.name().clone();
if self.themes.contains_key(&name) {
return Err(ThemeCatalogError::DuplicateTheme { name });
}
self.themes.insert(name, theme);
Ok(self)
}
pub fn build(self) -> ThemeCatalog {
ThemeCatalog {
themes: self.themes,
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, thiserror::Error)]
pub enum ThemeCatalogError {
#[error("theme catalog already contains {name}")]
DuplicateTheme { name: ThemeName },
#[error("theme catalog does not contain {name}")]
ThemeNotFound { name: ThemeName },
}
fn static_theme(name: &'static str, rules: &[(TokenId, TokenStyle)]) -> Theme {
let mut entries = BTreeMap::new();
for (token, style) in rules {
entries.insert(token.clone(), ThemeEntry::Replace(*style));
}
Theme(Arc::new(ThemeData {
name: ThemeName(name.to_owned()),
rules: entries,
}))
}
const fn ansi(color: AnsiColor) -> Color {
Color::Ansi(color)
}
const fn rgb(red: u8, green: u8, blue: u8, fallback: AnsiColor) -> Color {
Color::Rgb {
red,
green,
blue,
fallback,
}
}
fn semantic_theme(name: &'static str, palette: Palette) -> Theme {
let mut theme = static_theme(
name,
&[
(tokens::TEXT, TokenStyle::default()),
(tokens::TEXT_HEADING, TokenStyle::bold(palette.heading)),
(tokens::TEXT_SUBHEADING, TokenStyle::bold(palette.info)),
(tokens::TEXT_EMPHASIS, TokenStyle::emphasized()),
(tokens::TEXT_LINK, TokenStyle::underlined(palette.link)),
(tokens::TEXT_LABEL, TokenStyle::bold(palette.accent)),
(tokens::TEXT_MUTED, palette.muted),
(tokens::TEXT_COMMENT, palette.muted),
(tokens::LIST_MARKER, palette.muted),
(tokens::TABLE_HEADER, TokenStyle::bold(palette.heading)),
(tokens::SYNTAX_CODE, TokenStyle::foreground(palette.code)),
(tokens::SYNTAX_KEYWORD, TokenStyle::bold(palette.accent)),
(tokens::SYNTAX_COMMENT, palette.muted),
(tokens::SYNTAX_STRING, TokenStyle::foreground(palette.code)),
(
tokens::SYNTAX_STRING_ESCAPE,
TokenStyle::bold(palette.accent),
),
(tokens::SYNTAX_NUMBER, TokenStyle::foreground(palette.info)),
(tokens::SYNTAX_BOOLEAN, TokenStyle::bold(palette.info)),
(
tokens::SYNTAX_CONSTANT,
TokenStyle::foreground(palette.info),
),
(
tokens::SYNTAX_FUNCTION,
TokenStyle::foreground(palette.entity),
),
(
tokens::SYNTAX_PROPERTY,
TokenStyle::foreground(palette.entity),
),
(tokens::SYNTAX_TYPE, TokenStyle::bold(palette.info)),
(
tokens::SYNTAX_OPERATOR,
TokenStyle::foreground(palette.accent),
),
(tokens::SYNTAX_PUNCTUATION, palette.muted),
(tokens::PROMPT, TokenStyle::bold(palette.accent)),
(tokens::ENTITY, TokenStyle::foreground(palette.entity)),
(
tokens::ENTITY_IDENTIFIER,
TokenStyle::foreground(palette.entity),
),
(tokens::ENTITY_PATH, TokenStyle::foreground(palette.code)),
(tokens::ENTITY_REVISION, palette.muted),
(tokens::ENTITY_CAPABILITY, TokenStyle::bold(palette.accent)),
(tokens::ENTITY_RUNTIME, TokenStyle::bold(palette.success)),
(tokens::ENTITY_PROFILE, TokenStyle::bold(palette.info)),
(tokens::DATA_FORMAT, TokenStyle::bold(palette.accent)),
(tokens::DATA_NUMBER, palette.muted),
(tokens::DATA_COUNT, palette.muted),
(tokens::DATA_SIZE, palette.muted),
(tokens::DATA_DURATION, palette.muted),
(tokens::STATUS, TokenStyle::foreground(palette.info)),
(tokens::STATUS_SUCCESS, TokenStyle::bold(palette.success)),
(tokens::STATUS_INFO, TokenStyle::bold(palette.info)),
(tokens::STATUS_WARNING, TokenStyle::bold(palette.warning)),
(tokens::STATUS_ERROR, TokenStyle::bold(palette.error)),
(tokens::DIAGNOSTIC_NOTE, palette.muted),
(tokens::DIAGNOSTIC_INFO, TokenStyle::bold(palette.info)),
(
tokens::DIAGNOSTIC_WARNING,
TokenStyle::bold(palette.warning),
),
(tokens::DIAGNOSTIC_ERROR, TokenStyle::bold(palette.error)),
(tokens::PROGRESS, TokenStyle::bold(palette.info)),
],
);
let rules = &mut Arc::get_mut(&mut theme.0)
.expect("new semantic theme is uniquely owned")
.rules;
rules.insert(
tokens::PAIR_KEY,
ThemeEntry::Patch(ThemeRule::new().with_bold(true)),
);
rules.insert(
tokens::PAIR_LABEL,
ThemeEntry::Patch(ThemeRule::new().with_bold(true)),
);
rules.insert(
tokens::DIAGNOSTIC_LABEL,
ThemeEntry::Patch(ThemeRule::new().with_bold(true)),
);
rules.insert(
tokens::DIAGNOSTIC_CODE,
ThemeEntry::Patch(ThemeRule::new().with_bold(true)),
);
rules.insert(
tokens::DIAGNOSTIC_HINT,
ThemeEntry::Patch(ThemeRule::new().with_dim(true)),
);
theme
}
#[derive(Clone, Copy)]
struct Palette {
heading: Color,
accent: Color,
entity: Color,
code: Color,
link: Color,
muted: TokenStyle,
success: Color,
info: Color,
warning: Color,
error: Color,
}
pub mod themes {
use super::*;
use crate::background::Background;
pub fn for_background(background: Background) -> Theme {
match background {
Background::Light => light(),
Background::Dark | Background::Unknown => default(),
}
}
pub fn default() -> Theme {
semantic_theme(
"default",
Palette {
heading: ansi(AnsiColor::BrightCyan),
accent: ansi(AnsiColor::BrightBlue),
entity: ansi(AnsiColor::Cyan),
code: ansi(AnsiColor::Cyan),
link: ansi(AnsiColor::BrightBlue),
muted: TokenStyle::dimmed(),
success: ansi(AnsiColor::Green),
info: ansi(AnsiColor::Cyan),
warning: ansi(AnsiColor::Yellow),
error: ansi(AnsiColor::Red),
},
)
}
pub fn light() -> Theme {
semantic_theme(
"light",
Palette {
heading: rgb(38, 139, 210, AnsiColor::Blue),
accent: rgb(211, 54, 130, AnsiColor::Magenta),
entity: rgb(108, 113, 196, AnsiColor::Magenta),
code: rgb(42, 161, 152, AnsiColor::Cyan),
link: rgb(38, 139, 210, AnsiColor::Blue),
muted: TokenStyle::foreground(rgb(88, 110, 117, AnsiColor::Black)),
success: rgb(133, 153, 0, AnsiColor::Green),
info: rgb(38, 139, 210, AnsiColor::Blue),
warning: rgb(181, 137, 0, AnsiColor::Yellow),
error: rgb(220, 50, 47, AnsiColor::Red),
},
)
}
pub fn high_contrast() -> Theme {
semantic_theme(
"high-contrast",
Palette {
heading: ansi(AnsiColor::BrightWhite),
accent: ansi(AnsiColor::BrightCyan),
entity: ansi(AnsiColor::BrightBlue),
code: ansi(AnsiColor::BrightBlue),
link: ansi(AnsiColor::BrightCyan),
muted: TokenStyle::foreground(ansi(AnsiColor::White)),
success: ansi(AnsiColor::BrightGreen),
info: ansi(AnsiColor::BrightMagenta),
warning: ansi(AnsiColor::BrightYellow),
error: ansi(AnsiColor::BrightRed),
},
)
}
pub fn monochrome() -> Theme {
static_theme(
"monochrome",
&[
(tokens::TEXT, TokenStyle::default()),
(tokens::TEXT_HEADING, TokenStyle::emphasized()),
(tokens::TEXT_SUBHEADING, TokenStyle::emphasized()),
(tokens::TEXT_EMPHASIS, TokenStyle::emphasized()),
(tokens::TEXT_LABEL, TokenStyle::emphasized()),
(tokens::TABLE_HEADER, TokenStyle::emphasized()),
(tokens::PROMPT, TokenStyle::emphasized()),
(tokens::STATUS_SUCCESS, TokenStyle::emphasized()),
(tokens::STATUS_WARNING, TokenStyle::emphasized()),
(tokens::STATUS_ERROR, TokenStyle::emphasized()),
(tokens::TEXT_MUTED, TokenStyle::dimmed()),
(tokens::SYNTAX_COMMENT, TokenStyle::dimmed()),
],
)
}
pub fn dracula() -> Theme {
semantic_theme(
"dracula",
Palette {
heading: rgb(139, 233, 253, AnsiColor::BrightCyan),
accent: rgb(255, 121, 198, AnsiColor::BrightMagenta),
entity: rgb(189, 147, 249, AnsiColor::BrightMagenta),
code: rgb(241, 250, 140, AnsiColor::BrightYellow),
link: rgb(139, 233, 253, AnsiColor::BrightCyan),
muted: TokenStyle::foreground(rgb(98, 114, 164, AnsiColor::BrightBlack)),
success: rgb(80, 250, 123, AnsiColor::BrightGreen),
info: rgb(139, 233, 253, AnsiColor::BrightCyan),
warning: rgb(241, 250, 140, AnsiColor::BrightYellow),
error: rgb(255, 85, 85, AnsiColor::BrightRed),
},
)
}
pub fn nord() -> Theme {
semantic_theme(
"nord",
Palette {
heading: rgb(136, 192, 208, AnsiColor::BrightCyan),
accent: rgb(129, 161, 193, AnsiColor::BrightBlue),
entity: rgb(180, 142, 173, AnsiColor::BrightMagenta),
code: rgb(163, 190, 140, AnsiColor::Green),
link: rgb(94, 129, 172, AnsiColor::Blue),
muted: TokenStyle::foreground(rgb(76, 86, 106, AnsiColor::BrightBlack)),
success: rgb(163, 190, 140, AnsiColor::Green),
info: rgb(136, 192, 208, AnsiColor::Cyan),
warning: rgb(235, 203, 139, AnsiColor::Yellow),
error: rgb(191, 97, 106, AnsiColor::Red),
},
)
}
pub fn solarized_dark() -> Theme {
semantic_theme(
"solarized-dark",
Palette {
heading: rgb(42, 161, 152, AnsiColor::Cyan),
accent: rgb(38, 139, 210, AnsiColor::Blue),
entity: rgb(108, 113, 196, AnsiColor::Magenta),
code: rgb(181, 137, 0, AnsiColor::Yellow),
link: rgb(38, 139, 210, AnsiColor::Blue),
muted: TokenStyle::foreground(rgb(88, 110, 117, AnsiColor::BrightBlack)),
success: rgb(133, 153, 0, AnsiColor::Green),
info: rgb(42, 161, 152, AnsiColor::Cyan),
warning: rgb(203, 75, 22, AnsiColor::Yellow),
error: rgb(220, 50, 47, AnsiColor::Red),
},
)
}
pub fn gruvbox_dark() -> Theme {
semantic_theme(
"gruvbox-dark",
Palette {
heading: rgb(131, 165, 152, AnsiColor::Cyan),
accent: rgb(69, 133, 136, AnsiColor::Blue),
entity: rgb(211, 134, 155, AnsiColor::Magenta),
code: rgb(184, 187, 38, AnsiColor::Green),
link: rgb(131, 165, 152, AnsiColor::Cyan),
muted: TokenStyle::foreground(rgb(146, 131, 116, AnsiColor::BrightBlack)),
success: rgb(184, 187, 38, AnsiColor::Green),
info: rgb(131, 165, 152, AnsiColor::Cyan),
warning: rgb(250, 189, 47, AnsiColor::Yellow),
error: rgb(251, 73, 52, AnsiColor::Red),
},
)
}
}