Подключение sentry.

src/parser/mod.rs

@@ -1,12 +1,13 @@
+use crate::parser::LessonParseResult::{Lessons, Street};
 use crate::parser::schema::LessonType::Break;
 use crate::parser::schema::{
-    Day, Lesson, LessonSubGroup, LessonTime, LessonType, ParseError, ParseResult, ScheduleEntry,
+    Day, ErrorCell, ErrorCellPos, Lesson, LessonSubGroup, LessonTime, LessonType, ParseError,
+    ParseResult, ScheduleEntry,
 };
-use crate::parser::LessonParseResult::{Lessons, Street};
-use calamine::{open_workbook_from_rs, Reader, Xls};
+use calamine::{Reader, Xls, open_workbook_from_rs};
 use chrono::{DateTime, Duration, NaiveDateTime, Utc};
-use fuzzy_matcher::skim::SkimMatcherV2;
 use fuzzy_matcher::FuzzyMatcher;
+use fuzzy_matcher::skim::SkimMatcherV2;
 use regex::Regex;
 use std::collections::HashMap;
 use std::io::Cursor;
@@ -56,9 +57,8 @@ fn get_string_from_cell(worksheet: &WorkSheet, row: u32, col: u32) -> Option<Str
         return None;
     }
 
-    static NL_RE: LazyLock<Regex, fn() -> Regex> =
-        LazyLock::new(|| Regex::new(r"[\n\r]+").unwrap());
-    static SP_RE: LazyLock<Regex, fn() -> Regex> = LazyLock::new(|| Regex::new(r"\s+").unwrap());
+    static NL_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[\n\r]+").unwrap());
+    static SP_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\s+").unwrap());
 
     let trimmed_data = SP_RE
         .replace_all(&NL_RE.replace_all(&cell_data, " "), " ")
