helix-ast 0.1.0

Shared Helix query AST and JSON wire contract for Helix SDKs
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

use serde::{Deserialize, Serialize};

/// Type alias for node IDs.
pub type NodeId = u64;

/// Type alias for edge IDs.
pub type EdgeId = u64;
/// A reference to nodes.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum NodeRef {
    /// All nodes.
    All,
    /// Concrete node IDs.
    Ids(Vec<NodeId>),
    /// Named variable.
    Var(String),
    /// Runtime parameter containing IDs.
    Param(String),
}

impl NodeRef {
    /// Reference all nodes.
    pub fn all() -> Self {
        Self::All
    }

    /// Reference one node.
    pub fn id(id: NodeId) -> Self {
        Self::Ids(vec![id])
    }

    /// Reference multiple nodes.
    pub fn ids(ids: impl IntoIterator<Item = NodeId>) -> Self {
        Self::Ids(ids.into_iter().collect())
    }

    /// Reference a variable.
    pub fn var(name: impl Into<String>) -> Self {
        Self::Var(name.into())
    }

    /// Reference a runtime parameter.
    pub fn param(name: impl Into<String>) -> Self {
        Self::Param(name.into())
    }
}

impl From<NodeId> for NodeRef {
    fn from(value: NodeId) -> Self {
        Self::id(value)
    }
}

impl From<Vec<NodeId>> for NodeRef {
    fn from(value: Vec<NodeId>) -> Self {
        Self::Ids(value)
    }
}

impl<const N: usize> From<[NodeId; N]> for NodeRef {
    fn from(value: [NodeId; N]) -> Self {
        Self::Ids(value.to_vec())
    }
}

impl From<&str> for NodeRef {
    fn from(value: &str) -> Self {
        Self::Var(value.to_string())
    }
}

/// A reference to edges.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum EdgeRef {
    /// All edges.
    All,
    /// Concrete edge IDs.
    Ids(Vec<EdgeId>),
    /// Named variable.
    Var(String),
    /// Runtime parameter containing IDs.
    Param(String),
}

impl EdgeRef {
    /// Reference all edges.
    pub fn all() -> Self {
        Self::All
    }

    /// Reference one edge.
    pub fn id(id: EdgeId) -> Self {
        Self::Ids(vec![id])
    }

    /// Reference multiple edges.
    pub fn ids(ids: impl IntoIterator<Item = EdgeId>) -> Self {
        Self::Ids(ids.into_iter().collect())
    }

    /// Reference a variable.
    pub fn var(name: impl Into<String>) -> Self {
        Self::Var(name.into())
    }

    /// Reference a runtime parameter.
    pub fn param(name: impl Into<String>) -> Self {
        Self::Param(name.into())
    }
}

impl From<EdgeId> for EdgeRef {
    fn from(value: EdgeId) -> Self {
        Self::id(value)
    }
}

impl From<Vec<EdgeId>> for EdgeRef {
    fn from(value: Vec<EdgeId>) -> Self {
        Self::Ids(value)
    }
}

impl<const N: usize> From<[EdgeId; N]> for EdgeRef {
    fn from(value: [EdgeId; N]) -> Self {
        Self::Ids(value.to_vec())
    }
}