Fix #830 Prevent duplicate C# names after normalizing EntitiyIds (#832)

FrankBakkerNl · web-flow · commit 94d646511a6a · 2023-02-02T19:21:57.000+01:00
diff --git a/src/HassModel/NetDaemon.HassModel.CodeGenerator/CodeGeneration/EntitiesGenerator.cs b/src/HassModel/NetDaemon.HassModel.CodeGenerator/CodeGeneration/EntitiesGenerator.cs
@@ -70,12 +70,8 @@ private static TypeDeclarationSyntax GenerateEntiesForDomainClass(string classNa
 
     private static MemberDeclarationSyntax GenerateEntityProperty(EntityMetaData entity, string className)
     {
-        var entityName = EntityIdHelper.GetEntity(entity.id);
-
-        var normalizedPascalCase = entityName.ToNormalizedPascalCase((string)"E_");
-
-        var name = entity.friendlyName;
-        return PropertyWithExpressionBodyNew(className, normalizedPascalCase, "_haContext", $"\"{entity.id}\"").WithSummaryComment(name);
+        return PropertyWithExpressionBodyNew(className, entity.cSharpName, "_haContext", $"\"{entity.id}\"")
+            .WithSummaryComment(entity.friendlyName);
     }
 
     /// <summary>
diff --git a/src/HassModel/NetDaemon.HassModel.CodeGenerator/CodeGeneration/ServiceArguments.cs b/src/HassModel/NetDaemon.HassModel.CodeGenerator/CodeGeneration/ServiceArguments.cs
@@ -14,11 +14,10 @@ internal record ServiceArgument
 
     public string ParameterTypeName => Required ? TypeName : $"{TypeName}?";
 
-    public string PropertyName => HaName.ToNormalizedPascalCase();
+    public string PropertyName => HaName.ToValidCSharpPascalCase();
 
-    public string ParameterName => HaName.ToNormalizedCamelCase();
+    public string ParameterName => HaName.ToValidCSharpCamelCase();
 
-    
     public string ParameterDefault => Required ? "" : " = null";
 }
 
@@ -46,15 +45,15 @@ private ServiceArguments(string domain, string serviceName, IReadOnlyCollection<
 
     public IEnumerable<ServiceArgument> Arguments { get; }
 
-    public string TypeName => $"{_domain.ToNormalizedPascalCase()}{GetServiceMethodName(_serviceName)}Parameters";
+    public string TypeName => $"{_domain.ToValidCSharpPascalCase()}{GetServiceMethodName(_serviceName)}Parameters";
 
     public string GetParametersList()
     {
         var argumentList = Arguments.OrderByDescending(arg => arg.Required);
 
         var anonymousVariableStr = argumentList.Select(x => $"{x.ParameterTypeName} {EscapeIfRequired(x.ParameterName)}{x.ParameterDefault}");
 
-        return $"{string.Join(", ", anonymousVariableStr)}";
+        return string.Join(", ", anonymousVariableStr);
     }
 
     public string GetNewServiceArgumentsTypeExpression()
@@ -71,5 +70,4 @@ private static string EscapeIfRequired(string name)
 
         return match ? "@" + name : name;
     }
-
 }
