Revert tuplizer changes

hazzik · hazzik · commit 5cef9cf1531b · 2025-07-31T13:19:09.000+10:00
diff --git a/src/FluentNHibernate.Testing/DomainModel/Mapping/ComponentPartTester.cs b/src/FluentNHibernate.Testing/DomainModel/Mapping/ComponentPartTester.cs
@@ -1,6 +1,4 @@
-﻿using System;
-using FluentNHibernate.MappingModel;
-using NUnit.Framework;
+﻿using NUnit.Framework;
 
 namespace FluentNHibernate.Testing.DomainModel.Mapping;
 
@@ -105,34 +103,6 @@ public void ComponentSetsClass()
             .ForMapping(m =>
                 m.Component(x => x.Component, c => c.Map(x => x.Name)))
             .Element("class/component").HasAttribute("class", typeof(ComponentTarget).AssemblyQualifiedName);                
-    }
-    
-    [Test]
-    public void ComponentCanSetTuplizer()
-    {
-        Type tuplizerType = typeof(NHibernate.Tuple.Entity.PocoEntityTuplizer);
-        new MappingTester<PropertyTarget>()
-            .ForMapping(m =>
-                m.Component(x => x.Component, c => c.Tuplizer(TuplizerMode.Poco, tuplizerType)))
-            .Element("class/component/tuplizer")
-            .HasAttribute("class", tuplizerType.AssemblyQualifiedName)
-            .HasAttribute("entity-mode", nameof(TuplizerMode.Poco).ToLower());
-    }
-    
-    [Test]
-    public void ComponentCanSetTuplizerInCorrectOrderRegardlessOfDeclaration()
-    {
-        Type tuplizerType = typeof(NHibernate.Tuple.Entity.PocoEntityTuplizer);
-        new MappingTester<PropertyTarget>()
-            .ForMapping(m =>
-                m.Component(x => x.Component, c =>
-                {
-                    c.Map(x => x.Name);
-                    c.ParentReference(x => x.MyParent);
-                    c.Tuplizer(TuplizerMode.Poco, tuplizerType);
-                }))
-            .Element("class/component/tuplizer").Exists().ShouldBeInParentAtPosition(0)
-            .Element("class/component/parent").Exists().ShouldBeInParentAtPosition(1)
-            .Element("class/component/property").Exists().ShouldBeInParentAtPosition(2);
-    }
+    }        
+
 }
diff --git a/src/FluentNHibernate.Testing/DomainModel/Mapping/MappingTester.cs b/src/FluentNHibernate.Testing/DomainModel/Mapping/MappingTester.cs
@@ -48,7 +48,7 @@ public virtual MappingTester<T> SubClassMapping<TSubClass>(Action<SubclassMap<TS
 
         return this;
     }
-    
+
     public virtual MappingTester<T> ForMapping(Action<ClassMap<T>> mappingAction)
     {
         var classMap = new ClassMap<T>();
@@ -189,9 +189,7 @@ public virtual MappingTester<T> ShouldBeInParentAtPosition(int elementPosition)
         else
         {
             XmlElement elementAtPosition = (XmlElement)currentElement.ParentNode.ChildNodes.Item(elementPosition);
-            // Assert.That(elementWithoutChildren0, IsEqualTo(elementWithoutChildren1)) always returns true (it defaults
-            // to the NUnit IEnumerable comparer, which returns equal cause both don't have child nodes).
-            Assert.That(elementAtPosition?.OuterXml, Is.EqualTo(currentElement.OuterXml), $"Expected '{currentElement.Name}' but was '{elementAtPosition.Name}'");
+            Assert.That(elementAtPosition, Is.EqualTo(currentElement), $"Expected '{currentElement.Name}' but was '{elementAtPosition.Name}'");
         }
 
         return this;
diff --git a/src/FluentNHibernate.Testing/DomainModel/Mapping/SubClassTester.cs b/src/FluentNHibernate.Testing/DomainModel/Mapping/SubClassTester.cs
@@ -1,8 +1,6 @@
-using System;
 using FluentNHibernate.Conventions;
 using FluentNHibernate.Conventions.Instances;
 using FluentNHibernate.Mapping;
-using FluentNHibernate.MappingModel;
 using NUnit.Framework;
 
 namespace FluentNHibernate.Testing.DomainModel.Mapping;
@@ -592,28 +590,7 @@ public void SubSubclassOneToManyReferenceHasConventionApplied()
             .HasAttribute("foreign-key", "test_fk");
 
     }
