public void OnBeforeLogo(
NukeBuild build,
IReadOnlyCollection <ExecutableTarget> executableTargets)
{
var completionItems = new SortedDictionary <string, string[]>();
var targetNames = build.ExecutableTargets.Select(x => x.Name).OrderBy(x => x).ToList();
completionItems[Constants.InvokedTargetsParameterName] = targetNames.ToArray();
completionItems[Constants.SkippedTargetsParameterName] = targetNames.ToArray();
var parameters = InjectionUtility.GetParameterMembers(build.GetType(), includeUnlisted: false);
foreach (var parameter in parameters)
{
var parameterName = ParameterService.GetParameterMemberName(parameter);
if (completionItems.ContainsKey(parameterName))
{
continue;
}
var subItems = ParameterService.GetParameterValueSet(parameter, build)?.Select(x => x.Text);
completionItems[parameterName] = subItems?.ToArray();
}
SerializationTasks.YamlSerializeToFile(completionItems, Constants.GetCompletionFile(NukeBuild.RootDirectory));
if (EnvironmentInfo.GetParameter <bool>(Constants.CompletionParameterName))
{
Environment.Exit(exitCode: 0);
}
}
private static IEnumerable <InstalledPackage> GetLocalInstalledPackagesFromAssetsFile(
string packagesConfigFile,
bool resolveDependencies = true)
{
var assetsObject = SerializationTasks.JsonDeserializeFromFile <JObject>(packagesConfigFile);
// ReSharper disable HeapView.BoxingAllocation
var directReferences =
assetsObject["project"]["frameworks"]
.Single().Single()["dependencies"]
?.Children <JProperty>()
.Select(x => x.Name).ToList()
?? new List <string>();
var allReferences =
assetsObject["libraries"]
.Children <JProperty>()
.Where(x => x.Value["type"].ToString() == "package")
.Select(x => x.Name.Split('/'))
.Select(x => (PackageId: x.First(), Version: x.Last())).ToList();
// ReSharper restore HeapView.BoxingAllocation
foreach (var(name, version) in allReferences)
{
if (!resolveDependencies && !directReferences.Contains(name))
{
continue;
}
yield return(GetGlobalInstalledPackage(name, version, packagesConfigFile));
}
}
public static int Complete(string[] args, [CanBeNull] string rootDirectory, [CanBeNull] string buildScript)
{
if (rootDirectory == null)
{
return(0);
}
var words = args.Single();
if (!words.StartsWithOrdinalIgnoreCase(CommandName))
{
return(0);
}
words = words.Substring(CommandName.Length).TrimStart();
var completionFile = GetCompletionFile((AbsolutePath)rootDirectory);
if (!File.Exists(completionFile))
{
Build(buildScript.NotNull(), $"--{CompletionParameterName}");
return(1);
}
var position = EnvironmentInfo.GetParameter <int?>("position");
var completionItems = SerializationTasks.YamlDeserializeFromFile <Dictionary <string, string[]> >(completionFile);
foreach (var item in CompletionUtility.GetRelevantCompletionItems(words, completionItems))
{
Console.WriteLine(item);
}
return(0);
}
private static void WriteCompletionFile(NukeBuild build)
{
var completionItems = new SortedDictionary <string, string[]>();
var targets = build.ExecutableTargets.OrderBy(x => x.Name).ToList();
completionItems[InvokedTargetsParameterName] = targets.Where(x => x.Listed).Select(x => x.Name).ToArray();
completionItems[SkippedTargetsParameterName] = targets.Select(x => x.Name).ToArray();
var parameters = ValueInjectionUtility.GetParameterMembers(build.GetType(), includeUnlisted: false);
foreach (var parameter in parameters)
{
var parameterName = ParameterService.GetParameterMemberName(parameter);
if (completionItems.ContainsKey(parameterName))
{
continue;
}
var subItems = ParameterService.GetParameterValueSet(parameter, build)?.Select(x => x.Text);
completionItems[parameterName] = subItems?.ToArray();
}
SerializationTasks.YamlSerializeToFile(completionItems, GetCompletionFile(NukeBuild.RootDirectory));
}
public static PackageManifest FromFile(string path = "./vc-package.json")
{
var result = SerializationTasks.JsonDeserializeFromFile <PackageManifest>(path);
PlatformVersion.CurrentVersion = new SemanticVersion(Version.Parse(result.PlatformVersion));
return(result);
}
public static int Complete(string[] args, [CanBeNull] string rootDirectory, [CanBeNull] string buildScript)
{
var words = args.Single();
if (!words.StartsWithOrdinalIgnoreCase("nuke"))
{
return(0);
}
if (rootDirectory == null)
{
// TODO: parse --root parameter
return(0);
}
var completionFile = Constants.GetCompletionFile((PathConstruction.AbsolutePath)rootDirectory);
if (!File.Exists(completionFile))
{
Build(buildScript.NotNull(), $"--{Constants.CompletionParameterName}");
return(1);
}
words = words.Substring("nuke ".Length);
var position = ParameterService.Instance.GetParameter <int?>("position");
var completionItems = SerializationTasks.YamlDeserializeFromFile <Dictionary <string, string[]> >(completionFile);
foreach (var item in GetRelevantCompletionItems(words, position, completionItems))
{
Console.WriteLine(item);
}
return(0);
}
private static Dictionary <string, string> LoadSecrets(IReadOnlyCollection <string> secretParameters, byte[] password, string parametersFile)
{
var jobject = SerializationTasks.JsonDeserializeFromFile <JObject>(parametersFile);
return(jobject.Properties()
.Where(x => secretParameters.Contains(x.Name))
.ToDictionary(x => x.Name, x => Decrypt(x.Value.Value <string>(), password, x.Name)));
}
private static string GetDotNetRuntimeVersion()
{
var globalJsonFile = NukeBuild.RootDirectory / "global.json";
var jobject = File.Exists(globalJsonFile)
? SerializationTasks.JsonDeserializeFromFile <JObject>(globalJsonFile)
: new JObject();
return(jobject["sdk"]?["version"]?.Value <string>().Substring(startIndex: 0, length: 5));
}
public void ChangeProjectVersion(string prefix = null, string suffix = null)
{
//theme
if (IsTheme)
{
//var json = JsonDocument.Parse(File.ReadAllText(PackageJsonPath));
//json.RootElement.GetProperty("version")
var json = SerializationTasks.JsonDeserializeFromFile <JObject>(PackageJsonPath);
json["version"] = prefix;
SerializationTasks.JsonSerializeToFile(json, Path.GetFullPath(PackageJsonPath));
}
else
{
//module.manifest
if (IsModule)
{
var manifest = ModuleManifest.Clone();
if (!String.IsNullOrEmpty(prefix))
{
manifest.Version = prefix;
}
if (!String.IsNullOrEmpty(suffix))
{
manifest.VersionTag = suffix;
}
using (var writer = new Utf8StringWriter())
{
XmlSerializer xml = new XmlSerializer(typeof(ModuleManifest));
xml.Serialize(writer, manifest);
File.WriteAllText(ModuleManifestFile, writer.ToString(), Encoding.UTF8);
}
}
//Directory.Build.props
var xmlDoc = new XmlDocument()
{
PreserveWhitespace = true
};
xmlDoc.LoadXml(File.ReadAllText(DirectoryBuildPropsPath));
if (!String.IsNullOrEmpty(prefix))
{
var prefixNodex = xmlDoc.GetElementsByTagName("VersionPrefix");
prefixNodex[0].InnerText = prefix;
}
if (String.IsNullOrEmpty(VersionSuffix) && !String.IsNullOrEmpty(suffix))
{
var suffixNodes = xmlDoc.GetElementsByTagName("VersionSuffix");
suffixNodes[0].InnerText = suffix;
}
using (var writer = new Utf8StringWriter())
{
xmlDoc.Save(writer);
File.WriteAllText(DirectoryBuildPropsPath, writer.ToString());
}
}
}
private static void SaveSecrets(Dictionary <string, string> secrets, byte[] password, string parametersFile)
{
var jobject = SerializationTasks.JsonDeserializeFromFile <JObject>(parametersFile);
foreach (var(name, secret) in secrets)
{
jobject[name] = Encrypt(secret, password);
}
SerializationTasks.JsonSerializeToFile(jobject, parametersFile);
}
private static List <VSWhereResult> GetResult(IProcess process, VSWhereSettings toolSettings)
{
if (!(toolSettings.UTF8 ?? false) || toolSettings.Format != VSWhereFormat.json || toolSettings.Property != null)
{
return(null);
}
var output = process.Output.EnsureOnlyStd().Select(x => x.Text).JoinNewLine();
return(SerializationTasks.JsonDeserialize <VSWhereResult[]>(output).ToList());
}
private static IEnumerable <string> GetSecretParameters(AbsolutePath rootDirectory)
{
var buildSchemaFile = GetBuildSchemaFile(rootDirectory);
var jobject = SerializationTasks.JsonDeserializeFromFile <JObject>(buildSchemaFile);
return(jobject
.GetPropertyValue("definitions")
.GetPropertyValue("build")
.GetPropertyValue("properties")
.Children <JProperty>()
.Where(x => x.Value.Value <JObject>().GetPropertyValueOrNull <string>("default") != null)
.Select(x => x.Name));
}
private static OctoVersionInfo GetResult(IProcess process, OctoVersionGetVersionSettings toolSettings)
{
Assert.FileExists(toolSettings.OutputJsonFile);
try
{
return(SerializationTasks.JsonDeserializeFromFile <OctoVersionInfo>(toolSettings.OutputJsonFile, settings =>
{
settings.ContractResolver = new AllWritableContractResolver();
return settings;
}));
}
catch (Exception exception)
{
throw new Exception($"Cannot parse {nameof(OctoVersion)} output from {toolSettings.OutputJsonFile.SingleQuote()}.", exception);
}
}
private static GitVersion GetResult(IProcess process, GitVersionSettings toolSettings)
{
var output = process.Output.EnsureOnlyStd().Select(x => x.Text).JoinNewLine();
try
{
return(SerializationTasks.JsonDeserialize <GitVersion>(output, settings =>
{
settings.ContractResolver = new AllWritableContractResolver();
return settings;
}));
}
catch (Exception exception)
{
throw new Exception($"Cannot parse {nameof(GitVersion)} output:".Concat(new[] { output }).JoinNewLine(), exception);
}
}
private static void UpdateGlobalJsonFile(AbsolutePath rootDirectory)
{
var latestInstalledSdk = DotNetTasks.DotNet("--list-sdks", logInvocation: false, logOutput: false)
.LastOrDefault().Text?.Split(" ").First();
if (latestInstalledSdk == null)
{
return;
}
var globalJsonFile = rootDirectory / "global.json";
var jobject = File.Exists(globalJsonFile)
? SerializationTasks.JsonDeserializeFromFile <JObject>(globalJsonFile)
: new JObject();
jobject["sdk"] ??= new JObject();
jobject["sdk"].NotNull()["version"] = latestInstalledSdk;
SerializationTasks.JsonSerializeToFile(jobject, globalJsonFile);
}
private static async Task <JObject> PostMessage(string url, object message, string accessToken)
{
var httpHandler = new GitterTasks.AuthenticatedHttpClientHandler(accessToken);
using var client = new HttpClient(httpHandler);
var payload = JsonConvert.SerializeObject(message);
var response = await client.PostAsync(url, new StringContent(payload, Encoding.UTF8, "application/json"));
var responseContent = await response.Content.ReadAsStringAsync();
ControlFlow.Assert(response.StatusCode == HttpStatusCode.OK, responseContent);
var jobject = SerializationTasks.JsonDeserialize <JObject>(responseContent);
var error = jobject.GetPropertyValueOrNull <string>("error");
ControlFlow.Assert(error == null, error);
return(jobject);
}
private static void HandleCompletion(NukeBuild build)
{
var completionItems = new SortedDictionary <string, string[]>();
var targetNames = build.TargetDefinitions.Select(x => x.Name).OrderBy(x => x).ToList();
completionItems[NukeBuild.InvokedTargetsParameterName] = targetNames.ToArray();
completionItems[NukeBuild.SkippedTargetsParameterName] = targetNames.ToArray();
string[] GetSubItems(Type type)
{
if (type.IsEnum)
{
return(type.GetEnumNames());
}
if (type.IsSubclassOf(typeof(Enumeration)))
{
return(type.GetFields(ReflectionService.Static).Select(x => x.Name).ToArray());
}
return(null);
}
foreach (var parameter in build.GetParameterMembers())
{
var parameterName = ParameterService.Instance.GetParameterName(parameter);
if (completionItems.ContainsKey(parameterName))
{
continue;
}
completionItems[parameterName] = GetSubItems(parameter.GetFieldOrPropertyType())?.OrderBy(x => x).ToArray();
}
SerializationTasks.YamlSerializeToFile(completionItems, NukeBuild.CompletionFile);
if (EnvironmentInfo.ParameterSwitch(NukeBuild.CompletionParameterName))
{
Environment.Exit(exitCode: 0);
}
}
public static T StdToJson <T>(this IEnumerable <Output> output)
{
return(SerializationTasks.JsonDeserialize <T>(output.StdToText()));
}
public static PackageManifest FromFile(string path = "./vc-package.json")
{
var result = SerializationTasks.JsonDeserializeFromFile <PackageManifest>(path);
return(result);
}
public static void ToFile(PackageManifest manifest, string path = "./vc-package.json")
{
SerializationTasks.JsonSerializeToFile(manifest, path);
}
