Initial commit of regex search feature

Author: ProgrammerAL

README.md

@@ -118,14 +118,26 @@ This is a config file used by the app to determine what updates to run. It is co
         - NpmBuildCommand
           - NpmBuildCommand
             - String. Npm command to "compile" the npm directory. The CLI command that will be run is: `npm run {{NpmBuildCommand}}`
+- RegexSearchOptions
+  - Optional
+  - Regex to search for specific string. Handy for finding things you need to manually update, that this tool can't easily do. For example, setting the correct version of .NET in a YAML file for a CI/CD Pipeline
+  - Required Properties:
+    - Searches:
+      - Collection of searches to make in all files that are not ignored
+        - Object Required Properties:
+          - Search Regex:
+            - String. Regex to search for in all files that are not ignored.
+          - Description:
+            - String. Description to show in the output.
 
 
 ### Example Options File
 
 ```json
+{
 {
   "UpdatePathOptions": {
-    "RootDirectory": "C:/my-repos/my-app-1",
+    "RootDirectory": "D:\\GitHub\\ProgrammerAL\\ProgrammerAlSite",
     "IgnorePatterns": [
       "/samples/",
       "\\samples\\"
@@ -159,9 +171,15 @@ This is a config file used by the app to determine what updates to run. It is co
     }
   },
   "NpmOptions": {
-    "NpmCompileOptions":{
-      "BuildCommand": "publish"
-    }
+    "NpmBuildCommand": "publish"
+  },
+  "RegexSearchOptions": {
+    "Searches": [
+      {
+        "SearchRegex": "[0-9]{1,2}\\..+\\.x",
+        "Description": "YAML Dotnet Version"
+      }
+    ]
   }
 }
 ```

src/CodeUpdater/CodeUpdater/Options/UpdateOptions.cs

@@ -21,6 +21,11 @@ public class UpdateOptions
     /// </summary>
     public NpmOptions? NpmOptions { get; set; }
 
+    /// <summary>
+    /// Regex to search for specific string. Handy for finding things you need to manually update, that this tool can't easily do. For example, setting the correct version of .NET in a YAML file for a CI/CD Pipeline
+    /// </summary>
+    public RegexSearchOptions? RegexSearchOptions { get; set; }
+
     /// <summary>
     /// Options for output logging of the operation
     /// </summary>
@@ -185,3 +190,27 @@ public class LoggingOptions
     /// </summary>
     public string LogLevel { get; set; } = "verbose";
 }
+
+public class RegexSearchOptions
+{
+    /// <summary>
+    /// Collection of searches to make in all files that are not ignored
+    /// </summary>
+    [Required]
+    public required IEnumerable<StringSearch> Searches { get; set; }
+
+    public class StringSearch
+    {
+        /// <summary>
+        /// Regex to search for in all files that are not ignored
+        /// </summary>
+        [Required(AllowEmptyStrings = false)]
+        public required string SearchRegex { get; set; }
+
+        /// <summary>
+        /// Description to show in the output
+        /// </summary>
+        [Required(AllowEmptyStrings = false)]
+        public required string Description { get; set; }
+    }
+}

src/CodeUpdater/CodeUpdater/Program.cs

@@ -30,10 +30,9 @@ static async ValueTask RunAsync(CommandOptions commandOptions)
     var cSharpUpdater = new CSharpUpdater(logger, runProcessHelper, updateOptions);
     var npmUpdater = new NpmUpdater(logger, runProcessHelper);
     var compileRunner = new CompileRunner(logger, runProcessHelper);
+    var regexSearcher = new RegexSearcher(logger, updateOptions);
 
-    var skipPaths = workLocator.DetermineSkipPaths(updateOptions.UpdatePathOptions.IgnorePatterns);
-
-    var updateWork = workLocator.DetermineUpdateWork(updateOptions.UpdatePathOptions.RootDirectory, skipPaths);
+    var updateWork = workLocator.DetermineUpdateWork(updateOptions.UpdatePathOptions.RootDirectory);
 
     var canRun = await validator.VerifyCanRunAsync(updateWork);
 
@@ -45,13 +44,14 @@ static async ValueTask RunAsync(CommandOptions commandOptions)
 
     var csUpdates = await cSharpUpdater.UpdateAllCSharpProjectsAsync(updateWork);
     var npmUpdates = npmUpdater.UpdateNpmPackages(updateWork);
