Crate rudi

Rudi

Rudi - an out-of-the-box dependency injection framework for Rust.

Quick Links

Here are links to the most important sections of the docs:

• Context: The core of the entire dependency injection framework, responsible for managing all providers.
• #[Singleton] / #[Transient] / #[SingleOwner]: Three attribute macros used to generate the implementation of DefaultProvider, thus registering providers.

Feature Flags

• rudi-macro (Default): Enables the #[Singleton], #[Transient] and #[SingleOwner] attribute macros.
• auto-register (Default): Enables automatic registration of types and functions.
• tracing: Adds support for logging with tracing.

Example

use rudi::{Context, Singleton, Transient};

// Register `fn(cx) -> A { A }` as the constructor for `A`
#[derive(Debug)]
#[Transient]
struct A;

#[derive(Debug)]
struct B(A);

// Register `fn(cx) -> B { B::new(cx.resolve::<A>()) }` as the constructor for `B`
#[Transient]
impl B {
    #[di]
    fn new(a: A) -> B {
        B(a)
    }
}

// Register `fn(cx) -> C { C::B(cx.resolve::<B>()) }` as the constructor for `C`
#[allow(dead_code)]
#[Transient]
enum C {
    A(A),

    #[di]
    B(B),
}

// Register `fn(cx) -> () { Run(cx.resolve::<B>(), cx.resolve::<C>()) }` as the constructor for `()`
#[Singleton]
fn Run(b: B, c: C) {
    println!("{:?}", b);
    assert!(matches!(c, C::B(_)));
}

fn main() {
    // Automatically register all types and functions with the `#[Singleton]`, `#[Transient]` or `#[SingleOwner]` attribute.
    let mut cx = Context::auto_register();

    // Get an instance of `()` from the `Context`, which will call the `Run` function.
    // This is equivalent to `cx.resolve::<()>();`
    cx.resolve()
}

Macros

components

Convert a set of types that implement DefaultProvider to a set of DynProvider instances

enableauto-register

Generate a function to enable auto-registration.

modules

Convert a set of types that implement Module to a set of ResolveModule instances.

providers

Convert a set of instances that implement Into<DynProvider> to a set of DynProvider instances

register_providerauto-register

Register a Provider that will be collected by auto_registered_providers.

Structs

AutoRegisterModuleauto-register

A module that auto-registers all providers.

Context

A context is a container for all the providers and instances.

ContextOptions

Options and flags which can be used to configure how a context is created.

Definition

Represents a definition of a provider.

DynProvider

Represents a Provider that erased its type.

DynSingle

Represents a Single that erased its type.

Key

Represents a unique key for a provider.

Provider

Represents the provider of an instance of type T.

ResolveModule

A type representing a Module, converted from a type that implements Module.

Single

Represents a Singleton or SingleOwner instance.

SingleOwnerAsyncProvider

Represents a specialized Provider.

SingleOwnerProvider

Represents a specialized Provider.

SingletonAsyncProvider

Represents a specialized Provider.

SingletonProvider

Represents a specialized Provider.

TransientAsyncProvider

Represents a specialized Provider.

TransientProvider

Represents a specialized Provider.

Type

Represents a type.

Enums

Color

Represents the color of the function, i.e., async or sync.

EagerCreateFunction

Represents the eager create function.

Scope

Represents the scope of the provider.

Traits

DefaultProvider

A trait for giving a type a default Provider.

FutureExt

An extension trait for Futures that provides a convenient adapter.

Module

Represents a module.

Functions

auto_registered_providersauto-register

Returns an iterator over all auto-registered providers.

single_owner

create a SingleOwnerProvider instance

single_owner_async

Create a SingleOwnerAsyncProvider instance

singleton

create a SingletonProvider instance

singleton_async

Create a SingletonAsyncProvider instance

transient

create a TransientProvider instance

transient_async

Create a TransientAsyncProvider instance

Type Aliases

BoxFuture

An owned dynamically typed Future for use in cases where you can’t statically type your result or need to add some indirection.

Attribute Macros

SingleOwnerrudi-macro

Define a single owner provider.

Singletonrudi-macro

Define a singleton provider.

Transientrudi-macro

Define a transient provider.