Annotation Schema

CodeModel.Tests/Integration/CodeModelFactoryTests.cs

@@ -74,6 +74,17 @@ public void Create_code_model_with_links(string folderLocation)
             difference.ShouldBeEmpty();
         }
 
+        [Fact]
+        public void Create_code_model_with_links_with_partial_classes()
+        {
+            CodeModelFactory factory = new CodeModelFactory(true);
+            var project = factory.CreateProjectWithCodeFileLinks("C:/sdataset-partial");
+
+            var projectClassesAndMembersCount = project.Classes.Count + project.Classes.Sum(c => c.Members.Count);
+
+            project.CodeLinks.Count.ShouldBe(projectClassesAndMembersCount);
+        }
+
         [Fact]
         public void Create_code_model_with_links_on_large_repo()
         {
@@ -93,5 +104,27 @@ public void Create_code_model_with_links_on_large_repo()
             locationLink.StartLoC.ShouldBe(15);
             locationLink.EndLoC.ShouldBe(16);
         }
+
+        [Theory]
+        //[InlineData("C:\\temp\\challenge-sandbox\\start\\01. Structural Cohesion")]
+        //[InlineData("C:\\temp\\challenge-sandbox\\end\\01. structural")]
+        //[InlineData("C:\\temp\\challenge-sandbox\\start\\03. Coupling\\Employees")]
+        //[InlineData("C:\\temp\\challenge-sandbox\\end\\03. coupling employee")]
+        //[InlineData("C:\\temp\\challenge-sandbox\\start\\03. Coupling\\Rental")]
+        //[InlineData("C:\\temp\\challenge-sandbox\\end\\03. coupling rental")]
+        //[InlineData("C:\\temp\\challenge-sandbox\\start\\04. SRP\\Achievements")]
+        //[InlineData("C:\\temp\\challenge-sandbox\\end\\04. srp achievements")]
+        [InlineData("C:\\temp\\challenge-sandbox\\start\\04. SRP\\Books")]
+        [InlineData("C:\\temp\\challenge-sandbox\\end\\04. srp books")]
+        public void Create_code_model(string folderLocation)
+        {
+            CodeModelFactory factory = new CodeModelFactory();
+            var project = factory.CreateProjectWithCodeFileLinks(folderLocation);
+
+            var classes = project.Classes;
+            var members = project.Classes.SelectMany(c => c.Members);
+
+            var firstClassMetrics = classes.First().Metrics;
+        }
     }
 }

CodeModel/CaDETModel/CodeItems/CaDETClass.cs

@@ -27,6 +27,7 @@ public string ContainerName
         public List<CaDETMember> Members { get; internal set; }
         public List<CaDETField> Fields { get; internal set; }
         public Dictionary<CaDETMetric, double> Metrics { get; set; }
+        public List<CaDETClass> Subclasses { get; set; }
 
         public CaDETClass(string name)
         {

CodeModel/CaDETModel/CodeItems/CaDETModifier.cs

@@ -1,5 +1,4 @@
-using CodeModel.CodeParsers.CSharp.Exceptions;
-using System.ComponentModel;
+using System.ComponentModel;
 
 namespace CodeModel.CaDETModel.CodeItems
 {
@@ -27,7 +26,7 @@ public CaDETModifier(string modifier)
                 "const" => CaDETModifierValue.Const,
                 "async" => CaDETModifierValue.Async,
                 "volatile" => CaDETModifierValue.Volatile,
-                "partial" => throw new PartialIsNotSupportedException(),
+                "partial" => CaDETModifierValue.Partial,
                 _ => throw new InvalidEnumArgumentException(modifier)
             };
         }

CodeModel/CodeModel.csproj

@@ -13,6 +13,7 @@
     <RepositoryUrl>https://github.com/Clean-CaDET/platform/tree/master/CodeModel</RepositoryUrl>
     <PackageLicenseExpression>GPL-3.0-or-later</PackageLicenseExpression>
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+    <Version>1.0.3</Version>
   </PropertyGroup>
 
   <ItemGroup>

CodeModel/CodeModelCache.cs

