chore: errors block processing simplification (#4046)

* Errors block code cleanup

* Errors block cleanup

* Error block fix

* Extracted common code

* Removed unused code

* Map to slice tests update

* Fixed lint issues

* Lint issues fix

* Cleanp

Author: denis256

config/config.go

@@ -975,7 +975,6 @@ func decodeAsTerragruntConfigFile(ctx *ParsingContext, file *hclparse.File, eval
 
 	if err := file.Decode(&terragruntConfig, evalContext); err != nil {
 		var diagErr hcl.Diagnostics
-		// diagErr, ok := errors.Unwrap(err).(hcl.Diagnostics)
 		ok := errors.As(err, &diagErr)
 
 		// in case of render-json command and inputs reference error, we update the inputs with default value

config/errors_block.go

@@ -9,8 +9,8 @@ import (
 
 // ErrorsConfig represents the top-level errors configuration
 type ErrorsConfig struct {
-	Retry  []*RetryBlock  `cty:"retry"  hcl:"retry,block"`
-	Ignore []*IgnoreBlock `cty:"ignore"  hcl:"ignore,block"`
+	Retry  []*RetryBlock  `cty:"retry" hcl:"retry,block"`
+	Ignore []*IgnoreBlock `cty:"ignore" hcl:"ignore,block"`
 }
 
 // RetryBlock represents a labeled retry block
@@ -29,146 +29,169 @@ type IgnoreBlock struct {
 	IgnorableErrors []string             `cty:"ignorable_errors" hcl:"ignorable_errors"`
 }
 
-// Clone creates a deep copy of ErrorsConfig
+// Clone returns a deep copy of ErrorsConfig
 func (c *ErrorsConfig) Clone() *ErrorsConfig {
 	if c == nil {
 		return nil
 	}
 
-	clone := &ErrorsConfig{
-		Retry:  make([]*RetryBlock, len(c.Retry)),
-		Ignore: make([]*IgnoreBlock, len(c.Ignore)),
+	return &ErrorsConfig{
+		Retry:  cloneRetryBlocks(c.Retry),
+		Ignore: cloneIgnoreBlocks(c.Ignore),
 	}
+}
 
-	// Clone Retry blocks
-	for i, retry := range c.Retry {
-		clone.Retry[i] = retry.Clone()
+// Merge combines the current ErrorsConfig with another one, prioritizing the other config
+func (c *ErrorsConfig) Merge(other *ErrorsConfig) {
+	if c == nil || other == nil {
+		return
 	}
 
-	// Clone Ignore blocks
-	for i, ignore := range c.Ignore {
-		clone.Ignore[i] = ignore.Clone()
+	c.Retry = mergeRetryBlocks(c.Retry, other.Retry)
+	c.Ignore = mergeIgnoreBlocks(c.Ignore, other.Ignore)
+}
+
+// Clone returns a deep copy of a RetryBlock
+func (r *RetryBlock) Clone() *RetryBlock {
+	if r == nil {
+		return nil
 	}
 
-	return clone
+	return &RetryBlock{
+		Label:            r.Label,
+		RetryableErrors:  cloneStringSlice(r.RetryableErrors),
+		MaxAttempts:      r.MaxAttempts,
+		SleepIntervalSec: r.SleepIntervalSec,
+	}
 }
 
-// Merge combines the current ErrorsConfig with another one, with the other config taking precedence
-func (c *ErrorsConfig) Merge(other *ErrorsConfig) {
-	if other == nil {
-		return
+// Clone returns a deep copy of an IgnoreBlock
+func (i *IgnoreBlock) Clone() *IgnoreBlock {
+	if i == nil {
+		return nil
 	}
 
-	if c == nil {
-		*c = *other
-		return
+	return &IgnoreBlock{
+		Label:           i.Label,
+		IgnorableErrors: cloneStringSlice(i.IgnorableErrors),
+		Message:         i.Message,
+		Signals:         cloneSignalsMap(i.Signals),
 	}
+}
 
-	retryMap := make(map[string]*RetryBlock)
-	for _, block := range c.Retry {
-		retryMap[block.Label] = block
+// Helper function to deep copy a slice of RetryBlock
+func cloneRetryBlocks(blocks []*RetryBlock) []*RetryBlock {
+	if blocks == nil {
+		return nil
 	}
 
-	ignoreMap := make(map[string]*IgnoreBlock)
-	for _, block := range c.Ignore {
-		ignoreMap[block.Label] = block
+	cloned := make([]*RetryBlock, len(blocks))
+	for i, block := range blocks {
+		cloned[i] = block.Clone()
 	}
 
-	// Merge retry blocks
-	for _, otherBlock := range other.Retry {
-		if existing, exists := retryMap[otherBlock.Label]; exists {
-			existing.RetryableErrors = util.MergeStringSlices(existing.RetryableErrors, otherBlock.RetryableErrors)
-
-			if otherBlock.MaxAttempts > 0 {
-				existing.MaxAttempts = otherBlock.MaxAttempts
-			}
+	return cloned
+}
 
-			if otherBlock.SleepIntervalSec > 0 {
-				existing.SleepIntervalSec = otherBlock.SleepIntervalSec
-			}
-		} else {
-			// Add new block
-			retryMap[otherBlock.Label] = otherBlock
-		}
+// Helper function to deep copy a slice of IgnoreBlock
+func cloneIgnoreBlocks(blocks []*IgnoreBlock) []*IgnoreBlock {
+	if blocks == nil {
+		return nil
 	}
 
-	// Merge ignore blocks
-	for _, otherBlock := range other.Ignore {
-		if existing, exists := ignoreMap[otherBlock.Label]; exists {
-			existing.IgnorableErrors = util.MergeStringSlices(existing.IgnorableErrors, otherBlock.IgnorableErrors)
-
-			if otherBlock.Message != "" {
-				existing.Message = otherBlock.Message
-			}
+	cloned := make([]*IgnoreBlock, len(blocks))
+	for i, block := range blocks {
+		cloned[i] = block.Clone()
+	}
 
-			if otherBlock.Signals != nil {
-				if existing.Signals == nil {
-					existing.Signals = make(map[string]cty.Value)
-				}
+	return cloned
+}
 
-				maps.Copy(existing.Signals, otherBlock.Signals)
-			}
-		} else {
-			// Add new block
-			ignoreMap[otherBlock.Label] = otherBlock
-		}
+// Helper function to deep copy a slice of strings
+func cloneStringSlice(slice []string) []string {
+	if slice == nil {
+		return nil
 	}
 
-	// Convert maps back to slices
-	c.Retry = make([]*RetryBlock, 0, len(retryMap))
-	for _, block := range retryMap {
-		c.Retry = append(c.Retry, block)
-	}
+	cloned := make([]string, len(slice))
+	copy(cloned, slice)
 
-	c.Ignore = make([]*IgnoreBlock, 0, len(ignoreMap))
-	for _, block := range ignoreMap {
-		c.Ignore = append(c.Ignore, block)
-	}
+	return cloned
 }
 
-// Clone creates a deep copy of RetryBlock
-func (r *RetryBlock) Clone() *RetryBlock {
-	if r == nil {
+// Helper function to deep copy a map of signals
+func cloneSignalsMap(signals map[string]cty.Value) map[string]cty.Value {
+	if signals == nil {
 		return nil
 	}
 
-	clone := &RetryBlock{
-		Label:            r.Label,
-		MaxAttempts:      r.MaxAttempts,
-		SleepIntervalSec: r.SleepIntervalSec,
+	cloned := make(map[string]cty.Value, len(signals))
+	maps.Copy(cloned, signals)
+
+	return cloned
+}
+
+// Merges two slices of RetryBlock, prioritizing the second slice
+func mergeRetryBlocks(existing, other []*RetryBlock) []*RetryBlock {
+	retryMap := make(map[string]*RetryBlock, len(existing)+len(other))
+
+	// Add existing retry blocks
+	for _, block := range existing {
+		retryMap[block.Label] = block
 	}
 
-	// Deep copy RetryableErrors slice
-	if r.RetryableErrors != nil {
-		clone.RetryableErrors = make([]string, len(r.RetryableErrors))
-		copy(clone.RetryableErrors, r.RetryableErrors)
+	// Merge retry blocks from 'other'
+	for _, otherBlock := range other {
+		if existingBlock, found := retryMap[otherBlock.Label]; found {
+			existingBlock.RetryableErrors = util.MergeStringSlices(existingBlock.RetryableErrors, otherBlock.RetryableErrors)
+
+			if otherBlock.MaxAttempts > 0 {
+				existingBlock.MaxAttempts = otherBlock.MaxAttempts
+			}
+
+			if otherBlock.SleepIntervalSec > 0 {
+				existingBlock.SleepIntervalSec = otherBlock.SleepIntervalSec
+			}
+
+			continue
+		}
+
+		retryMap[otherBlock.Label] = otherBlock
 	}
 
-	return clone
+	return util.MapToSlice(retryMap)
 }
 
-// Clone creates a deep copy of IgnoreBlock
-func (i *IgnoreBlock) Clone() *IgnoreBlock {
-	if i == nil {
-		return nil
-	}
+// Merges two slices of IgnoreBlock, prioritizing the second slice
+func mergeIgnoreBlocks(existing, other []*IgnoreBlock) []*IgnoreBlock {
+	ignoreMap := make(map[string]*IgnoreBlock, len(existing)+len(other))
 
-	clone := &IgnoreBlock{
-		Label:   i.Label,
-		Message: i.Message,
+	// Add existing ignore blocks
+	for _, block := range existing {
+		ignoreMap[block.Label] = block
 	}
 
-	// Deep copy IgnorableErrors slice
-	if i.IgnorableErrors != nil {
-		clone.IgnorableErrors = make([]string, len(i.IgnorableErrors))
-		copy(clone.IgnorableErrors, i.IgnorableErrors)
-	}
+	// Merge ignore blocks from 'other'
+	for _, otherBlock := range other {
+		if existingBlock, found := ignoreMap[otherBlock.Label]; found {
+			existingBlock.IgnorableErrors = util.MergeStringSlices(existingBlock.IgnorableErrors, otherBlock.IgnorableErrors)
 
-	// Deep copy Signals map
-	if i.Signals != nil {
-		clone.Signals = make(map[string]cty.Value, len(i.Signals))
-		maps.Copy(clone.Signals, i.Signals)
+			if otherBlock.Message != "" {
+				existingBlock.Message = otherBlock.Message
+			}
+
+			if otherBlock.Signals != nil {
+				if existingBlock.Signals == nil {
+					existingBlock.Signals = make(map[string]cty.Value, len(otherBlock.Signals))
+				}
+
+				maps.Copy(existingBlock.Signals, otherBlock.Signals)
+			}
+		} else {
+			ignoreMap[otherBlock.Label] = otherBlock
+		}
 	}
 
-	return clone
+	// Convert map back to slice
+	return util.MapToSlice(ignoreMap)
 }

util/collections.go

@@ -225,3 +225,20 @@ func MergeStringSlices(a, b []string) []string {
 
 	return result
 }
+
+// MapToSlice transforms a map with string keys and pointer values into a slice of pointers.
+// It extracts all values from the map and returns them as a slice while maintaining their original order in the map iteration.
+//
+// Parameters:
+//   - m: A map where the keys are strings and the values are pointers to elements of type T.
+//
+// Returns:
+//   - A slice containing all the pointer values from the input map.
+func MapToSlice[T any](m map[string]*T) []*T {
+	result := make([]*T, 0, len(m))
+	for _, block := range m {
+		result = append(result, block)
+	}
+
+	return result
+}

util/collections_test.go

@@ -273,3 +273,26 @@ func TestStringListInsert(t *testing.T) {
 		})
 	}
 }
+
+func TestMapToSlice(t *testing.T) {
+	t.Parallel()
+
+	t.Run("Empty Map", func(t *testing.T) {
+		t.Parallel()
+		m := make(map[string]*int)
+		result := util.MapToSlice(m)
+		if len(result) != 0 {
+			t.Errorf("Expected empty slice, got %v", result)
+		}
+	})
+
+	t.Run("Single Element Map", func(t *testing.T) {
+		t.Parallel()
+		val := 42
+		m := map[string]*int{"key1": &val}
+		result := util.MapToSlice(m)
+		if len(result) != 1 || result[0] != &val {
+			t.Errorf("Expected slice with one element %v, got %v", &val, result)
+		}
+	})
+}