Add For/Exclude to allow exclusion of members inside a collection

Src/FluentAssertions/Common/MemberPath.cs

@@ -17,6 +17,8 @@ internal class MemberPath
 
         private string[] segments;
 
+        private static readonly MemberPathSegmentEqualityComparer MemberPathSegmentEqualityComparer = new();
+
         public MemberPath(IMember member, string parentPath)
             : this(member.ReflectedType, member.DeclaringType, parentPath.Combine(member.Name))
         {
@@ -53,7 +55,7 @@ public bool IsSameAs(MemberPath candidate)
             {
                 string[] candidateSegments = candidate.Segments;
 
-                return candidateSegments.SequenceEqual(Segments);
+                return candidateSegments.SequenceEqual(Segments, MemberPathSegmentEqualityComparer);
             }
 
             return false;
@@ -64,15 +66,22 @@ private bool IsParentOf(MemberPath candidate)
             string[] candidateSegments = candidate.Segments;
 
             return candidateSegments.Length > Segments.Length &&
-                   candidateSegments.Take(Segments.Length).SequenceEqual(Segments);
+                   candidateSegments.Take(Segments.Length).SequenceEqual(Segments, MemberPathSegmentEqualityComparer);
         }
 
         private bool IsChildOf(MemberPath candidate)
         {
             string[] candidateSegments = candidate.Segments;
 
             return candidateSegments.Length < Segments.Length
-                   && candidateSegments.SequenceEqual(Segments.Take(candidateSegments.Length));
+                   && candidateSegments.SequenceEqual(Segments.Take(candidateSegments.Length),
+                       MemberPathSegmentEqualityComparer);
+        }
+
+        public MemberPath Join(MemberPath nextPath, string separator)
+        {
+            var extendedDottedPath = dottedPath.Combine(nextPath.dottedPath, separator);
+            return new MemberPath(declaringType, nextPath.reflectedType, extendedDottedPath);
         }
 
         /// <summary>
@@ -86,7 +95,7 @@ public bool IsEquivalentTo(string path)
         public bool HasSameParentAs(MemberPath path)
         {
             return Segments.Length == path.Segments.Length
-                   && GetParentSegments().SequenceEqual(path.GetParentSegments());
+                   && GetParentSegments().SequenceEqual(path.GetParentSegments(), MemberPathSegmentEqualityComparer);
         }
 
         private IEnumerable<string> GetParentSegments() => Segments.Take(Segments.Length - 1);
@@ -96,6 +105,11 @@ public bool HasSameParentAs(MemberPath path)
         /// </summary>
         public bool GetContainsSpecificCollectionIndex() => dottedPath.ContainsSpecificCollectionIndex();
 
+        private string[] Segments =>
+            segments ??= dottedPath
+                .Replace("[]", "[*]", StringComparison.Ordinal)
+                .Split(new[] { '.', '[', ']' }, StringSplitOptions.RemoveEmptyEntries);
+
         /// <summary>
         /// Returns a copy of the current object as if it represented an un-indexed item in a collection.
         /// </summary>
@@ -104,8 +118,6 @@ public MemberPath WithCollectionAsRoot()
             return new MemberPath(reflectedType, declaringType, "[]." + dottedPath);
         }
 
-        private string[] Segments => segments ??= dottedPath.Split(new[] { '.', '[', ']' }, StringSplitOptions.RemoveEmptyEntries);
-
         /// <summary>
         /// Returns the name of the member the current path points to without its parent path.
         /// </summary>

Src/FluentAssertions/Common/MemberPathSegmentEqualityComparer.cs

