vespe 0.1.2

Text as a Canvas for LLM Collaboration and Automation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use super::super::Ast2Error;
use super::parser::Parser;
use super::values::{_try_parse_enclosed_string, _try_parse_enclosed_value, _try_parse_value};
use serde_json::json;

#[test]
fn test_try_parse_enclosed_string_double_quote() {
    let doc = r#""hello world" rest"#;
    let parser = Parser::new(doc);
    let p_after_opening_quote = parser.consume_matching_char_immutable('"').unwrap(); // Consume opening quote
    let (value, p_next) = _try_parse_enclosed_string(&parser, "\"").unwrap().unwrap();
    assert_eq!(value, "hello world");
    assert_eq!(p_next.remain(), " rest");

    let doc_escaped = r#""hello \"world\"" rest"#;
    let parser_escaped = Parser::new(doc_escaped);
    let p_after_opening_quote_escaped =
        parser_escaped.consume_matching_char_immutable('"').unwrap(); // Consume opening quote
    let (value_escaped, p_next_escaped) = _try_parse_enclosed_string(&parser_escaped, "\"")
        .unwrap()
        .unwrap();
    assert_eq!(value_escaped, "hello \"world\""); // Expect unescaped
    assert_eq!(p_next_escaped.remain(), " rest");

    let doc_unclosed = r#""hello"#;
    let parser_unclosed = Parser::new(doc_unclosed);
    let p_after_opening_quote_unclosed = parser_unclosed
        .consume_matching_char_immutable('"')
        .unwrap(); // Consume opening quote
    let result = _try_parse_enclosed_string(&parser_unclosed, "\"");
    assert!(matches!(result, Err(Ast2Error::UnclosedString { .. })));
}

#[test]
fn test_try_parse_enclosed_string_single_quote() {
    let doc = r#"'hello world' rest"#;
    let parser = Parser::new(doc);
    let p_after_opening_quote = parser.consume_matching_char_immutable('\'').unwrap(); // Consume opening quote
    let (value, p_next) = _try_parse_enclosed_string(&parser, "'").unwrap().unwrap();
    assert_eq!(value, "hello world");
    assert_eq!(p_next.remain(), " rest");

    let doc_escaped = r#"'hello \'world\'' rest"#;
    let parser_escaped = Parser::new(doc_escaped);
    let p_after_opening_quote_escaped = parser_escaped
        .consume_matching_char_immutable('\'')
        .unwrap(); // Consume opening quote
    let (value_escaped, p_next_escaped) = _try_parse_enclosed_string(&parser_escaped, "'")
        .unwrap()
        .unwrap();
    assert_eq!(value_escaped, "hello 'world'"); // Expect unescaped
    assert_eq!(p_next_escaped.remain(), " rest");
}

#[test]
fn test_try_parse_enclosed_value_double_quote() {
    let doc = r#""json value" rest"#;
    let parser = Parser::new(doc);
    let p_after_opening_quote = parser.consume_matching_char_immutable('"').unwrap(); // Consume opening quote
    let (value, p_next) = _try_parse_enclosed_value(&parser, "\"").unwrap().unwrap();
    assert_eq!(value, json!("json value"));
    assert_eq!(p_next.remain(), " rest");
}

#[test]
fn test_try_parse_enclosed_value_single_quote() {
    let doc = "'json value' rest";
    let parser = Parser::new(doc);
    let p_after_opening_quote = parser.consume_matching_char_immutable('\'').unwrap(); // Consume opening quote
    let (value, p_next) = _try_parse_enclosed_value(&parser, "'").unwrap().unwrap();
    assert_eq!(value, json!("json value"));
    assert_eq!(p_next.remain(), " rest");
}

#[test]
fn test_try_parse_value_enclosed() {
    let doc_double = r#""double quoted" rest"#;
    let parser_double = Parser::new(doc_double);
    let (value_double, p_next_double) = _try_parse_value(&parser_double).unwrap().unwrap();
    assert_eq!(value_double, json!("double quoted"));
    assert_eq!(p_next_double.remain(), " rest");

    let doc_single = "'single quoted' rest";
    let parser_single = Parser::new(doc_single);
    let (value_single, p_next_single) = _try_parse_value(&parser_single).unwrap().unwrap();
    assert_eq!(value_single, json!("single quoted"));
    assert_eq!(p_next_single.remain(), " rest");
}