domainforge 0.13.0

package/domainforge-core/src/parser/error.rs

@@ -0,0 +1,291 @@
+use crate::parser::Rule;
+use pest::error::Error as PestError;
+use std::fmt;
+
+pub type ParseResult<T> = Result<T, ParseError>;
+
+#[derive(Debug, Clone)]
+pub enum ParseError {
+    SyntaxError {
+        message: String,
+        line: usize,
+        column: usize,
+    },
+    UnsupportedExpression {
+        kind: String,
+        span: Option<String>,
+    },
+    GrammarError(String),
+    UndefinedEntity {
+        name: String,
+        line: usize,
+        column: usize,
+    },
+    UndefinedResource {
+        name: String,
+        line: usize,
+        column: usize,
+    },
+    UndefinedVariable {
+        name: String,
+        line: usize,
+        column: usize,
+    },
+    DuplicateDeclaration {
+        name: String,
+        line: usize,
+        column: usize,
+    },
+    TypeError {
+        message: String,
+        location: String,
+    },
+    InvalidExpression(String),
+    InvalidQuantity(String),
+    Validation(String),
+
+    // E500-E599: Namespace and module errors
+    /// E500: Referenced namespace does not exist
+    NamespaceNotFound {
+        namespace: String,
+        line: usize,
+        column: usize,
+        suggestion: Option<String>,
+    },
+    /// E503: Referenced module file could not be found
+    ModuleNotFound {
+        module_path: String,
+        line: usize,
+        column: usize,
+    },
+    /// E504: Imported symbol is not exported by the target module
+    SymbolNotExported {
+        symbol: String,
+        module: String,
+        line: usize,
+        column: usize,
+        available_exports: Vec<String>,
+    },
+    /// E505: Circular dependency detected between modules
+    CircularDependency {
+        cycle: Vec<String>,
+    },
+}
+
+impl ParseError {
+    pub fn from_pest(err: PestError<Rule>) -> Self {
+        let (line, column) = match err.line_col {
+            pest::error::LineColLocation::Pos((l, c)) => (l, c),
+            pest::error::LineColLocation::Span((l, c), _) => (l, c),
+        };
+
+        ParseError::SyntaxError {
+            message: err.variant.message().to_string(),
+            line,
+            column,
+        }
+    }
+
+    pub fn syntax_error(message: impl Into<String>, line: usize, column: usize) -> Self {
+        ParseError::SyntaxError {
+            message: message.into(),
+            line,
+            column,
+        }
+    }
+
+    pub fn undefined_entity(name: impl Into<String>, line: usize, column: usize) -> Self {
+        ParseError::UndefinedEntity {
+            name: name.into(),
+            line,
+            column,
+        }
+    }
+
+    /// Creates an UndefinedEntity error without location information (uses 0:0)
+    pub fn undefined_entity_no_loc(name: impl Into<String>) -> Self {
+        Self::undefined_entity(name, 0, 0)
+    }
+
+    pub fn undefined_resource(name: impl Into<String>, line: usize, column: usize) -> Self {
+        ParseError::UndefinedResource {
+            name: name.into(),
+            line,
+            column,
+        }
+    }
+
+    /// Creates an UndefinedResource error without location information (uses 0:0)
+    pub fn undefined_resource_no_loc(name: impl Into<String>) -> Self {
+        Self::undefined_resource(name, 0, 0)
+    }
+
+    pub fn undefined_variable(name: impl Into<String>, line: usize, column: usize) -> Self {
+        ParseError::UndefinedVariable {
+            name: name.into(),
+            line,
+            column,
+        }
+    }
+
+    pub fn duplicate_declaration(name: impl Into<String>, line: usize, column: usize) -> Self {
+        ParseError::DuplicateDeclaration {
+            name: name.into(),
+            line,
+            column,
+        }
+    }
+
+    /// Creates a DuplicateDeclaration error without location information (uses 0:0)
+    pub fn duplicate_declaration_no_loc(name: impl Into<String>) -> Self {
+        Self::duplicate_declaration(name, 0, 0)
+    }
+
+    pub fn type_error(message: impl Into<String>, location: impl Into<String>) -> Self {
+        ParseError::TypeError {
+            message: message.into(),
+            location: location.into(),
+        }
+    }
+
+    /// E500: Namespace not found error
+    pub fn namespace_not_found(
+        namespace: impl Into<String>,
+        line: usize,
+        column: usize,
+        suggestion: Option<String>,
+    ) -> Self {
+        ParseError::NamespaceNotFound {
+            namespace: namespace.into(),
+            line,
+            column,
+            suggestion,
+        }
+    }
+
+    /// E503: Module not found error
+    pub fn module_not_found(module_path: impl Into<String>, line: usize, column: usize) -> Self {
+        ParseError::ModuleNotFound {
+            module_path: module_path.into(),
+            line,
+            column,
+        }
+    }
+
+    /// E504: Symbol not exported error
+    pub fn symbol_not_exported(
+        symbol: impl Into<String>,
+        module: impl Into<String>,
+        line: usize,
+        column: usize,
+        available_exports: Vec<String>,
+    ) -> Self {
+        ParseError::SymbolNotExported {
+            symbol: symbol.into(),
+            module: module.into(),
+            line,
+            column,
+            available_exports,
+        }
+    }
+
+    /// E505: Circular dependency error
+    pub fn circular_dependency(cycle: Vec<String>) -> Self {
+        ParseError::CircularDependency { cycle }
+    }
+}
+
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ParseError::SyntaxError {
+                message,
+                line,
+                column,
+            } => {
+                write!(f, "Syntax error at {}:{}: {}", line, column, message)
+            }
+            ParseError::UnsupportedExpression { kind, span } => {
+                if let Some(span) = span {
+                    write!(f, "Unsupported expression '{}' at {}", kind, span)
+                } else {
+                    write!(f, "Unsupported expression '{}'", kind)
+                }
+            }
+            ParseError::GrammarError(msg) => write!(f, "Grammar error: {}", msg),
+            ParseError::UndefinedEntity { name, line, column } => {
+                write!(f, "Undefined entity: {} at {}:{}", name, line, column)
+            }
+            ParseError::UndefinedResource { name, line, column } => {
+                write!(f, "Undefined resource: {} at {}:{}", name, line, column)
+            }
+            ParseError::UndefinedVariable { name, line, column } => {
+                write!(f, "Undefined variable: {} at {}:{}", name, line, column)
+            }
+            ParseError::DuplicateDeclaration { name, line, column } => {
+                write!(f, "Duplicate declaration: {} at {}:{}", name, line, column)
+            }
+            ParseError::TypeError { message, location } => {
+                write!(f, "Type error at {}: {}", location, message)
+            }
+            ParseError::InvalidExpression(msg) => write!(f, "Invalid expression: {}", msg),
+            ParseError::InvalidQuantity(msg) => write!(f, "Invalid quantity: {}", msg),
+            ParseError::Validation(msg) => write!(f, "Validation error: {}", msg),
+            ParseError::NamespaceNotFound {
+                namespace,
+                line,
+                column,
+                suggestion,
+            } => {
+                write!(
+                    f,
+                    "Namespace '{}' not found at {}:{}",
+                    namespace, line, column
+                )?;
+                if let Some(sug) = suggestion {
+                    write!(f, ". Did you mean '{}'?", sug)?;
+                }
+                Ok(())
+            }
+            ParseError::ModuleNotFound {
+                module_path,
+                line,
+                column,
+            } => {
+                write!(
+                    f,
+                    "Module '{}' not found at {}:{}",
+                    module_path, line, column
+                )
+            }
+            ParseError::SymbolNotExported {
+                symbol,
+                module,
+                line,
+                column,
+                available_exports,
+            } => {
+                write!(
+                    f,
+                    "Symbol '{}' is not exported by module '{}' at {}:{}",
+                    symbol, module, line, column
+                )?;
+                if !available_exports.is_empty() {
+                    write!(f, ". Available exports: {}", available_exports.join(", "))?;
+                }
+                Ok(())
+            }
+            ParseError::CircularDependency { cycle } => {
+                write!(f, "Circular dependency detected: {}", cycle.join(" -> "))
+            }
+        }
+    }
+}
+
+impl std::error::Error for ParseError {}
+
+impl From<PestError<Rule>> for ParseError {
+    fn from(err: PestError<Rule>) -> Self {
+        ParseError::from_pest(err)
+    }
+}

