brthor · brthor · Feb 25, 2016 · Feb 29, 2016 · livarcocc · Feb 29, 2016
diff --git a/src/Microsoft.DotNet.Cli.Utils/CommandResolution/AppBaseCommandResolver.cs b/src/Microsoft.DotNet.Cli.Utils/CommandResolution/AppBaseCommandResolver.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Microsoft.DotNet.ProjectModel;
+using Microsoft.DotNet.ProjectModel.Graph;
+using Microsoft.Extensions.PlatformAbstractions;
+using NuGet.Frameworks;
+using NuGet.Packaging;
+namespace Microsoft.DotNet.Cli.Utils
+{
+    internal class AppBaseCommandResolver : ICommandResolver
+    {
+        public CommandSpec Resolve(CommandResolverArguments commandResolverArguments)
+        {
+            if (commandResolverArguments.CommandName == null)
+            {
+                return null;
+            }
+
+            var commandPath = commandResolverArguments.Environment.GetCommandPathFromRootPath(
+                PlatformServices.Default.Application.ApplicationBasePath, 
+                commandResolverArguments.CommandName);
+
+            return commandPath == null
+                ? null
+                : CommandResolverCommon.CreateCommandSpecPreferringExe(
+                    commandResolverArguments.CommandName,
+                    commandResolverArguments.CommandArguments,
+                    commandPath,
+                    CommandResolutionStrategy.BaseDirectory,
+                    commandResolverArguments.Environment);
+        }
+    }
+}
diff --git a/...et.Cli.Utils/CommandResolutionStrategy.cs → ...ndResolution/CommandResolutionStrategy.cs b/...et.Cli.Utils/CommandResolutionStrategy.cs → ...ndResolution/CommandResolutionStrategy.cs
@@ -11,9 +11,12 @@ public enum CommandResolutionStrategy
         //command loaded from the same directory as a project.json file
         ProjectLocal,
 
-        //command loaded from path
+        //command loaded from PATH environment variable
         Path,
 
+        //command loaded from rooted path
+        RootedPath,
+
         //command not found
         None
     }

