valence_text 0.2.0-alpha.1+mc.1.20.1

Parsing and writing Minecraft's JSON text format
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use valence_ident::ident;

use super::*;

#[test]
fn text_round_trip() {
    let before = "foo".color(Color::RED).bold()
        + ("bar".obfuscated().color(Color::YELLOW)
            + "baz".underlined().not_bold().italic().color(Color::BLACK));

    let json = format!("{before:#}");

    let after = Text::from_str(&json).unwrap();

    println!("==== Before ====\n");
    println!("{before:#?}");
    println!("==== After ====\n");
    println!("{after:#?}");

    assert_eq!(before, after);
    assert_eq!(before.to_string(), after.to_string());
}

#[test]
fn non_object_data_types() {
    let input = r#"["foo", true, false, 1.9E10, 9999]"#;
    let txt: Text = serde_json::from_str(input).unwrap();

    assert_eq!(txt, "foo".into_text() + true + false + 1.9E10 + 9999);
}

#[test]
fn translate() {
    let txt = Text::translate(
        "chat.type.advancement.task",
        ["arg1".into_text(), "arg2".into_text()],
    );
    let serialized = txt.to_string();
    let deserialized = Text::from_str(&serialized).unwrap();
    assert_eq!(
        serialized,
        r#"{"translate":"chat.type.advancement.task","with":[{"text":"arg1"},{"text":"arg2"}]}"#
    );
    assert_eq!(txt, deserialized);
}

#[test]
fn score() {
    let txt = Text::score("foo", "bar", Some(Cow::from("baz")));
    let serialized = txt.to_string();
    let deserialized = Text::from_str(&serialized).unwrap();
    assert_eq!(
        serialized,
        r#"{"score":{"name":"foo","objective":"bar","value":"baz"}}"#
    );
    assert_eq!(txt, deserialized);
}

#[test]
fn selector() {
    let separator = Text::text("bar").color(Color::RED).bold();
    let txt = Text::selector("foo", Some(separator));
    let serialized = txt.to_string();
    let deserialized = Text::from_str(&serialized).unwrap();
    assert_eq!(
        serialized,
        r##"{"selector":"foo","separator":{"text":"bar","color":"red","bold":true}}"##
    );
    assert_eq!(txt, deserialized);
}

#[test]
fn keybind() {
    let txt = Text::keybind("foo");
    let serialized = txt.to_string();
    let deserialized = Text::from_str(&serialized).unwrap();
    assert_eq!(serialized, r#"{"keybind":"foo"}"#);
    assert_eq!(txt, deserialized);
}

#[test]
fn block_nbt() {
    let txt = Text::block_nbt("foo", "bar", Some(true), Some("baz".into_text()));
    let serialized = txt.to_string();
    let deserialized = Text::from_str(&serialized).unwrap();
    let expected = r#"{"block":"foo","nbt":"bar","interpret":true,"separator":{"text":"baz"}}"#;
    assert_eq!(serialized, expected);
    assert_eq!(txt, deserialized);
}

#[test]
fn entity_nbt() {
    let txt = Text::entity_nbt("foo", "bar", Some(true), Some("baz".into_text()));
    let serialized = txt.to_string();
    let deserialized = Text::from_str(&serialized).unwrap();
    let expected = r#"{"entity":"foo","nbt":"bar","interpret":true,"separator":{"text":"baz"}}"#;
    assert_eq!(serialized, expected);
    assert_eq!(txt, deserialized);
}

#[test]
fn storage_nbt() {
    let txt = Text::storage_nbt(ident!("foo"), "bar", Some(true), Some("baz".into_text()));
    let serialized = txt.to_string();
    let deserialized = Text::from_str(&serialized).unwrap();
    let expected =
        r#"{"storage":"minecraft:foo","nbt":"bar","interpret":true,"separator":{"text":"baz"}}"#;
    assert_eq!(serialized, expected);
    assert_eq!(txt, deserialized);
}

#[test]
fn text_to_legacy_lossy() {
    let text = "Heavily formatted green text\n"
        .bold()
        .italic()
        .strikethrough()
        .underlined()
        .obfuscated()
        .color(Color::GREEN)
        + "Lightly formatted red text\n"
            .not_bold()
            .not_strikethrough()
            .not_obfuscated()
            .color(Color::RED)
        + "Not formatted blue text"
            .not_italic()
            .not_underlined()
            .color(Color::BLUE);

    assert_eq!(
        text.to_legacy_lossy(),
        "§a§k§l§m§n§oHeavily formatted green text\n§r§c§n§oLightly formatted red text\n§r§9Not \
         formatted blue text"
    );
}