clouseau_core/
lib.rs

1#[cfg(feature = "arrayvec")]
2mod arrayvec;
3mod float;
4mod std_impls;
5#[cfg(feature = "uuid")]
6mod uuid;
7
8use float::WellBehavedF64;
9use std::fmt;
10use std::iter;
11use std::rc::Rc;
12use thiserror::Error;
13
14#[derive(Debug, Error)]
15pub enum Error {
16    #[error("Expected value")]
17    ExpectedValue,
18    #[error("Expected node")]
19    ExpectedNode,
20    // TODO include names of actual and expected types
21    #[error("Type error")]
22    TypeError,
23    #[error("Expected integer")]
24    ExpectedInt,
25    #[error("Variable not found")]
26    VarNotFound,
27    #[error("Function not found")]
28    FnNotFound,
29    #[error("Cannot execute a path on a value")]
30    PathOnValue,
31    #[error("Input is empty in {0}")]
32    Empty(&'static str),
33    #[error("Conversion failed: {0}")]
34    Conversion(#[from] Box<dyn std::error::Error>),
35}
36
37pub type Result<T> = std::result::Result<T, Error>;
38
39pub type Node<'a, 'q> = &'a (dyn Queryable<'q> + 'a);
40
41#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
42pub enum Value {
43    String(String),
44    Int(i64),
45    Float(WellBehavedF64),
46    Bool(bool),
47    Array(Array),
48}
49
50pub struct ValueIter<'a>(pub Box<dyn Iterator<Item = Value> + 'a>);
51
52impl<'a> ValueIter<'a> {
53    pub fn empty() -> Self {
54        ValueIter(Box::new(iter::empty()))
55    }
56
57    pub fn once<V: Into<Value>>(val: V) -> Self {
58        ValueIter(Box::new(iter::once(val.into())))
59    }
60
61    pub fn from_values<T: 'a>(values: impl IntoIterator<Item = T> + 'a) -> Self
62    where
63        T: Into<Value>,
64    {
65        ValueIter(Box::from(values.into_iter().map(|v| v.into())))
66    }
67}
68
69impl<'a> Iterator for ValueIter<'a> {
70    type Item = Value;
71    fn next(&mut self) -> Option<Self::Item> {
72        self.0.next()
73    }
74}
75
76pub struct NodeIter<'a, 'q>(pub Box<dyn Iterator<Item = Node<'a, 'q>> + 'a>);
77
78impl<'a, 'q> NodeIter<'a, 'q> {
79    pub fn empty() -> NodeIter<'a, 'q> {
80        NodeIter(Box::new(iter::empty()))
81    }
82
83    pub fn from_queryables<Q>(queryables: impl IntoIterator<Item = &'a Q> + 'a) -> Self
84    where
85        Q: Queryable<'q> + 'a,
86    {
87        NodeIter(Box::from(queryables.into_iter().map(|q| q as _)))
88    }
89}
90
91impl<'a, 'q> Iterator for NodeIter<'a, 'q> {
92    type Item = Node<'a, 'q>;
93    fn next(&mut self) -> Option<Self::Item> {
94        self.0.next()
95    }
96}
97
98#[derive(Debug)]
99pub enum NodeOrValue<'a, 'q> {
100    Node(Node<'a, 'q>),
101    Value(Value),
102}
103
104impl<'a, 'q> NodeOrValue<'a, 'q> {
105    pub fn try_into_int(self) -> Result<i64> {
106        self.try_into_value()
107            .map_err(|_| Error::ExpectedInt)
108            .and_then(Value::try_into_int)
109    }
110
111    pub fn try_into_value(self) -> Result<Value> {
112        match self {
113            NodeOrValue::Node(node) => {
114                if let Some(data) = node.data() {
115                    Ok(data)
116                } else {
117                    Err(Error::ExpectedValue)
118                }
119            }
120            NodeOrValue::Value(v) => Ok(v),
121        }
122    }
123
124    pub fn try_into_node(self) -> Result<Node<'a, 'q>> {
125        match self {
126            NodeOrValue::Node(n) => Ok(n),
127            NodeOrValue::Value(_) => Err(Error::ExpectedNode),
128        }
129    }
130}
131
132impl<'a, 'q> From<Value> for NodeOrValue<'a, 'q> {
133    fn from(v: Value) -> Self {
134        NodeOrValue::Value(v)
135    }
136}
137
138impl<'a, 'q> From<Node<'a, 'q>> for NodeOrValue<'a, 'q> {
139    fn from(n: Node<'a, 'q>) -> Self {
140        NodeOrValue::Node(n)
141    }
142}
143
144impl<'a, 'q> fmt::Display for NodeOrValue<'a, 'q> {
145    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
146        match self {
147            NodeOrValue::Node(node) => write!(f, "{}", node),
148            NodeOrValue::Value(value) => write!(f, "{}", value),
149        }
150    }
151}
152
153pub struct NodeOrValueIter<'a, 'q>(Box<dyn Iterator<Item = Result<NodeOrValue<'a, 'q>>> + 'a>);
154
155impl<'a, 'q> NodeOrValueIter<'a, 'q> {
156    pub fn empty() -> Self {
157        NodeOrValueIter(Box::new(iter::empty()))
158    }
159
160    pub fn one(item: Result<NodeOrValue<'a, 'q>>) -> Self {
161        NodeOrValueIter(Box::new(iter::once(item)))
162    }
163
164    pub fn one_node(node: Node<'a, 'q>) -> Self {
165        Self::from_raw(iter::once(node).map(|n| Ok(n.into())))
166    }
167
168    pub fn one_value(value: Value) -> Self {
169        Self::from_raw(iter::once(value).map(|v| Ok(v.into())))
170    }
171
172    pub fn from_queryables<I, Q>(nodes: I) -> Self
173    where
174        I: IntoIterator<Item = &'a Q> + 'a,
175        Q: Queryable<'q> + 'a,
176    {
177        NodeOrValueIter(Box::new(
178            nodes.into_iter().map(|node| Ok(NodeOrValue::Node(node))),
179        ))
180    }
181
182    pub fn from_nodes<I>(nodes: I) -> Self
183    where
184        I: IntoIterator<Item = &'a dyn Queryable<'q>> + 'a,
185    {
186        NodeOrValueIter(Box::new(
187            nodes.into_iter().map(|node| Ok(NodeOrValue::Node(node))),
188        ))
189    }
190
191    pub fn from_values<I>(values: I) -> Self
192    where
193        I: IntoIterator + 'a,
194        I::Item: Into<Value>,
195    {
196        NodeOrValueIter(Box::new(
197            values
198                .into_iter()
199                .map(|value| Ok(NodeOrValue::Value(value.into()))),
200        ))
201    }
202
203    pub fn from_raw<I>(iter: I) -> Self
204    where
205        I: IntoIterator<Item = Result<NodeOrValue<'a, 'q>>> + 'a,
206    {
207        NodeOrValueIter(Box::new(iter.into_iter()))
208    }
209}
210
211impl<'a, 'q> Iterator for NodeOrValueIter<'a, 'q> {
212    type Item = Result<NodeOrValue<'a, 'q>>;
213    fn next(&mut self) -> Option<Self::Item> {
214        self.0.next()
215    }
216}
217
218pub trait Queryable<'q> {
219    fn keys(&self) -> ValueIter<'_> {
220        ValueIter::empty()
221    }
222    fn member<'a, 'f>(&'a self, _: &'f Value) -> Option<Node<'a, 'q>> {
223        None
224    }
225    fn all<'a>(&'a self) -> NodeOrValueIter<'a, 'q> {
226        NodeOrValueIter::empty()
227    }
228    fn descendants<'a>(&'a self) -> NodeOrValueIter<'a, 'q> {
229        if self.all().next().is_some() {
230            NodeOrValueIter::from_raw(self.all().chain(self.all().flat_map(|node| {
231                if let Ok(node) = node {
232                    match node {
233                        NodeOrValue::Node(node) => node.descendants(),
234                        NodeOrValue::Value(value) => NodeOrValueIter::one_value(value),
235                    }
236                } else {
237                    NodeOrValueIter::empty()
238                }
239            })))
240        } else {
241            self.all()
242        }
243    }
244    fn name(&self) -> &'static str;
245    fn data(&self) -> Option<Value> {
246        None
247    }
248}
249
250#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
251pub struct Array(pub Rc<[Value]>);
252
253impl Array {
254    pub fn len(&self) -> usize {
255        self.0.len()
256    }
257
258    pub fn is_empty(&self) -> bool {
259        self.0.is_empty()
260    }
261}
262
263impl IntoIterator for Array {
264    type Item = Value;
265    type IntoIter = ArrayIter;
266    fn into_iter(self) -> ArrayIter {
267        ArrayIter {
268            current: 0,
269            array: self,
270        }
271    }
272}
273
274pub struct ArrayIter {
275    current: usize,
276    array: Array,
277}
278
279impl Iterator for ArrayIter {
280    type Item = Value;
281    fn next(&mut self) -> Option<Value> {
282        if self.current == self.array.len() {
283            None
284        } else {
285            let index = self.current;
286            self.current += 1;
287            Some(self.array.0[index].clone())
288        }
289    }
290}
291
292impl fmt::Display for Array {
293    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
294        f.write_str("{")?;
295        let mut it = self.clone().into_iter().peekable();
296        while let Some(val) = it.next() {
297            let mut format = |args| {
298                if it.peek().is_some() {
299                    write!(f, "{}, ", args)
300                } else {
301                    write!(f, "{}", args)
302                }
303            };
304            if let Value::String(s) = val {
305                format(format_args!(r#""{}""#, s))
306            } else {
307                format(format_args!("{}", val))
308            }?;
309        }
310        f.write_str("}")
311    }
312}
313
314impl Value {
315    pub fn try_into_int(self) -> Result<i64> {
316        if let Value::Int(i) = self {
317            Ok(i)
318        } else {
319            Err(Error::ExpectedInt)
320        }
321    }
322}
323
324impl fmt::Display for Value {
325    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
326        match self {
327            Value::String(v) => write!(f, "{}", v),
328            Value::Int(v) => write!(f, "{}", v),
329            Value::Bool(v) => write!(f, "{}", v),
330            Value::Array(v) => write!(f, "{}", v),
331            Value::Float(v) => write!(f, "{}", v),
332        }
333    }
334}
335
336impl<'a, 'q> fmt::Display for Node<'a, 'q> {
337    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
338        if let Some(data) = self.data() {
339            write!(f, "{}", data)
340        } else {
341            write!(f, "[{}]", self.name())
342        }
343    }
344}
345
346impl<'a, 'q> fmt::Debug for &'a dyn Queryable<'q> {
347    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
348        write!(f, "[{} {:?}]", self.name(), self.data())
349    }
350}
clouseau_core/lib.rs

clouseau_core/
lib.rs
