Implemented SqlDoc methods and error handling

Author: RPG-Alex

src/docs.rs

@@ -1,5 +1,7 @@
 //! Module for parsing sql and comments and returning `table` and `column`
 //! information, including comments
+use core::fmt;
+
 use sqlparser::ast::{Ident, ObjectName, ObjectNamePart, Spanned, Statement};
 
 use crate::{ast::ParsedSqlFile, comments::Comments, error::DocError};
@@ -32,8 +34,20 @@ impl ColumnDoc {
     /// Getter for the field `doc`
     #[must_use]
     #[allow(clippy::missing_const_for_fn)]
-    pub fn doc(&self) -> &Option<String> {
-        &self.doc
+    pub fn doc(&self) -> Option<&str> {
+        self.doc.as_deref()
+    }
+}
+
+impl fmt::Display for ColumnDoc {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "Column Name: {}", self.name())?;
+        if let Some(c) = self.doc() {
+            writeln!(f, "Column Doc: {c}")?;
+        } else {
+            writeln!(f, "No Column Doc Found")?;
+        }
+        Ok(())
     }
 }
 
@@ -66,6 +80,12 @@ impl TableDoc {
         Self { schema, name, doc, columns }
     }
 
+    /// Getter for the `Schema` of the table (if there is one)
+    #[must_use]
+    pub fn schema(&self) -> Option<&str> {
+        self.schema.as_deref()
+    }
+
     /// Getter for the `name` field
     #[must_use]
     #[allow(clippy::missing_const_for_fn)]
@@ -76,8 +96,8 @@ impl TableDoc {
     /// Getter for the `doc` field
     #[must_use]
     #[allow(clippy::missing_const_for_fn)]
-    pub fn doc(&self) -> &Option<String> {
-        &self.doc
+    pub fn doc(&self) -> Option<&str> {
+        self.doc.as_deref()
     }
 
     /// Getter for the `columns` field
@@ -88,6 +108,30 @@ impl TableDoc {
     }
 }
 
+impl fmt::Display for TableDoc {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(s) = self.schema() {
+            writeln!(f, "Table Schema: {s}")?;
+        } else {
+            writeln!(f, "No Table Schema")?;
+        }
+
+        writeln!(f, "Table Name: {}", self.name())?;
+
+        if let Some(d) = self.doc() {
+            writeln!(f, "Table Doc: {d}")?;
+        } else {
+            writeln!(f, "No Table Doc")?;
+        }
+
+        writeln!(f, "Table Column Docs: ")?;
+        for col in self.columns() {
+            writeln!(f, " {col}")?;
+        }
+        Ok(())
+    }
+}
+
 /// Structure for containing the docs for every `Table` in an `.sql` file as a
 /// `Vec` of [`TableDoc`]
 #[derive(Clone, Debug, Eq, PartialEq)]

src/error.rs

@@ -1,5 +1,5 @@
 //! Module for managing Document Errors as [`DocError`]
-use crate::comments::CommentError;
+use crate::{comments::CommentError, docs::TableDoc};
 use core::fmt;
 use sqlparser::parser::ParserError;
 use std::{error, fmt::Debug};
@@ -21,6 +21,16 @@ pub enum DocError {
         /// The column number for the invalid [`sqlparser::ast::ObjectName`]
         column: u64,
     },
+    /// Table not found when searching [`crate::SqlDoc`]
+    TableNotFound {
+        /// The name of the table that was not found
+        name: String,
+    },
+    /// Duplicate tables with same name were found when searching [`crate::SqlDoc`]
+    DuplicateTablesFound {
+        /// `Vec` of the [`TableDoc`] for each duplicate table found
+        tables: Vec<TableDoc>
+    }
 }
 
 impl fmt::Display for DocError {
@@ -33,7 +43,16 @@ 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::DuplicateTablesFound { tables } => {
+                writeln!(f, "Duplicate tables found:")?;
+                for t in tables {
+                    writeln!(f, "{t}")?; 
+                }
+                Ok(())
             }
+
         }
     }
 }
@@ -44,7 +63,7 @@ impl error::Error for DocError {
             Self::FileReadError(e) => Some(e),
             Self::CommentError(e) => Some(e),
             Self::SqlParserError(e) => Some(e),
-            Self::InvalidObjectName { .. } => None,
+            Self::InvalidObjectName { .. } | Self::TableNotFound { .. } |  Self::DuplicateTablesFound { .. } => None,
         }
     }
 }

src/lib.rs

@@ -110,7 +110,6 @@ mod tests {
             assert_eq!(parsed_doc.tables()[i].name(), table_names[i]);
             let parsed_doc_table_doc = parsed_doc.tables()[i]
                 .doc()
-                .as_ref()
                 .map_or_else(|| panic!("unable to find SqlFileDoc table doc"), |val| val);
             assert_eq!(parsed_doc_table_doc, table_comments[i]);
         }
@@ -124,7 +123,6 @@ mod tests {
             assert_eq!(column.name(), user_columns[i]);
             let column_doc = column
                 .doc()
-                .as_ref()
                 .map_or_else(|| panic!("unable to find column doc value"), |val| val);
             assert_eq!(column_doc, user_columns_comments[i]);
         }

src/sql_doc.rs

@@ -3,11 +3,8 @@
 use std::path::{Path, PathBuf};
 
 use crate::{
-    ast::ParsedSqlFileSet,
-    comments::Comments,
-    docs::{SqlFileDoc, TableDoc, ColumnDoc},
+    docs::{SqlFileDoc, TableDoc},
     error::DocError,
-    files::SqlFileSet,
 };
 
 /// Structure for Sql Documentation, built from [`TableDoc`] and 
@@ -34,8 +31,57 @@ enum SqlFileDocSource {
 }
 
 impl SqlDoc {
+    /// 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() }
+    }
+    /// 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() }
+    }
 
-
+    /// 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>>();
+        match matches.as_slice() {
+            [] => 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>>();
+        match matches.as_slice() {
+            [] => Err(DocError::TableNotFound {
+                name: name.to_string(),
+            }),
+            [only] => Ok(*only),
+            _ => Err(DocError::DuplicateTablesFound {
+                tables: matches.into_iter().cloned().collect(),
+            }),
+        }
+    }
 }
 
 impl SqlDocBuilder {