Implemented no_std with feature gated std support

Author: RPG-Alex

src/ast.rs

@@ -12,70 +12,74 @@ use alloc::vec::Vec;
 
 use crate::source::SqlSource;
 
-/// A single SQL file plus all [`Statement`].
+/// A single SQL Source (such as a file) plus all [`Statement`].
 #[derive(Debug)]
-pub struct ParsedSqlFile {
-    file: SqlSource,
+pub struct ParsedSqlSource {
+    source: SqlSource,
     statements: Vec<Statement>,
 }
 
-impl ParsedSqlFile {
+#[cfg(feature = "std")]
+impl ParsedSqlSource {
+    /// Getter method for returning the current object' source's path
+    #[must_use]
+    pub fn path(&self) -> Option<&std::path::Path> {
+        self.source.path()
+    }
+
+    /// Getter that returns an [`std::path::PathBuf`] for the path rather than `&Path`
+    #[must_use]
+    pub fn path_into_path_buf(&self) -> Option<std::path::PathBuf> {
+        self.source.path_into_path_buf()
+    }
+}
+
+impl ParsedSqlSource {
     /// Parses a [`SqlSource`] into `sqlparser` [`Statement`] nodes.
     ///
     /// This is the AST layer used by the `comments` module to attach leading
     /// comment spans to statements/columns.
     ///
     /// # Parameters
-    /// - `file`: the [`SqlSource`] to parse
+    /// - `source`: the [`SqlSource`] to parse
     ///
     /// # Errors
     /// - Returns [`ParserError`] if parsing fails
-    pub fn parse<D>(file: SqlSource) -> Result<Self, ParserError>
+    pub fn parse<D>(source: SqlSource) -> Result<Self, ParserError>
     where
         D: Dialect + Default,
     {
-        let statements = Parser::parse_sql(&D::default(), file.content())?;
-        Ok(Self { file, statements })
+        let statements = Parser::parse_sql(&D::default(), source.content())?;
+        Ok(Self { source, statements })
     }
 
     /// Getter method for returning the [`SqlSource`]
     #[must_use]
-    pub const fn file(&self) -> &SqlSource {
-        &self.file
+    pub const fn source(&self) -> &SqlSource {
+        &self.source
     }
-
-    /// Getter method for returning the current object's file's path
-    #[must_use]
-    pub fn path(&self) -> Option<&std::path::Path> {
-        self.file.path()
-    }
-
-    /// Getter that returns an [`std::path::PathBuf`] for the path rather than `&Path`
-    #[must_use]
-    pub fn path_into_path_buf(&self) -> Option<std::path::PathBuf> {
-        self.file.path_into_path_buf()
-    }
-
-    /// Getter for the file's content
+    /// Getter for the source's content
     #[must_use]
     pub fn content(&self) -> &str {
-        self.file.content()
+        self.source.content()
     }
+}
 
+impl ParsedSqlSource {
     /// Getter method for returning the vector of all statements [`Statement`]
     #[must_use]
     pub fn statements(&self) -> &[Statement] {
         &self.statements
     }
 }
 
-/// Struct to contain the vector of parsed SQL files
+/// Struct to contain the vector of parsed SQL sources
 #[derive(Debug)]
-pub struct ParsedSqlFileSet {
-    files: Vec<ParsedSqlFile>,
+pub struct ParsedSqlSourceSet {
+    sources: Vec<ParsedSqlSource>,
 }
 
-impl ParsedSqlFileSet {
+impl ParsedSqlSourceSet {
     /// Method that parses a set of all members in a [`SqlSource`]
     ///
     /// # Parameters
@@ -87,16 +91,16 @@ impl ParsedSqlFileSet {
     where
         D: Dialect + Default,
     {
-        let files =
-            set.into_iter().map(ParsedSqlFile::parse::<D>).collect::<Result<Vec<_>, _>>()?;
+        let sources =
+            set.into_iter().map(ParsedSqlSource::parse::<D>).collect::<Result<Vec<_>, _>>()?;
 
-        Ok(Self { files })
+        Ok(Self { sources })
     }
 
-    /// Getter method for returning the vector of all [`ParsedSqlFile`]
+    /// Getter method for returning the vector of all [`ParsedSqlSource`]
     #[must_use]
-    pub fn files(&self) -> &[ParsedSqlFile] {
-        &self.files
+    pub fn sources(&self) -> &[ParsedSqlSource] {
+        &self.sources
     }
 }
 
@@ -119,7 +123,7 @@ mod tests {
         let sql = "CREATE TABLE users (id INTEGER PRIMARY KEY);";
         fs::write(&file_path, sql)?;
         let sql_file = SqlSource::from_path(&file_path)?;
-        let parsed = ParsedSqlFile::parse::<GenericDialect>(sql_file)?;
+        let parsed = ParsedSqlSource::parse::<GenericDialect>(sql_file)?;
         assert_eq!(parsed.path(), Some(file_path.as_path()));
         assert_eq!(parsed.content(), sql);
         assert_eq!(parsed.statements().len(), 1);
@@ -141,8 +145,8 @@ mod tests {
         fs::write(&file1, sql1)?;
         fs::write(&file2, sql2)?;
         let set = SqlSource::sql_sources(&base, &[])?;
-        let parsed_set = ParsedSqlFileSet::parse_all::<GenericDialect>(set)?;
-        let existing_files = parsed_set.files();
+        let parsed_set = ParsedSqlSourceSet::parse_all::<GenericDialect>(set)?;
+        let existing_files = parsed_set.sources();
         assert_eq!(existing_files.len(), 2);
         for parsed in existing_files {
             assert_eq!(parsed.statements().len(), 1);
@@ -166,7 +170,7 @@ mod tests {
         let sql = "CREATE TABLE t (id INTEGER PRIMARY KEY);";
         fs::write(&file_path, sql)?;
         let sql_file = SqlSource::from_path(&file_path)?;
-        let parsed = ParsedSqlFile::parse::<GenericDialect>(sql_file)?;
+        let parsed = ParsedSqlSource::parse::<GenericDialect>(sql_file)?;
         assert_eq!(parsed.path_into_path_buf(), Some(file_path));
         let _ = fs::remove_dir_all(&base);
         Ok(())
@@ -190,8 +194,8 @@ mod tests {
             CREATE TABLE t (id INTEGER PRIMARY KEY);
         ";
 
-        let src = SqlSource::from_str(sql.to_owned(), None);
-        let parsed = ParsedSqlFile::parse::<PostgreSqlDialect>(src)?;
+        let src = SqlSource::from(sql.to_owned());
+        let parsed = ParsedSqlSource::parse::<PostgreSqlDialect>(src)?;
         assert!(
             parsed.statements().len() >= 2,
             "expected at least 2 statements (function + table)"
@@ -232,11 +236,11 @@ mod tests {
         fs::write(&file2, pg_sql)?;
 
         let set = SqlSource::sql_sources(&base, &[])?;
-        let parsed_set = ParsedSqlFileSet::parse_all::<GenericDialect>(set)?;
+        let parsed_set = ParsedSqlSourceSet::parse_all::<GenericDialect>(set)?;
 
-        assert_eq!(parsed_set.files().len(), 2);
+        assert_eq!(parsed_set.sources().len(), 2);
 
-        for parsed in parsed_set.files() {
+        for parsed in parsed_set.sources() {
             assert!(
                 parsed.statements().iter().any(|s| matches!(s, Statement::CreateTable { .. })),
                 "expected CreateTable in parsed file; got statements: {:?}",
@@ -251,8 +255,8 @@ mod tests {
     #[test]
     fn parsed_sql_file_parse_invalid_sql_returns_error() {
         let sql = "CREATE TABLE";
-        let src = SqlSource::from_str(sql.to_owned(), None);
-        let res = ParsedSqlFile::parse::<GenericDialect>(src);
+        let src = SqlSource::from(sql.to_owned());
+        let res = ParsedSqlSource::parse::<GenericDialect>(src);
         assert!(res.is_err(), "expected parse to fail for invalid SQL");
     }
 }

src/comments.rs

@@ -5,13 +5,9 @@
 //! - **inline**: a comment that appears after code on the same line (ignored)
 //! - **interstitial**: a comment inside a statement (ignored)
 
-use std::fmt;
+use crate::ast::ParsedSqlSource;
 
-use crate::ast::ParsedSqlFile;
-
-use alloc::borrow::ToOwned;
-use alloc::string::String;
-use alloc::vec::Vec;
+use alloc::{borrow::ToOwned, string::String, vec::Vec};
 
 /// Represents a line/column location within a source file.
 #[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd)]
@@ -152,8 +148,8 @@ pub enum CommentError {
     },
 }
 
-impl fmt::Display for CommentError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl core::fmt::Display for CommentError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::UnmatchedMultilineCommentStart { location } => {
                 write!(
@@ -175,7 +171,7 @@ impl fmt::Display for CommentError {
     }
 }
 
-impl std::error::Error for CommentError {}
+impl core::error::Error for CommentError {}
 
 /// Alias for comment results that may return a [`CommentError`]
 pub type CommentResult<T> = Result<T, CommentError>;
@@ -218,7 +214,7 @@ impl Comments {
     ///   comment does not have an opening `/*`
     /// - Will return [`CommentError::UnterminatedMultiLineComment`] if a
     ///   multiline comment doesn't end before `EOF`
-    pub fn parse_all_comments_from_file(file: &ParsedSqlFile) -> CommentResult<Self> {
+    pub fn parse_all_comments_from_file(file: &ParsedSqlSource) -> CommentResult<Self> {
         let src = file.content();
         let comments = Self::scan_comments(src)?;
         Ok(comments)
@@ -537,7 +533,7 @@ mod tests {
 
     #[test]
     fn parse_comments() -> Result<(), Box<dyn std::error::Error>> {
-        use crate::{ast::ParsedSqlFileSet, comments::Comments, source::SqlSource};
+        use crate::{ast::ParsedSqlSourceSet, comments::Comments, source::SqlSource};
         let base = env::temp_dir().join("all_sql_files");
         let _ = fs::remove_dir_all(&base);
         fs::create_dir_all(&base)?;
@@ -554,12 +550,12 @@ mod tests {
         fs::File::create(&file4)?;
         fs::write(&file4, no_comments_sql())?;
         let set = SqlSource::sql_sources(&base, &[])?;
-        let parsed_set = ParsedSqlFileSet::parse_all::<GenericDialect>(set)?;
+        let parsed_set = ParsedSqlSourceSet::parse_all::<GenericDialect>(set)?;
 
-        for file in parsed_set.files() {
+        for file in parsed_set.sources() {
             let parsed_comments = Comments::parse_all_comments_from_file(file)?;
             let filename = file
-                .file()
+                .source()
                 .path()
                 .and_then(|p| p.file_name())
                 .and_then(|s| s.to_str())
@@ -773,20 +769,23 @@ CREATE TABLE posts (
 
     #[test]
     fn single_line_comment_spans_are_correct() -> Result<(), Box<dyn std::error::Error>> {
-        use crate::{ast::ParsedSqlFileSet, source::SqlSource};
+        use crate::{ast::ParsedSqlSourceSet, source::SqlSource};
         let base = env::temp_dir().join("single_line_spans");
         let _ = fs::remove_dir_all(&base);
         fs::create_dir_all(&base)?;
         let file = base.join("single.sql");
         fs::File::create(&file)?;
         fs::write(&file, single_line_comments_sql())?;
         let set = SqlSource::sql_sources(&base, &[])?;
-        let parsed_set = ParsedSqlFileSet::parse_all::<GenericDialect>(set)?;
+        let parsed_set = ParsedSqlSourceSet::parse_all::<GenericDialect>(set)?;
         let file = parsed_set
-            .files()
+            .sources()
             .iter()
             .find(|f| {
-                f.file().path().and_then(|p| p.to_str()).is_some_and(|p| p.ends_with("single.sql"))
+                f.source()
+                    .path()
+                    .and_then(|p| p.to_str())
+                    .is_some_and(|p| p.ends_with("single.sql"))
             })
             .ok_or("single.sql should be present")?;
 
@@ -811,20 +810,20 @@ CREATE TABLE posts (
 
     #[test]
     fn multiline_comment_spans_are_correct() -> Result<(), Box<dyn std::error::Error>> {
-        use crate::{ast::ParsedSqlFileSet, source::SqlSource};
+        use crate::{ast::ParsedSqlSourceSet, source::SqlSource};
         let base = env::temp_dir().join("multi_line_spans");
         let _ = fs::remove_dir_all(&base);
         fs::create_dir_all(&base)?;
         let file = base.join("multi.sql");
         fs::File::create(&file)?;
         fs::write(&file, multiline_comments_sql())?;
         let set = SqlSource::sql_sources(&base, &[])?;
-        let parsed_set = ParsedSqlFileSet::parse_all::<GenericDialect>(set)?;
+        let parsed_set = ParsedSqlSourceSet::parse_all::<GenericDialect>(set)?;
         let file = parsed_set
-            .files()
+            .sources()
             .iter()
             .find(|f| {
-                f.file().path().and_then(|p| p.to_str()).is_some_and(|p| p.ends_with("multi.sql"))
+                f.source().path().and_then(|p| p.to_str()).is_some_and(|p| p.ends_with("multi.sql"))
             })
             .ok_or("multi.sql should be present")?;