[Add] QueryInterestingClasses method and refactor Inspect; fixes #88

Author: samatstariongroup

uml4net.Reporting.Tests/Generators/ModelInspectorTestFixture.cs

@@ -48,8 +48,8 @@ public class ModelInspectorTestFixture
 
         private FileInfo reportFileInfo;
 
-        [OneTimeSetUp]
-        public void OneTimeSetUp()
+        [SetUp]
+        public void SetUp()
         {
             Log.Logger = new LoggerConfiguration()
                 .MinimumLevel.Verbose()
@@ -60,11 +60,7 @@ public void OneTimeSetUp()
             {
                 builder.AddSerilog();
             });
-        }
 
-        [SetUp]
-        public void SetUp()
-        {
             this.modelPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "TestData", "UML.xmi");
             this.modelFileInfo = new FileInfo(modelPath);
 
@@ -125,5 +121,37 @@ public void Verify_that_inspect_class_returns_expected_result()
 
             Log.Logger.Information(inspectionReport);
         }
+
+        [Test]
+        public void Verify_that_QueryInterestingClasses_returns_expected_result()
+        {
+            var rootPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "TestData");
+
+            var reader = XmiReaderBuilder.Create()
+                .UsingSettings(x => x.LocalReferenceBasePath = rootPath)
+                .WithLogger(this.loggerFactory)
+                .Build();
+
+            var xmiReaderResult = reader.Read(Path.Combine(rootPath, "UML.xmi"));
+
+            this.modelInspector = new ModelInspector(this.loggerFactory);
+
+            var interestingClasses = this.modelInspector.QueryInterestingClasses(xmiReaderResult.Root);
+
+            var expectedResult = new List<string>
+            {
+                "ActivityGroup", "Association", "Class", "Classifier",
+                "Connector", "CreateLinkAction", "DurationConstraint", "DurationObservation",
+                "Element", "Extension", "ExtensionEnd", "InformationFlow",
+                "LiteralInteger", "LiteralReal", "LiteralUnlimitedNatural", "MultiplicityElement",
+                "NamedElement", "OpaqueExpression", "Operation", "PackageableElement",
+                "RedefinableTemplateSignature","Relationship","TimeConstraint","Transition",
+                "UnmarshallAction"
+            };
+
+            var interestingClassesNames = interestingClasses.Select(x => x.Name);
+
+            Assert.That(interestingClassesNames, Is.EquivalentTo(expectedResult));
+        }
     }
 }

uml4net.Reporting/Generators/IModelInspector.cs

