Replace #[derive(WorldInit)] macro with #[derive(World)] (#217)

[ilslv]

Resolves #217

Synopsis

To improve ergonomics we should unify WorldInit and World traits and macros.

Solution

Replace #[derive(WorldInit)] macro with #[derive(World)] and remove the WorldInit trait by moving all methods from it into the World trait.

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]

FCM

Replace `#[derive(WorldInit)]` macro with `#[derive(World)]` (#219, #217)

- merge `WorldInit` trait into the `World` trait

[ilslv]

@tyranron I've also decided to remove WorldInit trait entirely and move all blanket methods into the World trait itself. I'm not sure though is it ok to have different number of trait methods based on macros feature. But as they are blanket impls and I don't think practically anyone uses this crate without macros, I've decided to do it to simplify imports.

In case you have a different view, just revert the last commit. All changes related to WorldInit removal are there.

Before:

use std::{convert::Infallible, time::Duration};

use async_trait::async_trait;
use cucumber::{given, then, when, World, WorldInit};
use tokio::time::sleep;

#[derive(Debug, WorldInit)]
struct MyWorld {
    user: Option<String>,
    capacity: usize,
}

#[async_trait(?Send)]
impl World for MyWorld {
    type Error = Infallible;

    async fn new() -> Result<Self, Self::Error> {
        Ok(Self { user: None, capacity: 0 })
    }
}

#[given(expr = "{word} is hungry")] // Cucumber Expression
async fn someone_is_hungry(w: &mut MyWorld, user: String) {
    sleep(Duration::from_secs(2)).await;
    
    w.user = Some(user);
}

#[when(regex = r"^(?:he|she|they) eats? (\d+) cucumbers?$")]
async fn eat_cucumbers(w: &mut MyWorld, count: usize) {
    sleep(Duration::from_secs(2)).await;

    w.capacity += count;
    
    assert!(w.capacity < 4, "{} exploded!", w.user.as_ref().unwrap());
}

#[then("she is full")]
async fn is_full(w: &mut MyWorld) {
    sleep(Duration::from_secs(2)).await;

    assert_eq!(w.capacity, 3, "{} isn't full!", w.user.as_ref().unwrap());
}

#[tokio::main]
async fn main() {
    MyWorld::run("tests/features/readme").await;
}

After:

use std::time::Duration;

use cucumber::{given, then, when, World};
use tokio::time::sleep;

#[derive(Debug, Default, World)]
struct MyWorld {
    user: Option<String>,
    capacity: usize,
}

#[given(expr = "{word} is hungry")] // Cucumber Expression
async fn someone_is_hungry(w: &mut MyWorld, user: String) {
    sleep(Duration::from_secs(2)).await;
    
    w.user = Some(user);
}

#[when(regex = r"^(?:he|she|they) eats? (\d+) cucumbers?$")]
async fn eat_cucumbers(w: &mut MyWorld, count: usize) {
    sleep(Duration::from_secs(2)).await;

    w.capacity += count;
    
    assert!(w.capacity < 4, "{} exploded!", w.user.as_ref().unwrap());
}

#[then("she is full")]
async fn is_full(w: &mut MyWorld) {
    sleep(Duration::from_secs(2)).await;

    assert_eq!(w.capacity, 3, "{} isn't full!", w.user.as_ref().unwrap());
}

#[tokio::main]
async fn main() {
    MyWorld::run("tests/features/readme").await;
}