Move logic to ToolRunFromSourceCommand.cs

Author: edvilme

src/Cli/dotnet/Commands/Tool/Run/ToolRunCommand.cs

@@ -7,6 +7,7 @@
 using Microsoft.DotNet.Cli.CommandFactory;
 using Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
 using Microsoft.DotNet.Cli.Commands.Tool.Install;
+using Microsoft.DotNet.Cli.NuGetPackageDownloader;
 using Microsoft.DotNet.Cli.ToolManifest;
 using Microsoft.DotNet.Cli.ToolPackage;
 using Microsoft.DotNet.Cli.Utils;
@@ -16,18 +17,15 @@ namespace Microsoft.DotNet.Cli.Commands.Tool.Run;
 
 internal class ToolRunCommand(
     ParseResult result,
-    LocalToolsCommandResolver localToolsCommandResolver = null,
-    ToolManifestFinder toolManifest = null) : CommandBase(result)
+    LocalToolsCommandResolver localToolsCommandResolver = null) : CommandBase(result)
 {
     private readonly string _toolCommandName = result.GetValue(ToolRunCommandParser.CommandNameArgument);
-    private readonly LocalToolsCommandResolver _localToolsCommandResolver = localToolsCommandResolver ?? new LocalToolsCommandResolver();
     private readonly IEnumerable<string> _forwardArgument = result.GetValue(ToolRunCommandParser.CommandArgument);
-    public bool _allowRollForward = result.GetValue(ToolRunCommandParser.RollForwardOption);
-    private readonly ToolManifestFinder _toolManifest = toolManifest ?? new ToolManifestFinder(new DirectoryPath(Directory.GetCurrentDirectory()));
     private readonly bool _fromSource = result.GetValue(ToolRunCommandParser.FromSourceOption);
 
-    private readonly IToolManifestEditor _toolManifestEditor = new ToolManifestEditor();
-    private readonly ILocalToolsResolverCache _localToolsResolverCache = new LocalToolsResolverCache();
+    private readonly LocalToolsCommandResolver _localToolsCommandResolver = localToolsCommandResolver ?? new LocalToolsCommandResolver();
+    public bool _allowRollForward = result.GetValue(ToolRunCommandParser.RollForwardOption);
+
     public override int Execute()
     {
         CommandSpec commandSpec = _localToolsCommandResolver.ResolveStrict(new CommandResolverArguments()
@@ -38,9 +36,10 @@ public override int Execute()
 
         }, _allowRollForward);
 
-        if (commandSpec == null && _fromSource && UserAgreedToExecuteFromSource())
+        if (commandSpec == null && _fromSource)
         {
-            return ExecuteFromSource();
+            // Reroute to ToolRunFromSourceCommand
+            return new ToolRunFromSourceCommand(_parseResult).Execute();
         }
 
         if (commandSpec == null)
@@ -52,50 +51,5 @@ public override int Execute()
         return result.ExitCode;
     }
 
-    public int ExecuteFromSource()
-    {
-        string tempDirectory = PathUtilities.CreateTempSubdirectory();
-        FilePath manifestFile = _toolManifest.FindFirst(true);
-        PackageId packageId = new(_toolCommandName);
-
-        ToolInstallLocalInstaller _toolInstaller = new(_parseResult, new ToolPackageDownloader(
-            store: new ToolPackageStoreAndQuery(new DirectoryPath(tempDirectory))));
-
-        IToolPackage toolPackage = _toolInstaller.Install(manifestFile, packageId);
-
-        _toolManifestEditor.Add(
-            manifestFile,
-            toolPackage.Id,
-            toolPackage.Version,
-            [toolPackage.Command.Name],
-            _allowRollForward);
-
-        _localToolsResolverCache.SaveToolPackage(
-            toolPackage,
-            _toolInstaller.TargetFrameworkToInstall);
-
-        CommandSpec commandSpec = _localToolsCommandResolver.ResolveStrict(new CommandResolverArguments()
-        {
-            CommandName = $"dotnet-{toolPackage.Command.Name}",
-            CommandArguments = _forwardArgument,
-        }, _allowRollForward);
-
-        if (commandSpec == null)
-        {
-            throw new GracefulException([string.Format(CliCommandStrings.CannotFindCommandName, _toolCommandName)], isUserError: false);
-        }
-
-        var result = CommandFactoryUsingResolver.Create(commandSpec).Execute();
-
-        _toolManifestEditor.Remove(manifestFile, toolPackage.Id);
 
-        return result.ExitCode;
-    }
-
-    private bool UserAgreedToExecuteFromSource()
-    {
-        // TODO: Use a better way to ask for user input
-        Console.WriteLine("Tool will be run from source. Accept? [yn]");
-        return Console.ReadLine() == "y";
-    }
 }

