Struct Specificity 

pub struct Specificity(/* private fields */);

Specificity.

Specificity is an ordering and tie-breaking concept borrowed from CSS, where more specific selectors take precedence over less specific ones. Specificity is computable for the likes of Expression, Term, Operand, Id, Selector, and Glob.

Representation

Specificity is represented as a 4-tuple (a, b, c, l), which is compared in lexicographic order, meaning that components are compared in sequence:

• a – number of segments with literals only, e.g. src, main.rs.
• b – number of segments with single-wildcards, e.g. *, ?, [abc].
• c – number of segments with double-wildcards, compared in reverse.
• l – number of literals across all segments.

Atoms

In a Segment, atoms are combined with Specificity::min_sum_len - the structural component a, b, or c is assigned by taking the minimum across all atoms in the segment, whereas the length component l receives the sum across all atoms in the segment.

Ids and selectors

The specificity of an Id or Selector is computed by summing the specificities of its components, where the specificity of each component is computed individually and then combined with Specificity::sum. Empty components receive the Specificity::default, which is (0, 0, 0, 0).

zrs:{git,file}:::{docs}:index.md: # (3, 0, 0, 15)
zrs::::docs:{index,about}.md:     # (2, 0, 0, 12)
zrs:::::index.{md,rst}:           # (1, 0, 0, 8)
zrs:::::{*}:                      # (0, 1, 0, 0)

Expressions

An Expression is a combination of multiple Id and Selector terms, with its specificity computed according to its Operator:

• Expression::any: takes the minimum. The expression is as specific as its least specific operand, since any operand can match.

• Expression::all: sums specificities. The expression is as specific as the combination of all its operands, since all operands must match.

• Expression::not: contributes nothing, i.e., (0, 0, 0, 0), since a negation is a guard that filters matches but does not select them.

Alternate groups, e.g. {jpg,png}, are equivalent to Expression::any at the Atom level and follow the same rules.

Examples

use zrx_id::specificity::ToSpecificity;
use zrx_id::{selector, Expression};

// Create expression and compute specificity
let expr = Expression::any(|expr| {
    expr.with(selector!(location = "**/*.jpg")?)?
        .with(selector!(location = "**/*.png")?)
})?;
assert_eq!(expr.to_specificity(), (0, 1, 1, 4).into());

Trait Implementations

impl Clone for Specificity

fn clone(&self) -> Specificity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Specificity

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

Formats the value using the given formatter.

impl Default for Specificity

fn default() -> Specificity

Returns the “default value” for a type.

impl From<(u16, u16, u16, u16)> for Specificity

fn from((a, b, c, l): (u16, u16, u16, u16)) -> Self

Creates a specificity from a tuple.

impl<T> From<T> for Specificity

where T: ToSpecificity,

fn from(value: T) -> Self

Creates a specificity from a value.

impl Ord for Specificity

fn cmp(&self, other: &Self) -> Ordering

Orders two specificities.

Examples

use zrx_id::selector;
use zrx_id::specificity::ToSpecificity;

// Create and compare selectors by specificity
let a = selector!(location = "**/*.md")?;
let b = selector!(location = "*.md")?;
assert!(a.to_specificity() < b.to_specificity());

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Specificity

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Specificity

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

Orders two specificities.

Examples

use zrx_id::selector;
use zrx_id::specificity::ToSpecificity;

// Create and compare selectors by specificity
let a = selector!(location = "**/*.md")?;
let b = selector!(location = "*.md")?;
assert!(a.to_specificity() < b.to_specificity());

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Specificity

impl Eq for Specificity

impl StructuralPartialEq for Specificity