Add more tests to cover possible regressions from 0.4.0 to 0.5.0

Author: IvanIsCoding

src/ungron.rs

@@ -125,6 +125,7 @@ impl<'a> PathParser<'a> {
         self.expect_char('[')?;
         let segment = match self.peek_char() {
             Some('"') => PathSegment::Property(self.parse_json_string()?),
+            Some('\'') => PathSegment::Property(self.parse_quoted_string('\'')?),
             Some(ch) if ch.is_ascii_digit() => PathSegment::Index(self.parse_index()?),
             Some(ch) => {
                 return Err(anyhow!(
@@ -158,6 +159,61 @@ impl<'a> PathParser<'a> {
         Err(anyhow!("Unclosed string path segment"))
     }
 
+    fn parse_quoted_string(&mut self, delimiter: char) -> Result<String> {
+        self.bump_char();
+
+        let mut result = String::new();
+        while let Some(ch) = self.peek_char() {
+            self.bump_char();
+            if ch == delimiter {
+                return Ok(result);
+            }
+            if ch == '\\' {
+                result.push(self.parse_escape_sequence()?);
+            } else {
+                result.push(ch);
+            }
+        }
+
+        Err(anyhow!("Unclosed string path segment"))
+    }
+
+    fn parse_escape_sequence(&mut self) -> Result<char> {
+        let Some(ch) = self.peek_char() else {
+            return Err(anyhow!("Unclosed escape sequence"));
+        };
+        self.bump_char();
+
+        match ch {
+            '"' => Ok('"'),
+            '\'' => Ok('\''),
+            '\\' => Ok('\\'),
+            '/' => Ok('/'),
+            'b' => Ok('\u{0008}'),
+            'f' => Ok('\u{000c}'),
+            'n' => Ok('\n'),
+            'r' => Ok('\r'),
+            't' => Ok('\t'),
+            'u' => self.parse_unicode_escape(),
+            other => Ok(other),
+        }
+    }
+
+    fn parse_unicode_escape(&mut self) -> Result<char> {
+        let start = self.pos;
+        for _ in 0..4 {
+            match self.peek_char() {
+                Some(ch) if ch.is_ascii_hexdigit() => self.bump_char(),
+                Some(ch) => return Err(anyhow!("Invalid unicode escape character '{}'", ch)),
+                None => return Err(anyhow!("Unclosed unicode escape sequence")),
+            }
+        }
+
+        let code = u32::from_str_radix(&self.input[start..self.pos], 16)
+            .context("Failed to parse unicode escape")?;
+        char::from_u32(code).ok_or_else(|| anyhow!("Invalid unicode escape code point"))
+    }
+
     fn parse_index(&mut self) -> Result<usize> {
         let start = self.pos;
         while matches!(self.peek_char(), Some(ch) if ch.is_ascii_digit()) {
@@ -220,7 +276,12 @@ fn parse_value(right: &str) -> Result<JsonValue> {
         return Err(anyhow!("Expected assignment to end with ';'"));
     };
 
-    serde_json::from_str(value_src.trim()).context("Failed to parse gron value as JSON")
+    let value_src = value_src.trim();
+    if value_src.starts_with('\'') {
+        return parse_single_quoted_value(value_src);
+    }
+
+    serde_json::from_str(value_src).context("Failed to parse gron value as JSON")
 }
 
 fn strip_trailing_semicolon(right: &str) -> Option<&str> {
@@ -234,7 +295,7 @@ fn strip_trailing_semicolon(right: &str) -> Option<&str> {
             Some(_) if ch == '\\' => escaped = true,
             Some(delimiter) if ch == delimiter => string_delimiter = None,
             Some(_) => {}
-            None if ch == '"' => string_delimiter = Some(ch),
+            None if ch == '"' || ch == '\'' => string_delimiter = Some(ch),
             None if ch == ';' => semicolon = Some(idx),
             None if !ch.is_whitespace() && semicolon.is_some() => return None,
             None => {}
@@ -244,6 +305,15 @@ fn strip_trailing_semicolon(right: &str) -> Option<&str> {
     semicolon.map(|idx| &right[..idx])
 }
 
+fn parse_single_quoted_value(value_src: &str) -> Result<JsonValue> {
+    let mut parser = PathParser::new(value_src);
+    let value = parser.parse_quoted_string('\'')?;
+    if !parser.input[parser.pos..].trim().is_empty() {
+        return Err(anyhow!("Unexpected characters after string value"));
+    }
+    Ok(JsonValue::String(value))
+}
+
 fn set_value_at_path(root: &mut JsonValue, path: &[PathSegment], value: JsonValue) -> Result<()> {
     let mut cur = root;
 

src/xml2json.rs

@@ -71,13 +71,23 @@ pub fn parse_xml(xml: &str) -> Result<Value, XmlParseError> {
     let mut reader = Reader::from_str(xml);
     let mut stack = Vec::new();
     let mut output = Value::Null;
+    let mut root_seen = false;
 
     loop {
         match reader.read_event() {
-            Ok(Event::Start(event)) => stack.push(node_from_start(&reader, &event)?),
+            Ok(Event::Start(event)) => {
+                if root_seen && stack.is_empty() {
+                    return Err(XmlParseError("multiple root elements".to_string()));
+                }
+                stack.push(node_from_start(&reader, &event)?);
+            }
             Ok(Event::Empty(event)) => {
+                if root_seen && stack.is_empty() {
+                    return Err(XmlParseError("multiple root elements".to_string()));
+                }
                 let node = node_from_start(&reader, &event)?;
                 if let Some(root) = close_node(node, &mut stack)? {
+                    root_seen = true;
                     output = root;
                 }
             }
@@ -86,6 +96,8 @@ pub fn parse_xml(xml: &str) -> Result<Value, XmlParseError> {
             Ok(Event::CData(event)) => {
                 if let Some(node) = stack.last_mut() {
                     node.text.push_str(&event.decode()?);
+                } else {
+                    return Err(XmlParseError("CDATA outside root element".to_string()));
                 }
             }
             Ok(Event::End(event)) => {
@@ -100,6 +112,7 @@ pub fn parse_xml(xml: &str) -> Result<Value, XmlParseError> {
                     )));
                 }
                 if let Some(root) = close_node(node, &mut stack)? {
+                    root_seen = true;
                     output = root;
                 }
             }
@@ -144,6 +157,8 @@ fn node_from_start(reader: &Reader<&[u8]>, event: &BytesStart<'_>) -> Result<Nod
 fn append_text(stack: &mut [Node], event: BytesText<'_>) -> Result<(), XmlParseError> {
     if let Some(node) = stack.last_mut() {
         node.text.push_str(&event.decode()?);
+    } else if !event.decode()?.chars().all(char::is_whitespace) {
+        return Err(XmlParseError("text outside root element".to_string()));
     }
     Ok(())
 }
@@ -159,6 +174,10 @@ fn append_ref(stack: &mut [Node], event: BytesRef<'_>) -> Result<(), XmlParseErr
             })?;
             node.text.push_str(resolved);
         }
+    } else {
+        return Err(XmlParseError(
+            "entity reference outside root element".to_string(),
+        ));
     }
     Ok(())
 }

src/xml2json_test.rs

@@ -97,6 +97,22 @@ fn rejects_unclosed_elements_at_end_of_input() {
     assert!(err.contains("unexpected end of input"));
 }
 
+#[test]
+fn rejects_multiple_root_elements() {
+    let err = parse_xml("<foo>one</foo><bar>two</bar>")
+        .unwrap_err()
+        .to_string();
+
+    assert!(err.contains("multiple root elements"));
+}
+
+#[test]
+fn rejects_text_outside_root_element() {
+    let err = parse_xml("text<foo>bar</foo>").unwrap_err().to_string();
+
+    assert!(err.contains("text outside root element"));
+}
+
 #[test]
 fn rejects_unknown_entity_references() {
     let err = parse_xml("<foo>&unknown;</foo>").unwrap_err().to_string();

tests/golden.rs

@@ -917,6 +917,26 @@ json["123numeric"] = "value4";
     r#"{"123numeric":"value4","key with spaces":"value3","key-with-dashes":"value1","key.with.dots":"value2"}"#
 );
 
+#[cfg(feature = "greppable")]
+test!(
+    from_gron_single_quoted_path_segment,
+    &["--from-gron", "-S", "this"],
+    r#"json = {};
+json['User-Agent'] = "gron/0.1";
+"#,
+    r#"{"User-Agent":"gron/0.1"}"#
+);
+
+#[cfg(feature = "greppable")]
+test!(
+    from_gron_single_quoted_value,
+    &["--from-gron", "-S", "this"],
+    r#"json = {};
+json.value = 'single quoted';
+"#,
+    r#"{"value":"single quoted"}"#
+);
+
 #[cfg(feature = "greppable")]
 test!(
     from_gron_deeply_nested,