Added UT's

Zubin Ramlakhan · Zubin Ramlakhan · commit 8ad56c8bf558 · 2021-06-11T09:59:21.000+02:00
Split project + sln reference replacements
Replacements regexes now match on relativeprojpath
diff --git a/CodeConverter/CodeConverter.csproj b/CodeConverter/CodeConverter.csproj
@@ -4,13 +4,14 @@
     <AssemblyName>ICSharpCode.CodeConverter</AssemblyName>
     <RootNamespace>ICSharpCode.CodeConverter</RootNamespace>
     <Company>ICSharpCode</Company>
-    <Description>Convert VB.NET to/from C#
-* Accurate: Full project context (through Roslyn) is used to get the most accurate conversion.
-* Actively developed: User feedback helps us continuously strive for a more accurate conversion.
-* Completely free and open source
-This nuget package is useful if you're building a tool which converts code, or if you want finer-grained control over what's converted.
-See https://github.com/icsharpcode/CodeConverter for a pre-built command line, visual studio extension and web converter.
-</Description>
+    <Description>
+      Convert VB.NET to/from C#
+      * Accurate: Full project context (through Roslyn) is used to get the most accurate conversion.
+      * Actively developed: User feedback helps us continuously strive for a more accurate conversion.
+      * Completely free and open source
+      This nuget package is useful if you're building a tool which converts code, or if you want finer-grained control over what's converted.
+      See https://github.com/icsharpcode/CodeConverter for a pre-built command line, visual studio extension and web converter.
+    </Description>
     <Product>Code Converter for C# to/from VB.NET</Product>
     <Copyright>Copyright (c) 2017-2020 AlphaSierraPapa for the CodeConverter team</Copyright>
     <AssemblyVersion>8.2.3.0</AssemblyVersion>
@@ -46,6 +47,7 @@ See https://github.com/icsharpcode/CodeConverter for a pre-built command line, v
     <PackageReference Include="Microsoft.VisualStudio.Composition" Version="15.8.98" />
     <PackageReference Include="Microsoft.VisualStudio.Threading" Version="15.8.122" />
     <PackageReference Include="System.Globalization.Extensions" Version="4.3.0" />
+    <PackageReference Include="System.IO.Abstractions" Version="13.2.33" />
     <PackageReference Include="System.Linq.Async" Version="4.0.0" />
     <PackageReference Include="System.Threading.Tasks.Dataflow" Version="4.6.0">
       <IncludeAssets>all</IncludeAssets>
diff --git a/CodeConverter/Shared/ISolutionFileTextEditor.cs b/CodeConverter/Shared/ISolutionFileTextEditor.cs
@@ -0,0 +1,10 @@
+﻿namespace ICSharpCode.CodeConverter.Shared
+{
+    using System.Collections.Generic;
+
+    public interface ISolutionFileTextEditor
+    {
+        List<(string Find, string Replace, bool FirstOnly)> GetProjectFileProjectReferenceReplacements(
+            IEnumerable<(string Name, string RelativeProjPath, string ProjContents)> projTuples, string sourceSolutionContents);
+    }
+}
diff --git a/CodeConverter/Shared/PathConverter.cs b/CodeConverter/Shared/PathConverter.cs
@@ -1,4 +1,5 @@
-﻿using System.IO;
+﻿using System;
+using System.IO;
 
 namespace ICSharpCode.CodeConverter.Shared
 {
@@ -33,12 +34,12 @@ private static string GetConvertedExtension(string originalExtension)
             }
         }
 
-        public static string GetFileDirPath(string fileName, string dirPath)
+        public static string GetRelativePath(string relativeTo, string path)
         {
-            var dirName = Path.GetFileName(dirPath);
-            var fileDirPath = Path.Combine(dirName ?? string.Empty, fileName);
+            var uri = new Uri(relativeTo);
+            var rel = Uri.UnescapeDataString(uri.MakeRelativeUri(new Uri(path)).ToString()).Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
 
-            return fileDirPath;
+            return rel;
         }
     }
 }
diff --git a/CodeConverter/Shared/ProjectConversion.cs b/CodeConverter/Shared/ProjectConversion.cs
@@ -10,10 +10,11 @@
 using ICSharpCode.CodeConverter.CSharp;
 using ICSharpCode.CodeConverter.Util;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Text;
