Replace usage of GenericEnumMapper with native EnumStringType<> (#562)

hazzik · web-flow · commit 23fe01d5e728 · 2022-10-12T22:22:02.000Z
+semver:feature
diff --git a/src/FluentNHibernate.Specs/Automapping/AutomappingSpecs.Properties.Enum.cs b/src/FluentNHibernate.Specs/Automapping/AutomappingSpecs.Properties.Enum.cs
@@ -1,10 +1,10 @@
 using System.Linq;
 using FluentNHibernate.Automapping;
-using FluentNHibernate.Mapping;
 using FluentNHibernate.MappingModel.ClassBased;
 using FluentNHibernate.Specs.Automapping.Fixtures;
 using Machine.Specifications;
 using FluentAssertions;
+using NHibernate.Type;
 
 namespace FluentNHibernate.Specs.Automapping
 {
@@ -34,8 +34,8 @@ public class when_the_automapper_is_told_to_map_an_entity_with_a_enum_property :
         It should_create_a_property_mapping_for_the_property = () =>
             mapping.Properties.ShouldContain(x => x.Name == "EnumProperty");
 
-        It should_use_the_generic_enum_mapper_for_the_property = () =>
-            mapping.Properties.First().Type.GetUnderlyingSystemType().Should().Be(typeof(GenericEnumMapper<Enum>));
+        It should_use_the_enum_string_type_for_the_property = () =>
+            mapping.Properties.First().Type.GetUnderlyingSystemType().Should().Be(typeof(EnumStringType<Enum>));
 
         It should_create_a_column_for_the_property_mapping_with_the_property_name = () =>
             mapping.Properties.First().Columns.ShouldContain(x => x.Name == "EnumProperty");
@@ -52,8 +52,8 @@ public class when_the_automapper_is_told_to_map_an_entity_with_a_nullable_enum_p
         It should_create_a_property_mapping_for_the_property = () =>
             mapping.Properties.ShouldContain(x => x.Name == "EnumProperty");
 
-        It should_use_the_generic_enum_mapper_for_the_property = () =>
-            mapping.Properties.First().Type.GetUnderlyingSystemType().Should().Be(typeof(GenericEnumMapper<Enum>));
+        It should_use_the_enum_string_mapper_for_the_property = () =>
+            mapping.Properties.First().Type.GetUnderlyingSystemType().Should().Be(typeof(EnumStringType<Enum>));
 
         It should_create_a_column_for_the_property_mapping_with_the_property_name = () =>
             mapping.Properties.First().Columns.ShouldContain(x => x.Name == "EnumProperty");
diff --git a/src/FluentNHibernate.Testing/AutoMapping/Overrides/CompositeIdOverrides.cs b/src/FluentNHibernate.Testing/AutoMapping/Overrides/CompositeIdOverrides.cs
@@ -1,8 +1,8 @@
 using System;
 using System.Linq;
 using FluentNHibernate.Automapping;
-using FluentNHibernate.Mapping;
 using FluentNHibernate.MappingModel.Identity;
+using NHibernate.Type;
 using NUnit.Framework;
 
 namespace FluentNHibernate.Testing.AutoMapping.Overrides
@@ -60,7 +60,7 @@ public void ShouldMapEnumIdAsAString()
 				//of getting to the key type though
 				firstKey.ShouldBeOfType(typeof(KeyPropertyMapping));
 				var keyProp = (KeyPropertyMapping)firstKey;
-				keyProp.Type.GetUnderlyingSystemType().ShouldEqual(typeof(GenericEnumMapper<>).MakeGenericType(typeof(SomeEnum)));
+				keyProp.Type.GetUnderlyingSystemType().ShouldEqual(typeof(EnumStringType<>).MakeGenericType(typeof(SomeEnum)));
 			});
 		}
 
diff --git a/src/FluentNHibernate.Testing/DomainModel/Mapping/ClassMapXmlCreationTester.cs b/src/FluentNHibernate.Testing/DomainModel/Mapping/ClassMapXmlCreationTester.cs
@@ -4,6 +4,7 @@
 using FluentNHibernate.MappingModel;
 using NUnit.Framework;
 using FluentNHibernate.Mapping;
+using NHibernate.Type;
 
 namespace FluentNHibernate.Testing.DomainModel.Mapping
 {
@@ -218,13 +219,13 @@ public void DoubleNotWorksCorrectly()
         }
 
         [Test]
-        public void Map_an_enumeration()
+        public void MapAnEnumeration()
         {
             new MappingTester<MappedObject>()
                 .ForMapping(m => m.Map(x => x.Color))
                 .Element("class/property[@name='Color']")
                     .Exists()
-                    .HasAttribute("type", typeof(GenericEnumMapper<ColorEnum>).AssemblyQualifiedName)
+                    .HasAttribute("type", typeof(EnumStringType<ColorEnum>).AssemblyQualifiedName)
                 .Element("class/property[@name='Color']/column")
                     .Exists();
         }
