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]: Two 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.