Struct syntect_assets::assets::HighlightingAssets

pub struct HighlightingAssets { /* private fields */ }

Implementations

impl HighlightingAssets

pub fn default_theme() -> &'static str

The default theme.

Windows and Linux

Windows and most Linux distributions has a dark terminal theme by default. On these platforms, this function always returns a theme that looks good on a dark background.

macOS

On macOS the default terminal background is light, but it is common that Dark Mode is active, which makes the terminal background dark. On this platform, the default theme depends on

defaults read -globalDomain AppleInterfaceStyle

To avoid the overhead of the check on macOS, simply specify a theme explicitly via --theme, BAT_THEME, or ~/.config/syntect-assets.

See https://github.com/sharkdp/bat/issues/1746 and https://github.com/sharkdp/bat/issues/1928 for more context.

pub fn from_cache(cache_path: &Path) -> Result<Self, Error>

pub fn from_binary() -> Self

Examples found in repository

examples/list_syntaxes_and_themes.rs (line 5)

fn main() {
    let assets = HighlightingAssets::from_binary();

    println!("Syntaxes:");
    for syntax in assets.get_syntaxes().unwrap() {
        println!("- {} ({})", syntax.name, syntax.file_extensions.join(", "));
    }

    println!();

    println!("Themes:");
    for theme in assets.themes() {
        println!("- {}", theme);
    }
}

examples/line.rs (line 8)

fn main() {
    // Load these once at the start of your program
    let assets = HighlightingAssets::from_binary();
    let ss = assets.get_syntax_set().unwrap();
    let syntax = ss.find_syntax_by_extension("rs").unwrap();
    let theme = assets.get_theme("OneHalfDark");

    let mut h = HighlightLines::new(syntax, theme);
    let s = "pub struct Wow { hi: u64 }\nfn blah() -> u64 {}\n";
    for line in LinesWithEndings::from(s) { // LinesWithEndings enables use of newlines mode
        let ranges: Vec<(Style, &str)> = h.highlight_line(line, ss).unwrap();
        let escaped = as_24_bit_terminal_escaped(&ranges[..], true);
        print!("{}", escaped);
    }
}

examples/simple.rs (line 10)

fn main() {
    let assets = HighlightingAssets::from_binary();

    let ss = assets.get_syntax_set().unwrap();
    let theme = assets.get_theme("OneHalfDark");

    let mut highlighter = HighlightFile::new(file!(), ss, theme).unwrap();
    let mut line = String::new();
    while highlighter.reader.read_line(&mut line).unwrap() > 0 {
        {
            let regions: Vec<(Style, &str)> = highlighter.highlight_lines.highlight_line(&line, &ss).unwrap();
            print!("{}", as_24_bit_terminal_escaped(&regions[..], true));
        } // until NLL this scope is needed so we can clear the buffer after
        line.clear(); // read_line appends so we need to clear between lines
    }
}

