Add error messages

src/bin/main.rs

@@ -3,13 +3,11 @@ use std::time::Instant;
 
 use anyhow::Result;
 use clap::{Parser, ValueHint};
-
-use log::info;
+use log::{error, info};
 use rayon::prelude::*;
-use walkdir::{DirEntry, WalkDir};
-
 use rust_python_linter::linter::check_path;
 use rust_python_linter::message::Message;
+use walkdir::{DirEntry, WalkDir};
 
 fn set_up_logging(verbose: bool) -> Result<()> {
     fern::Dispatch::new()
@@ -74,7 +72,12 @@ fn main() -> Result<()> {
     let start = Instant::now();
     let messages: Vec<Message> = files
         .par_iter()
-        .map(|entry| check_path(entry.path()).unwrap())
+        .map(|entry| {
+            check_path(entry.path()).unwrap_or_else(|e| {
+                error!("Failed to check {}: {e:?}", entry.path().to_string_lossy());
+                vec![]
+            })
+        })
         .flatten()
         .collect();
     let duration = start.elapsed();

src/cache.rs

@@ -2,6 +2,8 @@ use std::borrow::Cow;
 use std::os::unix::fs::MetadataExt;
 use std::path::Path;
 
+use cacache::Error::EntryNotFound;
+use log::error;
 use serde::{Deserialize, Serialize};
 
 use crate::message::Message;
@@ -33,19 +35,21 @@ fn cache_key(path: &Path) -> Cow<str> {
 }
 
 pub fn get(path: &Path) -> Option<Vec<Message>> {
-    if let Ok(encoded) = cacache::read_sync(cache_dir(), cache_key(path)) {
-        if let Ok(file_metadata) = path.metadata() {
-            if let Ok(CheckResult { metadata, messages }) =
-                bincode::deserialize::<CheckResult>(&encoded[..])
-            {
-                if file_metadata.size() == metadata.size && file_metadata.mtime() == metadata.mtime
-                {
-                    return Some(messages);
+    match cacache::read_sync(cache_dir(), cache_key(path)) {
+        Ok(encoded) => match path.metadata() {
+            Ok(m) => match bincode::deserialize::<CheckResult>(&encoded[..]) {
+                Ok(CheckResult { metadata, messages }) => {
+                    if m.size() == metadata.size && m.mtime() == metadata.mtime {
+                        return Some(messages);
+                    }
                 }
-            }
-        }
+                Err(e) => error!("Failed to deserialize encoded cache entry: {e:?}"),
+            },
+            Err(e) => error!("Failed to read metadata from path: {e:?}"),
+        },
+        Err(EntryNotFound(_, _)) => {}
+        Err(e) => error!("Failed to read from cache: {e:?}"),
     }
-
     None
 }
 
@@ -58,10 +62,13 @@ pub fn set(path: &Path, messages: &[Message]) {
             },
             messages,
         };
-        let _ = cacache::write_sync(
+        match cacache::write_sync(
             cache_dir(),
             cache_key(path),
             bincode::serialize(&check_result).unwrap(),
-        );
+        ) {
+            Ok(_) => {}
+            Err(e) => error!("Failed to write to cache: {e:?}"),
+        }
     }
 }

src/linter.rs

@@ -23,9 +23,9 @@ struct CheckResult {
 pub fn check_path(path: &Path) -> Result<Vec<Message>> {
     // TODO(charlie): These specific files are causing a stack overflow.
     if path.to_string_lossy().eq_ignore_ascii_case(
-         "../../spring-experiments/spr_experiments/spr_experiments/assayworks/experiments/order_20220204/pipeline_steps.py") ||
+         "../spring-experiments/spr_experiments/spr_experiments/assayworks/experiments/order_20220204/pipeline_steps.py") ||
         path.to_string_lossy().eq_ignore_ascii_case
-        ( "../../spring-experiments/spr_platform/spr_platform/data_index/bigquery_index.py")
+        ( "../spring-experiments/spr_platform/spr_platform/data_index/bigquery_index.py")
     {
         return Ok(vec![]);
     }

src/message.rs

@@ -1,8 +1,9 @@
+use std::fmt;
+use std::path::PathBuf;
+
 use colored::Colorize;
 use rustpython_parser::ast::Location;
 use serde::{Deserialize, Serialize};
-use std::fmt;
-use std::path::PathBuf;
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "Location")]

src/parser.rs

@@ -1,10 +1,11 @@
-use anyhow::Result;
-use rustpython_parser::ast::Suite;
-use rustpython_parser::parser;
 use std::fs::File;
 use std::io::{BufReader, Read};
 use std::path::Path;
 
+use anyhow::Result;
+use rustpython_parser::ast::Suite;
+use rustpython_parser::parser;
+
 pub fn parse(path: &Path) -> Result<Suite> {
     let file = File::open(path)?;
     let mut buf_reader = BufReader::new(file);