hcl/expr/
edit.rs

1use super::*;
2use crate::edit::{expr, template, Decorated, Ident};
3
4impl From<expr::Expression> for Expression {
5    fn from(value: expr::Expression) -> Self {
6        match value {
7            expr::Expression::Null(_) => Expression::Null,
8            expr::Expression::Bool(b) => b.value_into(),
9            expr::Expression::Array(array) => Expression::from_iter(array),
10            expr::Expression::Number(num) => num.value_into(),
11            expr::Expression::String(string) => string.value_into(),
12            expr::Expression::Object(object) => Expression::from_iter(object),
13            expr::Expression::UnaryOp(unary) => UnaryOp::from(*unary).into(),
14            expr::Expression::BinaryOp(binary) => BinaryOp::from(*binary).into(),
15            expr::Expression::ForExpr(for_expr) => ForExpr::from(*for_expr).into(),
16            expr::Expression::StringTemplate(template) => TemplateExpr::from(template).into(),
17            expr::Expression::HeredocTemplate(template) => Heredoc::from(*template).into(),
18            expr::Expression::Variable(variable) => Expression::Variable(variable.value_into()),
19            expr::Expression::FuncCall(func_call) => FuncCall::from(*func_call).into(),
20            expr::Expression::Traversal(traversal) => Traversal::from(*traversal).into(),
21            expr::Expression::Parenthesis(parens) => {
22                Expression::Parenthesis(Box::new(parens.into_inner().into()))
23            }
24            expr::Expression::Conditional(cond) => Conditional::from(*cond).into(),
25        }
26    }
27}
28
29impl From<Expression> for expr::Expression {
30    fn from(value: Expression) -> Self {
31        match value {
32            Expression::Null => expr::Expression::null(),
33            Expression::Bool(b) => b.into(),
34            Expression::Array(array) => expr::Expression::from_iter(array),
35            Expression::Number(num) => num.into(),
36            Expression::String(string) => string.into(),
37            Expression::Object(object) => expr::Expression::from_iter(object),
38            Expression::Operation(op) => match *op {
39                Operation::Unary(unary) => expr::UnaryOp::from(unary).into(),
40                Operation::Binary(binary) => expr::BinaryOp::from(binary).into(),
41            },
42            Expression::ForExpr(for_expr) => expr::ForExpr::from(*for_expr).into(),
43            Expression::TemplateExpr(template) => match *template {
44                TemplateExpr::Heredoc(heredoc) => template::HeredocTemplate::from(heredoc).into(),
45                TemplateExpr::QuotedString(template) => {
46                    template::StringTemplate::from(template_or_default(template)).into()
47                }
48            },
49            Expression::Variable(variable) => {
50                expr::Expression::Variable(variable.into_inner().into())
51            }
52            Expression::FuncCall(func_call) => expr::FuncCall::from(*func_call).into(),
53            Expression::Traversal(traversal) => expr::Traversal::from(*traversal).into(),
54            Expression::Parenthesis(parens) => expr::Parenthesis::new((*parens).into()).into(),
55            Expression::Conditional(cond) => expr::Conditional::from(*cond).into(),
56        }
57    }
58}
59
60impl From<expr::ObjectKey> for ObjectKey {
61    fn from(value: expr::ObjectKey) -> Self {
62        match value {
63            expr::ObjectKey::Ident(ident) => ObjectKey::Identifier(ident.into()),
64            expr::ObjectKey::Expression(expr) => ObjectKey::Expression(expr.into()),
65        }
66    }
67}
68
69impl From<ObjectKey> for expr::ObjectKey {
70    fn from(value: ObjectKey) -> Self {
71        match value {
72            ObjectKey::Identifier(ident) => expr::ObjectKey::Ident(ident.into()),
73            ObjectKey::Expression(expr) => expr::ObjectKey::Expression(expr.into()),
74        }
75    }
76}
77
78impl From<expr::ObjectValue> for Expression {
79    fn from(value: expr::ObjectValue) -> Self {
80        value.into_expr().into()
81    }
82}
83
84impl From<Expression> for expr::ObjectValue {
85    fn from(value: Expression) -> Self {
86        expr::ObjectValue::new(value)
87    }
88}
89
90impl From<expr::Conditional> for Conditional {
91    fn from(value: expr::Conditional) -> Self {
92        Conditional::new(value.cond_expr, value.true_expr, value.false_expr)
93    }
94}
95
96impl From<Conditional> for expr::Conditional {
97    fn from(value: Conditional) -> Self {
98        expr::Conditional::new(value.cond_expr, value.true_expr, value.false_expr)
99    }
100}
101
102impl From<expr::ForExpr> for ForExpr {
103    fn from(value: expr::ForExpr) -> Self {
104        let intro = value.intro;
105        ForExpr {
106            key_var: intro.key_var.map(Into::into),
107            value_var: intro.value_var.into(),
108            collection_expr: intro.collection_expr.into(),
109            key_expr: value.key_expr.map(Into::into),
110            value_expr: value.value_expr.into(),
111            grouping: value.grouping,
112            cond_expr: value.cond.map(|cond| cond.expr.into()),
113        }
114    }
115}
116
117impl From<ForExpr> for expr::ForExpr {
118    fn from(value: ForExpr) -> Self {
119        let mut intro = expr::ForIntro::new(value.value_var, value.collection_expr);
120        intro.key_var = value.key_var.map(Into::into);
121
122        let mut for_expr = expr::ForExpr::new(intro, value.value_expr);
123        for_expr.key_expr = value.key_expr.map(Into::into);
124        for_expr.grouping = value.grouping;
125        for_expr.cond = value.cond_expr.map(expr::ForCond::new);
126        for_expr
127    }
128}
129
130impl From<expr::FuncName> for FuncName {
131    fn from(value: expr::FuncName) -> Self {
132        FuncName {
133            namespace: value.namespace.into_iter().map(Into::into).collect(),
134            name: value.name.into(),
135        }
136    }
137}
138
139impl From<FuncName> for expr::FuncName {
140    fn from(value: FuncName) -> Self {
141        expr::FuncName {
142            namespace: value.namespace.into_iter().map(Into::into).collect(),
143            name: value.name.into(),
144        }
145    }
146}
147
148impl From<expr::FuncCall> for FuncCall {
149    fn from(value: expr::FuncCall) -> Self {
150        let expand_final = value.args.expand_final();
151        FuncCall {
152            name: value.name.into(),
153            args: value.args.into_iter().map(Into::into).collect(),
154            expand_final,
155        }
156    }
157}
158
159impl From<FuncCall> for expr::FuncCall {
160    fn from(value: FuncCall) -> Self {
161        let mut args = expr::FuncArgs::from_iter(value.args);
162        args.set_expand_final(value.expand_final);
163        expr::FuncCall::new(value.name, args)
164    }
165}
166
167impl From<expr::UnaryOp> for Operation {
168    fn from(value: expr::UnaryOp) -> Self {
169        Operation::Unary(value.into())
170    }
171}
172
173impl From<expr::BinaryOp> for Operation {
174    fn from(value: expr::BinaryOp) -> Self {
175        Operation::Binary(value.into())
176    }
177}
178
179impl From<expr::UnaryOp> for UnaryOp {
180    fn from(value: expr::UnaryOp) -> Self {
181        UnaryOp::new(value.operator.value_into(), value.expr)
182    }
183}
184
185impl From<UnaryOp> for expr::UnaryOp {
186    fn from(value: UnaryOp) -> Self {
187        expr::UnaryOp::new(value.operator, value.expr)
188    }
189}
190
191impl From<expr::BinaryOp> for BinaryOp {
192    fn from(value: expr::BinaryOp) -> Self {
193        BinaryOp::new(value.lhs_expr, value.operator.value_into(), value.rhs_expr)
194    }
195}
196
197impl From<BinaryOp> for expr::BinaryOp {
198    fn from(value: BinaryOp) -> Self {
199        expr::BinaryOp::new(value.lhs_expr, value.operator, value.rhs_expr)
200    }
201}
202
203impl From<template::StringTemplate> for TemplateExpr {
204    fn from(value: template::StringTemplate) -> Self {
205        TemplateExpr::QuotedString(template::Template::from(value).to_string())
206    }
207}
208
209impl From<template::HeredocTemplate> for Heredoc {
210    fn from(value: template::HeredocTemplate) -> Self {
211        let strip = value
212            .indent()
213            .map_or(HeredocStripMode::None, |_| HeredocStripMode::Indent);
214
215        Heredoc {
216            delimiter: value.delimiter.into(),
217            template: value.template.to_string(),
218            strip,
219        }
220    }
221}
222
223impl From<Heredoc> for template::HeredocTemplate {
224    fn from(value: Heredoc) -> Self {
225        template::HeredocTemplate::new(value.delimiter.into(), template_or_default(value.template))
226    }
227}
228
229impl From<expr::Traversal> for Traversal {
230    fn from(value: expr::Traversal) -> Self {
231        Traversal::new(value.expr, value.operators)
232    }
233}
234
235impl From<Traversal> for expr::Traversal {
236    fn from(value: Traversal) -> Self {
237        expr::Traversal::new(
238            value.expr,
239            value.operators.into_iter().map(Into::into).collect(),
240        )
241    }
242}
243
244impl From<Decorated<expr::TraversalOperator>> for TraversalOperator {
245    fn from(value: Decorated<expr::TraversalOperator>) -> Self {
246        value.value_into()
247    }
248}
249
250impl From<TraversalOperator> for Decorated<expr::TraversalOperator> {
251    fn from(value: TraversalOperator) -> Self {
252        Decorated::new(value.into())
253    }
254}
255
256impl From<expr::TraversalOperator> for TraversalOperator {
257    fn from(value: expr::TraversalOperator) -> Self {
258        match value {
259            expr::TraversalOperator::Index(index) => Expression::from(index).into(),
260            expr::TraversalOperator::GetAttr(ident) => ident.into(),
261            expr::TraversalOperator::AttrSplat(_) => TraversalOperator::AttrSplat,
262            expr::TraversalOperator::FullSplat(_) => TraversalOperator::FullSplat,
263            expr::TraversalOperator::LegacyIndex(index) => index.value_into(),
264        }
265    }
266}
267
268impl From<TraversalOperator> for expr::TraversalOperator {
269    fn from(value: TraversalOperator) -> Self {
270        match value {
271            TraversalOperator::Index(index) => expr::TraversalOperator::Index(index.into()),
272            TraversalOperator::GetAttr(ident) => expr::TraversalOperator::GetAttr(ident.into()),
273            TraversalOperator::AttrSplat => expr::TraversalOperator::AttrSplat(expr::Splat.into()),
274            TraversalOperator::FullSplat => expr::TraversalOperator::FullSplat(expr::Splat.into()),
275            TraversalOperator::LegacyIndex(index) => {
276                expr::TraversalOperator::LegacyIndex(index.into())
277            }
278        }
279    }
280}
281
282impl From<Ident> for Variable {
283    fn from(ident: Ident) -> Self {
284        Identifier::from(ident).into()
285    }
286}
287
288impl From<Decorated<Ident>> for Identifier {
289    fn from(value: Decorated<Ident>) -> Self {
290        value.value_into()
291    }
292}
293
294impl From<Identifier> for Decorated<Ident> {
295    fn from(value: Identifier) -> Self {
296        Decorated::new(value.into())
297    }
298}
299
300fn template_or_default<T: AsRef<str>>(s: T) -> template::Template {
301    s.as_ref().parse().unwrap_or_default()
302}
hcl/expr/edit.rs

hcl/expr/
edit.rs
