Second try to add a no-unsafe flag. This is better than the first attempt, but there are still areas for improvement. Getting this commited because AI has twice suggested wiping this out and starting over to fix some minor problem.

Both version compile and have the same problems with the navigation tests (which still need to be fixed from earlier).

The indentation is badly messed up in places.

Author: NSoiffer

Cargo.toml

@@ -15,11 +15,12 @@ exclude = ["src/main.rs", "docs", "PythonScripts"]    # should have "Rules/", bu
 "include-zip" = []
 "enable-logs" = ["android_logger"]
 "tts" = [ "natural-tts" ]
+"no-unsafe" = ["sxd-document/no-unsafe", "sxd-xpath/no-unsafe"]
 
 
 [dependencies]
-sxd-document = "0.3"
-sxd-xpath = "0.4"
+sxd-document = { path = "../sxd-document" }
+sxd-xpath = { path = "../sxd-xpath-no-unsafe" }
 yaml-rust = "0.4"
 # yaml-rust = { version = "0.11", package = "yaml-rust2" }
 strum = "0.27.2"

src/braille.rs

@@ -2,6 +2,7 @@
 use strum_macros::Display;
 use sxd_document::dom::{Element, ChildOfElement};
 use sxd_document::Package;
+use sxd_document::{as_str, as_opt_str};
 use crate::definitions::SPEECH_DEFINITIONS;
 use crate::errors::*;
 use crate::pretty_print::mml_to_string;
