Support Cucumber Expressions (#124)

[ilslv]

Part of #124

Synopsis

Sometimes regex is a bit too much and we want something easier. Cucumber expressions are a great fit in this scenario.

Solution

Support in attribute macros with #[given(expr = "...")]/#[given(expression = "...")]

Checklist

• Created PR:
  • In draft mode
  • Name contains Draft: prefix
  • Name contains issue reference
  • Has assignee
• Documentation is updated (if required)
• Tests are updated (if required)
• Changes conform code style
• CHANGELOG entry is added (if required)
• FCM (final commit message) is posted
  • and approved
• Review is completed and changes are approved
• Before merge:
  • Milestone is set
  • PR's name and description are correct and up-to-date
  • Draft: prefix is removed
  • All temporary labels are removed

[ilslv]

Current blockers:

• derive_more release with Move MSRV test to separate job with cargo +nightly update -Z minimal-versions JelteF/derive_more#175 fix to make CI happy
• Cucumber Expressions language has no formal specification. Because of this the no way for us to say that cucumber-expressions implementation is correct, as there is no notion of correctness: Update Grammar in Architecture cucumber/cucumber-expressions#41

[tyranron]

@ilslv cucumber-expressions 0.1.0 is released, we can move on here.

[ilslv]

FCM

Support Cucumber Expressions (#157, #124)

[tyranron]

@ilslv we need a clear example of how to use custom parameters in Cucumber Expressions.

Also, a FromStr example in the Book doesn't actually demonstrate how it works with a parameter captured by a Cucumber Expression.

[ilslv]

@tyranron for custom parameters I propose something like this

enum Animal {
    Cat,
    Dog,
    Ferris,
}

impl FromStr for Animal {
    type Err = &'static str;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "cat" => Ok(Self::Cat),
            "dog" => Ok(Self::Dog),
            "🦀" => Ok(Self::Ferris),
            _ => Err("expected 'cat', 'dog' or '🦀'"),
        }
    }
}

impl CustomParameter for Animal {
    const NAME = "animal";
    const REGEX = "cat|dog|🦀";
}

#[then(expr = "the {animal} is not hungry")]
async fn cat_is_fed(world: &mut AnimalWorld, animal: Animal) {
    sleep(Duration::from_secs(2)).await;

    match animal {
        Animal::Cat => assert!(!world.cat.hungry),
        Animal::Dog => assert!(!world.dog.hungry),
        Animal::Ferris => assert!(!world.ferris.hungry),
    };
}

With that we can validate that parameter name is right with const assertion. And to validate regex we can even use clippy lint : Playground.
Also, as we have exact type, we can use deref-based specialisation to fallback on default parameter name in our const assertion.

UPD:

Clippy lint will require our users to run it over tests codebase, which is rarely done. If we want to avoid this, we'll have to implement CustomParameter with our own derive macro, as I don't think there is another way of validating regex at compile time.

[tyranron]

@ilslv let's move this discussion to the issue, because it won't be a part of this PR. And merge this PR only with FromStr.