5770559224

pending completion

Build # 5770559224

Build Type

push

github

Committed by

web-flow

Commit Message

Add default metadata for lights entities (#901)

* Add default metadata and deprecate UseAttributeBaseClasses setting

* add the missing default metadata file

* Removed resource includes from project file.

* Removed more stuff from project file

* Removed the test attribute I forgot to remove

* Added check for brightness in test

Run Details

792 of 1112 branches covered (71.22%)

Branch coverage included in aggregate %.

15 of 15 new or added lines in 2 files covered. (100.0%)

3705 of 4339 relevant lines covered (85.39%)

48.22 hits per line

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

38.27

/src/HassModel/NetDaemon.HassModel.CodeGenerator/Controller.cs

﻿using System.IO;
using System.Reflection;
using System.Threading.Tasks;
using NetDaemon.Client.Settings;

namespace NetDaemon.HassModel.CodeGenerator;

#pragma warning disable CA1303
#pragma warning disable CA2000 // because of await using ... configureAwait()

internal class Controller
{
    private const string ResourceName = "NetDaemon.HassModel.CodeGenerator.MetaData.DefaultMetadata.DefaultEntityMetaData.json";
    private readonly CodeGenerationSettings _generationSettings;
    private readonly HomeAssistantSettings _haSettings;

    public Controller(CodeGenerationSettings generationSettings, HomeAssistantSettings haSettings)
    {
        _generationSettings = generationSettings;
        _haSettings = haSettings;
    }

    private string EntityMetaDataFileName => Path.Combine(OutputFolder, "EntityMetaData.json");
    private string ServicesMetaDataFileName => Path.Combine(OutputFolder, "ServicesMetaData.json");

    private string OutputFolder => string.IsNullOrEmpty(_generationSettings.OutputFolder) 
        ? Directory.GetParent(Path.GetFullPath(_generationSettings.OutputFile))!.FullName 
        : _generationSettings.OutputFolder;
    
    public async Task RunAsync()
    {
        var (hassStates, servicesMetaData) = await HaRepositry.GetHaData(_haSettings).ConfigureAwait(false);

        var previousEntityMetadata = await LoadEntitiesMetaDataAsync().ConfigureAwait(false);
        var currentEntityMetaData = EntityMetaDataGenerator.GetEntityDomainMetaData(hassStates);
        var mergedEntityMetaData = EntityMetaDataMerger.Merge(_generationSettings, previousEntityMetadata, currentEntityMetaData);

        await Save(mergedEntityMetaData, EntityMetaDataFileName).ConfigureAwait(false);
        await Save(servicesMetaData, ServicesMetaDataFileName).ConfigureAwait(false);

        var generatedTypes = Generator.GenerateTypes(mergedEntityMetaData.Domains, ServiceMetaDataParser.Parse(servicesMetaData!.Value));

        SaveGeneratedCode(generatedTypes);
    }

    internal async Task<EntitiesMetaData> LoadEntitiesMetaDataAsync()
    {
        var fileStream = File.Exists(EntityMetaDataFileName) switch
        {
            true => File.OpenRead(EntityMetaDataFileName),
            false => GetDefaultMetaDataFileFromResource()
        };

        await using var _ = fileStream.ConfigureAwait(false);

        var loaded = await JsonSerializer.DeserializeAsync<EntitiesMetaData>(fileStream, JsonSerializerOptions).ConfigureAwait(false);

        return loaded ?? new EntitiesMetaData();
    }

    private static Stream GetDefaultMetaDataFileFromResource()
    {
        var assembly = Assembly.GetExecutingAssembly();
        return assembly.GetManifestResourceStream(ResourceName)!;
    }

    private async Task Save<T>(T merged, string fileName)
    {
        Directory.CreateDirectory(OutputFolder);

        var fileStream = File.Create(fileName);
        await using var _ = fileStream.ConfigureAwait(false);
        await JsonSerializer.SerializeAsync(fileStream, merged, JsonSerializerOptions).ConfigureAwait(false);
    }
    
    private static JsonSerializerOptions JsonSerializerOptions =>
        new()
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            WriteIndented = true,
            Converters = { new ClrTypeJsonConverter() }
        };
    
    private void SaveGeneratedCode(MemberDeclarationSyntax[] generatedTypes)
    {
        if (!_generationSettings.GenerateOneFilePerEntity)
        {
            Console.WriteLine("Generating single file for all entities.");
            var unit = Generator.BuildCompilationUnit(_generationSettings.Namespace, generatedTypes.ToArray());

            Directory.CreateDirectory(Directory.GetParent(_generationSettings.OutputFile)!.FullName);

            using var writer = new StreamWriter(_generationSettings.OutputFile);
            unit.WriteTo(writer);

            Console.WriteLine(Path.GetFullPath(_generationSettings.OutputFile));
        }
        else
        {
            Console.WriteLine("Generating separate file per entity.");

            Directory.CreateDirectory(OutputFolder);

            foreach (var type in generatedTypes)
            {
                var unit = Generator.BuildCompilationUnit(_generationSettings.Namespace, type);
                using var writer = new StreamWriter(Path.Combine(OutputFolder, $"{unit.GetClassName()}.cs"));
                unit.WriteTo(writer);
            }

            Console.WriteLine($"Generated {generatedTypes.Length} files.");
            Console.WriteLine(OutputFolder);
        }
    }
}

