public override Task <ProjectPackages> GetInstalledAndTransitivePackagesAsync(CancellationToken token)
{
var transitivePackages = TransitivePackages.Select(p => new TransitivePackageReference(p));
var projectPackages = new ProjectPackages(InstalledPackages.ToList(), transitivePackages.ToList());
return(Task.FromResult(projectPackages));
}
public void PackageNameContainsNumbers()
{
ProjectPackages projectPackages = new ProjectPackages( new[] {
new PackageReference( new PackageIdentity( "C.1V1", NuGetVersion.Parse( "1.2.3" ) ), NuGetFramework.Parse( "net45" ), false )
} );
Assert.That( projectPackages.IsPackageReferenced( new Reference( string.Empty, null, null, "C.1V1.1.2.3" ).HintPath ), Is.True );
Assert.That( projectPackages.IsPackageReferenced( new Reference( string.Empty, null, null, "C.2V1.1.2.3" ).HintPath ), Is.False );
}
public bool PassAudit()
{
return(MissingPackages.IsEmpty() &&
ProjectPackages.IsEmpty() &&
InconsistentPackages.IsEmpty() &&
UnusedPackages.IsEmpty() &&
SnapshotPackages.IsEmpty() &&
MissingPackageReferences.IsEmpty() &&
DuplicatePackageReferences.IsEmpty() &&
BindingRedirectMismatchReferences.IsEmpty() &&
BadProjectRefGuids.IsEmpty() &&
IllegalNugetTargets.IsEmpty());
}
public async Task GetInstalledPackagesAsync_PackageReferenceProject_ReturnsTransitiveAsync()
{
// Arrange
var projectGuid = Guid.NewGuid();
var settings = new Mock <ISettings>();
var telemetryProvider = new Mock <INuGetTelemetryProvider>(MockBehavior.Strict);
var installedPackages = new List <PackageReference>()
{
new PackageReference(new PackageIdentity("a", new NuGetVersion(1, 0, 0)), FrameworkConstants.CommonFrameworks.Net50)
};
var transitivePackages = new List <PackageReference>()
{
new PackageReference(new PackageIdentity("b", new NuGetVersion(1, 2, 3)), FrameworkConstants.CommonFrameworks.Net50)
};
var transitiveProjectPackages = transitivePackages.Select(p => new TransitivePackageReference(p)).ToList();
var projectPackages = new ProjectPackages(installedPackages, transitiveProjectPackages);
var project = new TestPackageReferenceProject("ProjectA", @"src\ProjectA\Project.csproj", @"c:\path\to\src\ProjectA\ProjectA.csproj",
installedPackages, transitivePackages);
var solutionManager = new Mock <IVsSolutionManager>();
solutionManager.Setup(sm => sm.GetNuGetProjectAsync(projectGuid.ToString()))
.Returns(() => Task.FromResult <NuGetProject>(project));
// Act
var target = new NuGetProjectService(solutionManager.Object, settings.Object, telemetryProvider.Object);
InstalledPackagesResult actual = await target.GetInstalledPackagesAsync(projectGuid, CancellationToken.None);
// Assert
Assert.NotNull(actual);
Assert.Equal(InstalledPackageResultStatus.Successful, actual.Status);
NuGetInstalledPackage package = actual.Packages.FirstOrDefault(p => p.Id == "a");
Assert.NotNull(package);
Assert.True(package.DirectDependency);
package = actual.Packages.FirstOrDefault(p => p.Id == "b");
Assert.NotNull(package);
Assert.False(package.DirectDependency);
}
/// <summary>
/// Merges project files and references
/// </summary>
/// <param name="projectPackages">Nuget package information</param>
/// <param name="baseDocument">The base project xml</param>
/// <param name="localDocument">The local project xml</param>
/// <param name="incomingDocument">The incoming project xml</param>
/// <param name="filePath">The file containing the conflicts being merged</param>
/// <returns>Returns the merged items</returns>
public IEnumerable<Item> Merge(
string filePath,
ProjectPackages projectPackages,
XDocument baseDocument,
XDocument localDocument,
XDocument incomingDocument )
{
var projFileName = Path.GetFileName( filePath );
var localProj = CsProjParser.Parse( projFileName, localDocument );
var theirProj = CsProjParser.Parse( projFileName, incomingDocument );
var baseProj = CsProjParser.Parse( projFileName, baseDocument );
var localRefs = localProj.GetItems<Reference>().ToList();
var theirRefs = theirProj.GetItems<Reference>().ToList();
var baseRefs = baseProj.GetItems<Reference>().ToList();
localRefs.ForEach( r => r.ApplyIsResolveOption( projectPackages ) );
theirRefs.ForEach( r => r.ApplyIsResolveOption( projectPackages ) );
baseRefs.ForEach( r => r.ApplyIsResolveOption( projectPackages ) );
var localProjectRefs = localProj.GetItemsDictionary<ProjectReference>();
var theirProjectRefs = theirProj.GetItemsDictionary<ProjectReference>();
var baseProjectRefs = baseProj.GetItemsDictionary<ProjectReference>();
var localItems = localProj.GetItemsDictionary<RawItem>();
var theirItems = theirProj.GetItemsDictionary<RawItem>();
var baseItems = baseProj.GetItemsDictionary<RawItem>();
var resolvedItems = MergeHelper<RawItem>.MergeAll(
filePath, _operation, baseItems, localItems, theirItems, _itemResolver );
var resolvedReferences = MergeReferences( filePath, baseRefs, localRefs, theirRefs );
var resolvedProjectReferences = MergeHelper<ProjectReference>.MergeAll(
filePath, _operation, baseProjectRefs, localProjectRefs, theirProjectRefs, _projectReferenceResolver );
return resolvedItems.Cast<Item>().Concat( resolvedReferences ).Concat( resolvedProjectReferences );
}
public override string ToString()
{
var sb = new StringBuilder();
sb.AppendLine(RoslynProject.Name);
UnusedPackages.ForEach(p => sb.AppendFormat("\t{0}\n", p));
ProjectPackages.ForEach(p => sb.AppendFormat("\t{0}\n", p));
MissingPackages.ForEach(p => sb.AppendFormat("\t{0}\n", p));
MissingPackageReferences.ForEach(p => sb.AppendFormat("\t{0}\n", p));
BindingRedirectMismatchReferences.ForEach(p => sb.AppendFormat("\t{0}\n", p));
SnapshotPackages.ForEach(p => sb.AppendFormat("\t{0}\n", p));
DuplicatePackageReferences.ForEach(p => sb.AppendFormat("\t{0}\n", p));
BadProjectRefGuids.ForEach(p => sb.AppendFormat("\t{0}\n", p));
IllegalNugetTargets.ForEach(p => sb.AppendFormat("\t{0}\n", p));
if (InconsistentPackages != null)
{
InconsistentPackages.ForEach(p => sb.AppendFormat("\t{0}\n", p));
}
return(sb.ToString());
}
private static void ProcessProjectFiles(
CurrentOperation operation,
string[] conflictPaths,
DirectoryInfo folder,
Logger logger,
string rootFolder )
{
var merger = new ProjectMerger(
operation,
new UserConflictResolver<ProjectReference>( operation, repositoryRootDirectory: rootFolder ),
new ReferenceConflictResolver( new UserConflictResolver<Reference>( operation, notResolveOptionText: PackageNotInstalledText, repositoryRootDirectory: rootFolder ) ),
new UserConflictResolver<RawItem>( operation, repositoryRootDirectory: rootFolder ),
new UserDuplicateResolver<Reference>( operation, notResolveOptionText: PackageNotInstalledText, repositoryRootDirectory: rootFolder ) );
foreach ( var conflict in conflictPaths.Where( p => p.EndsWith( ".csproj" ) || p.EndsWith( ".fsproj" ) || p.EndsWith( ".xproj" )) ) {
var fullConflictPath = Path.Combine( folder.FullName, conflict );
logger.Info( $"{LogHelper.Header}{Environment.NewLine}Examining concurrent modification for {fullConflictPath}" );
var baseContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Ancestor, conflict );
var localContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Ours, conflict );
var incomingContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Theirs, conflict );
var conflictFolder = Path.GetDirectoryName( Path.Combine( rootFolder, conflict ) );
if ( conflictFolder == null ) {
throw new Exception( "No conflict folder" );
}
if ( string.IsNullOrEmpty( localContent ) || string.IsNullOrEmpty( incomingContent ) ) {
logger.Log( LogLevel.Info, $"Skipping '{conflict}' - no content on one side" );
continue;
}
var localDocument = XDocument.Parse( localContent );
var incomingDocument = XDocument.Parse( incomingContent );
var baseDocument = XDocument.Parse( baseContent ?? "<?xml version=\"1.0\" encoding=\"utf - 8\"?><Project/>" );
var resolved = false;
try {
var projectFolder = Path.Combine( folder.FullName, conflictFolder );
var packagesConfigFilePath = ProjectPackages.GetPackagesConfigFilePath( projectFolder );
var packagesConfig = ProjectPackages.TryLoadPackagesConfig( packagesConfigFilePath );
if ( packagesConfig == null ) {
continue;
}
var packageIndex = new ProjectPackages( projectFolder, NuGetExtensions.FindRelativePathOfPackagesFolder( projectFolder ), packagesConfig );
Item[] items = merger.Merge(
conflict,
packageIndex,
baseDocument,
localDocument,
incomingDocument ).ToArray();
// Now remove everything we have handled, to check if we are done.
ProjectFile.DeleteItems( localDocument );
ProjectFile.DeleteItems( incomingDocument );
ProjectFile.DeleteItems( baseDocument );
ProjectFile.AddItems( baseDocument, items );
ProjectFile.AddItems( localDocument, items );
ProjectFile.AddItems( incomingDocument, items );
XDocument resolvedDocument = null;
var localXml = localDocument.ToString();
var incomingXml = incomingDocument.ToString();
var baseXml = baseDocument.ToString();
// Check for any project file changes outside of the references and items.
if ( localXml == incomingXml ) {
resolvedDocument = localDocument;
} else if ( baseXml == localXml ) {
resolvedDocument = incomingDocument;
} else if ( baseXml == incomingXml ) {
resolvedDocument = localDocument;
}
if ( resolvedDocument != null ) {
// We handled all the differences
using ( var textWriter = new StreamWriter( fullConflictPath ) ) {
SerialisationHelper.WriteXml( resolvedDocument, textWriter );
}
using ( var repository = new Repository( rootFolder ) ) {
repository.Stage( conflict );
}
resolved = true;
}
} catch ( MergeAbortException ) {
logger.Log( LogLevel.Info, $"Project merge aborted for {conflict}" );
continue;
} catch ( UserQuitException ) {
throw;
} catch ( Exception exception ) {
logger.Log( LogLevel.Error, exception, $"Project merge failed for {conflict}{Environment.NewLine}{exception}" );
}
if ( resolved ) {
continue;
}
string userQuestionText = $"Could not resolve conflict: {conflict}{Environment.NewLine}Would you like to resolve the conflict with the mergetool?";
var userQuestion = new UserQuestion<bool>( userQuestionText, UserQuestion<bool>.YesNoOptions() );
if ( userQuestion.Resolve() ) {
using ( var repository = new Repository( rootFolder ) ) {
GitHelper.ResolveWithStandardMergetool(
repository,
fullConflictPath,
baseDocument,
localDocument,
incomingDocument,
logger,
conflict );
}
}
}
}
public static void ApplyIsResolveOption( this Reference reference, ProjectPackages projectPackages )
{
reference.IsResolveOption = !projectPackages.IsPackageReference( reference.HintPath ) ||
projectPackages.IsPackageReferenced( reference.HintPath );
}
public override Task <ProjectPackages> GetInstalledAndTransitivePackagesAsync(CancellationToken token)
{
var projectPackages = new ProjectPackages(_installedPackages, _transitivePackages);
return(Task.FromResult(projectPackages));
}
private bool UpgradePackagesConfig(
ProjectPackages oldPackagesConfig,
ProjectFile project )
{
List<PackageReference> updatedPackages = new List<PackageReference>();
bool changed = false;
var logger = LogManager.GetCurrentClassLogger();
foreach ( var package in oldPackagesConfig ) {
var newPackage = _packageIndex.GetTarget( package.PackageIdentity.Id );
updatedPackages.Add( newPackage );
var newVersion = newPackage.PackageIdentity.Version;
if ( newVersion.Equals( package.PackageIdentity.Version ) ) {
continue;
}
changed = true;
logger.Info( project.Name +
": Changing " + package.PackageIdentity.Id +
" version " + package.PackageIdentity.Version + " to " + newVersion );
NuGetExtensions.InstallPackage( Path.GetDirectoryName( _projectFile ), newPackage );
}
if ( !changed ) {
return false;
}
var config = Path.Combine( Path.GetDirectoryName( _projectFile ), "packages.config" );
logger.Info( "Writing changes to " + config );
updatedPackages.Write( config );
return true;
}
public void AlignReferences()
{
Logger logger = LogManager.GetCurrentClassLogger();
var projectFolder = Path.GetDirectoryName( _projectFile );
var packagesRelativePath = NuGetExtensions.FindRelativePathOfPackagesFolder( projectFolder );
var oldXml = ProjectPackages.TryLoadPackagesConfig( projectFolder );
if ( oldXml == null ) {
return;
}
ProjectPackages oldPackagesConfig = new ProjectPackages( projectFolder, packagesRelativePath, oldXml );
var projectPath = _projectFile;
ProjectFile project;
using ( var fs = new FileStream( projectPath, FileMode.Open ) ) {
project = CsProjParser.Parse( Path.GetFileName( projectPath ), fs );
}
if ( !UpgradePackagesConfig( oldPackagesConfig, project ) ) {
return;
}
var newXml = ProjectPackages.TryLoadPackagesConfig( projectFolder );
if ( newXml == null ) {
return;
}
// reparse packages
ProjectPackages updatedPackagesConfig = new ProjectPackages( projectFolder, packagesRelativePath, newXml );
bool changed = false;
Dictionary<Item, Item> itemMap = new Dictionary<Item, Item>( new XmlComparer( oldXml.Root.Name.Namespace ) );
foreach ( var itemGroup in project.ItemGroups ) {
foreach ( var item in itemGroup.Items ) {
if ( !( item is Reference ) ) {
itemMap[item] = item;
continue;
}
Reference reference = item as Reference;
if ( !oldPackagesConfig.IsPackageReference( reference.HintPath ) ) {
if ( itemMap.ContainsKey( item ) ) {
logger.Error(
$"{_projectFile} has duplicate entry\n{item.ToElement( XNamespace.None )}\nThis has been fixed automatically." );
}
itemMap.Add( item, item ); // we keep any non package references (ie System.Xml)
continue;
}
var referencedInOldPackage = oldPackagesConfig.IsPackageReferenced( reference.HintPath );
if ( !referencedInOldPackage
&& !updatedPackagesConfig.IsPackageReferenced( reference.HintPath ) ) {
logger.Info( "Removing " + reference + " as package not listed in packages.config" );
changed = true;
continue; // remove reference
}
PackageIdentity refPackage = oldPackagesConfig.PackageIdentityFromHintPath( reference.HintPath );
PackageReference newestPackage = updatedPackagesConfig[refPackage.Id];
if ( !refPackage.Equals( newestPackage.PackageIdentity ) ) {
if ( new VersionComparer( VersionComparison.Default ).Compare( refPackage.Version, newestPackage.PackageIdentity.Version ) > 0 ) {
logger.Warn( "The installed version "
+ newestPackage.PackageIdentity.Version
+ "(that we are aligning to) of " + refPackage.Id + " is lower than the referenced package version " + refPackage.Version );
}
var updatedReference = UpdateReference( projectFolder, packagesRelativePath, refPackage, newestPackage, reference );
if ( updatedReference != null ) {
reference = updatedReference;
changed = true;
}
else {
logger.Error( "Could not reconstruct hintpath " + reference.HintPath + " original reference will not be changed" );
}
}
itemMap.Add( item, reference );
}
}
if ( !changed ) {
logger.Info( "No changes made to " + _projectFile );
return;
}
XDocument projectXml = XDocument.Load( _projectFile );
projectXml = ReplaceItems( projectXml, itemMap );
using ( var textWriter = new StreamWriter( _projectFile ) ) {
logger.Info( "Writing " + _projectFile );
projectXml.WriteXml( textWriter );
}
}
public void ApplyIsResolveOption( ProjectPackages projectPackages )
{
IsResolveOption = !projectPackages.IsPackageReference( this ) || projectPackages.IsPackageReferenced( this );
}
