usage/spec/
helpers.rs

1use indexmap::IndexMap;
2use kdl::{KdlEntry, KdlNode, KdlValue};
3use miette::SourceSpan;
4use std::fmt::Debug;
5use std::ops::RangeBounds;
6
7use crate::error::UsageErr;
8use crate::spec::context::ParsingContext;
9
10#[derive(Debug)]
11pub struct NodeHelper<'a> {
12    pub(crate) node: &'a KdlNode,
13    pub(crate) ctx: &'a ParsingContext,
14}
15
16impl<'a> NodeHelper<'a> {
17    pub(crate) fn new(ctx: &'a ParsingContext, node: &'a KdlNode) -> Self {
18        Self { node, ctx }
19    }
20
21    pub(crate) fn name(&self) -> &str {
22        self.node.name().value()
23    }
24    pub(crate) fn span(&self) -> SourceSpan {
25        (self.node.span().offset(), self.node.span().len()).into()
26    }
27    pub(crate) fn ensure_arg_len<R>(&self, range: R) -> Result<&Self, UsageErr>
28    where
29        R: RangeBounds<usize> + Debug,
30    {
31        let count = self.args().count();
32        if !range.contains(&count) {
33            let ctx = self.ctx;
34            let span = self.span();
35            bail_parse!(ctx, span, "expected {range:?} arguments, got {count}",)
36        }
37        Ok(self)
38    }
39    pub(crate) fn get(&self, key: &str) -> Option<ParseEntry> {
40        self.node.entry(key).map(|e| ParseEntry::new(self.ctx, e))
41    }
42    pub(crate) fn arg(&self, i: usize) -> Result<ParseEntry, UsageErr> {
43        if let Some(entry) = self.args().nth(i) {
44            return Ok(entry);
45        }
46        bail_parse!(self.ctx, self.span(), "missing argument")
47    }
48    pub(crate) fn args(&self) -> impl Iterator<Item = ParseEntry> + '_ {
49        self.node
50            .entries()
51            .iter()
52            .filter(|e| e.name().is_none())
53            .map(|e| ParseEntry::new(self.ctx, e))
54    }
55    pub(crate) fn props(&self) -> IndexMap<&str, ParseEntry> {
56        self.node
57            .entries()
58            .iter()
59            .filter_map(|e| {
60                e.name()
61                    .map(|key| (key.value(), ParseEntry::new(self.ctx, e)))
62            })
63            .collect()
64    }
65    pub(crate) fn children(&self) -> Vec<Self> {
66        self.node
67            .children()
68            .map(|c| {
69                c.nodes()
70                    .iter()
71                    .map(|n| NodeHelper::new(self.ctx, n))
72                    .collect()
73            })
74            .unwrap_or_default()
75    }
76}
77
78#[derive(Debug)]
79pub(crate) struct ParseEntry<'a> {
80    pub(crate) ctx: &'a ParsingContext,
81    pub(crate) entry: &'a KdlEntry,
82    pub(crate) value: &'a KdlValue,
83}
84
85impl<'a> ParseEntry<'a> {
86    fn new(ctx: &'a ParsingContext, entry: &'a KdlEntry) -> Self {
87        Self {
88            ctx,
89            entry,
90            value: entry.value(),
91        }
92    }
93
94    fn span(&self) -> SourceSpan {
95        (self.entry.span().offset(), self.entry.span().len()).into()
96    }
97}
98
99impl ParseEntry<'_> {
100    pub fn ensure_usize(&self) -> Result<usize, UsageErr> {
101        match self.value.as_integer() {
102            Some(i) => Ok(i as usize),
103            None => bail_parse!(self.ctx, self.span(), "expected usize"),
104        }
105    }
106    #[allow(dead_code)]
107    pub fn ensure_f64(&self) -> Result<f64, UsageErr> {
108        match self.value.as_float() {
109            Some(f) => Ok(f),
110            None => bail_parse!(self.ctx, self.span(), "expected float"),
111        }
112    }
113    pub fn ensure_bool(&self) -> Result<bool, UsageErr> {
114        match self.value.as_bool() {
115            Some(b) => Ok(b),
116            None => bail_parse!(self.ctx, self.span(), "expected bool"),
117        }
118    }
119    pub fn ensure_string(&self) -> Result<String, UsageErr> {
120        match self.value.as_string() {
121            Some(s) => Ok(s.to_string()),
122            None => bail_parse!(self.ctx, self.span(), "expected string"),
123        }
124    }
125}
usage/spec/helpers.rs

usage/spec/
helpers.rs
