Add octal binary literals (#5604)

Schema `0o[77]` with the same padding behavior as the other binary literals

- this updates #5551
- test for parsing binary from octal
- test for string parsing

crates/nu-parser/src/parser.rs

@@ -1094,7 +1094,11 @@ pub fn parse_binary(
 ) -> (Expression, Option<ParseError>) {
     let (hex_value, err) = parse_binary_with_base(working_set, span, 16, 2, b"0x[", b"]");
     if err.is_some() {
-        return parse_binary_with_base(working_set, span, 2, 8, b"0b[", b"]");
+        let (octal_value, err) = parse_binary_with_base(working_set, span, 8, 3, b"0o[", b"]");
+        if err.is_some() {
+            return parse_binary_with_base(working_set, span, 2, 8, b"0b[", b"]");
+        }
+        return (octal_value, err);
     }
     (hex_value, err)
 }

crates/nu-parser/tests/test_parser.rs

@@ -117,6 +117,91 @@ pub fn parse_binary_with_incomplete_binary_format() {
     assert_eq!(expressions[0].expr, Expr::Binary(vec![0b00000010]))
 }
 
+#[test]
+pub fn parse_binary_with_octal_format() {
+    let engine_state = EngineState::new();
+    let mut working_set = StateWorkingSet::new(&engine_state);
+
+    let (block, err) = parse(&mut working_set, None, b"0o[250]", true, &[]);
+
+    assert!(err.is_none());
+    assert!(block.len() == 1);
+    let expressions = &block[0];
+    assert!(expressions.len() == 1);
+    assert_eq!(expressions[0].expr, Expr::Binary(vec![0o250]))
+}
+
+#[test]
+pub fn parse_binary_with_incomplete_octal_format() {
+    let engine_state = EngineState::new();
+    let mut working_set = StateWorkingSet::new(&engine_state);
+
+    let (block, err) = parse(&mut working_set, None, b"0o[2]", true, &[]);
+
+    assert!(err.is_none());
+    assert!(block.len() == 1);
+    let expressions = &block[0];
+    assert!(expressions.len() == 1);
+    assert_eq!(expressions[0].expr, Expr::Binary(vec![0o2]))
+}
+
+#[test]
+pub fn parse_binary_with_invalid_octal_format() {
+    let engine_state = EngineState::new();
+    let mut working_set = StateWorkingSet::new(&engine_state);
+
+    let (block, err) = parse(&mut working_set, None, b"0b[90]", true, &[]);
+
+    assert!(err.is_none());
+    assert!(block.len() == 1);
+    let expressions = &block[0];
+    assert!(expressions.len() == 1);
+    assert!(match &expressions[0].expr {
+        Expr::Binary(_) => false,
+        _ => true,
+    })
+}
+
+#[test]
+pub fn parse_string() {
+    let engine_state = EngineState::new();
+    let mut working_set = StateWorkingSet::new(&engine_state);
+
+    let (block, err) = parse(&mut working_set, None, b"\"hello nushell\"", true, &[]);
+
+    assert!(err.is_none());
+    assert!(block.len() == 1);
+    let expressions = &block[0];
+    assert!(expressions.len() == 1);
+    assert_eq!(
+        expressions[0].expr,
+        Expr::String("hello nushell".to_string())
+    )
+}
+
+#[test]
+pub fn parse_escaped_string() {
+    let engine_state = EngineState::new();
+    let mut working_set = StateWorkingSet::new(&engine_state);
+
+    let (block, err) = parse(
+        &mut working_set,
+        None,
+        b"\"hello \\u006e\\u0075\\u0073hell\"",
+        true,
+        &[],
+    );
+
+    assert!(err.is_none());
+    assert!(block.len() == 1);
+    let expressions = &block[0];
+    assert!(expressions.len() == 1);
+    assert_eq!(
+        expressions[0].expr,
+        Expr::String("hello nushell".to_string())
+    )
+}
+
 #[test]
 pub fn parse_call() {
     let engine_state = EngineState::new();