#![forbid(unsafe_code)]
#![deny(missing_docs)]
mod bash;
mod css;
mod dockerfile;
mod emit;
mod html;
mod js;
mod json;
mod markdown;
mod python;
mod rust;
mod toml;
mod util;
mod yaml;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Lang {
Rust,
Bash,
Css,
Dockerfile,
Html,
JavaScript,
Json,
Markdown,
Python,
Toml,
TypeScript,
Yaml,
}
const SLUGS: &[(&str, Lang)] = &[
("rust", Lang::Rust),
("rs", Lang::Rust),
("bash", Lang::Bash),
("sh", Lang::Bash),
("shell", Lang::Bash),
("zsh", Lang::Bash),
("console", Lang::Bash),
("terminal", Lang::Bash),
("css", Lang::Css),
("dockerfile", Lang::Dockerfile),
("docker", Lang::Dockerfile),
("containerfile", Lang::Dockerfile),
("html", Lang::Html),
("htm", Lang::Html),
("xml", Lang::Html),
("svg", Lang::Html),
("javascript", Lang::JavaScript),
("js", Lang::JavaScript),
("jsx", Lang::JavaScript),
("mjs", Lang::JavaScript),
("cjs", Lang::JavaScript),
("json", Lang::Json),
("jsonc", Lang::Json),
("json5", Lang::Json),
("markdown", Lang::Markdown),
("md", Lang::Markdown),
("mdx", Lang::Markdown),
("python", Lang::Python),
("py", Lang::Python),
("py3", Lang::Python),
("toml", Lang::Toml),
("typescript", Lang::TypeScript),
("ts", Lang::TypeScript),
("tsx", Lang::TypeScript),
("yaml", Lang::Yaml),
("yml", Lang::Yaml),
];
impl Lang {
#[must_use]
pub fn from_slug(slug: &str) -> Option<Lang> {
SLUGS
.iter()
.find(|(name, _)| name.eq_ignore_ascii_case(slug))
.map(|&(_, lang)| lang)
}
#[must_use]
pub fn from_path(path: &str) -> Option<Lang> {
let name = path
.rsplit(['/', '\\'])
.next()
.unwrap_or(path)
.trim_end_matches(['.', ' ']);
if let Some((_, ext)) = name.rsplit_once('.')
&& let Some(lang) = Lang::from_slug(ext)
{
return Some(lang);
}
let stem = name.split('.').next().unwrap_or(name);
(stem.eq_ignore_ascii_case("dockerfile") || stem.eq_ignore_ascii_case("containerfile"))
.then_some(Lang::Dockerfile)
}
#[must_use]
pub fn slug(self) -> &'static str {
match self {
Lang::Rust => "rust",
Lang::Bash => "bash",
Lang::Css => "css",
Lang::Dockerfile => "dockerfile",
Lang::Html => "html",
Lang::JavaScript => "javascript",
Lang::Json => "json",
Lang::Markdown => "markdown",
Lang::Python => "python",
Lang::Toml => "toml",
Lang::TypeScript => "typescript",
Lang::Yaml => "yaml",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Kind {
Plain,
Keyword,
String,
Comment,
Number,
Type,
Function,
Attribute,
Property,
Tag,
Operator,
Punctuation,
Constant,
Variable,
}
impl Kind {
#[must_use]
pub fn class(self) -> &'static str {
match self {
Kind::Plain => "plain",
Kind::Keyword => "keyword",
Kind::String => "string",
Kind::Comment => "comment",
Kind::Number => "number",
Kind::Type => "type",
Kind::Function => "function",
Kind::Attribute => "attribute",
Kind::Property => "property",
Kind::Tag => "tag",
Kind::Operator => "operator",
Kind::Punctuation => "punctuation",
Kind::Constant => "constant",
Kind::Variable => "variable",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Span<'a> {
pub kind: Kind,
pub text: &'a str,
}
#[must_use]
pub fn highlight(lang: Lang, src: &str) -> Vec<Span<'_>> {
let mut out = emit::Emit::new(src);
match lang {
Lang::Rust => rust::lex(&mut out),
Lang::Bash => bash::lex(&mut out),
Lang::Css => css::lex(&mut out),
Lang::Dockerfile => dockerfile::lex(&mut out),
Lang::Html => html::lex(&mut out),
Lang::JavaScript => js::lex(&mut out, false),
Lang::TypeScript => js::lex(&mut out, true),
Lang::Json => json::lex(&mut out),
Lang::Markdown => markdown::lex(&mut out),
Lang::Python => python::lex(&mut out),
Lang::Toml => toml::lex(&mut out),
Lang::Yaml => yaml::lex(&mut out),
}
out.finish()
}