Removed PyO3 integration and turned this into a strict parsing library

Author: cmbasnett

Cargo.toml

@@ -1,14 +1,14 @@
 [package]
-name = "unrealscriptplus"
+name = "unrealscript_parser"
 version = "0.2.1"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 
 [lib]
-name = "unrealscriptplus"
-crate-type = ["lib", "cdylib"]
+name = "unrealscript_parser"
+crate-type = ["lib"]
 
 [dependencies]
 pest = "2.7"
@@ -20,8 +20,4 @@ strum_macros = "0.26"
 pest_consume = "1.1"
 pest_consume_macros = "1.1"
 convert_case = "0.6"
-if_chain = "1.0"
-
-[dependencies.pyo3]
-version = "0.27"
-features = ["extension-module"]
+if_chain = "1.0"

src/lib.rs

@@ -1,106 +1,6 @@
 pub mod ast;
 pub mod parser;
 pub mod visitor;
-pub mod transform;
 
-use pest::error::{ErrorVariant, LineColLocation, InputLocation};
-use crate::parser::{ParsingError, ParserRule, ProgramResult};
-
-// PYTHON STUFF
-use pyo3::prelude::*;
-use pyo3::{create_exception, PyErr};
-use pyo3::types::PyDict;
-use pyo3::exceptions;
-
-create_exception!(unrealscriptplus, ScriptParseError, pyo3::exceptions::PyException);
-
-fn parsing_error_to_py_err(py: Python, error: ParsingError) -> PyErr {
-    match error {
-        ParsingError::PestError(e) => ScriptParseError::new_err(pest_error_to_py_object(py, e)),
-        ParsingError::EncodingError(e) => exceptions::PyUnicodeEncodeError::new_err(e.to_string()),
-        ParsingError::IoError(e) => exceptions::PyIOError::new_err(e.to_string())
-    }
-}
-
-fn program_result_to_py_object(py: Python, result: &ProgramResult) -> Py<PyAny> {
-    let errors: Vec<Py<PyAny>> = result.errors.iter().map(|e| {
-        let dict = PyDict::new(py);
-        dict.set_item("line", e.span.line).unwrap();
-        dict.set_item("message", &e.message).unwrap();
-        dict.set_item("severity", format!("{:?}", e.severity)).unwrap();
-        dict.into()
-    }).collect();
-    
-    let dict = PyDict::new(py);
-    dict.set_item("errors", errors).unwrap();
-    dict.into()
-}
-
-fn pest_error_to_py_object(py: Python, e: pest_consume::Error<ParserRule>) -> Py<PyAny> {
-    let dict = PyDict::new(py);
-    
-    match e.line_col {
-        LineColLocation::Pos(pos) => {
-            dict.set_item("line_col", pos).unwrap();
-        },
-        LineColLocation::Span(span1, span2) => {
-            dict.set_item("line_col", (span1, span2)).unwrap();
-        }
-    };
-    
-    match e.location {
-        InputLocation::Pos(pos) => {
-            dict.set_item("location", pos).unwrap();
-        },
-        InputLocation::Span(span) => {
-            dict.set_item("location", span).unwrap();
-        }
-    };
-    
-    let variant: Py<PyAny> = match e.variant {
-        ErrorVariant::ParsingError { positives, negatives } => {
-            let positives: Vec<String> = positives.into_iter().map(|r| format!("{:?}", r)).collect();
-            let negatives: Vec<String> = negatives.into_iter().map(|r| format!("{:?}", r)).collect();
-            let variant_dict = PyDict::new(py);
-            variant_dict.set_item("type", "parsing").unwrap();
-            variant_dict.set_item("positives", positives).unwrap();
-            variant_dict.set_item("negatives", negatives).unwrap();
-            variant_dict.into()
-        },
-        ErrorVariant::CustomError { message } => {
-            let variant_dict = PyDict::new(py);
-            variant_dict.set_item("type", "custom").unwrap();
-            variant_dict.set_item("message", message).unwrap();
-            variant_dict.into()
-        },
-    };
-    dict.set_item("variant", variant).unwrap();
-    
-    dict.into()
-}
-
-#[pyfunction]
-fn parse_expression(py: Python, path: &str) -> PyResult<String> {
-    match crate::parser::parse_expression(path) {
-        Ok(p) => { Ok(format!("{:?}", p)) }
-        Err(e) => { Err(parsing_error_to_py_err(py, e.into())) }
-    }
-}
-
-#[pyfunction]
-fn parse_file(py: Python, path: &str) -> PyResult<Py<PyAny>> {
-    match crate::parser::parse_file(path) {
-        Ok(result) => {
-            Ok(program_result_to_py_object(py, &result))
-        }
-        Err(e) => Err(parsing_error_to_py_err(py, e))
-    }
-}
-
-#[pymodule]
-fn unrealscriptplus(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(parse_expression, m)?)?;
-    m.add_function(wrap_pyfunction!(parse_file, m)?)?;
-    m.add("ScriptParseError", m.py().get_type::<ScriptParseError>())?;
-    Ok(())
-}
+// Re-export main parsing functions and types for library consumers
+pub use parser::{parse_expression, parse_with_rule, parse_program, ParsingError, ProgramResult, Rule};

src/parser.rs

@@ -9,10 +9,6 @@ use std::str::FromStr;
 use std::collections::HashMap;
 use lazy_static::lazy_static;
 
-use encoding::{DecoderTrap, Encoding};
-use std::fs::File;
-use std::io::Read;
-
 use std::rc::Rc;
 
 use crate::ast::*;
@@ -1236,6 +1232,7 @@ impl UnrealScriptParser {
     }
 }
 
+#[derive(Debug)]
 pub enum ParsingError {
     IoError(std::io::Error),
     EncodingError(String),
@@ -1254,15 +1251,6 @@ impl From<Error<Rule>> for ParsingError {
     }
 }
 
-fn read_file_to_string(path: &str) -> std::result::Result<String, ParsingError> {
-    let mut file = File::open(path)?;
-    let mut buffer: Vec<u8> = Vec::new();
-    file.read_to_end(&mut buffer)?;
-    encoding::all::WINDOWS_1252
-        .decode(&mut buffer, DecoderTrap::Strict)
-        .map_err(|e| ParsingError::EncodingError(e.to_string()))
-}
-
 #[derive(Debug, PartialEq, Clone)]
 pub enum ProgramErrorSeverity {
     Warning,
@@ -1330,6 +1318,22 @@ pub fn parse_expression(contents: &str) -> std::result::Result<Box<AstNode<Expre
     }
 }
 
-pub fn parse_file(path: &str) -> std::result::Result<ProgramResult, ParsingError> {
-    parse_program(read_file_to_string(path)?.as_str())
+/// Parse text starting at a specific grammar rule.
+/// Useful for incremental parsing where you want to parse a slice of code.
+/// 
+/// # Arguments
+/// * `rule` - The grammar rule to start parsing from
+/// * `contents` - The text to parse
+/// 
+/// # Returns
+/// The raw pest_consume Nodes iterator on success, or a ParsingError on failure.
+/// 
+/// # Example
+/// ```ignore
+/// use unrealscript_parser::{parse_with_rule, Rule};
+/// let result = parse_with_rule(Rule::expression, "1 + 2");
+/// ```
+pub fn parse_with_rule(rule: Rule, contents: &str) -> std::result::Result<pest_consume::Nodes<'_, Rule, ()>, ParsingError> {
+    UnrealScriptParser::parse(rule, contents)
+        .map_err(|e| ParsingError::from(e))
 }