Set imports_granularity "Crate"

rclrust-msg-gen/src/parser/action.rs

@@ -1,11 +1,9 @@
-use std::fs;
-use std::path::Path;
+use std::{fs, path::Path};
 
 use anyhow::{Context, Result};
 use regex::Regex;
 
-use super::error::RclMsgError;
-use super::message::parse_message_string;
+use super::{error::RclMsgError, message::parse_message_string};
 use crate::types::Action;
 
 const ACTION_GOAL_SUFFIX: &str = "_Goal";
@@ -62,9 +60,7 @@ mod test {
     use std::path::PathBuf;
 
     use super::*;
-    use crate::types::primitives::*;
-    use crate::types::sequences::*;
-    use crate::types::MemberType;
+    use crate::types::{primitives::*, sequences::*, MemberType};
 
     fn parse_action_def(srv_name: &str) -> Result<Action> {
         let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))

rclrust-msg-gen/src/parser/constant.rs

@@ -1,14 +1,14 @@
 use anyhow::{ensure, Result};
-use nom::bytes::complete::is_not;
-use nom::character::complete::{char, space0, space1};
-use nom::combinator::{eof, recognize};
-use nom::multi::separated_list1;
-use nom::sequence::tuple;
+use nom::{
+    bytes::complete::is_not,
+    character::complete::{char, space0, space1},
+    combinator::{eof, recognize},
+    multi::separated_list1,
+    sequence::tuple,
+};
 
