summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/eval/mod.rs112
-rw-r--r--src/geom/paint.rs17
-rw-r--r--src/library/deco.rs14
-rw-r--r--src/syntax/highlight.rs61
4 files changed, 194 insertions, 10 deletions
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index c16c2208..58400f5a 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -31,20 +31,32 @@ use std::io;
use std::mem;
use std::path::PathBuf;
+use once_cell::sync::Lazy;
+use syntect::easy::HighlightLines;
+use syntect::highlighting::{FontStyle, Highlighter, Style as SynStyle, Theme, ThemeSet};
+use syntect::parsing::SyntaxSet;
+
use unicode_segmentation::UnicodeSegmentation;
use crate::diag::{At, Error, StrResult, Trace, Tracepoint, TypResult};
-use crate::geom::{Angle, Fractional, Length, Relative};
+use crate::geom::{Angle, Fractional, Length, Paint, Relative, RgbaColor};
use crate::image::ImageStore;
use crate::layout::RootNode;
-use crate::library::{self, TextNode};
+use crate::library::{self, DecoLine, TextNode};
use crate::loading::Loader;
+use crate::parse;
use crate::source::{SourceId, SourceStore};
+use crate::syntax;
use crate::syntax::ast::*;
-use crate::syntax::{Span, Spanned};
+use crate::syntax::{RedNode, Span, Spanned};
use crate::util::{EcoString, RefMutExt};
use crate::Context;
+static THEME: Lazy<Theme> =
+ Lazy::new(|| ThemeSet::load_defaults().themes.remove("InspiredGitHub").unwrap());
+
+static SYNTAXES: Lazy<SyntaxSet> = Lazy::new(|| SyntaxSet::load_defaults_newlines());
+
/// An evaluated module, ready for importing or conversion to a root layout
/// tree.
#[derive(Debug, Default, Clone)]
@@ -209,15 +221,103 @@ impl Eval for RawNode {
type Output = Node;
fn eval(&self, _: &mut EvalContext) -> TypResult<Self::Output> {
- let text = Node::Text(self.text.clone()).monospaced();
+ let code = self.highlighted();
Ok(if self.block {
- Node::Block(text.into_block())
+ Node::Block(code.into_block())
} else {
- text
+ code
})
}
}
+impl RawNode {
+ /// Styled node for a code block, with optional syntax highlighting.
+ pub fn highlighted(&self) -> Node {
+ let mut sequence: Vec<Styled<Node>> = vec![];
+
+ let syntax = if let Some(syntax) = self
+ .lang
+ .as_ref()
+ .and_then(|token| SYNTAXES.find_syntax_by_token(&token))
+ {
+ Some(syntax)
+ } else if matches!(
+ self.lang.as_ref().map(|s| s.to_ascii_lowercase()).as_deref(),
+ Some("typ" | "typst")
+ ) {
+ None
+ } else {
+ return Node::Text(self.text.clone()).monospaced();
+ };
+
+ let foreground = THEME
+ .settings
+ .foreground
+ .map(RgbaColor::from)
+ .unwrap_or(RgbaColor::BLACK)
+ .into();
+
+ match syntax {
+ Some(syntax) => {
+ let mut highlighter = HighlightLines::new(syntax, &THEME);
+ for (i, line) in self.text.lines().enumerate() {
+ if i != 0 {
+ sequence.push(Styled::bare(Node::Linebreak));
+ }
+
+ for (style, line) in highlighter.highlight(line, &SYNTAXES) {
+ sequence.push(Self::styled_piece(style, line, foreground));
+ }
+ }
+ }
+ None => {
+ let green = parse::parse(&self.text);
+ let red = RedNode::from_root(green, SourceId::from_raw(0));
+ let highlighter = Highlighter::new(&THEME);
+
+ syntax::highlight_syntect(
+ red.as_ref(),
+ &highlighter,
+ &mut |range, style| {
+ sequence.push(Self::styled_piece(
+ style,
+ &self.text[range],
+ foreground,
+ ));
+ },
+ )
+ }
+ }
+
+ Node::Sequence(sequence).monospaced()
+ }
+
+ fn styled_piece(style: SynStyle, piece: &str, foreground: Paint) -> Styled<Node> {
+ let paint = style.foreground.into();
+ let node = Node::Text(piece.into());
+
+ let mut styles = StyleMap::new();
+
+ if paint != foreground {
+ styles.set(TextNode::FILL, paint);
+ }
+
+ if style.font_style.contains(FontStyle::BOLD) {
+ styles.set(TextNode::STRONG, true);
+ }
+
+ if style.font_style.contains(FontStyle::ITALIC) {
+ styles.set(TextNode::EMPH, true);
+ }
+
+ if style.font_style.contains(FontStyle::UNDERLINE) {
+ styles.set(TextNode::LINES, vec![DecoLine::Underline.into()]);
+ }
+
+ Styled::new(node, styles)
+ }
+}
+
impl Eval for MathNode {
type Output = Node;
diff --git a/src/geom/paint.rs b/src/geom/paint.rs
index d906561c..f8638656 100644
--- a/src/geom/paint.rs
+++ b/src/geom/paint.rs
@@ -1,6 +1,8 @@
use std::fmt::Display;
use std::str::FromStr;
+use syntect::highlighting::Color as SynColor;
+
use super::*;
/// How a fill or stroke should be painted.
@@ -34,9 +36,12 @@ impl Debug for Color {
}
}
-impl From<RgbaColor> for Color {
- fn from(rgba: RgbaColor) -> Self {
- Self::Rgba(rgba)
+impl<T> From<T> for Color
+where
+ T: Into<RgbaColor>,
+{
+ fn from(rgba: T) -> Self {
+ Self::Rgba(rgba.into())
}
}
@@ -114,6 +119,12 @@ impl FromStr for RgbaColor {
}
}
+impl From<SynColor> for RgbaColor {
+ fn from(color: SynColor) -> Self {
+ Self::new(color.r, color.b, color.g, color.a)
+ }
+}
+
impl Debug for RgbaColor {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
if f.alternate() {
diff --git a/src/library/deco.rs b/src/library/deco.rs
index 3e91d1de..ccb657d1 100644
--- a/src/library/deco.rs
+++ b/src/library/deco.rs
@@ -38,6 +38,18 @@ pub struct Decoration {
pub extent: Linear,
}
+impl From<DecoLine> for Decoration {
+ fn from(line: DecoLine) -> Self {
+ Self {
+ line,
+ stroke: None,
+ thickness: None,
+ offset: None,
+ extent: Linear::zero(),
+ }
+ }
+}
+
/// The kind of decorative line.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub enum DecoLine {
@@ -49,7 +61,7 @@ pub enum DecoLine {
Overline,
}
-/// Differents kinds of decorative lines for text.
+/// Different kinds of decorative lines for text.
pub trait LineKind {
const LINE: DecoLine;
}
diff --git a/src/syntax/highlight.rs b/src/syntax/highlight.rs
index 9f7365a8..0f1ee89d 100644
--- a/src/syntax/highlight.rs
+++ b/src/syntax/highlight.rs
@@ -1,5 +1,8 @@
use std::ops::Range;
+use syntect::highlighting::{Highlighter, Style};
+use syntect::parsing::Scope;
+
use super::{NodeKind, RedRef};
/// Provide highlighting categories for the children of a node that fall into a
@@ -19,6 +22,37 @@ where
}
}
+/// Provide syntect highlighting styles for the children of a node.
+pub fn highlight_syntect<F>(node: RedRef, highlighter: &Highlighter, f: &mut F)
+where
+ F: FnMut(Range<usize>, Style),
+{
+ highlight_syntect_impl(node, vec![], highlighter, f)
+}
+
+/// Recursive implementation for returning syntect styles.
+fn highlight_syntect_impl<F>(
+ node: RedRef,
+ scopes: Vec<Scope>,
+ highlighter: &Highlighter,
+ f: &mut F,
+) where
+ F: FnMut(Range<usize>, Style),
+{
+ if node.children().size_hint().0 == 0 {
+ f(node.span().to_range(), highlighter.style_for_stack(&scopes));
+ return;
+ }
+
+ for child in node.children() {
+ let mut scopes = scopes.clone();
+ if let Some(category) = Category::determine(child, node) {
+ scopes.push(Scope::new(category.tm_scope()).unwrap())
+ }
+ highlight_syntect_impl(child, scopes, highlighter, f);
+ }
+}
+
/// The syntax highlighting category of a node.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub enum Category {
@@ -186,6 +220,33 @@ impl Category {
NodeKind::IncludeExpr => None,
}
}
+
+ /// Return the TextMate grammar scope for the given highlighting category.
+ pub fn tm_scope(&self) -> &'static str {
+ match self {
+ Self::Bracket => "punctuation.definition.typst",
+ Self::Punctuation => "punctuation.typst",
+ Self::Comment => "comment.typst",
+ Self::Strong => "markup.bold.typst",
+ Self::Emph => "markup.italic.typst",
+ Self::Raw => "markup.raw.typst",
+ Self::Math => "string.other.math.typst",
+ Self::Heading => "markup.heading.typst",
+ Self::List => "markup.list.typst",
+ Self::Shortcut => "punctuation.shortcut.typst",
+ Self::Escape => "constant.character.escape.content.typst",
+ Self::Keyword => "keyword.typst",
+ Self::Operator => "keyword.operator.typst",
+ Self::None => "constant.language.none.typst",
+ Self::Auto => "constant.language.auto.typst",
+ Self::Bool => "constant.language.boolean.typst",
+ Self::Number => "constant.numeric.typst",
+ Self::String => "string.quoted.double.typst",
+ Self::Function => "entity.name.function.typst",
+ Self::Variable => "variable.parameter.typst",
+ Self::Invalid => "invalid.typst",
+ }
+ }
}
#[cfg(test)]
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-15 23:38:01 +0000