Generate equality for array properties

mjul · mjul · commit 10c762ea5cb3 · 2013-06-18T15:39:53.000+02:00
diff --git a/Diesel.sln b/Diesel.sln
@@ -10,6 +10,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		CHANGELOG.md = CHANGELOG.md
 		LICENSE.txt = LICENSE.txt
 		README.md = README.md
+		TODO.md = TODO.md
 	EndProjectSection
 EndProject
 Global
diff --git a/Diesel/CodeGeneration/CodeDomGenerator.cs b/Diesel/CodeGeneration/CodeDomGenerator.cs
@@ -195,12 +195,7 @@ private static CodeTypeMember[] CreateEqualsOverloadingUsingEqualityOperator(str
             };
 
             var compareExpressions = from property in properties
-                                     select new CodeBinaryOperatorExpression(
-                                         new CodePropertyReferenceExpression(
-                                             new CodeThisReferenceExpression(), property.Name),
-                                         CodeBinaryOperatorType.ValueEquality,
-                                         new CodePropertyReferenceExpression(
-                                             new CodeVariableReferenceExpression("other"), property.Name));
+                                     select EqualityMethodsGenerator.ComparePropertyValueEqualityExpression(property, "other");
 
             var nullGuardSeed = isValueType
                                     ? (CodeExpression) new CodePrimitiveExpression(true)
@@ -231,6 +226,8 @@ private static CodeTypeMember[] CreateEqualsOverloadingUsingEqualityOperator(str
             return new CodeTypeMember[] { equalsTyped, equalsObject };
         }
 
+
+        
         private static CodeMethodInvokeExpression CreateTypeIsAssignableFrom(string typeName, CodeExpression instanceExpression)
         {
             // typeof(typeName).IsAssignableFrom(instanceExpression.GetType())
diff --git a/Diesel/CodeGeneration/EqualityMethodsGenerator.cs b/Diesel/CodeGeneration/EqualityMethodsGenerator.cs
@@ -0,0 +1,121 @@
+﻿using System;
+using System.CodeDom;
+using System.Linq;
+using Diesel.Parsing;
+using Diesel.Parsing.CSharp;
+
+namespace Diesel.CodeGeneration
+{
+    public class EqualityMethodsGenerator
+    {
+        /// <summary>
+        /// Produce an expression that compares two properties by value.
+        /// </summary>
+        public static CodeExpression ComparePropertyValueEqualityExpression(PropertyDeclaration property, string otherVariableName)
+        {
+            return ComparePropertyValueEqualityExpression((dynamic)property.Type, property.Name, otherVariableName);
+        }
+
+        private static CodeBinaryOperatorExpression ComparePropertyValueEqualityExpression(SimpleType propertyType, String propertyName, String otherVariableName)
+        {
+            return CompareValueEquality(propertyName, otherVariableName);
+        }
+
+        private static CodeBinaryOperatorExpression ComparePropertyValueEqualityExpression(StringReferenceType propertyType, String propertyName, String otherVariableName)
+        {
+            return CompareValueEquality(propertyName, otherVariableName);
+        }
+
+        /// <summary>
+        /// this.PropertyName == other.PropertyName
+        /// </summary>
+        private static CodeBinaryOperatorExpression CompareValueEquality(string propertyName, string otherVariableName)
+        {
+            return new CodeBinaryOperatorExpression(
+                ThisPropertyReference(propertyName),
+                CodeBinaryOperatorType.ValueEquality,
+                OtherPropertyReference(propertyName, otherVariableName));
+        }
+
+        /// <summary>
+        /// Object.Equals(a.Property, b.Property)
+        /// </summary>
+        private static CodeExpression CompareObjectEquality(string propertyName, string otherVariableName)
+        {
+            return new CodeMethodInvokeExpression(
+                new CodeTypeReferenceExpression(typeof (Object)),
+                "Equals",
+                ThisPropertyReference(propertyName),
+                OtherPropertyReference(propertyName, otherVariableName));
+        }
+
+        private static CodeBinaryOperatorExpression ComparePropertyValueEqualityExpression(NullableType propertyType, String propertyName, String otherVariableName)
+        {
+            return CompareValueEquality(propertyName, otherVariableName);
+        }
+
+        /// <summary>
+        /// (this.Property.Length == other.Property.Length) 
+        ///  && Enumerable.Zip(a, b, (a, b) => a == b).All(areEqual => areEqual);
+        /// </summary>
+        private static CodeBinaryOperatorExpression ComparePropertyValueEqualityExpression(ArrayType propertyType,
+                                                                                           String propertyName,
+                                                                                           String otherVariableName)
+        {
+            // TODO: this should probably be a warning in the model
+            if (propertyType.RankSpecifiers.Ranks.Count() > 1)
+                throw new InvalidOperationException(
+                    "Cannot generate equality for Array Types with more than one rank-specifier.");
+            var rankSpecifier = propertyType.RankSpecifiers.Ranks.Single();
+            if (rankSpecifier.Dimensions > 1)
+                throw new InvalidOperationException(
+                    "Cannot generate equality for Array Type with more than one dimension");
+
+            // (this.Property.Length == other.Property.Length) 
+            // && Enumerable.Zip(a, b, (a, b) => Object.Equals(a, b)).All(areEqual => areEqual);
+
+            var thisPropertyReference = ThisPropertyReference(propertyName);
+            var otherPropertyReference = OtherPropertyReference(propertyName, otherVariableName);
+
+            var sameArrayLength = new CodeBinaryOperatorExpression(
+                new CodePropertyReferenceExpression(thisPropertyReference, "Length"),
+                CodeBinaryOperatorType.ValueEquality,
+                new CodePropertyReferenceExpression(otherPropertyReference, "Length"));
+
+            var zipExpression = new CodeMethodInvokeExpression(
+                new CodeMethodReferenceExpression(
+                    new CodeTypeReferenceExpression(typeof (System.Linq.Enumerable)),
+                    "Zip"),
+                thisPropertyReference,
+                otherPropertyReference,
+                new CodeSnippetExpression("(a, b) => Object.Equals(a,b)"));
+
+            var zipPairwiseEquality =
+                new CodeMethodInvokeExpression(
+                    new CodeMethodReferenceExpression(
+                        new CodeTypeReferenceExpression(typeof (System.Linq.Enumerable)),
+                        "All"),
+                    zipExpression,
+                    new CodeSnippetExpression("areEqual => areEqual")
+                    );
+
+            return new CodeBinaryOperatorExpression(sameArrayLength,
+                                                    CodeBinaryOperatorType.BooleanAnd, zipPairwiseEquality);
+        }
+
+        private static CodePropertyReferenceExpression OtherPropertyReference(string propertyName, string otherVariableName)
+        {
+            return new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(otherVariableName), propertyName);
+        }
+
+        private static CodePropertyReferenceExpression ThisPropertyReference(string propertyName)
+        {
+            return new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), propertyName);
+        }
+
+        private static CodeExpression ComparePropertyValueEqualityExpression(TypeNameTypeNode propertyType, String propertyName, String otherVariableName)
+        {
+            return CompareObjectEquality(propertyName, otherVariableName);
+        }
+    }
+}
diff --git a/Diesel/Diesel.csproj b/Diesel/Diesel.csproj
@@ -46,6 +46,7 @@
     <Compile Include="CodeGeneration\ApplicationServiceGenerator.cs" />
     <Compile Include="CodeGeneration\CommandGenerator.cs" />
     <Compile Include="CodeGeneration\DomainEventGenerator.cs" />