@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace FluentAssertions.Common
+{
+    /// <summary>
+    /// Compares two segments of a <see cref="MemberPath"/>.
+    /// Sets the <see cref="AnyIndexQualifier"/> equal with any numeric index qualifier.
+    /// All other comparisons are default string equality.
+    /// </summary>
+    internal class MemberPathSegmentEqualityComparer : IEqualityComparer<string>
+    {
+        private const string AnyIndexQualifier = "*";
+        private static readonly Regex IndexQualifierRegex = new(@"^\d+$");
+
+        /// <summary>
+        /// Compares two segments of a <see cref="MemberPath"/>.
+        /// </summary>
+        /// <param name="x">Left part of the comparison.</param>
+        /// <param name="y">Right part of the comparison.</param>
+        /// <returns>True if segments are equal, false if not.</returns>
+        public bool Equals(string x, string y)
+        {
+            if (x is null || y is null)
+            {
+                return x == y;
+            }
+
+            if (x == AnyIndexQualifier)
+            {
+                return EqualsAnyIndexQualifier(y);
+            }
+
+            if (y == AnyIndexQualifier)
+            {
+                return EqualsAnyIndexQualifier(x);
+            }
+
+            return x == y;
+        }
+
+        private static bool EqualsAnyIndexQualifier(string segment)
+            => segment == AnyIndexQualifier || IndexQualifierRegex.IsMatch(segment);
+
+        public int GetHashCode(string obj)
+        {
+#if NETCOREAPP2_1_OR_GREATER
+            return obj.GetHashCode(System.StringComparison.Ordinal);
+#else
+            return obj.GetHashCode();
+#endif
+        }
+    }
+}

Src/FluentAssertions/Equivalency/EquivalencyAssertionOptions.cs

@@ -2,7 +2,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq.Expressions;
 using FluentAssertions.Common;
 using FluentAssertions.Equivalency.Execution;
@@ -40,6 +39,16 @@ public EquivalencyAssertionOptions<TExpectation> Excluding(Expression<Func<TExpe
             return this;
         }
 
+        /// <summary>
+        /// Selects a collection to define exclusions at.
+        /// Allows to navigate deeper by using <see cref="For{TNext}"/>.
+        /// </summary>
+        public NestedExclusionOptionBuilder<TExpectation, TNext> For<TNext>(Expression<Func<TExpectation, IEnumerable<TNext>>> expression)
+        {
+            var selectionRule = new ExcludeMemberByPathSelectionRule(expression.GetMemberPath());
+            return new NestedExclusionOptionBuilder<TExpectation, TNext>(this, selectionRule);
+        }
+
         /// <summary>
         /// Includes the specified member in the equality check.
         /// </summary>

Src/FluentAssertions/Equivalency/NestedExclusionOptionBuilder.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using FluentAssertions.Common;
+using FluentAssertions.Equivalency.Selection;
+
+namespace FluentAssertions.Equivalency
+{
+    public class NestedExclusionOptionBuilder<TExpectation, TCurrent> : EquivalencyAssertionOptions<TExpectation>
+    {
+        /// <summary>
+        /// The selected path starting at the first <see cref="EquivalencyAssertionOptions{TExpectation}.For{TNext}"/>.
+        /// </summary>
+        private readonly ExcludeMemberByPathSelectionRule currentPathSelectionRule;
+
+        internal NestedExclusionOptionBuilder(EquivalencyAssertionOptions<TExpectation> equivalencyAssertionOptions,
+            ExcludeMemberByPathSelectionRule currentPathSelectionRule)
+            : base(equivalencyAssertionOptions)
+        {
+            this.currentPathSelectionRule = currentPathSelectionRule;
+        }
+
+        /// <summary>
+        /// Selects a nested property to exclude. This ends the <see cref="For{TNext}"/> chain.
+        /// </summary>
+        public EquivalencyAssertionOptions<TExpectation> Exclude(Expression<Func<TCurrent, object>> expression)
+        {
+            var nextPath = expression.GetMemberPath();
+            currentPathSelectionRule.AppendPath(nextPath);
+            AddSelectionRule(currentPathSelectionRule);
+            return this;
+        }
+
+        /// <summary>
+        /// Adds the selected collection to the <see cref="For{TNext}"/> chain.
+        /// </summary>
+        public NestedExclusionOptionBuilder<TExpectation, TNext> For<TNext>(
+            Expression<Func<TCurrent, IEnumerable<TNext>>> expression)
+        {
+            var nextPath = expression.GetMemberPath();
+            currentPathSelectionRule.AppendPath(nextPath);
+            return new NestedExclusionOptionBuilder<TExpectation, TNext>(this, currentPathSelectionRule);
+        }
+    }
+}

