Fix #121: Implementation of IElement Extensions method, including operation

Author: antoineatstariongroup

SysML2.NET.Tests/Extend/ElementExtensionsTestFixture.cs

@@ -21,10 +21,10 @@
 namespace SysML2.NET.Tests.Extend
 {
     using System;
-    using System.Linq;
 
     using NUnit.Framework;
 
+    using SysML2.NET.Core.POCO.Kernel.Packages;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
     using SysML2.NET.Core.POCO.Root.Namespaces;
@@ -43,7 +43,7 @@ public void VerifyComputeDocumentation()
             var documentation = new Documentation();
             var annotation = new Annotation();
 
-            Assert.That(() => element.ComputeDocumentation(), Has.Count.EqualTo(0));
+            Assert.That(element.ComputeDocumentation, Has.Count.EqualTo(0));
 
             element.AssignOwnership(annotation, documentation);
 
@@ -61,16 +61,16 @@ public void VerifyComputeIsLibraryElement()
 
             using (Assert.EnterMultipleScope())
             {
-                Assert.That(() => element.ComputeIsLibraryElement(), Is.False);
-                Assert.That(() => documentation.ComputeIsLibraryElement(), Is.False);
+                Assert.That(element.ComputeIsLibraryElement, Is.False);
+                Assert.That(documentation.ComputeIsLibraryElement, Is.False);
             }
 
             element.AssignOwnership(annotation, documentation);
 
             using (Assert.EnterMultipleScope())
             {
-                Assert.That(() =>element.ComputeIsLibraryElement(), Is.False);
-                Assert.That(() => documentation.ComputeIsLibraryElement(), Throws.TypeOf<NotSupportedException>());
+                Assert.That(element.ComputeIsLibraryElement, Is.False);
+                Assert.That(documentation.ComputeIsLibraryElement, Throws.TypeOf<NotSupportedException>());
             }
         }
 
@@ -81,10 +81,10 @@ public void VerifyComputeName()
 
             var element = new Definition();
 
-            Assert.That(() => element.ComputeName(), Is.Null);
+            Assert.That(element.ComputeName, Is.Null);
 
             element.DeclaredName = "definitionName";
-            Assert.That(() => element.ComputeName(), Is.EqualTo("definitionName"));
+            Assert.That(element.ComputeName, Is.EqualTo("definitionName"));
         }
 
         [Test]
@@ -96,10 +96,10 @@ public void VerifyComputeOwnedAnnotation()
             var documentation = new Documentation();
             var annotation = new Annotation();
             element.AssignOwnership(annotation, documentation);
-            Assert.That(() => element.ComputeOwnedAnnotation(), Has.Count.EqualTo(0));
+            Assert.That(element.ComputeOwnedAnnotation, Has.Count.EqualTo(0));
 
             annotation.AnnotatedElement =  element;
-            Assert.That(() => element.ComputeOwnedAnnotation(), Is.EquivalentTo([annotation]));
+            Assert.That(element.ComputeOwnedAnnotation, Is.EquivalentTo([annotation]));
         }
 
         [Test]
@@ -110,10 +110,10 @@ public void VerifyComputeOwnedElement()
             var element = new Definition();
             var documentation = new Documentation();
             var annotation = new Annotation();
-            Assert.That(() => element.ComputeOwnedElement(), Has.Count.EqualTo(0));
+            Assert.That(element.ComputeOwnedElement, Has.Count.EqualTo(0));
 
             element.AssignOwnership(annotation, documentation);
-            Assert.That(() => element.ComputeDocumentation(), Is.EquivalentTo([documentation]));
+            Assert.That(element.ComputeDocumentation, Is.EquivalentTo([documentation]));
         }
 
         [Test]
@@ -127,16 +127,16 @@ public void VerifyComputeOwner()
 
             using (Assert.EnterMultipleScope())
             {
-                Assert.That(() => element.ComputeOwner(), Is.Null);
-                Assert.That(() => documentation.ComputeOwner(), Is.Null);
+                Assert.That(element.ComputeOwner, Is.Null);
+                Assert.That(documentation.ComputeOwner, Is.Null);
             }
 
             element.AssignOwnership(annotation, documentation);
 
             using (Assert.EnterMultipleScope())
             {
-                Assert.That(() => element.ComputeOwner(), Is.Null);
-                Assert.That(() => documentation.ComputeOwner(), Is.EqualTo(element));
+                Assert.That(element.ComputeOwner, Is.Null);
+                Assert.That(documentation.ComputeOwner, Is.EqualTo(element));
             }        
         }
 
