Пример #1
0
        private CommandSpec ResolveFromProjectTools(CommandResolverArguments commandResolverArguments)
        {
            var projectFactory = new ProjectFactory(_environment);
            var project        = projectFactory.GetProject(
                commandResolverArguments.ProjectDirectory,
                commandResolverArguments.Framework,
                commandResolverArguments.Configuration,
                commandResolverArguments.BuildBasePath,
                commandResolverArguments.OutputPath);
            var tools = project.GetTools();

            return(ResolveCommandSpecFromAllToolLibraries(
                       tools,
                       commandResolverArguments.CommandName,
                       commandResolverArguments.CommandArguments.OrEmptyIfNull(),
                       project.GetLockFile(),
                       project));
        }
        private CommandSpec ResolveFromProjectDependencies(
            string projectDirectory,
            NuGetFramework framework,
            string configuration,
            string commandName,
            IEnumerable <string> commandArguments,
            string outputPath,
            string buildBasePath)
        {
            var allowedExtensions = GetAllowedCommandExtensionsFromEnvironment(_environment);

            var projectFactory = new ProjectFactory(_environment);
            var project        = projectFactory.GetProject(
                projectDirectory,
                framework,
                configuration,
                buildBasePath,
                outputPath);

            if (project == null)
            {
                Reporter.Verbose.WriteLine(string.Format(
                                               LocalizableStrings.DidNotFindAMatchingProject,
                                               ProjectDependenciesCommandResolverName,
                                               projectDirectory));
                return(null);
            }

            var depsFilePath = project.DepsJsonPath;

            if (!File.Exists(depsFilePath))
            {
                Reporter.Verbose.WriteLine(string.Format(
                                               LocalizableStrings.DoesNotExist,
                                               ProjectDependenciesCommandResolverName,
                                               depsFilePath));
                return(null);
            }

            var runtimeConfigPath = project.RuntimeConfigJsonPath;

            if (!File.Exists(runtimeConfigPath))
            {
                Reporter.Verbose.WriteLine(string.Format(
                                               LocalizableStrings.DoesNotExist,
                                               ProjectDependenciesCommandResolverName,
                                               runtimeConfigPath));
                return(null);
            }

            var lockFile    = project.GetLockFile();
            var toolLibrary = GetToolLibraryForContext(lockFile, commandName, framework);
            var normalizedNugetPackagesRoot =
                PathUtility.EnsureNoTrailingDirectorySeparator(lockFile.PackageFolders.First().Path);

            var commandSpec = _packagedCommandSpecFactory.CreateCommandSpecFromLibrary(
                toolLibrary,
                commandName,
                commandArguments,
                allowedExtensions,
                normalizedNugetPackagesRoot,
                s_commandResolutionStrategy,
                depsFilePath,
                runtimeConfigPath);

            commandSpec?.AddEnvironmentVariablesFromProject(project);

            return(commandSpec);
        }