9308339452

Committed 30 May 2024 07:50PM UTC coverage: 82.183% (-0.8%) from 83.029%

Build # 9308339452

Build Type

Pull #1111

github

Committed by

web-flow

Commit Message

Merge 7a790f3c1 into 7f6be196c

Pull Request Pull Request #1111: Support service calls with return values in codegen

Run Details

869 of 1201 branches covered (72.36%)

Branch coverage included in aggregate %.

32 of 74 new or added lines in 5 files covered. (43.24%)

6 existing lines in 2 files now uncovered.

3250 of 3811 relevant lines covered (85.28%)

81.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.38

/src/HassModel/NetDaemon.HassModel.CodeGenerator/CodeGeneration/ServicesGenerator.cs

﻿using Microsoft.CodeAnalysis.CSharp;
using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

namespace NetDaemon.HassModel.CodeGenerator;

internal static class ServicesGenerator
{
    public static IEnumerable<MemberDeclarationSyntax> Generate(IReadOnlyList<HassServiceDomain> serviceDomains)
    {
        var domains = serviceDomains.Select(x => x.Domain!).ToArray();

        yield return GenerateRootServicesInterface(domains);

        yield return GenerateRootServicesType(domains);

        foreach (var domainServicesGroup in serviceDomains.Where(sd => sd.Services.Any() == true).GroupBy(x => x.Domain, x => x.Services))
        {
            var domain = domainServicesGroup.Key!;
            var domainServices = domainServicesGroup
                .SelectMany(services => services!)
                .OrderBy(x => x.Service)
                .ToList();

            yield return GenerateServicesDomainType(domain, domainServices);

            foreach (var domainService in domainServices)
            {
                foreach (var serviceArgsRecord in GenerateServiceArgsRecord(domain, domainService))
                {
                    yield return serviceArgsRecord;
                }
            }
        }
    }

    private static TypeDeclarationSyntax GenerateRootServicesType(IEnumerable<string> domains)
    {
        var properties = domains.Select(domain => PropertyWithExpressionBodyNew(GetServicesTypeName(domain), domain.ToPascalCase(), "_haContext")).ToArray();

        return ClassWithInjectedHaContext(ServicesClassName).WithBase((string)"IServices").AddMembers(properties);
    }

    private static TypeDeclarationSyntax GenerateRootServicesInterface(IEnumerable<string> domains)
    {
        var properties = domains.Select(domain =>
        {
            var typeName = GetServicesTypeName(domain);
            var domainName = domain.ToPascalCase();

            return AutoPropertyGet(typeName, domainName);
        }).ToArray<MemberDeclarationSyntax>();

        return InterfaceDeclaration("IServices").WithMembers(List(properties)).ToPublic();
    }

    private static TypeDeclarationSyntax GenerateServicesDomainType(string domain, IEnumerable<HassService> services)
    {
        var serviceTypeDeclaration = ClassWithInjectedHaContext(GetServicesTypeName(domain));

        var serviceMethodDeclarations = services.SelectMany(service => GenerateServiceMethod(domain, service)).ToArray();

        return serviceTypeDeclaration.AddMembers(serviceMethodDeclarations);
    }

    private static IEnumerable<TypeDeclarationSyntax> GenerateServiceArgsRecord(string domain, HassService service)
    {
        var serviceArguments = ServiceArguments.Create(domain, service);

        if (serviceArguments is null)
        {
            yield break;
        }

        var autoProperties = serviceArguments.Arguments
            .Select(argument => AutoPropertyGetInit($"{argument.TypeName!}?", argument.PropertyName!)
                .ToPublic()
                .WithJsonPropertyName(argument.HaName!).WithSummaryComment(argument.Comment))
            .ToArray();

        yield return Record(serviceArguments.TypeName, autoProperties)
            .ToPublic()
            .AddModifiers(Token(SyntaxKind.PartialKeyword));
    }

