Dotnet list package json output implementation

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageReferenceCommands/ListPackage/IListPackageCommandRunner.cs

@@ -7,6 +7,6 @@ namespace NuGet.CommandLine.XPlat
 {
     internal interface IListPackageCommandRunner
     {
-        Task ExecuteCommandAsync(ListPackageArgs packageRefArgs);
+        Task<int> ExecuteCommandAsync(ListPackageArgs packageRefArgs);
     }
 }

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageReferenceCommands/ListPackage/ListPackageArgs.cs

@@ -3,7 +3,10 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Text;
 using System.Threading;
+using NuGet.CommandLine.XPlat.ListPackage;
 using NuGet.Common;
 using NuGet.Configuration;
 
@@ -16,6 +19,8 @@ internal class ListPackageArgs
         public IEnumerable<PackageSource> PackageSources { get; }
         public IEnumerable<string> Frameworks { get; }
         public ReportType ReportType { get; }
+        public IReportRenderer Renderer { get; }
+        public string ArgumentText { get; }
         public bool IncludeTransitive { get; }
         public bool Prerelease { get; }
         public bool HighestPatch { get; }
@@ -31,6 +36,7 @@ internal class ListPackageArgs
         /// <param name="packageSources"> The sources for the packages to check in the case of --outdated </param>
         /// <param name="frameworks"> The user inputed frameworks to look up for their packages </param>
         /// <param name="reportType"> Which report we're producing (e.g. --outdated) </param>
+        /// <param name="renderer">The report output renderer (e.g. console, json)</param>
         /// <param name="includeTransitive"> Bool for --include-transitive present </param>
         /// <param name="prerelease"> Bool for --include-prerelease present </param>
         /// <param name="highestPatch"> Bool for --highest-patch present </param>
@@ -42,6 +48,7 @@ public ListPackageArgs(
             IEnumerable<PackageSource> packageSources,
             IEnumerable<string> frameworks,
             ReportType reportType,
+            IReportRenderer renderer,
             bool includeTransitive,
             bool prerelease,
             bool highestPatch,
@@ -53,12 +60,63 @@ public ListPackageArgs(
             PackageSources = packageSources ?? throw new ArgumentNullException(nameof(packageSources));
             Frameworks = frameworks ?? throw new ArgumentNullException(nameof(frameworks));
             ReportType = reportType;
+            Renderer = renderer;
             IncludeTransitive = includeTransitive;
             Prerelease = prerelease;
             HighestPatch = highestPatch;
             HighestMinor = highestMinor;
             Logger = logger ?? throw new ArgumentNullException(nameof(logger));
             CancellationToken = cancellationToken;
+            ArgumentText = GetReportParameters();
+        }
+
+        private string GetReportParameters()
+        {
+            StringBuilder sb = new StringBuilder();
+
+            switch (ReportType)
+            {
+                case ReportType.Default:
+                    break;
+                case ReportType.Deprecated:
+                    sb.Append(" --deprecated");
+                    break;
+                case ReportType.Outdated:
+                    sb.Append(" --outdated");
+                    break;
+                case ReportType.Vulnerable:
+                    sb.Append(" --vulnerable");
+                    break;
+                default:
+                    break;
+            }
+
+            if (IncludeTransitive)
+            {
+                sb.Append(" --include-transitive");
+            }
+
+            if (Frameworks != null && Frameworks.Any())
+            {
+                sb.Append(" --framework " + string.Join(" ", Frameworks));
+            }
+
+            if (Prerelease)
+            {
+                sb.Append(" --include-prerelease");
+            }
+
+            if (HighestMinor)
+            {
+                sb.Append(" --highest-minor");
+            }
+
+            if (HighestPatch)
+            {
+                sb.Append("--highest-patch");
+            }
+
+            return sb.ToString().Trim();
         }
     }
 }

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageReferenceCommands/ListPackage/ListPackageCommand.cs

@@ -8,6 +8,7 @@
 using System.Linq;
 using System.Threading;
 using Microsoft.Extensions.CommandLineUtils;
+using NuGet.CommandLine.XPlat.ListPackage;
 using NuGet.Commands;
 using NuGet.Common;
 using NuGet.Configuration;
@@ -89,6 +90,16 @@ public static void Register(
                     Strings.ListPkg_ConfigDescription,
                     CommandOptionType.SingleValue);
 