1	using System.IO;
2	using System.Reflection;
3	using System.Threading.Tasks;
4	using NetDaemon.Client.Settings;
5
6	namespace NetDaemon.HassModel.CodeGenerator;
7
8	#pragma warning disable CA1303
9	#pragma warning disable CA2000 // because of await using ... configureAwait()
10
11	internal class Controller
12	{
13	private const string ResourceName = "NetDaemon.HassModel.CodeGenerator.MetaData.DefaultMetadata.DefaultEntityMetaData.json";
14	private readonly CodeGenerationSettings _generationSettings;
15	private readonly HomeAssistantSettings _haSettings;
16
17	public Controller(CodeGenerationSettings generationSettings, HomeAssistantSettings haSettings)	1✔
18	{	1✔
19	_generationSettings = generationSettings;	1✔
20	_haSettings = haSettings;	1✔
21	}	1✔
22
23	private string EntityMetaDataFileName => Path.Combine(OutputFolder, "EntityMetaData.json");	1✔
24	private string ServicesMetaDataFileName => Path.Combine(OutputFolder, "ServicesMetaData.json");	×
25
26	private string OutputFolder => string.IsNullOrEmpty(_generationSettings.OutputFolder)	1!
27	? Directory.GetParent(Path.GetFullPath(_generationSettings.OutputFile))!.FullName	1✔
28	: _generationSettings.OutputFolder;	1✔
29
30	public async Task RunAsync()
31	{	×
32	var (hassStates, servicesMetaData) = await HaRepositry.GetHaData(_haSettings).ConfigureAwait(false);	×
33
34	var previousEntityMetadata = await LoadEntitiesMetaDataAsync().ConfigureAwait(false);	×
35	var currentEntityMetaData = EntityMetaDataGenerator.GetEntityDomainMetaData(hassStates);	×
36	var mergedEntityMetaData = EntityMetaDataMerger.Merge(_generationSettings, previousEntityMetadata, currentEntityMetaData);	×
37
38	await Save(mergedEntityMetaData, EntityMetaDataFileName).ConfigureAwait(false);	×
39	await Save(servicesMetaData, ServicesMetaDataFileName).ConfigureAwait(false);	×
40
41	var generatedTypes = Generator.GenerateTypes(mergedEntityMetaData.Domains, ServiceMetaDataParser.Parse(servicesMetaData!.Value));	×
42
43	SaveGeneratedCode(generatedTypes);	×
44	}	×
45
46	internal async Task<EntitiesMetaData> LoadEntitiesMetaDataAsync()
47	{	1✔
48	var fileStream = File.Exists(EntityMetaDataFileName) switch	1!
49	{	1✔
50	true => File.OpenRead(EntityMetaDataFileName),	×
51	false => GetDefaultMetaDataFileFromResource()	1✔
52	};	1✔
53
54	await using var _ = fileStream.ConfigureAwait(false);	1✔
55
56	var loaded = await JsonSerializer.DeserializeAsync<EntitiesMetaData>(fileStream, JsonSerializerOptions).ConfigureAwait(false);	1✔
57
58	return loaded ?? new EntitiesMetaData();	1!
59	}	1✔
60
61	private static Stream GetDefaultMetaDataFileFromResource()
62	{	1✔
63	var assembly = Assembly.GetExecutingAssembly();	1✔
64	return assembly.GetManifestResourceStream(ResourceName)!;	1✔
65	}	1✔
66
67	private async Task Save<T>(T merged, string fileName)
68	{	×
69	Directory.CreateDirectory(OutputFolder);	×
70
71	var fileStream = File.Create(fileName);	×
72	await using var _ = fileStream.ConfigureAwait(false);	×
73	await JsonSerializer.SerializeAsync(fileStream, merged, JsonSerializerOptions).ConfigureAwait(false);	×
74	}	×
75
76	private static JsonSerializerOptions JsonSerializerOptions =>
77	new()	1✔
78	{	1✔
79	PropertyNamingPolicy = JsonNamingPolicy.CamelCase,	1✔
80	WriteIndented = true,	1✔
81	Converters = { new ClrTypeJsonConverter() }	1✔
82	};	1✔
83
84	private void SaveGeneratedCode(MemberDeclarationSyntax[] generatedTypes)
85	{	×
86	if (!_generationSettings.GenerateOneFilePerEntity)	×
87	{	×
88	Console.WriteLine("Generating single file for all entities.");	×
89	var unit = Generator.BuildCompilationUnit(_generationSettings.Namespace, generatedTypes.ToArray());	×
90
91	Directory.CreateDirectory(Directory.GetParent(_generationSettings.OutputFile)!.FullName);	×
92
93	using var writer = new StreamWriter(_generationSettings.OutputFile);	×
94	unit.WriteTo(writer);	×
95
96	Console.WriteLine(Path.GetFullPath(_generationSettings.OutputFile));	×
97	}	×
98	else
99	{	×
100	Console.WriteLine("Generating separate file per entity.");	×
101
102	Directory.CreateDirectory(OutputFolder);	×
103
104	foreach (var type in generatedTypes)	×
105	{	×
106	var unit = Generator.BuildCompilationUnit(_generationSettings.Namespace, type);	×
107	using var writer = new StreamWriter(Path.Combine(OutputFolder, $"{unit.GetClassName()}.cs"));	×
108	unit.WriteTo(writer);	×
109	}	×
110
111	Console.WriteLine($"Generated {generatedTypes.Length} files.");	×
112	Console.WriteLine(OutputFolder);	×
113	}	×
114	}	×
115	}

net-daemon / netdaemon / 5770559224

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