@@ -17,7 +17,7 @@ public CaDETProject GetOrCreate(string repoAndCommitUrl, string repoFolder, Lang
         {
             if (_cache.TryGetValue(repoAndCommitUrl, out CaDETProject cacheEntry)) return cacheEntry;
 
-            cacheEntry = new CodeModelFactory(language).CreateProjectWithCodeFileLinks(repoFolder);
+            cacheEntry = new CodeModelFactory(false, language).CreateProjectWithCodeFileLinks(repoFolder);
 
             var cacheEntryOptions = new MemoryCacheEntryOptions
             {

CodeModel/CodeModelFactory.cs

@@ -12,16 +12,18 @@ namespace CodeModel
     public class CodeModelFactory
     {
         private readonly LanguageEnum _language;
+        private readonly bool _includePartial;
 
-        public CodeModelFactory(LanguageEnum language = LanguageEnum.CSharp)
+        public CodeModelFactory(bool includePartial = false, LanguageEnum language = LanguageEnum.CSharp)
         {
+            _includePartial = includePartial;
             _language = language;
         }
 
         public CaDETProject CreateProject(IEnumerable<string> multipleClassSourceCode)
         {
             ICodeParser codeParser = SimpleParserFactory.CreateParser(_language);
-            return codeParser.Parse(multipleClassSourceCode);
+            return _includePartial ? codeParser.ParseWithPartial(multipleClassSourceCode) : codeParser.Parse(multipleClassSourceCode);
         }
 
         public CaDETProject CreateProject(string sourceCodeLocation, List<string> ignoredFolders)

CodeModel/CodeParsers/CSharp/CSharpCodeParser.cs

@@ -27,12 +27,20 @@ public CSharpCodeParser()
         public CaDETProject Parse(IEnumerable<string> sourceCode)
         {
             var syntaxErrors = LoadSyntaxTrees(sourceCode);
-            var parsedClasses = ParseClasses();
+            var parsedClasses = ParseClasses(false);
             ValidateUniqueFullNameForNonPartial(parsedClasses);
             parsedClasses = ConnectCaDETGraph(parsedClasses);
             return new CaDETProject(LanguageEnum.CSharp, CalculateMetrics(parsedClasses), syntaxErrors);
         }
 
+        public CaDETProject ParseWithPartial(IEnumerable<string> sourceCode)
+        {
+            var syntaxErrors = LoadSyntaxTrees(sourceCode);
+            var parsedClasses = ParseClasses(true);
+            parsedClasses = ConnectCaDETGraph(parsedClasses);
+            return new CaDETProject(LanguageEnum.CSharp, CalculateMetrics(parsedClasses), syntaxErrors);
+        }
+
         private List<string> LoadSyntaxTrees(IEnumerable<string> sourceCode)
         {
             var syntaxErrors = new List<string>();
@@ -47,7 +55,7 @@ private List<string> LoadSyntaxTrees(IEnumerable<string> sourceCode)
 
             return syntaxErrors;
         }
-        private List<CaDETClass> ParseClasses()
+        private List<CaDETClass> ParseClasses(bool includePartial)
         {
             List<CaDETClass> builtClasses = new List<CaDETClass>();
             foreach (var ast in _compilation.SyntaxTrees)
@@ -59,7 +67,7 @@ private List<CaDETClass> ParseClasses()
                 {
                     try
                     {
-                        ValidateNoPartialModifier(node);
+                        if(!includePartial) ValidateNoPartialModifier(node);
                         ValidateNoStructParent(node);
                         builtClasses.Add(ParseClass(semanticModel, node));
                     }
@@ -196,6 +204,7 @@ private List<CaDETClass> ConnectCaDETGraph(List<CaDETClass> classes)
             foreach (var c in classes)
             {
                 c.Parent = LinkParent(classes, c.Parent);
+                c.Subclasses = LinkSubclasses(classes, c);
                 var outerClass = LinkOuterClass(classes, c.ContainerName);
                 if (outerClass != null)
                 {
@@ -218,6 +227,19 @@ private static CaDETClass LinkParent(List<CaDETClass> classes, CaDETClass parent
             if (parent.Name.Equals("object")) return null;
             return classes.FirstOrDefault(c => c.FullName.Equals(parent.Name));
         }
+
+        private List<CaDETClass> LinkSubclasses(List<CaDETClass> classes, CaDETClass c)
+        {
+            var subclasses = new List<CaDETClass>();
+            foreach(var subclass in classes)
+            {
+                if (subclass.Parent == null) continue;
+                if (subclass.Parent.FullName != null && subclass.Parent.FullName.Equals(c.FullName)) subclasses.Add(subclass);
+                else if (subclass.Parent.Name != null &&  subclass.Parent.Name.Equals(c.FullName)) subclasses.Add(subclass);
+            }
+            return subclasses;
+        }
+
         private static CaDETClass LinkOuterClass(List<CaDETClass> classes, string containerName)
         {
             return classes.FirstOrDefault(c => c.FullName.Equals(containerName));

CodeModel/CodeParsers/ICodeParser.cs

@@ -6,5 +6,6 @@ namespace CodeModel.CodeParsers
     public interface ICodeParser
     {
         CaDETProject Parse(IEnumerable<string> sourceCode);
+        CaDETProject ParseWithPartial(IEnumerable<string> sourceCode);
     }
 }

DataSetExplorer/Core/AnnotationConsistency/AnnotationConsistencyService.cs

@@ -16,7 +16,7 @@ public AnnotationConsistencyService(FullDataSetFactory fullDataSetFactory)
             _fullDataSetFactory = fullDataSetFactory;
         }
 
-        public Result<string> CheckMetricsSignificanceBetweenAnnotatorsForSeverity(int severity, IDictionary<string, string> projects, List<Annotator> annotators)
+        public Result<string> CheckMetricsSignificanceBetweenAnnotatorsForSeverity(string severity, IDictionary<string, string> projects, List<Annotator> annotators)
         {
             var instancesGroupedBySmells = _fullDataSetFactory.GetAnnotatedInstancesGroupedBySmells(projects, annotators, annotatorId: null);
             IMetricsSignificanceTester tester = new AnovaTest();
@@ -42,7 +42,7 @@ public Result<string> CheckMetricsSignificanceInAnnotationsForAnnotator(int anno
             return Result.Ok();
         }
 
-        public Result<string> CheckAnnotationConsistencyBetweenAnnotatorsForSeverity(int severity, IDictionary<string, string> projects, List<Annotator> annotators)
+        public Result<string> CheckAnnotationConsistencyBetweenAnnotatorsForSeverity(string severity, IDictionary<string, string> projects, List<Annotator> annotators)
         {
             var instancesGroupedBySmells = _fullDataSetFactory.GetAnnotatedInstancesGroupedBySmells(projects, annotators, annotatorId: null);
             IAnnotatorsConsistencyTester tester = new ManovaTest();
@@ -67,7 +67,7 @@ public Result<Dictionary<string, string>> CheckAnnotationConsistencyForAnnotator
             return tester.TestConsistencyOfSingleAnnotator(annotatorId, instancesGroupedBySmells);
         }
 
-        public Result<Dictionary<string, string>> CheckAnnotationConsistencyBetweenAnnotatorsForSeverity(int projectId, int severity)
+        public Result<Dictionary<string, string>> CheckAnnotationConsistencyBetweenAnnotatorsForSeverity(int projectId, string severity)
         {
             var instancesGroupedBySmells = _fullDataSetFactory.GetAnnotatedInstancesGroupedBySmells(projectId, annotatorId: null);
             IAnnotatorsConsistencyTester tester = new ManovaTest();
@@ -81,7 +81,7 @@ public Result<Dictionary<string, Dictionary<string, string>>> CheckMetricsSignif
             return tester.TestForSingleAnnotator(annotatorId, instancesGroupedBySmells);
         }
 
-        public Result<Dictionary<string, Dictionary<string, string>>> CheckMetricsSignificanceBetweenAnnotatorsForSeverity(int projectId, int severity)
+        public Result<Dictionary<string, Dictionary<string, string>>> CheckMetricsSignificanceBetweenAnnotatorsForSeverity(int projectId, string severity)
         {
             var instancesGroupedBySmells = _fullDataSetFactory.GetAnnotatedInstancesGroupedBySmells(projectId, annotatorId: null);
             IMetricsSignificanceTester tester = new AnovaTest();

DataSetExplorer/Core/AnnotationConsistency/AnovaTest.cs

@@ -11,8 +11,8 @@ namespace DataSetExplorer.Core.AnnotationConsistency
 {
     public class AnovaTest : IMetricsSignificanceTester
     {
-        private readonly string _anovaScriptFile = "./AnnotationConsistency/scripts/anova_test.py";
-        private readonly string _pythonPath = "./AnnotationConsistency/venv/Scripts/python.exe";
+        private readonly string _anovaScriptFile = "./Core/AnnotationConsistency/scripts/anova_test.py";
+        private readonly string _pythonPath = "./Core/AnnotationConsistency/venv/Scripts/python.exe";
         private string _annotatedInstancesFile;
         private string _dependentVariable;
         private string _independentVariable;
@@ -22,23 +22,26 @@ public class AnovaTest : IMetricsSignificanceTester
 
         public Result<Dictionary<string, Dictionary<string, string>>> TestForSingleAnnotator(int annotatorId, List<SmellCandidateInstances> instancesGroupedBySmells)
         {
-            return Test(annotatorId, instancesGroupedBySmells, TestCodeSmellForAnnotator);
-        }
-
-        public Result<Dictionary<string, Dictionary<string, string>>> TestBetweenAnnotators(int severity, List<SmellCandidateInstances> instancesGroupedBySmells)
-        {
-            return Test(severity, instancesGroupedBySmells, TestCodeSmellBetweenAnnotators);
+            var results = new Dictionary<string, Dictionary<string, string>>();
+            foreach (var codeSmellGroup in instancesGroupedBySmells)
+            {
+                var codeSmell = codeSmellGroup.CodeSmell.Name;
+                var metrics = codeSmellGroup.Instances.First().MetricFeatures.Keys.ToList();
+                var instances = codeSmellGroup.Instances;
+                results[codeSmell] = TestCodeSmellForAnnotator(annotatorId, instances, codeSmell, metrics);
+            }
+            return Result.Ok(results);
         }
 
-        private Result<Dictionary<string, Dictionary<string, string>>> Test(int id, List<SmellCandidateInstances> instancesGroupedBySmells, TestCodeSmellDelegate testCodeSmell)
+        public Result<Dictionary<string, Dictionary<string, string>>> TestBetweenAnnotators(string severity, List<SmellCandidateInstances> instancesGroupedBySmells)
         {
             var results = new Dictionary<string, Dictionary<string, string>>();
             foreach (var codeSmellGroup in instancesGroupedBySmells)
             {
                 var codeSmell = codeSmellGroup.CodeSmell.Name;
                 var metrics = codeSmellGroup.Instances.First().MetricFeatures.Keys.ToList();
                 var instances = codeSmellGroup.Instances;
-                results[codeSmell] = testCodeSmell(id, instances, codeSmell, metrics);
+                results[codeSmell] = TestCodeSmellBetweenAnnotators(severity, instances, codeSmell, metrics);
             }
             return Result.Ok(results);
         }
@@ -55,7 +58,7 @@ private Dictionary<string, string> TestCodeSmellForAnnotator(int annotatorId, Li
             return results;
         }
 
-        private Dictionary<string, string> TestCodeSmellBetweenAnnotators(int severity, List<Instance> instances, string codeSmell, List<CaDETMetric> metrics)
+        private Dictionary<string, string> TestCodeSmellBetweenAnnotators(string severity, List<Instance> instances, string codeSmell, List<CaDETMetric> metrics)
         {
             var results = new Dictionary<string, string>();
             string exportedAnnotationsFile = ExportAnnotationsForSeverity(severity, instances, codeSmell);
@@ -75,7 +78,7 @@ private string ExportAnnotationsForAnnotator(int annotatorId, List<Instance> ins
             return exportedAnnotationsFile;
         }
 
-        private string ExportAnnotationsForSeverity(int severity, List<Instance> instances, string codeSmell)
+        private string ExportAnnotationsForSeverity(string severity, List<Instance> instances, string codeSmell)
         {
             var exportedAnnotationsFile = "MetricsSignificance_" + codeSmell + "_Severity_" + severity;
             var exporter = new AnnotationConsistencyByMetricsExporter(_annotatedInstancesFolderPath);

DataSetExplorer/Core/AnnotationConsistency/IAnnotationConsistencyService.cs

@@ -6,14 +6,13 @@ namespace DataSetExplorer.Core.AnnotationConsistency
 {
     public interface IAnnotationConsistencyService
     {
-        Result<string> CheckMetricsSignificanceBetweenAnnotatorsForSeverity(int severity, IDictionary<string, string> projects, List<Annotator> annotators);
+        Result<string> CheckMetricsSignificanceBetweenAnnotatorsForSeverity(string severity, IDictionary<string, string> projects, List<Annotator> annotators);
         Result<string> CheckMetricsSignificanceInAnnotationsForAnnotator(int annotatorId, IDictionary<string, string> projects, List<Annotator> annotators);
-        Result<string> CheckAnnotationConsistencyBetweenAnnotatorsForSeverity(int severity, IDictionary<string, string> projects, List<Annotator> annotators);
+        Result<string> CheckAnnotationConsistencyBetweenAnnotatorsForSeverity(string severity, IDictionary<string, string> projects, List<Annotator> annotators);
         Result<string> CheckAnnotationConsistencyForAnnotator(int annotatorId, IDictionary<string, string> projects, List<Annotator> annotators);
-
         Result<Dictionary<string, string>> CheckAnnotationConsistencyForAnnotator(int projectId, int annotatorId);
-        Result<Dictionary<string, string>> CheckAnnotationConsistencyBetweenAnnotatorsForSeverity(int projectId, int severity);
+        Result<Dictionary<string, string>> CheckAnnotationConsistencyBetweenAnnotatorsForSeverity(int projectId, string severity);
         Result<Dictionary<string, Dictionary<string, string>>> CheckMetricsSignificanceInAnnotationsForAnnotator(int projectId, int annotatorId);
-        Result<Dictionary<string, Dictionary<string, string>>> CheckMetricsSignificanceBetweenAnnotatorsForSeverity(int projectId, int severity);
+        Result<Dictionary<string, Dictionary<string, string>>> CheckMetricsSignificanceBetweenAnnotatorsForSeverity(int projectId, string severity);
     }
 }

DataSetExplorer/Core/AnnotationConsistency/IAnnotatorsConsistencyTester.cs

@@ -6,7 +6,7 @@ namespace DataSetExplorer.Core.AnnotationConsistency
 {
     internal interface IAnnotatorsConsistencyTester
     {
-        public Result<Dictionary<string, string>> TestConsistencyBetweenAnnotators(int severity, List<SmellCandidateInstances> instancesGroupedBySmells);
+        public Result<Dictionary<string, string>> TestConsistencyBetweenAnnotators(string severity, List<SmellCandidateInstances> instancesGroupedBySmells);
 
         public Result<Dictionary<string, string>> TestConsistencyOfSingleAnnotator(int annotatorId, List<SmellCandidateInstances> instancesGroupedBySmells); 
     }

DataSetExplorer/Core/AnnotationConsistency/IMetricsSignificanceTester.cs

@@ -8,6 +8,6 @@ internal interface IMetricsSignificanceTester
     {
         public Result<Dictionary<string, Dictionary<string, string>>> TestForSingleAnnotator(int annotatorId, List<SmellCandidateInstances> instancesGroupedBySmells);
 
-        public Result<Dictionary<string, Dictionary<string, string>>> TestBetweenAnnotators(int severity, List<SmellCandidateInstances> instancesGroupedBySmells);
+        public Result<Dictionary<string, Dictionary<string, string>>> TestBetweenAnnotators(string severity, List<SmellCandidateInstances> instancesGroupedBySmells);
     }
 }