-
 namespace ICSharpCode.CodeConverter.Shared
 {
+    using System.IO.Abstractions;
+    using Microsoft.CodeAnalysis.Text;
+
     public class ProjectConversion
     {
         private readonly IProjectContentsConverter _projectContentsConverter;
@@ -22,7 +23,7 @@ public class ProjectConversion
         private readonly ILanguageConversion _languageConversion;
         private readonly bool _showCompilationErrors;
         private readonly bool _returnSelectedNode;
-        private static readonly string[] BannedPaths = new[] { ".AssemblyAttributes.", "\\bin\\", "\\obj\\" };
+        private static readonly string[] BannedPaths = { ".AssemblyAttributes.", "\\bin\\", "\\obj\\" };
         private readonly CancellationToken _cancellationToken;
 
         private ProjectConversion(IProjectContentsConverter projectContentsConverter, IEnumerable<Document> documentsToConvert, IEnumerable<TextDocument> additionalDocumentsToConvert,
diff --git a/CodeConverter/Shared/SolutionConverter.cs b/CodeConverter/Shared/SolutionConverter.cs
@@ -2,11 +2,10 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text.RegularExpressions;
 using System.Threading;
-using ICSharpCode.CodeConverter.CSharp;
 using ICSharpCode.CodeConverter.Util;
 using Microsoft.CodeAnalysis;
+using System.IO.Abstractions;
 
 namespace ICSharpCode.CodeConverter.Shared
 {
@@ -18,32 +17,58 @@ public class SolutionConverter
         private readonly List<(string Find, string Replace, bool FirstOnly)> _projectReferenceReplacements;
         private readonly IProgress<ConversionProgress> _progress;
         private readonly ILanguageConversion _languageConversion;
+        private readonly SolutionFileTextEditor _solutionFileTextEditor;
         private readonly CancellationToken _cancellationToken;
 
+        public static IFileSystem FileSystem { get; set; } = new FileSystem();
+
+        public static SolutionConverter CreateFor<TLanguageConversion>(IReadOnlyCollection<Project> projectsToConvert, string sourceSolutionContents)
+            where TLanguageConversion : ILanguageConversion, new()
+        {
+            return CreateFor<TLanguageConversion>(projectsToConvert, solutionContents: sourceSolutionContents);
+        }
+
         public static SolutionConverter CreateFor<TLanguageConversion>(IReadOnlyCollection<Project> projectsToConvert,
             ConversionOptions conversionOptions = default,
             IProgress<ConversionProgress> progress = null,
-            CancellationToken cancellationToken = default) where TLanguageConversion : ILanguageConversion, new()
+            CancellationToken cancellationToken = default,
+            string solutionContents = "") where TLanguageConversion : ILanguageConversion, new()
         {
             var conversion = new TLanguageConversion { ConversionOptions = conversionOptions };
-            return CreateFor(conversion, projectsToConvert, progress, cancellationToken);
+            return CreateFor(conversion, projectsToConvert, progress, cancellationToken, solutionContents);
         }
 
         public static SolutionConverter CreateFor(ILanguageConversion languageConversion, IReadOnlyCollection<Project> projectsToConvert,
             IProgress<ConversionProgress> progress,
-            CancellationToken cancellationToken)
+            CancellationToken cancellationToken, string solutionContents = "")
         {
             languageConversion.ConversionOptions ??= new ConversionOptions();
             var solutionFilePath = projectsToConvert.First().Solution.FilePath;
-            var sourceSolutionContents = File.Exists(solutionFilePath) ? File.ReadAllText(solutionFilePath) : "";
-            var projectReferenceReplacements = GetProjectReferenceReplacements(projectsToConvert, sourceSolutionContents);
-            return new SolutionConverter(solutionFilePath, sourceSolutionContents, projectsToConvert, projectReferenceReplacements, progress ?? new Progress<ConversionProgress>(), cancellationToken, languageConversion);
+            var sourceSolutionContents = File.Exists(solutionFilePath)
+                ? FileSystem.File.ReadAllText(solutionFilePath)
+                : solutionContents;
+
+            var projTuples = projectsToConvert.Select(proj =>
+            {
+                var relativeProjPath = PathConverter.GetRelativePath(solutionFilePath, proj.FilePath);
+                var projContents = FileSystem.File.ReadAllText(proj.FilePath);
+
+                return (proj.Name, RelativeProjPath: relativeProjPath, ProjContents: projContents);
+            });
+
+            var solutionFileTextEditor = new SolutionFileTextEditor();
+            var projectReferenceReplacements = solutionFileTextEditor.GetProjectFileProjectReferenceReplacements(projTuples, sourceSolutionContents);
+
+            return new SolutionConverter(solutionFilePath, sourceSolutionContents, projectsToConvert, projectReferenceReplacements,
+                progress ?? new Progress<ConversionProgress>(), cancellationToken, languageConversion, solutionFileTextEditor);
         }
 
         private SolutionConverter(string solutionFilePath,
             string sourceSolutionContents, IReadOnlyCollection<Project> projectsToConvert,
-            List<(string Find, string Replace, bool FirstOnly)> projectReferenceReplacements, IProgress<ConversionProgress> showProgressMessage,
-            CancellationToken cancellationToken, ILanguageConversion languageConversion)
+            List<(string Find, string Replace, bool FirstOnly)> projectReferenceReplacements,
+            IProgress<ConversionProgress> showProgressMessage,
+            CancellationToken cancellationToken, ILanguageConversion languageConversion,
+            SolutionFileTextEditor solutionFileTextEditor)
         {
             _solutionFilePath = solutionFilePath;
             _sourceSolutionContents = sourceSolutionContents;
@@ -52,6 +77,7 @@ private SolutionConverter(string solutionFilePath,
             _progress = showProgressMessage;
             _languageConversion = languageConversion;
             _cancellationToken = cancellationToken;
+            _solutionFileTextEditor = solutionFileTextEditor;
         }
 
         public IAsyncEnumerable<ConversionResult> Convert()
@@ -76,34 +102,32 @@ private IAsyncEnumerable<ConversionResult> ConvertProject(Project project)
 
         private IEnumerable<ConversionResult> UpdateProjectReferences(IEnumerable<Project> projectsToUpdateReferencesOnly)
         {
-            return projectsToUpdateReferencesOnly
-                .Where(p => p.FilePath != null) //Some project types like Websites don't have a project file
-                .Select(project => {
+            var conversionResults = projectsToUpdateReferencesOnly
+               .Where(p => p.FilePath != null) //Some project types like Websites don't have a project file
+               .Select(project => {
                     var withReferencesReplaced =
                         new FileInfo(project.FilePath).ConversionResultFromReplacements(_projectReferenceReplacements);
                     withReferencesReplaced.TargetPathOrNull = withReferencesReplaced.SourcePathOrNull;
                     return withReferencesReplaced;
-                }).Where(c => !c.IsIdentity);
-        }
+                });
 
-        private static List<(string Find, string Replace, bool FirstOnly)> GetProjectReferenceReplacements(IReadOnlyCollection<Project> projectsToConvert, string sourceSolutionContents) =>
-            SolutionFileTextEditor.GetProjectReferenceReplacements(projectsToConvert.Select(p => (FilePath: p.FilePath, DirectoryPath: p.GetDirectoryPath())), sourceSolutionContents).ToList();
+            return conversionResults.Where(c => !c.IsIdentity);
+        }
 
-        private ConversionResult ConvertSolutionFile()
+        public ConversionResult ConvertSolutionFile()
         {
             var projectTypeGuidMappings = _languageConversion.GetProjectTypeGuidMappings();
-            var projectTypeReplacements = _projectsToConvert.SelectMany(project => GetProjectTypeReplacement(project, projectTypeGuidMappings)).ToList();
+            var relativeProjPaths = _projectsToConvert.Select(proj =>
+                (proj.Name, RelativeProjPath: PathConverter.GetRelativePath(_solutionFilePath, proj.FilePath)));
+
+            var slnProjectReferenceReplacements = _solutionFileTextEditor.GetSolutionFileProjectReferenceReplacements(relativeProjPaths,
+                _sourceSolutionContents, projectTypeGuidMappings);
 
-            var convertedSolutionContents = _sourceSolutionContents.Replace(_projectReferenceReplacements.Concat(projectTypeReplacements));
+            var convertedSolutionContents = _sourceSolutionContents.Replace(slnProjectReferenceReplacements);
             return new ConversionResult(convertedSolutionContents) {
                 SourcePathOrNull = _solutionFilePath,
                 TargetPathOrNull = _solutionFilePath
             };
         }
-
-        private IEnumerable<(string, string, bool)> GetProjectTypeReplacement(Project project, IReadOnlyCollection<(string, string)> typeGuidMappings)
-        {
-            return typeGuidMappings.Select(guidReplacement => ($@"Project\s*\(\s*""{guidReplacement.Item1}""\s*\)\s*=\s*""{project.Name}""", $@"Project(""{guidReplacement.Item2}"") = ""{project.Name}""", false));
-        }
     }
 }
