added method to parse str with an associated Path

Author: RPG-Alex

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "sql_docs"
-version = "1.0.8"
+version = "1.0.9"
 edition = "2024"
 description = "A crate for parsing comments from sql files and using them for documentation generation"
 documentation = "https://docs.rs/sql_docs"

Cargo.toml

@@ -53,22 +53,22 @@ impl SqlFilesList {
     /// Returns an [`io::Error`] if directory traversal fails.
     pub fn new<P: AsRef<Path>>(path: P, deny_list: &[String]) -> io::Result<Self> {
         let recursive_scan = recursive_dir_scan(path.as_ref())?;
-        let allow_list = {
+        let mut allow_list: Vec<PathBuf> = {
             let deny = DenyList::new(deny_list);
             recursive_scan.into_iter().filter(|p| !deny.deny_files().contains(p)).collect()
         };
-
+        allow_list.sort();
         Ok(Self { sql_files: allow_list })
     }
 
     /// Returns discovered `.sql` files in discovery order (filesystem-dependent).
     #[must_use]
-    pub fn sql_files(&self) -> Vec<&PathBuf> {
-        let mut files: Vec<&PathBuf> = self.sql_files.iter().collect();
+    pub fn sql_files(&self) -> Vec<PathBuf> {
+        let mut files: Vec<PathBuf> =
+            self.sql_files.iter().map(std::borrow::ToOwned::to_owned).collect();
         files.sort();
         files
     }
-
 }
 
 impl From<SqlFilesList> for Vec<PathBuf> {
@@ -252,7 +252,7 @@ mod tests {
         fs::File::create(&non_sql1)?;
         fs::File::create(&non_sql2)?;
         let sql_file_list = SqlFilesList::new(&base, &[])?;
-        let mut expected = vec![&file1, &file2];
+        let mut expected = vec![file1, file2];
         expected.sort();
         assert_eq!(sql_file_list.sql_files(), expected);
         let _ = fs::remove_dir_all(&base);
@@ -309,8 +309,8 @@ mod tests {
         fs::File::create(&non_sql2)?;
         let deny_list = &[file1.to_string_lossy().to_string()];
         let sql_file_list = SqlFilesList::new(&base, deny_list)?;
-        let found = sql_file_list.sql_files_sorted();
-        let mut expected = vec![&file2];
+        let found = sql_file_list.sql_files();
+        let mut expected = vec![file2];
         expected.sort();
         assert_eq!(found, expected);
         let _ = fs::remove_dir_all(&base);
@@ -352,16 +352,16 @@ mod tests {
         fs::File::create(&file2)?;
         fs::File::create(&noise)?;
         let sql_file_list = SqlFilesList::new(&base, &[])?;
-        let expected: Vec<PathBuf> = sql_file_list.sql_files().to_vec();
+        let expected: Vec<PathBuf> = sql_file_list.sql_files();
         let got: Vec<PathBuf> = Vec::from(sql_file_list);
         assert_eq!(got, expected);
         let _ = fs::remove_dir_all(&base);
         Ok(())
     }
     #[test]
     fn test_sql_file_new_from_str_has_no_path_and_preserves_content() {
-        let sql = "SELECT * FROM users;".to_owned();
-        let file = SqlFile::new_from_str(sql.clone());
+        let sql = "SELECT * FROM users;";
+        let file = SqlFile::new_from_str(sql.to_owned(), None);
         assert!(file.path().is_none());
         assert!(file.path_into_path_buf().is_none());
         assert_eq!(file.content(), sql);

src/files.rs

@@ -2,7 +2,8 @@
 
 use std::{
     path::{Path, PathBuf},
-    str::FromStr, vec,
+    str::FromStr,
+    vec,
 };
 
 use crate::{
@@ -49,7 +50,7 @@ enum SqlFileDocSource<'a> {
     File(PathBuf),
     Files(Vec<PathBuf>),
     FromString(&'a str),
-    FromStringsWithPaths(&'a[(String, PathBuf)])
+    FromStringsWithPaths(&'a [(String, PathBuf)]),
 }
 
 impl SqlDoc {
@@ -100,14 +101,15 @@ impl SqlDoc {
 
     /// Creates a builder from a vec of tuples containing the `sql` as [`String`] and the path as [`PathBuf`]
     #[must_use]
-    pub const fn builder_from_strs_with_paths(string_with_path: &[(String, PathBuf)]) -> SqlDocBuilder<'_> {
+    pub const fn builder_from_strs_with_paths(
+        string_with_path: &[(String, PathBuf)],
+    ) -> SqlDocBuilder<'_> {
         SqlDocBuilder {
             source: SqlFileDocSource::FromStringsWithPaths(string_with_path),
             deny: Vec::new(),
-            multiline_flat: MultiFlatten::NoFlat
+            multiline_flat: MultiFlatten::NoFlat,
         }
     }
-    
 
     /// Method for finding a specific [`TableDoc`] by `name`
     ///
@@ -223,8 +225,10 @@ impl SqlDocBuilder<'_> {
             SqlFileDocSource::FromString(content) => {
                 let sql_docs = generate_docs_str(content, None)?;
                 vec![sql_docs]
-            },
-            SqlFileDocSource::FromStringsWithPaths(strings_paths ) => generate_docs_from_strs_with_paths(strings_paths)?,
+            }
+            SqlFileDocSource::FromStringsWithPaths(strings_paths) => {
+                generate_docs_from_strs_with_paths(strings_paths)?
+            }
             SqlFileDocSource::Files(files) => generate_docs_from_files(files)?,
         };
         let num_of_tables = docs.iter().map(super::docs::SqlFileDoc::number_of_tables).sum();
@@ -314,9 +318,11 @@ fn generate_docs_str(content: &str, path: Option<PathBuf>) -> Result<SqlFileDoc,
     Ok(docs)
 }
 
-fn generate_docs_from_strs_with_paths(strings_with_paths: &[(String, PathBuf)]) -> Result<Vec<SqlFileDoc>, DocError> {
+fn generate_docs_from_strs_with_paths(
+    strings_with_paths: &[(String, PathBuf)],
+) -> Result<Vec<SqlFileDoc>, DocError> {
     let mut docs = Vec::new();
-    for (content,path) in strings_with_paths {
+    for (content, path) in strings_with_paths {
         docs.push(generate_docs_str(content, Some(path.to_owned()))?);
     }
 
@@ -837,4 +843,100 @@ mod tests {
         assert_eq!(t.schema(), Some("public"));
         Ok(())
     }
+    #[test]
+    fn test_generate_docs_from_strs_with_paths_builds_tables_and_stamps_paths()
+    -> Result<(), Box<dyn std::error::Error>> {
+        // Two simple SQL strings with distinct paths
+        let sql1 = r#"
+            -- Users table
+            CREATE TABLE users (
+                -- id
+                id INTEGER PRIMARY KEY
+            );
+        "#;
+
+        let sql2 = r#"
+            /* Posts table */
+            CREATE TABLE posts (
+                /* primary key */
+                id INTEGER PRIMARY KEY
+            );
+        "#;
+
+        let p1 = PathBuf::from("a/one.sql");
+        let p2 = PathBuf::from("b/two.sql");
+
+        // NOTE: builder expects owned String for sql and a PathBuf
+        let inputs: Vec<(String, PathBuf)> =
+            vec![(sql1.to_owned(), p1.clone()), (sql2.to_owned(), p2.clone())];
+
+        // Build via the new builder arm
+        let doc = SqlDoc::builder_from_strs_with_paths(&inputs).build()?;
+
+        // We should have 2 tables total
+        assert_eq!(doc.tables().len(), 2);
+
+        // Verify table names exist
+        let users = doc.table("users", None)?;
+        let posts = doc.table("posts", None)?;
+
+        // Verify each table got the correct stamped path
+        assert_eq!(users.path(), Some(p1.as_path()));
+        assert_eq!(posts.path(), Some(p2.as_path()));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_builder_from_strs_with_paths_is_used_in_build_match_arm()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let sql_a = "CREATE TABLE alpha (id INTEGER);";
+        let sql_b = "CREATE TABLE beta (id INTEGER);";
+        let path_a = PathBuf::from("alpha.sql");
+        let path_b = PathBuf::from("beta.sql");
+
+        let inputs = vec![(sql_a.to_owned(), path_a.clone()), (sql_b.to_owned(), path_b.clone())];
+
+        let built = SqlDoc::builder_from_strs_with_paths(&inputs).build()?;
+
+        let names: Vec<&str> = built.tables().iter().map(|t| t.name()).collect();
+        assert_eq!(names, vec!["alpha", "beta"]);
+
+        assert_eq!(built.table("alpha", None)?.path(), Some(path_a.as_path()));
+        assert_eq!(built.table("beta", None)?.path(), Some(path_b.as_path()));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_builder_from_str_no_path_has_none_path() -> Result<(), Box<dyn std::error::Error>> {
+        let sql = "CREATE TABLE t (id INTEGER);";
+        let built = SqlDoc::builder_from_str(sql).build()?;
+
+        let t = built.table("t", None)?;
+        assert_eq!(t.path(), None);
+
+        Ok(())
+    }
+    #[test]
+fn test_table_with_schema_not_found_uses_no_schema_provided_message() {
+    use crate::{SqlDoc, docs::TableDoc, error::DocError};
+
+    let sql_doc = SqlDoc::new(vec![
+        TableDoc::new(Some("analytics".to_owned()), "events".to_owned(), None, vec![], None),
+        TableDoc::new(Some("public".to_owned()), "events".to_owned(), None, vec![], None),
+    ]);
+
+    match sql_doc.table("events", None) {
+        Err(DocError::TableWithSchemaNotFound { name, schema }) => {
+            assert_eq!(name, "events");
+            assert_eq!(schema, "No schema provided");
+        }
+        Err(e) => panic!(
+            "expected TableWithSchemaNotFound with 'No schema provided', got: {e:?}"
+        ),
+        Ok(_) => panic!("expected error, got Ok"),
+    }
+}
+
 }