    private static IEnumerable<MemberDeclarationSyntax> GenerateServiceMethod(string domain, HassService service)
    {
        var serviceName = service.Service!;

        var serviceArguments = ServiceArguments.Create(domain, service);
        var haContextVariableName = GetVariableName<IHaContext>("_");

        var serviceMethodName = GetServiceMethodName(serviceName);

        var targetParam = service.Target is not null ? $"{SimplifyTypeName(typeof(ServiceTarget))} target" : null;
        var targetArg = service.Target is not null ? "target" : "null";
        var targetComment = service.Target is not null ? ParameterComment("target", "The target for this service call") : (SyntaxTrivia?)null;

        if (serviceArguments is null)
        {
            // method without arguments
            yield return ParseMemberDeclaration($$"""
                        void {{serviceMethodName}}({{CommaSeparateNonEmpty(targetParam, "object? data = null")}})
                        {
                            {{haContextVariableName}}.CallService("{{domain}}", "{{serviceName}}", {{CommaSeparateNonEmpty(targetArg, "data")}});
                        }
                        """)!
                .ToPublic()
                .WithSummaryComment(service.Description)
                .AppendTrivia(targetComment);
            // method without arguments and with response
            if (service.Response is not null)
            {
                yield return ParseMemberDeclaration($$"""
                            Task<JsonElement?> {{serviceMethodName}}Async({{CommaSeparateNonEmpty(targetParam, "object? data = null")}})
                            {
                                return {{haContextVariableName}}.CallServiceWithResponseAsync("{{domain}}", "{{serviceName}}", {{CommaSeparateNonEmpty(targetArg, "data")}});
                            }
                            """)!
                    .ToPublic()
                    .WithSummaryComment(service.Description)
                    .AppendTrivia(targetComment);
            }
        }
        else
        {
            // method using arguments object
            yield return ParseMemberDeclaration($$"""
                        void {{serviceMethodName}}({{CommaSeparateNonEmpty(targetParam, serviceArguments.TypeName)}} data)
                        {
                            {{haContextVariableName}}.CallService("{{domain}}", "{{serviceName}}", {{targetArg}}, data);
                        }
                        """)!
                .ToPublic()
                .WithSummaryComment(service.Description)
                .AppendTrivia(targetComment);

            // method using arguments as separate parameters
            yield return ParseMemberDeclaration($$"""
                        void {{serviceMethodName}}({{CommaSeparateNonEmpty(targetParam, serviceArguments.GetParametersList())}})
                        {
                            {{haContextVariableName}}.CallService("{{domain}}", "{{serviceName}}", {{targetArg}}, {{serviceArguments.GetNewServiceArgumentsTypeExpression()}});
                        }
                        """)!
                .ToPublic()
                .WithSummaryComment(service.Description)
                .AppendTrivia(targetComment)
                .AppendParameterComments(serviceArguments);
            if (service.Response is not null)
            {
                // method using arguments object
                yield return ParseMemberDeclaration($$"""
                            Task<JsonElement?> {{serviceMethodName}}Async({{CommaSeparateNonEmpty(targetParam, serviceArguments.TypeName)}} data)
                            {
                                return {{haContextVariableName}}.CallServiceWithResponseAsync("{{domain}}", "{{serviceName}}", {{targetArg}}, data);
                            }
                            """)!
                    .ToPublic()
                    .WithSummaryComment(service.Description)
                    .AppendTrivia(targetComment);

                // method using arguments as separate parameters
                yield return ParseMemberDeclaration($$"""
                            Task<JsonElement?> {{serviceMethodName}}Async({{CommaSeparateNonEmpty(targetParam, serviceArguments.GetParametersList())}})
                            {
                                return {{haContextVariableName}}.CallServiceWithResponseAsync("{{domain}}", "{{serviceName}}", {{targetArg}}, {{serviceArguments.GetNewServiceArgumentsTypeExpression()}});
                            }
                            """)!
                    .ToPublic()
                    .WithSummaryComment(service.Description)
                    .AppendTrivia(targetComment)
                    .AppendParameterComments(serviceArguments);
            }
        }
    }

    private static string CommaSeparateNonEmpty(params string?[] args) => string.Join(", ", args.Where(s => !string.IsNullOrEmpty(s)));
}