-    
-    [Test]
-    public void SubclassCanSetTuplizerInCorrectOrder()
-    {
-        Type tuplizerType = typeof(NHibernate.Tuple.Entity.PocoEntityTuplizer);
-        new MappingTester<MappedObject>()
-            .SubClassMapping<MappedObjectSubclass>(m =>
-            {
-                m.Map(x => x.SubclassProperty);
-                m.Tuplizer(TuplizerMode.Poco, tuplizerType);
-                m.DiscriminatorValue("test");
-            })
-            .ForMapping(m =>
-            {
-                m.DiscriminateSubClassesOnColumn("test_column");
-                m.Id(x => x.Id);
-                m.Tuplizer(TuplizerMode.Poco, tuplizerType);
-            })
-            .Element("class/subclass/tuplizer").Exists().ShouldBeInParentAtPosition(0)
-            .Element("class/tuplizer").Exists().ShouldBeInParentAtPosition(0);
-    }
-    
+
     public class TestPropertyConvention : IPropertyConvention
     {
         public void Apply(IPropertyInstance instance)
diff --git a/src/FluentNHibernate.Testing/DomainModel/Mapping/UnionSubclassTester.cs b/src/FluentNHibernate.Testing/DomainModel/Mapping/UnionSubclassTester.cs
@@ -1,5 +1,3 @@
-using System;
-using FluentNHibernate.MappingModel;
 using NUnit.Framework;
 
 namespace FluentNHibernate.Testing.DomainModel.Mapping;
@@ -46,24 +44,4 @@ public void ShouldAllowEntityNameToBeSetOnUnionSubclasses()
             }).Element("class/union-subclass")
             .HasAttribute("entity-name", "name");
     }
-    
-    [Test]
-    public void SubclassCanSetTuplizerInCorrectOrder()
-    {
-        Type tuplizerType = typeof(NHibernate.Tuple.Entity.PocoEntityTuplizer);
-        new MappingTester<MappedObject>()
-            .SubClassMapping<MappedObjectSubclass>(m =>
-            {
-                m.Map(x => x.SubclassProperty);
-                m.Tuplizer(TuplizerMode.Poco, tuplizerType);
-            })
-            .ForMapping(m =>
-            {
-                m.UseUnionSubclassForInheritanceMapping();
-                m.Id(x => x.Id);
-                m.Tuplizer(TuplizerMode.Poco, tuplizerType);
-            })
-            .Element("class/union-subclass/tuplizer").Exists().ShouldBeInParentAtPosition(0)
-            .Element("class/tuplizer").Exists().ShouldBeInParentAtPosition(0);
-    }
 }
diff --git a/src/FluentNHibernate/Mapping/ClassMap.cs b/src/FluentNHibernate/Mapping/ClassMap.cs
@@ -583,8 +583,17 @@ public ClassMap<T> ApplyFilter(string name)
     /// </summary>
     /// <param name="mode">Tuplizer entity-mode</param>
     /// <param name="tuplizerType">Tuplizer type</param>
-    public TuplizerPart Tuplizer(TuplizerMode mode, Type tuplizerType) => CreateTuplizerPart(mode, tuplizerType);
-    
+    public TuplizerPart Tuplizer(TuplizerMode mode, Type tuplizerType)
+    {
+        providers.TuplizerMapping = new TuplizerMapping();
+        providers.TuplizerMapping.Set(x => x.Mode, Layer.UserSupplied, mode);
+        providers.TuplizerMapping.Set(x => x.Type, Layer.UserSupplied, new TypeReference(tuplizerType));
+
+        return new TuplizerPart(providers.TuplizerMapping)
+            .Type(tuplizerType)
+            .Mode(mode);
+    }
+
     ClassMapping IMappingProvider.GetClassMapping()
     {
         var mapping = new ClassMapping(attributes.Clone());
diff --git a/src/FluentNHibernate/Mapping/ClasslikeMapBase.cs b/src/FluentNHibernate/Mapping/ClasslikeMapBase.cs
@@ -3,7 +3,6 @@
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using FluentNHibernate.Mapping.Providers;
-using FluentNHibernate.MappingModel;
 using FluentNHibernate.Utils;
 
 namespace FluentNHibernate.Mapping;
@@ -439,17 +438,6 @@ protected StoredProcedurePart StoredProcedure(string element, string innerText)
         providers.StoredProcedures.Add(part);
         return part;
     }
-    
-    protected TuplizerPart CreateTuplizerPart(TuplizerMode mode, Type tuplizerType)
-    {
-        providers.TuplizerMapping = new TuplizerMapping();
-        providers.TuplizerMapping.Set(x => x.Mode, Layer.UserSupplied, mode);
-        providers.TuplizerMapping.Set(x => x.Type, Layer.UserSupplied, new TypeReference(tuplizerType));
-
-        return new TuplizerPart(providers.TuplizerMapping)
-            .Type(tuplizerType)
-            .Mode(mode);
-    }
 
     internal IEnumerable<IPropertyMappingProvider> Properties => providers.Properties;
 