diff --git a/src/Microsoft.DotNet.Cli.Utils/CommandResolution/CommandResolverArguments.cs b/src/Microsoft.DotNet.Cli.Utils/CommandResolution/CommandResolverArguments.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.DotNet.ProjectModel;
+using Microsoft.DotNet.ProjectModel.Graph;
+using NuGet.Frameworks;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    public class CommandResolverArguments
+    {
+        public string CommandName { get; set; }
+
+        public IEnumerable<string> CommandArguments { get; set; }
+
+        public NuGetFramework Framework { get; set; }
+
+        public string ProjectDirectory { get; set; }
+
+        public string Configuration { get; set; }
+
+        public IEnumerable<string> InferredExtensions { get; set; }
+
+        public IEnvironmentProvider Environment { get; set; }
+    }
+}
diff --git a/src/Microsoft.DotNet.Cli.Utils/CommandResolution/CommandResolverCommon.cs b/src/Microsoft.DotNet.Cli.Utils/CommandResolution/CommandResolverCommon.cs
@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Microsoft.DotNet.ProjectModel;
+using Microsoft.DotNet.ProjectModel.Graph;
+using Microsoft.Extensions.PlatformAbstractions;
+using NuGet.Frameworks;
+using NuGet.Packaging;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    internal class CommandResolverCommon
+    {
+        public static CommandSpec CreateCommandSpecPreferringExe(
+           string commandName,
+           IEnumerable<string> args,
+           string commandPath,
+           CommandResolutionStrategy resolutionStrategy,
+           IEnvironmentProvider environment)
+        {
+            var useComSpec = false;
+
+            if (PlatformServices.Default.Runtime.OperatingSystemPlatform == Platform.Windows &&
+                Path.GetExtension(commandPath).Equals(".cmd", StringComparison.OrdinalIgnoreCase))
+            {
+                var preferredCommandPath = environment.GetCommandPath(commandName, ".exe");
+
+                // Use cmd if we can't find an exe
+                if (preferredCommandPath == null)
+                {
+                    useComSpec = true;
+                }
+                else
+                {
+                    commandPath = preferredCommandPath;
+                }
+            }
+
+            if (useComSpec)
+            {
+                return CreateCmdCommandSpec(commandPath, args, resolutionStrategy);
+            }
+            else
+            {
+                var escapedArgs = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(args);
+                return new CommandSpec(commandPath, escapedArgs, resolutionStrategy);
+            }
+        }
+
+        private static CommandSpec CreateCmdCommandSpec(
+            string command,
+            IEnumerable<string> args,
+            CommandResolutionStrategy resolutionStrategy)
+        {
+            var comSpec = Environment.GetEnvironmentVariable("ComSpec");
+
+            // Handle the case where ComSpec is already the command
+            if (command.Equals(comSpec, StringComparison.OrdinalIgnoreCase))
+            {
+                command = args.FirstOrDefault();
+                args = args.Skip(1);
+            }
+            var cmdEscapedArgs = ArgumentEscaper.EscapeAndConcatenateArgArrayForCmdProcessStart(args);
+
+            if (ArgumentEscaper.ShouldSurroundWithQuotes(command))
+            {
+                command = $"\"{command}\"";
+            }
+
+            var escapedArgString = $"/s /c \"{command} {cmdEscapedArgs}\"";
+
+            return new CommandSpec(comSpec, escapedArgString, resolutionStrategy);
+        }
+    }
+}
diff --git a/src/Microsoft.DotNet.Cli.Utils/CommandResolution/DefaultCommandResolver.cs b/src/Microsoft.DotNet.Cli.Utils/CommandResolution/DefaultCommandResolver.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Microsoft.DotNet.ProjectModel;
+using Microsoft.DotNet.ProjectModel.Graph;
+using Microsoft.Extensions.PlatformAbstractions;
+using NuGet.Frameworks;
+using NuGet.Packaging;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    public class DefaultCommandResolver : ICommandResolver
+    {
+        private IList<ICommandResolver> _orderedCommandResolvers;
+
+        public DefaultCommandResolver() : this(new PackagedCommandSpecCreator()) { }
+
+        public DefaultCommandResolver(IPackagedCommandSpecCreator packagedCommandSpecCreator)
+        {
+            _orderedCommandResolvers = new List<ICommandResolver>
+            {
+                new RootedCommandResolver(),
+                new ProjectDependenciesPackageCommandResolver(packagedCommandSpecCreator),
+                new ProjectToolsPackageCommandResolver(packagedCommandSpecCreator),
+                new AppBaseCommandResolver(),
+                new PathCommandResolver()
+            };
+        }
+
+        public CommandSpec Resolve(CommandResolverArguments commandResolverArguments)
+        {
+            foreach (var commandResolver in _orderedCommandResolvers)
+            {
+                var commandSpec = commandResolver.Resolve(commandResolverArguments);
+
+                if (commandSpec != null)
+                {
+                    return commandSpec;
+                }
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/src/Microsoft.DotNet.Cli.Utils/CommandResolution/ICommandResolver.cs b/src/Microsoft.DotNet.Cli.Utils/CommandResolution/ICommandResolver.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    public interface ICommandResolver
+    {
+        CommandSpec Resolve(CommandResolverArguments arguments);
+    }
+}
diff --git a/src/Microsoft.DotNet.Cli.Utils/CommandResolution/IPackagedCommandSpecCreator.cs b/src/Microsoft.DotNet.Cli.Utils/CommandResolution/IPackagedCommandSpecCreator.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.DotNet.ProjectModel.Graph;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    public interface IPackagedCommandSpecCreator
+    {
+        CommandSpec CreateCommandSpecFromLibrary(
+            LockFilePackageLibrary library,
+            string commandName,
+            IEnumerable<string> commandArguments,
+            IEnumerable<string> allowedExtensions,
+            string nugetPackagesRoot,
+            string depsFilePath = null);
+
+    }
+}
diff --git a/src/Microsoft.DotNet.Cli.Utils/CommandResolution/PackagedCommandSpecCreator.cs b/src/Microsoft.DotNet.Cli.Utils/CommandResolution/PackagedCommandSpecCreator.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Microsoft.DotNet.ProjectModel;
+using Microsoft.DotNet.ProjectModel.Graph;
+using Microsoft.Extensions.PlatformAbstractions;
+using NuGet.Frameworks;
+using NuGet.Packaging;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    internal class PackagedCommandSpecCreator : IPackagedCommandSpecCreator
+    {
+        public CommandSpec CreateCommandSpecFromLibrary(
+            LockFilePackageLibrary library,
+            string commandName,
+            IEnumerable<string> commandArguments,
+            IEnumerable<string> allowedExtensions,
+            string nugetPackagesRoot,
+            string depsFilePath)
+        {
+            var packageDirectory = GetPackageDirectoryFullPath(library, nugetPackagesRoot);
+
+            if (!Directory.Exists(packageDirectory))
+            {
+                return null;
+            }
+
+            var commandFile = GetCommandFileRelativePath(library, commandName, allowedExtensions);
+
+            if (commandFile == null)
+            {
+                return null;
+            }
+
+            var commandPath = Path.Combine(packageDirectory, commandFile);
+
+            return CreateCommandSpecUsingCoreHostIfDll(commandPath, commandArguments, depsFilePath);
+        }
+
+        private string GetPackageDirectoryFullPath(LockFilePackageLibrary library, string nugetPackagesRoot)
+        {
+            var packageDirectory = new VersionFolderPathResolver(nugetPackagesRoot)
+                .GetInstallPath(library.Name, library.Version);
+
+            return packageDirectory;
+        }
+
+        private string GetCommandFileRelativePath(
+            LockFilePackageLibrary library, 
+            string commandName, 
+            IEnumerable<string> allowedExtensions)
+        {
+            // TODO: Should command names be case sensitive?
+            return library.Files
+                    .Where(f => Path.GetFileNameWithoutExtension(f) == commandName)
+                    .Where(e => allowedExtensions.Contains(Path.GetExtension(e)))
+                    .FirstOrDefault();
+        }
+
+        private CommandSpec CreateCommandSpecUsingCoreHostIfDll(
+            string commandPath, 
+            IEnumerable<string> commandArguments, 
+            string depsFilePath)
+        {
+            var commandExtension = Path.GetExtension(commandPath);
+
+            if (commandExtension == FileNameSuffixes.DotNet.DynamicLib)
+            {
+                return CreatePackageCommandSpecUsingDotnetExec(commandPath, commandArguments, depsFilePath);
+            }
+
+            return CreateCommandSpec(commandPath, commandArguments);
+        }
+
+        private CommandSpec CreatePackageCommandSpecUsingDotnetExec(
+            string commandPath, 
+            IEnumerable<string> commandArguments, 
+            string depsFilePath)
+        {
+            var corehost = DotnetExec.HostExePath;
+
+            var arguments = new List<string>();
+            arguments.Add("exec");
+            arguments.Add(commandPath);
+
+            if (depsFilePath != null)
+            {
+                arguments.Add($"--depsfile:{depsFilePath}");
+            }
+
+            arguments.AddRange(commandArguments);
+
+            return CreateCommandSpec(corehost, arguments);
+        }
+
+        private CommandSpec CreateCommandSpec(
+            string commandPath, 
+            IEnumerable<string> commandArguments)
+        {
+            var escapedArgs = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(commandArguments);
+
+            return new CommandSpec(commandPath, escapedArgs, CommandResolutionStrategy.NugetPackage);
+        }   
+    }
+}
diff --git a/src/Microsoft.DotNet.Cli.Utils/CommandResolution/PathCommandResolver.cs b/src/Microsoft.DotNet.Cli.Utils/CommandResolution/PathCommandResolver.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Microsoft.DotNet.ProjectModel;
+using Microsoft.DotNet.ProjectModel.Graph;
+using Microsoft.Extensions.PlatformAbstractions;
+using NuGet.Frameworks;
+using NuGet.Packaging;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    internal class PathCommandResolver : ICommandResolver
+    {
+        public CommandSpec Resolve(CommandResolverArguments commandResolverArguments)
+        {
+            if (commandResolverArguments.CommandName == null 
+                || commandResolverArguments.Environment == null)
+            {
+                return null;
+            }
+
+            var commandPath = commandResolverArguments.Environment
+                .GetCommandPath(commandResolverArguments.CommandName);
+
+            return commandPath == null
+                ? null
+                : CommandResolverCommon.CreateCommandSpecPreferringExe(
+                    commandResolverArguments.CommandName,
+                    commandResolverArguments.CommandArguments,
+                    commandPath,
+                    CommandResolutionStrategy.Path,
+                    commandResolverArguments.Environment);
+        }
+    }
+}