Rust Framework 🐦
Wildbird
## Introduction 👋
Welcome to the Wildbird 🐦, designed to streamline your Rust development. Equipped with tools for creating and managing services 🧩 and globals with dependency injection 📌 functionality.
## Table of contents
- [Get Started](#get-started)
- [Services](#services)
- [Globals](#globals)
- [Dependency Injection](#dependency-injection)
- [Authors](#created-by)
## Services
Create service instance (Singleton) in one step
```rust
use wildbird::prelude::*;
// Convert struct to Service + impl construct()
#[service(construct = "init")]
struct HelloService {
component_name: String,
}
impl HelloService {
fn init() -> HelloService {
HelloService {
component_name: "Hello penguins 🐧".to_string(),
}
}
fn say_hello(&self) {
println!("Hello! 👋")
}
}
fn main() {
HelloService.say_hello();
}
```
- Async init
```rust
use wildbird::derive::*;
#[service(construct = "async init")]
struct AsyncService {}
impl AsyncService {
async fn init() -> AsyncService {
AsyncService {}
}
fn greeting(&self) {
println!("Hello 🗼")
}
}
fn main() {
AsyncService.greeting();
}
```
- Async init functional
```rust
use wildbird::derive::*;
// Convert struct to Service
#[service]
struct HelloService {
component_name: String,
}
// Impl Service trait construct()
#[service(construct)]
async fn hello_init() -> HelloService {
HelloService {
component_name: "Hello 🚀".to_string(),
}
}
```
## Globals
Create global
```rust
use wildbird::derive::*;
#[var]
pub fn my_name() -> String {
String::from("Hawk 🦅")
}
fn main() {
println!("Hello from 🇵🇱, {}", &*MY_NAME);
}
```
- Custom name
```rust
use wildbird::derive::*;
#[var(name = "HOME")]
fn custom_name() -> String {
std::env::var("HOME").expect("env:HOME not found")
}
fn main() {
println!("Home: {}", &*HOME);
}
```
- Async init
```rust
use std::time::Duration;
use wildbird::derive::*;
use std::thread::sleep;
#[var(name = "USERS")]
async fn http_fetch_users() -> String {
sleep(Duration::from_millis(200));
String::from("⏱️")
}
```
- callback init
```rust
use std::time::Duration;
use wildbird::derive::*;
use std::thread::sleep;
#[var(name = "PORT")]
async fn init_http_service(callback: wildbird::Callback) {
sleep(Duration::from_millis(200));
println!("Server started");
callback.call("8080".to_string());
}
```
## Dependency Injection
Injection support is currently limited to the `#[service(construct)]` initialization method.
For example:
```rust
use wildbird::prelude::*;
#[service]
struct B {
name: String,
}
#[service(construct)]
async fn b_init() -> B {
B {
name: "Baby 🐤".to_string(),
}
}
#[service]
struct A {
name: String,
b_service: Arc
}
#[service(construct)]
async fn a_init(b: Arc) -> A {
A {
name: "Automobile 🚗".to_string(),
b_service: b
}
}
```
## Get started
##### Add dependency
Cargo.toml
```toml
[dependencies]
wildbird = "^0.0.11"
```
##### Feature flags
Optional features
- *tokio* - Use to support tokio async environment
```toml
[dependencies]
tokio = "1.28"
wildbird = {version = "^0.0.11", features = ["tokio"]}
```
##### Project status
Project is in early state of development. Each release is prior tested but api changes will most likely to happen in the future as the project progress.
## Created By
This project is licensed under the MIT License.
[BACK TO TOP ⬆️](#top)