refactor: update filter check methods to use references

- Changed `check` method signatures in `Filter` trait and its implementations to use references for `Client` and `Update`.
- Updated `Context`, `Dispatcher`, `And`, `Command`, `Not`, `Or`, and `Handler` to reflect these changes.

lib/ferogram/src/context.rs

@@ -849,11 +849,7 @@ impl Context {
     ) -> Result<Update, crate::Error> {
         loop {
             if let Some(update) = self.wait_for_update(timeout).await {
-                if filter
-                    .check(self.client.clone(), update.clone())
-                    .await
-                    .is_continue()
-                {
+                if filter.check(&self.client, &update).await.is_continue() {
                     return Ok(update);
                 }
             } else {

lib/ferogram/src/dispatcher.rs

@@ -274,7 +274,7 @@ mod tests {
         Dispatcher::default()
             .router(|router| router)
             .router(|router| {
-                router.handler(handler::then(|_: Client, _: Update| async { Ok(()) }))
+                router.register(handler::then(|_: Client, _: Update| async { Ok(()) }))
             });
     }
 }

lib/ferogram/src/filter.rs

@@ -21,7 +21,7 @@ use crate::Flow;
 #[async_trait]
 pub trait Filter: CloneFilter + Send + Sync + 'static {
     /// Checks if the update should be handled.
-    async fn check(&mut self, client: Client, update: Update) -> Flow;
+    async fn check(&mut self, client: &Client, update: &Update) -> Flow;
 
     /// Wrappes `self` and `second` into [`And`] filter.
     fn and<S: Filter>(self, second: S) -> And
@@ -67,12 +67,12 @@ pub trait Filter: CloneFilter + Send + Sync + 'static {
 #[async_trait]
 impl<T: Clone, F, O> Filter for T
 where
-    T: Fn(Client, Update) -> F + Send + Sync + 'static,
+    T: FnMut(Client, Update) -> F + Send + Sync + 'static,
     F: Future<Output = O> + Send + Sync + 'static,
     O: Into<Flow>,
 {
-    async fn check(&mut self, client: Client, update: Update) -> Flow {
-        self(client, update).await.into()
+    async fn check(&mut self, client: &Client, update: &Update) -> Flow {
+        self(client.clone(), update.clone()).await.into()
     }
 }
 
@@ -83,8 +83,8 @@ where
     F: Future<Output = O> + Send + Sync + 'static,
     O: Into<Flow>,
 {
-    async fn check(&mut self, client: Client, update: Update) -> Flow {
-        self(client, update).await.into()
+    async fn check(&mut self, client: &Client, update: &Update) -> Flow {
+        self(client.clone(), update.clone()).await.into()
     }
 }
 

lib/ferogram/src/filters/and.rs

@@ -19,8 +19,8 @@ pub struct And {
 
 #[async_trait]
 impl Filter for And {
-    async fn check(&mut self, client: Client, update: Update) -> Flow {
-        let mut first_flow = self.first.check(client.clone(), update.clone()).await;
+    async fn check(&mut self, client: &Client, update: &Update) -> Flow {
+        let mut first_flow = self.first.check(client, update).await;
 
         if first_flow.is_continue() {
             let second_flow = self.second.check(client, update).await;

lib/ferogram/src/filters/command.rs

@@ -45,7 +45,7 @@ impl Command {
 
 #[async_trait]
 impl Filter for Command {
-    async fn check(&mut self, client: Client, update: Update) -> Flow {
+    async fn check(&mut self, client: &Client, update: &Update) -> Flow {
         let command = self.command.clone();
         let splitted = command.split_whitespace().collect::<Vec<_>>();
 

lib/ferogram/src/filters/not.rs

@@ -18,11 +18,7 @@ pub struct Not {
 
 #[async_trait]
 impl Filter for Not {
-    async fn check(&mut self, client: Client, update: Update) -> Flow {
-        self.filter
-            .check(client.clone(), update.clone())
-            .await
-            .is_break()
-            .into()
+    async fn check(&mut self, client: &Client, update: &Update) -> Flow {
+        self.filter.check(client, update).await.is_break().into()
     }
 }

lib/ferogram/src/filters/or.rs

@@ -19,8 +19,8 @@ pub struct Or {
 
 #[async_trait]
 impl Filter for Or {
-    async fn check(&mut self, client: Client, update: Update) -> Flow {
-        let first_flow = self.first.check(client.clone(), update.clone()).await;
+    async fn check(&mut self, client: &Client, update: &Update) -> Flow {
+        let first_flow = self.first.check(client, update).await;
 
         if first_flow.is_continue() {
             first_flow

lib/ferogram/src/handler.rs

@@ -132,7 +132,7 @@ impl Handler {
     pub(crate) async fn check(&mut self, client: &Client, update: &Update) -> Flow {
         if self.update_type == *update {
             if let Some(ref mut filter) = self.filter {
-                filter.check(client.clone(), update.clone()).await
+                filter.check(client, update).await
             } else {
                 flow::continue_now()
             }