#2227 Move Transform functionality into Rewrite

src/ReleaseHistory.md

@@ -1,5 +1,7 @@
 # SARIF Package Release History (SDK, Driver, Converters, and Multitool)
 
+* BREAKING: Move `transform` functionality into `rewrite` and delete redundant `transform` command. [#2252](https://github.com/microsoft/sarif-sdk/pull/2252)
+
 ## **v2.4.0** [Sdk](https://www.nuget.org/packages/Sarif.Sdk/2.4.0) | [Driver](https://www.nuget.org/packages/Sarif.Driver/2.4.0) | [Converters](https://www.nuget.org/packages/Sarif.Converters/2.4.0) | [Multitool](https://www.nuget.org/packages/Sarif.Multitool/2.4.0) | [Multitool Library](https://www.nuget.org/packages/Sarif.Multitool.Library/2.4.0)
 * BREAKING: Entirely remove `verbose` whose fuctionality has been replaced by `--level` and `--kind`. [#2241](https://github.com/microsoft/sarif-sdk/pull/2241)
 * BREAKING: Rename `LoggingOptions` to `LogFilePersistenceOptions`. [#2241](https://github.com/microsoft/sarif-sdk/pull/2241)

src/Sarif.Driver/DriverExtensionMethods.cs

@@ -34,12 +34,24 @@ public static LogFilePersistenceOptions ConvertToLogFilePersistenceOptions(this
         /// </returns>
         public static bool Validate(this SingleFileOptionsBase options)
         {
-            bool valid = true;
+            if (options.SarifOutputVersion == SarifVersion.Unknown)
+            {
+                //  Parsing the output version failed and the the enum evaluated to 0.
+                Console.WriteLine(DriverResources.ErrorInvalidTransformTargetVersion);
+                return false;
+            }
 
-            valid &= options.ValidateOutputLocationOptions();
-            valid &= options.ValidateOutputFormatOptions();
+            if (!options.ValidateOutputLocationOptions())
+            {
+                return false;
+            }
 
-            return valid;
+            if (!options.ValidateOutputFormatOptions())
+            {
+                return false;
+            }
+
+            return true;
         }
 
         private static bool ValidateOutputLocationOptions(this SingleFileOptionsBase options)
@@ -139,6 +151,7 @@ public static bool ValidateOutputOptions(this MultipleFilesOptionsBase options)
             bool valid = true;
 
             //  TODO:  Is it correct to modify options in a "validate" method?
+            //  #2267 https://github.com/microsoft/sarif-sdk/issues/2267
             if (options.Inline)
             {
                 options.Force = true;

src/Sarif.Driver/DriverResources.resx

@@ -184,4 +184,7 @@
   <data name="OptionValueMustBeNonNegative" xml:space="preserve">
     <value>The value of the '{0}' option must be greater than or equal to zero.</value>
   </data>
+  <data name="ErrorInvalidTransformTargetVersion" xml:space="preserve">
+    <value>Target version must be 1 or 2</value>
+  </data>
 </root>

src/Sarif.Driver/Sdk/CommandBase.cs

@@ -18,11 +18,18 @@ public abstract class CommandBase
 
         protected IFileSystem FileSystem { get; set; }
 
+        // TODO:  Removing this constructor broke the one of AbsoluteUriCommand entirely but all unit tests were passing
+        // Add unit tests that will break when this constructor is deleted or malfunctioning.
+        // #2268 https://github.com/microsoft/sarif-sdk/issues/2268
         public CommandBase(IFileSystem fileSystem = null)
         {
             this.FileSystem = fileSystem ?? Sarif.FileSystem.Instance;
         }
 
+        //  TODO:  What's the point of having a bunch of static methods in an abstract class?
+        //  We even have a static class, "CommandUtilities" which seems like the more appropriate 
+        //  place for these to go.
+        //  #2269 https://github.com/microsoft/sarif-sdk/issues/2269
         protected static bool ValidateNonNegativeCommandLineOption<T>(long optionValue, string optionName)
         {
             bool valid = true;

src/Sarif.Driver/Sdk/CommonOptionsBase.cs

@@ -76,7 +76,7 @@ public class CommonOptionsBase
             HelpText =
             "The SARIF version of the output log file. Valid values are OneZeroZero and Current",
             Default = SarifVersion.Current)]
-        public SarifVersion SarifOutputVersion { get; set; }
+        public SarifVersion SarifOutputVersion { get; set; } = SarifVersion.Current;
 
         [Option(
             "threads",

src/Sarif.Multitool.Library/RewriteCommand.cs

@@ -4,9 +4,15 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 
 using Microsoft.CodeAnalysis.Sarif.Driver;
+using Microsoft.CodeAnalysis.Sarif.Readers;
+using Microsoft.CodeAnalysis.Sarif.VersionOne;
 using Microsoft.CodeAnalysis.Sarif.Visitors;
+using Microsoft.CodeAnalysis.Sarif.Writers;
+
+using Newtonsoft.Json;
 
 namespace Microsoft.CodeAnalysis.Sarif.Multitool
 {
@@ -27,9 +33,24 @@ public int Run(RewriteOptions options)
                 Stopwatch w = Stopwatch.StartNew();
 
                 bool valid = ValidateOptions(options);
-                if (!valid) { return FAILURE; }
+                if (!valid)
+                {
+                    return FAILURE;
+                }
+
+                string actualOutputPath = CommandUtilities.GetTransformedOutputFileName(options);
+
+                SarifLog actualLog = null;
 
-                SarifLog actualLog = ReadSarifFile<SarifLog>(_fileSystem, options.InputFilePath);
+                string inputVersion = SniffVersion(options.InputFilePath);
+                if (!inputVersion.Equals(SarifUtilities.StableSarifVersion))
+                {
+                    actualLog = TransformFileToVersionTwo(options.InputFilePath, inputVersion);
+                }
+                else
+                {
+                    actualLog = ReadSarifFile<SarifLog>(_fileSystem, options.InputFilePath);
+                }
 
                 OptionallyEmittedData dataToInsert = options.DataToInsert.ToFlags();
                 OptionallyEmittedData dataToRemove = options.DataToRemove.ToFlags();
@@ -38,9 +59,17 @@ public int Run(RewriteOptions options)
                 SarifLog reformattedLog = new RemoveOptionalDataVisitor(dataToRemove).VisitSarifLog(actualLog);
                 reformattedLog = new InsertOptionalDataVisitor(dataToInsert, originalUriBaseIds).VisitSarifLog(reformattedLog);
 
-                string fileName = CommandUtilities.GetTransformedOutputFileName(options);
+                if (options.SarifOutputVersion == SarifVersion.OneZeroZero)
+                {
+                    var visitor = new SarifCurrentToVersionOneVisitor();
+                    visitor.VisitSarifLog(reformattedLog);
 
-                WriteSarifFile(_fileSystem, reformattedLog, fileName, options.Minify);
+                    WriteSarifFile(_fileSystem, visitor.SarifLogVersionOne, actualOutputPath, options.Minify, SarifContractResolverVersionOne.Instance);
+                }
+                else
+                {
+                    WriteSarifFile(_fileSystem, reformattedLog, actualOutputPath, options.Minify);
+                }
 
                 w.Stop();
                 Console.WriteLine($"Rewrite completed in {w.Elapsed}.");
@@ -56,13 +85,59 @@ public int Run(RewriteOptions options)
 
         private bool ValidateOptions(RewriteOptions rewriteOptions)
         {
-            bool valid = true;
+            if (!rewriteOptions.Validate())
+            {
+                return false;
+            }
 
-            valid &= rewriteOptions.Validate();
+            //  While this is returning true for inline cases, I think it's doing so for the wrong reasons.
+            //  TODO: validate whether "actualOutputPath" can be created.
+            //  #2270 https://github.com/microsoft/sarif-sdk/issues/2270
+            if (!DriverUtilities.ReportWhetherOutputFileCanBeCreated(rewriteOptions.OutputFilePath, rewriteOptions.Force, _fileSystem))
+            {
+                return false;
+            }
 
-            valid &= DriverUtilities.ReportWhetherOutputFileCanBeCreated(rewriteOptions.OutputFilePath, rewriteOptions.Force, _fileSystem);
+            return true;
+        }
 
-            return valid;
+        //  TODO Move this into a separate class for better unit testing
+        //  #2271 https://github.com/microsoft/sarif-sdk/issues/2271
+        private string SniffVersion(string sarifPath)
+        {
+            using (JsonTextReader reader = new JsonTextReader(new StreamReader(_fileSystem.FileOpenRead(sarifPath))))
+            {
+                while (reader.Read())
+                {
+                    if (reader.TokenType == JsonToken.PropertyName && ((string)reader.Value).Equals("version"))
+                    {
+                        reader.Read();
+                        return (string)reader.Value;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private SarifLog TransformFileToVersionTwo(string inputFilePath, string inputVersion)
+        {
+            if (inputVersion == "1.0.0")
+            {
+                //  Converting version 1 to version 2
+                SarifLogVersionOne actualLog = ReadSarifFile<SarifLogVersionOne>(_fileSystem, inputFilePath, SarifContractResolverVersionOne.Instance);
+                var visitor = new SarifVersionOneToCurrentVisitor();
+                visitor.VisitSarifLogVersionOne(actualLog);
+                return visitor.SarifLog;
+            }
+            else
+            {
+                //  Converting prerelease version 2 to version 2
+                return PrereleaseCompatibilityTransformer.UpdateToCurrentVersion(
+                    _fileSystem.FileReadAllText(inputFilePath),
+                    formatting: Formatting.None,
+                    out string _);
+            }
         }
     }
 }

src/Sarif.Multitool/Program.cs

@@ -52,7 +52,6 @@ public static int Main(string[] args)
                 (QueryOptions queryOptions) => new QueryCommand().Run(queryOptions),
                 (RebaseUriOptions rebaseOptions) => new RebaseUriCommand().Run(rebaseOptions),
                 (RewriteOptions rewriteOptions) => new RewriteCommand().Run(rewriteOptions),
-                (TransformOptions transformOptions) => new TransformCommand().Run(transformOptions),
                 (ValidateOptions validateOptions) => new ValidateCommand().Run(validateOptions),
                  _ => HandleParseError(args));
         }

src/Sarif/Visitors/SarifCurrentToVersionOneVisitor.cs

@@ -46,6 +46,8 @@ public override SarifLog VisitSarifLog(SarifLog v2SarifLog)
                 SarifLogVersionOne.Runs.Add(CreateRunVersionOne(v2Run));
             }
 
+            //  TODO: We always return null here.  Is there a pattern that allows us to change the method signature to "void" ?
+            //  #2266  https://github.com/microsoft/sarif-sdk/issues/2266
             return null;
         }