#2227 Move Transform functionality into Rewrite

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)

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,9 @@ public abstract class CommandBase
 
         protected IFileSystem FileSystem { get; set; }
 
-        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.
         protected static bool ValidateNonNegativeCommandLineOption<T>(long optionValue, string optionName)
         {
             bool valid = true;

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,29 @@ public int Run(RewriteOptions options)
                 Stopwatch w = Stopwatch.StartNew();
 
                 bool valid = ValidateOptions(options);
-                if (!valid) { return FAILURE; }
-
-                SarifLog actualLog = ReadSarifFile<SarifLog>(_fileSystem, options.InputFilePath);
+                if (!valid)
+                {
+                    return FAILURE;
+                }
+
+                string actualOutputPath = CommandUtilities.GetTransformedOutputFileName(options);
+
+                SarifLog actualLog = null;
+
+                string inputVersion = SniffVersion(options.InputFilePath);
+                if (!inputVersion.Equals(SarifUtilities.StableSarifVersion))
+                {
+                    //  Transform file and write to output path.  Then continue rewriting as before.
+                    //  TODO:  Consolidate this so only a single write is necessary.
+                    TransformFileToVersionTwo(options, inputVersion, actualOutputPath);
+                    //  We wrote to the output path, so read from it again.
+                    actualLog = ReadSarifFile<SarifLog>(_fileSystem, actualOutputPath);
+                }
+                else
+                {
+                    //  Read from the original input path.
+                    actualLog = ReadSarifFile<SarifLog>(_fileSystem, options.InputFilePath);
+                }
 
                 OptionallyEmittedData dataToInsert = options.DataToInsert.ToFlags();
                 OptionallyEmittedData dataToRemove = options.DataToRemove.ToFlags();
@@ -38,9 +64,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 +90,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.
+            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
+        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 void TransformFileToVersionTwo(SingleFileOptionsBase options, string inputVersion, string outputFilePath)
+        {
+            if (inputVersion == "1.0.0")
+            {
+                //  Converting version 1 to version 2
+                SarifLogVersionOne actualLog = ReadSarifFile<SarifLogVersionOne>(_fileSystem, options.InputFilePath, SarifContractResolverVersionOne.Instance);
+                var visitor = new SarifVersionOneToCurrentVisitor();
+                visitor.VisitSarifLogVersionOne(actualLog);
+                WriteSarifFile(_fileSystem, visitor.SarifLog, outputFilePath, options.Minify);
+            }
+            else
+            {
+                //  Converting prerelease version 2 to version 2
+                PrereleaseCompatibilityTransformer.UpdateToCurrentVersion(
+                    _fileSystem.FileReadAllText(options.InputFilePath),
+                    formatting: options.Formatting,
+                    out string sarifText);
+
+                _fileSystem.FileWriteAllText(outputFilePath, sarifText);
+            }
         }
     }
 }

src/Sarif.Multitool/Program.cs

@@ -46,13 +46,12 @@ public static int Main(string[] args)
                 (ExportValidationConfigurationOptions options) => new ExportValidationConfigurationCommand().Run(options),
                 (ExportValidationRulesMetadataOptions options) => new ExportValidationRulesMetadataCommand().Run(options),
                 (FileWorkItemsOptions fileWorkItemsOptions) => new FileWorkItemsCommand().Run(fileWorkItemsOptions),
-                (ResultMatchingOptions baselineOptions) => new ResultMatchingCommand().Run(baselineOptions),
                 (MergeOptions mergeOptions) => new MergeCommand().Run(mergeOptions),
                 (PageOptions pageOptions) => new PageCommand().Run(pageOptions),
                 (QueryOptions queryOptions) => new QueryCommand().Run(queryOptions),
                 (RebaseUriOptions rebaseOptions) => new RebaseUriCommand().Run(rebaseOptions),
+                (ResultMatchingOptions baselineOptions) => new ResultMatchingCommand().Run(baselineOptions),
                 (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,7 @@ 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" ?
             return null;
         }
 

src/Sarif/Writers/ConsoleLogger.cs

@@ -11,6 +11,8 @@ namespace Microsoft.CodeAnalysis.Sarif.Writers
 {
     public class ConsoleLogger : BaseLogger, IAnalysisLogger
     {
+        //  TODO:  We directly instantiate this logger in two classes, creating 
+        //  unamanged dependencies.  Fix this pattern with dependency injection or a factory.
         public ConsoleLogger(bool quietConsole, string toolName, IEnumerable<FailureLevel> levels = null, IEnumerable<ResultKind> kinds = null) : base(levels, kinds)
         {
             _quietConsole = quietConsole;