Remove unnecessary mutability

Signed-off-by: Jim Crossley <[email protected]>

Author: jcrossley3

modules/importer/src/runner/clearly_defined_curation/handler.rs

@@ -24,11 +24,7 @@ where
 {
     type Error = Error;
 
-    fn process(
-        &mut self,
-        path: &Path,
-        relative_path: &Path,
-    ) -> Result<(), HandlerError<Self::Error>> {
+    fn process(&self, path: &Path, relative_path: &Path) -> Result<(), HandlerError<Self::Error>> {
         if let Some(head) = relative_path.components().next() {
             if let Some(head) = head.as_os_str().to_str() {
                 if self.types.iter().any(|e| e.matches(head)) {
@@ -58,7 +54,7 @@ impl<C> ClearlyDefinedHandler<C>
 where
     C: Callbacks<Vec<u8>> + Send + 'static,
 {
-    fn process_file(&mut self, path: &Path, rel_path: &Path) -> Result<(), ProcessingError> {
+    fn process_file(&self, path: &Path, rel_path: &Path) -> Result<(), ProcessingError> {
         let curation = match path.extension().map(|s| s.to_string_lossy()).as_deref() {
             Some("yaml") => {
                 let mut bytes = Vec::new();

modules/importer/src/runner/clearly_defined_curation/mod.rs

@@ -52,13 +52,13 @@ impl<C: RunContext> Context<C> {
 }
 
 impl<C: RunContext> Callbacks<Vec<u8>> for Context<C> {
-    fn loading_error(&mut self, path: PathBuf, message: String) {
+    fn loading_error(&self, path: PathBuf, message: String) {
         self.report
             .lock()
             .add_error(Phase::Validation, path.to_string_lossy(), message);
     }
 
-    fn process(&mut self, path: &Path, curation: Vec<u8>) -> Result<(), CallbackError> {
+    fn process(&self, path: &Path, curation: Vec<u8>) -> Result<(), CallbackError> {
         if let Err(err) = self.store(path, curation) {
             self.report
                 .lock()

modules/importer/src/runner/common/walker/git.rs

@@ -27,17 +27,13 @@ pub enum HandlerError<T> {
 pub trait Handler: Send + 'static {
     type Error: Display + Debug;
 
-    fn process(
-        &mut self,
-        path: &Path,
-        relative_path: &Path,
-    ) -> Result<(), HandlerError<Self::Error>>;
+    fn process(&self, path: &Path, relative_path: &Path) -> Result<(), HandlerError<Self::Error>>;
 }
 
 impl Handler for () {
     type Error = Infallible;
 
-    fn process(&mut self, _: &Path, _: &Path) -> Result<(), HandlerError<Self::Error>> {
+    fn process(&self, _: &Path, _: &Path) -> Result<(), HandlerError<Self::Error>> {
         Ok(())
     }
 }
@@ -173,12 +169,12 @@ where
     /// Run the walker
     #[instrument(skip(self), ret)]
     pub async fn run(self) -> Result<Continuation, Error> {
-        tokio::task::spawn_blocking(move || self.run_sync()).await?
+        tokio::task::spawn_blocking(|| self.run_sync()).await?
     }
 
     /// Sync version, as all git functions are sync
     #[instrument(skip(self))]
-    fn run_sync(mut self) -> Result<Continuation, Error> {
+    fn run_sync(self) -> Result<Continuation, Error> {
         log::debug!("Starting run for: {}", self.source);
 
         let working_dir = self
@@ -407,7 +403,7 @@ where
     }
 
     #[instrument(skip(self, changes), err)]
-    fn walk(&mut self, base: &Path, changes: &Option<HashSet<PathBuf>>) -> Result<(), Error> {
+    fn walk(&self, base: &Path, changes: &Option<HashSet<PathBuf>>) -> Result<(), Error> {
         let mut collected = vec![];
 
         for entry in WalkDir::new(base)

modules/importer/src/runner/common/walker/mod.rs

@@ -14,13 +14,13 @@ pub enum CallbackError {
 pub trait Callbacks<T>: Send + 'static {
     /// Handle an error while loading the file
     #[allow(unused)]
-    fn loading_error(&mut self, path: PathBuf, message: String) {}
+    fn loading_error(&self, path: PathBuf, message: String) {}
 
     /// Process the file.
     ///
     /// Any error returned will terminate the walk with a critical error.
     #[allow(unused)]
-    fn process(&mut self, path: &Path, document: T) -> Result<(), CallbackError> {
+    fn process(&self, path: &Path, document: T) -> Result<(), CallbackError> {
         Ok(())
     }
 }

modules/importer/src/runner/cve/handler.rs

@@ -22,11 +22,7 @@ where
 {
     type Error = Error;
 
-    fn process(
-        &mut self,
-        path: &Path,
-        relative_path: &Path,
-    ) -> Result<(), HandlerError<Self::Error>> {
+    fn process(&self, path: &Path, relative_path: &Path) -> Result<(), HandlerError<Self::Error>> {
         // Get the year, as we walk with a base of `cves`, that must be the year folder.
         // If it is not, we skip it.
         let Some(year) = relative_path
@@ -69,7 +65,7 @@ impl<C> CveHandler<C>
 where
     C: Callbacks<Vec<u8>> + Send + 'static,
 {
-    fn process_file(&mut self, path: &Path, rel_path: &Path) -> Result<(), ProcessingError> {
+    fn process_file(&self, path: &Path, rel_path: &Path) -> Result<(), ProcessingError> {
         let cve = match path.extension().map(|s| s.to_string_lossy()).as_deref() {
             Some("json") => {
                 let mut data = Vec::new();

modules/importer/src/runner/cve/mod.rs

@@ -52,13 +52,13 @@ impl<C: RunContext> Context<C> {
 }
 
 impl<C: RunContext> Callbacks<Vec<u8>> for Context<C> {
-    fn loading_error(&mut self, path: PathBuf, message: String) {
+    fn loading_error(&self, path: PathBuf, message: String) {
         self.report
             .lock()
             .add_error(Phase::Validation, path.to_string_lossy(), message);
     }
 
-    fn process(&mut self, path: &Path, cve: Vec<u8>) -> Result<(), CallbackError> {
+    fn process(&self, path: &Path, cve: Vec<u8>) -> Result<(), CallbackError> {
         if let Err(err) = self.store(path, cve) {
             self.report
                 .lock()

modules/importer/src/runner/osv/handler.rs

@@ -17,11 +17,7 @@ where
 {
     type Error = Error;
 
-    fn process(
-        &mut self,
-        path: &Path,
-        relative_path: &Path,
-    ) -> Result<(), HandlerError<Self::Error>> {
+    fn process(&self, path: &Path, relative_path: &Path) -> Result<(), HandlerError<Self::Error>> {
         match self.process_file(path, relative_path) {
             Ok(()) => Ok(()),
             Err(ProcessingError::Critical(err)) => {
@@ -41,7 +37,7 @@ impl<C> OsvHandler<C>
 where
     C: Callbacks<Vec<u8>> + Send + 'static,
 {
-    fn process_file(&mut self, path: &Path, rel_path: &Path) -> Result<(), ProcessingError> {
+    fn process_file(&self, path: &Path, rel_path: &Path) -> Result<(), ProcessingError> {
         let osv = match path.extension().map(|s| s.to_string_lossy()).as_deref() {
             Some("yaml") | Some("json") => {
                 let mut data = Vec::new();

modules/importer/src/runner/osv/mod.rs

@@ -79,13 +79,13 @@ impl<C: RunContext> Context<C> {
 }
 
 impl<C: RunContext> Callbacks<Vec<u8>> for Context<C> {
-    fn loading_error(&mut self, path: PathBuf, message: String) {
+    fn loading_error(&self, path: PathBuf, message: String) {
         self.report
             .lock()
             .add_error(Phase::Validation, path.to_string_lossy(), message);
     }
 
-    fn process(&mut self, path: &Path, osv: Vec<u8>) -> Result<(), CallbackError> {
+    fn process(&self, path: &Path, osv: Vec<u8>) -> Result<(), CallbackError> {
         if let Err(err) = self.store(path, osv) {
             self.report
                 .lock()