1	using Microsoft.CodeAnalysis.CSharp;
2	using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
3
4	namespace NetDaemon.HassModel.CodeGenerator;
5
6	internal static class ServicesGenerator
7	{
8	public static IEnumerable<MemberDeclarationSyntax> Generate(IReadOnlyList<HassServiceDomain> serviceDomains)
9	{
10	var domains = serviceDomains.Select(x => x.Domain!).ToArray();	23✔
11
12	yield return GenerateRootServicesInterface(domains);	15✔
13
14	yield return GenerateRootServicesType(domains);	15✔
15
16	foreach (var domainServicesGroup in serviceDomains.Where(sd => sd.Services.Any() == true).GroupBy(x => x.Domain, x => x.Services))	70✔
17	{
18	var domain = domainServicesGroup.Key!;	8✔
19	var domainServices = domainServicesGroup	8✔
20	.SelectMany(services => services!)	8✔
21	.OrderBy(x => x.Service)	11✔
22	.ToList();	8✔
23
24	yield return GenerateServicesDomainType(domain, domainServices);	8✔
25
26	foreach (var domainService in domainServices)	38✔
27	{
28	foreach (var serviceArgsRecord in GenerateServiceArgsRecord(domain, domainService))	30✔
29	{
30	yield return serviceArgsRecord;	4✔
31	}
32	}
33	}	8✔
34	}	15✔
35
36	private static TypeDeclarationSyntax GenerateRootServicesType(IEnumerable<string> domains)
37	{
38	var properties = domains.Select(domain => PropertyWithExpressionBodyNew(GetServicesTypeName(domain), domain.ToPascalCase(), "_haContext")).ToArray();	23✔
39
40	return ClassWithInjectedHaContext(ServicesClassName).WithBase((string)"IServices").AddMembers(properties);	15✔
41	}
42
43	private static TypeDeclarationSyntax GenerateRootServicesInterface(IEnumerable<string> domains)
44	{
45	var properties = domains.Select(domain =>	15✔
46	{	15✔
47	var typeName = GetServicesTypeName(domain);	8✔
48	var domainName = domain.ToPascalCase();	8✔
49		15✔
50	return AutoPropertyGet(typeName, domainName);	8✔
51	}).ToArray<MemberDeclarationSyntax>();	15✔
52
53	return InterfaceDeclaration("IServices").WithMembers(List(properties)).ToPublic();	15✔
54	}
55
56	private static TypeDeclarationSyntax GenerateServicesDomainType(string domain, IEnumerable<HassService> services)
57	{
58	var serviceTypeDeclaration = ClassWithInjectedHaContext(GetServicesTypeName(domain));	8✔
59
60	var serviceMethodDeclarations = services.SelectMany(service => GenerateServiceMethod(domain, service)).ToArray();	19✔
61
62	return serviceTypeDeclaration.AddMembers(serviceMethodDeclarations);	8✔
63	}
64
65	private static IEnumerable<TypeDeclarationSyntax> GenerateServiceArgsRecord(string domain, HassService service)
66	{
67	var serviceArguments = ServiceArguments.Create(domain, service);	11✔
68
69	if (serviceArguments is null)	11✔
70	{
71	yield break;	7✔
72	}
73
74	var autoProperties = serviceArguments.Arguments	4✔
75	.Select(argument => AutoPropertyGetInit($"{argument.TypeName!}?", argument.PropertyName!)	5✔
76	.ToPublic()	5✔
77	.WithJsonPropertyName(argument.HaName!).WithSummaryComment(argument.Comment))	5✔
78	.ToArray();	4✔
79
80	yield return Record(serviceArguments.TypeName, autoProperties)	4✔
81	.ToPublic()	4✔
82	.AddModifiers(Token(SyntaxKind.PartialKeyword));	4✔
83	}	4✔
84
85	private static IEnumerable<MemberDeclarationSyntax> GenerateServiceMethod(string domain, HassService service)
86	{
87	var serviceName = service.Service!;	11✔
88
89	var serviceArguments = ServiceArguments.Create(domain, service);	11✔
90	var haContextVariableName = GetVariableName<IHaContext>("_");	11✔
91
92	var serviceMethodName = GetServiceMethodName(serviceName);	11✔
93
94	var targetParam = service.Target is not null ? $"{SimplifyTypeName(typeof(ServiceTarget))} target" : null;	11✔
95	var targetArg = service.Target is not null ? "target" : "null";	11✔
96	var targetComment = service.Target is not null ? ParameterComment("target", "The target for this service call") : (SyntaxTrivia?)null;	11✔
97
98	if (serviceArguments is null)	11✔
99	{
100	// method without arguments
101	yield return ParseMemberDeclaration($$"""	7✔
102	void {{serviceMethodName}}({{CommaSeparateNonEmpty(targetParam, "object? data = null")}})	7✔
103	{	7✔
104	{{haContextVariableName}}.CallService("{{domain}}", "{{serviceName}}", {{CommaSeparateNonEmpty(targetArg, "data")}});	7✔
105	}	7✔
106	""")!	7✔
107	.ToPublic()	7✔
108	.WithSummaryComment(service.Description)	7✔
109	.AppendTrivia(targetComment);	7✔
110	// method without arguments and with response
111	if (service.Response is not null)	7✔
112	{
113	yield return ParseMemberDeclaration($$"""	1✔
114	Task<JsonElement?> {{serviceMethodName}}Async({{CommaSeparateNonEmpty(targetParam, "object? data = null")}})	1✔
115	{	1✔
116	return {{haContextVariableName}}.CallServiceWithResponseAsync("{{domain}}", "{{serviceName}}", {{CommaSeparateNonEmpty(targetArg, "data")}});	1✔
117	}	1✔
118	""")!	1✔
119	.ToPublic()	1✔
120	.WithSummaryComment(service.Description)	1✔
121	.AppendTrivia(targetComment);	1✔
122	}
123	}
124	else
125	{
126	// method using arguments object
127	yield return ParseMemberDeclaration($$"""	4✔
128	void {{serviceMethodName}}({{CommaSeparateNonEmpty(targetParam, serviceArguments.TypeName)}} data)	4✔
129	{	4✔
130	{{haContextVariableName}}.CallService("{{domain}}", "{{serviceName}}", {{targetArg}}, data);	4✔
131	}	4✔
132	""")!	4✔
133	.ToPublic()	4✔
134	.WithSummaryComment(service.Description)	4✔
135	.AppendTrivia(targetComment);	4✔
136
137	// method using arguments as separate parameters
138	yield return ParseMemberDeclaration($$"""	4✔
139	void {{serviceMethodName}}({{CommaSeparateNonEmpty(targetParam, serviceArguments.GetParametersList())}})	4✔
140	{	4✔
141	{{haContextVariableName}}.CallService("{{domain}}", "{{serviceName}}", {{targetArg}}, {{serviceArguments.GetNewServiceArgumentsTypeExpression()}});	4✔
142	}	4✔
143	""")!	4✔
144	.ToPublic()	4✔
145	.WithSummaryComment(service.Description)	4✔
146	.AppendTrivia(targetComment)	4✔
147	.AppendParameterComments(serviceArguments);	4✔
148	if (service.Response is not null)	4!
149	{
150	// method using arguments object
NEW 151	yield return ParseMemberDeclaration($$"""	×
NEW 152	Task<JsonElement?> {{serviceMethodName}}Async({{CommaSeparateNonEmpty(targetParam, serviceArguments.TypeName)}} data)	×
NEW 153	{	×
NEW 154	return {{haContextVariableName}}.CallServiceWithResponseAsync("{{domain}}", "{{serviceName}}", {{targetArg}}, data);	×
NEW 155	}	×
NEW 156	""")!	×
NEW 157	.ToPublic()	×
NEW 158	.WithSummaryComment(service.Description)	×
NEW 159	.AppendTrivia(targetComment);	×
160
161	// method using arguments as separate parameters
NEW 162	yield return ParseMemberDeclaration($$"""	×
NEW 163	Task<JsonElement?> {{serviceMethodName}}Async({{CommaSeparateNonEmpty(targetParam, serviceArguments.GetParametersList())}})	×
NEW 164	{	×
NEW 165	return {{haContextVariableName}}.CallServiceWithResponseAsync("{{domain}}", "{{serviceName}}", {{targetArg}}, {{serviceArguments.GetNewServiceArgumentsTypeExpression()}});	×
NEW 166	}	×
NEW 167	""")!	×
NEW 168	.ToPublic()	×
NEW 169	.WithSummaryComment(service.Description)	×
NEW 170	.AppendTrivia(targetComment)	×
NEW 171	.AppendParameterComments(serviceArguments);	×
172	}
173	}
174	}	11✔
175
176	private static string CommaSeparateNonEmpty(params string?[] args) => string.Join(", ", args.Where(s => !string.IsNullOrEmpty(s)));	72✔
177	}

net-daemon / netdaemon / 9308339452

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous