Merge pull request #33 from krojew/clippy

clippy fixes

Author: krojew

springtime-di/src/component.rs

@@ -3,8 +3,8 @@
 //!
 //! ## Registering concrete components
 //!
-//! Any type which wants to be managed by the DI system, needs to implement `Component`. For
-//! convenience, the trait can be automatically derived with all infrastructure if the `derive`
+//! Any type that wants to be managed by the DI system needs to implement `Component`. For
+//! convenience, the trait can be automatically derived with all infrastructures if the `derive`
 //! feature is enabled:
 //!
 //! ```
@@ -28,9 +28,9 @@
 //!     dependency_1: ComponentInstancePtr<TestDependency>,
 //!     // primary dyn Trait dependency - note Send + Sync when using the "threadsafe" feature
 //!     dependency_2: ComponentInstancePtr<dyn TestTrait + Send + Sync>,
-//!     // optional dependency - don't fail, when not present
+//!     // optional dependency - don't fail when not present
 //!     optional_dependency: Option<ComponentInstancePtr<TestDependency>>,
-//!     // all registered dependencies of given type
+//!     // all registered dependencies of a given type
 //!     all_dependencies: Vec<ComponentInstancePtr<dyn TestTrait + Sync + Send>>,
 //!     #[component(default)]
 //!     default: i8,
@@ -48,22 +48,22 @@
 //! ### Supported `#[component]` struct configuration
 //!
 //! * `names = ["name"]` - use given name list as the component names, instead of the auto-generated
-//! one
+//!   one
 //! * `condition = "expr"` - call `expr()` and evaluate if given component should be registered; see
-//! [crate::component_registry::conditional]
+//!   [crate::component_registry::conditional]
 //! * `priority = number` - if a condition is present, use the given numerical priority to establish
-//! the order of registration in relation to other components with a condition (i8; higher is first;
-//! default is 0)
+//!   the order of registration in relation to other components with a condition (i8; higher is first;
+//!   default is 0)
 //! * `constructor = "expr"` - call `expr(dependencies...)` to construct the component, instead of
-//! using standard struct construction; parameters must be in the same order as fields in the struct
-//! while non-injected fields can be ignored with the `#[component(ignore)]` attribute
+//!   using standard struct construction; parameters must be in the same order as fields in the struct
+//!   while non-injected fields can be ignored with the `#[component(ignore)]` attribute
 //! * `constructor_parameters = "params"` - additional injectable parameters for the above
-//! constructor; the "params" string consists of comma separated definitions in format:
-//! `(Type | Type/name | Option<Type> | Option<Type>/name | Vec<Type>)`, which means (in order):
-//! primary instance of `Type`, `name`d instance of `Type`, optional primary instance of `Type`,
-//! optional `name`d instance of `Type`, all instances of `Type`
+//!   constructor; the "params" string consists of comma separated definitions in format:
+//!   `(Type | Type/name | Option<Type> | Option<Type>/name | Vec<Type>)`, which means (in order):
+//!   primary instance of `Type`, `name`d instance of `Type`, optional primary instance of `Type`,
+//!   optional `name`d instance of `Type`, all instances of `Type`
 //! * `scope = "name"` - use the [scope](crate::scope) named `name` or
-//! [SINGLETON](crate::scope::SINGLETON) as default
+//!   [SINGLETON](crate::scope::SINGLETON) as default
 //!
 //! ### Supported `#[component]` field configuration
 //!
@@ -103,15 +103,15 @@
 //! ### Supported `#[component_alias]` arguments
 //!
 //! * `primary` - mark the concrete component, for which we're implementing the trait, as selected
-//! (primary) when requesting a single instance of `ComponentInstancePtr<dyn Trait>` and multiple
-//! components are available
+//!   (primary) when requesting a single instance of `ComponentInstancePtr<dyn Trait>` and multiple
+//!   components are available
 //! * `condition = "expr"` - call `expr()` and evaluate if given component should be registered; see
-//! [crate::component_registry::conditional]
+//!   [crate::component_registry::conditional]
 //! * `priority = number` - if a condition is present, use the given numerical priority to establish
-//! the order of registration in relation to other components with a condition (i8; higher is first;
-//! default is 0)
+//!   the order of registration in relation to other components with a condition (i8; higher
+//!   is first; default is 0)
 //! * `scope = "name"` - use the [scope](crate::scope) named `name` to override the concrete
-//! component scope
+//!   component scope
 
 #[cfg(feature = "async")]
 use crate::future::BoxFuture;
@@ -122,7 +122,7 @@ use crate::instance_provider::{
 
 /// Base trait for components for dependency injection.
 ///
-/// Components might depend on other components, which forms the basis for dependency injection. To
+/// Components might depend on other components, which form the basis for dependency injection. To
 /// make the system work, your component instances must be wrapped in a [ComponentInstancePtr].
 /// Please see the module-level documentation for more information.
 pub trait Component: ComponentDowncast<Self> + Sized {
@@ -136,7 +136,7 @@ pub trait Component: ComponentDowncast<Self> + Sized {
     /// Creates an instance of this component using dependencies from given [ComponentInstanceProvider].
     fn create(
         instance_provider: &mut (dyn ComponentInstanceProvider + Sync + Send),
-    ) -> BoxFuture<Result<Self, ComponentInstanceProviderError>>;
+    ) -> BoxFuture<'_, Result<Self, ComponentInstanceProviderError>>;
 }
 
 /// Helper trait for traits implemented by components, thus allowing injection of components based

springtime-di/src/scope.rs

@@ -1,11 +1,11 @@
 //! Component instances are contained in [Scope]s - containers which decide when to reuse or create
 //! an instance. There's a global one for singletons, but there also can be other, specialized ones.
-//! Some can be simple, like [PrototypeScope], while other can be quite complex and depend on
+//! Some can be simple, like [PrototypeScope], while others can be quite complex and depend on
 //! external factors, e.g. tying the lifetime of instances to web sessions.
 //!
 //! Note: scope resolution happens at component instantiation time, which can lead to unexpected
 //! consequences if incompatible scopes are mixed together, e.g. a [singleton](SINGLETON) component
-//! can depend on a [prototype](PROTOTYPE) one. In such case when creating the singleton, a new
+//! can depend on a [prototype](PROTOTYPE) one. In such a case when creating the singleton, a new
 //! instance of the dependency will be created, since it's a prototype, but then that single
 //! instance will live as long as the singleton lives.
 
@@ -33,8 +33,8 @@ pub trait Scope {
     /// Gets an instance requested for the given definition, if available in this scope.
     fn instance(&self, definition: &ComponentDefinition) -> Option<ComponentInstanceAnyPtr>;
 
-    /// Stores given instance in the scope. The scope might not support storing instances and ignore
-    /// it.
+    /// Stores a given instance in the scope. The scope might not support storing instances and
+    /// ignore it.
     fn store_instance(
         &mut self,
         definition: &ComponentDefinition,

springtime-migrate-refinery/src/lib.rs

@@ -1,7 +1,7 @@
 //! SQL migration framework based on [refinery](https://crates.io/crates/refinery) and
 //! [Springtime](https://crates.io/crates/springtime).
 //!
-//! `refinery` is powerful SQL migration toolkit for Rust, which makes creating migrations easy.
+//! `refinery` is a powerful SQL migration toolkit for Rust, which makes creating migrations easy.
 //! This crate integrates `refinery` with the broader *Springtime Framework* allowing for providing
 //! database clients and migrations via dependency injection, which further eases creating and
 //! applying migrations, either from files or Rust code.
@@ -12,7 +12,7 @@
 //! ### Features
 //!
 //! * `refinery` async db features: `mysql_async`, `rusqlite-bundled`, `tiberius`,
-//! `tiberius-config`, `tokio-postgres`
+//!   `tiberius-config`, `tokio-postgres`
 
 pub mod config;
 pub mod migration;

springtime-web-axum-derive/src/controller.rs

@@ -19,6 +19,7 @@ macro_rules! impl_handlers {
     }
 }
 
+#[derive(Clone)]
 enum ControllerMethod {
     Configuration(TokenStream),
     Source(TokenStream),
@@ -101,17 +102,7 @@ fn extract_router_configuration(item: &mut ItemImpl) -> Result<RouterConfigurati
                     }
                 });
 
-            if let Some(error) = controller_attrs
-                .iter()
-                .find_map(|attr| {
-                    if let Err(error) = attr {
-                        Some(error)
-                    } else {
-                        None
-                    }
-                })
-                .cloned()
-            {
+            if let Some(error) = controller_attrs.iter().find_map(|attr| attr.clone().err()) {
                 return Err(error);
             }
 

springtime/Cargo.toml

@@ -20,7 +20,7 @@ threadsafe = ["springtime-di/threadsafe"]
 config = "0.15.4"
 derive_more = { version = "2.0.1", features = ["constructor"] }
 futures = { version = "0.3.29", optional = true }
-serde = "1.0.159"
+serde = { version = "1.0.159", features = ["default", "derive"] }
 springtime-di = { version = "1.0.0", path = "../springtime-di", default-features = false, features = ["derive"] }
 thiserror = "2.0.3"
 tokio = { version = "1.34.0", features = ["full"], optional = true }

springtime/src/lib.rs

@@ -6,7 +6,7 @@
 //! DI framework. This, in turn, requires an entrypoint for the application which initializes DI and
 //! runs the actual business logic of the application. This crate provides such entrypoint in the
 //! form of [Application](application::Application), which also configures additional supporting
-//! infrastructure, e.g. logging.
+//! infrastructure, e.g., logging.
 //!
 //! ### Simple usage example
 //!

springtime/src/runner.rs

@@ -15,7 +15,7 @@ pub type ApplicationRunnerPtr = dyn ApplicationRunner;
 
 /// Runs application logic. Runners are run by the [Application](crate::application::Application)
 /// and are discovered by the dependency injection framework. If the `async` feature is enabled,
-/// runners with the same priority are ran concurrently.
+/// runners with the same priority are run concurrently.
 #[injectable]
 #[cfg_attr(test, automock)]
 pub trait ApplicationRunner {