use config in dynamic blocks from individual

Author: lantoli

internal/convert/convert.go

@@ -201,8 +201,6 @@ func fillReplicationSpecs(resourceb *hclwrite.Body, root attrVals) error {
 			break
 		}
 		specbSrc := specSrc.Body()
-		// ok to fail as zone_name is optional
-		_ = hcl.MoveAttr(specbSrc, specb, nZoneName, nZoneName, errRepSpecs)
 		d, err := fillRegionConfigsDynamicBlock(specbSrc, root)
 		if err != nil {
 			return err
@@ -212,6 +210,8 @@ func fillReplicationSpecs(resourceb *hclwrite.Body, root attrVals) error {
 			resourceb.SetAttributeRaw(nRepSpecs, d.tokens)
 			return nil
 		}
+		// ok to fail as zone_name is optional
+		_ = hcl.MoveAttr(specbSrc, specb, nZoneName, nZoneName, errRepSpecs)
 		shards := specbSrc.GetAttribute(nNumShards)
 		if shards == nil {
 			return fmt.Errorf("%s: %s not found", errRepSpecs, nNumShards)
@@ -316,6 +316,11 @@ func fillRegionConfigsDynamicBlock(specbSrc *hclwrite.Body, root attrVals) (dyna
 	if err != nil || !d.IsPresent() {
 		return dynamicBlock{}, err
 	}
+	shards := specbSrc.GetAttribute(nNumShards)
+	if shards == nil {
+		return dynamicBlock{}, fmt.Errorf("%s: %s not found", errRepSpecs, nNumShards)
+	}
+	zoneName := hcl.GetAttrExpr(specbSrc.GetAttribute(nZoneName))
 	const nRegion = "region"
 	configSrc := d.content
 	configSrcb := configSrc.Body()
@@ -326,13 +331,32 @@ func fillRegionConfigsDynamicBlock(specbSrc *hclwrite.Body, root attrVals) (dyna
 		expr := replaceDynamicBlockExpr(attr, name, oldPrefix, nRegion)
 		configSrcb.SetAttributeRaw(name, hcl.TokensFromExpr(expr))
 	}
-
 	region, err := getRegionConfig(configSrc, root)
 	if err != nil {
 		return dynamicBlock{}, err
 	}
-
-	d.tokens = hcl.EncloseBrackets(hcl.EncloseNewLines(hcl.TokensObject(region.Body())))
+	forOuter := fmt.Sprintf("for i in range(%s) :", hcl.GetAttrExpr(shards))
+	repSpec := hclwrite.NewEmptyFile()
+	repSpecb := repSpec.Body()
+	if zoneName != "" {
+		repSpecb.SetAttributeRaw(nZoneName, hcl.TokensFromExpr(zoneName))
+	}
+	config := region.BuildTokens(nil)
+	config = append(config, hcl.TokenNewLine())
+	config = hcl.EncloseBraces(config, true)
+	config = append(config, hcl.TokensFromExpr("if region.priority == priority")...)
+	forRegion := hcl.TokensFromExpr(fmt.Sprintf("for region in %s :", hcl.GetAttrExpr(d.forEach)))
+	forRegion = append(forRegion, config...)
+
+	priorityContent := hcl.EncloseBrackets(hcl.EncloseNewLines(forRegion))
+	priorityBlock := hcl.TokensFromExpr("for priority in range(7, 0, -1) : ")
+	priorityBlock = append(priorityBlock, priorityContent...)
+	repSpecb.SetAttributeRaw(nConfig, hcl.TokensFuncFlatten(priorityBlock))
+
+	tokens := hcl.TokensFromExpr(forOuter)
+	tokens = append(tokens, hcl.EncloseBraces(repSpec.BuildTokens(nil), true)...)
+	tokens = hcl.EncloseBrackets(hcl.EncloseNewLines(tokens))
+	d.tokens = tokens
 	return d, nil
 }
 

internal/convert/testdata/clu2adv/dynamic_regions_config.in.tf

@@ -6,6 +6,7 @@ resource "mongodbatlas_cluster" "dynamic_regions_config" {
   provider_instance_size_name = "M10"
   replication_specs {
     num_shards = var.replication_specs.num_shards
+    zone_name  = "Zone 1"
     dynamic "regions_config" {
       for_each = var.replication_specs.regions_config
       content {

internal/convert/testdata/clu2adv/dynamic_regions_config.out.tf

@@ -4,6 +4,7 @@ resource "mongodbatlas_advanced_cluster" "dynamic_regions_config" {
   cluster_type = "SHARDED"
   replication_specs = [
     for i in range(var.replication_specs.num_shards) : {
+      zone_name = "Zone 1"
       region_configs = flatten([
         for priority in range(7, 0, -1) : [
           for region in var.replication_specs.regions_config : {

internal/hcl/hcl.go

@@ -33,6 +33,9 @@ func PopAttr(body *hclwrite.Body, attrName, errPrefix string) (hclwrite.Tokens,
 
 // GetAttrExpr returns the expression of an attribute as a string.
 func GetAttrExpr(attr *hclwrite.Attribute) string {
+	if attr == nil {
+		return ""
+	}
 	return strings.TrimSpace(string(attr.Expr().BuildTokens(nil).Bytes()))
 }
 
@@ -77,6 +80,10 @@ func GetAttrString(attr *hclwrite.Attribute, errPrefix string) (string, error) {
 	return val.AsString(), nil
 }
 
+func TokenNewLine() *hclwrite.Token {
+	return &hclwrite.Token{Type: hclsyntax.TokenNewline, Bytes: []byte("\n")}
+}
+
 // TokensArray creates an array of objects.
 func TokensArray(bodies []*hclwrite.Body) hclwrite.Tokens {
 	tokens := make([]hclwrite.Tokens, 0)
@@ -93,9 +100,9 @@ func TokensArraySingle(body *hclwrite.Body) hclwrite.Tokens {
 
 // TokensObject creates an object.
 func TokensObject(body *hclwrite.Body) hclwrite.Tokens {
-	tokens := hclwrite.Tokens{tokenNewLine}
+	tokens := hclwrite.Tokens{TokenNewLine()}
 	tokens = append(tokens, RemoveLeadingNewline(body.BuildTokens(nil))...)
-	return EncloseBraces(tokens)
+	return EncloseBraces(tokens, false)
 }
 
 // TokensFromExpr creates the tokens for an expression provided as a string.
@@ -105,7 +112,7 @@ func TokensFromExpr(expr string) hclwrite.Tokens {
 
 // TokensObjectFromExpr creates an object with an expression.
 func TokensObjectFromExpr(expr string) hclwrite.Tokens {
-	return EncloseBraces(EncloseNewLines(TokensFromExpr(expr)))
+	return EncloseBraces(EncloseNewLines(TokensFromExpr(expr)), false)
 }
 
 // TokensFuncMerge creates the tokens for the HCL merge function.
@@ -115,6 +122,12 @@ func TokensFuncMerge(tokens ...hclwrite.Tokens) hclwrite.Tokens {
 	return append(ret, EncloseParens(params)...)
 }
 
+// TokensFuncFlatten creates the tokens for the HCL flatten function.
+func TokensFuncFlatten(tokens hclwrite.Tokens) hclwrite.Tokens {
+	ret := TokensFromExpr("flatten")
+	return append(ret, EncloseParens(EncloseBrackets(EncloseNewLines(tokens)))...)
+}
+
 // RemoveLeadingNewline removes the first newline if it exists to make the output prettier.
 func RemoveLeadingNewline(tokens hclwrite.Tokens) hclwrite.Tokens {
 	if len(tokens) > 0 && tokens[0].Type == hclsyntax.TokenNewline {
@@ -140,8 +153,6 @@ func GetParser(config []byte) (*hclwrite.File, error) {
 	return parser, nil
 }
 
-var tokenNewLine = &hclwrite.Token{Type: hclsyntax.TokenNewline, Bytes: []byte("\n")}
-
 // joinTokens joins multiple tokens with commas and newlines.
 func joinTokens(tokens ...hclwrite.Tokens) hclwrite.Tokens {
 	ret := hclwrite.Tokens{}
@@ -150,7 +161,7 @@ func joinTokens(tokens ...hclwrite.Tokens) hclwrite.Tokens {
 		if i < len(tokens)-1 {
 			ret = append(ret,
 				&hclwrite.Token{Type: hclsyntax.TokenComma, Bytes: []byte(",")},
-				tokenNewLine)
+				TokenNewLine())
 		}
 	}
 	return ret
@@ -164,8 +175,11 @@ func EncloseParens(tokens hclwrite.Tokens) hclwrite.Tokens {
 }
 
 // EncloseBraces encloses tokens with curly braces, { }.
-func EncloseBraces(tokens hclwrite.Tokens) hclwrite.Tokens {
+func EncloseBraces(tokens hclwrite.Tokens, initialNewLine bool) hclwrite.Tokens {
 	ret := hclwrite.Tokens{{Type: hclsyntax.TokenOBrace, Bytes: []byte("{")}}
+	if initialNewLine {
+		ret = append(ret, TokenNewLine())
+	}
 	ret = append(ret, tokens...)
 	return append(ret, &hclwrite.Token{Type: hclsyntax.TokenCBrace, Bytes: []byte("}")})
 }
@@ -179,7 +193,7 @@ func EncloseBrackets(tokens hclwrite.Tokens) hclwrite.Tokens {
 
 // EncloseNewLines encloses tokens with newlines at the beginning and end.
 func EncloseNewLines(tokens hclwrite.Tokens) hclwrite.Tokens {
-	ret := hclwrite.Tokens{tokenNewLine}
+	ret := hclwrite.Tokens{TokenNewLine()}
 	ret = append(ret, tokens...)
-	return append(ret, tokenNewLine)
+	return append(ret, TokenNewLine())
 }