Reduce visibility of internal functions

Author: istathar

src/language/types.rs

@@ -214,7 +214,7 @@ pub use crate::language::quantity::Quantity;
 // the validate functions all need to have start and end anchors, which seems
 // like it should be abstracted away.
 
-pub fn validate_license(input: &str) -> Option<&str> {
+pub(crate) fn validate_license(input: &str) -> Option<&str> {
     let re = regex!(r"^[A-Za-z0-9.,\-_ \(\)\[\]]+$");
 
     if re.is_match(input) {
@@ -224,7 +224,7 @@ pub fn validate_license(input: &str) -> Option<&str> {
     }
 }
 
-pub fn validate_copyright(input: &str) -> Option<&str> {
+pub(crate) fn validate_copyright(input: &str) -> Option<&str> {
     let re = regex!(r"^[A-Za-z0-9.,\-_ \(\)\[\]]+$");
 
     if re.is_match(input) {
@@ -234,7 +234,7 @@ pub fn validate_copyright(input: &str) -> Option<&str> {
     }
 }
 
-pub fn validate_template(input: &str) -> Option<&str> {
+pub(crate) fn validate_template(input: &str) -> Option<&str> {
     let re = regex!(r"^[A-Za-z0-9.,\-]+$");
 
     if re.is_match(input) {
@@ -244,7 +244,7 @@ pub fn validate_template(input: &str) -> Option<&str> {
     }
 }
 
-pub fn validate_identifier(input: &str) -> Option<Identifier<'_>> {
+pub(crate) fn validate_identifier(input: &str) -> Option<Identifier<'_>> {
     if input.len() == 0 {
         return None;
     }
@@ -257,7 +257,7 @@ pub fn validate_identifier(input: &str) -> Option<Identifier<'_>> {
     }
 }
 
-pub fn validate_forma(input: &str) -> Option<Forma<'_>> {
+pub(crate) fn validate_forma(input: &str) -> Option<Forma<'_>> {
     if input.len() == 0 {
         return None;
     }
@@ -294,7 +294,7 @@ fn parse_tuple(input: &str) -> Option<Vec<Forma<'_>>> {
 }
 
 /// This one copes with (and discards) any internal whitespace encountered.
-pub fn validate_genus(input: &str) -> Option<Genus<'_>> {
+pub(crate) fn validate_genus(input: &str) -> Option<Genus<'_>> {
     let first = input
         .chars()
         .next()
@@ -371,33 +371,6 @@ pub fn validate_response(input: &str) -> Option<Response<'_>> {
     Some(Response { value, condition })
 }
 
-fn _validate_decimal(_input: &str) -> Option<Numeric<'_>> {
-    // Test the regex macro availability within types.rs
-    let _decimal_regex = regex!(r"^\s*-?[0-9]+\.[0-9]+\s*$");
-    // For now, just return None since we removed Decimal variant
-    None
-}
-
-pub fn validate_numeric(input: &str) -> Option<Numeric<'_>> {
-    if input.is_empty() {
-        return None;
-    }
-
-    let input = input.trim_ascii();
-
-    // Try to parse as a simple Integral first
-    if let Ok(amount) = input.parse::<i64>() {
-        return Some(Numeric::Integral(amount));
-    }
-
-    // Try to parse as a Quantity (scientific notation with units)
-    if let Some(quantity) = parse_quantity(input) {
-        return Some(Numeric::Scientific(quantity));
-    }
-
-    None
-}
-
 #[cfg(test)]
 mod check {
     use super::*;
@@ -582,18 +555,6 @@ mod check {
         t1
     }
 
-    #[test]
-    fn numeric_rules() {
-        // Test simple integers
-        assert_eq!(validate_numeric("42"), Some(Numeric::Integral(42)));
-        assert_eq!(validate_numeric("0"), Some(Numeric::Integral(0)));
-        assert_eq!(validate_numeric("-123"), Some(Numeric::Integral(-123)));
-        assert_eq!(
-            validate_numeric("9223372036854775807"),
-            Some(Numeric::Integral(9223372036854775807))
-        );
-    }
-
     #[test]
     fn ast_construction() {
         let t1 = Metadata {

src/parsing/mod.rs

@@ -4,11 +4,13 @@ use std::path::Path;
 use tracing::debug;
 
 use crate::language::{Document, LoadingError, Technique};
-use crate::parsing::parser::ParsingError;
 
-pub mod parser;
+mod parser;
 mod scope;
 
+// Export the actual public API
+pub use parser::{parse_with_recovery, Parser, ParsingError};
+
 /// Read a file and return an owned String. We pass that ownership back to the
 /// main function so that the Technique object created by parse() below can
 /// have the same lifetime.

src/parsing/parser.rs

@@ -136,7 +136,7 @@ pub struct Parser<'i> {
 }
 
 impl<'i> Parser<'i> {
-    pub fn new() -> Parser<'i> {
+    fn new() -> Parser<'i> {
         Parser {
             filename: Path::new("-"),
             original: "",
@@ -146,10 +146,10 @@ impl<'i> Parser<'i> {
         }
     }
 
-    pub fn filename(&mut self, filename: &'i Path) {
+    fn filename(&mut self, filename: &'i Path) {
         self.filename = filename;
     }
-    pub fn initialize(&mut self, content: &'i str) {
+    fn initialize(&mut self, content: &'i str) {
         self.original = content;
         self.source = content;
         self.offset = 0;
@@ -732,7 +732,7 @@ impl<'i> Parser<'i> {
         })
     }
 
-    pub fn read_technique_header(&mut self) -> Result<Metadata<'i>, ParsingError> {
+    fn read_technique_header(&mut self) -> Result<Metadata<'i>, ParsingError> {
         // Process magic line
         let version = if is_magic_line(self.source) {
             let result = self.read_magic_line()?;
@@ -907,7 +907,7 @@ impl<'i> Parser<'i> {
     }
 
     /// Parse a procedure with error recovery - collects multiple errors instead of stopping at the first one
-    pub fn read_procedure(&mut self) -> Result<Procedure<'i>, ParsingError> {
+    fn read_procedure(&mut self) -> Result<Procedure<'i>, ParsingError> {
         // Find the procedure block boundaries
         let mut i = 0;
         let mut begun = false;
@@ -1821,7 +1821,7 @@ impl<'i> Parser<'i> {
     }
 
     /// Parse top-level ordered step
-    pub fn read_step_dependent(&mut self) -> Result<Scope<'i>, ParsingError> {
+    fn read_step_dependent(&mut self) -> Result<Scope<'i>, ParsingError> {
         self.take_block_lines(is_step_dependent, is_step_dependent, |outer| {
             outer.trim_whitespace();
 
@@ -1860,7 +1860,7 @@ impl<'i> Parser<'i> {
     }
 
     /// Parse a top-level concurrent step
-    pub fn read_step_parallel(&mut self) -> Result<Scope<'i>, ParsingError> {
+    fn read_step_parallel(&mut self) -> Result<Scope<'i>, ParsingError> {
         self.take_block_lines(is_step_parallel, is_step_parallel, |outer| {
             outer.trim_whitespace();
 
@@ -1961,7 +1961,7 @@ impl<'i> Parser<'i> {
         )
     }
 
-    pub fn read_descriptive(&mut self) -> Result<Vec<Paragraph<'i>>, ParsingError> {
+    fn read_descriptive(&mut self) -> Result<Vec<Paragraph<'i>>, ParsingError> {
         self.take_block_lines(
             |_| true,
             |line| {

src/problem/format.rs

@@ -1,7 +1,7 @@
 use super::messages::generate_error_message;
 use owo_colors::OwoColorize;
 use std::path::Path;
-use technique::{formatting::Render, language::LoadingError, parsing::parser::ParsingError};
+use technique::{formatting::Render, language::LoadingError, parsing::ParsingError};
 
 /// Format a parsing error with full details including source code context
 pub fn full_parsing_error<'i>(

src/problem/messages.rs

@@ -1,5 +1,5 @@
 use crate::problem::Present;
-use technique::{formatting::Render, language::*, parsing::parser::ParsingError};
+use technique::{formatting::Render, language::*, parsing::ParsingError};
 
 /// Generate problem and detail messages for parsing errors using AST construction
 pub fn generate_error_message<'i>(error: &ParsingError, renderer: &dyn Render) -> (String, String) {