enum_unknown_error_nested.yml

input:
    input.go: |
        package example

        import (
            input "github.com/jmattheis/goverter/execution/input"
            output "github.com/jmattheis/goverter/execution/output"
        )

        // goverter:converter
        // goverter:enum:unknown @error
        type Converter interface {
            Convert([]Input) ([]Output, error)
        }

        type Input struct { Nested NestedInput }
        type Output struct { Nested NestedOutput }
        type NestedInput struct { Color input.Color }
        type NestedOutput struct { Color output.Color }
    input/enum.go: |
        package input

        type Color int

        const (
            Green Color = iota
            Blue
            Red
        )
    output/enum.go: |
        package output

        type Color string
        const (
            Green Color = "green"
            Blue  Color = "blue"
            Red   Color = "red"
        )
success:
    - generated/generated.go: |
        // Code generated by github.com/jmattheis/goverter, DO NOT EDIT.

        package generated

        import (
        	"fmt"
        	execution "github.com/jmattheis/goverter/execution"
        	input "github.com/jmattheis/goverter/execution/input"
        	output "github.com/jmattheis/goverter/execution/output"
        )

        type ConverterImpl struct{}

        func (c *ConverterImpl) Convert(source []execution.Input) ([]execution.Output, error) {
        	var exampleOutputList []execution.Output
        	if source != nil {
        		exampleOutputList = make([]execution.Output, len(source))
        		for i := 0; i < len(source); i++ {
        			exampleOutput, err := c.exampleInputToExampleOutput(source[i])
        			if err != nil {
        				return nil, err
        			}
        			exampleOutputList[i] = exampleOutput
        		}
        	}
        	return exampleOutputList, nil
        }
        func (c *ConverterImpl) exampleInputToExampleOutput(source execution.Input) (execution.Output, error) {
        	var exampleOutput execution.Output
        	exampleNestedOutput, err := c.exampleNestedInputToExampleNestedOutput(source.Nested)
        	if err != nil {
        		return exampleOutput, err
        	}
        	exampleOutput.Nested = exampleNestedOutput
        	return exampleOutput, nil
        }
        func (c *ConverterImpl) exampleNestedInputToExampleNestedOutput(source execution.NestedInput) (execution.NestedOutput, error) {
        	var exampleNestedOutput execution.NestedOutput
        	outputColor, err := c.inputColorToOutputColor(source.Color)
        	if err != nil {
        		return exampleNestedOutput, err
        	}
        	exampleNestedOutput.Color = outputColor
        	return exampleNestedOutput, nil
        }
        func (c *ConverterImpl) inputColorToOutputColor(source input.Color) (output.Color, error) {
        	var outputColor output.Color
        	switch source {
        	case input.Blue:
        		outputColor = output.Blue
        	case input.Green:
        		outputColor = output.Green
        	case input.Red:
        		outputColor = output.Red
        	default:
        		return outputColor, fmt.Errorf("unexpected enum element: %v", source)
        	}
        	return outputColor, nil
        }