Src/FluentAssertions/Equivalency/Selection/ExcludeMemberByPathSelectionRule.cs

@@ -8,7 +8,7 @@ namespace FluentAssertions.Equivalency.Selection
     /// </summary>
     internal class ExcludeMemberByPathSelectionRule : SelectMemberByPathSelectionRule
     {
-        private readonly MemberPath memberToExclude;
+        private MemberPath memberToExclude;
 
         public ExcludeMemberByPathSelectionRule(MemberPath pathToExclude)
             : base(pathToExclude.ToString())
@@ -23,6 +23,12 @@ public ExcludeMemberByPathSelectionRule(MemberPath pathToExclude)
                 memberToExclude.IsSameAs(new MemberPath(member, parentPath)));
         }
 
+        public void AppendPath(MemberPath nextPath)
+        {
+            memberToExclude = memberToExclude.Join(nextPath, "[]");
+            SetSelectedPath(memberToExclude.ToString());
+        }
+
         public override string ToString()
         {
             return "Exclude member " + memberToExclude;

Src/FluentAssertions/Equivalency/Selection/SelectMemberByPathSelectionRule.cs

@@ -7,7 +7,7 @@ namespace FluentAssertions.Equivalency.Selection
 {
     internal abstract class SelectMemberByPathSelectionRule : IMemberSelectionRule
     {
-        private readonly string selectedPath;
+        private string selectedPath;
 
         protected SelectMemberByPathSelectionRule(string selectedPath)
         {
@@ -16,6 +16,11 @@ protected SelectMemberByPathSelectionRule(string selectedPath)
 
         public virtual bool IncludesMembers => false;
 
+        protected void SetSelectedPath(string path)
+        {
+            this.selectedPath = path;
+        }
+
         public IEnumerable<IMember> SelectMembers(INode currentNode, IEnumerable<IMember> selectedMembers,
             MemberSelectionContext context)
         {

Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt

@@ -757,6 +757,7 @@ namespace FluentAssertions.Equivalency
         public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<System.Collections.Generic.IEnumerable<TExpectation>> AsCollection() { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Excluding(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expression) { }
+        public FluentAssertions.Equivalency.NestedExclusionOptionBuilder<TExpectation, TNext> For<TNext>(System.Linq.Expressions.Expression<System.Func<TExpectation, System.Collections.Generic.IEnumerable<TNext>>> expression) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Including(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expression) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> WithMapping(string expectationMemberPath, string subjectMemberPath) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> WithMapping<TSubject>(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expectationMemberPath, System.Linq.Expressions.Expression<System.Func<TSubject, object>> subjectMemberPath) { }
@@ -921,6 +922,11 @@ namespace FluentAssertions.Equivalency
         Internal = 1,
         Public = 2,
     }
+    public class NestedExclusionOptionBuilder<TExpectation, TCurrent> : FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation>
+    {
+        public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Exclude(System.Linq.Expressions.Expression<System.Func<TCurrent, object>> expression) { }
+        public FluentAssertions.Equivalency.NestedExclusionOptionBuilder<TExpectation, TNext> For<TNext>(System.Linq.Expressions.Expression<System.Func<TCurrent, System.Collections.Generic.IEnumerable<TNext>>> expression) { }
+    }
     public class Node : FluentAssertions.Equivalency.INode
     {
         public Node() { }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/net6.0.verified.txt

@@ -769,6 +769,7 @@ namespace FluentAssertions.Equivalency
         public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<System.Collections.Generic.IEnumerable<TExpectation>> AsCollection() { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Excluding(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expression) { }
+        public FluentAssertions.Equivalency.NestedExclusionOptionBuilder<TExpectation, TNext> For<TNext>(System.Linq.Expressions.Expression<System.Func<TExpectation, System.Collections.Generic.IEnumerable<TNext>>> expression) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Including(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expression) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> WithMapping(string expectationMemberPath, string subjectMemberPath) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> WithMapping<TSubject>(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expectationMemberPath, System.Linq.Expressions.Expression<System.Func<TSubject, object>> subjectMemberPath) { }
@@ -933,6 +934,11 @@ namespace FluentAssertions.Equivalency
         Internal = 1,
         Public = 2,
     }
+    public class NestedExclusionOptionBuilder<TExpectation, TCurrent> : FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation>
+    {
+        public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Exclude(System.Linq.Expressions.Expression<System.Func<TCurrent, object>> expression) { }
+        public FluentAssertions.Equivalency.NestedExclusionOptionBuilder<TExpectation, TNext> For<TNext>(System.Linq.Expressions.Expression<System.Func<TCurrent, System.Collections.Generic.IEnumerable<TNext>>> expression) { }
+    }
     public class Node : FluentAssertions.Equivalency.INode
     {
         public Node() { }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt

@@ -757,6 +757,7 @@ namespace FluentAssertions.Equivalency
         public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<System.Collections.Generic.IEnumerable<TExpectation>> AsCollection() { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Excluding(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expression) { }
+        public FluentAssertions.Equivalency.NestedExclusionOptionBuilder<TExpectation, TNext> For<TNext>(System.Linq.Expressions.Expression<System.Func<TExpectation, System.Collections.Generic.IEnumerable<TNext>>> expression) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Including(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expression) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> WithMapping(string expectationMemberPath, string subjectMemberPath) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> WithMapping<TSubject>(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expectationMemberPath, System.Linq.Expressions.Expression<System.Func<TSubject, object>> subjectMemberPath) { }
@@ -921,6 +922,11 @@ namespace FluentAssertions.Equivalency
         Internal = 1,
         Public = 2,
     }
+    public class NestedExclusionOptionBuilder<TExpectation, TCurrent> : FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation>
+    {
+        public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Exclude(System.Linq.Expressions.Expression<System.Func<TCurrent, object>> expression) { }
+        public FluentAssertions.Equivalency.NestedExclusionOptionBuilder<TExpectation, TNext> For<TNext>(System.Linq.Expressions.Expression<System.Func<TCurrent, System.Collections.Generic.IEnumerable<TNext>>> expression) { }
+    }
     public class Node : FluentAssertions.Equivalency.INode
     {
         public Node() { }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt

@@ -757,6 +757,7 @@ namespace FluentAssertions.Equivalency
         public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<System.Collections.Generic.IEnumerable<TExpectation>> AsCollection() { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Excluding(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expression) { }
+        public FluentAssertions.Equivalency.NestedExclusionOptionBuilder<TExpectation, TNext> For<TNext>(System.Linq.Expressions.Expression<System.Func<TExpectation, System.Collections.Generic.IEnumerable<TNext>>> expression) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Including(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expression) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> WithMapping(string expectationMemberPath, string subjectMemberPath) { }
         public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> WithMapping<TSubject>(System.Linq.Expressions.Expression<System.Func<TExpectation, object>> expectationMemberPath, System.Linq.Expressions.Expression<System.Func<TSubject, object>> subjectMemberPath) { }
@@ -921,6 +922,11 @@ namespace FluentAssertions.Equivalency
         Internal = 1,
         Public = 2,
     }
+    public class NestedExclusionOptionBuilder<TExpectation, TCurrent> : FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation>
+    {
+        public FluentAssertions.Equivalency.EquivalencyAssertionOptions<TExpectation> Exclude(System.Linq.Expressions.Expression<System.Func<TCurrent, object>> expression) { }
+        public FluentAssertions.Equivalency.NestedExclusionOptionBuilder<TExpectation, TNext> For<TNext>(System.Linq.Expressions.Expression<System.Func<TCurrent, System.Collections.Generic.IEnumerable<TNext>>> expression) { }
+    }
     public class Node : FluentAssertions.Equivalency.INode
     {
         public Node() { }