Struct Lowerer 

pub struct Lowerer<'a> {
    pub regexes: &'a RegexCache,
    pub schema: &'a RepoPath,
    pub findings: Vec<Finding>,
    pub rule_ids: HashSet<String>,
    pub lifecycle: Vec<LifecycleDimension>,
    pub types: TypeRegistry,
}

The state of one lowering: the schema it reports on, what it found, and what it has read so far that later keys resolve against.

Fields

regexes: &'a RegexCache

The cache the schema’s regexes compile through.

schema: &'a RepoPath

The schema that every finding is reported on.

findings: Vec<Finding>

The findings so far.

rule_ids: HashSet<String>

The rule-ids declared so far.

lifecycle: Vec<LifecycleDimension>

The lifecycle, which only resolves against.

types: TypeRegistry

The types a template of this schema is written with.

Implementations

impl Lowerer<'_>

pub fn explained( &mut self, node: &Spanned, shapes: &[&str], format_speaks: bool, )

A rule that declares a shape shows an example of it. A regex is a shape and not an instruction, and the example is the one voice a rule has: every failure it raises shows it, and the scaffold writes it. A unit rule bound to a format takes the format’s, where format_speaks; the format of a frontmatter value checks the value and has no example. A rule that only selects, a count and a text state nothing.

pub fn one_voice(&mut self, node: &Spanned)

Guidance says what the example cannot, so the two holding one sentence, or guidance that is one text of an example list, is guidance that says nothing.

pub fn one_voice_in( &mut self, line: usize, guidance: &str, examples: impl IntoIterator<Item = String>, )

As one_voice, for guidance and each of examples, which the format gathers from wherever its scaffold writes them after it.

pub fn check_bounds(&mut self, line: usize, min: usize, max: Option<usize>)

A rule’s min is at most its max.

impl Lowerer<'_>

pub fn shape(&mut self, node: &Spanned) -> Option<Shape>

The shape node declares, a failure reported on the schema.

pub fn check_key( &mut self, line: usize, key: &str, shape: Option<&Shape>, format: Option<&Format>, )

A key names a hole or a named group of shape, or of every shape of the format the rule binds.

pub fn frontmatter_constraint( &mut self, node: &Spanned, key: &str, ) -> FrontmatterConstraint

Grammar frontmatter-constraint, for the key key.

impl<'a> Lowerer<'a>

pub fn new( regexes: &'a RegexCache, schema: &'a RepoPath, types: TypeRegistry, ) -> Self

A lowering of a schema at schema, whose templates see types.

pub fn fail( &mut self, line: usize, criterion: &'static str, message: impl Into<String>, )

A finding on the schema, at line, that breaks criterion.

pub fn fail_with(&mut self, line: usize, problem: Problem)

A finding on the schema, at line, for problem.

pub fn regex(&self, node: &Spanned, key: &str) -> Option<Regex>

The regex at key of node, checked where the grammar was read.

pub fn prohibitions(&self, node: &Spanned) -> Vec<Prohibition>

The prohibited-patterns of node.

pub fn only(&mut self, node: &Spanned) -> Only

The only of a rule, resolved against the lifecycle.

pub fn common(&mut self, node: &Spanned) -> RuleCommon

The keys every rule map carries: severity, and only.

pub fn lower_core( &mut self, yaml: &Spanned, formats: FormatRegistry, ) -> CoreSchema

The keys of the core grammar of a schema: the lifecycle first, which only resolves against, then the frontmatter, the bans and the examples. formats is the registry the schema sees.