Struct StepPattern 

pub struct StepPattern { /* private fields */ }

Pattern text used to match a step at runtime.

Implementations

impl StepPattern

pub const fn new(value: &'static str) -> Self

Create a new pattern wrapper from a string literal.

pub const fn as_str(&self) -> &'static str

Access the underlying pattern string.

pub fn compile(&self) -> Result<(), StepPatternError>

Compile the pattern into a regular expression, caching the result.

Errors

Returns an error if the pattern contains invalid placeholders or the generated regex fails to compile.

Notes

• This operation is idempotent. Subsequent calls after a successful compilation are no-ops.
• This method is thread-safe; concurrent calls may race to build a Regex, but only the first successful value is cached.

pub fn specificity(&self) -> Result<SpecificityScore, StepPatternError>

Calculate and cache the specificity score for this pattern.

Used to rank patterns when multiple match the same step text. Higher scores indicate more specific patterns.

Errors

Returns StepPatternError if the pattern contains invalid syntax.

Notes

• This operation is idempotent. Subsequent calls after a successful calculation are no-ops.
• This method is thread-safe; concurrent calls may race to compute the score, but only the first successful value is cached.

Examples

use rstest_bdd::StepPattern;

let specific = StepPattern::from("overlap apples");
let generic = StepPattern::from("overlap {item}");

let specific_score = specific.specificity().expect("specific pattern is valid");
let generic_score = generic.specificity().expect("generic pattern is valid");
assert!(specific_score > generic_score);

Trait Implementations

impl Debug for StepPattern

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

Formats the value using the given formatter.

impl From<&'static str> for StepPattern

fn from(value: &'static str) -> Self

Converts to this type from the input type.

impl Hash for StepPattern

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for StepPattern

fn eq(&self, other: &Self) -> 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 Eq for StepPattern