private static int Setup(string[] args, [CanBeNull] string rootDirectory, [CanBeNull] string buildScript)
{
#region Basic
var nukeLatestReleaseVersion = NuGetPackageResolver.GetLatestPackageVersion("Nuke.Common", includePrereleases: false);
var nukeLatestPrereleaseVersion = NuGetPackageResolver.GetLatestPackageVersion("Nuke.Common", includePrereleases: true);
var nukeLatestLocalVersion = NuGetPackageResolver.GetGlobalInstalledPackage("Nuke.Common", version: null, packagesConfigFile: null)
?.Version.ToString();
if (rootDirectory == null)
{
var rootDirectoryItems = new[] { ".git", ".svn" };
rootDirectory = FileSystemTasks.FindParentDirectory(
EnvironmentInfo.WorkingDirectory,
x => rootDirectoryItems.Any(y => x.GetFileSystemInfos(y, SearchOption.TopDirectoryOnly).Any()));
}
if (rootDirectory == null)
{
Logger.Warn("Could not find root directory. Falling back to working directory.");
rootDirectory = EnvironmentInfo.WorkingDirectory;
}
var buildProjectName = ConsoleUtility.PromptForInput("How should the build project be named?", "_build");
var buildDirectoryName = ConsoleUtility.PromptForInput("Where should the build project be located?", "./build");
var targetPlatform = !EnvironmentInfo.GetParameter <bool>("boot")
? PLATFORM_NETCORE
: ConsoleUtility.PromptForChoice("What bootstrapping method should be used?",
(PLATFORM_NETCORE, ".NET Core SDK"),
(PLATFORM_NETFX, ".NET Framework/Mono"));
var targetFramework = targetPlatform == PLATFORM_NETFX
? FRAMEWORK_NET461
: FRAMEWORK_NETCOREAPP2;
var projectFormat = targetPlatform == PLATFORM_NETCORE
? FORMAT_SDK
: ConsoleUtility.PromptForChoice("What project format should be used?",
(FORMAT_SDK, "SDK-based Format: requires .NET Core SDK"),
(FORMAT_LEGACY, "Legacy Format: supported by all MSBuild/Mono versions"));
var nukeVersion = ConsoleUtility.PromptForChoice("Which NUKE version should be used?",
new[]
private static int Fix(string[] args, [CanBeNull] string rootDirectory, [CanBeNull] string buildScript)
{
PrintInfo();
if (rootDirectory == null)
{
return(0);
}
var missingPackageFile = Constants.GetMissingPackageFile((AbsolutePath)rootDirectory);
if (!File.Exists(missingPackageFile))
{
return(0);
}
Logger.Info("During last execution a package was found to be missing.");
var missingPackageContents = File.ReadAllLines(missingPackageFile);
var buildProjectFile = missingPackageContents.FirstOrDefault();
ControlFlow.Assert(File.Exists(buildProjectFile), $"File.Exists({buildProjectFile})");
var packages = missingPackageContents
.Skip(1)
.Select(x => x.Split("@", StringSplitOptions.RemoveEmptyEntries))
.ForEachLazy(x => ControlFlow.Assert(x.Length == 2, "x.Length == 2"))
.Select(x => (packageName: x[0], version: x[1])).ToList();
ControlFlow.Assert(packages.Count > 0, "packages.Count > 0");
var(selectedPackageId, selectedPackageVersion) = packages.Count == 1
? packages.Single()
: PromptForChoice("Which package should be added?",
packages.Select(x => (x, x.packageName)).ToArray());
if (selectedPackageVersion == ToolPathResolver.MissingPackageDefaultVersion)
{
var latestReleaseVersion = NuGetPackageResolver.GetLatestPackageVersion(selectedPackageId, includePrereleases: false);
var latestPrereleaseVersion = NuGetPackageResolver.GetLatestPackageVersion(selectedPackageId, includePrereleases: true);
var latestLocalVersion = NuGetPackageResolver.GetGlobalInstalledPackage(selectedPackageId, version: null, packagesConfigFile: null)
?.Version.ToString();
var packageVersions = new[]
public NuGetAssemblyResolver(string projectLockFile)
{
NuGetPackageResolver resolver = new NuGetPackageResolver {
ProjectLockFile = projectLockFile
};
resolver.Resolve();
string[] resolvedReferences = resolver.ResolvedReferences;
this._references = new Dictionary <string, string>(resolvedReferences.Length, StringComparer.InvariantCultureIgnoreCase);
foreach (string str in resolvedReferences)
{
string str3;
string fileName = Path.GetFileName(str);
if (this._references.TryGetValue(fileName, out str3))
{
throw new Exception($"Reference " { str } " already added as " { str3 } ".");
}
this._references.Add(fileName, str);
}
}
private string GetOrSelectWaveVersion()
{
if (WaveVersion != null)
{
Console.WriteLine($"Building for given wave version: {WaveVersion}");
return(WaveVersion);
}
string selected = NuGetPackageResolver
.GetLocalInstalledPackages(RootDirectory / MainProjectName / (MainProjectName + ".csproj"))
.Where(x => x.Id == "Wave")
.OrderByDescending(x => x.Version.Version)
.FirstOrDefault()
.NotNull("There's no R# installed and no wave version is given. Please, pass wave version as an argument: '--waveVersion 193.0'")
.Version
.Version
.ToString(2);
Console.WriteLine($"No WaveVersion is given. Auto-detected version:{selected}");
return(selected);
}
public CacheWriter(ResolvePackageAssets task, Stream stream = null)
{
var targetFramework = NuGetUtils.ParseFrameworkName(task.TargetFrameworkMoniker);
_task = task;
_lockFile = new LockFileCache(task).GetLockFile(task.ProjectAssetsFile);
_packageResolver = NuGetPackageResolver.CreateResolver(_lockFile, _task.ProjectPath);
_compileTimeTarget = _lockFile.GetTargetAndThrowIfNotFound(targetFramework, runtime: null);
_runtimeTarget = _lockFile.GetTargetAndThrowIfNotFound(targetFramework, _task.RuntimeIdentifier);
_stringTable = new Dictionary <string, int>(InitialStringTableCapacity, StringComparer.Ordinal);
_metadataStrings = new List <string>(InitialStringTableCapacity);
_bufferedMetadata = new List <int>();
if (stream == null)
{
Directory.CreateDirectory(Path.GetDirectoryName(task.ProjectAssetsCacheFile));
stream = File.Open(task.ProjectAssetsCacheFile, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
_writer = new BinaryWriter(stream, TextEncoding, leaveOpen: false);
}
else
{
_writer = new BinaryWriter(stream, TextEncoding, leaveOpen: true);
}
}
// TODO [3]: validation of wave version?
private static IReadOnlyCollection <NuGetPackageResolver.InstalledPackage> GetInstalledPlugins()
{
return(NuGetPackageResolver.GetLocalInstalledPackages()
.Where(x => x.Metadata.GetDependencyGroups().SelectMany(y => y.Packages).Any(y => y.Id == "Wave"))
.ToList());
}
// TODO [3]: validation of wave version?
private static IReadOnlyCollection <NuGetPackageResolver.InstalledPackage> GetInstalledPlugins()
=> NuGetPackageResolver.GetLocalInstalledPackages(ToolPathResolver.NuGetPackagesConfigFile)
.Where(x => x.Metadata.GetDependencyGroups().SelectMany(y => y.Packages).Any(y => y.Id == "Wave"))
.ToList();
private PathConstruction.AbsolutePath GetPackageFrameworkDir()
{
var package = NuGetPackageResolver.GetLocalInstalledPackage("nswag.msbuild", ToolPathResolver.NuGetPackagesConfigFile);
return(package.Directory / (package.Version.Version >= new Version(major: 11, minor: 18, build: 1) ? "tools" : "build"));
}
public void TestGetLocalInstalledPackagesViaAssetsFile()
{
var result = NuGetPackageResolver.GetLocalInstalledPackages(BuildAssetsFile, resolveDependencies: false);
result.Should().Contain(x => x.Id == "JetBrains.ReSharper.GlobalTools");
}
public void TestGetLocalInstalledPackageViaAssetsFile()
{
var result = NuGetPackageResolver.GetLocalInstalledPackage("xunit.runner.console", BuildAssetsFile, resolveDependencies: false);
result.Version.OriginalVersion.Should().Be(XunitConsolePackageVersion);
}
public async Task TestGetLatestPackageVersion(string packageId, bool includePrereleases, bool includeUnlisted, string expected)
{
var result = await NuGetPackageResolver.GetLatestPackageVersion(packageId, includePrereleases, includeUnlisted);
result.Should().Be(expected);
}
