Struct ultron_syntaxes_themes::SyntaxSet [−][src]
pub struct SyntaxSet { /* fields omitted */ }
Expand description
A syntax set holds multiple syntaxes that have been linked together.
Use a SyntaxSetBuilder
to load syntax definitions and build a syntax set.
After building, the syntax set is immutable and can no longer be modified, but you can convert
it back into a builder by using the into_builder
method.
Implementations
Instantiates a new syntax set from a binary dump of Sublime Text’s default open source syntax definitions.
These dumps are included in this library’s binary for convenience.
This method loads the version for parsing line strings with no \n
characters at the end.
If you’re able to efficiently include newlines at the end of strings, use
load_defaults_newlines
since it works better. See SyntaxSetBuilder::add_from_folder
for more info on this issue.
This is the recommended way of creating a syntax set for non-advanced use cases. It is also significantly faster than loading the YAML files.
Note that you can load additional syntaxes after doing this. If you want you can even use the fact that SyntaxDefinitions are serializable with the bincode crate to cache dumps of additional syntaxes yourself.
Same as load_defaults_nonewlines
but for parsing line strings with newlines at the end.
These are separate methods because thanks to linker garbage collection, only the serialized dumps for the method(s) you call will be included in the binary (each is ~200kb for now).
Convenience constructor for creating a builder, then loading syntax definitions from a folder and then building the syntax set.
Note that this uses lines_include_newline
set to false
, see the
add_from_folder
method docs on SyntaxSetBuilder
for an explanation
as to why this might not be the best.
The list of syntaxes in the set
Finds a syntax by its default scope, for example source.regexp
finds the regex syntax.
This and all similar methods below do a linear search of syntaxes, this should be fast because there aren’t many syntaxes, but don’t think you can call it a bajillion times per second.
Searches for a syntax first by extension and then by case-insensitive name
This is useful for things like Github-flavoured-markdown code block highlighting where all you have to go on is a short token given by the user
Try to find the syntax for a file based on its first line
This uses regexes that come with some sublime syntax grammars for matching things like
shebangs and mode lines like -*- Mode: C -*-
Searches for a syntax by it’s original file path when it was first loaded from disk
This is primarily useful for syntax tests. Some may specify a
Packages/PackageName/SyntaxName.sublime-syntax
path, and others may just have
SyntaxName.sublime-syntax
. This caters for these by matching the end of the path of the
loaded syntax definition files
pub fn find_syntax_for_file<P>(
&self,
path_obj: P
) -> Result<Option<&SyntaxReference>, Error> where
P: AsRef<Path>,
pub fn find_syntax_for_file<P>(
&self,
path_obj: P
) -> Result<Option<&SyntaxReference>, Error> where
P: AsRef<Path>,
Convenience method that tries to find the syntax for a file path, first by extension/name and then by first line of the file if that doesn’t work.
May IO Error because it sometimes tries to read the first line of the file.
Examples
When determining how to highlight a file, use this in combination with a fallback to plain text:
use syntect::parsing::SyntaxSet;
let ss = SyntaxSet::load_defaults_newlines();
let syntax = ss.find_syntax_for_file("testdata/highlight_test.erb")
.unwrap() // for IO errors, you may want to use try!() or another plain text fallback
.unwrap_or_else(|| ss.find_syntax_plain_text());
assert_eq!(syntax.name, "HTML (Rails)");
Finds a syntax for plain text, which usually has no highlighting rules.
This is good as a fallback when you can’t find another syntax but you still want to use the same highlighting pipeline code.
This syntax should always be present, if not this method will panic. If the way you load
syntaxes doesn’t create one, use add_plain_text_syntax
.
Examples
use syntect::parsing::SyntaxSetBuilder;
let mut builder = SyntaxSetBuilder::new();
builder.add_plain_text_syntax();
let ss = builder.build();
let syntax = ss.find_syntax_by_token("rs").unwrap_or_else(|| ss.find_syntax_plain_text());
assert_eq!(syntax.name, "Plain Text");
Converts this syntax set into a builder so that more syntaxes can be added to it.
Note that newly added syntaxes can have references to existing syntaxes in the set, but not the other way around.
Trait Implementations
pub fn deserialize<__D>(
__deserializer: __D
) -> Result<SyntaxSet, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
pub fn deserialize<__D>(
__deserializer: __D
) -> Result<SyntaxSet, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
pub fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
pub fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
Serialize this value into the given Serde serializer. Read more
Auto Trait Implementations
impl !RefUnwindSafe for SyntaxSet
impl UnwindSafe for SyntaxSet
Blanket Implementations
Mutably borrows from an owned value. Read more