curlpipe / synoptic Goto Github PK

Thanks for the library, it saves so much time getting started! I am using your library in a way you did not plan for, but allow.
I am using FLTK, and the backend is a buffer full of single characters.

fn example() {
    // test
}

Here is the FLTK version of the github highlighting above MOL

BBACCCCCCCAAAA
AAAAEEEEEEE
A

I currently use something like this:

let mut output:string = String::new();
//snip
for token in row {
    match token {
        Token::Start(kind) => {
            highlighting = true;
            match kind.as_str() {
                "keywords" => character = "B".to_string(),
                "comments" =>  character = "E".to_string(),
                //etc..
                _=> character = "A".to_string(),
            }
            output.push_str(character.as_str());// <-- here?
        }
        Token::Text(txt) => {
            let len = txt.chars().count();
            let ch = character.as_str();
            // `string.len()` == `text.len()`
            let string = ch.repeat(len);
            output.push_str(string.as_str());
        },
        Token::End(_) =>  {
            //output.push_str(character.as_str()); // <-- OR here?
            highlighting = false;
            character = "A".to_string();
        },
    }
}

Just not sure how to get it to be the correct length of the styling.
non-highlighted characters creep in, but I also end up with an incorrect len() if I do not push a some character to the output string.

That said, your library is quite intuitive and I really enjoy the thought you put into making it flexible!

In line 45 of your code example, it should be changed to Token::Start(kind) => match kind.as_str() {. The change is from match *kind to kind.as_str().

Include pre-defined highlighters.

• Rust
• Python
• Java
• Javascript
• C#
• PHP
• C
• C++
• R
• Objective-C
• Swift
• TypeScript
• CSS
• HTML
• MD
• SQL
• MATLAB
• Perl
• Assembly
• Go
• Ruby

I could potentially look at a concurrent highlighting solution, where single line tokens, multiline tokens and bounded tokens are all calculated in parallel, hopefully that would speed up performance significantly.