-use super::error::RclMsgError;
-use super::{ident, literal, types};
-use crate::types::primitives::PrimitiveType;
-use crate::types::{Constant, ConstantType};
+use super::{error::RclMsgError, ident, literal, types};
+use crate::types::{primitives::PrimitiveType, Constant, ConstantType};
 
 fn validate_value(r#type: ConstantType, value: &str) -> Result<Vec<String>> {
     match r#type {

rclrust-msg-gen/src/parser/ident.rs

@@ -1,9 +1,11 @@
-use nom::branch::alt;
-use nom::character::complete::{alphanumeric0, char, one_of};
-use nom::combinator::{opt, recognize};
-use nom::multi::{many1, separated_list0, separated_list1};
-use nom::sequence::{pair, tuple};
-use nom::IResult;
+use nom::{
+    branch::alt,
+    character::complete::{alphanumeric0, char, one_of},
+    combinator::{opt, recognize},
+    multi::{many1, separated_list0, separated_list1},
+    sequence::{pair, tuple},
+    IResult,
+};
 
 fn upperalpha(s: &str) -> IResult<&str, char> {
     one_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ")(s)

rclrust-msg-gen/src/parser/literal.rs

@@ -1,15 +1,15 @@
 use std::convert::TryFrom;
 
-use nom::branch::alt;
-use nom::bytes::complete::{is_not, tag, tag_no_case, take_while};
-use nom::character::complete::{
-    anychar, char, digit1, hex_digit1, none_of, oct_digit1, one_of, space0,
+use nom::{
+    branch::alt,
+    bytes::complete::{is_not, tag, tag_no_case, take_while},
+    character::complete::{anychar, char, digit1, hex_digit1, none_of, oct_digit1, one_of, space0},
+    combinator::{eof, map, map_res, opt, recognize, rest, value, verify},
+    multi::{many0, separated_list1},
+    number::complete::recognize_float,
+    sequence::{delimited, pair, tuple},
+    IResult,
 };
-use nom::combinator::{eof, map, map_res, opt, recognize, rest, value, verify};
-use nom::multi::{many0, separated_list1};
-use nom::number::complete::recognize_float;
-use nom::sequence::{delimited, pair, tuple};
-use nom::IResult;
 
 use crate::types::primitives::{BasicType, GenericString};
 

rclrust-msg-gen/src/parser/member.rs

@@ -1,14 +1,14 @@
 use anyhow::{ensure, Result};
-use nom::bytes::complete::is_not;
-use nom::character::complete::{space0, space1};
-use nom::combinator::{eof, opt, recognize};
-use nom::multi::separated_list1;
-use nom::sequence::{preceded, tuple};
+use nom::{
+    bytes::complete::is_not,
+    character::complete::{space0, space1},
+    combinator::{eof, opt, recognize},
+    multi::separated_list1,
+    sequence::{preceded, tuple},
+};
 
-use super::error::RclMsgError;
-use super::{ident, literal, types};
-use crate::types::primitives::NestableType;
-use crate::types::{Member, MemberType};
+use super::{error::RclMsgError, ident, literal, types};
+use crate::types::{primitives::NestableType, Member, MemberType};
 
 fn nestable_type_default(nestable_type: NestableType, default: &str) -> Result<Vec<String>> {
     match nestable_type {

rclrust-msg-gen/src/parser/message.rs

@@ -1,10 +1,8 @@
-use std::fs;
-use std::path::Path;
+use std::{fs, path::Path};
 
 use anyhow::{Context, Result};
 
-use super::constant::constant_def;
-use super::member::member_def;
+use super::{constant::constant_def, member::member_def};
 use crate::types::Message;
 
 fn split_once(s: &'_ str, pat: char) -> (&'_ str, Option<&'_ str>) {
@@ -62,9 +60,7 @@ mod test {
     use std::path::PathBuf;
 
     use super::*;
-    use crate::types::primitives::*;
-    use crate::types::sequences::*;
-    use crate::types::*;
+    use crate::types::{primitives::*, sequences::*, *};
 
     #[test]
     fn test_split_once() {

rclrust-msg-gen/src/parser/package.rs

@@ -1,12 +1,12 @@
-use std::fs::{self, File};
-use std::io::{BufRead, BufReader};
-use std::path::Path;
+use std::{
+    fs::{self, File},
+    io::{BufRead, BufReader},
+    path::Path,
+};
 
 use anyhow::Result;
 
-use super::action::parse_action_file;
-use super::message::parse_message_file;
-use super::service::parse_service_file;
+use super::{action::parse_action_file, message::parse_message_file, service::parse_service_file};
 use crate::types::Package;
 
 const ROSIDL_INTERFACES: &str = "share/ament_index/resource_index/rosidl_interfaces";

rclrust-msg-gen/src/parser/service.rs

@@ -1,11 +1,9 @@
-use std::fs;
-use std::path::Path;
+use std::{fs, path::Path};
 
 use anyhow::{Context, Result};
 use regex::Regex;
 
-use super::error::RclMsgError;
-use super::message::parse_message_string;
+use super::{error::RclMsgError, message::parse_message_string};
 use crate::types::Service;
 
 const SERVICE_REQUEST_SUFFIX: &str = "_Request";

rclrust-msg-gen/src/parser/types.rs

@@ -1,16 +1,22 @@
 use anyhow::anyhow;
-use nom::branch::alt;
-use nom::bytes::complete::tag;
-use nom::character::complete::{char, space1};
-use nom::combinator::{eof, map, map_res, opt, peek};
-use nom::sequence::{delimited, pair, preceded, tuple};
-use nom::IResult;
+use nom::{
+    branch::alt,
+    bytes::complete::tag,
+    character::complete::{char, space1},
+    combinator::{eof, map, map_res, opt, peek},
+    sequence::{delimited, pair, preceded, tuple},
+    IResult,
+};
 
-use super::ident::{message_name, package_name};
-use super::literal::usize_literal;
-use crate::types::primitives::*;
-use crate::types::sequences::{Array, BoundedSequence, PrimitiveArray, Sequence};
-use crate::types::{ConstantType, MemberType};
+use super::{
+    ident::{message_name, package_name},
+    literal::usize_literal,
+};
+use crate::types::{
+    primitives::*,
+    sequences::{Array, BoundedSequence, PrimitiveArray, Sequence},
+    ConstantType, MemberType,
+};
 
 pub fn parse_member_type(s: &str) -> IResult<&str, MemberType> {
     map_res(

rclrust-msg-gen/src/types/action.rs

@@ -1,8 +1,7 @@
 use heck::SnakeCase;
 use quote::{format_ident, quote, ToTokens};
 
-use super::primitives::*;
-use super::{Member, Message, Service};
+use super::{primitives::*, Member, Message, Service};
 
 /// An action definition
 #[derive(Debug, Clone)]

rclrust-msg-gen/src/types/constant.rs

@@ -1,7 +1,9 @@
 use quote::{quote, ToTokens};
 
-use super::primitives::{BasicType, GenericUnboundedString, PrimitiveType};
-use super::sequences::PrimitiveArray;
+use super::{
+    primitives::{BasicType, GenericUnboundedString, PrimitiveType},
+    sequences::PrimitiveArray,
+};
 
 macro_rules! define_enum_from {
     ($into_t:ty, $from_t:ty, $path:path) => {

rclrust-msg-gen/src/types/member.rs

@@ -1,7 +1,6 @@
 use quote::{quote, ToTokens};
 
-use super::primitives::*;
-use super::sequences::*;
+use super::{primitives::*, sequences::*};
 
 macro_rules! define_enum_from {
     ($into_t:ty, $from_t:ty, $path:path) => {

rclrust-msg-gen/src/types/message.rs

@@ -1,9 +1,7 @@
 use heck::SnakeCase;
 use quote::{format_ident, quote, ToTokens};
 
-use super::primitives::*;
-use super::sequences::Array;
-use super::{ConstantType, MemberType};
+use super::{primitives::*, sequences::Array, ConstantType, MemberType};
 
 /// A member of a structure
 #[derive(Debug, Clone)]

rclrust-msg/src/_core/sequence.rs

@@ -1,5 +1,4 @@
-use std::mem::ManuallyDrop;
-use std::ops::Deref;
+use std::{mem::ManuallyDrop, ops::Deref};
 
 use super::traits::{FFIFromRust, FFIToRust};
 

rclrust-msg/src/_core/string.rs

@@ -1,5 +1,7 @@
-use std::ffi::{CStr, CString};
-use std::os::raw::c_char;
+use std::{
+    ffi::{CStr, CString},
+    os::raw::c_char,
+};
 
 use widestring::{U16CStr, U16CString, U16String};
 

rclrust-msg/src/_core/traits.rs

@@ -1,5 +1,4 @@
-use std::convert::TryInto;
-use std::os::raw::c_void;
+use std::{convert::TryInto, os::raw::c_void};
 
 use array_init::array_init;
 use widestring::U16String;

rclrust/examples/client.rs

@@ -1,6 +1,5 @@
 use anyhow::Result;
-use rclrust::qos::QoSProfile;
-use rclrust::rclrust_info;
+use rclrust::{qos::QoSProfile, rclrust_info};
 use rclrust_msg::example_interfaces::srv::{AddTwoInts, AddTwoInts_Request};
 
 fn main() -> Result<()> {

rclrust/examples/logger.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
-use rclrust::{rclrust_debug, rclrust_error, rclrust_fatal, rclrust_info, rclrust_warn};
-use rclrust::{Clock, Logger};
+use rclrust::{
+    rclrust_debug, rclrust_error, rclrust_fatal, rclrust_info, rclrust_warn, Clock, Logger,
+};
 use rclrust_msg::geometry_msgs::msg::Twist;
 
 fn main() -> Result<()> {

rclrust/examples/parameters.rs

@@ -1,6 +1,5 @@
 use anyhow::Result;
-use rclrust::rclrust_info;
-use rclrust::{Parameter, ParameterValue};
+use rclrust::{rclrust_info, Parameter, ParameterValue};
 
 fn main() -> Result<()> {
     let ctx = rclrust::init()?;

rclrust/examples/publisher.rs

@@ -1,9 +1,7 @@
-use std::thread::sleep;
-use std::time::Duration;
+use std::{thread::sleep, time::Duration};
 
 use anyhow::Result;
-use rclrust::qos::QoSProfile;
-use rclrust::rclrust_info;
+use rclrust::{qos::QoSProfile, rclrust_info};
 use rclrust_msg::std_msgs::msg::String as String_;
 
 fn main() -> Result<()> {

rclrust/examples/raw_subscription.rs

@@ -1,8 +1,6 @@
 use anyhow::Result;
-use rclrust::qos::QoSProfile;
-use rclrust::rclrust_info;
-use rclrust_msg::_core::FFIToRust;
-use rclrust_msg::std_msgs::msg::String as String_;
+use rclrust::{qos::QoSProfile, rclrust_info};
+use rclrust_msg::{_core::FFIToRust, std_msgs::msg::String as String_};
 
 fn main() -> Result<()> {
     let ctx = rclrust::init()?;

rclrust/examples/subscription.rs

@@ -1,6 +1,5 @@
 use anyhow::Result;
-use rclrust::qos::QoSProfile;
-use rclrust::rclrust_info;
+use rclrust::{qos::QoSProfile, rclrust_info};
 use rclrust_msg::std_msgs::msg::String as String_;
 
 fn main() -> Result<()> {

rclrust/examples/timer.rs

@@ -1,5 +1,4 @@
-use std::cell::Cell;
-use std::time::Duration;
+use std::{cell::Cell, time::Duration};
 
 use anyhow::Result;
 use rclrust::rclrust_info;

rclrust/src/client.rs

@@ -1,23 +1,27 @@
-use std::collections::HashMap;
-use std::ffi::CString;
-use std::marker::PhantomData;
-use std::mem::MaybeUninit;
-use std::os::raw::c_void;
-use std::sync::{Arc, Mutex, Weak};
-use std::time::Duration;
+use std::{
+    collections::HashMap,
+    ffi::CString,
+    marker::PhantomData,
+    mem::MaybeUninit,
+    os::raw::c_void,
+    sync::{Arc, Mutex, Weak},
+    time::Duration,
+};
 
 use anyhow::{anyhow, Context as _, Result};
 use futures::channel::oneshot;
 use rclrust_msg::_core::{FFIToRust, MessageT, ServiceT};
 
-use crate::context::Context;
-use crate::error::{RclRustError, ToRclRustResult};
-use crate::internal::ffi::*;
-use crate::log::Logger;
-use crate::node::{Node, RclNode};
-use crate::qos::QoSProfile;
-use crate::rclrust_error;
-use crate::wait_set::RclWaitSet;
+use crate::{
+    context::Context,
+    error::{RclRustError, ToRclRustResult},
+    internal::ffi::*,
+    log::Logger,
+    node::{Node, RclNode},
+    qos::QoSProfile,
+    rclrust_error,
+    wait_set::RclWaitSet,
+};
 
 #[derive(Debug)]
 pub(crate) struct RclClient(Box<rcl_sys::rcl_client_t>);

rclrust/src/clock.rs

@@ -2,11 +2,9 @@ use std::mem::MaybeUninit;
 
 use anyhow::{ensure, Context, Result};
 
-use crate::error::ToRclRustResult;
-use crate::impl_from_trait_for_enum;
-use crate::log::Logger;
-use crate::rclrust_error;
-use crate::time::Time;
+use crate::{
+    error::ToRclRustResult, impl_from_trait_for_enum, log::Logger, rclrust_error, time::Time,
+};
 
 /// Time source type, used to indicate the source of a time measurement.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

rclrust/src/context.rs

@@ -1,16 +1,19 @@
-use std::ffi::CString;
-use std::os::raw::c_int;
-use std::sync::{Arc, Mutex};
+use std::{
+    ffi::CString,
+    os::raw::c_int,
+    sync::{Arc, Mutex},
+};
 
 use anyhow::{Context as _, Result};
 
-use crate::error::ToRclRustResult;
-use crate::init_options::InitOptions;
-use crate::log::Logger;
-use crate::log::{logging_output_handler, LOGGER_MUTEX};
-use crate::node::Node;
-use crate::node_options::NodeOptions;
-use crate::rclrust_error;
+use crate::{
+    error::ToRclRustResult,
+    init_options::InitOptions,
+    log::{logging_output_handler, Logger, LOGGER_MUTEX},
+    node::Node,
+    node_options::NodeOptions,
+    rclrust_error,
+};
 
 #[derive(Debug)]
 pub(crate) struct RclContext(Box<rcl_sys::rcl_context_t>);

rclrust/src/executor.rs

@@ -1,12 +1,11 @@
-use std::sync::{Arc, Weak};
-use std::time::Duration;
+use std::{
+    sync::{Arc, Weak},
+    time::Duration,
+};
 
 use anyhow::Result;
 
-use crate::context::Context;
-use crate::error::RclRustError;
-use crate::node::Node;
-use crate::wait_set::RclWaitSet;
+use crate::{context::Context, error::RclRustError, node::Node, wait_set::RclWaitSet};
 
 pub fn spin(node: &Arc<Node<'_>>) -> Result<()> {
     let mut exec = SingleThreadExecutor::new(node.context)?;

rclrust/src/init_options.rs

@@ -1,8 +1,6 @@
 use anyhow::{Context, Result};
 
-use crate::error::ToRclRustResult;
-use crate::log::Logger;
-use crate::rclrust_error;
+use crate::{error::ToRclRustResult, log::Logger, rclrust_error};
 
 #[derive(Debug)]
 pub(crate) struct RclInitOptions(rcl_sys::rcl_init_options_t);

rclrust/src/internal/ffi.rs

@@ -1,5 +1,7 @@
-use std::ffi::{CStr, CString};
-use std::os::raw::c_char;
+use std::{
+    ffi::{CStr, CString},
+    os::raw::c_char,
+};
 
 pub unsafe trait SizedFromCChar: Sized {
     unsafe fn from_c_char(ptr: *const c_char) -> Option<Self>;

rclrust/src/log.rs

@@ -1,13 +1,17 @@
-use std::convert::{TryFrom, TryInto};
-use std::ffi::CString;
-use std::os::raw::{c_char, c_int};
+use std::{
+    convert::{TryFrom, TryInto},
+    ffi::CString,
+    os::raw::{c_char, c_int},
+};
 
 use anyhow::{Context, Result};
 use once_cell::sync::Lazy;
 use parking_lot::ReentrantMutex;
 
-use crate::error::{RclRustError, ToRclRustResult};
-use crate::impl_from_trait_for_enum;
+use crate::{
+    error::{RclRustError, ToRclRustResult},
+    impl_from_trait_for_enum,
+};
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum LogSeverity {

rclrust/src/node.rs

@@ -1,26 +1,32 @@
-use std::ffi::CString;
-use std::sync::{Arc, Mutex, Weak};
-use std::time::Duration;
+use std::{
+    ffi::CString,
+    sync::{Arc, Mutex, Weak},
+    time::Duration,
+};
 
 use anyhow::{ensure, Context as _, Result};
-use rclrust_msg::_core::{FFIToRust, MessageT, ServiceT};
-use rclrust_msg::rcl_interfaces::msg::ParameterDescriptor;
-
-use crate::client::{Client, ClientBase};
-use crate::clock::ClockType;
-use crate::context::{Context, RclContext};
-use crate::error::ToRclRustResult;
-use crate::internal::ffi::*;
-use crate::log::Logger;
-use crate::node_options::NodeOptions;
-use crate::parameter::{Parameter, ParameterValue, Parameters};
-use crate::publisher::Publisher;
-use crate::qos::QoSProfile;
-use crate::rclrust_error;
-use crate::service::{Service, ServiceBase};
-use crate::subscription::{Subscription, SubscriptionBase};
-use crate::timer::Timer;
-use crate::wait_set::RclWaitSet;
+use rclrust_msg::{
+    _core::{FFIToRust, MessageT, ServiceT},
+    rcl_interfaces::msg::ParameterDescriptor,
+};
+
+use crate::{
+    client::{Client, ClientBase},
+    clock::ClockType,
+    context::{Context, RclContext},
+    error::ToRclRustResult,
+    internal::ffi::*,
+    log::Logger,
+    node_options::NodeOptions,
+    parameter::{Parameter, ParameterValue, Parameters},
+    publisher::Publisher,
+    qos::QoSProfile,
+    rclrust_error,
+    service::{Service, ServiceBase},
+    subscription::{Subscription, SubscriptionBase},
+    timer::Timer,
+    wait_set::RclWaitSet,
+};
 
 #[derive(Debug)]
 pub(crate) struct RclNode(Box<rcl_sys::rcl_node_t>);

rclrust/src/node_options.rs

@@ -1,6 +1,4 @@
-use crate::error::ToRclRustResult;
-use crate::log::Logger;
-use crate::rclrust_error;
+use crate::{error::ToRclRustResult, log::Logger, rclrust_error};
 
 #[derive(Debug)]
 pub(crate) struct RclNodeOptions(rcl_sys::rcl_node_options_t);

rclrust/src/parameter/parameters.rs

@@ -1,14 +1,11 @@
-use std::collections::HashMap;
-use std::sync::Mutex;
+use std::{collections::HashMap, sync::Mutex};
 
 use anyhow::Result;
 
 use super::{
     Parameter, ParameterDescriptor, ParameterType, ParameterValue, RclParams, SetParametersResult,
 };
-use crate::context::RclContext;
-use crate::error::RclRustError;
-use crate::node::RclNode;
+use crate::{context::RclContext, error::RclRustError, node::RclNode};
 
 #[derive(Debug, Default, Clone)]
 pub struct ParameterInfo {

rclrust/src/parameter/rcl_params.rs

@@ -3,8 +3,10 @@ use std::collections::HashMap;
 use anyhow::{Context, Result};
 
 use super::ParameterValue;
-use crate::error::{RclRustError, ToRclRustResult};
-use crate::internal::ffi::{FromCChar, SizedFromCChar};
+use crate::{
+    error::{RclRustError, ToRclRustResult},
+    internal::ffi::{FromCChar, SizedFromCChar},
+};
 
 #[derive(Debug)]
 pub struct RclParams(Box<*mut rcl_sys::rcl_params_t>);

rclrust/src/publisher.rs

@@ -1,17 +1,21 @@
-use std::ffi::CString;
-use std::marker::PhantomData;
-use std::os::raw::c_void;
-use std::sync::{Arc, Mutex};
+use std::{
+    ffi::CString,
+    marker::PhantomData,
+    os::raw::c_void,
+    sync::{Arc, Mutex},
+};
 
 use anyhow::{Context, Result};
 use rclrust_msg::_core::MessageT;
 
-use crate::error::ToRclRustResult;
-use crate::internal::ffi::*;
-use crate::log::Logger;
-use crate::node::{Node, RclNode};
-use crate::qos::QoSProfile;
-use crate::rclrust_error;
+use crate::{
+    error::ToRclRustResult,
+    internal::ffi::*,
+    log::Logger,
+    node::{Node, RclNode},
+    qos::QoSProfile,
+    rclrust_error,
+};
 
 #[derive(Debug)]
 pub(crate) struct RclPublisher(Box<rcl_sys::rcl_publisher_t>);

rclrust/src/qos.rs

@@ -1,7 +1,6 @@
 use std::time::Duration;
 
-use crate::impl_from_trait_for_enum;
-use crate::time::RclDurationT;
+use crate::{impl_from_trait_for_enum, time::RclDurationT};
 
 /// QoS reliability enumerations
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

rclrust/src/service.rs

@@ -1,16 +1,20 @@
-use std::ffi::{c_void, CString};
-use std::mem::MaybeUninit;
-use std::sync::{Arc, Mutex};
+use std::{
+    ffi::{c_void, CString},
+    mem::MaybeUninit,
+    sync::{Arc, Mutex},
+};
 
 use anyhow::{Context, Result};
 use rclrust_msg::_core::{MessageT, ServiceT};
 
-use crate::error::{RclRustError, ToRclRustResult};
-use crate::internal::ffi::*;
-use crate::log::Logger;
-use crate::node::{Node, RclNode};
-use crate::qos::QoSProfile;
-use crate::rclrust_error;
+use crate::{
+    error::{RclRustError, ToRclRustResult},
+    internal::ffi::*,
+    log::Logger,
+    node::{Node, RclNode},
+    qos::QoSProfile,
+    rclrust_error,
+};
 
 pub struct RclService(Box<rcl_sys::rcl_service_t>);
 

rclrust/src/subscription.rs

@@ -1,16 +1,20 @@
-use std::ffi::CString;
-use std::os::raw::c_void;
-use std::sync::{Arc, Mutex};
+use std::{
+    ffi::CString,
+    os::raw::c_void,
+    sync::{Arc, Mutex},
+};
 
 use anyhow::{Context, Result};
 use rclrust_msg::_core::MessageT;
 
-use crate::error::{RclRustError, ToRclRustResult};
-use crate::internal::ffi::*;
-use crate::log::Logger;
-use crate::node::{Node, RclNode};
-use crate::qos::QoSProfile;
-use crate::rclrust_error;
+use crate::{
+    error::{RclRustError, ToRclRustResult},
+    internal::ffi::*,
+    log::Logger,
+    node::{Node, RclNode},
+    qos::QoSProfile,
+    rclrust_error,
+};
 
 #[derive(Debug)]
 pub(crate) struct RclSubscription(Box<rcl_sys::rcl_subscription_t>);

rclrust/src/time.rs

@@ -1,5 +1,4 @@
-use std::convert::TryInto;
-use std::time::Duration;
+use std::{convert::TryInto, time::Duration};
 
 use rclrust_msg::builtin_interfaces;
 

rclrust/src/timer.rs

@@ -1,15 +1,19 @@
-use std::convert::TryInto;
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
+use std::{
+    convert::TryInto,
+    sync::{Arc, Mutex},
+    time::Duration,
+};
 
 use anyhow::{Context, Result};
 
-use crate::clock::{Clock, ClockType};
-use crate::context::RclContext;
-use crate::error::ToRclRustResult;
-use crate::log::Logger;
-use crate::node::Node;
-use crate::rclrust_error;
+use crate::{
+    clock::{Clock, ClockType},
+    context::RclContext,
+    error::ToRclRustResult,
+    log::Logger,
+    node::Node,
+    rclrust_error,
+};
 
 #[derive(Debug)]
 pub struct RclTimer(Box<rcl_sys::rcl_timer_t>);

rclrust/src/utility.rs

@@ -2,8 +2,7 @@ use std::sync::Arc;
 
 use anyhow::Result;
 
-use crate::context::Context;
-use crate::init_options::InitOptions;
+use crate::{context::Context, init_options::InitOptions};
 
 /// Initialize rclrust context
 ///

rclrust/src/wait_set.rs

@@ -1,13 +1,9 @@
 use anyhow::{Context, Result};
 
-use crate::client::RclClient;
-use crate::context::RclContext;
-use crate::error::ToRclRustResult;
-use crate::log::Logger;
-use crate::rclrust_error;
-use crate::service::RclService;
-use crate::subscription::RclSubscription;
-use crate::timer::RclTimer;
+use crate::{
+    client::RclClient, context::RclContext, error::ToRclRustResult, log::Logger, rclrust_error,
+    service::RclService, subscription::RclSubscription, timer::RclTimer,
+};
 
 #[derive(Debug)]
 pub(crate) struct RclWaitSet(rcl_sys::rcl_wait_set_t);

rustfmt.toml

@@ -1,2 +1,3 @@
 format_code_in_doc_comments = true
 group_imports = "StdExternalCrate"
+imports_granularity = "Crate"