+    var searchResults = regexSearcher.SearchUpdatableFiles(updateWork);
 
     //After updating everything, compile all projects
     //  Don't do this in the above loop in case a project needs an update that would cause it to not compile
     //  So wait for all projects to be updated
     var compileResults = await compileRunner.CompileProjectsAsync(updateWork, updateOptions);
 
-    OutputSummary(updateWork, csUpdates, npmUpdates, compileResults, logger);
+    OutputSummary(updateWork, csUpdates, npmUpdates, compileResults, searchResults, logger);
 }
 
 static ILogger SetupLogger(UpdateOptions updateOptions)
@@ -132,7 +132,7 @@ static async Task<UpdateOptions> LoadUpdateOptionsAsync(string configFilePath)
     return updateOptions;
 }
 
-static void OutputSummary(UpdateWork updateWork, ImmutableArray<CSharpUpdateResult> csUpdates, NpmUpdates npmUpdates, CompileResults compileResults, ILogger logger)
+static void OutputSummary(UpdateWork updateWork, ImmutableArray<CSharpUpdateResult> csUpdates, NpmUpdates npmUpdates, CompileResults compileResults, RegexSearchResults searchResults, ILogger logger)
 {
 #pragma warning disable IDE0058 // Expression value is never used
     var builder = new StringBuilder();
@@ -182,6 +182,29 @@ static void OutputSummary(UpdateWork updateWork, ImmutableArray<CSharpUpdateResu
         builder.AppendLine($"\t{npmCompileFailure.BuildResult}:{npmCompileFailure.Directory}");
     }
 
+    builder.AppendLine();
+    builder.AppendLine("Regex Search Results:");
+    if (searchResults.Results.Any())
+    {
+        var groupedResults = searchResults.Results.GroupBy(x => x.Description);
+        foreach (var group in groupedResults)
+        {
+            builder.AppendLine($"\t{group.Key}:");
+            foreach (var regexSearchResult in group)
+            {
+                builder.AppendLine($"\t\t- {regexSearchResult.FilePath}");
+                foreach (var matchedString in regexSearchResult.MatchedStrings)
+                {
+                    builder.AppendLine($"\t\t\t- {matchedString}");
+                }
+            }
+        }
+    }
+    else
+    {
+        builder.AppendLine("\tNo search results");
+    }
+
     logger.Information(builder.ToString());
 #pragma warning restore IDE0058 // Expression value is never used
 }

src/CodeUpdater/CodeUpdater/Properties/launchSettings.json

@@ -2,7 +2,7 @@
   "profiles": {
     "CodeUpdater": {
       "commandName": "Project",
-      "commandLineArgs": "--config \"../../../sampleUpdateOptions.json"
+      "commandLineArgs": "--options \"../../../sampleUpdateOptions.json"
     }
   }
 }

src/CodeUpdater/CodeUpdater/Results.cs

