FileSystems TextReplConverter and SolutionConverter are now injectable.

Zubin Ramlakhan · Zubin Ramlakhan · commit 92ae6b808a6d · 2021-06-14T01:16:13.000+02:00
diff --git a/CodeConverter/Shared/ProjectConversion.cs b/CodeConverter/Shared/ProjectConversion.cs
@@ -10,11 +10,10 @@
 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;
@@ -82,7 +81,8 @@ private static ConversionResult GetSingleResultForDocument(ConversionResult[] co
         }
 
         public static async IAsyncEnumerable<ConversionResult> ConvertProject(Project project,
-            ILanguageConversion languageConversion, IProgress<ConversionProgress> progress,
+            ILanguageConversion languageConversion, TextReplacementConverter textReplacementConverter,
+            IProgress<ConversionProgress> progress,
             IEnumerable<IAssemblySymbol> assembliesBeingConverted,
             [EnumeratorCancellation] CancellationToken cancellationToken,
             params (string Find, string Replace, bool FirstOnly)[] replacements)
@@ -93,12 +93,14 @@ public static async IAsyncEnumerable<ConversionResult> ConvertProject(Project pr
             var sourceFilePaths = project.Documents.Concat(projectContentsConverter.SourceProject.AdditionalDocuments).Select(d => d.FilePath).ToImmutableHashSet();
             var convertProjectContents = ConvertProjectContents(projectContentsConverter, languageConversion, progress, cancellationToken);
 
-            var results = WithProjectFile(projectContentsConverter, languageConversion, sourceFilePaths, convertProjectContents, replacements);
+            var results = WithProjectFile(projectContentsConverter, textReplacementConverter, languageConversion, sourceFilePaths, convertProjectContents, replacements);
             await foreach (var result in results.WithCancellation(cancellationToken)) yield return result;
         }
 
         /// <remarks>Perf: Keep lazy so that we don't keep an extra copy of all files in memory at once</remarks>
-        private static async IAsyncEnumerable<ConversionResult> WithProjectFile(IProjectContentsConverter projectContentsConverter, ILanguageConversion languageConversion, ImmutableHashSet<string> originalSourcePaths, IAsyncEnumerable<ConversionResult> convertProjectContents, (string Find, string Replace, bool FirstOnly)[] replacements)
+        private static async IAsyncEnumerable<ConversionResult> WithProjectFile(IProjectContentsConverter projectContentsConverter, TextReplacementConverter textReplacementConverter,
+            ILanguageConversion languageConversion, ImmutableHashSet<string> originalSourcePaths,
+            IAsyncEnumerable<ConversionResult> convertProjectContents, (string Find, string Replace, bool FirstOnly)[] replacements)
         {
             var project = projectContentsConverter.SourceProject;
             var projectDir = project.GetDirectoryPath();
@@ -129,14 +131,17 @@ private static async IAsyncEnumerable<ConversionResult> WithProjectFile(IProject
                     ChangeLanguageVersionRegex(projectContentsConverter.LanguageVersion)
                 }).ToArray();
 
-            yield return ConvertProjectFile(project, languageConversion, replacementSpecs);
+            yield return ConvertProjectFile(project, languageConversion, textReplacementConverter, replacementSpecs);
         }
 
         public static ConversionResult ConvertProjectFile(Project project,
             ILanguageConversion languageConversion,
+            TextReplacementConverter textReplacementConverter,
             params (string Find, string Replace, bool FirstOnly)[] textReplacements)
         {
-            return new FileInfo(project.FilePath).ConversionResultFromReplacements(textReplacements,
+            var fileInfo = new FileInfo(project.FilePath);
+
+            return textReplacementConverter.ConversionResultFromReplacements(fileInfo, textReplacements,
                 languageConversion.PostTransformProjectFile);
         }
 
diff --git a/CodeConverter/Shared/SolutionConverter.cs b/CodeConverter/Shared/SolutionConverter.cs
@@ -20,39 +20,34 @@ public class SolutionConverter
         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);
-        }
+        private readonly TextReplacementConverter _textReplacementConverter;
 
         public static SolutionConverter CreateFor<TLanguageConversion>(IReadOnlyCollection<Project> projectsToConvert,
             ConversionOptions conversionOptions = default,
             IProgress<ConversionProgress> progress = null,
             CancellationToken cancellationToken = default,
+            IFileSystem fileSystem = null,
             string solutionContents = "") where TLanguageConversion : ILanguageConversion, new()
         {
             var conversion = new TLanguageConversion { ConversionOptions = conversionOptions };
-            return CreateFor(conversion, projectsToConvert, progress, cancellationToken, solutionContents);
+            return CreateFor(conversion, projectsToConvert, progress, cancellationToken, fileSystem, solutionContents);
         }
 
         public static SolutionConverter CreateFor(ILanguageConversion languageConversion, IReadOnlyCollection<Project> projectsToConvert,
-            IProgress<ConversionProgress> progress,
-            CancellationToken cancellationToken, string solutionContents = "")
+            IProgress<ConversionProgress> progress, CancellationToken cancellationToken, IFileSystem fileSystem = null, string solutionContents = "")
         {
             languageConversion.ConversionOptions ??= new ConversionOptions();
+            fileSystem ??= new FileSystem();
+
             var solutionFilePath = projectsToConvert.First().Solution.FilePath;
-            var sourceSolutionContents = File.Exists(solutionFilePath)
-                ? FileSystem.File.ReadAllText(solutionFilePath)
+            var sourceSolutionContents = fileSystem.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);
+                var projContents = fileSystem.File.ReadAllText(proj.FilePath);
 
                 return (proj.Name, RelativeProjPath: relativeProjPath, ProjContents: projContents);
             });
