3.2.0

[commonsensesoftware]

This release has some minor fixes and quality of life improvements.

Features

Service Decoration

Service decoration was already possible, but required a lot of ceremony to set up. First-class support for service decoration is now provided out of the box. Service decoration occurs when one service needs to decorate an existing service registration and replace it without discarding it. It most cases it would not be possible to properly build back up the registered service to be decorated by the decorator type.

The new API enables you to specify the service being decorated and its new implementation type. The existing registration will be automatically resolved and supplied in the callback that you can use to construct the decorated service.

let services = ServiceCollection::new()
    .add(FeatureImpl::transient())
    .decorate::<dyn Feature, FeatureTracker>(|sp, decorated| {
        Ref::new(FeatureTracker { decorated, count: Default::default() })
    })
    .build_provider()
    .unwrap();

Additional information and the full example can be found in the Service Decoration section of the user guide.

It is currently not possible to use the Injectable trait or #[injectable] attribute macro for service decoration as it would result in infinite recursion. This capability might become possible in the future.

Fixes

Fix Conditional #[inject] Resolution When Using #[cfg_attr]

Due to the order of attribute macro resolution, the #[inject] marker was not properly detected if you conditionally used #[injectable] with a custom constructor function. The workaround was to use cfg_if! for the entire declaration or make sure your constructor function always followed the default naming convention of fn new() -> Self. This fix corrects the problem and now allows:

use std::rc::Rc;

#[cfg_attr(feature = "di", di::injectable)]
struct Bar;

struct Foo(Rc<Bar>);

#[cfg_attr(feature = "di", di::injectable)]
impl Foo {
    #[cfg_attr(feature = "di", di::inject)]
    fn _inject(bar: di::Ref<Bar>) -> Self {
        Self(bar)
    }
}

Breaking Changes^*

There are two behavioral, breaking changes that may affect existing users.

• Colored output formatting for debugging is now controlled using the alternate format code (e.g. #)
  • Previously, this was only driven by the fmt feature
  • The default output will now always be uncolored; for example: println!("{}", ServiceCollection::new());
    • Previously, the behavior toggled between whether the fmt feature was enabled
  • The colored output now requires the alternate format code; for example: println!("{:#}", ServiceCollection::new());
    • This enables consistent behavior and opting in or out of colorization dynamically (ex: one to logs and one to the terminal)
    • If the fmt feature isn't enabled, then both forms produce the same, uncolored output
• The async feature now requires all services to be Send + Sync
  • This should have already been a requirement using di::Ref or Arc directly and produced warnings if you weren't
  • The ServiceProvider unsafely lied that it was Send + Sync, which has been removed and is now verified by the compiler

These changes are typically considered a breaking change, but I found them to be fully backward compatible in numerous production use cases. Traits used with the async feature either already had Send + Sync applied or adding them was trivial and the correct thing to do anyway. Bumping to a major version would require a major version bump in related crates so I'm attempting a minor version bump first. Please report any issues. I'll yank this version and use a major version bump instead if problems arise.

---

This discussion was created from the release 3.2.0.