public NugetPackageInformationComparer(NugetPackageReference localPackage, Datum onlinePackageDatum)
{
_localPackage = localPackage;
_onlinePackage = onlinePackageDatum;
localPackage.Version.Equals(onlinePackageDatum);
}
public AddNugetRestoreSourcesResult(
bool succeeded,
NugetPackageReference requestedPackage,
IReadOnlyList <ResolvedNugetPackageReference> addedReferences = null,
IReadOnlyCollection <string> errors = null) : base(succeeded, requestedPackage, errors)
{
}
public async Task <AddNugetResult> AddPackage(
string packageName,
string packageVersion = null,
string restoreSources = null)
{
var requestedPackage = new NugetPackageReference(packageName, packageVersion, restoreSources);
if (!String.IsNullOrEmpty(packageName) && _nugetPackageReferences.TryGetValue(requestedPackage, out var _))
{
return(new AddNugetPackageResult(false, requestedPackage));
}
_nugetPackageReferences.Add(requestedPackage, null);
WriteProjectFile();
var dotnet = new Dotnet(Directory);
var result = await dotnet.Execute("msbuild -restore /t:WriteNugetAssemblyPaths");
if (result.ExitCode != 0)
{
if (string.IsNullOrEmpty(packageName) && string.IsNullOrEmpty(restoreSources))
{
return(new AddNugetRestoreSourcesResult(
succeeded: false,
requestedPackage,
errors: result.Output.Concat(result.Error).ToArray()));
}
else
{
return(new AddNugetPackageResult(
succeeded: false,
requestedPackage,
errors: result.Output.Concat(result.Error).ToArray()));
}
}
var addedReferences =
GetResolvedNugetReferences()
.Values
.ToArray();
if (string.IsNullOrEmpty(packageName) && !string.IsNullOrEmpty(restoreSources))
{
return(new AddNugetRestoreSourcesResult(
succeeded: true,
requestedPackage: requestedPackage,
addedReferences: addedReferences));
}
else
{
return(new AddNugetPackageResult(
succeeded: true,
requestedPackage: requestedPackage,
addedReferences: addedReferences));
}
}
public NuGetPackageAdded(AddNugetPackage addNugetPackage, NugetPackageReference packageReference) : base(addNugetPackage)
{
if (addNugetPackage == null)
{
throw new System.ArgumentNullException(nameof(addNugetPackage));
}
PackageReference = packageReference;
}
public void Can_find_path_of_nuget_package()
{
var firstPackageRef = new NugetPackageReference("first", "2.0.0");
var secondPackageRef = new NugetPackageReference("second", "3.0.0");
var directory = new InMemoryDirectoryAccessor()
{
($"{firstPackageRef.PackageName}/{firstPackageRef.PackageVersion}/lib/netstandard2.0/{firstPackageRef.PackageName}.dll", ""),
($"{secondPackageRef.PackageName}/{secondPackageRef.PackageVersion}/lib/netstandard2.0/{secondPackageRef.PackageName}.dll", "")
};
NuGetPackagePathResolver.TryGetNuGetPackageBasePath(firstPackageRef, directory.GetAllFilesRecursively().Select(file => directory.GetFullyQualifiedFilePath(file)), out var nugetPackageDirectory);
nugetPackageDirectory.GetFullyQualifiedRoot().FullName.Should().Be(directory.GetFullyQualifiedPath(new RelativeDirectoryPath($"{firstPackageRef.PackageName}/{firstPackageRef.PackageVersion}")).FullName);
}
public AddNugetPackageResult(
bool succeeded,
NugetPackageReference requestedPackage,
IReadOnlyList <ResolvedNugetPackageReference> addedReferences = null,
IReadOnlyCollection <string> errors = null) : base(succeeded, requestedPackage, errors)
{
AddedReferences = addedReferences ?? Array.Empty <ResolvedNugetPackageReference>();
if (Succeeded)
{
InstalledVersion = AddedReferences
.Single(r => r.PackageName.Equals(requestedPackage.PackageName, StringComparison.OrdinalIgnoreCase))
.PackageVersion;
}
}
public bool TryGetPackageVersion(string packageName, out string version)
{
version = string.Empty;
try
{
IList <NugetPackageReference> packageReferences = null;
NugetPackageReference found = null;
if (_targetFramework == ProjectTargetFramework.NETFramework20 ||
_targetFramework == ProjectTargetFramework.NETFramework35 ||
_targetFramework == ProjectTargetFramework.NETFramework40 ||
_targetFramework == ProjectTargetFramework.NETFramework45 ||
_targetFramework == ProjectTargetFramework.NETFramework46 ||
_targetFramework == ProjectTargetFramework.NETFramework47 ||
_targetFramework == ProjectTargetFramework.NETFramework48)
{
if (_packagesConfigFileExist)
{
packageReferences = _fileReaders[_targetFramework].ReadNugetPackages(_metadata.ProjectFullPath) as IList <NugetPackageReference>;
found = packageReferences.FirstOrDefault(x => x.PackageName.Equals(packageName));
version = found.Version;
return(!string.IsNullOrWhiteSpace(found.Version));
}
packageReferences = _fileReaders[ProjectTargetFramework.NETFramework].ReadNugetPackages(_metadata.ProjectFullPath) as IList <NugetPackageReference>;
found = packageReferences.FirstOrDefault(x => x.PackageName.Equals(packageName));
version = found.Version;
return(!string.IsNullOrWhiteSpace(found.Version));
}
packageReferences = _fileReaders[_targetFramework].ReadNugetPackages(_metadata.ProjectFullPath) as IList <NugetPackageReference>;
found = packageReferences.FirstOrDefault(x => x.PackageName.Equals(packageName));
version = found.Version;
return(!string.IsNullOrWhiteSpace(found.Version));
}
catch (InvalidOperationException)
{
return(false);
}
catch (Exception)
{
return(false);
}
}
public ProjectFileAnalyzerResult Analyze(string location = null, bool disableAnalysis = false)
{
if (disableAnalysis)
{
return(new ProjectFileAnalyzerResult
{
ProjectFileFound = false
});
}
var result = LocateCsproj(location);
if (!result.ProjectFileFound)
{
return(result);
}
XPathDocument doc = new XPathDocument(result.ProjectFileLocation);
XPathNavigator nav = doc.CreateNavigator();
var packageReferences = nav.Select("//PackageReference");
while (packageReferences.MoveNext())
{
NugetPackageReference reference = new NugetPackageReference();
reference.Id = packageReferences.Current.GetAttribute("Include", string.Empty);
reference.Version = packageReferences.Current.GetAttribute("Version", string.Empty);
result.NugetReferences.Add(reference);
}
var assemblyReferences = nav.Select("//Reference");
while (assemblyReferences.MoveNext())
{
AssemblyReference reference = new AssemblyReference();
reference.Name = assemblyReferences.Current.GetAttribute("Include", string.Empty);
var packageNode = assemblyReferences.Current.Clone();
if (packageNode.MoveToChild("HintPath", string.Empty))
{
reference.Path = Path.Combine(Path.GetDirectoryName(result.ProjectFileLocation), packageNode.InnerXml);
}
result.AssemblyReferences.Add(reference);
}
return(result);
}
public IEnumerable <NugetPackageReference> ReadNugetPackages(string fileName)
{
var nugetPackages = new List <NugetPackageReference>();
var xmlContent = FileUtil.ReadFileContent(fileName);
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xmlContent);
var nsMgr = new XmlNamespaceManager(xmlDoc.NameTable);
nsMgr.AddNamespace("x", "http://schemas.microsoft.com/developer/msbuild/2003");
foreach (XmlNode xmlNode in xmlDoc.SelectNodes("//x:PackageReference", nsMgr))
{
var packageName = xmlNode.Attributes["Include"].Value;
var packageVersion = xmlNode.InnerText;
//
// SHAH: NOTE on PackageReference "Version" data in .csproj file
/* We need this since there were some modification to the .csproj file structure
* Old strucutre:
* <PackageReference Include="Xamarin.Forms">
* <Version>4.0.0.425677</Version>
* </PackageReference>
*
* New structure:
* <PackageReference Include="Xamarin.Forms" Version="4.0.0.425677" />
*/
if (string.IsNullOrWhiteSpace(packageVersion))
{
packageVersion = xmlNode.Attributes["Version"].Value;
}
var package = new NugetPackageReference(packageName, packageVersion);
nugetPackages.Add(package);
}
return(nugetPackages);
}
public AddNugetResult(
bool succeeded,
NugetPackageReference requestedPackage,
IReadOnlyCollection <string> errors = null)
{
if (requestedPackage == null)
{
throw new ArgumentNullException(nameof(requestedPackage));
}
Succeeded = succeeded;
if (!succeeded &&
errors?.Count == 0)
{
throw new ArgumentException("Must provide errors when succeeded is false."); //TBD: Localize
}
Errors = errors ?? Array.Empty <string>();
}
public IEnumerable <NugetPackageReference> ReadNugetPackages(string fileName)
{
var xmlContent = FileUtil.ReadFileContent(fileName);
var xElement = XElement.Parse(xmlContent);
var itemGroups = xElement.Elements("ItemGroup").ToList();
var packageReferences = itemGroups.Elements("PackageReference").ToList();
var packageReferenceList = new List <NugetPackageReference>();
foreach (var item in packageReferences)
{
var include = item.FirstAttribute.Value;
var version = item.FirstAttribute.NextAttribute.Value;
var packageRefItem = new NugetPackageReference(include, version);
packageReferenceList.Add(packageRefItem);
}
return(packageReferenceList);
}
public NugetPackageReferenceExtended(string projectName, NugetPackageReference nugetPackage)
: base(nugetPackage.PackageName, nugetPackage.Version, nugetPackage.TargetFramework)
{
ProjectName = projectName;
}
public NugetPackageReferenceExtended(Project project, NugetPackageReference nugetPackage)
: base(nugetPackage.PackageName, nugetPackage.Version, nugetPackage.TargetFramework)
{
ProjectName = project.ProjectName;
ProjectTargetFramework = project.TargetFramework;
}
public NuGetPackageAdded(AddNugetPackage command, NugetPackageReference packageReference) : base(command)
{
PackageReference = packageReference;
}
public NuGetPackageAdded(NugetPackageReference packageReference)
{
PackageReference = packageReference;
}
public LoadExtensionFromNuGetPackage(NugetPackageReference nugetPackageReference, IEnumerable <FileInfo> metadataReferences)
{
NugetPackageReference = nugetPackageReference ?? throw new ArgumentNullException(nameof(nugetPackageReference));
MetadataReferences = metadataReferences ?? throw new ArgumentNullException(nameof(metadataReferences));
}
public void SetUp()
{
_name = "TestValue371271030";
_version = "TestValue67196216";
_testClass = new NugetPackageReference(_name, _version);
}
public static CSharpKernel UseNugetDirective(
this CSharpKernel kernel)
{
var packageRefArg = new Argument <NugetPackageReference>((SymbolResult result, out NugetPackageReference reference) =>
NugetPackageReference.TryParse(result.Token.Value, out reference))
{
Name = "package"
};
var command = new Command("#r")
{
packageRefArg
};
var restoreContext = new PackageRestoreContext();
command.Handler = CommandHandler.Create <NugetPackageReference, KernelInvocationContext>(async(package, pipelineContext) =>
{
var addPackage = new AddNugetPackage(package);
addPackage.Handler = async context =>
{
var message = $"Installing package {package.PackageName}";
if (!string.IsNullOrWhiteSpace(package.PackageVersion))
{
message += $", version {package.PackageVersion}";
}
message += "...";
var key = message;
var displayed = new DisplayedValueProduced(message, context.Command, valueId: key);
context.Publish(displayed);
var addPackageTask = restoreContext.AddPackage(
package.PackageName,
package.PackageVersion,
package.RestoreSources);
while (await Task.WhenAny(Task.Delay(500), addPackageTask) != addPackageTask)
{
message += ".";
context.Publish(new DisplayedValueUpdated(message, key));
}
message += "done!";
context.Publish(new DisplayedValueUpdated(message, key));
var result = await addPackageTask;
var helper = kernel.NativeAssemblyLoadHelper;
if (result.Succeeded)
{
switch (result)
{
case AddNugetPackageResult packageResult:
var nativeLibraryProbingPaths = packageResult.NativeLibraryProbingPaths;
helper?.SetNativeLibraryProbingPaths(nativeLibraryProbingPaths);
var addedAssemblyPaths =
packageResult
.AddedReferences
.SelectMany(added => added.AssemblyPaths)
.ToArray();
if (helper != null)
{
foreach (var addedReference in packageResult.AddedReferences)
{
helper.Handle(addedReference);
}
}
kernel.AddScriptReferences(packageResult.AddedReferences);
context.Publish(
new DisplayedValueProduced($"Successfully added reference to package {package.PackageName}, version {packageResult.InstalledVersion}",
context.Command));
context.Publish(new NuGetPackageAdded(addPackage, package));
var resolvedNugetPackageReference = await restoreContext.GetResolvedNugetPackageReference(package.PackageName);
await context.HandlingKernel.SendAsync(
new LoadExtensionsInDirectory(
resolvedNugetPackageReference.PackageRoot,
addedAssemblyPaths));
break;
default:
break;
}
}
else
{
var errors = $"{string.Join(Environment.NewLine, result.Errors)}";
switch (result)
{
case AddNugetPackageResult _:
context.Publish(
new ErrorProduced(
$"Failed to add reference to package {package.PackageName}{Environment.NewLine}{errors}"));
break;
case AddNugetRestoreSourcesResult _:
context.Publish(
new ErrorProduced(
$"Failed to apply RestoreSources {package.RestoreSources}{Environment.NewLine}{errors}"));
break;
default:
break;
}
}
context.Complete();
};
await pipelineContext.HandlingKernel.SendAsync(addPackage);
});
kernel.AddDirective(command);
return(kernel);
}
public void CanConstruct()
{
var instance = new NugetPackageReference(_name, _version);
Assert.That(instance, Is.Not.Null);
}
public void Nuget_package_reference_correctly_parses_package_name(string value)
{
NugetPackageReference.TryParse(value, out var reference);
reference.PackageName.Should().Be("PocketLogger");
}
public void Nuget_package_reference_correctly_parses_package_version(string value, string expectedVersion)
{
NugetPackageReference.TryParse(value, out var reference);
reference.PackageVersion.Should().Be(expectedVersion);
}
public AddNugetPackage(NugetPackageReference packageReference)
{
PackageReference = packageReference ?? throw new ArgumentNullException(nameof(packageReference));
}
