Began implementing no-std support

Author: RPG-Alex

Cargo.toml

@@ -18,7 +18,8 @@ categories = [
 ]
 
 [features]
-default = []
+default = ["std"]
+std = []
 fuzzing = []
 
 [dependencies]

src/ast.rs

@@ -2,14 +2,14 @@
 //!
 //! This module does not interpret semantics; it only produces an AST + file metadata.
 
-use std::path::{Path, PathBuf};
-
 use sqlparser::{
     ast::Statement,
     dialect::Dialect,
     parser::{Parser, ParserError},
 };
 
+use alloc::vec::Vec;
+
 use crate::source::SqlSource;
 
 /// A single SQL file plus all [`Statement`].
@@ -46,13 +46,13 @@ impl ParsedSqlFile {
 
     /// Getter method for returning the current object's file's path
     #[must_use]
-    pub fn path(&self) -> Option<&Path> {
+    pub fn path(&self) -> Option<&std::path::Path> {
         self.file.path()
     }
 
-    /// Getter that returns an [`PathBuf`] for the path rather than `&Path`
+    /// Getter that returns an [`std::path::PathBuf`] for the path rather than `&Path`
     #[must_use]
-    pub fn path_into_path_buf(&self) -> Option<PathBuf> {
+    pub fn path_into_path_buf(&self) -> Option<std::path::PathBuf> {
         self.file.path_into_path_buf()
     }
 
@@ -102,9 +102,10 @@ impl ParsedSqlFileSet {
 
 #[cfg(test)]
 mod tests {
-    use std::{env, fs};
-
+    use alloc::borrow::ToOwned;
+    use alloc::boxed::Box;
     use sqlparser::dialect::{GenericDialect, PostgreSqlDialect};
+    use std::{env, fs};
 
     use super::*;
     use crate::source::SqlSource;

src/comments.rs

@@ -9,6 +9,10 @@ use std::fmt;
 
 use crate::ast::ParsedSqlFile;
 
+use alloc::borrow::ToOwned;
+use alloc::string::String;
+use alloc::vec::Vec;
+
 /// Represents a line/column location within a source file.
 #[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd)]
 pub struct Location {
@@ -466,9 +470,13 @@ pub enum MultiFlatten<'a> {
 
 #[cfg(test)]
 mod tests {
-    use std::{env, fs};
-
+    use alloc::borrow::ToOwned;
+    use alloc::boxed::Box;
+    use alloc::format;
+    use alloc::string::{String, ToString};
+    use alloc::{vec, vec::Vec};
     use sqlparser::dialect::GenericDialect;
+    use std::{env, fs};
 
     use crate::comments::{Comment, CommentError, CommentKind, Comments, Location, Span};
 

src/docs.rs

@@ -5,6 +5,10 @@ use std::path::{Path, PathBuf};
 
 use sqlparser::ast::{Ident, ObjectName, ObjectNamePart, Spanned, Statement};
 
+use alloc::borrow::ToOwned;
+use alloc::string::String;
+use alloc::vec::Vec;
+
 use crate::{
     ast::ParsedSqlFile,
     comments::{Comments, LeadingCommentCapture, MultiFlatten},
@@ -332,14 +336,18 @@ fn schema_and_table(name: &ObjectName) -> Result<(Option<String>, String), DocEr
 
 #[cfg(test)]
 mod tests {
+    use alloc::borrow::ToOwned;
+    use alloc::boxed::Box;
+    use alloc::string::String;
+    use alloc::string::ToString;
+    use alloc::{vec, vec::Vec};
     use core::fmt;
-    use std::{env, fs, path::PathBuf};
-
     use sqlparser::{
         ast::{Ident, ObjectName, ObjectNamePart, ObjectNamePartFunction},
         dialect::GenericDialect,
         tokenizer::Span,
     };
+    use std::{env, fs, path::PathBuf};
 
     use crate::{
         docs::{ColumnDoc, SqlFileDoc, TableDoc, schema_and_table},

src/error.rs

@@ -4,15 +4,16 @@ use crate::{
     comments::CommentError,
     docs::{ColumnDoc, TableDoc},
 };
+use alloc::{string::String, vec::Vec};
 use core::fmt;
 use sqlparser::parser::ParserError;
-use std::{error, fmt::Debug};
 
 /// Errors that can occur while discovering, parsing, or documenting SQL files.
 #[non_exhaustive]
 #[derive(Debug)]
 pub enum DocError {
     /// Wrapper for standard [`std::io::Error`]
+    #[cfg(feature = "std")]
     FileReadError(std::io::Error),
     /// Wrapper for [`CommentError`]
     CommentError(CommentError),
@@ -90,8 +91,9 @@ impl fmt::Display for DocError {
     }
 }
 
-impl error::Error for DocError {
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+#[cfg(feature = "std")]
+impl std::error::Error for DocError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
             Self::FileReadError(e) => Some(e),
             Self::CommentError(e) => Some(e),
@@ -129,7 +131,7 @@ mod tests {
     use sqlparser::parser::ParserError;
 
     use crate::{comments::CommentError, docs::TableDoc, error::DocError};
-
+    use alloc::{borrow::ToOwned, string::ToString, vec};
     #[test]
     fn test_doc_errors() {
         use std::fs;

src/files.rs

@@ -1,12 +1,13 @@
+#![cfg(feature = "std")]
 //! Discover and filter `.sql` files on disk.
 //!
 //! This module finds file paths; it does not parse SQL or extract comments.
-
 use std::{
     fs, io,
     path::{Path, PathBuf},
+    string::String,
+    vec::Vec,
 };
-
 /// A list of SQL files to exclude from processing.
 ///
 /// Entries in the deny list are treated as full [`PathBuf`] paths.
@@ -160,9 +161,15 @@ impl SqlContentSet {
 
 #[cfg(test)]
 mod tests {
-    use std::{env, fs};
-
     use super::*;
+    use std::{
+        boxed::Box,
+        env, fs,
+        path::{Path, PathBuf},
+        string::ToString,
+        vec,
+        vec::Vec,
+    };
 
     #[test]
     fn test_recursive_scan_finds_only_sql_files_recursively()

src/lib.rs

@@ -2,6 +2,7 @@
 #![deny(missing_docs)]
 #![deny(rustdoc::broken_intra_doc_links)]
 #![deny(rustdoc::private_intra_doc_links)]
+#![cfg_attr(not(feature = "std"), no_std)]
 //!
 //! ## Module layout
 //!
@@ -12,11 +13,13 @@
 //! - [`sql_doc`]  — Build the top-level [`SqlDoc`] and primary entry point
 //!
 //! **Start here:** [`SqlDoc::from_dir`], [`SqlDoc::from_path`], or [`SqlDoc::builder_from_str`]
+extern crate alloc;
 
 pub mod ast;
 pub mod comments;
 pub mod docs;
 pub mod error;
+#[cfg(feature = "std")]
 pub mod files;
 pub mod source;
 pub mod sql_doc;

src/source.rs

@@ -1,17 +1,39 @@
 //! Module for structuring the Sql input
+#[cfg(feature = "std")]
 use crate::files::{SqlContent, SqlContentSet};
+#[cfg(feature = "std")]
 use std::{
     io,
     path::{Path, PathBuf},
 };
 
+use alloc::{borrow::ToOwned, string::String, vec::Vec};
+
 /// Holds the optional path and content of the `sql` to be parsed
 #[derive(Debug)]
 pub struct SqlSource {
+    #[cfg(feature = "std")]
     path: Option<PathBuf>,
     content: String,
 }
 
+#[cfg(not(feature = "std"))]
+impl From<String> for SqlSource {
+    /// Creates an [`SqlSource`] from a a [`String`]
+    fn from(content: String) -> Self {
+        Self { content }
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<String> for SqlSource {
+    /// Creates an [`SqlSource`] from a a [`String`]
+    fn from(content: String) -> Self {
+        Self { content, path: None }
+    }
+}
+
+#[cfg(feature = "std")]
 impl SqlSource {
     /// Loads a [`SqlSource`] from the given path.
     ///
@@ -25,7 +47,7 @@ impl SqlSource {
 
     /// Creates an [`SqlSource`] from a a [`String`] and a [`Option<PathBuf>`]
     #[must_use]
-    pub const fn from_str(content: String, path: Option<PathBuf>) -> Self {
+    pub const fn from_str_with_path(content: String, path: Option<PathBuf>) -> Self {
         Self { path, content }
     }
 
@@ -40,12 +62,6 @@ impl SqlSource {
         self.path.clone()
     }
 
-    /// Returns the raw SQL text contained in this file.
-    #[must_use]
-    pub fn content(&self) -> &str {
-        &self.content
-    }
-
     /// Recursively discovers `.sql` files under `path`, applies the optional
     /// deny list, and loads the contents of each file.
     ///
@@ -58,6 +74,7 @@ impl SqlSource {
     ///
     /// Returns an [`io::Error`] if directory traversal fails or if any of the
     /// discovered SQL files cannot be read.
+    #[cfg(feature = "std")]
     pub fn sql_sources(path: &Path, deny_list: &[String]) -> io::Result<Vec<Self>> {
         let sql_content_set = SqlContentSet::new(path, deny_list)?;
 
@@ -70,14 +87,22 @@ impl SqlSource {
     }
 }
 
+impl SqlSource {
+    /// Returns the raw SQL text contained in this file.
+    #[must_use]
+    pub fn content(&self) -> &str {
+        &self.content
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use std::{env, fs, path::PathBuf};
-
     use crate::source::SqlSource;
 
+    #[cfg(feature = "std")]
     #[test]
     fn test_sql_file_read() -> Result<(), Box<dyn std::error::Error>> {
+        use std::{env, fs, path::PathBuf};
         let base = env::temp_dir().join("recursive_scan_test3");
         let _ = fs::remove_dir_all(&base);
         fs::create_dir_all(&base)?;
@@ -109,8 +134,12 @@ mod tests {
         Ok(())
     }
 
+    #[cfg(not(feature = "std"))]
     #[test]
     fn test_sql_file_new_from_str_has_no_path_and_preserves_content() {
+        use alloc::boxed::Box;
+        use alloc::vec;
+        use alloc::vec::Vec;
         let sql = "SELECT * FROM users;";
         let file = SqlSource::from_str(sql.to_owned(), None);
         assert!(file.path().is_none());

src/sql_doc.rs

@@ -1,10 +1,13 @@
 //! Public entry point for building [`SqlDoc`] from a directory, file, or string.
-
+#[cfg(feature = "std")]
 use std::{
     path::{Path, PathBuf},
     vec,
 };
 
+use alloc::borrow::ToOwned;
+use alloc::string::String;
+use alloc::vec::Vec;
 use sqlparser::dialect::Dialect;
 
 use crate::{
@@ -18,6 +21,7 @@ use crate::{
 
 /// Top-level documentation object containing all discovered [`TableDoc`] entries.
 #[derive(Clone, Debug, Eq, PartialEq)]
+
 pub struct SqlDoc {
     /// Holds the [`Vec`] of all tables found in all specified files.
     tables: Vec<TableDoc>,
@@ -285,10 +289,14 @@ pub struct SqlDocBuilder<'a> {
 /// Enum for specifying a file doc source as a `directory` or a specific `file`
 #[derive(Debug, Eq, PartialEq)]
 enum SqlFileDocSource<'a> {
+    #[cfg(feature = "std")]
     Dir(PathBuf),
+    #[cfg(feature = "std")]
     File(PathBuf),
+    #[cfg(feature = "std")]
     Files(Vec<PathBuf>),
     FromString(&'a str),
+    #[cfg(feature = "std")]
     FromStringsWithPaths(&'a [(String, PathBuf)]),
 }
 
@@ -462,6 +470,11 @@ fn generate_docs_from_strs_with_paths<D: Dialect + Default>(
 
 #[cfg(test)]
 mod tests {
+    use alloc::borrow::ToOwned;
+    use alloc::boxed::Box;
+    use alloc::format;
+    use alloc::string::String;
+    use alloc::vec::Vec;
     use std::{
         env, fs,
         path::{Path, PathBuf},
@@ -797,7 +810,6 @@ mod tests {
         let built = SqlDoc::builder_from_str(sql)
             .flatten_multiline_with(" | ")
             .build::<GenericDialect>()?;
-        dbg!(&built);
         let t = built.table("t", None)?;
         assert_eq!(t.doc(), Some("hello | world"));
         assert_eq!(t.columns()[0].doc(), Some("x | y | z"));