@@ -326,7 +327,8 @@ pub fn get_navigation_node_from_braille_position(mathml: Element, position: usiz
     /// find the navigation node that most tightly encapsulates the target position (0-based)
     /// 'node' is the current node we are on inside of 'mathml'
     fn find_navigation_node<'e>(mathml: Element<'e>, node: Element<'e>, target_position: usize) -> Result<SearchState<'e>> {
-        let node_id = match node.attribute_value("id") {
+        let raw_node_id = node.attribute_value("id");
+        let node_id = match as_opt_str!(raw_node_id) {
             Some(id) => id,
             None => bail!("'id' is not present on mathml: {}", mml_to_string(node)),
         };
@@ -444,7 +446,7 @@ pub fn get_navigation_node_from_braille_position(mathml: Element, position: usiz
         return BRAILLE_DEFINITIONS.with(|definitions| {
             let definitions = definitions.borrow();
             let comparison_operators = definitions.get_hashset("ComparisonOperators").unwrap();
-            return comparison_operators.contains(as_text(node));
+            return comparison_operators.contains(as_str!(as_text(node)));
         });        
     }
 
@@ -478,7 +480,7 @@ pub fn get_navigation_node_from_braille_position(mathml: Element, position: usiz
 
     fn estimate_braille_chars(child: ChildOfElement, n_number_indicator: usize) -> usize {
         let node = as_element(child);
-        let leaf_name = name(node);
+        let leaf_name = as_str!(name(node));
         if is_leaf(node) {
             let text = as_text(node);
             // len() is close since mn's probably have ASCII digits and lower case vars are common (count as) and other chars need extra braille chars
@@ -2238,7 +2240,7 @@ impl NemethNestingChars {
             max_value += repeat_char;
             node.set_attribute_value(NEMETH_FRAC_LEVEL, &max_value);
             return max_value;
-        } else if FIRST_CHILD_ONLY.contains(&name) {
+        } else if FIRST_CHILD_ONLY.contains(&as_str!(name)) {
             // only look at the base -- ignore scripts/index
             return NemethNestingChars::nemeth_frac_value(as_element(children[0]), repeat_char);
         } else {
@@ -2273,11 +2275,11 @@ impl NemethNestingChars {
                 if let ParentOfChild::Element(e) =  parent_of_child {
                     parent = e;
                 } else {
-                    return Err( sxd_xpath::function::Error::Other("Internal error in nemeth_root_value: didn't find 'math' tag".to_string()) );
+                    return Err( sxd_xpath::function::Error::Other { what: "Internal error in nemeth_root_value: didn't find 'math' tag".to_string() } );
                 }
             }
         }
-        return Err( XPathError::Other("Internal error in nemeth_root_value: didn't find 'math' tag".to_string()) );
+        return Err( XPathError::Other { what: "Internal error in nemeth_root_value: didn't find 'math' tag".to_string() } );
     }
 }
 
@@ -2308,7 +2310,7 @@ impl Function for NemethNestingChars {
             } else if name == "msqrt" || name == "mroot" {
                 return Ok( Value::String( NemethNestingChars::nemeth_root_value(el, &repeat_char)? ) );
             } else {
-                return Err(XPathError::Other(format!("NestingChars chars should be used only on 'mfrac'. '{}' was passed in", name)));
+                return Err(XPathError::Other { what: format!("NestingChars chars should be used only on 'mfrac'. '{}' was passed in", name) });
             }
         } else {
             // not an element, so nothing to do
@@ -2330,11 +2332,11 @@ impl BrailleChars {
             "Vietnam" => BrailleChars:: get_braille_vietnam_chars(node, text_range),
             "Swedish" => BrailleChars:: get_braille_ueb_chars(node, text_range),    // FIX: need to figure out what to implement
             "Finnish" => BrailleChars:: get_braille_ueb_chars(node, text_range),    // FIX: need to figure out what to implement
-            _ => return Err(sxd_xpath::function::Error::Other(format!("get_braille_chars: unknown braille code '{code}'")))
+            _ => return Err(sxd_xpath::function::Error::Other { what: format!("get_braille_chars: unknown braille code '{code}'") })
         };
         return match result {
             Ok(string) => Ok(make_quoted_string(string)),
-            Err(err) => return Err(sxd_xpath::function::Error::Other(err.to_string())),
+            Err(err) => return Err(sxd_xpath::function::Error::Other { what: err.to_string() }),
         }
     }
 
@@ -2346,8 +2348,8 @@ impl BrailleChars {
         static PICK_APART_CHAR: LazyLock<Regex> = LazyLock::new(|| {
             Regex::new(r"(?P<face>[SB𝔹TIR]*)(?P<lang>[EDGVHU]?)(?P<cap>C?)(?P<letter>L?)(?P<num>[N]?)(?P<char>.)").unwrap()
         });
-        let math_variant = node.attribute_value("mathvariant");
-        // FIX: cover all the options -- use phf::Map
+        let raw_math_variant = node.attribute_value("mathvariant");
+        let math_variant = as_opt_str!(raw_math_variant);
         let  attr_typeface = match math_variant {
             None => "R",
             Some(variant) => match variant {
@@ -2360,7 +2362,7 @@ impl BrailleChars {
                 _ => "R",       // normal and unknown
             },
         };
-        let text = BrailleChars::substring(as_text(node), &text_range);
+        let text = BrailleChars::substring(as_str!(as_text(node)), &text_range);
         let braille_chars = braille_replace_chars(&text, node)?;
         // debug!("Nemeth chars: text='{}', braille_chars='{}'", &text, &braille_chars);
 
@@ -2422,8 +2424,9 @@ impl BrailleChars {
             Regex::new(r"(?P<bold>B??)(?P<italic>I??)(?P<face>[S𝔹TD]??)s??(?P<cap>C??)(?P<greek>G??)(?P<char>[NL].)").unwrap()
         });
 
-        let math_variant = node.attribute_value("mathvariant");
-        let text = BrailleChars::substring(as_text(node), &text_range);
+        let raw_math_variant = node.attribute_value("mathvariant");
+        let math_variant = as_opt_str!(raw_math_variant);
+        let text = BrailleChars::substring(as_str!(as_text(node)), &text_range);
         let mut braille_chars = braille_replace_chars(&text, node)?;
 
         // debug!("get_braille_ueb_chars: before/after unicode.yaml: '{}'/'{}'", text, braille_chars);
@@ -2475,8 +2478,9 @@ impl BrailleChars {
             Regex::new(r"(?P<bold>B??)(?P<italic>I??)(?P<face>[S𝔹TD]??)s??(?P<cap>C??)(?P<greek>G??)(?P<char>[NL].)").unwrap()
         });
 
-        let math_variant = node.attribute_value("mathvariant");
-        let text = BrailleChars::substring(as_text(node), &text_range);
+        let raw_math_variant = node.attribute_value("mathvariant");
+        let math_variant = as_opt_str!(raw_math_variant);
+        let text = BrailleChars::substring(as_str!(as_text(node)), &text_range);
         let text = add_separator(text);
 
         let braille_chars = braille_replace_chars(&text, node)?;
@@ -2609,13 +2613,14 @@ impl BrailleChars {
         return false;
 
         fn child_meets_conditions(node: Element) -> bool {
-            let name = name(node);
+            let name = as_str!(name(node));
             return match name {
                 "mi" | "mn" => true,
                 "mo"  => !crate::canonicalize::is_relational_op(node),
                 "mtext" => {
-                    let text = as_text(node).trim();
-                    return text=="?" || text=="-?-" || text.is_empty();   // various forms of "fill in missing content" (see also Nemeth_RULEs.yaml, "omissions")
+                    let raw_text = as_text(node);
+                    let text = raw_text.trim();
+                    return text=="?" || text=="-?-" || text.is_empty();
                 },
                 "mrow" => {
                     if IsBracketed::is_bracketed(node, "", "", false, false) {
@@ -2630,7 +2635,7 @@ impl BrailleChars {
                     true      
                 },
                 "menclose" => {
-                    if let Some(notation) = node.attribute_value("notation") {
+                    if let Some(notation) = as_opt_str!(node.attribute_value("notation")) {
                         if notation != "bottom" || notation != "box" {
                             return false;
                         }
@@ -2675,7 +2680,7 @@ impl Function for BrailleChars {
         use crate::canonicalize::create_mathml_element;
         let mut args = Args(args);
         if let Err(e) = args.exactly(2).or_else(|_| args.exactly(4)) {
-            return Err( XPathError::Other(format!("BrailleChars requires 2 or 4 args: {e}")));
+            return Err( XPathError::Other { what: format!("BrailleChars requires 2 or 4 args: {e}") });
         };
 
         let range = if args.len() == 4 {
@@ -2707,7 +2712,7 @@ impl Function for BrailleChars {
         };
 
         if !is_leaf(node) {
-            return Err( XPathError::Other(format!("BrailleChars called on non-leaf element '{}'", mml_to_string(node))) );
+            return Err( XPathError::Other { what: format!("BrailleChars called on non-leaf element '{}'", mml_to_string(node)) } );
         }
         return Ok( Value::String( BrailleChars::get_braille_chars(node, &braille_code, range)? ) );
     }
@@ -2773,7 +2778,7 @@ impl NeedsToBeGrouped {
     /// FIX: what needs to be implemented?
     fn needs_grouping_for_finnish(mathml: Element, is_base: bool) -> bool {
         use crate::xpath_functions::IsInDefinition;
-        let mut node_name = name(mathml);
+        let mut node_name = as_str!(name(mathml));
         if mathml.attribute_value("data-roman-numeral").is_some() {
             node_name = "mi";           // roman numerals don't follow number rules
         }
@@ -2804,7 +2809,7 @@ impl NeedsToBeGrouped {
                 }
             },
             "mi" | "mo" | "mtext" => {
-                let text = as_text(mathml);
+                let text = as_str!(as_text(mathml));
                 let parent = get_parent(mathml);   // there is always a "math" node
                 let parent_name = name(parent);   // there is always a "math" node
                 if is_base && (parent_name == "msub" || parent_name == "msup" || parent_name == "msubsup") && !text.contains([' ', '\u{00A0}']) {
@@ -2864,15 +2869,15 @@ impl NeedsToBeGrouped {
     // if the number is irregular, return the ordinal form, otherwise return 'None'.
     fn needs_grouping_for_swedish(mathml: Element, is_base: bool) -> bool {
         use crate::xpath_functions::IsInDefinition;
-        let mut node_name = name(mathml);
+        let mut node_name = as_str!(name(mathml));
         if mathml.attribute_value("data-roman-numeral").is_some() {
             node_name = "mi";           // roman numerals don't follow number rules
         }
 
         match node_name {
             "mn" => return false,
             "mi" | "mo" | "mtext" => {
-                let text = as_text(mathml);
+                let text = as_str!(as_text(mathml));
                 let parent = get_parent(mathml);   // there is always a "math" node
                 let parent_name = name(parent);   // there is always a "math" node
                 if is_base && (parent_name == "msub" || parent_name == "msup" || parent_name == "msubsup") && !text.contains([' ', '\u{00A0}']) {
@@ -2931,7 +2936,7 @@ impl NeedsToBeGrouped {
         // 8. If none of the foregoing apply, the item is simply the [this element's] individual symbol.
 
         use crate::xpath_functions::IsInDefinition;
-        let mut node_name = name(mathml);
+        let mut node_name = as_str!(name(mathml));
         if mathml.attribute_value("data-roman-numeral").is_some() {
             node_name = "mi";           // roman numerals don't follow number rules
         }
@@ -2960,7 +2965,7 @@ impl NeedsToBeGrouped {
                 }
             },
             "mi" | "mo" | "mtext" => {
-                let text = as_text(mathml);
+                let text = as_str!(as_text(mathml));
                 let parent = get_parent(mathml);   // there is always a "math" node
                 let parent_name = name(parent);   // there is always a "math" node
                 if is_base && (parent_name == "msub" || parent_name == "msup" || parent_name == "msubsup") && !text.contains([' ', '\u{00A0}']) {
@@ -3016,12 +3021,12 @@ impl Function for NeedsToBeGrouped {
                 "UEB" => NeedsToBeGrouped::needs_grouping_for_ueb(e, is_base),
                 "Finnish" => NeedsToBeGrouped::needs_grouping_for_finnish(e, is_base),
                 "Swedish" => NeedsToBeGrouped::needs_grouping_for_swedish(e, is_base),
-                _ => return Err(XPathError::Other(format!("NeedsToBeGrouped: braille code arg '{braille_code:?}' is not a known code ('UEB', 'CMU', or 'Swedish')"))),
+                _ => return Err(XPathError::Other { what: format!("NeedsToBeGrouped: braille code arg '{braille_code:?}' is not a known code ('UEB', 'CMU', or 'Swedish')") }),
             };
             return Ok( Value::Boolean( answer ) );
         }
 
-        return Err(XPathError::Other(format!("NeedsToBeGrouped: first arg '{node:?}' is not a node")));
+        return Err(XPathError::Other { what: format!("NeedsToBeGrouped: first arg '{node:?}' is not a node") });
     }
 }