src/Cli/dotnet/Commands/Tool/Run/ToolRunCommandParser.cs

@@ -4,6 +4,7 @@
 #nullable disable
 
 using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Tool.Install;
 
 namespace Microsoft.DotNet.Cli.Commands.Tool.Run;
 

src/Cli/dotnet/Commands/Tool/Run/ToolRunFromSourceCommand.cs

@@ -0,0 +1,82 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandFactory;
+using Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
+using Microsoft.DotNet.Cli.Commands.Tool.Install;
+using Microsoft.DotNet.Cli.ToolManifest;
+using Microsoft.DotNet.Cli.ToolPackage;
+using Microsoft.DotNet.Cli.Utils;
+using Microsoft.Extensions.EnvironmentAbstractions;
+using NuGet.Versioning;
+
+namespace Microsoft.DotNet.Cli.Commands.Tool.Run
+{
+    internal class ToolRunFromSourceCommand(
+        ParseResult result) : CommandBase(result)
+    {
+        private readonly string? _toolCommandName = result.GetValue(ToolRunCommandParser.CommandNameArgument);
+        private readonly IEnumerable<string>? _forwardArguments = result.GetValue(ToolRunCommandParser.CommandArgument);
+        private readonly bool _allowRollForward = result.GetValue(ToolRunCommandParser.RollForwardOption);
+
+        public override int Execute()
+        {
+            if (!UserAgreedToExecuteFromSource())
+            {
+                return 1;
+            }
+
+            PackageId packageId = new(_toolCommandName);
+            VersionRange versionRange = _parseResult.GetVersionRange();
+
+            string tempDirectory = PathUtilities.CreateTempSubdirectory();
+
+            IToolManifestFinder toolManifestFinder = new ToolManifestFinder(new(tempDirectory));
+            IToolManifestEditor toolManifestEditor = new ToolManifestEditor();
+            FilePath toolManifestPath = toolManifestFinder.FindFirst(true);
+
+            ToolPackageStoreAndQuery toolPackageStoreAndQuery = new(new(tempDirectory));
+            ToolPackageDownloader toolPackageDownloader = new(toolPackageStoreAndQuery);
+
+            IToolPackage toolPackage = toolPackageDownloader.InstallPackage(
+                new PackageLocation(),
+                packageId: packageId,
+                verbosity: VerbosityOptions.d,
+                versionRange: versionRange);
+
+            toolManifestEditor.Add(
+                toolManifestPath,
+                packageId,
+                toolPackage.Version,
+                [toolPackage.Command.Name],
+                rollForward: _allowRollForward);
+
+            LocalToolsCommandResolver localToolsCommandResolver = new();
+
+            CommandSpec commandSpec = localToolsCommandResolver.ResolveStrict(new()
+            {
+                CommandName = $"dotnet-{toolPackage.Command.Name}",
+                CommandArguments = _forwardArguments,
+            }, _allowRollForward);
+
+            if (commandSpec == null)
+            {
+                throw new GracefulException(
+                    string.Format(CliCommandStrings.CannotFindCommandName, _toolCommandName),
+                    isUserError: false);
+            }
+
+            var command = CommandFactoryUsingResolver.Create(commandSpec);
+            var result = command.Execute();
+
+            return result.ExitCode;
+        }
+        private bool UserAgreedToExecuteFromSource()
+        {
+            // TODO: Use a better way to ask for user input
+            Console.WriteLine("Tool will be run from source. Accept? [yn]");
+            return Console.ReadKey().Key == ConsoleKey.Y;
+        }
+    }
+}

src/Cli/dotnet/ToolManifest/IToolManifestEditor.cs

@@ -12,7 +12,7 @@ namespace Microsoft.DotNet.Cli.ToolManifest;
 
 internal interface IToolManifestEditor
 {
-    void Add(FilePath manifest, PackageId packageId, NuGetVersion nuGetVersion, ToolCommandName[] toolCommandNames, bool RollForward = false);
+    void Add(FilePath manifest, PackageId packageId, NuGetVersion nuGetVersion, ToolCommandName[] toolCommandNames, bool rollForward = false);
     void Remove(FilePath manifest, PackageId packageId);
     void Edit(FilePath manifest, PackageId packageId, NuGetVersion newNuGetVersion, ToolCommandName[] newToolCommandNames);
 }