@@ -149,21 +149,21 @@ public void VerifyComputeOwningMembership()
             var documentation = new Documentation();
             var annotation = new Annotation();
 
-            Assert.That(() => documentation.ComputeOwningMembership(), Is.Null);
+            Assert.That(documentation.ComputeOwningMembership, Is.Null);
 
             element.AssignOwnership(annotation, documentation);
 
             using (Assert.EnterMultipleScope())
             {
-                Assert.That(() => documentation.ComputeOwningMembership(), Is.Null);
-                Assert.That(() => element.ComputeOwningMembership(), Is.Null);
+                Assert.That(documentation.ComputeOwningMembership, Is.Null);
+                Assert.That(element.ComputeOwningMembership, Is.Null);
             }
 
             var membership = new OwningMembership();
             var namespaceElement = new Namespace();
 
             namespaceElement.AssignOwnership(membership, element);
-            Assert.That(() => element.ComputeOwningMembership(), Is.EqualTo(membership));
+            Assert.That(element.ComputeOwningMembership, Is.EqualTo(membership));
         }
 
         [Test]
@@ -176,12 +176,12 @@ public void VerifyComputeOwningNamespace()
             var annotation = new Annotation();
             element.AssignOwnership(annotation, documentation);
 
-            Assert.That(() => documentation.ComputeOwningNamespace(), Is.Null);
+            Assert.That(documentation.ComputeOwningNamespace, Is.Null);
             var membership = new OwningMembership();
             var namespaceElement = new Namespace();
 
             namespaceElement.AssignOwnership(membership, element);
-            Assert.That(() => element.ComputeOwningNamespace(), Is.EqualTo(namespaceElement));
+            Assert.That(element.ComputeOwningNamespace, Is.EqualTo(namespaceElement));
         }
 
         [Test]
@@ -191,15 +191,43 @@ public void VerifyComputeQualifiedName()
 
             var element = new Definition();
 
-            Assert.That(() => element.ComputeQualifiedName(), Is.Null);
+            Assert.That(element.ComputeQualifiedName, Is.Null);
 
             var membership = new OwningMembership();
+            var secondMembership = new OwningMembership();
+
             var namespaceElement = new Namespace();
 
             namespaceElement.AssignOwnership(membership, element);
             element.DeclaredName = "name";
+            
+            Assert.That(element.ComputeQualifiedName, Is.EqualTo("name"));
+            
+            var secondElement = new Definition()
+            {
+                DeclaredName = "name"
+            };
+            
+            namespaceElement.AssignOwnership(secondMembership, secondElement);
+            
+            using (Assert.EnterMultipleScope())
+            {
+                Assert.That(element.ComputeQualifiedName, Is.EqualTo("name"));
+                Assert.That(secondElement.ComputeQualifiedName, Is.Null);
+            }
+
+            var packageOwner = new Package()
+            {
+                DeclaredName = "owner"
+            };
 
-            Assert.That(() => element.ComputeQualifiedName(), Is.EqualTo("name"));
+            var packageMembership = new OwningMembership();
+            packageOwner.AssignOwnership(packageMembership, namespaceElement);
+            
+            Assert.That(element.ComputeQualifiedName, Is.Null);
+
+            namespaceElement.DeclaredName = "namespace";
+            Assert.That(element.ComputeQualifiedName, Is.EqualTo("namespace::name"));
         }
 
         [Test]
@@ -209,10 +237,10 @@ public void VerifyComputeShortName()
 
             var element = new Definition();
 
-            Assert.That(() =>  element.ComputeShortName(), Is.Null);
+            Assert.That(element.ComputeShortName, Is.Null);
 
             element.DeclaredShortName = "shortName";
-            Assert.That(() =>  element.ComputeShortName(), Is.EqualTo("shortName"));
+            Assert.That(element.ComputeShortName, Is.EqualTo("shortName"));
         }
 
         [Test]
@@ -224,11 +252,61 @@ public void VerifyComputeTextualRepresentation()
             var textualRepresentation = new TextualRepresentation();
             var annotation = new Annotation();
 