+                var outputFormat = listpkg.Option(
+                    "--format",
+                    Strings.ListPkg_OutputFormatDescription,
+                    CommandOptionType.SingleValue);
+
+                var outputVersion = listpkg.Option(
+                    "--output-version",
+                    Strings.ListPkg_OutputVersionDescription,
+                    CommandOptionType.SingleValue);
+
                 var interactive = listpkg.Option(
                     "--interactive",
                     Strings.NuGetXplatCommand_Interactive,
@@ -117,25 +128,27 @@ public static void Register(
                         isDeprecated: deprecatedReport.HasValue(),
                         isVulnerable: vulnerableReport.HasValue());
 
+                    IReportRenderer reportRenderer = GetOutputType(outputFormat.Value(), outputVersionOption: outputVersion.Value());
+
                     var packageRefArgs = new ListPackageArgs(
                         path.Value,
                         packageSources,
                         framework.Values,
                         reportType,
+                        reportRenderer,
                         includeTransitive.HasValue(),
                         prerelease.HasValue(),
                         highestPatch.HasValue(),
                         highestMinor.HasValue(),
                         logger,
                         CancellationToken.None);
 
-                    DisplayMessages(packageRefArgs);
+                    WarnAboutIncompatibleOptions(packageRefArgs, reportRenderer);
 
                     DefaultCredentialServiceUtility.SetupDefaultCredentialService(getLogger(), !interactive.HasValue());
 
                     var listPackageCommandRunner = getCommandRunner();
-                    await listPackageCommandRunner.ExecuteCommandAsync(packageRefArgs);
-                    return 0;
+                    return await listPackageCommandRunner.ExecuteCommandAsync(packageRefArgs);
                 });
             });
         }
@@ -158,12 +171,43 @@ private static ReportType GetReportType(bool isDeprecated, bool isOutdated, bool
             throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.ListPkg_InvalidOptions));
         }
 
-        private static void DisplayMessages(ListPackageArgs packageRefArgs)
+        private static IReportRenderer GetOutputType(string outputFormatOption, string outputVersionOption)
+        {
+            ReportOutputFormat outputFormat = ReportOutputFormat.Console;
+            if (!string.IsNullOrEmpty(outputFormatOption) &&
+                !Enum.TryParse(outputFormatOption, ignoreCase: true, out outputFormat))
+            {
+                string currentlySupportedFormat = GetEnumValues<ReportOutputFormat>();
+                throw new ArgumentException(string.Format(Strings.ListPkg_InvalidOutputFormat, outputFormatOption, currentlySupportedFormat));
+            }
+
+            if (outputFormat == ReportOutputFormat.Console)
+            {
+                return new ListPackageConsoleRenderer();
+            }
+
+            IReportRenderer jsonReportRenderer;
+
+            var currentlySupportedReportVersions = new List<string> { "1" };
+            // If customer pass unsupported version then error out instead of defaulting to version probably unsupported by customer machine.
+            if (!string.IsNullOrEmpty(outputVersionOption) && !currentlySupportedReportVersions.Contains(outputVersionOption))
+            {
+                throw new ArgumentException(string.Format(Strings.ListPkg_InvalidOutputVersion, outputVersionOption, string.Join(" ,", currentlySupportedReportVersions)));
+            }
+            else
+            {
+                jsonReportRenderer = new ListPackageJsonRenderer();
+            }
+
+            return jsonReportRenderer;
+        }
+
+        private static void WarnAboutIncompatibleOptions(ListPackageArgs packageRefArgs, IReportRenderer reportRenderer)
         {
             if (packageRefArgs.ReportType != ReportType.Outdated &&
                 (packageRefArgs.Prerelease || packageRefArgs.HighestMinor || packageRefArgs.HighestPatch))
             {
-                Console.WriteLine(Strings.ListPkg_VulnerableIgnoredOptions);
+                reportRenderer.AddProblem(ProblemType.Warning, Strings.ListPkg_VulnerableIgnoredOptions);
             }
         }
 
@@ -216,5 +260,13 @@ private static IEnumerable<PackageSource> GetPackageSources(ISettings settings,
 
             return packageSources;
         }
+
+        private static string GetEnumValues<T>() where T : Enum
+        {
+            var enumValues = ((T[])Enum.GetValues(typeof(T)))
+               .Select(x => x.ToString());
+
+            return string.Join(", ", enumValues).ToLower(CultureInfo.CurrentCulture);
+        }
     }
 }