Fixed clippy issues.

Author: s3rius

src/js/jetstream.rs

@@ -19,6 +19,7 @@ pub struct JetStream {
 }
 
 impl JetStream {
+    #[must_use]
     pub fn new(ctx: async_nats::jetstream::Context) -> Self {
         Self {
             ctx: Arc::new(RwLock::new(ctx)),
@@ -40,7 +41,7 @@ impl JetStream {
         &self,
         py: Python<'py>,
         subject: String,
-        payload: Bound<PyBytes>,
+        payload: &Bound<PyBytes>,
         headers: Option<Bound<PyDict>>,
         reply: Option<String>,
         err_on_disconnect: bool,
@@ -51,25 +52,28 @@ impl JetStream {
             .map(async_nats::HeaderMap::from_pydict)
             .transpose()?;
         natsrpy_future(py, async move {
-            let js = ctx.read().await;
-            if err_on_disconnect && js.client().connection_state() == State::Disconnected {
+            if err_on_disconnect
+                && ctx.read().await.client().connection_state() == State::Disconnected
+            {
                 return Err(NatsrpyError::Disconnected);
             }
-            js.publish_message(async_nats::message::OutboundMessage {
-                subject: Subject::from(subject),
-                payload: data,
-                headers: headermap,
-                reply: reply.map(Subject::from),
-            })
-            .await?;
+            ctx.read()
+                .await
+                .publish_message(async_nats::message::OutboundMessage {
+                    subject: Subject::from(subject),
+                    payload: data,
+                    headers: headermap,
+                    reply: reply.map(Subject::from),
+                })
+                .await?;
             Ok(())
         })
     }
 
     pub fn create_kv<'py>(
         &self,
         py: Python<'py>,
-        config: Bound<'py, KVConfig>,
+        config: &Bound<'py, KVConfig>,
     ) -> NatsrpyResult<Bound<'py, PyAny>> {
         let ctx = self.ctx.clone();
         let config = config.borrow().deref().clone().try_into()?;
@@ -91,7 +95,7 @@ impl JetStream {
     pub fn update_kv<'py>(
         &self,
         py: Python<'py>,
-        config: Bound<'py, KVConfig>,
+        config: &Bound<'py, KVConfig>,
     ) -> NatsrpyResult<Bound<'py, PyAny>> {
         let ctx = self.ctx.clone();
         let config = config.borrow().deref().clone().try_into()?;

src/js/kv.rs

@@ -52,7 +52,8 @@ impl KVConfig {
         placement=None,
         limit_markers=None,
     ))]
-    pub fn __new__(
+    #[must_use]
+    pub const fn __new__(
         bucket: String,
         description: Option<String>,
         max_value_size: Option<i32>,
@@ -100,29 +101,32 @@ impl TryFrom<KVConfig> for async_nats::jetstream::kv::Config {
             history: value.history.unwrap_or_default(),
             max_age: value
                 .max_age
-                .map(|val| std::time::Duration::from_secs_f32(val))
+                .map(std::time::Duration::from_secs_f32)
                 .unwrap_or_default(),
             max_bytes: value.max_bytes.unwrap_or_default(),
             storage: value.storage.unwrap_or_default().into(),
             num_replicas: value.num_replicas.unwrap_or_default(),
-            republish: value.republish.map(|r| r.into()),
-            mirror: value.mirror.map(|m| m.try_into()).transpose()?,
+            republish: value.republish.map(std::convert::Into::into),
+            mirror: value
+                .mirror
+                .map(std::convert::TryInto::try_into)
+                .transpose()?,
             sources: value
                 .sources
                 .map(|srcs| {
                     // Collect the results of trying to convert each source, and if any conversion
                     // fails, return the error
                     srcs.into_iter()
-                        .map(|s| s.try_into())
+                        .map(std::convert::TryInto::try_into)
                         .collect::<Result<Vec<_>, _>>()
                 })
                 // Now it's a Option<Result<_>>,
                 // we transpose it to Result<Option<_>>
                 .transpose()?,
             mirror_direct: value.mirror_direct.unwrap_or_default(),
             compression: value.compression.unwrap_or_default(),
-            placement: value.placement.map(|p| p.into()),
-            limit_markers: value.limit_markers.map(|val| Duration::from_secs_f32(val)),
+            placement: value.placement.map(std::convert::Into::into),
+            limit_markers: value.limit_markers.map(Duration::from_secs_f32),
         })
     }
 }
@@ -133,6 +137,7 @@ pub struct KeyValue {
 }
 
 impl KeyValue {
+    #[must_use]
     pub fn new(store: async_nats::jetstream::kv::Store) -> Self {
         Self {
             store: Arc::new(RwLock::new(store)),
@@ -145,27 +150,25 @@ impl KeyValue {
     pub fn get<'py>(&self, py: Python<'py>, key: String) -> NatsrpyResult<Bound<'py, PyAny>> {
         let store = self.store.clone();
         natsrpy_future(py, async move {
-            let kv = store.read().await;
-            if let Some(data) = kv.get(key).await? {
-                let pybytes = Python::attach(move |gil| PyBytes::new(gil, &data).unbind());
-                Ok(Some(pybytes))
-            } else {
-                Ok(None)
-            }
+            Ok(store
+                .read()
+                .await
+                .get(key)
+                .await?
+                .map(|data| Python::attach(move |gil| PyBytes::new(gil, &data).unbind())))
         })
     }
 
     pub fn put<'py>(
         &self,
         py: Python<'py>,
         key: String,
-        value: Bound<'py, PyBytes>,
+        value: &Bound<'py, PyBytes>,
     ) -> NatsrpyResult<Bound<'py, PyAny>> {
         let store = self.store.clone();
         let data = bytes::Bytes::copy_from_slice(value.as_bytes());
         natsrpy_future(py, async move {
-            let kv = store.read().await;
-            let status = kv.put(key, data).await?;
+            let status = store.read().await.put(key, data).await?;
             Ok(status)
         })
     }

src/js/stream.rs

@@ -36,7 +36,7 @@ impl From<Republish> for async_nats::jetstream::stream::Republish {
         Self {
             source: value.source.clone(),
             destination: value.destination.clone(),
-            headers_only: value.headers_only.clone(),
+            headers_only: value.headers_only,
         }
     }
 }