@@ -252,7 +252,7 @@ fn parse_lesson(
 
         let raw_name = raw_name_opt.unwrap();
 
-        static OTHER_STREET_RE: LazyLock<Regex, fn() -> Regex> =
+        static OTHER_STREET_RE: LazyLock<Regex> =
             LazyLock::new(|| Regex::new(r"^[А-Я][а-я]+,?\s?[0-9]+$").unwrap());
 
         if OTHER_STREET_RE.is_match(&raw_name) {
@@ -275,7 +275,9 @@ fn parse_lesson(
             .filter(|time| time.xls_range.1.0 == cell_range.1.0)
             .collect::<Vec<&InternalTime>>();
 
-        let end_time = end_time_arr.first().ok_or(ParseError::LessonTimeNotFound)?;
+        let end_time = end_time_arr
+            .first()
+            .ok_or(ParseError::LessonTimeNotFound(ErrorCellPos { row, column }))?;
 
         let range: Option<[u8; 2]> = if time.default_index != None {
             let default = time.default_index.unwrap() as u8;
@@ -389,14 +391,12 @@ fn parse_cabinets(worksheet: &WorkSheet, row: u32, column: u32) -> Vec<String> {
 
 /// Getting the "pure" name of the lesson and list of teachers from the text of the lesson cell.
 fn parse_name_and_subgroups(name: &String) -> Result<(String, Vec<LessonSubGroup>), ParseError> {
-    static LESSON_RE: LazyLock<Regex, fn() -> Regex> =
+    static LESSON_RE: LazyLock<Regex> =
         LazyLock::new(|| Regex::new(r"(?:[А-Я][а-я]+[А-Я]{2}(?:\([0-9][а-я]+\))?)+$").unwrap());
-    static TEACHER_RE: LazyLock<Regex, fn() -> Regex> =
+    static TEACHER_RE: LazyLock<Regex> =
         LazyLock::new(|| Regex::new(r"([А-Я][а-я]+)([А-Я])([А-Я])(?:\(([0-9])[а-я]+\))?").unwrap());
-    static CLEAN_RE: LazyLock<Regex, fn() -> Regex> =
-        LazyLock::new(|| Regex::new(r"[\s.,]+").unwrap());
-    static END_CLEAN_RE: LazyLock<Regex, fn() -> Regex> =
-        LazyLock::new(|| Regex::new(r"[.\s]+$").unwrap());
+    static CLEAN_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[\s.,]+").unwrap());
+    static END_CLEAN_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[.\s]+$").unwrap());
 
     let (teachers, lesson_name) = {
         let clean_name = CLEAN_RE.replace_all(&name, "").to_string();
@@ -423,14 +423,9 @@ fn parse_name_and_subgroups(name: &String) -> Result<(String, Vec<LessonSubGroup
 
     for captures in teacher_it {
         subgroups.push(LessonSubGroup {
-            number: if let Some(capture) = captures.get(4) {
-                capture
-                    .as_str()
-                    .to_string()
-                    .parse::<u8>()
-                    .map_err(|_| ParseError::SubgroupIndexParsingFailed)?
-            } else {
-                0
+            number: match captures.get(4) {
+                Some(capture) => capture.as_str().to_string().parse::<u8>().unwrap(),
+                None => 0,
             },
             cabinet: None,
             teacher: format!(
@@ -665,10 +660,12 @@ pub fn parse_xls(buffer: &Vec<u8>) -> Result<ParseResult, ParseError> {
 
                     // time
                     let time_range = {
-                        static TIME_RE: LazyLock<Regex, fn() -> Regex> =
+                        static TIME_RE: LazyLock<Regex> =
                             LazyLock::new(|| Regex::new(r"(\d+\.\d+)-(\d+\.\d+)").unwrap());
 
-                        let parse_res = TIME_RE.captures(&time).ok_or(ParseError::GlobalTime)?;
+                        let parse_res = TIME_RE.captures(&time).ok_or(ParseError::GlobalTime(
+                            ErrorCell::new(row, lesson_time_column, time.clone()),
+                        ))?;
 
                         let start_match = parse_res.get(1).unwrap().as_str();
                         let start_parts: Vec<&str> = start_match.split(".").collect();

src/parser/schema.rs

@@ -1,5 +1,5 @@
 use chrono::{DateTime, Utc};
-use derive_more::Display;
+use derive_more::{Display, Error};
 use serde::{Deserialize, Serialize, Serializer};
 use serde_repr::{Deserialize_repr, Serialize_repr};
 use std::collections::HashMap;
@@ -115,10 +115,33 @@ pub struct ParseResult {
     pub teachers: HashMap<String, ScheduleEntry>,
 }
 
-#[derive(Debug, Display, Clone, ToSchema)]
+#[derive(Clone, Debug, Display, Error, ToSchema)]
+#[display("row {row}, column {column}")]
+pub struct ErrorCellPos {
+    pub row: u32,
+    pub column: u32,
+}
+
+#[derive(Clone, Debug, Display, Error, ToSchema)]
+#[display("'{data}' at {pos}")]
+pub struct ErrorCell {
+    pub pos: ErrorCellPos,
+    pub data: String,
+}
+
+impl ErrorCell {
+    pub fn new(row: u32, column: u32, data: String) -> Self {
+        Self {
+            pos: ErrorCellPos { row, column },
+            data,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Display, Error, ToSchema)]
 pub enum ParseError {
     /// Errors related to reading XLS file.
-    #[display("{}: Failed to read XLS file.", "_0")]
+    #[display("{_0:?}: Failed to read XLS file.")]
     #[schema(value_type = String)]
     BadXLS(Arc<calamine::XlsError>),
 
@@ -131,16 +154,12 @@ pub enum ParseError {
     UnknownWorkSheetRange,
 
     /// Failed to read the beginning and end of the lesson from the line
-    #[display("Failed to read lesson start and end times from string.")]
-    GlobalTime,
+    #[display("Failed to read lesson start and end times from {_0}.")]
+    GlobalTime(ErrorCell),
 
     /// Not found the beginning and the end corresponding to the lesson.
-    #[display("No start and end times matching the lesson was found.")]
-    LessonTimeNotFound,
-
-    /// Failed to read the subgroup index.
-    #[display("Failed to read subgroup index.")]
-    SubgroupIndexParsingFailed,
+    #[display("No start and end times matching the lesson (at {_0}) was found.")]
+    LessonTimeNotFound(ErrorCellPos),
 }
 
 impl Serialize for ParseError {
@@ -154,11 +173,8 @@ impl Serialize for ParseError {
             ParseError::UnknownWorkSheetRange => {
                 serializer.serialize_str("UNKNOWN_WORK_SHEET_RANGE")
             }
-            ParseError::GlobalTime => serializer.serialize_str("GLOBAL_TIME"),
-            ParseError::LessonTimeNotFound => serializer.serialize_str("LESSON_TIME_NOT_FOUND"),
-            ParseError::SubgroupIndexParsingFailed => {
-                serializer.serialize_str("SUBGROUP_INDEX_PARSING_FAILED")
-            }
+            ParseError::GlobalTime(_) => serializer.serialize_str("GLOBAL_TIME"),
+            ParseError::LessonTimeNotFound(_) => serializer.serialize_str("LESSON_TIME_NOT_FOUND"),
         }
     }
 }