public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var path = (string)value;
string name = Path.GetFileName(path);
string[] parts = path.Split('\\');
if (parts.Length == 2 &&
WellknownPackageFolders.Any(s => s.Equals(parts[0], StringComparison.OrdinalIgnoreCase)))
{
FrameworkName frameworkName;
try
{
frameworkName = VersionUtility.ParseFrameworkName(name);
}
catch (ArgumentException)
{
if (parts[0].Equals("lib", StringComparison.OrdinalIgnoreCase) ||
parts[0].Equals("build", StringComparison.OrdinalIgnoreCase))
{
return(" (Invalid framework)");
}
else
{
return(String.Empty);
}
}
if (frameworkName != VersionUtility.UnsupportedFrameworkName)
{
return(" (" + frameworkName + ")");
}
else if (!parts[0].Equals("content", StringComparison.OrdinalIgnoreCase))
{
return(" (Unrecognized framework)");
}
}
return(String.Empty);
}
public static List <IPackageFile> CreateFiles(IEnumerable <string> fileNames, string directory = "")
{
var files = new List <IPackageFile>();
foreach (var fileName in fileNames)
{
string path = Path.Combine(directory, fileName);
var mockFile = new Mock <IPackageFile>();
mockFile.Setup(m => m.Path).Returns(path);
mockFile.Setup(m => m.GetStream()).Returns(() => new MemoryStream(Encoding.Default.GetBytes(path)));
string effectivePath;
FrameworkName fn = VersionUtility.ParseFrameworkNameFromFilePath(path, out effectivePath);
mockFile.Setup(m => m.TargetFramework).Returns(fn);
mockFile.Setup(m => m.EffectivePath).Returns(effectivePath);
mockFile.Setup(m => m.SupportedFrameworks).Returns(
fn == null ? new FrameworkName[0] : new FrameworkName[] { fn });
files.Add(mockFile.Object);
}
return(files);
}
public void ShouldNotInstallExistingPackages()
{
var logger = new Mock <ILog>();
var provider = new Mock <IInstallationProvider>();
provider.Setup(
i => i.IsInstalled(It.Is <IPackageReference>(x => x.PackageId == "testId"), It.IsAny <bool>()))
.Returns(true);
var references = new List <IPackageReference>
{
new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")),
new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("4.0")),
new PackageReference("testId3", VersionUtility.ParseFrameworkName("net40"), new Version("5.0"))
};
var installer = new PackageInstaller(provider.Object, logger.Object);
installer.InstallPackages(references);
provider.Verify(i => i.InstallPackage(It.Is <IPackageReference>(x => x.PackageId == "testId"), It.IsAny <bool>()), Times.Never());
}
/// <summary>
/// Filters the provided list of items, returning only those items compatible with the given project framework.
/// </summary>
/// <typeparam name="T">the type of items being filtered</typeparam>
/// <param name="projectFramework">The project framework.</param>
/// <param name="items">The items.</param>
/// <returns>The compatible items. Empty if try is unsuccessful.</returns>
/// <exception cref="System.ArgumentNullException">
/// projectFramework or items
/// </exception>
public IEnumerable <T> GetCompatibleItems <T>(FrameworkName projectFramework, IEnumerable <T> items)
where T : IFrameworkTargetable
{
if (projectFramework == null)
{
throw new ArgumentNullException("projectFramework");
}
if (items == null)
{
throw new ArgumentNullException("items");
}
var nugetItems = items.Select(item => new FrameworkTargetableWrapper <T>(item)).ToArray();
IEnumerable <FrameworkTargetableWrapper <T> > compatibleNugetItems;
if (VersionUtility.TryGetCompatibleItems(projectFramework, nugetItems, out compatibleNugetItems))
{
return(compatibleNugetItems.Select(item => item.WrappedItem));
}
return(Enumerable.Empty <T>());
}
public void ShouldShowErrorIfOneOfPackagesFail()
{
var provider = new Mock <IInstallationProvider>();
provider.Setup(
i => i.InstallPackage(It.Is <IPackageReference>(x => x.PackageId == "testId"), It.IsAny <bool>()))
.Throws <Exception>();
var references = new List <IPackageReference>
{
new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")),
new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("4.0")),
new PackageReference("testId3", VersionUtility.ParseFrameworkName("net40"), new Version("5.0"))
};
var installer = new PackageInstaller(provider.Object, new TestLogProvider());
var exception = Record.Exception(() => installer.InstallPackages(references, true));
provider.Verify(i => i.InstallPackage(It.IsAny <IPackageReference>(), It.IsAny <bool>()), Times.Exactly(3));
exception.ShouldBeType <AggregateException>();
((AggregateException)exception).InnerExceptions.Count.ShouldEqual(1);
}
public void ShouldShowSuccessIfNoneOfPackagesFail()
{
var callbacks = new List <string>();
var provider = new Mock <IInstallationProvider>();
provider.Setup(
i => i.InstallPackage(It.IsAny <IPackageReference>(), It.IsAny <bool>(), It.IsAny <Action <string> >()))
.Returns(true);
var references = new List <IPackageReference> {
new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")),
new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("4.0")),
new PackageReference("testId3", VersionUtility.ParseFrameworkName("net40"), new Version("5.0"))
};
var installer = new PackageInstaller(provider.Object);
installer.InstallPackages(references, true, msg => callbacks.Add(msg));
callbacks.Count.ShouldEqual(1);
callbacks.Count(x => x.EndsWith("successful.")).ShouldEqual(1);
}
public void GetDescriptionReturnsCorrectResults(string name, string version, string framework, string path, bool found)
{
var libraryRange = new LibraryRange(name, frameworkReference: true)
{
VersionRange = VersionUtility.ParseVersionRange(version)
};
var frameworkName = FrameworkNameHelper.ParseFrameworkName(framework);
var resolver = new GacDependencyResolver();
var library = resolver.GetDescription(libraryRange, frameworkName);
if (found)
{
Assert.NotNull(library);
Assert.Equal(SemanticVersion.Parse(version), library.Identity.Version);
Assert.Equal(Environment.ExpandEnvironmentVariables(path), library.Path);
}
else
{
Assert.Null(library);
}
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (!libraryRange.IsGacOrFrameworkReference)
{
return(null);
}
var name = libraryRange.Name;
var version = libraryRange.VersionRange?.MinVersion;
string path;
if (!FrameworkResolver.TryGetAssembly(name, targetFramework, out path))
{
return(null);
}
SemanticVersion assemblyVersion = VersionUtility.GetAssemblyVersion(path);
if (version == null || version == assemblyVersion)
{
_resolvedPaths[name] = path;
return(new LibraryDescription
{
LibraryRange = libraryRange,
Identity = new Library
{
Name = name,
Version = assemblyVersion,
IsGacOrFrameworkReference = true
},
LoadableAssemblies = new[] { name },
Dependencies = Enumerable.Empty <LibraryDependency>()
});
}
return(null);
}
public void WhenManyPackagesAreMatchedAllMatchingDllsShouldBeReturned()
{
_packageIds.Add(new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")));
var p = new Mock <IPackageObject>();
p.Setup(i => i.GetCompatibleDlls(It.IsAny <FrameworkName>()))
.Returns(new List <string> {
"test3.dll", "test4.dll"
});
p.SetupGet(i => i.Id).Returns("testId2");
p.SetupGet(i => i.Version).Returns(new Version("3.0"));
p.SetupGet(i => i.TextVersion).Returns("3.0");
p.SetupGet(i => i.FullName).Returns(_package.Object.Id + "." + _package.Object.Version);
_packageContainer.Setup(i => i.FindPackage(It.IsAny <string>(), It.Is <IPackageReference>(x => x.PackageId == "testId2"))).Returns(p.Object);
var resolver = new PackageAssemblyResolver(_filesystem.Object, _packageContainer.Object);
var found = resolver.GetAssemblyNames(_workingDirectory).ToList();
found.ShouldNotBeEmpty();
found.Count.ShouldEqual(4);
}
public NuGetPackage()
{
myVersionSpec = new Lazy <Func <IPackage, bool> >(
() =>
{
try
{
var spec = VersionSpec;
if (string.IsNullOrWhiteSpace(spec))
{
return(True);
}
var pSpec = VersionUtility.ParseVersionSpec(spec);
return(xx => Enumerable.Any(new[] { xx }.FindByVersion(pSpec)));
}
catch (Exception e)
{
Console.Out.WriteLine("Error: " + e);
return(True);
}
});
}
public async Task <IEnumerable <LibraryDependency> > GetDependencies(WalkProviderMatch match, FrameworkName targetFramework)
{
using (var stream = await _source.OpenNuspecStreamAsync(new PackageInfo
{
Id = match.Library.Name,
Version = match.Library.Version,
ContentUri = match.Path
}))
{
var metadata = (IPackageMetadata)Manifest.ReadFrom(stream, validateSchema: false).Metadata;
IEnumerable <PackageDependencySet> dependencySet;
if (VersionUtility.TryGetCompatibleItems(targetFramework, metadata.DependencySets, out dependencySet))
{
return(dependencySet
.SelectMany(x => x.Dependencies)
.Select(x => new LibraryDependency(name: x.Id,
version: x.VersionSpec != null ? x.VersionSpec.MinVersion : null))
.ToList());
}
}
return(Enumerable.Empty <LibraryDependency>());
}
private bool CheckAlreadyDownloaded(PackageRequest request, List <InstalledPackage> installedPackages)
{
var existing = installedPackages.FirstOrDefault(op => string.Equals(op.Id, request.Id, StringComparison.OrdinalIgnoreCase));
if (existing == null)
{
return(false);
}
var requestVersionsRange = VersionUtility.ParseVersionSpec(request.VersionsRange);
var existingVersion = SemanticVersion.Parse(existing.Version);
if (!requestVersionsRange.Satisfies(existingVersion))
{
DependencyError(string.Format(
"Incompatible package version '{0}, version {1}, requested by {2}' conflicts with previously downloaded package '{3}, version {4}, requested by {5} ({6})'.",
request.Id, request.VersionsRange ?? "not specified", request.RequestedBy,
existing.Id, existing.Version, existing.Request.RequestedBy, existing.Request.VersionsRange));
}
return(true);
}
private IEnumerable <Package> GetMatchingPackages(string packageRegistrationId, string requiredVersionSpec)
{
var packageRegistrationRepository = GetService <IEntityRepository <PackageRegistration> >();
var candidatePackages = packageRegistrationRepository.GetAll()
.Include(pr => pr.Packages)
.Where(pr => pr.Id.Equals(packageRegistrationId, StringComparison.OrdinalIgnoreCase))
.SelectMany(pr => pr.Packages)
.Include(p => p.PackageRegistration)
.ToList();
if (requiredVersionSpec == null)
{
return(candidatePackages);
}
var versionSpec = VersionUtility.ParseVersionSpec(requiredVersionSpec);
var dependencies = from p in candidatePackages
where versionSpec.Satisfies(new SemanticVersion(p.Version))
select p;
return(dependencies);
}
public void ShouldShowSuccessIfNoneOfPackagesFail()
{
var logger = new Mock <ILog>();
var provider = new Mock <IInstallationProvider>();
provider.Setup(
i => i.InstallPackage(It.IsAny <IPackageReference>(), It.IsAny <bool>()))
.Returns(true);
var references = new List <IPackageReference>
{
new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0")),
new PackageReference("testId2", VersionUtility.ParseFrameworkName("net40"), new Version("4.0")),
new PackageReference("testId3", VersionUtility.ParseFrameworkName("net40"), new Version("5.0"))
};
var installer = new PackageInstaller(provider.Object, logger.Object);
installer.InstallPackages(references, true);
logger.Verify(i => i.Info(It.Is <string>(x => x.EndsWith("successful."))), Times.Once());
}
public void GetAllPossibleVersionsFourDigitsWithTrailingZeros()
{
// Arrange
var expectedVersions = new[] {
new SemanticVersion("1.1"),
new SemanticVersion("1.1.0"),
new SemanticVersion("1.1.0.0"),
};
var expectedVersionStrings = new[]
{
"1.1",
"1.1.0",
"1.1.0.0",
};
// Act
var versions = VersionUtility.GetPossibleVersions(new SemanticVersion("1.1.0.0")).ToList();
// Assert
Assert.Equal(expectedVersions, versions);
Assert.Equal(expectedVersionStrings, versions.Select(v => v.ToString()));
}
private async Task <WalkProviderMatch> FindLibraryByVersion(RestoreContext context, LibraryRange libraryRange, IEnumerable <IWalkProvider> providers)
{
if (libraryRange.VersionRange.VersionFloatBehavior != SemanticVersionFloatBehavior.None)
{
// Don't optimize the non http path for floating versions or we'll miss things
return(await FindLibrary(libraryRange, providers, provider => provider.FindLibrary(libraryRange, context.FrameworkName, includeUnlisted: false)));
}
// Try the non http sources first
// non-http sources don't support list/unlist so set includeUnlisted to true
var nonHttpMatch = await FindLibrary(libraryRange, providers.Where(p => !p.IsHttp), provider => provider.FindLibrary(libraryRange, context.FrameworkName, includeUnlisted: true));
// If we found an exact match then use it
if (nonHttpMatch != null && nonHttpMatch.Library.Version.Equals(libraryRange.VersionRange.MinVersion))
{
return(nonHttpMatch);
}
// Otherwise try listed packages on http sources
var httpMatch = await FindLibrary(libraryRange, providers.Where(p => p.IsHttp), provider => provider.FindLibrary(libraryRange, context.FrameworkName, includeUnlisted: false));
// If the http sources failed to find a listed package that matched, try unlisted packages
if (httpMatch == null)
{
httpMatch = await FindLibrary(libraryRange, providers.Where(p => p.IsHttp), provider => provider.FindLibrary(libraryRange, context.FrameworkName, includeUnlisted: true));
}
// Pick the best match of the 2
if (VersionUtility.ShouldUseConsidering(
nonHttpMatch?.Library?.Version,
httpMatch?.Library.Version,
libraryRange.VersionRange))
{
return(httpMatch);
}
return(nonHttpMatch);
}
private static IEnumerable <Package> GetUpdates(
IEnumerable <Package> packages,
Dictionary <string, Tuple <SemanticVersion, IVersionSpec> > versionLookup,
IEnumerable <FrameworkName> targetFrameworkValues,
bool includeAllVersions)
{
var updates = packages.AsEnumerable()
.Where(
p =>
{
// For each package, if the version is higher than the client version and we satisty the target framework, return it.
// TODO: We could optimize for the includeAllVersions case here by short circuiting the operation once we've encountered the highest version
// for a given Id
var version = SemanticVersion.Parse(p.Version);
Tuple <SemanticVersion, IVersionSpec> versionTuple;
if (versionLookup.TryGetValue(p.PackageRegistration.Id, out versionTuple))
{
SemanticVersion clientVersion = versionTuple.Item1;
var supportedPackageFrameworks = p.SupportedFrameworks.Select(f => f.FrameworkName);
IVersionSpec versionConstraint = versionTuple.Item2;
return((version > clientVersion) &&
(targetFrameworkValues == null ||
targetFrameworkValues.Any(s => VersionUtility.IsCompatible(s, supportedPackageFrameworks))) &&
(versionConstraint == null || versionConstraint.Satisfies(version)));
}
return(false);
});
if (!includeAllVersions)
{
return(updates.GroupBy(p => p.PackageRegistration.Id)
.Select(g => g.OrderByDescending(p => SemanticVersion.Parse(p.Version)).First()));
}
return(updates);
}
public GetAssemblyNamesMethod()
{
_workingDirectory = Path.GetTempPath();
_filesystem = new Mock <IFileSystem>();
_filesystem.SetupGet(i => i.CurrentDirectory).Returns(_workingDirectory);
_filesystem.SetupGet(i => i.PackagesFile).Returns("packages.config");
_filesystem.SetupGet(i => i.PackagesFolder).Returns("packages");
_filesystem.Setup(i => i.DirectoryExists(It.IsAny <string>())).Returns(true);
_filesystem.Setup(i => i.FileExists(It.IsAny <string>())).Returns(true);
_logger = new Mock <ILog>();
_package = new Mock <IPackageObject>();
_package.Setup(i => i.GetCompatibleDlls(It.IsAny <FrameworkName>()))
.Returns(new List <string> {
"test.dll", "test2.dll"
});
_package.SetupGet(i => i.Id).Returns("id");
_package.SetupGet(i => i.Version).Returns(new Version("3.0"));
_package.SetupGet(i => i.TextVersion).Returns("3.0");
_package.SetupGet(i => i.FullName).Returns(_package.Object.Id + "." + _package.Object.Version);
_package.SetupGet(i => i.FrameworkAssemblies).Returns(new[] { "System.Net.Http", "System.ComponentModel" });
_packageIds = new List <IPackageReference>
{
new PackageReference("testId", VersionUtility.ParseFrameworkName("net40"), new Version("3.0"))
};
_packageContainer = new Mock <IPackageContainer>();
_packageContainer.Setup(i => i.FindReferences(It.IsAny <string>())).Returns(_packageIds);
_packageContainer.Setup(i => i.FindPackage(It.IsAny <string>(), It.IsAny <IPackageReference>())).Returns(_package.Object);
_assemblyUtility = new Mock <IAssemblyUtility>();
_assemblyUtility.Setup(u => u.IsManagedAssembly(It.IsAny <string>())).Returns(true);
}
public LibraryDescription GetDescription(LibraryRange libraryRange, FrameworkName targetFramework)
{
if (!libraryRange.IsGacOrFrameworkReference)
{
return(null);
}
if (!RuntimeEnvironmentHelper.IsWindows)
{
return(null);
}
if (!VersionUtility.IsDesktop(targetFramework))
{
return(null);
}
var name = libraryRange.Name;
var version = libraryRange.VersionRange?.MinVersion;
string path;
if (!TryResolvePartialName(libraryRange.GetReferenceAssemblyName(), version, out path))
{
return(null);
}
_resolvedPaths[name] = path;
return(new LibraryDescription(
libraryRange,
new LibraryIdentity(name, version, isGacOrFrameworkReference: true),
path,
LibraryTypes.GlobalAssemblyCache,
Enumerable.Empty <LibraryDependency>(),
new[] { libraryRange.GetReferenceAssemblyName() },
framework: null));
}
private bool ExecuteCore(
string fullScriptPath,
string installPath,
IPackage package,
Project project,
FrameworkName targetFramework,
ILogger logger,
IPackageFile scriptFile)
{
if (File.Exists(fullScriptPath))
{
if (project != null && scriptFile != null)
{
// targetFramework can be null for unknown project types
string shortFramework = targetFramework == null ? string.Empty : VersionUtility.GetShortFrameworkName(targetFramework);
logger.Log(MessageLevel.Debug, NuGetResources.Debug_TargetFrameworkInfoPrefix, package.GetFullName(),
project.Name, shortFramework);
logger.Log(MessageLevel.Debug, NuGetResources.Debug_TargetFrameworkInfo_PowershellScripts,
Path.GetDirectoryName(scriptFile.Path), VersionUtility.GetTargetFrameworkLogString(scriptFile.TargetFramework));
}
string toolsPath = Path.GetDirectoryName(fullScriptPath);
string logMessage = String.Format(CultureInfo.CurrentCulture, VsResources.ExecutingScript, fullScriptPath);
// logging to both the Output window and progress window.
logger.Log(MessageLevel.Info, logMessage);
IConsole console = OutputConsoleProvider.CreateOutputConsole(requirePowerShellHost: true);
Host.Execute(console,
"$__pc_args=@(); $input|%{$__pc_args+=$_}; & " + PathHelper.EscapePSPath(fullScriptPath) + " $__pc_args[0] $__pc_args[1] $__pc_args[2] $__pc_args[3]; Remove-Variable __pc_args -Scope 0",
new object[] { installPath, toolsPath, package, project });
return(true);
}
return(false);
}
private static MemoryStream GetPackageStream(
IEnumerable <IPackageFile> files = null,
IEnumerable <PackageReferenceSet> references = null)
{
var builder = new PackageBuilder();
builder.Id = "Package";
builder.Version = new SemanticVersion("1.0");
builder.Authors.Add("dotnetjunky");
builder.Description = "This is a test package";
builder.ReleaseNotes = "This is a release note.";
builder.Copyright = "Copyright";
if (files != null)
{
builder.Files.AddRange(files);
}
else
{
builder.Files.AddRange(
PackageUtility.CreateFiles(
new[] { PathFixUtility.FixPath(@"lib\40\A.dll"), PathFixUtility.FixPath(@"content\foo") }
));
}
builder.FrameworkReferences.AddRange(
new[] { new FrameworkAssemblyReference("A", new[] { VersionUtility.ParseFrameworkName("sl50") }),
new FrameworkAssemblyReference("B", new[] { VersionUtility.ParseFrameworkName("windows8") }) });
if (references != null)
{
builder.PackageAssemblyReferences.AddRange(references);
}
var ms = new MemoryStream();
builder.Save(ms);
ms.Seek(0, SeekOrigin.Begin);
return(ms);
}
private static Tuple <Version, string> FindUpgradeVersion(string appSymbolicNameFolder, Version currentVersion)
{
Version version = null;
if (Directory.Exists(appSymbolicNameFolder))
{
string[] directories = Directory.GetDirectories(appSymbolicNameFolder);
string str = string.Empty;
string[] strArray2 = directories;
int index = 0;
while (true)
{
if (index >= strArray2.Length)
{
break;
}
string path = strArray2[index];
try
{
Version newVersion = new Version(new DirectoryInfo(path).Name);
if (VersionUtility.Compatible(currentVersion, newVersion) && ((version == null) || (newVersion > version)))
{
version = newVersion;
str = path;
}
}
catch
{
}
index++;
}
if (version != null)
{
return(new Tuple <Version, string>(version, str));
}
}
return(null);
}
public async Task <WalkProviderMatch> FindLibrary(LibraryRange libraryRange, FrameworkName targetFramework, bool includeUnlisted)
{
var results = await _source.FindPackagesByIdAsync(libraryRange.Name);
PackageInfo bestResult = null;
if (!includeUnlisted)
{
results = results.Where(p => p.Listed);
}
foreach (var result in results)
{
if (VersionUtility.ShouldUseConsidering(
current: bestResult?.Version,
considering: result.Version,
ideal: libraryRange.VersionRange))
{
bestResult = result;
}
}
if (bestResult == null)
{
return(null);
}
return(new WalkProviderMatch
{
Library = new Library
{
Name = bestResult.Id,
Version = bestResult.Version
},
Path = bestResult.ContentUri,
Provider = this,
});
}
public void Task_ReadPackagesConfig_ParseProjectoryConfig()
{
var projectPath = Assets.GetScenarioFilePath("Task_ReadPackagesConfig_ParseProjectoryConfig", @"A.csproj");
var task = new ReadPackagesConfig();
task.ProjectPath = projectPath;
var result = task.Execute();
var expectedVersionConstraint = VersionUtility.ParseVersionSpec("[1,2]").ToString();
Assert.True(result);
var fodyItem = new AssertTaskItem(task.PackageReferences, "Fody", items => Assert.Single(items))
{
{ "Version", "1.25.0" },
{ "TargetFramework", "net45" },
{ "VersionConstraint", expectedVersionConstraint },
{ "RequireReinstallation", bool.FalseString },
{ "IsDevelopmentDependency", bool.TrueString },
};
Assert.Single(fodyItem);
}
void extractDependentPackages(IEnumerable <IPackage> dependencies, DirectoryInfo tempPath, FrameworkName framework)
{
dependencies.ForEach(pkg => {
this.Log().Info("Scanning {0}", pkg.Id);
pkg.GetLibFiles().ForEach(file => {
var outPath = new FileInfo(Path.Combine(tempPath.FullName, file.Path));
if (!VersionUtility.IsCompatible(framework, new[] { file.TargetFramework }))
{
this.Log().Info("Ignoring {0} as the target framework is not compatible", outPath);
return;
}
Directory.CreateDirectory(outPath.Directory.FullName);
using (var of = File.Create(outPath.FullName)) {
this.Log().Info("Writing {0} to {1}", file.Path, outPath);
file.GetStream().CopyTo(of);
}
});
});
}
private bool WrapAssembly()
{
if (string.IsNullOrEmpty(Framework))
{
Reports.Error.WriteLine("Please specify framework when wrapping an assembly", Framework.Red().Bold());
return false;
}
var frameworkName = VersionUtility.ParseFrameworkName(Framework);
if (VersionUtility.UnsupportedFrameworkName.Equals(frameworkName))
{
Reports.Error.WriteLine("The framework '{0}' is not supported", Framework.Red().Bold());
return false;
}
var rootDir = ResolveRootDirectory(Directory.GetCurrentDirectory());
var wrapRoot = Path.Combine(rootDir, WrapRootName);
EmitAssemblyWrapper(wrapRoot, frameworkName, InputFilePath);
AddWrapFolderToGlobalJson(rootDir);
return true;
}
public static FrameworkName GetFrameworkNameForRuntime(string runtime)
{
var parts = runtime.Split(new[] { '.' }, 2);
if (parts.Length != 2)
{
return(null);
}
parts = parts[0].Split(new[] { '-' }, 3);
if (parts.Length != 3)
{
return(null);
}
switch (parts[1])
{
case "svr50":
return(VersionUtility.ParseFrameworkName("net451"));
case "svrc50":
return(VersionUtility.ParseFrameworkName("k10"));
}
return(null);
}
public IQueryable <IPackage> Search(string searchTerm, IEnumerable <string> targetFrameworks, bool allowPrereleaseVersions)
{
var cache = CachedPackages;
var packages = cache.AsQueryable()
.Find(searchTerm)
.FilterByPrerelease(allowPrereleaseVersions);
if (EnableDelisting)
{
packages = packages.Where(p => p.Listed);
}
if (EnableFrameworkFiltering && targetFrameworks.Any())
{
// Get the list of framework names
var frameworkNames = targetFrameworks.Select(frameworkName => VersionUtility.ParseFrameworkName(frameworkName));
packages = packages.Where(package => frameworkNames.Any(frameworkName => VersionUtility.IsCompatible(frameworkName, package.GetSupportedFrameworks())));
}
return(packages.AsQueryable());
}
public void AppHostShowsErrorWhenCurrentTargetFrameworkWasNotFoundInProjectJson(string flavor, string os, string architecture)
{
var runtimeTargetFrameworkString = flavor == "coreclr" ? FrameworkNames.LongNames.DnxCore50 : FrameworkNames.LongNames.Dnx451;
var runtimeTargetFramework = new FrameworkName(runtimeTargetFrameworkString);
var runtimeTargetFrameworkShortName = VersionUtility.GetShortFrameworkName(runtimeTargetFramework);
var runtimeType = flavor == "coreclr" ? "CoreCLR" : "CLR";
runtimeType = RuntimeEnvironmentHelper.IsMono ? "Mono" : runtimeType;
var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture);
var projectJsonContents = @"{
""frameworks"": {
""FRAMEWORK_NAME"": { }
}
}".Replace("FRAMEWORK_NAME", flavor == "coreclr" ? "dnx451" : "dnxcore50");
using (runtimeHomeDir)
using (var projectPath = new DisposableDir())
{
var projectName = new DirectoryInfo(projectPath).Name;
var projectJsonPath = Path.Combine(projectPath, Project.ProjectFileName);
File.WriteAllText(projectJsonPath, projectJsonContents);
string stdOut, stdErr;
var exitCode = TestUtils.ExecBootstrapper(
runtimeHomeDir,
arguments: $"run",
stdOut: out stdOut,
stdErr: out stdErr,
workingDir: projectPath);
// TODO: add complete error message check when OS version information is consistent on CoreCLR and CLR
var expectedErrorMsg = $@"The current runtime target framework is not compatible with '{projectName}'.";
Assert.Equal(1, exitCode);
Assert.Contains(expectedErrorMsg, stdErr);
}
}
public static void Run(string[] args)
{
string queryJsonString = File.ReadAllText("projectframeworks.v1.json");
JObject queryJson = JObject.Parse(queryJsonString);
JObject compat = new JObject();
IEnumerable <string> fwkNames = File.ReadLines("frameworks.txt").Select(x => x.Split(":".ToCharArray())[1].TrimStart()).OrderBy(x => x).Distinct().ToList();
foreach (JToken queryFwkToken in queryJson["data"])
{
string queryFwk = (string)queryFwkToken;
if (((IDictionary <string, JToken>)compat).ContainsKey(queryFwk))
{
continue;
}
JObject compatList = new JObject();
compat[queryFwk] = compatList;
foreach (string fwk in fwkNames)
{
if (VersionUtility.IsCompatible(new FrameworkName(queryFwk), new List <FrameworkName> {
new FrameworkName(fwk)
}))
{
compatList[fwk] = true;
}
}
}
JObject wrapper = new JObject();
wrapper["info"] = "Built from projectframeworks.v1.json and the output of the search index builder.";
wrapper["data"] = compat;
File.WriteAllText("frameworkCompat.v1.json", wrapper.ToString());
}