@@ -236,7 +237,7 @@ public void MapANullableEnumeration()
                 .ForMapping(m => m.Map(x => x.NullableColor))
                 .Element("class/property[@name='NullableColor']")
                     .Exists()
-                    .HasAttribute("type", typeof(GenericEnumMapper<ColorEnum>).AssemblyQualifiedName)
+                    .HasAttribute("type", typeof(EnumStringType<ColorEnum>).AssemblyQualifiedName)
                 .Element("class/property[@name='NullableColor']/column")
                     .Exists()
                     .HasAttribute("not-null", "false");
diff --git a/src/FluentNHibernate.Testing/DomainModel/Mapping/CompositeIdentityPartTester.cs b/src/FluentNHibernate.Testing/DomainModel/Mapping/CompositeIdentityPartTester.cs
@@ -1,8 +1,7 @@
-using System;
 using System.Linq;
-using FluentNHibernate.Mapping;
 using FluentNHibernate.Mapping.Providers;
 using FluentNHibernate.MappingModel.ClassBased;
+using NHibernate.Type;
 using NUnit.Framework;
 
 namespace FluentNHibernate.Testing.DomainModel.Mapping
@@ -89,7 +88,7 @@ public void KeyPropertyEnumShouldBeStringByDefault()
                     c.CompositeId()
                         .KeyProperty(x => x.EnumProperty))
                 .Element("class/composite-id/key-property")
-                    .HasAttribute("type", typeof(GenericEnumMapper<SomeEnum>).AssemblyQualifiedName);
+                    .HasAttribute("type", typeof(EnumStringType<SomeEnum>).AssemblyQualifiedName);
         }
 
         [Test]
diff --git a/src/FluentNHibernate.Testing/FluentInterfaceTests/PropertyEnumerablesTests.cs b/src/FluentNHibernate.Testing/FluentInterfaceTests/PropertyEnumerablesTests.cs
@@ -1,5 +1,5 @@
 using System.Linq;
-using FluentNHibernate.Mapping;
+using NHibernate.Type;
 using NUnit.Framework;
 
 namespace FluentNHibernate.Testing.FluentInterfaceTests
@@ -19,19 +19,19 @@ public void ShouldSetNullableEnumsToNullable()
         }
 
         [Test]
-        public void ShouldSetNullableEnumsToUseGenericEnumMapper()
+        public void ShouldSetNullableEnumsToUseEnumStringType()
         {
             Property<Target>(x => x.NullableEnum)
                 .Mapping(m => {})
-                .ModelShouldMatch(x => x.Type.GetUnderlyingSystemType().ShouldEqual(typeof(GenericEnumMapper<Enum>)));
+                .ModelShouldMatch(x => x.Type.GetUnderlyingSystemType().ShouldEqual(typeof(EnumStringType<Enum>)));
         }
 
         [Test]
-        public void ShouldSetEnumsToUseGenericEnumMapper()
+        public void ShouldSetEnumsToUseEnumStringType()
         {
             Property<Target>(x => x.Enum)
                 .Mapping(m => { })
-                .ModelShouldMatch(x => x.Type.GetUnderlyingSystemType().ShouldEqual(typeof(GenericEnumMapper<Enum>)));
+                .ModelShouldMatch(x => x.Type.GetUnderlyingSystemType().ShouldEqual(typeof(EnumStringType<Enum>)));
         }
 
         private class Target
diff --git a/src/FluentNHibernate.Testing/Utils/TypeReferenceEnumTests.cs b/src/FluentNHibernate.Testing/Utils/TypeReferenceEnumTests.cs
@@ -1,13 +1,22 @@
-﻿using FluentNHibernate.MappingModel;
+﻿using System;
+using FluentNHibernate.MappingModel;
 using NUnit.Framework;
 using FluentNHibernate.Mapping;