-            Assert.That(() => element.ComputeTextualRepresentation(), Has.Count.EqualTo(0));
+            Assert.That(element.ComputeTextualRepresentation, Has.Count.EqualTo(0));
 
             element.AssignOwnership(annotation, textualRepresentation);
 
             Assert.That(element.ComputeTextualRepresentation(), Is.EquivalentTo([textualRepresentation]));
         }
+
+        [Test]
+        public void VerifyComputePathOperation()
+        {
+            Assert.That(() => ((IElement)null).ComputePathOperation(), Throws.TypeOf<ArgumentNullException>());
+            
+            var element = new Definition();
+
+            Assert.That(element.ComputePathOperation, Is.Empty);
+            element.DeclaredName = "name";
+
+            Assert.That(element.ComputePathOperation, Is.Empty);
+            
+            var membership = new OwningMembership();
+            var secondMembership = new OwningMembership();
+            var namespaceElement = new Namespace();
+            
+            namespaceElement.AssignOwnership(membership, element);
+            
+            Assert.That(element.ComputePathOperation, Is.EqualTo("name"));
+
+            var secondElement = new Definition()
+            {
+                DeclaredName = "name"
+            };
+            
+            namespaceElement.AssignOwnership(secondMembership, secondElement);
+
+            using (Assert.EnterMultipleScope())
+            {
+                Assert.That(element.ComputePathOperation, Is.EqualTo("name"));
+                Assert.That(secondElement.ComputePathOperation, Throws.TypeOf<NotSupportedException>());
+            }
+        }
+
+        [Test]
+        public void VerifyComputeEscapedNameOperation()
+        {
+            Assert.That(() => ((IElement)null).ComputeEscapedNameOperation(), Throws.TypeOf<ArgumentNullException>());
+
+            var element = new Definition()
+            {
+                DeclaredName = "basic"
+            };
+
+            Assert.That(element.ComputeEscapedNameOperation, Is.EqualTo("basic"));
+
+            element.DeclaredName = "non basic";
+            Assert.That(element.ComputeEscapedNameOperation, Is.EqualTo("\'non basic\'"));
+        }
     }
 }

SysML2.NET.Tests/Extend/MembershipExtensionsTestFixture.cs

@@ -38,7 +38,7 @@ public void ComputeMemberElementId_ThrowsNotSupportedException()
         [Test]
         public void ComputeMembershipOwningNamespace_ThrowsNotSupportedException()
         {
-            Assert.That(() => ((IMembership)null).ComputeMembershipOwningNamespace(), Throws.TypeOf<NotSupportedException>());
+            Assert.That(() => ((IMembership)null).ComputeMembershipOwningNamespace(), Throws.TypeOf<ArgumentNullException>());
         }
     }
 }

SysML2.NET.Tests/Extend/OwningMembershipExtensionsTestFixture.cs

@@ -32,7 +32,7 @@ public class OwningMembershipExtensionsTestFixture
         [Test]
         public void ComputeOwnedMemberElement_ThrowsNotSupportedException()
         {
-            Assert.That(() => ((IOwningMembership)null).ComputeOwnedMemberElement(), Throws.TypeOf<NotSupportedException>());
+            Assert.That(() => ((IOwningMembership)null).ComputeOwnedMemberElement(), Throws.TypeOf<ArgumentNullException>());
         }
 
         [Test]
@@ -44,7 +44,7 @@ public void ComputeOwnedMemberElementId_ThrowsNotSupportedException()
         [Test]
         public void ComputeOwnedMemberName_ThrowsNotSupportedException()
         {
-            Assert.That(() => ((IOwningMembership)null).ComputeOwnedMemberName(), Throws.TypeOf<NotSupportedException>());
+            Assert.That(() => ((IOwningMembership)null).ComputeOwnedMemberName(), Throws.TypeOf<ArgumentNullException>());
         }
 
         [Test]

SysML2.NET/Extend/ElementExtensions.cs

@@ -336,7 +336,7 @@ internal static string ComputePathOperation(this IElement elementSubject)
             var ownedRelatedElementsIndex =  elementSubject.OwningRelationship.OwnedRelatedElement.ToList().IndexOf(elementSubject) +1;
             var parentPath = elementSubject.OwningRelationship.Path();
 
-            return string.IsNullOrWhiteSpace(parentPath) ? $"/{ownedRelatedElementsIndex}": $"{parentPath}/{ownedRelatedElementsIndex}";
+            return $"{parentPath}/{ownedRelatedElementsIndex}";
         }
     }
 }

