implemented helper for generating docs from directory

Author: RPG-Alex

src/error.rs

@@ -29,8 +29,8 @@ pub enum DocError {
     /// Duplicate tables with same name were found when searching [`crate::SqlDoc`]
     DuplicateTablesFound {
         /// `Vec` of the [`TableDoc`] for each duplicate table found
-        tables: Vec<TableDoc>
-    }
+        tables: Vec<TableDoc>,
+    },
 }
 
 impl fmt::Display for DocError {
@@ -43,16 +43,15 @@ impl fmt::Display for DocError {
             Self::SqlParserError(parser_error) => write!(f, "SQL parse error {parser_error}"),
             Self::InvalidObjectName { message, line, column } => {
                 write!(f, "{message} at line {line}, column {column}")
-            },
-            Self::TableNotFound{name} => write!(f, "Table not found in SqlDoc: {name}"),
+            }
+            Self::TableNotFound { name } => write!(f, "Table not found in SqlDoc: {name}"),
             Self::DuplicateTablesFound { tables } => {
                 writeln!(f, "Duplicate tables found:")?;
                 for t in tables {
-                    writeln!(f, "{t}")?; 
+                    writeln!(f, "{t}")?;
                 }
                 Ok(())
             }
-
         }
     }
 }
@@ -63,7 +62,9 @@ impl error::Error for DocError {
             Self::FileReadError(e) => Some(e),
             Self::CommentError(e) => Some(e),
             Self::SqlParserError(e) => Some(e),
-            Self::InvalidObjectName { .. } | Self::TableNotFound { .. } |  Self::DuplicateTablesFound { .. } => None,
+            Self::InvalidObjectName { .. }
+            | Self::TableNotFound { .. }
+            | Self::DuplicateTablesFound { .. } => None,
         }
     }
 }

src/lib.rs