+    <Compile Include="CodeGeneration\EqualityMethodsGenerator.cs" />
     <Compile Include="CodeGeneration\ReadOnlyProperty.cs" />
     <Compile Include="CodeGeneration\SystemTypeMapper.cs" />
     <Compile Include="CodeGeneration\ValueTypeGenerator.cs" />
diff --git a/TODO.md b/TODO.md
@@ -0,0 +1,24 @@
+# Feature Requests
+
+## Emit verbatim type-name for unknown types
+When a named type does not exist, emit the type name as specified
+rather than failing in the generation step when the corresponding System type 
+has not been found (`CodeDomGenerator`, `SystemTypeMapper`).
+
+## Validate model before generation
+
+### Validate allowed types in DTO types (Commands, Events).
+Commands and Domain events should only be able to have properties that are primitive types,
+arrays of these or other Data Transfer Objects.
+
+### Emit friendly error when code is not generatable 
+E.g. for multi-dimensional arrays in Equality.
+
+
+## Multi-dimensional array equality
+Currently one single-dimensional arrays are supported when generating equality members.
+Implement these, too:
+
+		(namespace TestCases.TypeDeclarations
+			(defcommand PrintArraySimple2D (int[,] Value))
+			(defcommand PrintArraySimpleMulti (int[][,] Value))
diff --git a/Test/CodeGeneration/EqualityMethodsGeneratorTest.cs b/Test/CodeGeneration/EqualityMethodsGeneratorTest.cs
@@ -0,0 +1,57 @@
+﻿using Diesel.CodeGeneration;
+using Diesel.Parsing;
+using Diesel.Parsing.CSharp;
+using NUnit.Framework;
+
+namespace Test.Diesel.CodeGeneration
+{
+    [TestFixture]
+    public class EqualityMethodsGeneratorTest
+    {
+
+        [Test]
+        public void ComparePropertyValueEqualityExpression_StringReferenceType_ShouldGenerateExpression()
+        {
+            var actual = EqualityMethodsGenerator.ComparePropertyValueEqualityExpression(
+                new PropertyDeclaration("Text", new StringReferenceType()), "other");
+            Assert.That(actual, Is.Not.Null);
+        }
+
+        [Test]
+        public void ComparePropertyValueEqualityExpression_SimpleType_ShouldGenerateExpression()
+        {
+            var actual = EqualityMethodsGenerator.ComparePropertyValueEqualityExpression(
+                new PropertyDeclaration("Value", new SimpleType(typeof(decimal))), "other");
+            Assert.That(actual, Is.Not.Null);
+        }
+
+        [Test]
+        public void ComparePropertyValueEqualityExpression_NullableSimpleType_ShouldGenerateExpression()
+        {
+            var actual = EqualityMethodsGenerator.ComparePropertyValueEqualityExpression(
+                new PropertyDeclaration("Value", new NullableType(new SimpleType(typeof(decimal)))), "other");
+            Assert.That(actual, Is.Not.Null);
+        }
+
+        [Test]
+        public void ComparePropertyValueEqualityExpression_NamedDateTime_ShouldGenerateExpression()
+        {
+            var actual = EqualityMethodsGenerator.ComparePropertyValueEqualityExpression(
+                new PropertyDeclaration("Value", new TypeNameTypeNode(new TypeName("System.DateTime"))), "other");
+            Assert.That(actual, Is.Not.Null);
+        }
+
+        [Test]
+        public void ComparePropertyValueEqualityExpression_ArrayType1D_ShouldGenerateExpression()
+        {
+            var actual = EqualityMethodsGenerator.ComparePropertyValueEqualityExpression(
+                new PropertyDeclaration("Value", 
+                    new ArrayType(new SimpleType(typeof(decimal)), 
+                        new RankSpecifiers(new[] {new RankSpecifier(1)}))), 
+                        "other");
+            Assert.That(actual, Is.Not.Null);
+        }
+
+
+    }
+}
diff --git a/Test/Examples/DieselCompilerIntegrationTestCase.txt b/Test/Examples/DieselCompilerIntegrationTestCase.txt
@@ -13,15 +13,13 @@
 	(defcommand PrintInt (int Value))
 	(defcommand PrintNullable (float? Value))
 	(defcommand PrintArraySimple (int[] Value))
-	(defcommand PrintArraySimple2D (int[,] Value))
-	(defcommand PrintArraySimpleMulti (int[][,] Value))
 	(defcommand PrintNullableSimple (decimal? Value))
 	(defcommand PrintString (string Value))
 	(defcommand PrintNamedTypeQualifiedDateTime (System.DateTime Value))
 	(defcommand PrintNamedTypeQualifiedGuid (System.Guid Value))
 	(defcommand PrintNamedTypeUnqualifiedGuid (Guid Value))
 	(defcommand PrintNamedTypeUnqualifiedDecimal (Decimal Value))
-	(defcommand PrintMulti (string Text, int? NullableNumber, int[,] TwoDimArray, decimal Decimal, DateTime When)))
+	(defcommand PrintMulti (string Text, int? NullableNumber, string[] SingleDimArray, decimal Decimal, DateTime When)))
 
 
 (namespace TestCases.Defvaluetype
diff --git a/Test/Generated/Example.dsl b/Test/Generated/Example.dsl
@@ -5,6 +5,8 @@
 	(defvaluetype EmailAddress string)
 	(defvaluetype EmployeeName (string FirstName, string LastName))
 	(defvaluetype EmployeeMetadata (string Source, int? SourceId))
+	(defvaluetype EmployeeRatings (int EmployeeNumber, int[] Ratings))
+	(defvaluetype EmployeeRoles (int EmployeeNumber, string[] Roles))
 	(defdomainevent EmployeeImported (Guid Id, int EmployeeNumber, string FirstName, string LastName, int? SourceId))
 	(defapplicationservice ImportService
 		(defcommand ImportEmployee (Guid CommandId, int EmployeeNumber, string FirstName, string LastName, int? SourceId))
diff --git a/Test/Generated/GenerateExamples.cs b/Test/Generated/GenerateExamples.cs
@@ -194,6 +194,108 @@ public override bool Equals(object obj) {
         }
     }
     
+    [System.SerializableAttribute()]
+    public partial struct EmployeeRatings : System.IEquatable<EmployeeRatings> {
+        
+        private int _employeeNumber;
+        
+        private int[] _ratings;
+        
+        public EmployeeRatings(int employeeNumber, int[] ratings) {
+            this._employeeNumber = employeeNumber;
+            this._ratings = ratings;
+        }
+        
+        public int EmployeeNumber {
+            get {
+                return this._employeeNumber;
+            }
+        }
+        
+        public int[] Ratings {
+            get {
+                return this._ratings;
+            }
+        }
+        
+        public static bool operator ==(EmployeeRatings left, EmployeeRatings right) {
+            return left.Equals(right);
+        }
+        
+        public static bool operator !=(EmployeeRatings left, EmployeeRatings right) {
+            return (false == left.Equals(right));
+        }
+        
+        public override int GetHashCode() {
+            return (0 + this.EmployeeNumber.GetHashCode());
+        }
+        
+        public bool Equals(EmployeeRatings other) {
+            return ((true 
+                        && (this.EmployeeNumber == other.EmployeeNumber)) 
+                        && ((this.Ratings.Length == other.Ratings.Length) 
+                        && System.Linq.Enumerable.All(System.Linq.Enumerable.Zip(this.Ratings, other.Ratings, (a, b) => Object.Equals(a,b)), areEqual => areEqual)));
+        }
+        
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) {
+                return false;
+            }
+            return (typeof(EmployeeRatings).IsAssignableFrom(obj.GetType()) && this.Equals(((EmployeeRatings)(obj))));
+        }
+    }
+    
+    [System.SerializableAttribute()]
+    public partial struct EmployeeRoles : System.IEquatable<EmployeeRoles> {
+        
+        private int _employeeNumber;
+        
+        private string[] _roles;
+        
+        public EmployeeRoles(int employeeNumber, string[] roles) {
+            this._employeeNumber = employeeNumber;
+            this._roles = roles;
+        }
+        
+        public int EmployeeNumber {
+            get {
+                return this._employeeNumber;
+            }
+        }
+        
+        public string[] Roles {
+            get {
+                return this._roles;
+            }
+        }
+        
+        public static bool operator ==(EmployeeRoles left, EmployeeRoles right) {
+            return left.Equals(right);
+        }
+        
+        public static bool operator !=(EmployeeRoles left, EmployeeRoles right) {
+            return (false == left.Equals(right));
+        }
+        
+        public override int GetHashCode() {
+            return (0 + this.EmployeeNumber.GetHashCode());
+        }
+        
+        public bool Equals(EmployeeRoles other) {
+            return ((true 
+                        && (this.EmployeeNumber == other.EmployeeNumber)) 
+                        && ((this.Roles.Length == other.Roles.Length) 
+                        && System.Linq.Enumerable.All(System.Linq.Enumerable.Zip(this.Roles, other.Roles, (a, b) => Object.Equals(a,b)), areEqual => areEqual)));
+        }
+        
+        public override bool Equals(object obj) {
+            if (object.ReferenceEquals(null, obj)) {
+                return false;
+            }
+            return (typeof(EmployeeRoles).IsAssignableFrom(obj.GetType()) && this.Equals(((EmployeeRoles)(obj))));
+        }
+    }
+    
     [System.Runtime.Serialization.DataContractAttribute(Name="EmployeeImported")]
     [System.SerializableAttribute()]
     public sealed partial class EmployeeImported : System.IEquatable<EmployeeImported>, Test.Diesel.IDomainEvent {
@@ -273,7 +375,7 @@ public override int GetHashCode() {
         
         public bool Equals(EmployeeImported other) {
             return ((((((false == object.ReferenceEquals(null, other)) 
-                        && (this.Id == other.Id)) 
+                        && object.Equals(this.Id, other.Id)) 
                         && (this.EmployeeNumber == other.EmployeeNumber)) 
                         && (this.FirstName == other.FirstName)) 
                         && (this.LastName == other.LastName)) 
@@ -374,7 +476,7 @@ public override int GetHashCode() {
         
         public bool Equals(ImportEmployee other) {
             return ((((((false == object.ReferenceEquals(null, other)) 
-                        && (this.CommandId == other.CommandId)) 
+                        && object.Equals(this.CommandId, other.CommandId)) 
                         && (this.EmployeeNumber == other.EmployeeNumber)) 
                         && (this.FirstName == other.FirstName)) 
                         && (this.LastName == other.LastName)) 
diff --git a/Test/GeneratedValueTypeWithArrayTest.cs b/Test/GeneratedValueTypeWithArrayTest.cs
diff --git a/Test/Test.csproj b/Test/Test.csproj
