Struct syntect::parsing::ScopeStack

pub struct ScopeStack {
    pub scopes: Vec<Scope>,
    /* private fields */
}

A stack/sequence of scopes for representing hierarchies for a given token of text

This is also used within ScopeSelectors.

In Sublime Text, the scope stack at a given point can be seen by pressing ctrl+shift+p. Also see the TextMate docs.

Example for a JS string inside a script tag in a Rails ERB file: text.html.ruby text.html.basic source.js.embedded.html string.quoted.double.js

Fields

scopes: Vec<Scope>

Implementations

impl ScopeStack

pub fn new() -> ScopeStack

pub fn from_vec(v: Vec<Scope>) -> ScopeStack

Note: creating a ScopeStack with this doesn’t contain information on what to do when clear_scopes contexts end.

pub fn push(&mut self, s: Scope)

pub fn pop(&mut self)

pub fn apply(&mut self, op: &ScopeStackOp) -> Result<(), ScopeError>

Modifies this stack according to the operation given

Use this to create a stack from a Vec of changes given by the parser.

pub fn apply_with_hook<F>( &mut self, op: &ScopeStackOp, hook: F ) -> Result<(), ScopeError>where F: FnMut(BasicScopeStackOp, &[Scope]),

Modifies this stack according to the operation given and calls the hook for each basic operation.

Like apply but calls hook for every basic modification (as defined by BasicScopeStackOp). Use this to do things only when the scope stack changes.

pub fn debug_print(&self, repo: &ScopeRepository)

Prints out each scope in the stack separated by spaces and then a newline. Top of the stack at the end.

pub fn bottom_n(&self, n: usize) -> &[Scope]

Returns the bottom n elements of the stack.

Equivalent to &scopes[0..n] on a Vec

pub fn as_slice(&self) -> &[Scope]

Return a slice of the scopes in this stack

pub fn len(&self) -> usize

Return the height/length of this stack

pub fn is_empty(&self) -> bool

pub fn does_match(&self, stack: &[Scope]) -> Option<MatchPower>

Checks if this stack as a selector matches the given stack, returning the match score if so

Higher match scores indicate stronger matches. Scores are ordered according to the rules found at https://manual.macromates.com/en/scope_selectors

It accomplishes this ordering through some floating point math ensuring deeper and longer matches matter. Unfortunately it is only guaranteed to return perfectly accurate results up to stack depths of 17, but it should be reasonably good even afterwards. TextMate has the exact same limitation, dunno about Sublime Text.

Examples

use syntect::parsing::{ScopeStack, MatchPower};
use std::str::FromStr;
assert_eq!(ScopeStack::from_str("a.b c e.f").unwrap()
    .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
    Some(MatchPower(0o212u64 as f64)));
assert_eq!(ScopeStack::from_str("a c.d.e").unwrap()
    .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
    None);

Trait Implementations

impl Clone for ScopeStack

fn clone(&self) -> ScopeStack

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScopeStack

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

Formats the value using the given formatter.

impl Default for ScopeStack

fn default() -> ScopeStack

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ScopeStack

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ScopeStack

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

Formats the value using the given formatter.

impl FromStr for ScopeStack

fn from_str(s: &str) -> Result<ScopeStack, ParseScopeError>

Parses a scope stack from a whitespace separated list of scopes.

type Err = ParseScopeError

The associated error which can be returned from parsing.

impl PartialEq<ScopeStack> for ScopeStack

fn eq(&self, other: &ScopeStack) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ScopeStack

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ScopeStack

impl StructuralEq for ScopeStack

impl StructuralPartialEq for ScopeStack