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

//! Utility for building a [`JsonPathQuery`](`crate::query::JsonPathQuery`)
//! programmatically.
use super::{JsonPathQuery, JsonPathQueryNode, Label};

/// Builder for [`JsonPathQuery`] instances.
///
/// # Examples
/// ```
/// # use rsonpath_lib::query::{JsonPathQuery, Label, builder::JsonPathQueryBuilder};
/// let builder = JsonPathQueryBuilder::new()
///     .child(Label::new("a"))
///     .descendant(Label::new("b"))
///     .any_child()
///     .child(Label::new("c"))
///     .any_descendant();
///
/// // Can also use `builder.build()`.
/// let query: JsonPathQuery = builder.into();
///
/// assert_eq!(format!("{query}"), "$['a']..['b'][*]['c']..[*]");
/// ```
pub struct JsonPathQueryBuilder {
    nodes: Vec<NodeTemplate>,
}

impl JsonPathQueryBuilder {
    /// Initialize an empty builder.
    ///
    /// # Examples
    /// ```
    /// # use rsonpath_lib::query::{JsonPathQuery, JsonPathQueryNode, Label, builder::JsonPathQueryBuilder};
    /// let builder = JsonPathQueryBuilder::new();
    /// let query: JsonPathQuery = builder.into();
    ///
    /// assert_eq!(*query.root(), JsonPathQueryNode::Root(None));
    /// ```
    #[must_use]
    #[inline(always)]
    pub fn new() -> Self {
        Self { nodes: vec![] }
    }

    /// Add a child selector with a given label.
    #[must_use]
    #[inline(always)]
    pub fn child(mut self, label: Label) -> Self {
        self.nodes.push(NodeTemplate::Child(label));
        self
    }

    /// Add a wildcard child selector.
    #[must_use]
    #[inline(always)]
    pub fn any_child(mut self) -> Self {
        self.nodes.push(NodeTemplate::AnyChild);
        self
    }

    /// Add a descendant selector with a given label.
    #[must_use]
    #[inline(always)]
    pub fn descendant(mut self, label: Label) -> Self {
        self.nodes.push(NodeTemplate::Descendant(label));
        self
    }

    /// Add a wildcard descendant selector.
    #[must_use]
    #[inline(always)]
    pub fn any_descendant(mut self) -> Self {
        self.nodes.push(NodeTemplate::AnyDescendant);
        self
    }

    /// Consume the builder and produce a [`JsonPathQuery`].
    #[must_use]
    #[inline]
    pub fn build(self) -> JsonPathQuery {
        let mut last = None;

        for node in self.nodes.into_iter().rev() {
            last = match node {
                NodeTemplate::Child(label) => Some(Box::new(JsonPathQueryNode::Child(label, last))),
                NodeTemplate::AnyChild => Some(Box::new(JsonPathQueryNode::AnyChild(last))),
                NodeTemplate::Descendant(label) => {
                    Some(Box::new(JsonPathQueryNode::Descendant(label, last)))
                }
                NodeTemplate::AnyDescendant => {
                    Some(Box::new(JsonPathQueryNode::AnyDescendant(last)))
                }
            };
        }

        JsonPathQuery {
            root: Box::new(JsonPathQueryNode::Root(last)),
        }
    }
}

impl Default for JsonPathQueryBuilder {
    #[inline(always)]
    fn default() -> Self {
        Self::new()
    }
}

impl From<JsonPathQueryBuilder> for JsonPathQuery {
    #[inline(always)]
    fn from(value: JsonPathQueryBuilder) -> Self {
        value.build()
    }
}

enum NodeTemplate {
    Child(Label),
    AnyChild,
    AnyDescendant,
    Descendant(Label),
}