diff --git a/src/FluentNHibernate/Mapping/ComponentPart.cs b/src/FluentNHibernate/Mapping/ComponentPart.cs
@@ -41,15 +41,6 @@ public ComponentPart<T> LazyLoad()
         nextBool = true;
         return this;
     }
-    
-    /// <summary>
-    /// Configures the tuplizer for this component. The tuplizer defines how to transform
-    /// a Property-Value to its persistent representation, and viceversa a Column-Value
-    /// to its in-memory representation, and the EntityMode defines which tuplizer is in use.
-    /// </summary>
-    /// <param name="mode">Tuplizer entity-mode</param>
-    /// <param name="tuplizerType">Tuplizer type</param>
-    public TuplizerPart Tuplizer(TuplizerMode mode, Type tuplizerType) => CreateTuplizerPart(mode, tuplizerType);
 
     IComponentMapping IComponentMappingProvider.GetComponentMapping()
     {
diff --git a/src/FluentNHibernate/Mapping/ComponentPartBase.cs b/src/FluentNHibernate/Mapping/ComponentPartBase.cs
@@ -166,9 +166,7 @@ protected ComponentMapping CreateComponentMapping()
 
         if (member is not null)
             mapping.Set(x => x.Name, Layer.Defaults, member.Name);
-        
-        mapping.Set(x => x.Tuplizer, Layer.UserSupplied, providers.TuplizerMapping);
-        
+
         foreach (var property in providers.Properties)
             mapping.AddProperty(property.GetPropertyMapping());
 
diff --git a/src/FluentNHibernate/Mapping/SubClassPart.cs b/src/FluentNHibernate/Mapping/SubClassPart.cs
@@ -4,6 +4,7 @@
 using FluentNHibernate.Mapping.Providers;
 using FluentNHibernate.MappingModel;
 using FluentNHibernate.MappingModel.ClassBased;
+using FluentNHibernate.Utils;
 
 namespace FluentNHibernate.Mapping;
 
diff --git a/src/FluentNHibernate/Mapping/SubclassMap.cs b/src/FluentNHibernate/Mapping/SubclassMap.cs
@@ -277,15 +277,6 @@ public void Extends(Type type)
     {
         attributes.Set("Extends", Layer.UserSupplied, type);
     }
-    
-    /// <summary>
-    /// Configures the tuplizer for this entity. The tuplizer defines how to transform
-    /// a Property-Value to its persistent representation, and viceversa a Column-Value
-    /// to its in-memory representation, and the EntityMode defines which tuplizer is in use.
-    /// </summary>
-    /// <param name="mode">Tuplizer entity-mode</param>
-    /// <param name="tuplizerType">Tuplizer type</param>
-    public TuplizerPart Tuplizer(TuplizerMode mode, Type tuplizerType) => CreateTuplizerPart(mode, tuplizerType);
 
     SubclassMapping IIndeterminateSubclassMappingProvider.GetSubclassMapping(SubclassType type)
     {
@@ -339,9 +330,15 @@ SubclassMapping IIndeterminateSubclassMappingProvider.GetSubclassMapping(Subclas
                 case MappingProviderStore.ProviderType.StoredProcedure:
                     mapping.AddStoredProcedure(((IStoredProcedureMappingProvider)mappingProviderObj).GetStoredProcedureMapping());
                     break;
+                case MappingProviderStore.ProviderType.Subclass:
+                case MappingProviderStore.ProviderType.Filter:
+                case MappingProviderStore.ProviderType.Join:
+                case MappingProviderStore.ProviderType.Identity:
+                case MappingProviderStore.ProviderType.CompositeId:
+                case MappingProviderStore.ProviderType.NaturalId:
+                case MappingProviderStore.ProviderType.Version:
+                case MappingProviderStore.ProviderType.Discriminator:
                 case MappingProviderStore.ProviderType.Tupilizer:
-                    mapping.Set(y => y.Tuplizer, Layer.Defaults, (TuplizerMapping)mappingProviderObj);
-                    break;
                 default:
                     throw new Exception("Internal Error");
             }
diff --git a/src/FluentNHibernate/MappingModel/ClassBased/ClassMappingBase.cs b/src/FluentNHibernate/MappingModel/ClassBased/ClassMappingBase.cs
@@ -17,7 +17,7 @@ public abstract class ClassMappingBase(AttributeStore attributes) : MappingBase,
     public override void AcceptVisitor(IMappingModelVisitor visitor)
     {
         mappedMembers.AcceptVisitor(visitor);
-        
+
         foreach (var subclass in Subclasses)
             visitor.Visit(subclass);
     }
diff --git a/src/FluentNHibernate/MappingModel/ClassBased/ComponentMapping.cs b/src/FluentNHibernate/MappingModel/ClassBased/ComponentMapping.cs
@@ -25,9 +25,6 @@ public override void AcceptVisitor(IMappingModelVisitor visitor)
     {
         visitor.ProcessComponent(this);
 
-        if (Tuplizer is not null)
-            visitor.Visit(Tuplizer);
-        
         base.AcceptVisitor(visitor);
     }
 
@@ -42,8 +39,6 @@ public override void AcceptVisitor(IMappingModelVisitor visitor)
     public TypeReference Class => attributes.GetOrDefault<TypeReference>();
 
     public bool Lazy => attributes.GetOrDefault<bool>();
-    
-    public TuplizerMapping Tuplizer => attributes.GetOrDefault<TuplizerMapping>();
 
     public bool Equals(ComponentMapping other)
     {
diff --git a/src/FluentNHibernate/MappingModel/ClassBased/SubclassMapping.cs b/src/FluentNHibernate/MappingModel/ClassBased/SubclassMapping.cs
@@ -27,9 +27,6 @@ public override void AcceptVisitor(IMappingModelVisitor visitor)
     {
         visitor.ProcessSubclass(this);
 
-        if (Tuplizer is not null)
-            visitor.Visit(Tuplizer);
-        
         if (SubclassType == SubclassType.JoinedSubclass && Key is not null)
             visitor.Visit(Key);
 
@@ -69,8 +66,6 @@ public override void AcceptVisitor(IMappingModelVisitor visitor)
     public TypeReference Persister => attributes.GetOrDefault<TypeReference>();
 
     public int BatchSize => attributes.GetOrDefault<int>();
-    
-    public TuplizerMapping Tuplizer => attributes.GetOrDefault<TuplizerMapping>();
 
     public void OverrideAttributes(AttributeStore store)
     {
diff --git a/src/FluentNHibernate/MappingModel/Output/BaseXmlComponentWriter.cs b/src/FluentNHibernate/MappingModel/Output/BaseXmlComponentWriter.cs
@@ -47,12 +47,4 @@ public override void Visit(ParentMapping parentMapping)
 
         document.ImportAndAppendChild(parentXml);
     }
-    
-    public override void Visit(TuplizerMapping mapping)
-    {
-        var writer = serviceLocator.GetWriter<TuplizerMapping>();
-        var filterXml = writer.Write(mapping);
-
-        document.ImportAndAppendChild(filterXml);
-    }
 }
diff --git a/src/FluentNHibernate/MappingModel/Output/XmlSubclassWriter.cs b/src/FluentNHibernate/MappingModel/Output/XmlSubclassWriter.cs
@@ -104,12 +104,4 @@ public override void Visit(JoinMapping joinMapping)
 
         document.ImportAndAppendChild(xml);
     }
-    
-    public override void Visit(TuplizerMapping mapping)
-    {
-        var writer = serviceLocator.GetWriter<TuplizerMapping>();
-        var filterXml = writer.Write(mapping);
-
-        document.ImportAndAppendChild(filterXml);
-    }
 }

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ public virtual MappingTester<T> SubClassMapping<TSubClass>(Action<SubclassMap<TS`
`48`	`48`
`49`	`49`	`return this;`
`50`	`50`	`}`
`51`		`-`
	`51`	`+`
`52`	`52`	`public virtual MappingTester<T> ForMapping(Action<ClassMap<T>> mappingAction)`
`53`	`53`	`{`
`54`	`54`	`var classMap = new ClassMap<T>();`
`@@ -189,9 +189,7 @@ public virtual MappingTester<T> ShouldBeInParentAtPosition(int elementPosition)`
`189`	`189`	`else`
`190`	`190`	`{`
`191`	`191`	`XmlElement elementAtPosition = (XmlElement)currentElement.ParentNode.ChildNodes.Item(elementPosition);`
`192`		`- // Assert.That(elementWithoutChildren0, IsEqualTo(elementWithoutChildren1)) always returns true (it defaults`
`193`		`- // to the NUnit IEnumerable comparer, which returns equal cause both don't have child nodes).`
`194`		`- Assert.That(elementAtPosition?.OuterXml, Is.EqualTo(currentElement.OuterXml), $"Expected '{currentElement.Name}' but was '{elementAtPosition.Name}'");`
	`192`	`+ Assert.That(elementAtPosition, Is.EqualTo(currentElement), $"Expected '{currentElement.Name}' but was '{elementAtPosition.Name}'");`
`195`	`193`	`}`
`196`	`194`
`197`	`195`	`return this;`