private static bool AddNonCultureResources(Project project, List<string> compilerArgs, string intermediateOutputPath)
        {
            var resgenFiles = CompilerUtil.GetNonCultureResources(project, intermediateOutputPath);

            foreach (var resgenFile in resgenFiles)
            {
                if (ResourceUtility.IsResxFile(resgenFile.InputFile))
                {
                    var result =
                        Command.Create("dotnet-resgen",
                            $"\"{resgenFile.InputFile}\" -o \"{resgenFile.OutputFile}\" -v \"{project.Version.Version}\"")
                            .ForwardStdErr()
                            .ForwardStdOut()
                            .Execute();

                    if (result.ExitCode != 0)
                    {
                        return false;
                    }

                    compilerArgs.Add($"--resource:\"{resgenFile.OutputFile}\",{Path.GetFileName(resgenFile.MetadataName)}");
                }
                else
                {
                    compilerArgs.Add($"--resource:\"{resgenFile.InputFile}\",{Path.GetFileName(resgenFile.MetadataName)}");
                }
            }

            return true;
        }

 public ArtifactPathsCalculator(Project project, string compiledArtifactsPath, string packageArtifactsPath, string configuration)
 {
     _project = project;
     CompiledArtifactsPathParameter = compiledArtifactsPath;
     PackageArtifactsPathParameter = packageArtifactsPath;
     _configuration = configuration;
 }

        private static Func<string, string> GetScriptVariable(Project project, Func<string, string> getVariable)
        {
            var keys = new Dictionary<string, Func<string>>(StringComparer.OrdinalIgnoreCase)
            {
                { "project:Directory", () => project.ProjectDirectory },
                { "project:Name", () => project.Name },
                { "project:Version", () => project.Version.ToString() },
            };

            return key =>
            {
                // try returning key from dictionary
                Func<string> valueFactory;
                if (keys.TryGetValue(key, out valueFactory))
                {
                    return valueFactory();
                }

                // try returning command-specific key
                var value = getVariable(key);
                if (!string.IsNullOrEmpty(value))
                {
                    return value;
                }

                // try returning environment variable
                return Environment.GetEnvironmentVariable(key);
            };
        }

 private static CommandSpec ResolveFromProjectPath(string commandName, IEnumerable<string> args, Project project, string[] inferredExtensionList)
 {
     var commandPath = Env.GetCommandPathFromRootPath(project.ProjectDirectory, commandName, inferredExtensionList);
     return commandPath == null
         ? null
         : CreateCommandSpecPreferringExe(commandName, args, commandPath, CommandResolutionStrategy.ProjectLocal);
 }

        public BuildCommand(
            string projectPath,
            string output="",
            string tempOutput="",
            string configuration="",
            bool noHost=false,
            bool native=false,
            string architecture="",
            string ilcArgs="",
            string ilcPath="",
            string appDepSDKPath="",
            bool nativeCppMode=false,
            string cppCompilerFlags="",
            bool buildProfile=true,
            bool forceIncrementalUnsafe=false
            )
            : base("dotnet")
        {
            _projectPath = projectPath;
            _project = ProjectReader.GetProject(projectPath);

            _outputDirectory = output;
            _tempOutputDirectory = tempOutput;
            _configuration = configuration;
            _noHost = noHost;
            _native = native;
            _architecture = architecture;
            _ilcArgs = ilcArgs;
            _ilcPath = ilcPath;
            _appDepSDKPath = appDepSDKPath;
            _nativeCppMode = nativeCppMode;
            _cppCompilerFlags = cppCompilerFlags;
            _buildProfile = buildProfile;
            _forceIncrementalUnsafe = forceIncrementalUnsafe;
        }

 public static CommandSpec TryResolveScriptCommandSpec(string commandName, IEnumerable<string> args, Project project, string[] inferredExtensionList)
 {
     return ResolveFromRootedCommand(commandName, args) ??
            ResolveFromProjectPath(commandName, args, project, inferredExtensionList) ??
            ResolveFromAppBase(commandName, args) ??
            ResolveFromPath(commandName, args);
 }

        protected static bool AddNonCultureResources(Project project, List<string> compilerArgs, string intermediateOutputPath)
        {
            var resgenFiles = CompilerUtil.GetNonCultureResources(project, intermediateOutputPath);

            foreach (var resgenFile in resgenFiles)
            {
                if (ResourceUtility.IsResxFile(resgenFile.InputFile))
                {
                    var arguments = new[]
                    {
                        resgenFile.InputFile,
                        $"-o:{resgenFile.OutputFile}",
                        $"-v:{project.Version.Version}"
                    };

                    var rsp = Path.Combine(intermediateOutputPath, $"dotnet-resgen-resx.rsp");
                    File.WriteAllLines(rsp, arguments);

                    var result = Resgen.ResgenCommand.Run(new[] { $"@{rsp}" });

                    if (result != 0)
                    {
                        return false;
                    }

                    compilerArgs.Add($"--resource:\"{resgenFile.OutputFile},{Path.GetFileName(resgenFile.MetadataName)}\"");
                }
                else
                {
                    compilerArgs.Add($"--resource:\"{resgenFile.InputFile},{Path.GetFileName(resgenFile.MetadataName)}\"");
                }
            }

            return true;
        }

 public RuntimeOutputFiles(string basePath,
     Project project,
     string configuration,
     NuGetFramework framework,
     string runtimeIdentifier) : base(basePath, project, configuration, framework)
 {
     _runtimeIdentifier = runtimeIdentifier;
 }

        public ScriptExecutorTests()
        {
            _root = Temp.CreateDirectory();

            var sourceTestProjectPath = Path.Combine(s_testProjectRoot, "TestApp");
            binTestProjectPath = _root.CopyDirectory(sourceTestProjectPath).Path;
            project = ProjectContext.Create(binTestProjectPath, NuGetFramework.Parse("netstandardapp1.5")).ProjectFile;
        }

        public static List<CultureResgenIO> GetCultureResources(Project project, string outputPath, CommonCompilerOptions compilationOptions)
        {
            if (compilationOptions.EmbedInclude == null)
            {
                return GetCultureResources(project, outputPath);
            }

            return GetCultureResourcesFromIncludeEntries(project, outputPath, compilationOptions);
        }

 protected override IEnumerable<ProjectContext> BuildProjectContexts(Project project)
 {
     foreach (var framework in project.GetTargetFrameworks())
     {
         yield return CreateBaseProjectBuilder(project)
             .AsDesignTime()
             .WithTargetFramework(framework.FrameworkName)
             .Build();
     }
 }

 public PublishCommand(string projectPath, string framework="", string runtime="", string output="", string config="")
     : base("dotnet")
 {
     _path = projectPath;
     _project = ProjectReader.GetProject(projectPath);
     _framework = framework;
     _runtime = runtime;
     _output = output;
     _config = config;
 }

 public BuildProjectCommand(
     Project project,
     string buildBasePath,
     string configuration,
     string versionSuffix)
 {
     _project = project;
     _buildBasePath = buildBasePath;
     _configuration = configuration;
     _versionSuffix = versionSuffix;
 }

 public BuildProjectCommand(
     Project project,
     string buildBasePath,
     string configuration,
     BuildWorkspace workspace)
 {
     _project = project;
     _buildBasePath = buildBasePath;
     _configuration = configuration;
     _workspace = workspace;
 }

 public PublishCommand(string projectPath, string framework = "", string runtime = "", string output = "", string config = "", bool forcePortable = false, bool noBuild = false)
     : base("dotnet")
 {
     _path = projectPath;
     _project = ProjectReader.GetProject(projectPath);
     _framework = framework;
     _runtime = runtime;
     _output = output;
     _config = config;
     _noBuild = noBuild;
 }

 // used in incremental compilation
 public static List<NonCultureResgenIO> GetNonCultureResources(Project project, string intermediateOutputPath)
 {
     return 
         (from resourceFile in project.Files.ResourceFiles
             let inputFile = resourceFile.Key
             where string.IsNullOrEmpty(ResourceUtility.GetResourceCultureName(inputFile))
             let metadataName = GetResourceFileMetadataName(project, resourceFile)
             let outputFile = ResourceUtility.IsResxFile(inputFile) ? Path.Combine(intermediateOutputPath, metadataName) : null
             select new NonCultureResgenIO(inputFile, outputFile, metadataName)
             ).ToList();
 }

 public BuildProjectCommand(
     Project project, 
     ArtifactPathsCalculator artifactPathsCalculator, 
     string intermediateOutputPath, 
     string configuration)
 {
     _project = project;
     _artifactPathsCalculator = artifactPathsCalculator;
     _intermediateOutputPath = intermediateOutputPath;
     _configuration = configuration;
 }

 public BuildProjectCommand(
     Project project, 
     ArtifactPathsCalculator artifactPathsCalculator, 
     string buildBasePath, 
     string configuration)
 {
     _project = project;
     _artifactPathsCalculator = artifactPathsCalculator;
     _buildBasePath = buildBasePath;
     _configuration = configuration;
 }

 // used in incremental compilation
 public static List<CultureResgenIO> GetCultureResources(Project project, string outputPath)
 {
     return
         (from resourceFileGroup in project.Files.ResourceFiles.GroupBy(resourceFile => ResourceUtility.GetResourceCultureName(resourceFile.Key))
             let culture = resourceFileGroup.Key
             where !string.IsNullOrEmpty(culture)
             let inputFileToMetadata = resourceFileGroup.ToDictionary(r => r.Key, r => GetResourceFileMetadataName(project, r))
             let resourceOutputPath = Path.Combine(outputPath, culture)
             let outputFile = Path.Combine(resourceOutputPath, project.Name + ".resources.dll")
             select new CultureResgenIO(culture, inputFileToMetadata, outputFile)
             ).ToList();
 }

        public static Command CreateForScript(string commandName, IEnumerable<string> args, Project project, string[] inferredExtensionList)
        {
            var commandSpec = CommandResolver.TryResolveScriptCommandSpec(commandName, args, project, inferredExtensionList);

            if (commandSpec == null)
            {
                throw new CommandUnknownException(commandName);
            }

            var command = new Command(commandSpec);

            return command;
        }