pub fn set_fallback_theme(&mut self, theme: &'static str)

pub fn get_syntax_set(&self) -> Result<&SyntaxSet, Error>

Return the collection of syntect syntax definitions.

Examples found in repository

examples/line.rs (line 9)

fn main() {
    // Load these once at the start of your program
    let assets = HighlightingAssets::from_binary();
    let ss = assets.get_syntax_set().unwrap();
    let syntax = ss.find_syntax_by_extension("rs").unwrap();
    let theme = assets.get_theme("OneHalfDark");

    let mut h = HighlightLines::new(syntax, theme);
    let s = "pub struct Wow { hi: u64 }\nfn blah() -> u64 {}\n";
    for line in LinesWithEndings::from(s) { // LinesWithEndings enables use of newlines mode
        let ranges: Vec<(Style, &str)> = h.highlight_line(line, ss).unwrap();
        let escaped = as_24_bit_terminal_escaped(&ranges[..], true);
        print!("{}", escaped);
    }
}

examples/simple.rs (line 12)

fn main() {
    let assets = HighlightingAssets::from_binary();

    let ss = assets.get_syntax_set().unwrap();
    let theme = assets.get_theme("OneHalfDark");

    let mut highlighter = HighlightFile::new(file!(), ss, theme).unwrap();
    let mut line = String::new();
    while highlighter.reader.read_line(&mut line).unwrap() > 0 {
        {
            let regions: Vec<(Style, &str)> = highlighter.highlight_lines.highlight_line(&line, &ss).unwrap();
            print!("{}", as_24_bit_terminal_escaped(&regions[..], true));
        } // until NLL this scope is needed so we can clear the buffer after
        line.clear(); // read_line appends so we need to clear between lines
    }
}

pub fn get_syntaxes(&self) -> Result<&[SyntaxReference], Error>

Examples found in repository

examples/list_syntaxes_and_themes.rs (line 8)

fn main() {
    let assets = HighlightingAssets::from_binary();

    println!("Syntaxes:");
    for syntax in assets.get_syntaxes().unwrap() {
        println!("- {} ({})", syntax.name, syntax.file_extensions.join(", "));
    }

    println!();

    println!("Themes:");
    for theme in assets.themes() {
        println!("- {}", theme);
    }
}

pub fn themes(&self) -> impl Iterator<Item = &str>

Examples found in repository

examples/list_syntaxes_and_themes.rs (line 15)

fn main() {
    let assets = HighlightingAssets::from_binary();

    println!("Syntaxes:");
    for syntax in assets.get_syntaxes().unwrap() {
        println!("- {} ({})", syntax.name, syntax.file_extensions.join(", "));
    }

    println!();

    println!("Themes:");
    for theme in assets.themes() {
        println!("- {}", theme);
    }
}

pub fn get_syntax_for_path( &self, path: impl AsRef<Path>, mapping: &SyntaxMapping<'_> ) -> Result<SyntaxReferenceInSet<'_>, Error>

Detect the syntax based on, in order:

1. Syntax mappings with [MappingTarget::MapTo] and [MappingTarget::MapToUnknown] (e.g. /etc/profile -> Bourne Again Shell (bash))
2. The file name (e.g. Dockerfile)
3. Syntax mappings with [MappingTarget::MapExtensionToUnknown] (e.g. *.conf)
4. The file name extension (e.g. .rs)

When detecting syntax based on syntax mappings, the full path is taken into account. When detecting syntax based on file name, no regard is taken to the path of the file. Only the file name itself matters. When detecting syntax based on file name extension, only the file name extension itself matters.

Returns [Error::UndetectedSyntax] if it was not possible detect syntax based on path/file name/extension (or if the path was mapped to [MappingTarget::MapToUnknown] or [MappingTarget::MapExtensionToUnknown]). In this case it is appropriate to fall back to other methods to detect syntax. Such as using the contents of the first line of the file.

Returns [Error::UnknownSyntax] if a syntax mapping exist, but the mapped syntax does not exist.

pub fn get_theme(&self, theme: &str) -> &Theme

Look up a syntect theme by name.

Examples found in repository

examples/line.rs (line 11)

fn main() {
    // Load these once at the start of your program
    let assets = HighlightingAssets::from_binary();
    let ss = assets.get_syntax_set().unwrap();
    let syntax = ss.find_syntax_by_extension("rs").unwrap();
    let theme = assets.get_theme("OneHalfDark");

    let mut h = HighlightLines::new(syntax, theme);
    let s = "pub struct Wow { hi: u64 }\nfn blah() -> u64 {}\n";
    for line in LinesWithEndings::from(s) { // LinesWithEndings enables use of newlines mode
        let ranges: Vec<(Style, &str)> = h.highlight_line(line, ss).unwrap();
        let escaped = as_24_bit_terminal_escaped(&ranges[..], true);
        print!("{}", escaped);
    }
}

examples/simple.rs (line 13)

fn main() {
    let assets = HighlightingAssets::from_binary();

    let ss = assets.get_syntax_set().unwrap();
    let theme = assets.get_theme("OneHalfDark");

    let mut highlighter = HighlightFile::new(file!(), ss, theme).unwrap();
    let mut line = String::new();
    while highlighter.reader.read_line(&mut line).unwrap() > 0 {
        {
            let regions: Vec<(Style, &str)> = highlighter.highlight_lines.highlight_line(&line, &ss).unwrap();
            print!("{}", as_24_bit_terminal_escaped(&regions[..], true));
        } // until NLL this scope is needed so we can clear the buffer after
        line.clear(); // read_line appends so we need to clear between lines
    }
}

Trait Implementations

impl Debug for HighlightingAssets

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.