package/domainforge-core/src/parser/lint.rs

@@ -0,0 +1,39 @@
+use std::collections::HashSet;
+use thiserror::Error;
+
+#[derive(Error, Debug, PartialEq)]
+pub enum LintError {
+    #[error("Keyword collision: '{name}' is a reserved keyword. Hint: {hint}")]
+    KeywordCollision { name: String, hint: String },
+}
+
+pub struct Linter {
+    keywords: HashSet<String>,
+}
+
+impl Default for Linter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Linter {
+    pub fn new() -> Self {
+        Self {
+            keywords: ["Entity", "Resource", "Flow", "Policy", "Unit", "Dimension"]
+                .iter()
+                .map(|s| s.to_string())
+                .collect(),
+        }
+    }
+
+    pub fn check_identifier(&self, name: &str, quoted: bool) -> Result<(), LintError> {
+        if !quoted && self.keywords.contains(name) {
+            return Err(LintError::KeywordCollision {
+                name: name.to_string(),
+                hint: format!("Use quoted identifier: \"{}\"", name),
+            });
+        }
+        Ok(())
+    }
+}

package/domainforge-core/src/parser/mod.rs

@@ -0,0 +1,193 @@
+use crate::graph::Graph;
+use pest_derive::Parser;
+use std::path::PathBuf;
+
+#[derive(Parser)]
+#[grammar = "grammar/sea.pest"]
+pub struct SeaParser;
+
+pub mod ast;
+pub mod ast_convert;
+pub mod ast_schema;
+pub mod error;
+pub mod lint;
+pub mod printer;
+pub mod profiles;
+pub mod string_utils;
+
+pub use ast::parse_expression_from_str;
+pub use ast::parse_source;
+pub use ast::Ast;
+pub use ast::AstNode;
+pub use error::{ParseError, ParseResult};
+pub use lint::*;
+pub use printer::PrettyPrinter;
+pub use profiles::{Profile, ProfileRegistry};
+pub use string_utils::unescape_string;
+
+/// Controls how the SEA parser interprets declarations.
+///
+/// Currently only the `default_namespace` value influences whether entities/resources
+/// without an explicit namespace inherit a fallback namespace.
+#[derive(Debug, Clone, Default)]
+pub struct ParseOptions {
+    /// When `Some`, unqualified declarations receive this namespace.
+    /// When `None`, entities and resources must provide their own namespace.
+    pub default_namespace: Option<String>,
+    /// Optional namespace registry used for module resolution.
+    pub namespace_registry: Option<crate::registry::NamespaceRegistry>,
+    /// Path to the entry file being parsed, used for module resolution.
+    pub entry_path: Option<PathBuf>,
+    /// Active profile to enforce when no profile is declared in the source file.
+    pub active_profile: Option<String>,
+    /// Downgrades profile violations from hard errors to warnings when set.
+    pub tolerate_profile_warnings: bool,
+}
+
+/// Parse SEA DSL source code into an AST
+pub fn parse(source: &str) -> ParseResult<Ast> {
+    ast::parse_source(source)
+}
+
+/// Parse SEA DSL source code directly into a Graph
+pub fn parse_to_graph(source: &str) -> ParseResult<Graph> {
+    let ast = parse(source)?;
+    ast::ast_to_graph_with_options(ast, &ParseOptions::default())
+}
+
+/// Parses SEA DSL `source` directly into a `Graph`, honoring the provided `options`.
+///
+/// # Parameters
+/// - `source`: DSL text that will be parsed into AST nodes.
+/// - `options`: Controls parser behavior (`default_namespace`, module resolution via `namespace_registry`/`entry_path`, `active_profile`, and whether profile violations are warnings).
+///
+/// # Returns
+/// A `ParseResult` containing the constructed `Graph` or a `ParseError`.
+///
+/// # Errors
+/// Returns an error if parsing fails or AST validation (graph construction) rejects the input.
+///
+/// # Example
+/// ```
+/// use domainforge_core::parser::{parse_to_graph_with_options, ParseOptions};
+///
+/// let options = ParseOptions {
+///     default_namespace: Some("logistics".to_string()),
+///     ..Default::default()
+/// };
+/// let graph = parse_to_graph_with_options("Entity \"Warehouse\"", &options).unwrap();
+/// ```
+pub fn parse_to_graph_with_options(source: &str, options: &ParseOptions) -> ParseResult<Graph> {
+    match (&options.namespace_registry, &options.entry_path) {
+        (Some(registry), Some(path)) => {
+            let mut resolver = crate::module::resolver::ModuleResolver::new(registry)?;
+            let ast = resolver.validate_entry(path, source)?;
+            resolver.validate_dependencies(path, &ast)?;
+            ast::ast_to_graph_with_options(ast, options)
+        }
+        (Some(_), None) => Err(ParseError::Validation(
+            "Namespace registry provided without entry path".to_string(),
+        )),
+        _ => {
+            if let Some(path) = &options.entry_path {
+                log::warn!(
+                        "Entry path '{}' provided without namespace registry; module resolution skipped",
+                        path.display()
+                    );
+            }
+            let ast = parse(source)?;
+            ast::ast_to_graph_with_options(ast, options)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_entity_declaration_syntax() {
+        let source = r#"
+            Entity "Warehouse A" in logistics
+        "#;
+
+        let result = parse(source);
+        assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+    }
+
+    #[test]
+    fn test_resource_declaration_syntax() {
+        let source = r#"
+            Resource "Camera Units" units in inventory
+        "#;
+
+        let result = parse(source);
+        assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+    }
+
+    #[test]
+    fn test_flow_declaration_syntax() {
+        let source = r#"
+            Flow "Camera Units" from "Warehouse" to "Factory" quantity 100
+        "#;
+
+        let result = parse(source);
+        assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+    }
+
+    #[test]
+    fn test_policy_simple_syntax() {
+        let source = r#"
+            Policy check_quantity as: Flow.quantity > 0
+        "#;
+
+        let result = parse(source);
+        assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+    }
+
+    #[test]
+    fn test_complex_policy_syntax() {
+        let source = r#"
+            Policy flow_constraints as:
+                (Flow.quantity > 0) and (Entity.name != "")
+        "#;
+
+        let result = parse(source);
+        assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+    }
+
+    #[test]
+    fn test_nested_expressions() {
+        let source = r#"
+            Policy multi_condition as:
+                (A or B) and (C or (D and E))
+        "#;
+
+        let result = parse(source);
+        assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+    }
+
+    #[test]
+    fn test_comments_ignored() {
+        let source = r#"
+            // This is a comment
+            Entity "Test" in domain
+            // Another comment
+        "#;
+
+        let result = parse(source);
+        assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+    }
+
+    #[test]
+    fn test_multiple_declarations() {
+        let source = r#"
+            Entity "Warehouse" in logistics
+            Resource "Cameras" units
+            Flow "Cameras" from "Warehouse" to "Factory" quantity 50
+        "#;
+
+        let result = parse(source);
+        assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+    }
+}