diff --git a/CodeConverter/Shared/SolutionFileTextEditor.cs b/CodeConverter/Shared/SolutionFileTextEditor.cs
@@ -1,36 +1,91 @@
-﻿using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-
-namespace ICSharpCode.CodeConverter.Shared
+﻿namespace ICSharpCode.CodeConverter.Shared
 {
-    public class SolutionFileTextEditor
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Text.RegularExpressions;
+
+    public class SolutionFileTextEditor : ISolutionFileTextEditor
     {
-        public static IEnumerable<(string Find, string Replace, bool FirstOnly)> GetProjectReferenceReplacements(IEnumerable<(string FilePath, string DirectoryPath)> projectsToConvert, string sourceSolutionContents)
+        public List<(string Find, string Replace, bool FirstOnly)> GetSolutionFileProjectReferenceReplacements(
+            IEnumerable<(string Name, string RelativeProjPath)> projTuples, string sourceSolutionContents,
+            IReadOnlyCollection<(string, string)> projTypeGuidMappings)
         {
-            foreach (var (projFilePath, projDirPath) in projectsToConvert) {
-                var projFilename = Path.GetFileName(projFilePath);
+            if (string.IsNullOrWhiteSpace(sourceSolutionContents)) return new List<(string Find, string Replace, bool FirstOnly)>();
+
+            var projectReferenceReplacements = new List<(string Find, string Replace, bool FirstOnly)>();
+            foreach ((string projName, string relativeProjPath) in projTuples)
+            {
+                var newProjPath = @"""" + PathConverter.TogglePathExtension(relativeProjPath) + @""", ";
+                var projPathEscaped = @"""" + Regex.Escape(relativeProjPath);
 
-                var newProjFilename = PathConverter.TogglePathExtension(projFilename);
+                (string oldType, string newType) = GetProjectTypeReplacement(projTypeGuidMappings, projName, projPathEscaped,
+                    sourceSolutionContents);
+                (string oldGuid, string newGuid, bool firstOnly) = GetProjectGuidReplacement(projPathEscaped, sourceSolutionContents);
 
-                var projPath = PathConverter.GetFileDirPath(projFilename, projDirPath);
-                var newProjPath = PathConverter.GetFileDirPath(newProjFilename, projDirPath);
+                var oldProjRefReplacement = oldType + projPathEscaped + @""", """ + oldGuid + @"""";
+                var newProjRefReplacement = newType + newProjPath + @"""" + newGuid + @"""";
 
-                var projPathEscaped = Regex.Escape(projPath);
+                projectReferenceReplacements.Add((oldProjRefReplacement, newProjRefReplacement, false));
 
-                yield return (projPathEscaped, newProjPath, false);
-                if (!string.IsNullOrWhiteSpace(sourceSolutionContents) && GetProjectGuidReplacement(projPathEscaped, sourceSolutionContents) is { } replacement) yield return replacement;
+                // this is needed for the guid replacement in the SolutionConfigurationPlatforms GlobalSection 
+                projectReferenceReplacements.Add((oldGuid, newGuid, firstOnly));
             }
+
+            return projectReferenceReplacements;
         }
 
-        private static (string Find, string Replace, bool FirstOnly)? GetProjectGuidReplacement(string projPath, string contents)
+        public List<(string Find, string Replace, bool FirstOnly)> GetProjectFileProjectReferenceReplacements(
+            IEnumerable<(string Name, string RelativeProjPath, string ProjContents)> projTuples, string sourceSolutionContents)
+        {
+            var projectReferenceReplacements = new List<(string Find, string Replace, bool FirstOnly)>();
+            foreach ((string _, string relativeProjPath, string projContents) in projTuples)
+            {
+                var escapedProjPath = Regex.Escape(relativeProjPath);
+                var projRefRegex = new Regex(@"(\\|"")" + escapedProjPath);
+
+                var projRefMatch = projRefRegex.Match(projContents);
+                var characterBeforePath = projRefMatch.Groups[1].Value;
+
+                var extendedEscProjPath = Regex.Escape(characterBeforePath) + escapedProjPath;
+                var newProjPath = characterBeforePath + PathConverter.TogglePathExtension(relativeProjPath);
+
+                projectReferenceReplacements.Add((extendedEscProjPath, newProjPath, false));
+                if (string.IsNullOrWhiteSpace(sourceSolutionContents)) {
+                    continue;
+                }
+
+                projectReferenceReplacements.Add(GetProjectGuidReplacement(escapedProjPath, sourceSolutionContents));
+            }
+
+            return projectReferenceReplacements;
+        }
+
+        private static (string oldProjTypeReference, string newProjTypeReference) GetProjectTypeReplacement(
+            IEnumerable<(string oldTypeGuid, string newTypeGuid)> projTypeGuidMappings, string projName, string projPath,
+            string contents)
+        {
+            foreach ((string oldTypeGuid, string newTypeGuid) in projTypeGuidMappings)
+            {
+                var oldProjTypeReference = $@"Project\s*\(\s*""{oldTypeGuid}""\s*\)\s*=\s*""{projName}"", ";
+                var projGuidRegex = new Regex($@"({oldProjTypeReference})({projPath})");
+                var projTypeReference = projGuidRegex.Match(contents);
+                if(projTypeReference.Groups.Count == 0) continue;
+
+                var oldReference = Regex.Escape(projTypeReference.Groups[1].Value);
+                var newProjTypeReference = $@"Project(""{newTypeGuid}"") = ""{projName}"", ";
+
+                return (oldReference, newProjTypeReference);
+            }
+
+            return default;
+        }
+
+        private static (string Find, string Replace, bool FirstOnly) GetProjectGuidReplacement(string projPath,
+            string contents)
         {
             var projGuidRegex = new Regex(projPath + @""", ""({[0-9A-Fa-f\-]{32,36}})("")");
             var projGuidMatch = projGuidRegex.Match(contents);
-            if (!projGuidMatch.Success) return null;
-
             var oldGuid = projGuidMatch.Groups[1].Value;
             var newGuid = GetDeterministicGuidFrom(new Guid(oldGuid));
             return (oldGuid, newGuid.ToString("B").ToUpperInvariant(), false);
@@ -44,4 +99,4 @@ private static Guid GetDeterministicGuidFrom(Guid guidToConvert)
             return new Guid(deterministicNewBytes.ToArray());
         }
     }
-}
+}
diff --git a/CodeConverter/Shared/TextReplacementConverter.cs b/CodeConverter/Shared/TextReplacementConverter.cs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System.IO;`
	`1`	`+using System;`
	`2`	`+using System.IO;`
`2`	`3`
`3`	`4`	`namespace ICSharpCode.CodeConverter.Shared`
`4`	`5`	`{`
`@@ -33,12 +34,12 @@ private static string GetConvertedExtension(string originalExtension)`
`33`	`34`	`}`
`34`	`35`	`}`
`35`	`36`
`36`		`- public static string GetFileDirPath(string fileName, string dirPath)`
	`37`	`+ public static string GetRelativePath(string relativeTo, string path)`
`37`	`38`	`{`
`38`		`- var dirName = Path.GetFileName(dirPath);`
`39`		`- var fileDirPath = Path.Combine(dirName ?? string.Empty, fileName);`
	`39`	`+ var uri = new Uri(relativeTo);`
	`40`	`+ var rel = Uri.UnescapeDataString(uri.MakeRelativeUri(new Uri(path)).ToString()).Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);`
`40`	`41`
`41`		`- return fileDirPath;`
	`42`	`+ return rel;`
`42`	`43`	`}`
`43`	`44`	`}`
`44`	`45`	`}`