backup

Author: tonyhallett

FineCodeCoverageTests/Editor/DynamicCoverage/ContainingCodeTrackedLinesBuilder_Tests.cs

@@ -8,7 +8,7 @@ namespace FineCodeCoverage.Editor.DynamicCoverage
     [Export(typeof(IContainingCodeTrackedLinesFactory))]
     internal class ContainingCodeTrackedLinesFactory : IContainingCodeTrackedLinesFactory
     {
-        public TrackedLines Create(
+        public IContainingCodeTrackerTrackedLines Create(
             List<IContainingCodeTracker> containingCodeTrackers,
             INewCodeTracker newCodeTracker,
             IFileCodeSpanRangeService fileCodeSpanRangeService

SharedProject/Editor/DynamicCoverage/TrackedLines/ContainingCodeTrackedLinesFactory.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace FineCodeCoverage.Editor.DynamicCoverage
+{
+    internal interface IContainingCodeTrackerTrackedLines : ITrackedLines
+    {
+        IReadOnlyList<IContainingCodeTracker> ContainingCodeTrackers { get; }
+    }
+}

SharedProject/Editor/DynamicCoverage/TrackedLines/IContainingCodeTrackerTrackedLines.cs

@@ -5,7 +5,7 @@
 
 namespace FineCodeCoverage.Editor.DynamicCoverage
 {
-    internal class TrackedLines : ITrackedLines
+    internal class TrackedLines : IContainingCodeTrackerTrackedLines
     {
         private readonly List<IContainingCodeTracker> containingCodeTrackers;
         private readonly INewCodeTracker newCodeTracker;

SharedProject/Editor/DynamicCoverage/TrackedLines/TrackedLines.cs

@@ -47,17 +47,18 @@ private ICoverageContentType GetCoverageContentType(ITextSnapshot textSnapshot)
         private IFileCodeSpanRangeService GetFileCodeSpanRangeServiceForChanges(ICoverageContentType coverageContentType)
             => coverageContentType.UseFileCodeSpanRangeServiceForChanges ? coverageContentType.FileCodeSpanRangeService : null;
 
+        private INewCodeTracker GetNewCodeTrackerIfProvidesLineExcluder(ILineExcluder lineExcluder) 
+            => lineExcluder == null ? null : this.newCodeTrackerFactory.Create(lineExcluder);
+
         public ITrackedLines Create(List<ILine> lines, ITextSnapshot textSnapshot)
         {
             ICoverageContentType coverageContentType = this.GetCoverageContentType(textSnapshot);
             IFileCodeSpanRangeService fileCodeSpanRangeService = coverageContentType.FileCodeSpanRangeService;
             List<IContainingCodeTracker> containingCodeTrackers = this.CreateContainingCodeTrackers(
                 lines, textSnapshot, fileCodeSpanRangeService, coverageContentType.CoverageOnlyFromFileCodeSpanRangeService);
-            ILineExcluder lineExcluder = coverageContentType.LineExcluder;
-            INewCodeTracker newCodeTracker = lineExcluder == null ? null : this.newCodeTrackerFactory.Create(lineExcluder);
             return this.containingCodeTrackedLinesFactory.Create(
                 containingCodeTrackers, 
-                newCodeTracker, 
+                this.GetNewCodeTrackerIfProvidesLineExcluder(coverageContentType.LineExcluder), 
                 this.GetFileCodeSpanRangeServiceForChanges(coverageContentType));
         }
 
@@ -105,10 +106,12 @@ bool coverageOnlyFromFileCodeSpanRangeService
         )
         {
             var containingCodeTrackers = new List<IContainingCodeTracker>();
-            int currentLine = 0;
-            // this should not happen - just in case missed
+            int nextPossibleOtherLine = 0;
+            // this should not happen for Roslyn - just in case missed.  
+            // for Blazor ignore the coverage lines that are not related to executable code visible in @code block
             void CreateSingleLineContainingCodeTrackerInCase(ILine line)
             {
+                nextPossibleOtherLine = line.Number;
                 if (!coverageOnlyFromFileCodeSpanRangeService)
                 {
                     containingCodeTrackers.Add(this.CreateSingleLineContainingCodeTracker(textSnapshot, line));
@@ -133,17 +136,17 @@ void TrackOtherLines()
             {
                 int to = currentCodeSpanRange.StartLine - 1;
                 TrackOtherLinesTo(to);
-                currentLine = currentCodeSpanRange.EndLine + 1;
+                nextPossibleOtherLine = currentCodeSpanRange.EndLine + 1;
             }
 
             void TrackOtherLinesTo(int to)
             {
-                if (to < currentLine) return;
-                IEnumerable<int> otherCodeLines = Enumerable.Range(currentLine, to - currentLine + 1);
+                if (to < nextPossibleOtherLine) return;
+                IEnumerable<int> otherCodeLines = Enumerable.Range(nextPossibleOtherLine, to - nextPossibleOtherLine + 1);
                 foreach (int otherCodeLine in otherCodeLines)
                 {
-                    string lineText = this.textSnapshotText.GetLineText(textSnapshot, otherCodeLine).Trim();
-                    if (!string.IsNullOrEmpty(lineText)){
+                    string lineText = this.textSnapshotText.GetLineText(textSnapshot, otherCodeLine);
+                    if (!string.IsNullOrWhiteSpace(lineText)){
                         containingCodeTrackers.Add(
                                 this.CreateOtherLines(
                                     textSnapshot,
@@ -205,18 +208,25 @@ void LineAction(ILine line)
 
             TrackOtherLinesTo(textSnapshot.LineCount - 1);
 
-            var orderedContainingCodeTrackers = containingCodeTrackers.OrderBy(ct => ct.GetState().CodeSpanRange.StartLine).ToList();
+            var orderedContainingCodeTrackers = containingCodeTrackers.OrderBy(
+                ct => ct.GetState().CodeSpanRange.StartLine).ToList();
             return orderedContainingCodeTrackers;
         }
 
+        #region Serialization
+
         private ITrackedLines RecreateTrackedLinesFromStates(
             List<SerializedState> states, 
-            ITextSnapshot currentSnapshot
+            ITextSnapshot currentSnapshot,
+            ILineExcluder lineExcluder
         )
         {
             var containingCodeTrackers = this.StatesWithinSnapshot(states, currentSnapshot)
                 .Select(state => this.RecreateCoverageLines(state, currentSnapshot)).ToList();
-            return this.containingCodeTrackedLinesFactory.Create(containingCodeTrackers, null, null);
+            return this.containingCodeTrackedLinesFactory.Create(
+                containingCodeTrackers, 
+                this.GetNewCodeTrackerIfProvidesLineExcluder(lineExcluder), 
+                null);
         }
 
         private IEnumerable<SerializedState> StatesWithinSnapshot(IEnumerable<SerializedState> states, ITextSnapshot currentSnapshot)
@@ -292,21 +302,21 @@ private IEnumerable<int> EveryLineInCodeSpanRanges(List<CodeSpanRange> newCodeCo
         public ITrackedLines Create(string serializedCoverage, ITextSnapshot currentSnapshot)
         {
             List<SerializedState> states = this.jsonConvertService.DeserializeObject<List<SerializedState>>(serializedCoverage);
-            ICoverageContentType coverageContextType = this.GetCoverageContentType(currentSnapshot);
-            IFileCodeSpanRangeService fileCodeSpanRangeService = coverageContextType.FileCodeSpanRangeService;
+            ICoverageContentType coverageContentType = this.GetCoverageContentType(currentSnapshot);
+            IFileCodeSpanRangeService fileCodeSpanRangeService = coverageContentType.FileCodeSpanRangeService;
             return fileCodeSpanRangeService == null
-                ? this.RecreateTrackedLinesFromStates(states, currentSnapshot)
-                : this.RecreateTrackedLinesFromCoverageContentType(states, currentSnapshot, coverageContextType);
+                ? this.RecreateTrackedLinesFromStates(states, currentSnapshot, coverageContentType.LineExcluder)
+                : this.RecreateTrackedLinesFromCoverageContentType(states, currentSnapshot, coverageContentType);
         }
 
         public string Serialize(ITrackedLines trackedLines)
         {
-            var trackedLinesImpl = trackedLines as TrackedLines;
-            List<SerializedState> states = this.GetSerializedStates(trackedLinesImpl);
+            var containingCodeTrackerTrackedLines = trackedLines as IContainingCodeTrackerTrackedLines;
+            List<SerializedState> states = this.GetSerializedStates(containingCodeTrackerTrackedLines);
             return this.jsonConvertService.SerializeObject(states);
         }
 
-        private List<SerializedState> GetSerializedStates(TrackedLines trackedLines)
+        private List<SerializedState> GetSerializedStates(IContainingCodeTrackerTrackedLines trackedLines)
             => trackedLines.ContainingCodeTrackers.Select(
                 containingCodeTracker => SerializedState.From(containingCodeTracker.GetState())).ToList();
 
@@ -322,5 +332,6 @@ public AdjustedLine(IDynamicLine dynamicLine)
 
             public CoverageType CoverageType { get; }
         }
+        #endregion
     }
 }

SharedProject/Editor/DynamicCoverage/TrackedLinesImpl/Construction/ContainingCodeTrackedLinesBuilder.cs

@@ -4,7 +4,7 @@ namespace FineCodeCoverage.Editor.DynamicCoverage
 {
     internal interface IContainingCodeTrackedLinesFactory
     {
-        TrackedLines Create(
+        IContainingCodeTrackerTrackedLines Create(
             List<IContainingCodeTracker> containingCodeTrackers,
             INewCodeTracker newCodeTracker,
              IFileCodeSpanRangeService fileCodeSpanRangeService

SharedProject/Editor/DynamicCoverage/TrackedLinesImpl/Construction/IContainingCodeTrackedLinesFactory.cs

@@ -210,6 +210,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Editor\DynamicCoverage\TrackedLinesImpl\ContainingCodeTracker\TrackingSpanRangeUpdatingTracker.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Editor\DynamicCoverage\TrackedLines\ContainingCodeTrackerState.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Editor\DynamicCoverage\TrackedLines\ContainingCodeTrackerType.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Editor\DynamicCoverage\TrackedLines\IContainingCodeTrackerTrackedLines.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Editor\DynamicCoverage\TrackedLines\IContainingCodeTrackerProcessResult.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Editor\DynamicCoverage\TrackedLines\IFileCodeSpanRangeService.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Editor\DynamicCoverage\Utilities\ITextInfo.cs" />