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;
}
/// <summary>
/// Create <see cref="ExtensionInfo"/> and copy properties from <see cref="Project"/>.
/// </summary>
/// <param name="project"></param>
/// <returns></returns>
private static ExtensionInfo ToDescriptor(Project project)
{
var descriptor = new ExtensionInfo();
descriptor.Name = project.Name;
descriptor.Title = project.Title;
descriptor.Description = project.Description;
descriptor.Copyright = project.Copyright;
descriptor.Authors = project.Authors;
descriptor.Version = project.Version.ToString();
descriptor.Dependencies = project.Dependencies.Select(t => t.Name);
return descriptor;
}
public static ICommand CreateCommandForScript(Project project, string scriptCommandLine, Func<string, string> getVariable)
{
var scriptArguments = ParseScriptArguments(project, scriptCommandLine, getVariable);
if (scriptArguments == null)
{
throw new Exception($"ScriptExecutor: failed to parse script \"{scriptCommandLine}\"");
}
var inferredExtensions = DetermineInferredScriptExtensions();
return Command
.CreateForScript(scriptArguments.First(), scriptArguments.Skip(1), project, inferredExtensions)
.WorkingDirectory(project.ProjectDirectory);
}
private static IEnumerable<string> ParseScriptArguments(Project project, string scriptCommandLine, Func<string, string> getVariable)
{
var scriptArguments = CommandGrammar.Process(
scriptCommandLine,
GetScriptVariable(project, getVariable),
preserveSurroundingQuotes: false);
scriptArguments = scriptArguments.Where(argument => !string.IsNullOrEmpty(argument)).ToArray();
if (scriptArguments.Length == 0)
{
return null;
}
return scriptArguments;
}
public OutputPathCalculator(
Project project,
NuGetFramework framework,
string runtimeIdentifier,
string baseOutputPath)
{
_project = project;
_framework = framework;
_runtimeIdentifier = runtimeIdentifier;
BaseOutputPath = string.IsNullOrWhiteSpace(baseOutputPath) ? _project.ProjectDirectory : baseOutputPath;
BaseCompilationOutputPath = string.IsNullOrWhiteSpace(baseOutputPath)
? Path.Combine(_project.ProjectDirectory, DirectoryNames.Bin)
: baseOutputPath;
}
// used in incremental compilation
public static List<NonCultureResgenIO> GetNonCultureResourcesFromIncludeEntries(
Project project,
string intermediateOutputPath,
CommonCompilerOptions compilationOptions)
{
var includeFiles = IncludeFilesResolver.GetIncludeFiles(compilationOptions.EmbedInclude, "/", diagnostics: null);
return
(from resourceFile in includeFiles
let inputFile = resourceFile.SourcePath
where string.IsNullOrEmpty(ResourceUtility.GetResourceCultureName(inputFile))
let target = resourceFile.IsCustomTarget ? resourceFile.TargetPath : null
let metadataName = GetResourceFileMetadataName(project, resourceFile.SourcePath, target)
let outputFile = ResourceUtility.IsResxFile(inputFile) ? Path.Combine(intermediateOutputPath, metadataName) : null
select new NonCultureResgenIO(inputFile, outputFile, metadataName)
).ToList();
}
public GivenThatIWantToLoadAProjectJsonFile()
{
var json = new JObject();
_emptyProject = GetProject(json);
_jsonCompilationOptions = new JObject();
_jsonCompilationOptions.Add("define", new JArray(_someDefines));
_jsonCompilationOptions.Add("nowarn", new JArray(_noWarnings));
_jsonCompilationOptions.Add("additionalArguments", new JArray(_someAdditionalArguments));
_jsonCompilationOptions.Add("languageVersion", SomeLanguageVersion);
_jsonCompilationOptions.Add("outputName", SomeOutputName);
_jsonCompilationOptions.Add("compilerName", SomeCompilerName);
_jsonCompilationOptions.Add("platform", SomePlatform);
_jsonCompilationOptions.Add("keyFile", SomeKeyFile);
_jsonCompilationOptions.Add("debugType", SomeDebugType);
_jsonCompilationOptions.Add("allowUnsafe", true);
_jsonCompilationOptions.Add("warningsAsErrors", true);
_jsonCompilationOptions.Add("optimize", true);
_jsonCompilationOptions.Add("delaySign", true);
_jsonCompilationOptions.Add("publicSign", true);
_jsonCompilationOptions.Add("emitEntryPoint", true);
_jsonCompilationOptions.Add("xmlDoc", true);
_jsonCompilationOptions.Add("preserveCompilationContext", true);
_commonCompilerOptions = new CommonCompilerOptions
{
Defines = _someDefines,
SuppressWarnings = _noWarnings,
AdditionalArguments = _someAdditionalArguments,
LanguageVersion = SomeLanguageVersion,
OutputName = SomeOutputName,
CompilerName = SomeCompilerName,
Platform = SomePlatform,
KeyFile = SomeKeyFile,
DebugType = SomeDebugType,
AllowUnsafe = true,
WarningsAsErrors = true,
Optimize = true,
DelaySign = true,
PublicSign = true,
EmitEntryPoint = true,
GenerateXmlDocumentation = true,
PreserveCompilationContext = true
};
}
public CompilationOutputFiles(
string basePath,
Project project,
string configuration,
NuGetFramework framework)
{
BasePath = basePath;
Project = project;
Configuration = configuration;
Framework = framework;
OutputExtension = FileNameSuffixes.DotNet.DynamicLib;
var compilationOptions = Project.GetCompilerOptions(framework, configuration);
if (framework.IsDesktop() && compilationOptions.EmitEntryPoint.GetValueOrDefault())
{
OutputExtension = FileNameSuffixes.DotNet.Exe;
}
}
public PublishCommand(string projectPath,
string framework = "",
string runtime = "",
string output = "",
string config = "",
bool noBuild = false,
string buildBasePath = "")
: base("dotnet")
{
_path = projectPath;
_project = ProjectReader.GetProject(projectPath);
_framework = framework;
_runtime = runtime;
_output = output;
_config = config;
_noBuild = noBuild;
_buidBasePathDirectory = buildBasePath;
}
public ProjectDescription(
LibraryRange libraryRange,
Project project,
IEnumerable<LibraryRange> dependencies,
TargetFrameworkInformation targetFrameworkInfo,
bool resolved) :
base(
new LibraryIdentity(project.Name, project.Version, LibraryType.Project),
string.Empty, // Projects don't have hashes
project.ProjectFilePath,
dependencies,
targetFrameworkInfo.FrameworkName,
resolved,
compatible: true)
{
Project = project;
TargetFrameworkInfo = targetFrameworkInfo;
}
public static CommandSpec TryResolveScriptCommandSpec(
string commandName,
IEnumerable<string> args,
Project project,
string[] inferredExtensionList)
{
var commandResolverArgs = new CommandResolverArguments
{
CommandName = commandName,
CommandArguments = args,
ProjectDirectory = project.ProjectDirectory,
InferredExtensions = inferredExtensionList
};
var scriptCommandResolver = ScriptCommandResolverPolicy.Create();
return scriptCommandResolver.Resolve(commandResolverArgs);
}