+using NHibernate.Type;
 
 namespace FluentNHibernate.Testing.Utils
 {
     [TestFixture]
     public class TypeReferenceEnumTests
     {
         [Test]
+        public void IsEnumOnTypeReferenceToEnumStringTypeShouldBeTrue()
+        {
+            var enumTypeReference = new TypeReference(typeof(EnumStringType<TestEnum>));
+            enumTypeReference.IsEnum.ShouldBeTrue();
+        }
+        
+        [Test, Obsolete]
         public void IsEnumOnTypeReferenceToGenericEnumMapperShouldBeTrue()
         {
             var enumTypeReference = new TypeReference(typeof(GenericEnumMapper<TestEnum>));
@@ -18,7 +27,5 @@ private enum TestEnum
         {
             Value1            
         }
-
-        
     }
 }
diff --git a/src/FluentNHibernate/Automapping/Steps/PropertyStep.cs b/src/FluentNHibernate/Automapping/Steps/PropertyStep.cs
@@ -6,8 +6,8 @@
 using FluentNHibernate.Mapping;
 using FluentNHibernate.MappingModel;
 using FluentNHibernate.MappingModel.ClassBased;
-using FluentNHibernate.MappingModel.Collections;
 using FluentNHibernate.Utils;
+using NHibernate.Type;
 
 namespace FluentNHibernate.Automapping.Steps
 {
@@ -116,10 +116,10 @@ static TypeReference GetDefaultType(Member property)
             var type = new TypeReference(property.PropertyType);
 
             if (property.PropertyType.IsEnum())
-                type = new TypeReference(typeof(GenericEnumMapper<>).MakeGenericType(property.PropertyType));
+                type = new TypeReference(typeof(EnumStringType<>).MakeGenericType(property.PropertyType));
 
             if (property.PropertyType.IsNullable() && property.PropertyType.IsEnum())
-                type = new TypeReference(typeof(GenericEnumMapper<>).MakeGenericType(property.PropertyType.GetGenericArguments()[0]));
+                type = new TypeReference(typeof(EnumStringType<>).MakeGenericType(property.PropertyType.GetGenericArguments()[0]));
 
             return type;
         }
diff --git a/src/FluentNHibernate/Mapping/CompositeIdentityPart.cs b/src/FluentNHibernate/Mapping/CompositeIdentityPart.cs
@@ -7,6 +7,7 @@
 using FluentNHibernate.MappingModel;
 using FluentNHibernate.MappingModel.Identity;
 using FluentNHibernate.Utils;
+using NHibernate.Type;
 
 namespace FluentNHibernate.Mapping
 {
@@ -74,7 +75,7 @@ protected virtual CompositeIdentityPart<T> KeyProperty(Member member, string col
             var type = member.PropertyType;
 
             if (type.IsEnum)
-                type = typeof(GenericEnumMapper<>).MakeGenericType(type);
+                type = typeof(EnumStringType<>).MakeGenericType(type);
 
             var key = new KeyPropertyMapping
             {
diff --git a/src/FluentNHibernate/Mapping/GenericEnumMapper.cs b/src/FluentNHibernate/Mapping/GenericEnumMapper.cs
@@ -3,6 +3,7 @@
 
 namespace FluentNHibernate.Mapping
 {
+    [Obsolete("Please use EnumStringType<T> instead")]
     [Serializable]
     public class GenericEnumMapper<TEnum> : EnumStringType
     {
diff --git a/src/FluentNHibernate/Mapping/PropertyPart.cs b/src/FluentNHibernate/Mapping/PropertyPart.cs
@@ -4,6 +4,7 @@
 using FluentNHibernate.Mapping.Providers;
 using FluentNHibernate.MappingModel;
 using FluentNHibernate.Utils;
+using NHibernate.Type;
 using NHibernate.UserTypes;
 
 namespace FluentNHibernate.Mapping
@@ -353,10 +354,10 @@ TypeReference GetDefaultType()
             var type = new TypeReference(member.PropertyType);
 
             if (member.PropertyType.IsEnum())
-                type = new TypeReference(typeof(GenericEnumMapper<>).MakeGenericType(member.PropertyType));
+                type = new TypeReference(typeof(EnumStringType<>).MakeGenericType(member.PropertyType));
 
             if (member.PropertyType.IsNullable() && member.PropertyType.IsEnum())
-                type = new TypeReference(typeof(GenericEnumMapper<>).MakeGenericType(member.PropertyType.GetGenericArguments()[0]));
+                type = new TypeReference(typeof(EnumStringType<>).MakeGenericType(member.PropertyType.GetGenericArguments()[0]));
 
             return type;
         }
diff --git a/src/FluentNHibernate/MappingModel/TypeReference.cs b/src/FluentNHibernate/MappingModel/TypeReference.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using FluentNHibernate.Mapping;
+using NHibernate.Type;
 
 namespace FluentNHibernate.MappingModel
 {
@@ -35,12 +37,20 @@ public bool IsEnum
                 if (innerType == null)
                     return false;
 
-                if (innerType.IsGenericType 
-                    && innerType.GetGenericTypeDefinition() == typeof(FluentNHibernate.Mapping.GenericEnumMapper<>))
+                if (innerType.IsGenericType)
                 {
-                    return true;
+                    if (innerType.GetGenericTypeDefinition() == typeof(EnumStringType<>))
+                    {
+                        return true;
+                    }
+#pragma warning disable CS0618
+                    if (innerType.GetGenericTypeDefinition() == typeof(GenericEnumMapper<>))
+#pragma warning restore CS0618
+                    {
+                        return true;
+                    }
                 }
-                
+
 
                 return innerType.IsEnum;
             }

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`using System.Linq;`
`2`		`-using FluentNHibernate.Mapping;`
	`2`	`+using NHibernate.Type;`
`3`	`3`	`using NUnit.Framework;`
`4`	`4`
`5`	`5`	`namespace FluentNHibernate.Testing.FluentInterfaceTests`
`@@ -19,19 +19,19 @@ public void ShouldSetNullableEnumsToNullable()`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`[Test]`
`22`		`- public void ShouldSetNullableEnumsToUseGenericEnumMapper()`
	`22`	`+ public void ShouldSetNullableEnumsToUseEnumStringType()`
`23`	`23`	`{`
`24`	`24`	`Property<Target>(x => x.NullableEnum)`
`25`	`25`	`.Mapping(m => {})`
`26`		`- .ModelShouldMatch(x => x.Type.GetUnderlyingSystemType().ShouldEqual(typeof(GenericEnumMapper<Enum>)));`
	`26`	`+ .ModelShouldMatch(x => x.Type.GetUnderlyingSystemType().ShouldEqual(typeof(EnumStringType<Enum>)));`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`[Test]`
`30`		`- public void ShouldSetEnumsToUseGenericEnumMapper()`
	`30`	`+ public void ShouldSetEnumsToUseEnumStringType()`
`31`	`31`	`{`
`32`	`32`	`Property<Target>(x => x.Enum)`
`33`	`33`	`.Mapping(m => { })`
`34`		`- .ModelShouldMatch(x => x.Type.GetUnderlyingSystemType().ShouldEqual(typeof(GenericEnumMapper<Enum>)));`
	`34`	`+ .ModelShouldMatch(x => x.Type.GetUnderlyingSystemType().ShouldEqual(typeof(EnumStringType<Enum>)));`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`private class Target`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,22 @@`
`1`		`-using FluentNHibernate.MappingModel;`
	`1`	`+using System;`
	`2`	`+using FluentNHibernate.MappingModel;`
`2`	`3`	`using NUnit.Framework;`
`3`	`4`	`using FluentNHibernate.Mapping;`
	`5`	`+using NHibernate.Type;`
`4`	`6`
`5`	`7`	`namespace FluentNHibernate.Testing.Utils`
`6`	`8`	`{`
`7`	`9`	`[TestFixture]`
`8`	`10`	`public class TypeReferenceEnumTests`
`9`	`11`	`{`
`10`	`12`	`[Test]`
	`13`	`+ public void IsEnumOnTypeReferenceToEnumStringTypeShouldBeTrue()`
	`14`	`+ {`
	`15`	`+ var enumTypeReference = new TypeReference(typeof(EnumStringType<TestEnum>));`
	`16`	`+ enumTypeReference.IsEnum.ShouldBeTrue();`
	`17`	`+ }`
	`18`	`+`
	`19`	`+ [Test, Obsolete]`
`11`	`20`	`public void IsEnumOnTypeReferenceToGenericEnumMapperShouldBeTrue()`
`12`	`21`	`{`
`13`	`22`	`var enumTypeReference = new TypeReference(typeof(GenericEnumMapper<TestEnum>));`
`@@ -18,7 +27,5 @@ private enum TestEnum`
`18`	`27`	`{`
`19`	`28`	`Value1`
`20`	`29`	`}`
`21`		`-`
`22`		`-`
`23`	`30`	`}`
`24`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`using FluentNHibernate.MappingModel;`
`8`	`8`	`using FluentNHibernate.MappingModel.Identity;`
`9`	`9`	`using FluentNHibernate.Utils;`
	`10`	`+using NHibernate.Type;`
`10`	`11`
`11`	`12`	`namespace FluentNHibernate.Mapping`
`12`	`13`	`{`
`@@ -74,7 +75,7 @@ protected virtual CompositeIdentityPart<T> KeyProperty(Member member, string col`
`74`	`75`	`var type = member.PropertyType;`
`75`	`76`
`76`	`77`	`if (type.IsEnum)`
`77`		`- type = typeof(GenericEnumMapper<>).MakeGenericType(type);`
	`78`	`+ type = typeof(EnumStringType<>).MakeGenericType(type);`
`78`	`79`
`79`	`80`	`var key = new KeyPropertyMapping`
`80`	`81`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace FluentNHibernate.Mapping`
`5`	`5`	`{`
	`6`	`+ [Obsolete("Please use EnumStringType<T> instead")]`
`6`	`7`	`[Serializable]`
`7`	`8`	`public class GenericEnumMapper<TEnum> : EnumStringType`
`8`	`9`	`{`