@@ -30,6 +30,9 @@ public record CompileCsProjResult(string CsProjFile, CompileResultType BuildResu
 public record CompileNpmDirectoryResults(ImmutableArray<CompileNpmDirectoryResult> Results);
 public record CompileNpmDirectoryResult(string Directory, CompileResultType BuildResult);
 
+public record RegexSearchResults(ImmutableArray<RegexSearchResult> Results);
+public record RegexSearchResult(string Description, string FilePath, ImmutableArray<string> MatchedStrings);
+
 public enum CompileResultType
 {
     Success,

src/CodeUpdater/CodeUpdater/Updaters/RegexSearcher.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+using Serilog;
+
+namespace ProgrammerAL.Tools.CodeUpdater.Updaters;
+
+public class RegexSearcher(ILogger Logger, UpdateOptions UpdateOptions)
+{
+    public RegexSearchResults SearchUpdatableFiles(UpdateWork updateWork)
+    {
+        if (UpdateOptions.RegexSearchOptions is null)
+        {
+            Logger.Information("No RegexSearchOptions config set, will not search files text");
+            return new RegexSearchResults(ImmutableArray<RegexSearchResult>.Empty);
+        }
+
+        var builder = ImmutableArray.CreateBuilder<RegexSearchResult>();
+        var allFiles = updateWork.ValidDirectories.SelectMany(x => Directory.GetFiles(x, "*", SearchOption.TopDirectoryOnly));
+        foreach (var filePath in allFiles)
+        {
+            try
+            {
+                var fileText = File.ReadAllText(filePath);
+                foreach (var search in UpdateOptions.RegexSearchOptions.Searches)
+                {
+                    var matches = Regex.Matches(fileText, search.SearchRegex);
+                    if (matches.Any())
+                    {
+                        var matchedStrings = matches.Select(x => x.Value).ToImmutableArray();
+                        builder.Add(new RegexSearchResult(search.Description, filePath, matchedStrings));
+                    }
+                }
+            }
+            catch (IOException)
+            { 
+                Logger.Error($"Could not read file '{filePath}' because of an IO Exception. It may be opened by something else. Skipping...");
+            }
+        }
+
+        return new RegexSearchResults(builder.ToImmutableArray());
+    }
+}

src/CodeUpdater/CodeUpdater/WorkLocator.cs

@@ -9,93 +9,125 @@
 
 namespace ProgrammerAL.Tools.CodeUpdater;
 
-public record UpdateWork(ImmutableArray<string> CsProjectFiles, ImmutableArray<string> NpmDirectories);
+public record UpdateWork(ImmutableArray<string> ValidDirectories, ImmutableArray<string> CsProjectFiles, ImmutableArray<string> NpmDirectories);
 
 public class WorkLocator(ILogger Logger, UpdateOptions UpdateOptions)
 {
-    public ImmutableArray<string> DetermineSkipPaths(IEnumerable<string> additionalSkipPaths)
+    public UpdateWork DetermineUpdateWork(string rootDirectory)
     {
-        var skipPaths = new[]
-        {
-            //Ignore all obj and bin folders
-            @"/obj/Debug/",
-            @"/obj/Release/",
-            @"/bin/Debug/",
-            @"/bin/Release/",
+        var validDirectories = DetermineValidDirectories(rootDirectory);
+        var csProjFiles = FindCsProjFiles(validDirectories);
+        var npmDirectories = FindNpmDirectories(validDirectories);
 
-            //Ignore packages inside node_modules
-            @"/node_modules/"
-        }
-        .ToImmutableArray();
-
-        //Include the same paths, but with backslashes so this is cross-platform
-        skipPaths = skipPaths.AddRange(skipPaths.Select(x => x.Replace("/", "\\")));
-
-        skipPaths = skipPaths.AddRange(additionalSkipPaths);
-
-        return skipPaths;
+        return new UpdateWork(validDirectories, csProjFiles, npmDirectories);
     }
 
-    public UpdateWork DetermineUpdateWork(string rootDirectory, ImmutableArray<string> skipPaths)
+    private ImmutableArray<string> DetermineValidDirectories(string rootDirectory)
     {
-        var csProjFiles = FindCsProjFiles(rootDirectory, skipPaths);
-        var npmDirectories = FindNpmDirectories(rootDirectory, skipPaths);
+        var skipPaths = DetermineSkipPaths(UpdateOptions.UpdatePathOptions.IgnorePatterns);
 
-        return new UpdateWork(csProjFiles, npmDirectories);
-    }
-
-    public ImmutableArray<string> FindCsProjFiles(string rootDirectory, ImmutableArray<string> skipPaths)
-    {
-        var allCsProjFilesPaths = Directory.GetFiles(rootDirectory, "*.csproj", SearchOption.AllDirectories);
-        var validCsProjFilesPaths = new List<string>();
+        //Get all directories, including subdirectories
+        //  Make sure the directory path string includes a trailing slash so we can compare it to the skip paths
+        var allDirectories = Directory.GetDirectories(rootDirectory, "*", SearchOption.AllDirectories)
+                                       .Select(x => $"{x}{Path.DirectorySeparatorChar}");
+        var validDirectories = new List<string>();
 
-        foreach (var csProjFilePath in allCsProjFilesPaths)
+        foreach (var directoryPath in allDirectories)
         {
-            var skipPath = skipPaths.FirstOrDefault(x => csProjFilePath.Contains(x, StringComparison.OrdinalIgnoreCase));
+            var skipPath = skipPaths.FirstOrDefault(x => directoryPath.Contains(x, StringComparison.OrdinalIgnoreCase));
             if (skipPath is object)
             {
-                Logger.Debug($"Skipping '{csProjFilePath}' file because it's path should be ignored by rule: {skipPath}");
+                Logger.Debug($"Skipping directory '{directoryPath}' because it's path should be ignored by rule: {skipPath}");
             }
             else
             {
-                validCsProjFilesPaths.Add(csProjFilePath);
+                validDirectories.Add(directoryPath);
             }
         }
 
+        return validDirectories.ToImmutableArray();
+    }
+
+    public ImmutableArray<string> FindCsProjFiles(ImmutableArray<string> validDirectories)
+    {
+        if (UpdateOptions.CSharpOptions is null)
+        {
+            Logger.Information("No CSharpOptions config set, will not attempt to update any C# code");
+            return ImmutableArray<string>.Empty;
+        }
+
+        var validCsProjFilesPaths = new List<string>();
+
+        foreach (var dir in validDirectories)
+        {
+            var allCsProjFilesPaths = Directory.GetFiles(dir, "*.csproj", SearchOption.TopDirectoryOnly);
+            validCsProjFilesPaths.AddRange(allCsProjFilesPaths);
+        }
+
         return validCsProjFilesPaths.ToImmutableArray();
     }
 
-    public ImmutableArray<string> FindNpmDirectories(string rootDirectory, ImmutableArray<string> skipPaths)
+    public ImmutableArray<string> FindNpmDirectories(ImmutableArray<string> validDirectories)
     {
         if (UpdateOptions.NpmOptions is null)
         {
             Logger.Information("No NpmOptions config set, will not attempt to update NPM Packages");
             return ImmutableArray<string>.Empty;
         }
 
-        var allPackageJsonPaths = Directory.GetFiles(rootDirectory, "package.json", SearchOption.AllDirectories);
         var validPaths = new List<string>();
 
-        foreach (var packageJsonPath in allPackageJsonPaths)
+        foreach (var dir in validDirectories)
         {
-            var packagePath = Path.GetDirectoryName(packageJsonPath);
-            if (string.IsNullOrWhiteSpace(packagePath))
+            var packageJsonFiles = Directory.GetFiles(dir, "package.json", SearchOption.TopDirectoryOnly);
+
+            var packageJsonFile = packageJsonFiles.FirstOrDefault();
+
+            if (string.IsNullOrWhiteSpace(packageJsonFile))
             {
-                Logger.Debug($"Skipping '{packageJsonPath}' file because it's path is null or empty");
+                Logger.Debug($"Skipping directory '{dir}' because it doesn't have a package.json file in it");
                 continue;
             }
 
-            var skipPath = skipPaths.FirstOrDefault(x => packagePath.Contains(x, StringComparison.OrdinalIgnoreCase));
-            if (skipPath is object)
-            {
-                Logger.Debug($"Skipping '{packagePath}' because it's path should be ignored by rule: {skipPath}");
-            }
-            else
+            var packagePath = Path.GetDirectoryName(packageJsonFile);
+            if (string.IsNullOrWhiteSpace(packagePath))
             {
-                validPaths.Add(packagePath);
+                Logger.Debug($"Skipping '{packageJsonFile}' file because it's package.json path is null or empty");
+                continue;
             }
+
+            validPaths.Add(packagePath);
         }
 
         return validPaths.ToImmutableArray();
     }
+
+    private ImmutableArray<string> DetermineSkipPaths(IEnumerable<string> additionalSkipPaths)
+    {
+        var skipPaths = new[]
+        {
+            //Ignore all obj and bin folders
+            @"/obj/",
+            @"/obj/Debug/",
+            @"/obj/Release/",
+            @"/bin/",
+            @"/bin/Debug/",
+            @"/bin/Release/",
+
+            //Ignore packages inside node_modules
+            @"/node_modules/",
+
+            //Ignore the .git folder
+            @"/.git/",
+            @"/.vs/",
+        }
+        .ToImmutableArray();
+
+        //Include the same paths, but with backslashes so this is cross-platform
+        skipPaths = skipPaths.AddRange(skipPaths.Select(x => x.Replace("/", "\\")));
+
+        skipPaths = skipPaths.AddRange(additionalSkipPaths);
+
+        return skipPaths;
+    }
 }