Skip to content

Commit a64bc51

Browse files
denis256denis256
committed
chore: cognitive complexity simplification
1 parent 7d859d0 commit a64bc51

2 files changed

Lines changed: 103 additions & 75 deletions

File tree

‎internal/hclparse/parse.go‎

Lines changed: 54 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -85,38 +85,9 @@ func ParseStackFile(src []byte, filename string, stackDir string, values *cty.Va
8585
evaluateLocals(stackFile.Locals.Remain, evalCtx)
8686
}
8787

88-
autoIncludes := make(map[string]*AutoIncludeResolved)
89-
90-
for _, unit := range stackFile.Units {
91-
if unit.AutoInclude == nil {
92-
continue
93-
}
94-
95-
resolved, resolveDiags := unit.AutoInclude.Resolve(evalCtx)
96-
if resolveDiags.HasErrors() {
97-
return nil, resolveDiags
98-
}
99-
100-
if resolved != nil {
101-
resolved.EvalCtx = evalCtx
102-
autoIncludes[unit.Name] = resolved
103-
}
104-
}
105-
106-
for _, stack := range stackFile.Stacks {
107-
if stack.AutoInclude == nil {
108-
continue
109-
}
110-
111-
resolved, resolveDiags := stack.AutoInclude.Resolve(evalCtx)
112-
if resolveDiags.HasErrors() {
113-
return nil, resolveDiags
114-
}
115-
116-
if resolved != nil {
117-
resolved.EvalCtx = evalCtx
118-
autoIncludes[stack.Name] = resolved
119-
}
88+
autoIncludes, err := resolveAutoIncludes(stackFile, evalCtx)
89+
if err != nil {
90+
return nil, err
12091
}
12192

12293
return &ParseResult{
@@ -164,6 +135,57 @@ func evaluateLocals(body hcl.Body, evalCtx *hcl.EvalContext) {
164135
}
165136
}
166137

138+
// resolveAutoIncludes resolves autoinclude blocks for all units and stacks in the stack file.
139+
func resolveAutoIncludes(stackFile *StackFileHCL, evalCtx *hcl.EvalContext) (map[string]*AutoIncludeResolved, error) {
140+
autoIncludes := make(map[string]*AutoIncludeResolved)
141+
142+
for _, unit := range stackFile.Units {
143+
if unit.AutoInclude == nil {
144+
continue
145+
}
146+
147+
resolved, err := resolveOneAutoInclude(unit.AutoInclude, evalCtx)
148+
if err != nil {
149+
return nil, err
150+
}
151+
152+
if resolved != nil {
153+
autoIncludes[unit.Name] = resolved
154+
}
155+
}
156+
157+
for _, stack := range stackFile.Stacks {
158+
if stack.AutoInclude == nil {
159+
continue
160+
}
161+
162+
resolved, err := resolveOneAutoInclude(stack.AutoInclude, evalCtx)
163+
if err != nil {
164+
return nil, err
165+
}
166+
167+
if resolved != nil {
168+
autoIncludes[stack.Name] = resolved
169+
}
170+
}
171+
172+
return autoIncludes, nil
173+
}
174+
175+
// resolveOneAutoInclude resolves a single autoinclude block and attaches the eval context.
176+
func resolveOneAutoInclude(autoInclude *AutoIncludeHCL, evalCtx *hcl.EvalContext) (*AutoIncludeResolved, error) {
177+
resolved, diags := autoInclude.Resolve(evalCtx)
178+
if diags.HasErrors() {
179+
return nil, diags
180+
}
181+
182+
if resolved != nil {
183+
resolved.EvalCtx = evalCtx
184+
}
185+
186+
return resolved, nil
187+
}
188+
167189
// processStackIncludes resolves include blocks by parsing the included files
168190
// and merging their unit/stack blocks into the main stack file.
169191
func processStackIncludes(stackFile *StackFileHCL, stackDir string) error {

‎internal/hclparse/partial_eval.go‎

Lines changed: 49 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -39,68 +39,74 @@ func PartialEval(expr hclsyntax.Expression, srcBytes []byte, evalCtx *hcl.EvalCo
3939
switch e := expr.(type) {
4040
case *hclsyntax.LiteralValueExpr:
4141
return valueToHCLBytes(e.Val)
42-
4342
case *hclsyntax.ScopeTraversalExpr:
44-
if deferred[e.Traversal.RootName()] {
45-
return rangeBytes(srcBytes, e.Range())
46-
}
47-
48-
val, diags := e.Value(evalCtx)
49-
if !diags.HasErrors() {
50-
return valueToHCLBytes(val)
51-
}
52-
53-
return rangeBytes(srcBytes, e.Range())
54-
43+
return partialEvalTraversal(e, srcBytes, evalCtx, deferred)
5544
case *hclsyntax.TemplateExpr:
5645
return partialEvalTemplate(e, srcBytes, evalCtx, deferred)
57-
5846
case *hclsyntax.TemplateWrapExpr:
5947
return rangeBytes(srcBytes, e.Range())
60-
6148
case *hclsyntax.ObjectConsExpr:
6249
return partialEvalObject(e, srcBytes, evalCtx, deferred)
63-
6450
case *hclsyntax.TupleConsExpr:
6551
return partialEvalTuple(e, srcBytes, evalCtx, deferred)
66-
6752
case *hclsyntax.ConditionalExpr:
68-
if IsPure(e.Condition, deferred) {
69-
condVal, diags := e.Condition.Value(evalCtx)
70-
if !diags.HasErrors() {
71-
boolVal, err := convert.Convert(condVal, cty.Bool)
72-
if err == nil {
73-
if boolVal.True() {
74-
return PartialEval(e.TrueResult, srcBytes, evalCtx, deferred)
75-
}
76-
77-
return PartialEval(e.FalseResult, srcBytes, evalCtx, deferred)
78-
}
79-
}
80-
}
81-
53+
return partialEvalConditional(e, srcBytes, evalCtx, deferred)
54+
case *hclsyntax.ParenthesesExpr:
55+
return partialEvalParens(e, srcBytes, evalCtx, deferred)
56+
default:
8257
return rangeBytes(srcBytes, e.Range())
58+
}
59+
}
8360

84-
case *hclsyntax.ParenthesesExpr:
85-
if IsPure(e.Expression, deferred) {
86-
return PartialEval(e.Expression, srcBytes, evalCtx, deferred)
87-
}
61+
func partialEvalTraversal(e *hclsyntax.ScopeTraversalExpr, srcBytes []byte, evalCtx *hcl.EvalContext, deferred map[string]bool) []byte {
62+
if deferred[e.Traversal.RootName()] {
63+
return rangeBytes(srcBytes, e.Range())
64+
}
8865

89-
inner := PartialEval(e.Expression, srcBytes, evalCtx, deferred)
66+
val, diags := e.Value(evalCtx)
67+
if !diags.HasErrors() {
68+
return valueToHCLBytes(val)
69+
}
9070

91-
var buf bytes.Buffer
71+
return rangeBytes(srcBytes, e.Range())
72+
}
9273

93-
buf.WriteByte('(')
94-
buf.Write(inner)
95-
buf.WriteByte(')')
74+
func partialEvalConditional(e *hclsyntax.ConditionalExpr, srcBytes []byte, evalCtx *hcl.EvalContext, deferred map[string]bool) []byte {
75+
if !IsPure(e.Condition, deferred) {
76+
return rangeBytes(srcBytes, e.Range())
77+
}
9678

97-
return buf.Bytes()
79+
condVal, diags := e.Condition.Value(evalCtx)
80+
if diags.HasErrors() {
81+
return rangeBytes(srcBytes, e.Range())
82+
}
9883

99-
default:
100-
// FunctionCallExpr, ForExpr, SplatExpr, BinaryOpExpr, UnaryOpExpr,
101-
// RelativeTraversalExpr, IndexExpr, AnonSymbolExpr — all verbatim.
84+
boolVal, err := convert.Convert(condVal, cty.Bool)
85+
if err != nil {
10286
return rangeBytes(srcBytes, e.Range())
10387
}
88+
89+
if boolVal.True() {
90+
return PartialEval(e.TrueResult, srcBytes, evalCtx, deferred)
91+
}
92+
93+
return PartialEval(e.FalseResult, srcBytes, evalCtx, deferred)
94+
}
95+
96+
func partialEvalParens(e *hclsyntax.ParenthesesExpr, srcBytes []byte, evalCtx *hcl.EvalContext, deferred map[string]bool) []byte {
97+
if IsPure(e.Expression, deferred) {
98+
return PartialEval(e.Expression, srcBytes, evalCtx, deferred)
99+
}
100+
101+
inner := PartialEval(e.Expression, srcBytes, evalCtx, deferred)
102+
103+
var buf bytes.Buffer
104+
105+
buf.WriteByte('(')
106+
buf.Write(inner)
107+
buf.WriteByte(')')
108+
109+
return buf.Bytes()
104110
}
105111

106112
// IsPure returns true if the expression has no references to deferred root names.

0 commit comments

Comments
 (0)