tss 0.2.2

Generated node type enums and metadata from tree-sitter languages
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

//! Basic integration tests for Rust language support.

#![allow(clippy::negative_feature_names)]
#![allow(clippy::redundant_feature_names)]
#![cfg(feature = "lang-rust")]

use tree_sitter_symbols::NodeTypeRust as NodeType;

// Check that a node type type exists (empty if no node features are on)
// You cannot do much without any node types
#[test]
fn enum_exists() {
    // This prints the type name at runtime
    println!("{}", std::any::type_name::<NodeType>());
}

#[cfg(feature = "lang-rust-full")]
#[test]
fn enum_variants_exist() {
    // Check some common node types exist as variants
    let _ = NodeType::FunctionItem;
    let _ = NodeType::StructItem;
    let _ = NodeType::ImplItem;
    let _ = NodeType::ModItem;
    let _ = NodeType::Block;
    let _ = NodeType::Identifier;
}

#[cfg(feature = "lang-rust-full")]
#[test]
fn from_str_works() {
    use std::str::FromStr;

    assert_eq!(
        NodeType::from_str("function_item").unwrap(),
        NodeType::FunctionItem
    );
    assert_eq!(
        NodeType::from_str("struct_item").unwrap(),
        NodeType::StructItem
    );
    assert_eq!(NodeType::from_str("impl_item").unwrap(), NodeType::ImplItem);
}

#[cfg(feature = "lang-rust-full")]
#[test]
fn from_str_rejects_unknown() {
    use std::str::FromStr;

    assert!(NodeType::from_str("not_a_real_node_type").is_err());
}

#[cfg(feature = "lang-rust-full")]
#[test]
fn display_works() {
    assert_eq!(NodeType::FunctionItem.to_string(), "function_item");
    assert_eq!(NodeType::StructItem.to_string(), "struct_item");
    assert_eq!(NodeType::ImplItem.to_string(), "impl_item");
}

#[cfg(feature = "lang-rust-full")]
#[test]
fn roundtrip() {
    use std::str::FromStr;

    let original = "function_item";
    let parsed = NodeType::from_str(original).unwrap();
    let displayed = parsed.to_string();
    assert_eq!(original, displayed);
}