@@ -61,15 +56,15 @@ public static SolutionConverter CreateFor(ILanguageConversion languageConversion
             var projectReferenceReplacements = solutionFileTextEditor.GetProjectFileProjectReferenceReplacements(projTuples, sourceSolutionContents);
 
             return new SolutionConverter(solutionFilePath, sourceSolutionContents, projectsToConvert, projectReferenceReplacements,
-                progress ?? new Progress<ConversionProgress>(), cancellationToken, languageConversion, solutionFileTextEditor);
+                progress ?? new Progress<ConversionProgress>(), cancellationToken, languageConversion, solutionFileTextEditor, fileSystem);
         }
 
         private SolutionConverter(string solutionFilePath,
             string sourceSolutionContents, IReadOnlyCollection<Project> projectsToConvert,
             List<(string Find, string Replace, bool FirstOnly)> projectReferenceReplacements,
             IProgress<ConversionProgress> showProgressMessage,
             CancellationToken cancellationToken, ILanguageConversion languageConversion,
-            SolutionFileTextEditor solutionFileTextEditor)
+            SolutionFileTextEditor solutionFileTextEditor, IFileSystem fileSystem)
         {
             _solutionFilePath = solutionFilePath;
             _sourceSolutionContents = sourceSolutionContents;
@@ -79,6 +74,7 @@ private SolutionConverter(string solutionFilePath,
             _languageConversion = languageConversion;
             _cancellationToken = cancellationToken;
             _solutionFileTextEditor = solutionFileTextEditor;
+            _textReplacementConverter = new TextReplacementConverter(fileSystem);
         }
 
         public async IAsyncEnumerable<ConversionResult> Convert()
@@ -103,17 +99,20 @@ private IAsyncEnumerable<ConversionResult> ConvertProject(Project project, IEnum
         {
             var replacements = _projectReferenceReplacements.ToArray();
             _progress.Report(new ConversionProgress($"Converting {project.Name}..."));
-            return ProjectConversion.ConvertProject(project, _languageConversion, _progress, assembliesBeingConverted, _cancellationToken, replacements);
+            return ProjectConversion.ConvertProject(project, _languageConversion, _textReplacementConverter, _progress, assembliesBeingConverted, _cancellationToken, replacements);
         }
 
         private IEnumerable<ConversionResult> UpdateProjectReferences(IEnumerable<Project> projectsToUpdateReferencesOnly)
         {
             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);
+                    var fileInfo = new FileInfo(project.FilePath);
+
+                    var withReferencesReplaced = 
+                        _textReplacementConverter.ConversionResultFromReplacements(fileInfo, _projectReferenceReplacements);
                     withReferencesReplaced.TargetPathOrNull = withReferencesReplaced.SourcePathOrNull;
+
                     return withReferencesReplaced;
                 });
 
@@ -129,7 +128,7 @@ public ConversionResult ConvertSolutionFile()
             var slnProjectReferenceReplacements = _solutionFileTextEditor.GetSolutionFileProjectReferenceReplacements(relativeProjPaths,
                 _sourceSolutionContents, projectTypeGuidMappings);
 
-            var convertedSolutionContents = _sourceSolutionContents.Replace(slnProjectReferenceReplacements);
+            var convertedSolutionContents = _textReplacementConverter.Replace(_sourceSolutionContents, slnProjectReferenceReplacements);
             return new ConversionResult(convertedSolutionContents) {
                 SourcePathOrNull = _solutionFilePath,
                 TargetPathOrNull = _solutionFilePath
diff --git a/CodeConverter/Shared/TextReplacementConverter.cs b/CodeConverter/Shared/TextReplacementConverter.cs
@@ -6,20 +6,26 @@ namespace ICSharpCode.CodeConverter.Shared
     using System.Text.RegularExpressions;
     using System.IO.Abstractions;
 
-    public static class TextReplacementConverter
+    public class TextReplacementConverter
     {
-        public static IFileSystem FileSystem { get; set; } = new FileSystem();
+        private readonly IFileSystem _fileSystem;
 
-        public static ConversionResult ConversionResultFromReplacements(this FileInfo filePath, IEnumerable<(string Find, string Replace, bool FirstOnly)> replacements, Func<string, string> postReplacementTransform = null)
+        public TextReplacementConverter(IFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+
+        public ConversionResult ConversionResultFromReplacements(FileInfo filePath, IEnumerable<(string Find, string Replace, bool FirstOnly)> replacements,
+            Func<string, string> postReplacementTransform = null)
         {
             postReplacementTransform ??= (s => s);
-            var oldProjectText = FileSystem.File.ReadAllText(filePath.FullName);
-            var newProjectText = oldProjectText.Replace(replacements);
+            var oldProjectText = _fileSystem.File.ReadAllText(filePath.FullName);
+            var newProjectText = Replace(oldProjectText, replacements);
             string withReplacements = postReplacementTransform(newProjectText);
             return new ConversionResult(withReplacements) { SourcePathOrNull = filePath.FullName, IsIdentity = oldProjectText == withReplacements};
         }
 
-        public static string Replace(this string originalText, IEnumerable<(string Find, string Replace, bool FirstOnly)> replacements)
+        public string Replace(string originalText, IEnumerable<(string Find, string Replace, bool FirstOnly)> replacements)
         {
             foreach (var (oldValue, newValue, firstOnly) in replacements) {
                 Regex regex = new Regex(oldValue, RegexOptions.IgnoreCase);
diff --git a/Tests/LanguageAgnostic/SolutionFileTextEditorTests.cs b/Tests/LanguageAgnostic/SolutionFileTextEditorTests.cs