SysML2.NET/Extend/NamespaceExtensions.cs

@@ -21,6 +21,7 @@
 namespace SysML2.NET.Core.POCO.Root.Namespaces
 {
     using System;
+    using System.Collections.Frozen;
     using System.Collections.Generic;
     using System.Linq;
 
@@ -46,7 +47,7 @@ internal static class NamespaceExtensions
         [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         internal static List<IMembership> ComputeImportedMembership(this INamespace namespaceSubject)
         {
-            return namespaceSubject == null ? throw new ArgumentNullException(nameof(namespaceSubject)) : namespaceSubject.ImportedMemberships((INamespace)null);
+            return namespaceSubject == null ? throw new ArgumentNullException(nameof(namespaceSubject)) : namespaceSubject.ImportedMemberships([]);
         }
 
         /// <summary>
@@ -88,10 +89,9 @@ internal static List<IMembership> ComputeMembership(this INamespace namespaceSub
         /// <returns>
         /// the computed result
         /// </returns>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         internal static List<IImport> ComputeOwnedImport(this INamespace namespaceSubject)
         {
-            throw new NotSupportedException("Create a GitHub issue when this method is required");
+            return namespaceSubject == null ? throw new ArgumentNullException(nameof(namespaceSubject)) : [..namespaceSubject.OwnedRelationship.OfType<IImport>()];
         }
 
         /// <summary>
@@ -204,10 +204,30 @@ internal static List<IMembership> ComputeVisibleMembershipsOperation(this INames
         /// <returns>
         /// The expected collection of <see cref="IMembership" />
         /// </returns>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         internal static List<IMembership> ComputeImportedMembershipsOperation(this INamespace namespaceSubject, List<INamespace> excluded)
         {
-            throw new NotSupportedException("Create a GitHub issue when this method is required");
+            var importedMemberships = namespaceSubject.ownedImport.Where(x => !excluded.Contains(x.importOwningNamespace))
+                .SelectMany(x => x.ImportedMemberships(excluded))
+                .Distinct()
+                .ToList();
+            
+            var ownedMembershipNames = namespaceSubject.ownedMembership
+                .Select(m => m.MemberName)
+                .Where(name => name != null)
+                .ToHashSet(StringComparer.Ordinal);
+            
+            var importedMembershipsNameFrequency = importedMemberships
+                .GroupBy(x => x.MemberName, StringComparer.Ordinal)
+                .ToFrozenDictionary(g => g.Key, g => g.Count(),  StringComparer.Ordinal);
+
+            var nonCollidingImportedMemberships = importedMemberships.Where(x =>
+            {
+                var name = x.MemberName;
+
+                return !string.IsNullOrWhiteSpace(name) && !ownedMembershipNames.Contains(name) && (!importedMembershipsNameFrequency.TryGetValue(name, out var frequency) || frequency <= 1);
+            }).ToList();
+            
+            return nonCollidingImportedMemberships;
         }
 
         /// <summary>

SysML2.NET/Extend/OwningMembershipExtensions.cs

@@ -43,10 +43,9 @@ internal static class OwningMembershipExtensions
         /// <returns>
         /// the computed result
         /// </returns>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         internal static IElement ComputeOwnedMemberElement(this IOwningMembership owningMembershipSubject)
         {
-            return owningMembershipSubject == null ? throw new ArgumentNullException(nameof(owningMembershipSubject)) : owningMembershipSubject.OwnedRelatedElement.SingleOrDefault();
+            return owningMembershipSubject == null ? throw new ArgumentNullException(nameof(owningMembershipSubject)) : owningMembershipSubject.OwnedRelatedElement.Single();
         }
 
         /// <summary>
@@ -73,10 +72,9 @@ internal static string ComputeOwnedMemberElementId(this IOwningMembership owning
         /// <returns>
         /// the computed result
         /// </returns>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         internal static string ComputeOwnedMemberName(this IOwningMembership owningMembershipSubject)
         {
-            throw new NotSupportedException("Create a GitHub issue when this method is required");
+            return owningMembershipSubject == null ? throw new ArgumentNullException(nameof(owningMembershipSubject)) : owningMembershipSubject.ownedMemberElement.name;
         }
 
         /// <summary>