diff --git a/src/HassModel/NetDaemon.HassModel.CodeGenerator/Extensions/StringExtensions.cs b/src/HassModel/NetDaemon.HassModel.CodeGenerator/Extensions/StringExtensions.cs
@@ -6,24 +6,26 @@ namespace NetDaemon.HassModel.CodeGenerator.Extensions;
 
 internal static class StringExtensions
 {
-    public static string ToNormalizedPascalCase(this string name, string prefix = "HA_")
+    public static string ToValidCSharpPascalCase(this string name)
     {
-        return name.ToPascalCase().ToNormalized(prefix);
+        return name.ToPascalCase().ToValidCSharpIdentifier();
     }
 
-    public static string ToNormalizedCamelCase(this string name, string prefix = "HA_")
+    public static string ToValidCSharpCamelCase(this string name)
     {
-        return name.ToCamelCase().ToNormalized(prefix);
+        return name.ToCamelCase().ToValidCSharpIdentifier();
     }
 
-    private static string ToNormalized(this string name, string prefix = "HA_")
+    public static string ToValidCSharpIdentifier(this string name)
     {
         name = name.Replace(".", "_", StringComparison.InvariantCulture);
 
-        if (!char.IsLetter(name[0]) && name[0] != '_')
-            name = prefix + name;
+        name = Regex.Replace(name, "[^a-zA-Z0-9_]+", "", RegexOptions.Compiled);
 
-        return Regex.Replace(name, "[^a-zA-Z0-9]+", "", RegexOptions.Compiled);
+        if (char.IsAsciiDigit(name[0]))
+            name = "_" + name;
+
+        return name;
     }
         
     public static string ToPascalCase(this string str)
diff --git a/src/HassModel/NetDaemon.HassModel.CodeGenerator/Helpers/NamingHelper.cs b/src/HassModel/NetDaemon.HassModel.CodeGenerator/Helpers/NamingHelper.cs
@@ -10,35 +10,28 @@ internal static class NamingHelper
 
     public static string GetEntitiesForDomainClassName(string prefix)
     {
-        var normalizedDomain = prefix.ToNormalizedPascalCase();
+        var normalizedDomain = prefix.ToValidCSharpPascalCase();
 
         return $"{normalizedDomain}Entities";
     }
 
-    public static string GetDomainEntityTypeName(string prefix)
-    {
-        var normalizedDomain = prefix.ToNormalizedPascalCase();
-
-        return $"{normalizedDomain}Entity";
-    }
-
     public static string GetServicesTypeName(string prefix)
     {
-        var normalizedDomain = prefix.ToNormalizedPascalCase();
+        var normalizedDomain = prefix.ToValidCSharpPascalCase();
 
         return $"{normalizedDomain}Services";
     }
 
     public static string GetEntityDomainExtensionMethodClassName(string prefix)
     {
-        var normalizedDomain = prefix.ToNormalizedPascalCase();
+        var normalizedDomain = prefix.ToValidCSharpPascalCase();
 
         return $"{normalizedDomain}EntityExtensionMethods";
     }
 
     public static string GetServiceMethodName(string serviceName)
     {
-        serviceName = serviceName.ToNormalizedPascalCase();
+        serviceName = serviceName.ToValidCSharpPascalCase();
 
         return $"{serviceName}";
     }
diff --git a/src/HassModel/NetDaemon.HassModel.CodeGenerator/MetaData/EntityMetaData/AttributeMetaDataGenerator.cs b/src/HassModel/NetDaemon.HassModel.CodeGenerator/MetaData/EntityMetaData/AttributeMetaDataGenerator.cs
@@ -16,7 +16,7 @@ public static IEnumerable<EntityAttributeMetaData> GetMetaDataFromEntityStates(I
         var attributesByJsonName = jsonPropetiesByName
             .Select(group => new EntityAttributeMetaData(
                 JsonName: group.Key,
-                CSharpName: group.Key.ToNormalizedPascalCase(),
+                CSharpName: group.Key.ToValidCSharpPascalCase(),
                 ClrType: GetBestClrType(group.Select(g => g.Value))));
 
         // We ignore possible duplicate CSharp names here, they will be handled later 
diff --git a/src/HassModel/NetDaemon.HassModel.CodeGenerator/MetaData/EntityMetaData/EntityDomainMetadata.cs b/src/HassModel/NetDaemon.HassModel.CodeGenerator/MetaData/EntityMetaData/EntityDomainMetadata.cs
@@ -21,18 +21,18 @@ IReadOnlyList<EntityAttributeMetaData> Attributes
     private readonly string prefixedDomain = (IsNumeric && EntityIdHelper.MixedDomains.Contains(Domain)  ? "numeric_" : "") + Domain;
 
     [JsonIgnore]
-    public string EntityClassName => GetDomainEntityTypeName(prefixedDomain);
+    public string EntityClassName => $"{prefixedDomain}Entity".ToValidCSharpPascalCase();
 
     [JsonIgnore]
-    public string AttributesClassName => $"{prefixedDomain}Attributes".ToNormalizedPascalCase();
+    public string AttributesClassName => $"{prefixedDomain}Attributes".ToValidCSharpPascalCase();
 
     [JsonIgnore]
-    public string EntitiesForDomainClassName => $"{Domain}Entities".ToNormalizedPascalCase();
+    public string EntitiesForDomainClassName => $"{Domain}Entities".ToValidCSharpPascalCase();
 
     [JsonIgnore]
     public Type? AttributesBaseClass { get; set; }
 };
 
-record EntityMetaData(string id, string? friendlyName);
+record EntityMetaData(string id, string? friendlyName, string cSharpName);
 
 record EntityAttributeMetaData(string JsonName, string CSharpName, Type ClrType);
diff --git a/src/HassModel/NetDaemon.HassModel.CodeGenerator/MetaData/EntityMetaData/EntityMetaDataGenerator.cs b/src/HassModel/NetDaemon.HassModel.CodeGenerator/MetaData/EntityMetaData/EntityMetaDataGenerator.cs
@@ -1,4 +1,5 @@
-﻿using NetDaemon.Client.HomeAssistant.Model;
+﻿using System.Diagnostics;
+using NetDaemon.Client.HomeAssistant.Model;
 
 namespace NetDaemon.HassModel.CodeGenerator;
 
@@ -25,9 +26,40 @@ private static EntityDomainMetadata mapEntityDomainMetadata(IGrouping<(string do
             Entities: MapToEntityMetaData(domainGroup),
             Attributes: AttributeMetaDataGenerator.GetMetaDataFromEntityStates(domainGroup).ToList());
 
-    private static List<EntityMetaData> MapToEntityMetaData(IEnumerable<HassState> g) =>
-        g.Select(state => new EntityMetaData(state.EntityId, GetFriendlyName(state)))
-            .OrderBy(s=>s.id).ToList();
+    private static List<EntityMetaData> MapToEntityMetaData(IEnumerable<HassState> g)
+    {
+        var entityMetaDatas = g.Select(state => new EntityMetaData(
+            id: state.EntityId, 
+            friendlyName: GetFriendlyName(state),
+            cSharpName: GetPreferredCSharpName(state.EntityId)));
+
+        entityMetaDatas = DeDuplicateCSharpNames(entityMetaDatas);
+        
+        return entityMetaDatas.OrderBy(e => e.id).ToList();
+    }
+
+    private static IEnumerable<EntityMetaData> DeDuplicateCSharpNames(IEnumerable<EntityMetaData> entityMetaDatas)
+    {
+        // The PascalCased EntityId might not be unique because we removed all underscores
+        // If we have duplicates we will use the original ID instead and only make sure it is a Valid C# identifier
+        return entityMetaDatas
+            .ToLookup(e => e.cSharpName)
+            .SelectMany(e => e.Count() == 1 
+                ? e 
+                : e.Select(i => i with { cSharpName = GetUniqueCSharpName(i.id) }));
+    }
+
+    /// <summary>
+    /// We prefer the Property names for Entities to be the id in PascalCase
+    /// </summary>
+    private static string GetPreferredCSharpName(string id) => EntityIdHelper.GetEntity(id).ToValidCSharpPascalCase();
+
+    /// <summary>
+    /// HA entity ID's can only contain [a-z0-9_]. Which are all also valid in Csharp identifiers.
+    /// HA does allow the id to begin with a digit which is not valid for C#. In those cases it will be prefixed with
+    /// an _ 
+    /// </summary>
+    private static string GetUniqueCSharpName(string id) => EntityIdHelper.GetEntity(id).ToValidCSharpIdentifier();
 
     private static string? GetFriendlyName(HassState hassState) => hassState.AttributesAs<Attributes>()?.friendly_name;
 
diff --git a/src/HassModel/NetDaemon.HassModel.Tests/CodeGenerator/CodeGeneratorTest.cs b/src/HassModel/NetDaemon.HassModel.Tests/CodeGenerator/CodeGeneratorTest.cs
@@ -58,6 +58,60 @@ public void Run(IHaContext ha)
         CodeGenTestHelper.AssertCodeCompiles(generatedCode.ToString(), appCode);
     }
         
+    [Fact]
+    public void TestEntityDuplictateNormalizedName()
+    {
+        var entityStates = new HassState[]
+        {
+            new() { EntityId = "light.light_1_1" },
+            new() { EntityId = "light.light_11" },
+        };
+
+        var generatedCode = CodeGenTestHelper.GenerateCompilationUnit(_settings, entityStates, Array.Empty<HassServiceDomain>());
+        var appCode = """
+                        using NetDaemon.HassModel.Entities;
+                        using NetDaemon.HassModel;
+                        using RootNameSpace;
+
+                        public class Root
+                        {
+                            public void Run(Entities entities)
+                            {
+                                LightEntity l1_1 = entities.Light.light_1_1;
+                                LightEntity l11 = entities.Light.light_11;
+                            }
+                        }
+                        """;
+        CodeGenTestHelper.AssertCodeCompiles(generatedCode.ToString(), appCode);
+    }    
+    
+    [Fact]
+    public void TestEntityInvalidCSharpName()
+    {
+        var entityStates = new HassState[]
+        {
+            new() { EntityId = "light.1light" },
+            new() { EntityId = "light.li@#ght" },
+        };
+
+        var generatedCode = CodeGenTestHelper.GenerateCompilationUnit(_settings, entityStates, Array.Empty<HassServiceDomain>());
+        var appCode = """
+                        using NetDaemon.HassModel.Entities;
+                        using NetDaemon.HassModel;
+                        using RootNameSpace;
+
+                        public class Root
+                        {
+                            public void Run(Entities entities)
+                            {
+                                LightEntity l1 = entities.Light._1light;
+                                LightEntity l2 = entities.Light.Light;
+                            }
+                        }
+                        """;
+        CodeGenTestHelper.AssertCodeCompiles(generatedCode.ToString(), appCode);
+    }        
+    
     [Fact]
     public void TestNumericSensorEntityGeneration()
     {
diff --git a/src/HassModel/NetDaemon.HassModel.Tests/CodeGenerator/MetaDataMergerTest.cs b/src/HassModel/NetDaemon.HassModel.Tests/CodeGenerator/MetaDataMergerTest.cs
@@ -10,8 +10,8 @@ public void MergeSimple()
     {
         var previous = new []{new EntityDomainMetadata("light", false, new []
             {
-                new EntityMetaData("light.living", "Livingroom spots"),
-                new EntityMetaData("light.kitchen", "Kitchen light")
+                new EntityMetaData("light.living", "Livingroom spots", "Living"),
+                new EntityMetaData("light.kitchen", "Kitchen light", "Kitchen")
             }, 
             new []
             {
@@ -20,20 +20,20 @@ public void MergeSimple()
 
         var current = new []{new EntityDomainMetadata("light", false, new []
             {
-                new EntityMetaData("light.bedroom", "nightlight"),
-                new EntityMetaData("light.kitchen", "Kitchen light new name")
+                new EntityMetaData("light.bedroom", "nightlight", "Bedroom"),
+                new EntityMetaData("light.kitchen", "Kitchen light new name", "Kitchen")
             }, 
             new []
             {
                 new EntityAttributeMetaData("off_brightness", "OffBrightness", typeof(double))
             })};
 
-        var result= EntityMetaDataMerger.Merge(new(), new EntitiesMetaData(){Domains = previous}, new EntitiesMetaData{Domains = current}).Domains;
+        var result = EntityMetaDataMerger.Merge(new(), new EntitiesMetaData { Domains = previous }, new EntitiesMetaData { Domains = current }).Domains;
 
         var expected = new []{new EntityDomainMetadata("light", false, new []
             {
-                new EntityMetaData("light.bedroom", "nightlight"),
-                new EntityMetaData("light.kitchen", "Kitchen light new name")
+                new EntityMetaData("light.bedroom", "nightlight", "Bedroom"),
+                new EntityMetaData("light.kitchen", "Kitchen light new name", "Kitchen")
             },
             new []
             {

Original file line number	Diff line number	Diff line change
`@@ -70,12 +70,8 @@ private static TypeDeclarationSyntax GenerateEntiesForDomainClass(string classNa`
`70`	`70`
`71`	`71`	`private static MemberDeclarationSyntax GenerateEntityProperty(EntityMetaData entity, string className)`
`72`	`72`	`{`
`73`		`- var entityName = EntityIdHelper.GetEntity(entity.id);`
`74`		`-`
`75`		`- var normalizedPascalCase = entityName.ToNormalizedPascalCase((string)"E_");`
`76`		`-`
`77`		`- var name = entity.friendlyName;`
`78`		`- return PropertyWithExpressionBodyNew(className, normalizedPascalCase, "_haContext", $"\"{entity.id}\"").WithSummaryComment(name);`
	`73`	`+ return PropertyWithExpressionBodyNew(className, entity.cSharpName, "_haContext", $"\"{entity.id}\"")`
	`74`	`+ .WithSummaryComment(entity.friendlyName);`
`79`	`75`	`}`
`80`	`76`
`81`	`77`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,10 @@ internal record ServiceArgument`
`14`	`14`
`15`	`15`	`public string ParameterTypeName => Required ? TypeName : $"{TypeName}?";`
`16`	`16`
`17`		`- public string PropertyName => HaName.ToNormalizedPascalCase();`
	`17`	`+ public string PropertyName => HaName.ToValidCSharpPascalCase();`
`18`	`18`
`19`		`- public string ParameterName => HaName.ToNormalizedCamelCase();`
	`19`	`+ public string ParameterName => HaName.ToValidCSharpCamelCase();`
`20`	`20`
`21`		`-`
`22`	`21`	`public string ParameterDefault => Required ? "" : " = null";`
`23`	`22`	`}`
`24`	`23`
`@@ -46,15 +45,15 @@ private ServiceArguments(string domain, string serviceName, IReadOnlyCollection<`
`46`	`45`
`47`	`46`	`public IEnumerable<ServiceArgument> Arguments { get; }`
`48`	`47`
`49`		`- public string TypeName => $"{_domain.ToNormalizedPascalCase()}{GetServiceMethodName(_serviceName)}Parameters";`
	`48`	`+ public string TypeName => $"{_domain.ToValidCSharpPascalCase()}{GetServiceMethodName(_serviceName)}Parameters";`
`50`	`49`
`51`	`50`	`public string GetParametersList()`
`52`	`51`	`{`
`53`	`52`	`var argumentList = Arguments.OrderByDescending(arg => arg.Required);`
`54`	`53`
`55`	`54`	`var anonymousVariableStr = argumentList.Select(x => $"{x.ParameterTypeName} {EscapeIfRequired(x.ParameterName)}{x.ParameterDefault}");`
`56`	`55`
`57`		`- return $"{string.Join(", ", anonymousVariableStr)}";`
	`56`	`+ return string.Join(", ", anonymousVariableStr);`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`public string GetNewServiceArgumentsTypeExpression()`
`@@ -71,5 +70,4 @@ private static string EscapeIfRequired(string name)`
`71`	`70`
`72`	`71`	`return match ? "@" + name : name;`
`73`	`72`	`}`
`74`		`-`
`75`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,24 +6,26 @@ namespace NetDaemon.HassModel.CodeGenerator.Extensions;`
`6`	`6`
`7`	`7`	`internal static class StringExtensions`
`8`	`8`	`{`
`9`		`- public static string ToNormalizedPascalCase(this string name, string prefix = "HA_")`
	`9`	`+ public static string ToValidCSharpPascalCase(this string name)`
`10`	`10`	`{`
`11`		`- return name.ToPascalCase().ToNormalized(prefix);`
	`11`	`+ return name.ToPascalCase().ToValidCSharpIdentifier();`
`12`	`12`	`}`
`13`	`13`
`14`		`- public static string ToNormalizedCamelCase(this string name, string prefix = "HA_")`
	`14`	`+ public static string ToValidCSharpCamelCase(this string name)`
`15`	`15`	`{`
`16`		`- return name.ToCamelCase().ToNormalized(prefix);`
	`16`	`+ return name.ToCamelCase().ToValidCSharpIdentifier();`
`17`	`17`	`}`
`18`	`18`
`19`		`- private static string ToNormalized(this string name, string prefix = "HA_")`
	`19`	`+ public static string ToValidCSharpIdentifier(this string name)`
`20`	`20`	`{`
`21`	`21`	`name = name.Replace(".", "_", StringComparison.InvariantCulture);`
`22`	`22`
`23`		`- if (!char.IsLetter(name[0]) && name[0] != '_')`
`24`		`- name = prefix + name;`
	`23`	`+ name = Regex.Replace(name, "[^a-zA-Z0-9_]+", "", RegexOptions.Compiled);`
`25`	`24`
`26`		`- return Regex.Replace(name, "[^a-zA-Z0-9]+", "", RegexOptions.Compiled);`
	`25`	`+ if (char.IsAsciiDigit(name[0]))`
	`26`	`+ name = "_" + name;`
	`27`	`+`
	`28`	`+ return name;`
`27`	`29`	`}`
`28`	`30`
`29`	`31`	`public static string ToPascalCase(this string str)`
Original file line number	Diff line number	Diff line change
`@@ -10,35 +10,28 @@ internal static class NamingHelper`
`10`	`10`
`11`	`11`	`public static string GetEntitiesForDomainClassName(string prefix)`
`12`	`12`	`{`
`13`		`- var normalizedDomain = prefix.ToNormalizedPascalCase();`
	`13`	`+ var normalizedDomain = prefix.ToValidCSharpPascalCase();`
`14`	`14`
`15`	`15`	`return $"{normalizedDomain}Entities";`
`16`	`16`	`}`
`17`	`17`
`18`		`- public static string GetDomainEntityTypeName(string prefix)`
`19`		`- {`
`20`		`- var normalizedDomain = prefix.ToNormalizedPascalCase();`
`21`		`-`
`22`		`- return $"{normalizedDomain}Entity";`
`23`		`- }`
`24`		`-`
`25`	`18`	`public static string GetServicesTypeName(string prefix)`
`26`	`19`	`{`
`27`		`- var normalizedDomain = prefix.ToNormalizedPascalCase();`
	`20`	`+ var normalizedDomain = prefix.ToValidCSharpPascalCase();`
`28`	`21`
`29`	`22`	`return $"{normalizedDomain}Services";`
`30`	`23`	`}`
`31`	`24`
`32`	`25`	`public static string GetEntityDomainExtensionMethodClassName(string prefix)`
`33`	`26`	`{`
`34`		`- var normalizedDomain = prefix.ToNormalizedPascalCase();`
	`27`	`+ var normalizedDomain = prefix.ToValidCSharpPascalCase();`
`35`	`28`
`36`	`29`	`return $"{normalizedDomain}EntityExtensionMethods";`
`37`	`30`	`}`
`38`	`31`
`39`	`32`	`public static string GetServiceMethodName(string serviceName)`
`40`	`33`	`{`
`41`		`- serviceName = serviceName.ToNormalizedPascalCase();`
	`34`	`+ serviceName = serviceName.ToValidCSharpPascalCase();`
`42`	`35`
`43`	`36`	`return $"{serviceName}";`
`44`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@ public void MergeSimple()`
`10`	`10`	`{`
`11`	`11`	`var previous = new []{new EntityDomainMetadata("light", false, new []`
`12`	`12`	`{`
`13`		`- new EntityMetaData("light.living", "Livingroom spots"),`
`14`		`- new EntityMetaData("light.kitchen", "Kitchen light")`
	`13`	`+ new EntityMetaData("light.living", "Livingroom spots", "Living"),`
	`14`	`+ new EntityMetaData("light.kitchen", "Kitchen light", "Kitchen")`
`15`	`15`	`},`
`16`	`16`	`new []`
`17`	`17`	`{`
`@@ -20,20 +20,20 @@ public void MergeSimple()`
`20`	`20`
`21`	`21`	`var current = new []{new EntityDomainMetadata("light", false, new []`
`22`	`22`	`{`
`23`		`- new EntityMetaData("light.bedroom", "nightlight"),`
`24`		`- new EntityMetaData("light.kitchen", "Kitchen light new name")`
	`23`	`+ new EntityMetaData("light.bedroom", "nightlight", "Bedroom"),`
	`24`	`+ new EntityMetaData("light.kitchen", "Kitchen light new name", "Kitchen")`
`25`	`25`	`},`
`26`	`26`	`new []`
`27`	`27`	`{`
`28`	`28`	`new EntityAttributeMetaData("off_brightness", "OffBrightness", typeof(double))`
`29`	`29`	`})};`
`30`	`30`
`31`		`- var result= EntityMetaDataMerger.Merge(new(), new EntitiesMetaData(){Domains = previous}, new EntitiesMetaData{Domains = current}).Domains;`
	`31`	`+ var result = EntityMetaDataMerger.Merge(new(), new EntitiesMetaData { Domains = previous }, new EntitiesMetaData { Domains = current }).Domains;`
`32`	`32`
`33`	`33`	`var expected = new []{new EntityDomainMetadata("light", false, new []`
`34`	`34`	`{`
`35`		`- new EntityMetaData("light.bedroom", "nightlight"),`
`36`		`- new EntityMetaData("light.kitchen", "Kitchen light new name")`
	`35`	`+ new EntityMetaData("light.bedroom", "nightlight", "Bedroom"),`
	`36`	`+ new EntityMetaData("light.kitchen", "Kitchen light new name", "Kitchen")`
`37`	`37`	`},`
`38`	`38`	`new []`
`39`	`39`	`{`