@@ -20,7 +20,11 @@
 
 namespace uml4net.Reporting.Generators
 {
+    using System.Collections.Generic;
+
+    using uml4net.Classification;
     using uml4net.Packages;
+    using uml4net.StructuredClassifiers;
 
     /// <summary>
     /// The purpose of the <see cref="IModelInspector"/> is to iterate through the model and report on the various kinds of
@@ -40,6 +44,19 @@ public interface IModelInspector : IReportGenerator
         /// </returns>
         public string Inspect(IPackage package);
 
+        /// <summary>
+        /// Inspect the content of the provided <see cref="IPackage"/> and returns a
+        /// read-only collection of interesting <see cref="IClass"/>
+        /// </summary>
+        /// <param name="package">
+        /// The <see cref="IPackage"/> that needs to be inspected
+        /// </param>
+        /// <returns>
+        /// A read-only collection of interesting <see cref="IClass"/> that cover the variations
+        /// of <see cref="IProperty"/>> and <see cref="IOperation"/> variations
+        /// </returns>
+        public IReadOnlyCollection<IClass> QueryInterestingClasses(IPackage package);
+
         /// <summary>
         /// Inspect the provided <see cref="IClass"/> (by name) that is contained in the <see cref="IPackage"/>
         /// and returns the variation of data-types, enums and multiplicity as an Analysis report

uml4net.Reporting/Generators/ModelInspector.cs

@@ -24,12 +24,14 @@ namespace uml4net.Reporting.Generators
     using System.Collections.Generic;
     using System.Diagnostics;
     using System.IO;
+    using System.IO.Packaging;
     using System.Linq;
     using System.Text;
 
     using Microsoft.Extensions.Logging;
     using Microsoft.Extensions.Logging.Abstractions;
 
+    using uml4net.Classification;
     using uml4net.CommonStructure;
     using uml4net.Extensions;
     using uml4net.Packages;
@@ -80,12 +82,66 @@ public string QueryReportType()
         /// Returns a report of the classes of interest in the provided package 
         /// </returns>
         public string Inspect(IPackage package)
+        {
+            // Step 1: Map class to property variations
+            var classPropertyVariations = this.MapClassPropertyVariation(package);
+
+            // Step 2: Greedy algorithm to cover all property variations with the fewest classes
+            var result = this.ReduceClassPropertyVariationToInterestingClasses(classPropertyVariations);
+
+            var sb = new StringBuilder();
+
+            sb.AppendLine($"----- PACKAGE {package.Name} ANALYSIS ------");
+            sb.AppendLine("");
+
+            sb.AppendLine("");
+            sb.AppendLine("----- MULTIPLICITY RESULTS ------");
+            sb.AppendLine("");
+
+            var uniqueAndOrderedPropertyVariations = new HashSet<string>(classPropertyVariations.Values.SelectMany(p => p).ToList())
+                .OrderBy(x => x).ToList();
+
+            foreach (var orderedPropertyVariation in uniqueAndOrderedPropertyVariations)
+            {
+                sb.AppendLine(orderedPropertyVariation);
+            }
+
+            sb.AppendLine("");
+            sb.AppendLine("----- INTERESTING CLASSES ------");
+            sb.AppendLine("");
+
+            var orderedClasses = result.OrderBy(x => x.Name).ToList();
+
+            foreach (var @class in orderedClasses)
+            {
+                var isAbstract = "";
+                if (@class.IsAbstract)
+                {
+                    isAbstract = " [Abstract]";
+                }
+
+                sb.AppendLine($"class : {@class.QueryQualifiedName()}{isAbstract}");
+            }
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Map class to property variations
+        /// </summary>
+        /// <param name="package">
+        /// The <see cref="IPackage"/> that needs to be inspected
+        /// </param>
+        /// <returns>
+        /// a Dictionary of <see cref="IClass"/> and associated <see cref="HashSet{T}"/> of property
+        /// variations for that class
+        /// </returns>
+        private Dictionary<IClass, HashSet<string>> MapClassPropertyVariation(IPackage package)
         {
             var classPropertyVariations = new Dictionary<IClass, HashSet<string>>();
 
             var classes = package.QueryPackages().SelectMany(x => x.PackagedElement.OfType<IClass>()).ToList();
 
-            // Step 1: Map class to property variations
             foreach (var @class in classes)
             {
                 var propertyVariations = new HashSet<string>();
@@ -164,64 +220,72 @@ public string Inspect(IPackage package)
                 classPropertyVariations.Add(@class, propertyVariations);
             }
 
+            return classPropertyVariations;
+        }
+
+        /// <summary>
+        /// Reduces the <see cref="IClass"/>> and property variations in a greedy fashion such
+        /// that the least amount of classes is returned
+        /// </summary>
+        /// <param name="classPropertyVariations">
+        /// The <see cref="IClass"/>> and property variations in a greedy fashion such that needs to
+        /// be reduced.
+        /// </param>
+        /// <returns>
+        /// a reduced set of <see cref="IClass"/> and <see cref="IProperty"/> variations.
+        /// </returns>
+        private IReadOnlyList<IClass> ReduceClassPropertyVariationToInterestingClasses(Dictionary<IClass, HashSet<string>> classPropertyVariations)
+        {
+            var dictionaryClone = new Dictionary<IClass, HashSet<string>>(classPropertyVariations);
+
             // Step 2: Get all unique property variations
-            var allPropertyVariations = new HashSet<string>(classPropertyVariations.Values.SelectMany(p => p));
+            var propertyVariations = dictionaryClone.Values.SelectMany(p => p).ToList();
 
-            // Step 3: Greedy algorithm to cover all property variations with fewest classes
+            var uniquePropertyVariations = new HashSet<string>(propertyVariations);
+
+            // Step 3: Greedy algorithm to cover all property variations with the fewest classes
             var result = new List<IClass>();
             var covered = new HashSet<string>();
 
-            while (covered.Count < allPropertyVariations.Count)
+            while (covered.Count < uniquePropertyVariations.Count)
             {
                 // Pick the class that contributes the most uncovered properties
-                var bestClass = classPropertyVariations
+                var bestClass = dictionaryClone
                     .OrderByDescending(kvp => kvp.Value.Count(p => !covered.Contains(p)))
                     .First().Key;
 
                 result.Add(bestClass);
 
-                foreach (var prop in classPropertyVariations[bestClass])
+                foreach (var prop in dictionaryClone[bestClass])
                     covered.Add(prop);
 
-                classPropertyVariations.Remove(bestClass); // avoid reusing the same class
-            }
-
-            var sw = Stopwatch.StartNew();
-
-            var sb = new StringBuilder();
-
-            sb.AppendLine($"----- PACKAGE {package.Name} ANALYSIS ------");
-            sb.AppendLine("");
-
-            sb.AppendLine("");
-            sb.AppendLine("----- MULTIPLICITY RESULTS ------");
-            sb.AppendLine("");
-
-            var orderedPropertyVariations = allPropertyVariations.OrderBy(x => x).ToList();
-
-            foreach (var orderedPropertyVariation in orderedPropertyVariations)
-            {
-                sb.AppendLine(orderedPropertyVariation);
+                dictionaryClone.Remove(bestClass); // avoid reusing the same class
             }
 
-            sb.AppendLine("");
-            sb.AppendLine("----- INTERESTING CLASSES ------");
-            sb.AppendLine("");
-
-            var orderedClasses = result.OrderBy(x => x.Name).ToList();
+            return result;
+        }
 
-            foreach (var @class in orderedClasses)
-            {
-                var isAbstract = "";
-                if (@class.IsAbstract)
-                {
-                    isAbstract = " [Abstract]";
-                }
+        /// <summary>
+        /// Inspect the content of the provided <see cref="IPackage"/> and returns a
+        /// read-only collection of interesting <see cref="IClass"/>
+        /// </summary>
+        /// <param name="package">
+        /// The <see cref="IPackage"/> that needs to be inspected
+        /// </param>
+        /// <returns>
+        /// A read-only collection of interesting <see cref="IClass"/> that cover the variations
+        /// of <see cref="IProperty"/>> and <see cref="IOperation"/> variations
+        /// </returns>
+        public IReadOnlyCollection<IClass> QueryInterestingClasses(IPackage package)
+        {
+            // Step 1: Map class to property variations
+            var classPropertyVariations = this.MapClassPropertyVariation(package);
 
-                sb.AppendLine($"class : {@class.QueryQualifiedName()}{isAbstract}");
-            }
+            // Step 2: Greedy algorithm to cover all property variations with the fewest classes
+            var result = this.ReduceClassPropertyVariationToInterestingClasses(classPropertyVariations)
+                .OrderBy(x => x.Name).ToList();
 
-            return sb.ToString();
+            return result;
         }
 
         /// <summary>