private IEnumerable <LibraryAsset> PopulateAssets(PackageDescription package, IEnumerable <LockFileItem> section)
{
foreach (var assemblyPath in section)
{
yield return(LibraryAsset.CreateFromRelativePath(package.Path, assemblyPath.Path));
}
}
private void PopulateMetadataReferences(PackageDescription description, FrameworkName targetFramework, IDictionary <string, IMetadataReference> paths)
{
var packageAssemblies = GetPackageAssemblies(description, targetFramework);
// Use contract if both contract and target path are available
bool hasContract = description.ContractPath != null;
bool hasLib = packageAssemblies.Any();
if (hasContract && hasLib)
{
paths[description.Library.Identity.Name] = new MetadataFileReference(description.Library.Identity.Name, description.ContractPath);
}
else if (hasLib)
{
foreach (var assembly in packageAssemblies)
{
paths[assembly.Name] = new MetadataFileReference(assembly.Name, assembly.Path);
}
}
foreach (var assembly in GetFrameworkAssemblies(description, targetFramework))
{
paths[assembly.Name] = new MetadataFileReference(assembly.Name, assembly.Path);
}
}
private Map PackageDetailsToMap(PackageDescription desc) => new Map
{
{ "name", desc.Name },
{ "version", desc.Version },
{ "description", desc.Description },
{ "license", desc.License }
};
/// <inheritdoc />
public byte[] GetPackageFile(
PackageDescription packageDescription)
{
new { packageDescription }.Must().NotBeNull();
var ret =
Using
.LinearBackOff(TimeSpan.FromSeconds(5))
.Run(() =>
{
var workingDirectory = Path.Combine(
this.defaultWorkingDirectory,
"Down-" + DateTime.Now.ToString(
DirectoryDateTimeToStringFormat,
CultureInfo.InvariantCulture));
var packageFilePath = this.DownloadPackages(new[] { packageDescription }, workingDirectory).Single();
var packageFileBytes = File.ReadAllBytes(packageFilePath);
// clean up temp files
Directory.Delete(workingDirectory, true);
return(packageFileBytes);
})
.Now();
return(ret);
}
private static async Task <PackageUpdateResult> UpdatePackage(PackageDescription pkg, JsonObject releaseInfo, CancellationToken ct = default)
{
DateTime currentTimestamp = default;
var tsfile = Path.Combine(PackageStateDir, pkg.Name + ".timestamp");
try
{
var ts = File.ReadAllText(tsfile, Encoding.UTF8);
currentTimestamp = DateTime.Parse(ts, null, System.Globalization.DateTimeStyles.RoundtripKind);
}
catch (Exception ex) { }
var newTimestamp = DateTime.Parse((string)releaseInfo["published_at"], null, System.Globalization.DateTimeStyles.RoundtripKind);
if (newTimestamp > currentTimestamp)
{
var asset = releaseInfo["assets"].AsArray().FirstOrDefault(x => (string)x["name"] == pkg.AssetName);
if (asset != default)
{
var download_url = (string)asset.AsObject()["browser_download_url"];
var download_to = Path.Combine(UpdatesDir, pkg.AssetName);
await DownloadAndExtractPackage(download_url, download_to, pkg.ExtractBase, _ => true, ct);
Directory.CreateDirectory(PackageStateDir);
File.WriteAllBytes(tsfile, Encoding.UTF8.GetBytes(newTimestamp.ToString("o")));
return(PackageUpdateResult.Success);
}
else
{
StatusText(string.Format("No such asset: {0}", pkg.AssetName));
return(PackageUpdateResult.Failed);
}
}
return(PackageUpdateResult.AlreadyUpToDate);
}
private List <AssemblyDescription> GetFrameworkAssemblies(PackageDescription description, FrameworkName targetFramework)
{
var results = new List <AssemblyDescription>();
var package = description.Package;
IEnumerable <FrameworkAssemblyReference> frameworkAssemblies;
if (VersionUtility.TryGetCompatibleItems(targetFramework, package.FrameworkAssemblies, out frameworkAssemblies))
{
foreach (var reference in frameworkAssemblies)
{
string path;
if (_frameworkReferenceResolver.TryGetAssembly(reference.AssemblyName, targetFramework, out path))
{
results.Add(new AssemblyDescription
{
Name = reference.AssemblyName,
Path = path
});
}
}
}
return(results);
}
private IEnumerable <string> GetSharedSources(PackageDescription description, FrameworkName targetFramework)
{
var directory = Path.Combine(description.Library.Path, "shared");
return(description.Package.LockFileLibrary.Files.Where(path => path.StartsWith("shared" + Path.DirectorySeparatorChar))
.Select(path => Path.Combine(description.Library.Path, path)));
}
public PackageDescription GetDescription(LockFilePackageLibrary package, LockFileTargetLibrary targetLibrary)
{
// If a NuGet dependency is supposed to provide assemblies but there is no assembly compatible with
// current target framework, we should mark this dependency as unresolved
var containsAssembly = package.Files
.Any(x => x.StartsWith($"ref{Path.DirectorySeparatorChar}") ||
x.StartsWith($"lib{Path.DirectorySeparatorChar}"));
var compatible = targetLibrary.FrameworkAssemblies.Any() ||
targetLibrary.CompileTimeAssemblies.Any() ||
targetLibrary.RuntimeAssemblies.Any() ||
!containsAssembly;
var dependencies = new List <LibraryRange>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count);
PopulateDependencies(dependencies, targetLibrary);
var path = _packagePathResolver.GetInstallPath(package.Name, package.Version);
var packageDescription = new PackageDescription(
path,
package,
targetLibrary,
dependencies,
compatible);
return(packageDescription);
}
TargetReport Diff(IPackage pkg, SemanticVersion left, SemanticVersion right)
{
var creator = new CompareSetCreator();
var differ = new CompareSetDiffer();
var packageDescription = new PackageDescription
{
PackageId = pkg.Id,
Versions = new VersionPair(left.ToString(), right.ToString())
};
var compareSets = creator.Create(packageDescription);
var diffedCompareSets = differ.Diff(compareSets);
var vm = ViewModelBuilder.Build(packageDescription, diffedCompareSets);
foreach (var framework in TopXNugets.Frameworks)
{
var target = vm.targets.FirstOrDefault(trg => trg.Name == framework);
if (target != null)
{
return(target);
}
}
return(null);
}
public static APIComparison Build(PackageDescription description, DiffedCompareSet[] diffedCompareSets)
{
return(new APIComparison
{
targets = BuildTargets(diffedCompareSets)
});
}
private LibraryExport ExportPackage(PackageDescription package)
{
var nativeLibraries = new List <LibraryAsset>();
PopulateAssets(package, package.Target.NativeLibraries, nativeLibraries);
var runtimeAssemblies = new List <LibraryAsset>();
PopulateAssets(package, package.Target.RuntimeAssemblies, runtimeAssemblies);
var compileAssemblies = new List <LibraryAsset>();
PopulateAssets(package, package.Target.CompileTimeAssemblies, compileAssemblies);
var sourceReferences = new List <string>();
foreach (var sharedSource in GetSharedSources(package))
{
sourceReferences.Add(sharedSource);
}
var analyzers = GetAnalyzerReferences(package);
return(new LibraryExport(package, compileAssemblies,
sourceReferences, runtimeAssemblies, Array.Empty <string>(), nativeLibraries, analyzers));
}
public PackageDescription GetDescription(NuGetFramework targetFramework, LockFilePackageLibrary package, LockFileTargetLibrary targetLibrary)
{
// If a NuGet dependency is supposed to provide assemblies but there is no assembly compatible with
// current target framework, we should mark this dependency as unresolved
var containsAssembly = package.Files
.Any(x => x.StartsWith($"ref{Path.DirectorySeparatorChar}") ||
x.StartsWith($"lib{Path.DirectorySeparatorChar}"));
var compatible = targetLibrary.FrameworkAssemblies.Any() ||
targetLibrary.CompileTimeAssemblies.Any() ||
targetLibrary.RuntimeAssemblies.Any() ||
!containsAssembly;
var dependencies = new List<LibraryRange>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count);
PopulateDependencies(dependencies, targetLibrary, targetFramework);
var path = _packagePathResolver.GetInstallPath(package.Name, package.Version);
// Remove place holders
targetLibrary.CompileTimeAssemblies = targetLibrary.CompileTimeAssemblies.Where(item => !IsPlaceholderFile(item.Path)).ToList();
targetLibrary.RuntimeAssemblies = targetLibrary.RuntimeAssemblies.Where(item => !IsPlaceholderFile(item.Path)).ToList();
// If the package's compile time assemblies is for a portable profile then, read the assembly metadata
// and turn System.* references into reference assembly dependencies
PopulateLegacyPortableDependencies(targetFramework, dependencies, path, targetLibrary);
var packageDescription = new PackageDescription(
path,
package,
targetLibrary,
dependencies,
compatible);
return packageDescription;
}
public PackageDescription GetDescription(LockFilePackageLibrary package, LockFileTargetLibrary targetLibrary)
{
// If a NuGet dependency is supposed to provide assemblies but there is no assembly compatible with
// current target framework, we should mark this dependency as unresolved
var containsAssembly = package.Files
.Any(x => x.StartsWith($"ref{Path.DirectorySeparatorChar}") ||
x.StartsWith($"lib{Path.DirectorySeparatorChar}"));
var compatible = targetLibrary.FrameworkAssemblies.Any() ||
targetLibrary.CompileTimeAssemblies.Any() ||
targetLibrary.RuntimeAssemblies.Any() ||
!containsAssembly;
var dependencies = new List<LibraryRange>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count);
PopulateDependencies(dependencies, targetLibrary);
var path = _packagePathResolver.GetInstallPath(package.Name, package.Version);
var packageDescription = new PackageDescription(
path,
package,
targetLibrary,
dependencies,
compatible);
return packageDescription;
}
private void step2StateStepcodeActivity_Initialize_ExecuteCode(object sender, EventArgs e)
{
try
{
if (this.BindingExist("EulaText") == false)
{
PackageDescription packageDescription = GetPackageDescription();
string eulaText = PackageSystemServices.GetEulaText(packageDescription);
this.Bindings.Add("EulaText", eulaText);
}
if (this.BindingExist("EulaAccepted") == false)
{
this.Bindings.Add("EulaAccepted", false);
}
}
catch (Exception ex)
{
this.UpdateBinding("Errors", new List <List <string> > {
new List <string> {
ex.Message, ""
}
});
}
}
public PackagingDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new PackageDescription {
Id = A.Dummy <string>(), Version = A.Dummy <string>()
};
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var packageDescription = A.Dummy <PackageDescription>();
var result = new Package {
PackageDescription = packageDescription, PackageFileBytes = Encoding.UTF32.GetBytes(A.Dummy <string>()), PackageFileBytesRetrievalDateTimeUtc = A.Dummy <DateTime>()
};
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new PackageRepositoryConfiguration {
Source = A.Dummy <string>(), SourceName = A.Dummy <string>(), UserName = A.Dummy <string>(), ClearTextPassword = A.Dummy <string>(), ProtocolVersion = A.Dummy <int?>()
};
return(result);
});
}
private bool TryPopulateMetadataReferences(PackageDescription description, FrameworkName targetFramework, IDictionary <string, IMetadataReference> paths)
{
if (_lookup == null)
{
return(false);
}
var lookupKey = Tuple.Create((string)null, targetFramework, description.Package.LockFileLibrary.Name);
LockFileTargetLibrary targetLibrary;
if (!_lookup.TryGetValue(lookupKey, out targetLibrary))
{
return(false);
}
foreach (var assemblyPath in targetLibrary.CompileTimeAssemblies)
{
if (IsPlaceholderFile(assemblyPath))
{
continue;
}
var name = Path.GetFileNameWithoutExtension(assemblyPath);
var path = Path.Combine(description.Library.Path, assemblyPath);
paths[name] = new MetadataFileReference(name, path);
}
return(true);
}
public static object Build(PackageDescription description, DiffedCompareSet[] diffedCompareSets)
{
return new
{
targets = BuildTargets(diffedCompareSets)
};
}
private IEnumerable <LibraryAsset> GetSharedSources(PackageDescription package)
{
return(package
.PackageLibrary
.Files
.Where(path => path.StartsWith("shared" + Path.DirectorySeparatorChar))
.Select(path => LibraryAsset.CreateFromRelativePath(package.Path, path)));
}
private IEnumerable <string> GetSharedSources(PackageDescription package)
{
return(package
.Library
.Files
.Where(path => path.StartsWith("shared" + Path.DirectorySeparatorChar))
.Select(path => Path.Combine(package.Path, path)));
}
public bool IsPackageServiceable(PackageDescription package)
{
if (!_isEnabled)
{
return false;
}
return package.Library.IsServiceable;
}
public PackageDescription InitializePackageNamed(String name)
{
if (!bindings.TryGetValue(name, out Element description))
{
description = new PackageDescription(name);
bindings.Add(name, description);
}
return((PackageDescription)description);
}
public bool IsPackageServiceable(PackageDescription package)
{
if (!_isEnabled)
{
return(false);
}
return(package.Library.IsServiceable);
}
private IEnumerable <Element> GetInstalledPackageGroupFolderChildren(string groupName, SearchToken seachToken)
{
IEnumerable <InstalledPackageInformation> installedPackageInformations =
from info in PackageManager.GetInstalledPackages()
where info.GroupName == groupName &&
info.IsLocalInstalled == false
orderby info.Name
select info;
var allServerPackages = PackageSystemServices.GetAllAvailablePackages();
foreach (InstalledPackageInformation installedPackageInformation in installedPackageInformations)
{
Element element = new Element(_context.CreateElementHandle(new PackageElementProviderInstalledPackageItemEntityToken(
installedPackageInformation.Id,
installedPackageInformation.GroupName,
installedPackageInformation.IsLocalInstalled,
installedPackageInformation.CanBeUninstalled)));
PackageDescription serverPackageDescription = allServerPackages.Where(f => f.Id == installedPackageInformation.Id).FirstOrDefault();
if (serverPackageDescription != null && !string.IsNullOrEmpty(serverPackageDescription.ConsoleBrowserUrl))
{
element.PropertyBag.Add("BrowserUrl", serverPackageDescription.ConsoleBrowserUrl);
element.PropertyBag.Add("BrowserToolingOn", "false");
}
element.VisualData = new ElementVisualizedData
{
Label = installedPackageInformation.Name,
ToolTip = installedPackageInformation.Name,
HasChildren = false,
Icon = GetIconForPackageItem(installedPackageInformation.Id),
};
element.AddAction(new ElementAction(new ActionHandle(new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.Plugins.Elements.ElementProviders.PackageElementProvider.ViewInstalledPackageInfoWorkflow"), ActionPermissions)))
{
VisualData = new ActionVisualizedData
{
Label = StringResourceSystemFacade.GetString("Composite.Plugins.PackageElementProvider", "ViewInstalledInformationLabel"),
ToolTip = StringResourceSystemFacade.GetString("Composite.Plugins.PackageElementProvider", "ViewInstalledInformationToolTip"),
Icon = ViewInstalledInformationIcon,
Disabled = false,
ActionLocation = new ActionLocation
{
ActionType = ActionType.Edit,
IsInFolder = false,
IsInToolbar = true,
ActionGroup = PrimaryActionGroup
}
}
});
yield return(element);
}
}
private void PopulateAssets(PackageDescription package, IEnumerable <LockFileItem> section, IList <LibraryAsset> assets)
{
foreach (var assemblyPath in section)
{
assets.Add(new LibraryAsset(
Path.GetFileNameWithoutExtension(assemblyPath),
assemblyPath,
Path.Combine(package.Path, assemblyPath)));
}
}
private IEnumerable <string> GetSharedSources(PackageDescription description, FrameworkName targetFramework)
{
var directory = Path.Combine(description.Library.Path, "shared");
if (!Directory.Exists(directory))
{
return(Enumerable.Empty <string>());
}
return(Directory.EnumerateFiles(directory, "*.*", SearchOption.AllDirectories));
}
public void Initialize(IEnumerable <LibraryDescription> packages, FrameworkName targetFramework)
{
Dependencies = packages;
var cacheResolvers = GetCacheResolvers();
var defaultResolver = new DefaultPackagePathResolver(_repository.RepositoryRoot);
foreach (var dependency in packages)
{
var package = FindCandidate(dependency.Identity.Name, dependency.Identity.Version);
if (package == null)
{
continue;
}
string packagePath = ResolvePackagePath(defaultResolver, cacheResolvers, package);
dependency.Path = packagePath;
var packageDescription = new PackageDescription
{
Library = dependency,
Package = package
};
_packageDescriptions[package.Id] = packageDescription;
// Try to find a contract folder for this package and store that
// for compilation
string contractPath = Path.Combine(dependency.Path, "lib", "contract",
package.Id + ".dll");
if (File.Exists(contractPath))
{
packageDescription.ContractPath = contractPath;
}
var assemblies = new List <string>();
foreach (var assemblyInfo in GetPackageAssemblies(packageDescription, targetFramework))
{
_packageAssemblyLookup[assemblyInfo.Name] = new PackageAssembly()
{
Path = assemblyInfo.Path,
RelativePath = assemblyInfo.RelativePath,
Library = dependency
};
assemblies.Add(assemblyInfo.Name);
}
dependency.LoadableAssemblies = assemblies;
}
}
/// <inheritdoc />
public Package GetPackage(
PackageDescription packageDescription)
{
var ret = new Package
{
PackageDescription = packageDescription,
PackageFileBytes = this.GetPackageFile(packageDescription),
PackageFileBytesRetrievalDateTimeUtc = DateTime.UtcNow,
};
return(ret);
}
private static CommandSpec ConfigureCommandFromPackage(string commandName, string args,
PackageDescription commandPackage, ProjectContext projectContext, string depsPath = null)
{
var files = commandPackage.Library.Files;
var packageRoot = projectContext.PackagesDirectory;
var packagePath = commandPackage.Path;
var packageDir = Path.Combine(packageRoot, packagePath);
return(ConfigureCommandFromPackage(commandName, args, files, packageDir, depsPath));
}
public PackageDescription GetDescription(
NuGetFramework targetFramework,
LockFileLibrary package,
LockFileTargetLibrary targetLibrary)
{
// If a NuGet dependency is supposed to provide assemblies but there is no assembly compatible with
// current target framework, we should mark this dependency as unresolved
var containsAssembly = package.Files
.Select(f => f.Replace('/', Path.DirectorySeparatorChar))
.Any(x => x.StartsWith($"ref{Path.DirectorySeparatorChar}") ||
x.StartsWith($"lib{Path.DirectorySeparatorChar}"));
var compatible = targetLibrary.FrameworkAssemblies.Any() ||
targetLibrary.CompileTimeAssemblies.Any() ||
targetLibrary.RuntimeAssemblies.Any() ||
!containsAssembly;
var dependencies =
new List <ProjectLibraryDependency>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count);
PopulateDependencies(dependencies, targetLibrary, targetFramework);
var path = _packagePathResolver?.GetPackageDirectory(package.Name, package.Version);
bool exists = path != null;
string hashPath = null;
if (_versionFolderPathResolver != null)
{
hashPath = _versionFolderPathResolver.GetHashFileName(package.Name, package.Version);
}
if (exists)
{
// If the package's compile time assemblies is for a portable profile then, read the assembly metadata
// and turn System.* references into reference assembly dependencies
PopulateLegacyPortableDependencies(targetFramework, dependencies, path, targetLibrary);
}
var packageDescription = new PackageDescription(
path,
hashPath,
package,
targetLibrary,
dependencies,
compatible,
resolved: compatible && exists);
return(packageDescription);
}
private void viewStateCodeActivity_Initialize_ExecuteCode(object sender, EventArgs e)
{
this.SetCustomToolbarDefinition(new FormDefinitionFileMarkupProvider(CustomToolbarFormPath));
if (this.BindingExist(BindingNames.PackageDescription))
{
return;
}
var castedToken = (PackageElementProviderAvailablePackagesItemEntityToken)this.EntityToken;
PackageDescription packageDescription =
(from description in PackageSystemServices.GetFilteredAllAvailablePackages()
where description.Id.ToString() == castedToken.Id
select description).SingleOrDefault();
if (packageDescription == null)
{
return;
}
string packageSourceName = PackageSystemServices.GetPackageSourceNameByPackageId(packageDescription.Id,
InstallationInformationFacade.InstallationId, UserSettings.CultureInfo);
var purchasableSubscriptions = packageDescription.AvailableInSubscriptions.Where(f => f.Purchasable).ToList();
bool showTrialInformation = false;
var licenses = GetSubscriptionLicenses(packageDescription.AvailableInSubscriptions);
var validLicense = licenses.Where(l => !l.Expired)
.OrderByDescending(l => l.ExpirationDate)
.FirstOrDefault();
this.Bindings = new Dictionary <string, object>
{
{ BindingNames.PackageDescription, packageDescription },
{ BindingNames.DocumentTitle, GetDocumentTitle(packageDescription) },
{ BindingNames.AddOnServerSource, packageSourceName },
{ BindingNames.HasOwnPrice, packageDescription.PriceAmmount > 0 },
{ BindingNames.PriceText, $"{packageDescription.PriceAmmount} {packageDescription.PriceCurrency}" },
{ BindingNames.IsInPurchasableSubscriptions, purchasableSubscriptions.Any() },
{ BindingNames.PurchasableSubscriptions,
string.Join(", \n", purchasableSubscriptions.Select(f => f.Name)) },
{ BindingNames.ShowTrialInfo, packageDescription.IsTrial&& validLicense == null },
{ BindingNames.ShowSubscriptionLicense, validLicense != null },
{ BindingNames.SubscriptionName, validLicense?.Name },
{ BindingNames.LicenseExpirationDate, validLicense?.ExpirationDate.ToLocalTime().ToString() }
};
}
private LibraryExport ExportPackage(PackageDescription package)
{
var builder = LibraryExportBuilder.Create(package);
builder.WithNativeLibraries(PopulateAssets(package, package.NativeLibraries));
builder.WithRuntimeAssemblies(PopulateAssets(package, package.RuntimeAssemblies));
builder.WithCompilationAssemblies(PopulateAssets(package, package.CompileTimeAssemblies));
builder.WithSourceReferences(GetSharedSources(package));
builder.WithAnalyzerReference(GetAnalyzerReferences(package));
if (package.ContentFiles.Any())
{
var parameters = PPFileParameters.CreateForProject(_rootProject.Project);
Action <Stream, Stream> transform = (input, output) => PPFilePreprocessor.Preprocess(input, output, parameters);
var sourceCodeLanguage = _rootProject.Project.GetSourceCodeLanguage();
var languageGroups = package.ContentFiles.GroupBy(file => file.CodeLanguage);
var selectedGroup = languageGroups.FirstOrDefault(g => g.Key == sourceCodeLanguage) ??
languageGroups.FirstOrDefault(g => g.Key == null);
if (selectedGroup != null)
{
foreach (var contentFile in selectedGroup)
{
if (contentFile.CodeLanguage != null &&
string.Compare(contentFile.CodeLanguage, sourceCodeLanguage, StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
}
var fileTransform = contentFile.PPOutputPath != null ? transform : null;
var fullPath = Path.Combine(package.Path, contentFile.Path);
if (contentFile.BuildAction == BuildAction.Compile)
{
builder.AddSourceReference(LibraryAsset.CreateFromRelativePath(package.Path, contentFile.Path, fileTransform));
}
else if (contentFile.BuildAction == BuildAction.EmbeddedResource)
{
builder.AddEmbedddedResource(LibraryAsset.CreateFromRelativePath(package.Path, contentFile.Path, fileTransform));
}
if (contentFile.CopyToOutput)
{
builder.AddRuntimeAsset(new LibraryAsset(contentFile.Path, contentFile.OutputPath, fullPath, fileTransform));
}
}
}
}
return(builder.Build());
}
private void PopulateMetadataReferences(PackageDescription package, IDictionary <string, IMetadataReference> paths)
{
foreach (var assemblyPath in package.Target.CompileTimeAssemblies)
{
if (PackageDependencyProvider.IsPlaceholderFile(assemblyPath))
{
continue;
}
var name = Path.GetFileNameWithoutExtension(assemblyPath);
var path = Path.Combine(package.Path, assemblyPath);
paths[name] = new MetadataFileReference(name, path);
}
}
private static List <AssemblyDescription> GetPackageAssemblies(PackageDescription description, FrameworkName targetFramework)
{
var package = description.Package;
var path = description.Library.Path;
var results = new List <AssemblyDescription>();
IEnumerable <IPackageAssemblyReference> compatibleReferences;
if (VersionUtility.TryGetCompatibleItems(targetFramework, package.AssemblyReferences, out compatibleReferences))
{
// Get the list of references for this target framework
var references = compatibleReferences.ToList();
// See if there's a list of specific references defined for this target framework
IEnumerable <PackageReferenceSet> referenceSets;
if (VersionUtility.TryGetCompatibleItems(targetFramework, package.PackageAssemblyReferences, out referenceSets))
{
// Get the first compatible reference set
var referenceSet = referenceSets.FirstOrDefault();
if (referenceSet != null)
{
// Remove all assemblies of which names do not appear in the References list
references.RemoveAll(r => !referenceSet.References.Contains(r.Name, StringComparer.OrdinalIgnoreCase));
}
}
foreach (var reference in references)
{
// Skip anything that isn't a dll. Unfortunately some packages put random stuff
// in the lib folder and they surface as assembly references
if (!Path.GetExtension(reference.Path).Equals(".dll", StringComparison.OrdinalIgnoreCase))
{
continue;
}
string fileName = Path.Combine(path, reference.Path);
results.Add(new AssemblyDescription
{
// Remove the .dll extension
Name = Path.GetFileNameWithoutExtension(reference.Name),
Path = fileName,
RelativePath = reference.Path
});
}
}
return(results);
}
private LibraryExport ExportPackage(PackageDescription package)
{
var references = new Dictionary <string, IMetadataReference>(StringComparer.OrdinalIgnoreCase);
PopulateMetadataReferences(package, references);
var sourceReferences = new List <ISourceReference>();
foreach (var sharedSource in GetSharedSources(package))
{
sourceReferences.Add(new SourceFileReference(sharedSource));
}
return(new LibraryExport(references.Values.ToList(), sourceReferences));
}
private string HtmlDiff(string packageName, string fromVersion, string untilVersion)
{
using (var writer = new StringWriter())
{
var formatter = new APIUpgradeToHtmlFormatter();
var packageDescription = new PackageDescription
{
PackageId = packageName,
Versions = new VersionPair(fromVersion, untilVersion)
};
var compareSetCreator = new CompareSetCreator();
var sets = compareSetCreator.Create(packageDescription);
var compareSetDiffer = new CompareSetDiffer();
var diff = compareSetDiffer.Diff(sets);
formatter.Render(writer, packageDescription, diff);
return writer.ToString();
}
}
PEAnalyzer(PackageDescription package)
{
_package = package;
}
public LicenseParser(PackageDescription package, Rule packageRule)
{
_package = package;
_packageRule = packageRule;
}
/// <summary>Determines whether the specified object is equal to the current object.</summary>
/// <returns>true if the specified object is equal to the current object; otherwise, false.</returns>
/// <param name="other">The object to compare with the current object. </param>
private bool Equals(PackageDescription other)
{
return string.Equals(this.BuildDate, other.BuildDate) && string.Equals(this.Id, other.Id) && string.Equals(this.Version, other.Version);
}
private List<AssemblyDescription> GetFrameworkAssemblies(PackageDescription description, FrameworkName targetFramework)
{
var results = new List<AssemblyDescription>();
var package = description.Package;
IEnumerable<FrameworkAssemblyReference> frameworkAssemblies;
if (VersionUtility.TryGetCompatibleItems(targetFramework, package.FrameworkAssemblies, out frameworkAssemblies))
{
foreach (var reference in frameworkAssemblies)
{
string path;
if (_frameworkReferenceResolver.TryGetAssembly(reference.AssemblyName, targetFramework, out path))
{
results.Add(new AssemblyDescription
{
Name = reference.AssemblyName,
Path = path
});
}
}
}
return results;
}
public Contributor(PackageDescription package)
{
Package = package;
}
private static List<AssemblyDescription> GetPackageAssemblies(PackageDescription description, FrameworkName targetFramework)
{
var package = description.Package;
var path = description.Library.Path;
var results = new List<AssemblyDescription>();
IEnumerable<IPackageAssemblyReference> compatibleReferences;
if (VersionUtility.TryGetCompatibleItems(targetFramework, package.AssemblyReferences, out compatibleReferences))
{
// Get the list of references for this target framework
var references = compatibleReferences.ToList();
// See if there's a list of specific references defined for this target framework
IEnumerable<PackageReferenceSet> referenceSets;
if (VersionUtility.TryGetCompatibleItems(targetFramework, package.PackageAssemblyReferences, out referenceSets))
{
// Get the first compatible reference set
var referenceSet = referenceSets.FirstOrDefault();
if (referenceSet != null)
{
// Remove all assemblies of which names do not appear in the References list
references.RemoveAll(r => !referenceSet.References.Contains(r.Name, StringComparer.OrdinalIgnoreCase));
}
}
foreach (var reference in references)
{
// Skip anything that isn't a dll. Unfortunately some packages put random stuff
// in the lib folder and they surface as assembly references
if (!Path.GetExtension(reference.Path).Equals(".dll", StringComparison.OrdinalIgnoreCase))
{
continue;
}
string fileName = Path.Combine(path, reference.Path);
results.Add(new AssemblyDescription
{
// Remove the .dll extension
Name = Path.GetFileNameWithoutExtension(reference.Name),
Path = fileName
});
}
}
return results;
}
private LibraryExport ExportPackage(PackageDescription package)
{
var builder = LibraryExportBuilder.Create(package);
builder.WithNativeLibraries(PopulateAssets(package, package.NativeLibraries));
builder.WithRuntimeAssemblies(PopulateAssets(package, package.RuntimeAssemblies));
builder.WithCompilationAssemblies(PopulateAssets(package, package.CompileTimeAssemblies));
builder.WithSourceReferences(GetSharedSources(package));
builder.WithAnalyzerReference(GetAnalyzerReferences(package));
if (package.ContentFiles.Any())
{
var parameters = PPFileParameters.CreateForProject(_rootProject.Project);
Action<Stream, Stream> transform = (input, output) => PPFilePreprocessor.Preprocess(input, output, parameters);
var sourceCodeLanguage = _rootProject.Project.GetSourceCodeLanguage();
var languageGroups = package.ContentFiles.GroupBy(file => file.CodeLanguage);
var selectedGroup = languageGroups.FirstOrDefault(g => g.Key == sourceCodeLanguage) ??
languageGroups.FirstOrDefault(g => g.Key == null);
if (selectedGroup != null)
{
foreach (var contentFile in selectedGroup)
{
if (contentFile.CodeLanguage != null &&
string.Compare(contentFile.CodeLanguage, sourceCodeLanguage, StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
}
var fileTransform = contentFile.PPOutputPath != null ? transform : null;
var fullPath = Path.Combine(package.Path, contentFile.Path);
if (contentFile.BuildAction == BuildAction.Compile)
{
builder.AddSourceReference(LibraryAsset.CreateFromRelativePath(package.Path, contentFile.Path, fileTransform));
}
else if (contentFile.BuildAction == BuildAction.EmbeddedResource)
{
builder.AddEmbedddedResource(LibraryAsset.CreateFromRelativePath(package.Path, contentFile.Path, fileTransform));
}
if (contentFile.CopyToOutput)
{
builder.AddRuntimeAsset(new LibraryAsset(contentFile.Path, contentFile.OutputPath, fullPath, fileTransform));
}
}
}
}
if (package.RuntimeTargets.Any())
{
foreach (var targetGroup in package.RuntimeTargets.GroupBy(t => t.Runtime))
{
var runtime = new List<LibraryAsset>();
var native = new List<LibraryAsset>();
foreach (var lockFileRuntimeTarget in targetGroup)
{
if (string.Equals(lockFileRuntimeTarget.AssetType, "native", StringComparison.OrdinalIgnoreCase))
{
native.Add(LibraryAsset.CreateFromRelativePath(package.Path, lockFileRuntimeTarget.Path));
}
else if (string.Equals(lockFileRuntimeTarget.AssetType, "runtime", StringComparison.OrdinalIgnoreCase))
{
runtime.Add(LibraryAsset.CreateFromRelativePath(package.Path, lockFileRuntimeTarget.Path));
}
}
builder.AddRuntimeTarget(new LibraryRuntimeTarget(targetGroup.Key, runtime, native));
}
}
return builder.Build();
}
public PropSheetParser(PackageDescription package)
{
_package = package;
}
private IEnumerable<LibraryAsset> GetSharedSources(PackageDescription package)
{
return package
.PackageLibrary
.Files
.Where(path => path.StartsWith("shared" + Path.DirectorySeparatorChar))
.Select(path => LibraryAsset.CreateFromRelativePath(package.Path, path));
}
public void Example()
{
var engine = new ComparerEngine();
var diff = engine.CreateDiff("ExampleV1.dll", "ExampleV2.dll");
var writer = new StringWriter();
var formatter = new APIUpgradeToHtmlFormatter();
var packageDescription = new PackageDescription
{
PackageId = "Example",
Versions = new VersionPair("1.0.0", "2.0.0")
};
var diffedCompareSet = new DiffedCompareSet
{
Diff = diff,
Set = new CompareSet()
};
formatter.Render(writer, packageDescription, new [] {diffedCompareSet});
Approvals.VerifyHtml(writer.ToString());
}
internal static Url Create(PackageDescription package, string url, string type)
{
return new Url() {Uri = url, Type = type, Id = new Huid(package.PackageName, package.PackageVersion, package.PackageArch, package.PubToken, "url", type, url)};
}
private IEnumerable<LibraryAsset> PopulateAssets(PackageDescription package, IEnumerable<LockFileItem> section)
{
foreach (var assemblyPath in section)
{
yield return LibraryAsset.CreateFromRelativePath(package.Path, assemblyPath.Path);
}
}
public void Render(TextWriter writer, PackageDescription description, DiffedCompareSet[] diffedCompareSets)
{
var data = ViewModelBuilder.Build(description, diffedCompareSets);
template(writer, data);
}
private IEnumerable<string> GetSharedSources(PackageDescription description, FrameworkName targetFramework)
{
var directory = Path.Combine(description.Library.Path, "shared");
if (!Directory.Exists(directory))
{
return Enumerable.Empty<string>();
}
return Directory.EnumerateFiles(directory, "*.*", SearchOption.AllDirectories);
}
public BindingMinMaxParser(PackageDescription package, Rule packageRule)
{
_package = package;
_packageRule = packageRule;
}
private void PopulateMetadataReferences(PackageDescription description, FrameworkName targetFramework, IDictionary<string, IMetadataReference> paths)
{
var packageAssemblies = GetPackageAssemblies(description, targetFramework);
// Use contract if both contract and target path are available
bool hasContract = description.ContractPath != null;
bool hasLib = packageAssemblies.Any();
if (hasContract && hasLib)
{
paths[description.Library.Identity.Name] = new MetadataFileReference(description.Library.Identity.Name, description.ContractPath);
}
else if (hasLib)
{
foreach (var assembly in packageAssemblies)
{
paths[assembly.Name] = new MetadataFileReference(assembly.Name, assembly.Path);
}
}
foreach (var assembly in GetFrameworkAssemblies(description, targetFramework))
{
paths[assembly.Name] = new MetadataFileReference(assembly.Name, assembly.Path);
}
}
private IEnumerable<AnalyzerReference> GetAnalyzerReferences(PackageDescription package)
{
var analyzers = package
.PackageLibrary
.Files
.Where(path => path.StartsWith("analyzers" + Path.DirectorySeparatorChar) &&
path.EndsWith(".dll"));
var analyzerRefs = new List<AnalyzerReference>();
// See https://docs.nuget.org/create/analyzers-conventions for the analyzer
// NuGet specification
foreach (var analyzer in analyzers)
{
var specifiers = analyzer.Split(Path.DirectorySeparatorChar);
var assemblyPath = Path.Combine(package.Path, analyzer);
// $/analyzers/{Framework Name}{Version}/{Supported Architecture}/{Supported Programming Language}/{Analyzer}.dll
switch (specifiers.Length)
{
// $/analyzers/{analyzer}.dll
case 2:
analyzerRefs.Add(new AnalyzerReference(
assembly: assemblyPath,
framework: null,
language: null,
runtimeIdentifier: null
));
break;
// $/analyzers/{framework}/{analyzer}.dll
case 3:
analyzerRefs.Add(new AnalyzerReference(
assembly: assemblyPath,
framework: NuGetFramework.Parse(specifiers[1]),
language: null,
runtimeIdentifier: null
));
break;
// $/analyzers/{framework}/{language}/{analyzer}.dll
case 4:
analyzerRefs.Add(new AnalyzerReference(
assembly: assemblyPath,
framework: NuGetFramework.Parse(specifiers[1]),
language: specifiers[2],
runtimeIdentifier: null
));
break;
// $/analyzers/{framework}/{runtime}/{language}/{analyzer}.dll
case 5:
analyzerRefs.Add(new AnalyzerReference(
assembly: assemblyPath,
framework: NuGetFramework.Parse(specifiers[1]),
language: specifiers[3],
runtimeIdentifier: specifiers[2]
));
break;
// Anything less than 2 specifiers or more than 4 is
// illegal according to the specification and will be
// ignored
}
}
return analyzerRefs;
}
public void Initialize(IEnumerable<LibraryDescription> packages, FrameworkName targetFramework)
{
Dependencies = packages;
var cacheResolvers = GetCacheResolvers();
var defaultResolver = new DefaultPackagePathResolver(_repository.RepositoryRoot);
foreach (var dependency in packages)
{
var packageInfo = _repository.FindPackagesById(dependency.Identity.Name)
.FirstOrDefault(p => p.Version == dependency.Identity.Version);
if (packageInfo == null)
{
continue;
}
string packagePath = ResolvePackagePath(defaultResolver, cacheResolvers, packageInfo);
// If the package path doesn't exist then mark this dependency as unresolved
if (!Directory.Exists(packagePath))
{
dependency.Resolved = false;
continue;
}
dependency.Path = packagePath;
var packageDescription = new PackageDescription
{
Library = dependency,
Package = packageInfo
};
_packageDescriptions[packageInfo.Id] = packageDescription;
if (Servicing.Breadcrumbs.Instance.IsPackageServiceable(packageDescription.Package))
{
Servicing.Breadcrumbs.Instance.AddBreadcrumb(packageInfo.Id, packageInfo.Version);
}
var group = packageInfo.LockFileLibrary.FrameworkGroups.FirstOrDefault(g => g.TargetFramework == targetFramework);
if (group == null)
{
continue;
}
var assemblies = new List<string>();
foreach (var assemblyPath in group.RuntimeAssemblies)
{
var name = Path.GetFileNameWithoutExtension(assemblyPath);
var path = Path.Combine(dependency.Path, assemblyPath);
string replacementPath;
if (Servicing.ServicingTable.TryGetReplacement(
packageInfo.Id,
packageInfo.Version,
assemblyPath,
out replacementPath))
{
_packageAssemblyLookup[name] = new PackageAssembly()
{
Path = replacementPath,
RelativePath = assemblyPath,
Library = dependency
};
}
else
{
_packageAssemblyLookup[name] = new PackageAssembly()
{
Path = path,
RelativePath = assemblyPath,
Library = dependency
};
}
assemblies.Add(name);
}
dependency.LoadableAssemblies = assemblies;
}
}
private IEnumerable<string> GetSharedSources(PackageDescription description, FrameworkName targetFramework)
{
var directory = Path.Combine(description.Library.Path, "shared");
return description.Package.LockFileLibrary.Files.Where(path => path.StartsWith("shared" + Path.DirectorySeparatorChar))
.Select(path => Path.Combine(description.Library.Path, path));
}
private bool TryPopulateMetadataReferences(PackageDescription description, FrameworkName targetFramework, IDictionary<string, IMetadataReference> paths)
{
var group = description.Package.LockFileLibrary.FrameworkGroups.FirstOrDefault(f => f.TargetFramework == targetFramework);
if (group == null)
{
return false;
}
foreach (var assemblyPath in group.CompileTimeAssemblies)
{
var name = Path.GetFileNameWithoutExtension(assemblyPath);
var path = Path.Combine(description.Library.Path, assemblyPath);
paths[name] = new MetadataFileReference(name, path);
}
return true;
}
private LibraryExport ExportPackage(PackageDescription package)
{
var nativeLibraries = new List<LibraryAsset>();
PopulateAssets(package, package.Target.NativeLibraries, nativeLibraries);
var runtimeAssemblies = new List<LibraryAsset>();
PopulateAssets(package, package.Target.RuntimeAssemblies, runtimeAssemblies);
var compileAssemblies = new List<LibraryAsset>();
PopulateAssets(package, package.Target.CompileTimeAssemblies, compileAssemblies);
var sourceReferences = new List<string>();
foreach (var sharedSource in GetSharedSources(package))
{
sourceReferences.Add(sharedSource);
}
return new LibraryExport(package, compileAssemblies, sourceReferences, runtimeAssemblies, nativeLibraries);
}
private IEnumerable<string> GetSharedSources(PackageDescription package)
{
return package
.Library
.Files
.Where(path => path.StartsWith("shared" + Path.DirectorySeparatorChar))
.Select(path => Path.Combine(package.Path, path));
}
private void PopulateAssets(PackageDescription package, IEnumerable<LockFileItem> section, IList<LibraryAsset> assets)
{
foreach (var assemblyPath in section)
{
if (PathUtility.IsPlaceholderFile(assemblyPath))
{
continue;
}
assets.Add(new LibraryAsset(
Path.GetFileNameWithoutExtension(assemblyPath),
assemblyPath,
Path.Combine(package.Path, assemblyPath)));
}
}
public void Initialize(IEnumerable<LibraryDescription> packages, FrameworkName targetFramework)
{
Dependencies = packages;
var cacheResolvers = GetCacheResolvers();
var defaultResolver = new DefaultPackagePathResolver(_repository.RepositoryRoot);
foreach (var dependency in packages)
{
var package = FindCandidate(dependency.Identity.Name, dependency.Identity.Version);
if (package == null)
{
continue;
}
string packagePath = ResolvePackagePath(defaultResolver, cacheResolvers, package);
dependency.Type = "Package";
dependency.Path = packagePath;
var packageDescription = new PackageDescription
{
Library = dependency,
Package = package
};
_packageDescriptions[package.Id] = packageDescription;
// Try to find a contract folder for this package and store that
// for compilation
string contractPath = Path.Combine(dependency.Path, "lib", "contract",
package.Id + ".dll");
if (File.Exists(contractPath))
{
packageDescription.ContractPath = contractPath;
}
foreach (var assemblyInfo in GetPackageAssemblies(packageDescription, targetFramework))
{
_packageAssemblyPaths[assemblyInfo.Name] = assemblyInfo.Path;
}
}
}
