public void CreateSharedRepository_MethodCalled_ReturnsSharedPackageRepository()
{
CreateCache();
ISharedPackageRepository repository = cache.CreateSharedRepository(null, null, null);
Assert.IsNotNull(repository);
}
private void RegisterPackagesConfig(ISharedPackageRepository sharedPackagesRepository)
{
var packagesConfigFilePath = Path.Combine(_vsProject.ProjectDirectory.FullName + "\\", PackageReferenceFilename);
sharedPackagesRepository.RegisterRepository(packagesConfigFilePath);
_vsProject.AddFile(PackageReferenceFilename);
}
public PackageManager(IPackageRepository sourceRepository, IPackagePathResolver pathResolver, IFileSystem fileSystem, ISharedPackageRepository localRepository)
{
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
if (pathResolver == null)
{
throw new ArgumentNullException("pathResolver");
}
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (localRepository == null)
{
throw new ArgumentNullException("localRepository");
}
SourceRepository = sourceRepository;
PathResolver = pathResolver;
FileSystem = fileSystem;
LocalRepository = localRepository;
DependencyVersion = DependencyVersion.Lowest;
CheckDowngrade = true;
}
public RepositoryInfo(string path, string configFolderPath, IFileSystem fileSystem, ISharedPackageRepository repository)
{
Path = path;
FileSystem = fileSystem;
Repository = repository;
ConfigFolderPath = configFolderPath;
}
public void AddNugetReferenceMetadata(ISharedPackageRepository sharedPackagesRepository, ICollection<IPackage> packagesToAdd)
{
_console.WriteLine("Checking for any project references for {0}...", PackageReferenceFilename);
if (!packagesToAdd.Any()) return;
CreatePackagesConfig(packagesToAdd);
RegisterPackagesConfig(sharedPackagesRepository);
}
public MockVsPackageManager(
ISolutionManager solutionManager,
IPackageRepository sourceRepository,
ISharedPackageRepository localRepository)
: base(solutionManager, sourceRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem("x:\\root"), localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object)
{
}
public PackageManager(
IPackageRepository sourceRepository,
IPackagePathResolver pathResolver,
IFileSystem fileSystem,
ISharedPackageRepository localRepository)
{
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
if (pathResolver == null)
{
throw new ArgumentNullException("pathResolver");
}
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (localRepository == null)
{
throw new ArgumentNullException("localRepository");
}
SourceRepository = sourceRepository;
DependencyResolver = new DependencyResolverFromRepo(sourceRepository);
PathResolver = pathResolver;
FileSystem = fileSystem;
LocalRepository = localRepository;
DependencyVersion = DependencyVersion.Lowest;
CheckDowngrade = true;
}
internal void UpdatePackages(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = new VerboseLogger(this);
using (sourceRepository.StartOperation(RepositoryOperationNames.Update))
{
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
try
{
if (projectManager.IsInstalled(package))
{
Log(Level.Debug, "Found installed package {0}", package.Id);
}
// If the user explicitly allows prerelease or if the package being updated is prerelease we'll include prerelease versions in our list of packages
// being considered for an update.
bool allowPrerelease = Prerelease || !package.IsReleaseVersion();
if (Safe)
{
IVersionSpec safeRange = VersionUtility.GetSafeRange(package.Version);
projectManager.UpdatePackageReference(package.Id, safeRange, updateDependencies: true, allowPrereleaseVersions: allowPrerelease);
}
else
{
projectManager.UpdatePackageReference(package.Id, version: null, updateDependencies: true, allowPrereleaseVersions: allowPrerelease);
}
}
catch (InvalidOperationException e)
{
Log(Level.Warning, e.Message);
}
}
}
}
}
public void CreatePackageManager_ProjectAndSolutionHaveDifferentFolders_PackageManagerLocalRepositoryIsSharedRepository()
{
CreateFactory();
CreateTestProject();
CreatePackageManager();
ISharedPackageRepository sharedRepository = packageManager.LocalRepository as ISharedPackageRepository;
Assert.IsNotNull(sharedRepository);
}
public VsPackageManager(ISolutionManager solutionManager, IPackageRepository sourceRepository, IFileSystem fileSystem, ISharedPackageRepository sharedRepository, IPackageRepository recentPackagesRepository) :
base(sourceRepository, new DefaultPackagePathResolver(fileSystem), fileSystem, sharedRepository)
{
_solutionManager = solutionManager;
_sharedRepository = sharedRepository;
_recentPackagesRepository = recentPackagesRepository;
_projects = new Dictionary <string, IProjectManager>(StringComparer.OrdinalIgnoreCase);
}
public CoreInteropPackageManager(
ISharedPackageRepository sharedRepo,
IDependencyResolver2 dependencyResolver,
CoreInteropSourceRepository sourceRepo)
{
_sharedRepo = sharedRepo;
_sourceRepo = sourceRepo;
DependencyResolver = dependencyResolver;
}
public CoreInteropPackageManager(
ISharedPackageRepository sharedRepo,
IDependencyResolver2 dependencyResolver,
CoreInteropSourceRepository sourceRepo)
{
_sharedRepo = sharedRepo;
_sourceRepo = sourceRepo;
DependencyResolver = dependencyResolver;
}
public VsPackageManager(ISolutionManager solutionManager, IPackageRepository sourceRepository, IFileSystem fileSystem, ISharedPackageRepository sharedRepository, IPackageRepository recentPackagesRepository)
: base(sourceRepository, new DefaultPackagePathResolver(fileSystem), fileSystem, sharedRepository)
{
_solutionManager = solutionManager;
_sharedRepository = sharedRepository;
_recentPackagesRepository = recentPackagesRepository;
_projects = new Dictionary<string, IProjectManager>(StringComparer.OrdinalIgnoreCase);
}
public void AddNugetReferenceMetadata(ISharedPackageRepository sharedPackagesRepository, ICollection <IPackage> packagesToAdd, FrameworkName targetFramework)
{
_console.WriteLine("Checking for any project references for {0}...", PackageReferenceFilename);
if (!packagesToAdd.Any())
{
return;
}
CreatePackagesConfig(packagesToAdd, targetFramework);
RegisterPackagesConfig(sharedPackagesRepository);
}
ISharpDevelopPackageManager CreatePackageManager(
IFileSystem fileSystem,
IPackageRepository packageRepository,
MSBuildBasedProject project)
{
DefaultPackagePathResolver pathResolver = new DefaultPackagePathResolver(fileSystem);
ISharedPackageRepository sharedRepository = CreateSharedRepository(pathResolver, fileSystem);
IProjectSystem projectSystem = CreateProjectSystem(project);
return(new SharpDevelopPackageManager(packageRepository, projectSystem, fileSystem, sharedRepository, pathResolver));
}
public PackageReferenceRepository(string configFilePath, ISharedPackageRepository sourceRepository)
{
if (string.IsNullOrEmpty(configFilePath))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "configFilePath");
}
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
this._packageReferenceFile = new PackageReferenceFile(configFilePath);
this.SourceRepository = sourceRepository;
}
public PackageReferenceRepository(IFileSystem fileSystem, ISharedPackageRepository sourceRepository)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
_packageReferenceFile = new PackageReferenceFile(fileSystem, PackageReferenceFile);
_fullPath = fileSystem.GetFullPath(PackageReferenceFile);
SourceRepository = sourceRepository;
}
public PackageReferenceRepository(IFileSystem fileSystem, ISharedPackageRepository sourceRepository)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
_packageReferenceFile = new PackageReferenceFile(fileSystem, Constants.PackageReferenceFile);
_fullPath = fileSystem.GetFullPath(Constants.PackageReferenceFile);
SourceRepository = sourceRepository;
}
public SharpDevelopPackageManager(
IPackageRepository sourceRepository,
IProjectSystem projectSystem,
IFileSystem fileSystem,
ISharedPackageRepository localRepository,
IPackagePathResolver pathResolver)
: base(
sourceRepository,
pathResolver,
fileSystem,
localRepository)
{
this.projectSystem = projectSystem;
CreateProjectManager();
}
public SharpDevelopPackageManager(
IPackageRepository sourceRepository,
IProjectSystem projectSystem,
IFileSystem fileSystem,
ISharedPackageRepository localRepository,
IPackagePathResolver pathResolver)
: base(
sourceRepository,
pathResolver,
fileSystem,
localRepository)
{
this.projectSystem = projectSystem;
CreateProjectManager();
}
public VsPackageManager(ISolutionManager solutionManager,
IPackageRepository sourceRepository,
IFileSystemProvider fileSystemProvider,
IFileSystem fileSystem,
ISharedPackageRepository sharedRepository,
IDeleteOnRestartManager deleteOnRestartManager,
VsPackageInstallerEvents packageEvents)
: base(sourceRepository, new DefaultPackagePathResolver(fileSystem), fileSystem, sharedRepository)
{
_solutionManager = solutionManager;
_sharedRepository = sharedRepository;
_packageEvents = packageEvents;
_fileSystemProvider = fileSystemProvider;
_deleteOnRestartManager = deleteOnRestartManager;
_projects = new Dictionary<string, IProjectManager>(StringComparer.OrdinalIgnoreCase);
}
public CoreInteropProjectManager(
InstallationTarget target,
SourceRepository activeSource,
IDependencyResolver2 dependencyResolver)
{
// Get the required features from the target
_sharedRepo = target.GetRequiredFeature <ISharedPackageRepository>();
_refRepo = target.GetRequiredFeature <IProjectManager>().LocalRepository;
_projectSystem = target.TryGetFeature <IProjectSystem>();
_target = target;
_sourceRepo = new CoreInteropSourceRepository(activeSource);
_pacman = new CoreInteropPackageManager(
_sharedRepo,
dependencyResolver,
_sourceRepo);
}
public PackageReferenceRepository(
string configFilePath,
ISharedPackageRepository sourceRepository)
{
if (String.IsNullOrEmpty(configFilePath))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "configFilePath");
}
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
_packageReferenceFile = new PackageReferenceFile(configFilePath);
SourceRepository = sourceRepository;
}
public CoreInteropProjectManager(
InstallationTarget target,
SourceRepository activeSource,
IDependencyResolver2 dependencyResolver)
{
// Get the required features from the target
_sharedRepo = target.GetRequiredFeature<ISharedPackageRepository>();
_refRepo = target.GetRequiredFeature<IProjectManager>().LocalRepository;
_projectSystem = target.TryGetFeature<IProjectSystem>();
_target = target;
_sourceRepo = new CoreInteropSourceRepository(activeSource);
_pacman = new CoreInteropPackageManager(
_sharedRepo,
dependencyResolver,
_sourceRepo);
}
public VsPackageManager(ISolutionManager solutionManager,
IPackageRepository sourceRepository,
IFileSystemProvider fileSystemProvider,
IFileSystem fileSystem,
ISharedPackageRepository sharedRepository,
IDeleteOnRestartManager deleteOnRestartManager,
VsPackageInstallerEvents packageEvents,
IVsFrameworkMultiTargeting frameworkMultiTargeting = null)
: base(sourceRepository, new DefaultPackagePathResolver(fileSystem), fileSystem, sharedRepository)
{
_solutionManager = solutionManager;
_sharedRepository = sharedRepository;
_packageEvents = packageEvents;
_fileSystemProvider = fileSystemProvider;
_deleteOnRestartManager = deleteOnRestartManager;
_frameworkMultiTargeting = frameworkMultiTargeting;
_projects = new Dictionary<string, IProjectManager>(StringComparer.OrdinalIgnoreCase);
}
public PackageReferenceRepository(
IFileSystem fileSystem,
string projectName,
ISharedPackageRepository sourceRepository)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
_packageReferenceFile = new PackageReferenceFile(
fileSystem, Constants.PackageReferenceFile, projectName);
SourceRepository = sourceRepository;
}
public PackageReferenceRepository(
IFileSystem fileSystem,
string projectName,
ISharedPackageRepository sourceRepository)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
_packageReferenceFile = new PackageReferenceFile(
fileSystem, Constants.PackageReferenceFile, projectName);
SourceRepository = sourceRepository;
}
internal void InstallPackages(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(packageManager, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = this;
bool allowPrerelease = Prerelease;
var resolver = new ActionResolver()
{
AllowPrereleaseVersions = allowPrerelease
};
var installPackageUtility = new InstallPackageUtility(resolver)
{
AllowPrereleaseVersions = allowPrerelease,
Safe = Safe
};
var operations = installPackageUtility.ResolveActionsForInstallPackage(Id.FirstOrDefault(), Version, new[] { projectManager }, false);
var userOperationExecutor = new ActionExecutor();
userOperationExecutor.Execute(operations);
}
internal IEnumerable <PackageDependency> GetReferences(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = new NugetUpdateTask.VerboseLogger(this);
using (sourceRepository.StartOperation(RepositoryOperationNames.Update))
{
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
if (projectManager.IsInstalled(package))
{
Log(Level.Debug, "Found installed package {0} version {1}", package.Id, package.Version);
yield return(new PackageDependency(package.Id, new VersionSpec(package.Version)));
}
}
}
}
}
internal void UpdatePackages(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem projectSystem)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(packageManager, pathResolver, projectSystem, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = projectSystem.Logger = this;
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
using (sourceRepository.StartOperation(RepositoryOperationNames.Update, package.Id, mainPackageVersion: null))
{
try
{
// If the user explicitly allows prerelease or if the package being updated is prerelease we'll include prerelease versions in our list of packages
// being considered for an update.
bool allowPrerelease = Prerelease || !package.IsReleaseVersion();
var resolver = new ActionResolver()
{
AllowPrereleaseVersions = allowPrerelease
};
var updateUtility = new UpdateUtility(resolver)
{
AllowPrereleaseVersions = allowPrerelease,
Safe = Safe
};
var operations = updateUtility.ResolveActionsForUpdate(package.Id, null, new[] { projectManager }, false);
var userOperationExecutor = new ActionExecutor();
userOperationExecutor.Execute(operations);
}
catch (InvalidOperationException e)
{
if (Console.Verbosity == NuGet.Verbosity.Detailed)
{
Console.WriteWarning(e.ToString());
}
else
{
Console.WriteWarning(e.Message);
}
}
}
}
}
}
public RepositoryInfo(string path, string configFolderPath, IFileSystem fileSystem, ISharedPackageRepository repository)
{
Path = path;
FileSystem = fileSystem;
Repository = repository;
ConfigFolderPath = configFolderPath;
}
internal void UpdatePackages(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = this;
using (sourceRepository.StartOperation(RepositoryOperationNames.Update))
{
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
try
{
// If the user explicitly allows prerelease or if the package being updated is prerelease we'll include prerelease versions in our list of packages
// being considered for an update.
bool allowPrerelease = Prerelease || !package.IsReleaseVersion();
if (Safe)
{
IVersionSpec safeRange = VersionUtility.GetSafeRange(package.Version);
projectManager.UpdatePackageReference(package.Id, safeRange, updateDependencies: true, allowPrereleaseVersions: allowPrerelease);
}
else
{
projectManager.UpdatePackageReference(package.Id, version: null, updateDependencies: true, allowPrereleaseVersions: allowPrerelease);
}
}
catch (InvalidOperationException e)
{
Console.WriteWarning(e.Message);
}
}
}
}
}
void CreateRepository(ConfigSettingsFileSystem configSettingsFileSystem)
{
repository = repositoryFactory.CreateSharedRepository(packagePathResolver, fileSystem, configSettingsFileSystem);
}
internal void UpdatePackages(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(packageManager, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = this;
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
using (sourceRepository.StartOperation(RepositoryOperationNames.Update, package.Id, mainPackageVersion: null))
{
try
{
// If the user explicitly allows prerelease or if the package being updated is prerelease we'll include prerelease versions in our list of packages
// being considered for an update.
bool allowPrerelease = Prerelease || !package.IsReleaseVersion();
var resolver = new ActionResolver()
{
AllowPrereleaseVersions = allowPrerelease
};
var updateUtility = new UpdateUtility(resolver)
{
AllowPrereleaseVersions = allowPrerelease,
Safe = Safe
};
var operations = updateUtility.ResolveActionsForUpdate(package.Id, null, new[] { projectManager }, false);
var userOperationExecutor = new ActionExecutor();
userOperationExecutor.Execute(operations);
}
catch (InvalidOperationException e)
{
if (Console.Verbosity == NuGet.Verbosity.Detailed)
{
Console.WriteWarning(e.ToString());
}
else
{
Console.WriteWarning(e.Message);
}
}
}
}
}
}
public MockVsPackageManager(
ISolutionManager solutionManager,
IPackageRepository sourceRepository,
ISharedPackageRepository localRepository)
: base(solutionManager, sourceRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem("x:\\root"), localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object)
{
}
public RepositoryInfo(string path, IFileSystem fileSystem, ISharedPackageRepository repository)
{
Path = path;
FileSystem = fileSystem;
Repository = repository;
}
private void NugetifyProject(IVsProject projectAdapter, DirectoryInfo solutionRoot, ISharedPackageRepository existingSolutionPackagesRepo)
{
var projectNugetifier = CreateProjectNugetifier(projectAdapter);
var packagesAdded = projectNugetifier.NugetifyReferences(solutionRoot);
projectNugetifier.AddNugetReferenceMetadata(existingSolutionPackagesRepo, packagesAdded);
projectAdapter.Save();
if (NuSpec)
{
var manifestDependencies = projectNugetifier.GetManifestDependencies(packagesAdded);
var nuspecBuilder = new NuspecBuilder(projectAdapter.AssemblyName);
nuspecBuilder.SetMetadata(this, manifestDependencies);
nuspecBuilder.SetDependencies(manifestDependencies);
nuspecBuilder.Save(Console);
}
}
public RepositoryInfo(string path, IFileSystem fileSystem, ISharedPackageRepository repository)
{
Path = path;
FileSystem = fileSystem;
Repository = repository;
}
void CreateRepository(ConfigSettingsFileSystem configSettingsFileSystem)
{
repository = repositoryFactory.CreateSharedRepository(packagePathResolver, fileSystem, configSettingsFileSystem);
}
void CreateRepository()
{
repository = repositoryFactory.CreateSharedRepository(packagePathResolver, fileSystem);
}
internal IEnumerable<PackageDependency> GetReferences(IPackageRepository localRepository,
IFileSystem sharedRepositoryFileSystem,
ISharedPackageRepository sharedPackageRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var packageManager = new PackageManager(sourceRepository, pathResolver, sharedRepositoryFileSystem, sharedPackageRepository);
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
// Fix for work item 2411: When updating packages, we did not add packages to the shared package repository.
// Consequently, when querying the package reference repository, we would have package references with no backing package files in
// the shared repository. This would cause the reference repository to skip the package assuming that the entry is invalid.
projectManager.PackageReferenceAdded += (sender, eventArgs) =>
{
PackageExtractor.InstallPackage(packageManager, eventArgs.Package);
};
projectManager.Logger = project.Logger = new NugetUpdateTask.VerboseLogger(this);
using (sourceRepository.StartOperation(RepositoryOperationNames.Update))
{
foreach (var package in GetPackages(localRepository))
{
if (localRepository.Exists(package.Id))
{
if (projectManager.IsInstalled(package))
{
Log(Level.Debug, "Found installed package {0} version {1}", package.Id, package.Version);
yield return new PackageDependency(package.Id, new VersionSpec(package.Version));
}
}
}
}
}
private void NugetifyProject(IVsProject projectAdapter, DirectoryInfo solutionRoot, ISharedPackageRepository existingSolutionPackagesRepo)
{
var targetFramework = TargetFramework != null?VersionUtility.ParseFrameworkName(TargetFramework) : null;
var projectNugetifier = CreateProjectNugetifier(projectAdapter);
var packagesAdded = projectNugetifier.NugetifyReferences(solutionRoot);
projectNugetifier.AddNugetReferenceMetadata(existingSolutionPackagesRepo, packagesAdded, targetFramework);
projectAdapter.Save();
if (NuSpec)
{
var manifestDependencies = projectNugetifier.GetManifestDependencies(packagesAdded);
var nuspecBuilder = new NuspecBuilder(projectAdapter.AssemblyName);
nuspecBuilder.SetMetadata(this, manifestDependencies);
nuspecBuilder.SetDependencies(manifestDependencies, TargetFramework);
nuspecBuilder.Save(Console);
}
}
private void RegisterPackagesConfig(ISharedPackageRepository sharedPackagesRepository)
{
var packagesConfigFilePath = Path.Combine(_vsProject.ProjectDirectory.FullName + "\\", PackageReferenceFilename);
sharedPackagesRepository.RegisterRepository(packagesConfigFilePath);
_vsProject.AddFile(PackageReferenceFilename);
}
public MockVsPackageManager(
ISolutionManager solutionManager,
IPackageRepository sourceRepository,
IFileSystemProvider fileSystemProvider,
IFileSystem fileSystem,
ISharedPackageRepository sharedRepository,
IDeleteOnRestartManager deleteOnRestartManager,
VsPackageInstallerEvents packageEvents) :
base(
solutionManager,
sourceRepository,
fileSystemProvider,
fileSystem,
sharedRepository,
deleteOnRestartManager,
packageEvents)
{
}
public NuGetAwareProjectPackageRepository(INuGetPackageManager project, ISharedPackageRepository sourceRepository)
{
_project = project;
_repo = sourceRepository;
}
public NuGetAwareProjectPackageRepository(INuGetPackageManager project, ISharedPackageRepository sourceRepository)
{
_project = project;
_repo = sourceRepository;
}
public PackageManager(IPackageRepository sourceRepository, IPackagePathResolver pathResolver, IFileSystem fileSystem, ISharedPackageRepository localRepository)
{
this._bindingRedirectEnabled = true;
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
if (pathResolver == null)
{
throw new ArgumentNullException("pathResolver");
}
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (localRepository == null)
{
throw new ArgumentNullException("localRepository");
}
this.SourceRepository = sourceRepository;
this.DependencyResolver = new DependencyResolverFromRepo(sourceRepository);
this.PathResolver = pathResolver;
this.FileSystem = fileSystem;
this.LocalRepository = localRepository;
this.DependencyVersion = NuGet.DependencyVersion.Lowest;
this.CheckDowngrade = true;
}