M31.FluentAPI/src/M31.FluentApi.Generator/CodeGeneration/CodeBoardActors/MethodCreation/Collections/CollectionMethodCreator.cs at 26a360dcd49db5714bed6a764dbff087426df326 · m31coding/M31.FluentAPI · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
using M31.FluentApi.Generator.CodeBuilding;
using M31.FluentApi.Generator.CodeGeneration.CodeBoardActors.Commons;
using M31.FluentApi.Generator.CodeGeneration.CodeBoardElements;
using M31.FluentApi.Generator.SourceGenerators.AttributeInfo;

namespace M31.FluentApi.Generator.CodeGeneration.CodeBoardActors.MethodCreation.Collections;

internal abstract class CollectionMethodCreator
{
    private readonly FluentCollectionAttributeInfo collectionAttributeInfo;
    private readonly string genericTypeArgument;
    private readonly MemberSymbolInfo symbolInfo;
    private readonly string questionMarkIfNullable;

    internal CollectionMethodCreator(
        FluentCollectionAttributeInfo collectionAttributeInfo,
        string genericTypeArgument,
        MemberSymbolInfo symbolInfo)
    {
        this.collectionAttributeInfo = collectionAttributeInfo;
        this.genericTypeArgument = genericTypeArgument;
        this.symbolInfo = symbolInfo;
        questionMarkIfNullable = symbolInfo.IsNullable ? "?" : string.Empty;
    }

    internal BuilderMethod? CreateWithItemsMethod(MethodCreator methodCreator)
    {
        return !ShouldCreateWithItemsMethod() ? null :
            methodCreator.CreateMethod(symbolInfo, collectionAttributeInfo.WithItems);
    }

    private bool ShouldCreateWithItemsMethod()
    {
        return symbolInfo.TypeForCodeGeneration != $"{genericTypeArgument}[]" &&
               symbolInfo.TypeForCodeGeneration != $"{genericTypeArgument}[]?";
    }

    internal BuilderMethod CreateWithItemsParamsMethod(MethodCreator methodCreator)
    {
        Parameter parameter = new Parameter(
            $"{genericTypeArgument}[]{questionMarkIfNullable}",
            symbolInfo.NameInCamelCase,
            null,
            null,
            new ParameterAnnotations(ParameterKinds.Params));

        return methodCreator.CreateMethodWithComputedValue(
            symbolInfo,
            collectionAttributeInfo.WithItems,
            parameter,
            p => CreateCollectionFromArray(genericTypeArgument, p));
    }

    internal BuilderMethod? CreateWithItemsLambdaParamsMethod(MethodCreator methodCreator)
    {
        if (collectionAttributeInfo.LambdaBuilderInfo == null)
        {
            return null;
        }

        ComputeValueCode lambdaCode = LambdaMethod.GetComputeValueCode(
            genericTypeArgument,
            collectionAttributeInfo.SingularNameInCamelCase,
            symbolInfo.Name,
            collectionAttributeInfo.LambdaBuilderInfo);

        string parameterType = $"{lambdaCode.Parameter!.Type}[]{questionMarkIfNullable}";
        string parameterName = LambdaMethod.GetFullParameterName(symbolInfo.NameInCamelCase);

        Parameter parameter = new Parameter(
            parameterType,
            parameterName,
            null,
            null,
            new ParameterAnnotations(ParameterKinds.Params));

        ComputeValueCode computeValueCode = ComputeValueCode.Create(
            lambdaCode.TargetMember,
            parameter,
            p => CreateCollectionFromEnumerable(
                genericTypeArgument,
                $"{p}{questionMarkIfNullable}.Select({lambdaCode.Parameter!.Name} => {lambdaCode.Code})"));

        RequiredUsings.Add("System");
        RequiredUsings.Add("System.Linq");

        return methodCreator.BuilderMethodFactory.CreateBuilderMethod(
            collectionAttributeInfo.WithItems,
            computeValueCode);
    }

    internal BuilderMethod? CreateWithItemMethod(MethodCreator methodCreator)
    {
        if (collectionAttributeInfo.WithItem == null)
        {
            return null;
        }

        Parameter parameter = new Parameter(genericTypeArgument, collectionAttributeInfo.SingularNameInCamelCase);
        return methodCreator.CreateMethodWithComputedValue(
            symbolInfo,
            collectionAttributeInfo.WithItem,
            parameter,
            p => CreateCollectionFromSingleItem(genericTypeArgument, p));
    }

    internal BuilderMethod? CreateWithItemLambdaMethod(MethodCreator methodCreator)
    {
        if (collectionAttributeInfo.WithItem == null || collectionAttributeInfo.LambdaBuilderInfo == null)
        {
            return null;
        }

        ComputeValueCode lambdaCode = LambdaMethod.GetComputeValueCode(
            genericTypeArgument,
            collectionAttributeInfo.SingularNameInCamelCase,
            symbolInfo.Name,
            collectionAttributeInfo.LambdaBuilderInfo);

        ComputeValueCode computeValueCode = ComputeValueCode.Create(
            lambdaCode.TargetMember,
            lambdaCode.Parameter!,
            _ => CreateCollectionFromSingleItem(genericTypeArgument, lambdaCode.Code));

        RequiredUsings.Add("System");

        return methodCreator.BuilderMethodFactory.CreateBuilderMethod(collectionAttributeInfo.WithItem,
            computeValueCode);
    }

    internal BuilderMethod? CreateWithZeroItemsMethod(MethodCreator methodCreator)
    {
        if (collectionAttributeInfo.WithZeroItems == null)
        {
            return null;
        }

        string collectionWithZeroItemsCode = CreateCollectionWithZeroItems(genericTypeArgument);
        return methodCreator.CreateMethodWithFixedValue(
            symbolInfo,
            collectionAttributeInfo.WithZeroItems,
            collectionWithZeroItemsCode);
    }

    protected abstract string CreateCollectionFromArray(string genericTypeArgument, string arrayParameter);
    protected abstract string CreateCollectionFromEnumerable(string genericTypeArgument, string enumerableParameter);
    protected abstract string CreateCollectionFromSingleItem(string genericTypeArgument, string itemParameter);
    protected abstract string CreateCollectionWithZeroItems(string genericTypeArgument);
    internal HashSet<string> RequiredUsings { get; } = new HashSet<string>();
}