Refactoring and progagating changes

RPG-Alex · RPG-Alex · commit 4d588320f2a5 · 2025-12-18T12:11:10.000+08:00
diff --git a/src/ast.rs b/src/ast.rs
@@ -42,13 +42,13 @@ impl ParsedSqlFile {
 
     /// Getter method for returning the current object's file's path
     #[must_use]
-    pub fn path(&self) -> &Path {
+    pub fn path(&self) -> Option<&Path> {
         self.file.path()
     }
 
     /// Getter that returns an [`PathBuf`] for the path rather than `&Path`
     #[must_use]
-    pub fn path_into_path_buf(&self) -> PathBuf {
+    pub fn path_into_path_buf(&self) -> Option<PathBuf> {
         self.file.path_into_path_buf()
     }
 
@@ -108,7 +108,7 @@ mod tests {
         fs::write(&file_path, sql)?;
         let sql_file = SqlFile::new(&file_path)?;
         let parsed = ParsedSqlFile::parse(sql_file)?;
-        assert_eq!(parsed.path(), file_path.as_path());
+        assert_eq!(parsed.path(), Some(file_path.as_path()));
         assert_eq!(parsed.content(), sql);
         assert_eq!(parsed.statements().len(), 1);
         let _ = fs::remove_dir_all(&base);
diff --git a/src/comments.rs b/src/comments.rs
@@ -435,9 +435,9 @@ mod tests {
             let filename = file
                 .file()
                 .path()
-                .file_name()
+                .and_then(|p| p.file_name())
                 .and_then(|s| s.to_str())
-                .unwrap_or_else(|| panic!("test file name should be valid UTF-8"));
+                .ok_or("Should have a file name")?;
 
             match filename {
                 "with_single_line_comments.sql" => {
@@ -536,17 +536,16 @@ mod tests {
         let path = Path::new("sql_files");
         let set = SqlFileSet::new(path, &[])?;
         let parsed_set = ParsedSqlFileSet::parse_all(set)?;
-        let file = {
-            let Some(f) = parsed_set.files().iter().find(|f| {
-                let Some(path) = f.file().path().to_str() else {
-                    return false;
-                };
-                path.ends_with("with_single_line_comments.sql")
-            }) else {
-                panic!("with_single_line_comments.sql should be present");
-            };
-            f
-        };
+        let file = parsed_set
+            .files()
+            .iter()
+            .find(|f| {
+                f.file()
+                    .path()
+                    .and_then(|p| p.to_str())
+                    .is_some_and(|p| p.ends_with("with_single_line_comments.sql"))
+            })
+            .ok_or("with_single_line_comments.sql should be present")?;
 
         let comments = Comments::parse_all_comments_from_file(file)?;
         let comments = comments.comments();
@@ -574,17 +573,17 @@ mod tests {
         let path = Path::new("sql_files");
         let set = SqlFileSet::new(path, &[])?;
         let parsed_set = ParsedSqlFileSet::parse_all(set)?;
-        let file = {
-            let Some(f) = parsed_set.files().iter().find(|f| {
-                let Some(path) = f.file().path().to_str() else {
-                    return false;
-                };
-                path.ends_with("with_multiline_comments.sql")
-            }) else {
-                panic!("with_multiline_comments.sql should be present");
-            };
-            f
-        };
+        let file = parsed_set
+            .files()
+            .iter()
+            .find(|f| {
+                f.file()
+                    .path()
+                    .and_then(|p| p.to_str())
+                    .is_some_and(|p| p.ends_with("with_multiline_comments.sql"))
+            })
+            .ok_or("with_multiline_comments.sql should be present")?;
+
         let comments = Comments::parse_all_comments_from_file(file)?;
         let comments = comments.comments();
         assert_eq!(comments.len(), 11);
diff --git a/src/docs.rs b/src/docs.rs
@@ -66,7 +66,7 @@ pub struct TableDoc {
     name: String,
     doc: Option<String>,
     columns: Vec<ColumnDoc>,
-    file: Option<PathBuf>,
+    path: Option<PathBuf>,
 }
 
 impl TableDoc {
@@ -83,9 +83,9 @@ impl TableDoc {
         name: String,
         doc: Option<String>,
         columns: Vec<ColumnDoc>,
-        file: Option<PathBuf>,
+        path: Option<PathBuf>,
     ) -> Self {
-        Self { schema, name, doc, columns, file }
+        Self { schema, name, doc, columns, path }
     }
 
     /// Getter for the `Schema` of the table (if there is one)
@@ -113,6 +113,11 @@ impl TableDoc {
         self.doc = Some(doc.into());
     }
 
+    /// Setter for updating the table [`PathBuf`] source
+    pub fn set_path(&mut self, path: Option<impl Into<PathBuf>>) {
+        self.path = path.map(Into::into);
+    }
+
     /// Getter for the `columns` field
     #[must_use]
     #[allow(clippy::missing_const_for_fn)]
@@ -202,22 +207,13 @@ impl SqlFileDoc {
                     }
                     let table_leading = comments.leading_comment(table_start);
                     let (schema, name) = schema_and_table(&table.name)?;
-                    let table_doc = match table_leading {
-                        Some(comment) => TableDoc::new(
-                            schema,
-                            name,
-                            Some(comment.text().to_string()),
-                            column_docs,
-                            Some(file.path_into_path_buf()),
-                        ),
-                        None => TableDoc::new(
-                            schema,
-                            name,
-                            None,
-                            column_docs,
-                            Some(file.path_into_path_buf()),
-                        ),
-                    };
+                    let table_doc = TableDoc::new(
+                        schema,
+                        name,
+                        table_leading.as_ref().map(|c| c.text().to_string()),
+                        column_docs,
+                        file.path_into_path_buf(),
+                    );
                     tables.push(table_doc);
                 }
                 // can add support for other types of statements below
@@ -233,6 +229,12 @@ impl SqlFileDoc {
     pub fn tables(&self) -> &[TableDoc] {
         &self.tables
     }
+
+    /// Getter that returns a mutable reference to the [`TableDoc`] vec
+    pub fn tables_mut(&mut self) -> &mut [TableDoc] {
+        &mut self.tables
+    }
+
     /// Returns the number fo tables in the `SqlFileDoc`
     #[must_use]
     pub fn number_of_tables(&self) -> usize {
@@ -336,32 +338,43 @@ mod tests {
             let filename = file
                 .file()
                 .path()
-                .file_name()
+                .and_then(|p| p.file_name())
                 .and_then(|s| s.to_str())
-                .unwrap_or_else(|| panic!("unable to find file name"));
+                .ok_or("unable to parse file")?;
+
+            let got = docs?;
+            let file_path = file.file().path().ok_or("missing path")?;
 
             match filename {
                 "with_single_line_comments.sql" | "with_mixed_comments.sql" => {
-                    assert_eq!(&docs?, &expected_values[0]);
+                    let expected = with_path(expected_values[0].clone(), file_path);
+                    assert_eq!(&got, &expected);
                 }
                 "with_multiline_comments.sql" => {
-                    assert_eq!(&docs?, &expected_values[1]);
+                    let expected = with_path(expected_values[1].clone(), file_path);
+                    assert_eq!(&got, &expected);
                 }
                 "without_comments.sql" => {
-                    let expected = expected_without_comments_docs();
-                    assert_eq!(&docs?, &expected);
-                }
-                other => {
-                    unreachable!(
-                        "unexpected test file {other}; directory should only contain known test files"
-                    );
+                    let expected = with_path(expected_without_comments_docs(), file_path);
+                    assert_eq!(&got, &expected);
                 }
+                _ => unreachable!(),
             }
         }
 
         Ok(())
     }
 
+    fn with_path(mut doc: SqlFileDoc, path: &std::path::Path) -> SqlFileDoc {
+        let pb = path.to_path_buf();
+
+        for table in doc.tables_mut() {
+            table.set_path(Some(pb.clone()));
+        }
+
+        doc
+    }
+
     fn expected_without_comments_docs() -> SqlFileDoc {
         SqlFileDoc::new(vec![
             TableDoc::new(
diff --git a/src/files.rs b/src/files.rs
@@ -107,7 +107,7 @@ fn recursive_dir_scan(path: &Path) -> io::Result<Vec<PathBuf>> {
 /// A single `.sql` file and its loaded contents.
 #[derive(Debug)]
 pub struct SqlFile {
-    path: PathBuf,
+    path: Option<PathBuf>,
     content: String,
 }
 
@@ -121,17 +121,23 @@ impl SqlFile {
     /// Returns an [`io::Error`] if the file cannot be read.
     pub fn new(path: &Path) -> io::Result<Self> {
         let content = fs::read_to_string(path)?;
-        Ok(Self { path: path.to_owned(), content })
+        Ok(Self { path: Some(path.to_owned()), content })
+    }
+
+    /// Creates an [`SqlFile`] from a string with a dummy path
+    #[must_use]
+    pub const fn new_from_str(content: String) -> Self {
+        Self { path: None, content }
     }
 
     /// Returns the filesystem path associated with this SQL file.
     #[must_use]
-    pub fn path(&self) -> &Path {
-        &self.path
+    pub fn path(&self) -> Option<&Path> {
+        self.path.as_deref()
     }
     /// Returns the [`PathBuf`] for the current path
     #[must_use]
-    pub fn path_into_path_buf(&self) -> PathBuf {
+    pub fn path_into_path_buf(&self) -> Option<PathBuf> {
         self.path.clone()
     }
 
@@ -290,7 +296,9 @@ mod tests {
         let sql_file_set = SqlFileSet::new(&base, &[])?;
         for file in sql_file_set.iter() {
             assert_eq!(file.content, sql_statement);
-            found.push(&file.path);
+            if let Some(p) = &file.path {
+                found.push(p);
+            }
         }
         assert_eq!(found, expected);
         let _ = fs::remove_dir_all(&base);
diff --git a/src/sql_doc.rs b/src/sql_doc.rs