@@ -121,9 +121,8 @@ mod tests {
             .map_or_else(|| panic!("unable to find first value"), |(_, docs)| docs.tables());
         for (i, column) in first_tables[0].columns().iter().enumerate() {
             assert_eq!(column.name(), user_columns[i]);
-            let column_doc = column
-                .doc()
-                .map_or_else(|| panic!("unable to find column doc value"), |val| val);
+            let column_doc =
+                column.doc().map_or_else(|| panic!("unable to find column doc value"), |val| val);
             assert_eq!(column_doc, user_columns_comments[i]);
         }
         Ok(())

src/sql_doc.rs

@@ -1,26 +1,24 @@
-//! Module for the top level `SqlDoc` structure. 
+//! Module for the top level `SqlDoc` structure.
 
 use std::path::{Path, PathBuf};
 
 use crate::{
-    docs::{SqlFileDoc, TableDoc},
-    error::DocError,
+    ast::ParsedSqlFileSet, comments::Comments, docs::{SqlFileDoc, TableDoc}, error::DocError, files::SqlFileSet
 };
 
-/// Structure for Sql Documentation, built from [`TableDoc`] and 
+/// Structure for Sql Documentation, built from [`TableDoc`] and
 pub struct SqlDoc {
     /// Holds the [`Vec`] of all tables found in all specified files.
     tables: Vec<TableDoc>,
-    /// Holds the [`Vec`] of each file's [`PathBuf`] and the original file's [`SqlFileDoc`]
-    files: Vec<(PathBuf, SqlFileDoc)>,
+    /// Optionally holds the [`Vec`] of each file's [`PathBuf`] and the original file's [`SqlFileDoc`]
+    files: Option<Vec<(PathBuf, SqlFileDoc)>>,
 }
 
-
 /// Builder structure for the [`SqlDoc`]
 pub struct SqlDocBuilder {
     /// The source for implementing the [`SqlDoc`] to be built
     source: SqlFileDocSource,
-    /// The list of files to be ignored for parsing purposes. 
+    /// The list of Paths to be ignored for parsing purposes.
     deny: Vec<String>,
 }
 
@@ -31,51 +29,65 @@ enum SqlFileDocSource {
 }
 
 impl SqlDoc {
-    /// Method for generating builder from a directory. 
+    /// Method for creating a new SqlDoc
+    pub fn new(tables: Vec<TableDoc>, files: Option<Vec<(PathBuf, SqlFileDoc)>>) -> Self {
+        SqlDoc { tables, files }
+    }
+    /// Method for generating builder from a directory.
     pub fn from_dir<P: AsRef<Path>>(root: P) -> SqlDocBuilder {
-        SqlDocBuilder { source: SqlFileDocSource::Dir(root.as_ref().to_path_buf()), deny: Vec::new() }
+        SqlDocBuilder {
+            source: SqlFileDocSource::Dir(root.as_ref().to_path_buf()),
+            deny: Vec::new(),
+        }
     }
-    /// Method for generating builder from a [`Path`] of a single file 
+    /// Method for generating builder from a [`Path`] of a single file
     pub fn from_path<P: AsRef<Path>>(path: P) -> SqlDocBuilder {
-        SqlDocBuilder { source: SqlFileDocSource::File(path.as_ref().to_path_buf()), deny: Vec::new() }
+        SqlDocBuilder {
+            source: SqlFileDocSource::File(path.as_ref().to_path_buf()),
+            deny: Vec::new(),
+        }
     }
 
     /// Method for finding a specific [`TableDoc`] by `name`
-    /// 
+    ///
     /// # Parameters
     /// - the table `name` as a [`str`]
-    /// 
+    ///
     /// # Errors
     /// - Will return [`DocError::TableNotFound`] if the expected table is not found
     /// - Will return [`DocError::DuplicateTablesFound`] if more than one table is found
     pub fn table(&self, table: &str) -> Result<&TableDoc, DocError> {
-        let matches = self.tables.iter().filter(|table_doc| table_doc.name() == table).collect::<Vec<&TableDoc>>();
+        let matches = self
+            .tables
+            .iter()
+            .filter(|table_doc| table_doc.name() == table)
+            .collect::<Vec<&TableDoc>>();
         match matches.as_slice() {
-            [] => Err(DocError::TableNotFound {
-                name: table.to_string(),
-            }),
+            [] => Err(DocError::TableNotFound { name: table.to_string() }),
             [only] => Ok(*only),
             _ => Err(DocError::DuplicateTablesFound {
                 tables: matches.into_iter().cloned().collect(),
             }),
         }
     }
-    
+
     /// Method for finding a specific [`TableDoc`] from `schema` and table `name`
-    /// 
+    ///
     /// # Parameters
     /// - the table's `schema` as a [`str`]
     /// - the table's `name` as a [`str`]
-    /// 
+    ///
     /// # Errors
     /// - Will return [`DocError::TableNotFound`] if the expected table is not found
     /// - Will return [`DocError::DuplicateTablesFound`] if more than one table is found
     pub fn table_with_schema(&self, schema: &str, name: &str) -> Result<&TableDoc, DocError> {
-        let matches = self.tables.iter().filter(|table_doc| table_doc.name() == name && table_doc.schema() == Some(schema)).collect::<Vec<&TableDoc>>();
+        let matches = self
+            .tables
+            .iter()
+            .filter(|table_doc| table_doc.name() == name && table_doc.schema() == Some(schema))
+            .collect::<Vec<&TableDoc>>();
         match matches.as_slice() {
-            [] => Err(DocError::TableNotFound {
-                name: name.to_string(),
-            }),
+            [] => Err(DocError::TableNotFound { name: name.to_string() }),
             [only] => Ok(*only),
             _ => Err(DocError::DuplicateTablesFound {
                 tables: matches.into_iter().cloned().collect(),
@@ -85,5 +97,38 @@ impl SqlDoc {
 }
 
 impl SqlDocBuilder {
+    /// Method for adding an item to the deny list
+    ///
+    /// # Parameters
+    /// - The `path` that will be added to deny path `Vec`
+    pub fn deny(mut self, deny_path: &str) -> Self {
+        self.deny.push(deny_path.into());
+        self
+    }
+
+    pub fn build(&self) -> SqlDoc {
+        
 
+        SqlDoc { tables: (), files: () }
+    }
 }
+
+
+fn generate_docs_from_dir<P: AsRef<Path>, S: AsRef<str>>(source: P, deny: &[S]) -> Result<Vec<(PathBuf, SqlFileDoc)>, DocError> {
+    let deny_list: Vec<String> = deny.iter().map(|file| file.as_ref().to_string()).collect();
+    let deny_option = if deny_list.is_empty() { None } else { Some(deny_list) };
+    let file_set = SqlFileSet::new(source.as_ref(), deny_option)?;
+    let parsed_files = ParsedSqlFileSet::parse_all(file_set)?;
+    let mut sql_docs = Vec::new();
+    for file in parsed_files.files() {
+        let comments = Comments::parse_all_comments_from_file(file)?;
+        let docs = SqlFileDoc::from_parsed_file(file, &comments)?;
+        let path = file.file().path().to_path_buf();
+        sql_docs.push((path, docs));
+    }
+    Ok(sql_docs)
+}
+
+fn generate_docs_from_file<P: AsRef<Path>, S: AsRef<str>>(source: P, deny: &[S]) -> Result<Vec<(PathBuf, SqlFileDoc)>, DocError> {
+    
+}