@@ -52,10 +52,11 @@ pub struct External {
 impl External {
     #[new]
     #[pyo3(signature = (api_prefix, delivery_prefix=None))]
-    pub fn __new__(api_prefix: String, delivery_prefix: Option<String>) -> Self {
+    #[must_use] 
+    pub const fn __new__(api_prefix: String, delivery_prefix: Option<String>) -> Self {
         Self {
-            api_prefix: api_prefix,
-            delivery_prefix: delivery_prefix,
+            api_prefix,
+            delivery_prefix,
         }
     }
 }
@@ -104,18 +105,18 @@ impl TryFrom<Source> for async_nats::jetstream::stream::Source {
         Ok(Self {
             name: value.name.clone(),
             filter_subject: value.filter_subject.clone(),
-            external: value.external.as_ref().map(|e| e.into()),
+            external: value.external.as_ref().map(std::convert::Into::into),
             start_sequence: value.start_sequence,
             start_time: value
                 .start_time
-                .map(|val| time::OffsetDateTime::from_unix_timestamp(val))
+                .map(time::OffsetDateTime::from_unix_timestamp)
                 .transpose()?,
             domain: value.domain.clone(),
             subject_transforms: value
                 .subject_transforms
-                .clone()
+                
                 .into_iter()
-                .map(|val| val.into())
+                .map(std::convert::Into::into)
                 .collect(),
         })
     }
@@ -168,6 +169,7 @@ pub struct Placement {
 impl Placement {
     #[new]
     #[pyo3(signature=(cluster=None, tags=None))]
+    #[must_use] 
     pub fn __new__(cluster: Option<String>, tags: Option<Vec<String>>) -> Self {
         Self {
             cluster,

src/lib.rs

@@ -1,22 +1,41 @@
+#![warn(
+    // Base lints.
+    clippy::all,
+    // Some pedantic lints.
+    clippy::pedantic,
+    // New lints which are cool.
+    clippy::nursery,
+)]
+#![
+    allow(
+        // I don't care about this.
+        clippy::module_name_repetitions, 
+        // Yo, the hell you should put
+        // it in docs, if signature is clear as sky.
+        clippy::missing_errors_doc,
+        // Because pythonic way is
+        // to have many args with defaults.
+        clippy::too_many_arguments    
+)]
 pub mod exceptions;
 pub mod js;
+pub mod message;
 pub mod nats_cls;
 pub mod subscription;
 pub mod utils;
-pub mod message;
 
 #[pyo3::pymodule]
 pub mod _inner {
     use pyo3::{Bound, PyResult, types::PyModule};
 
     use crate::utils::py::PyModuleSubmoduleExt;
 
+    #[pymodule_export]
+    use super::message::Message;
     #[pymodule_export]
     use super::nats_cls::NatsCls;
     #[pymodule_export]
     use super::subscription::Subscription;
-    #[pymodule_export]
-    use super::message::Message;
 
     #[pymodule_export]
     use super::js::pymod as js;

src/message.rs

@@ -6,6 +6,7 @@ use pyo3::{
 use crate::exceptions::rust_err::NatsrpyResult;
 
 #[pyo3::pyclass(get_all, set_all)]
+#[derive(Debug)]
 pub struct Message {
     pub subject: String,
     pub reply: Option<String>,
@@ -17,23 +18,22 @@ pub struct Message {
 }
 
 impl Message {
-    pub fn from_nats_message<'py>(
-        py: Python<'py>,
+    pub fn from_nats_message(
+        py: Python<'_>,
         message: async_nats::Message,
     ) -> NatsrpyResult<Self> {
         let headers = PyDict::new(py);
         if let Some(headermap) = message.headers {
             for (header_name, header_val) in headermap.iter() {
                 let py_val = header_val
                     .iter()
-                    .map(|val| val.to_string())
+                    .map(std::string::ToString::to_string)
                     .collect::<Vec<_>>();
                 if py_val.len() == 1 {
                     headers.set_item(header_name.to_string(), py_val.first())?;
                     continue;
-                } else {
-                    headers.set_item(header_name.to_string(), py_val)?;
                 }
+                headers.set_item(header_name.to_string(), py_val)?;
             }
         }
         Ok(Self {
@@ -50,20 +50,15 @@ impl Message {
 
 #[pyo3::pymethods]
 impl Message {
+    #[must_use] 
     pub fn __repr__(&self) -> String {
-        self.to_string()
-    }
-}
-
-impl ToString for Message {
-    fn to_string(&self) -> String {
         format!(
-            r#"Message<subject="{subject}", reply={reply}, payload={payload}, headers={headers}, description={description}, length={len}>"#,
+            r#"Message<subject="{subject}", reply={reply:?}, payload={payload}, headers={headers}, description={description:?}, length={len}>"#,
             subject = self.subject,
-            reply = format!("{:?}", self.reply),
-            payload = self.payload.to_string(),
-            headers = self.headers.to_string(),
-            description = format!("{:?}", self.description),
+            reply = self.reply,
+            payload = self.payload,
+            headers = self.headers,
+            description = self.description,
             len = self.length,
         )
     }