feat: initial commit

1 files changed, 455 insertions, 0 deletions

diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..f203289
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,455 @@
+//! A custom syntax highlighter for iced.
+//!
+//! It uses the colors from your app's Theme, based on the current [`Scope`]
+use iced_core::font::Font;
+use iced_core::text::highlighter::{self, Format};
+use iced_core::Theme;
+
+use once_cell::sync::Lazy;
+use std::collections::HashSet;
+use std::ops::Range;
+use std::str::FromStr;
+use syntect::highlighting;
+use syntect::parsing;
+
+static SYNTAXES: Lazy<parsing::SyntaxSet> = Lazy::new(parsing::SyntaxSet::load_defaults_nonewlines);
+
+const LINES_PER_SNAPSHOT: usize = 50;
+
+type ScopeSelectorsResult =
+    core::result::Result<highlighting::ScopeSelectors, parsing::ParseScopeError>;
+
+/// A syntax highlighter.
+#[derive(Debug)]
+pub struct Highlighter {
+    syntax: &'static parsing::SyntaxReference,
+    custom_scopes: Vec<Scope>,
+    style: Option<fn(&Theme, Scope) -> Format<Font>>,
+    caches: Vec<(parsing::ParseState, parsing::ScopeStack)>,
+    current_line: usize,
+}
+
+impl highlighter::Highlighter for Highlighter {
+    type Settings = Settings;
+    type Highlight = Highlight;
+
+    type Iterator<'a> = Box<dyn Iterator<Item = (Range<usize>, Self::Highlight)> + 'a>;
+
+    fn new(settings: &Self::Settings) -> Self {
+        let syntax = SYNTAXES
+            .find_syntax_by_token(&settings.token)
+            .unwrap_or_else(|| SYNTAXES.find_syntax_plain_text());
+
+        let style = settings.style.clone();
+        let custom_scopes = settings.custom_scopes.clone();
+
+        let parser = parsing::ParseState::new(syntax);
+        let stack = parsing::ScopeStack::new();
+
+        Highlighter {
+            syntax,
+            custom_scopes,
+            style,
+            caches: vec![(parser, stack)],
+            current_line: 0,
+        }
+    }
+
+    fn update(&mut self, new_settings: &Self::Settings) {
+        self.syntax = SYNTAXES
+            .find_syntax_by_token(&new_settings.token)
+            .unwrap_or_else(|| SYNTAXES.find_syntax_plain_text());
+
+        self.custom_scopes = new_settings.custom_scopes.clone();
+
+        self.style = new_settings.style.clone();
+
+        // Restart the highlighter
+        self.change_line(0);
+    }
+
+    fn change_line(&mut self, line: usize) {
+        let snapshot = line / LINES_PER_SNAPSHOT;
+
+        if snapshot <= self.caches.len() {
+            self.caches.truncate(snapshot);
+            self.current_line = snapshot * LINES_PER_SNAPSHOT;
+        } else {
+            self.caches.truncate(1);
+            self.current_line = 0;
+        }
+
+        let (parser, stack) = self.caches.last().cloned().unwrap_or_else(|| {
+            (
+                parsing::ParseState::new(self.syntax),
+                parsing::ScopeStack::new(),
+            )
+        });
+
+        self.caches.push((parser, stack));
+    }
+
+    fn highlight_line(&mut self, line: &str) -> Self::Iterator<'_> {
+        if self.current_line / LINES_PER_SNAPSHOT >= self.caches.len() {
+            let (parser, stack) = self.caches.last().expect("Caches must not be empty");
+
+            self.caches.push((parser.clone(), stack.clone()));
+        }
+
+        self.current_line += 1;
+
+        let (parser, stack) = self.caches.last_mut().expect("Caches must not be empty");
+
+        let ops = parser.parse_line(line, &SYNTAXES).unwrap_or_default();
+
+        let style = &self.style;
+        let custom_scopes = &self.custom_scopes;
+
+        Box::new(
+            ScopeRangeIterator {
+                ops,
+                line_length: line.len(),
+                index: 0,
+                last_str_index: 0,
+            }
+            .filter_map(move |(range, scope)| {
+                let _ = stack.apply(&scope);
+
+                if range.is_empty() {
+                    None
+                } else {
+                    Some((
+                        range,
+                        Highlight {
+                            scope: Scope::from_scopestack(stack.clone(), custom_scopes.clone()),
+                            style: style.clone(),
+                        },
+                    ))
+                }
+            }),
+        )
+    }
+
+    fn current_line(&self) -> usize {
+        self.current_line
+    }
+}
+
+/// The settings of a [`Highlighter`].
+#[derive(Debug, Clone, PartialEq)]
+pub struct Settings {
+    /// Custom scopes used for parsing the code.
+    ///
+    /// It extends [`Scope::ALL`].
+    pub custom_scopes: Vec<Scope>,
+
+    /// The styling method of the [`Highlighter`].
+    ///
+    /// It dictates how text matching a certain scope will be highlighted.
+    /// If set to None, [`default_style`] will be used.
+    ///
+    /// [`default_style`]: Highlight::default_style
+    pub style: Option<fn(&Theme, Scope) -> Format<Font>>,
+
+    /// The extension of the file or the name of the language to highlight.
+    ///
+    /// The [`Highlighter`] will use the token to automatically determine the grammar to use for highlighting.
+    pub token: String,
+}
+
+impl Settings {
+    /// Creates a new [`Settings`] struct with the given values.
+    pub fn new(
+        custom_scopes: Vec<Scope>,
+        style: Option<fn(&Theme, Scope) -> Format<Font>>,
+        token: impl Into<String>,
+    ) -> Self {
+        Self {
+            custom_scopes,
+            style,
+            token: token.into(),
+        }
+    }
+}
+
+/// A highlight produced by a [`Highlighter`].
+#[derive(Debug)]
+pub struct Highlight {
+    scope: Scope,
+    style: Option<fn(&Theme, Scope) -> Format<Font>>,
+}
+
+impl Highlight {
+    /// Returns the [`Format`] of the [`Highlight`].
+    ///
+    /// It contains both the [`color`] and the [`font`].
+    ///
+    /// [`color`]: iced_core::Color
+    /// [`font`]: iced_core::Font
+    pub fn to_format(&self, theme: &Theme) -> Format<Font> {
+        match self.style {
+            Some(style) => style(theme, self.scope.clone()),
+            None => Self::default_style(theme, self.scope.clone()),
+        }
+    }
+
+    /// The defalt styling function of a [`Highlight`].
+    pub fn default_style(theme: &Theme, scope: Scope) -> Format<Font> {
+        let color = match scope {
+            Scope::Comment | Scope::TagStart => theme.extended_palette().background.weak.color,
+            Scope::String | Scope::RegExp | Scope::QuotedString => {
+                theme.extended_palette().primary.base.color
+            }
+            Scope::EscapeSequence | Scope::SupportConstruct | Scope::Continuation => {
+                theme.extended_palette().danger.base.color
+            }
+            Scope::Number => theme.extended_palette().secondary.weak.color,
+            Scope::Variable | Scope::VariableStart | Scope::TagName | Scope::Brackets => {
+                theme.extended_palette().primary.weak.color
+            }
+            Scope::VariableFunction | Scope::FunctionName => {
+                theme.extended_palette().success.base.color
+            }
+            Scope::Keyword | Scope::KeywordOperator | Scope::Operator => {
+                theme.extended_palette().background.strong.color
+            }
+            Scope::KeywordOther => theme.extended_palette().danger.strong.color,
+            Scope::Storage
+            | Scope::StorageModifier
+            | Scope::StorageType
+            | Scope::Class
+            | Scope::LibraryClass
+            | Scope::LibraryFunction => theme.extended_palette().success.base.color,
+            Scope::QuotedSingle => theme.palette().text,
+            Scope::BuiltinConstant | Scope::UserDefinedConstant => {
+                theme.extended_palette().danger.base.color
+            }
+            Scope::Invalid => theme.extended_palette().danger.weak.color,
+            Scope::Special => theme.extended_palette().danger.strong.color,
+            Scope::Import => theme.extended_palette().primary.weak.color,
+            Scope::Exception => theme.extended_palette().danger.base.color,
+            Scope::Parantheses | Scope::Braces => theme.extended_palette().background.strong.color,
+            Scope::Other | Scope::Custom { .. } => theme.extended_palette().primary.strong.color,
+        };
+
+        Format {
+            color: Some(color),
+            font: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default, Hash)]
+pub enum Scope {
+    Comment,
+    String,
+    RegExp,
+    EscapeSequence,
+    Number,
+    Variable,
+    VariableFunction,
+    Keyword,
+    KeywordOperator,
+    KeywordOther,
+    Import,
+    Operator,
+    Storage,
+    StorageModifier,
+    Class,
+    LibraryClass,
+    FunctionName,
+    VariableStart,
+    BuiltinConstant,
+    UserDefinedConstant,
+    SupportConstruct,
+    TagName,
+    TagStart,
+    LibraryFunction,
+    Continuation,
+    StorageType,
+    Exception,
+    Special,
+    Invalid,
+    QuotedString,
+    QuotedSingle,
+    Brackets,
+    Parantheses,
+    Braces,
+    #[default]
+    Other,
+    /// A custom scope.
+    Custom {
+        /// The name of the scope, letting you identify it in match statements easily.
+        name: String,
+        /// A series of selectors separated by commas or pipes.
+        scope_string: String,
+    },
+}
+
+impl Scope {
+    /// A list with all the defined scopes.
+    pub const ALL: &'static [Self] = &[
+        Self::Comment,
+        Self::String,
+        Self::RegExp,
+        Self::EscapeSequence,
+        Self::Number,
+        Self::Variable,
+        Self::VariableFunction,
+        Self::Keyword,
+        Self::KeywordOperator,
+        Self::KeywordOther,
+        Self::Import,
+        Self::Operator,
+        Self::Storage,
+        Self::StorageModifier,
+        Self::Class,
+        Self::LibraryClass,
+        Self::FunctionName,
+        Self::VariableStart,
+        Self::BuiltinConstant,
+        Self::UserDefinedConstant,
+        Self::SupportConstruct,
+        Self::TagName,
+        Self::TagStart,
+        Self::LibraryFunction,
+        Self::Continuation,
+        Self::StorageType,
+        Self::Exception,
+        Self::Special,
+        Self::Invalid,
+        Self::QuotedString,
+        Self::QuotedSingle,
+        Self::Brackets,
+        Self::Parantheses,
+        Self::Braces,
+    ];
+
+    /// Creates a new custom [`Scope`].
+    pub fn custom(name: impl Into<String>, scope_string: impl Into<String>) -> Self {
+        Self::Custom {
+            name: name.into(),
+            scope_string: scope_string.into(),
+        }
+    }
+
+    /// Retuns the scope string of the [`Scope`].
+    pub fn scope_str(&self) -> &str {
+        match self {
+            Self::Comment => "comment, meta.documentation",
+            Self::String => "string",
+            Self::RegExp => "string.regexp",
+            Self::EscapeSequence => "constant.character.escape",
+            Self::Number => "constant.numeric",
+            Self::Variable => "variable",
+            Self::VariableFunction => "variable.function",
+            Self::Keyword => "keyword",
+            Self::KeywordOperator => "keyword.operator",
+            Self::KeywordOther => "keyword.other",
+            Self::Import => "meta.import keyword, keyword.control.import, keyword.control.import.from, keyword.other.import, keyword.control.at-rule.include, keyword.control.at-rule.import",
+            Self::Operator => "keyword.operator.comparison, keyword.operator.assignment, keyword.operator.arithmetic",
+            Self::Storage => "storage",
+            Self::StorageModifier => "storage.modifier",
+            Self::Class => "keyword.control.class, meta.class, entity.name.class, entity.name.type.class",
+            Self::LibraryClass => "support, support.type, support.class",
+            Self::FunctionName => "entity.name.function",
+            Self::VariableStart => "punctuation.definition.variable",
+            Self::BuiltinConstant => "constant.language, meta.preprocessor",
+            Self::UserDefinedConstant => "constant.character, constant.other",
+            Self::SupportConstruct => "support.function.construct, keyword.other.new",
+            Self::TagName => "entity.name.tag",
+            Self::TagStart => "punctuation.definition.tag.html, punctuation.definition.tag.begin, punctuation.definition.tag.end",
+            Self::LibraryFunction => "support.function",
+            Self::Continuation => "punctuation.separator.continuation",
+            Self::StorageType => "storage.type",
+            Self::Exception => "support.type.exception",
+            Self::Special => "keyword.other.special-method",
+            Self::Invalid => "invalid",
+            Self::QuotedString => "string.quoted.double, string.quoted.single",
+            Self::QuotedSingle => "punctuation.definition.string.begin, punctuation.definition.string.end",
+            Self::Brackets => "meta.brace.squares",
+            Self::Parantheses => "meta.brace.round, punctuation.definition.parameters.begin, punctuation.definition.parameters.end",
+            Self::Braces => "meta.brace.curly",
+            Self::Other => "",
+            Self::Custom {scope_string,..} => &scope_string
+        }
+    }
+
+    fn from_scopestack(stack: parsing::ScopeStack, custom_scopes: Vec<Self>) -> Self {
+        let scopes: Vec<Self>;
+
+        if custom_scopes.len() > 0 {
+            let mut hashset: HashSet<Self> = (*Self::ALL).to_vec().into_iter().collect();
+            hashset.extend(custom_scopes);
+            scopes = hashset.into_iter().collect();
+        } else {
+            scopes = Self::ALL.to_vec();
+        }
+
+        let selectors: Vec<(Self, highlighting::ScopeSelectors)> = scopes
+            .iter()
+            .filter_map(|scope| {
+                let selector: ScopeSelectorsResult = scope.clone().into();
+                match selector {
+                    Ok(selector) => Some((scope.clone(), selector)),
+                    Err(_) => None,
+                }
+            })
+            .collect();
+
+        let mut matching_scopes: Vec<(parsing::MatchPower, Self)> = selectors
+            .iter()
+            .filter_map(|(scope, selector)| {
+                selector
+                    .does_match(&stack.scopes)
+                    .map(|score| (score, scope.clone()))
+            })
+            .collect();
+        matching_scopes.sort_by_key(|&(score, _)| score);
+        match matching_scopes.last() {
+            Some(scope) => scope.1.clone(),
+            None => Self::Other,
+        }
+    }
+}
+
+impl From<Scope> for Result<highlighting::ScopeSelectors, parsing::ParseScopeError> {
+    fn from(value: Scope) -> Self {
+        highlighting::ScopeSelectors::from_str(value.scope_str())
+    }
+}
+
+struct ScopeRangeIterator {
+    ops: Vec<(usize, parsing::ScopeStackOp)>,
+    line_length: usize,
+    index: usize,
+    last_str_index: usize,
+}
+
+impl Iterator for ScopeRangeIterator {
+    type Item = (std::ops::Range<usize>, parsing::ScopeStackOp);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index > self.ops.len() {
+            return None;
+        }
+
+        let next_str_i = if self.index == self.ops.len() {
+            self.line_length
+        } else {
+            self.ops[self.index].0
+        };
+
+        let range = self.last_str_index..next_str_i;
+        self.last_str_index = next_str_i;
+
+        let op = if self.index == 0 {
+            parsing::ScopeStackOp::Noop
+        } else {
+            self.ops[self.index - 1].1.clone()
+        };
+
+        self.index += 1;
+        Some((range, op))
+    }
+}