public SharpDevelopProjectManager(IPackageRepository sourceRepository,
IPackagePathResolver pathResolver,
IProjectSystem project,
IPackageRepository localRepository)
: base(sourceRepository, pathResolver, project, localRepository)
{
}
public void TransformFile(IPackageFile file, string targetPath, IProjectSystem projectSystem)
{
if (!projectSystem.FileExists(targetPath)) {
using (Stream stream = Process(file, projectSystem).AsStream()) {
projectSystem.AddFile(targetPath, stream);
}
}
}
private static XElement GetXml(IPackageFile file, IProjectSystem projectSystem)
{
using (Stream stream = file.GetStream())
{
var content = Preprocessor.Process(file, projectSystem);
return XElement.Parse(content);
}
}
public ExtensionReferenceRepository(IProjectSystem project, IPackageRepository sourceRepository)
{
Guard.ArgumentNotNull(() => project);
Guard.ArgumentNotNull(() => sourceRepository);
Project = project;
SourceRepository = sourceRepository;
}
public VsProjectManager(
VsPackageManager packageManager,
IPackagePathResolver pathResolver,
IProjectSystem project,
IPackageRepository localRepository)
: base(packageManager, pathResolver, project, localRepository)
{
_packageManager = packageManager;
}
public void TransformFile(IPackageFile file, string targetPath, IProjectSystem projectSystem)
{
// Get the xml fragment
XElement xmlFragment = GetXml(file, projectSystem);
XDocument transformDocument = XmlUtility.GetOrCreateDocument(xmlFragment.Name, projectSystem, targetPath);
// Do a merge
transformDocument.Root.MergeWith(xmlFragment, _nodeActions);
projectSystem.AddFile(targetPath, transformDocument.Save);
}
public static INuGetProjectSystemFactory CreateProjectSystemFactory(IProjectSystem projectSystem = null)
{
if(projectSystem == null)
{
var mockProjectSystem = new Mock<IProjectSystem>();
mockProjectSystem.Setup(ps => ps.Root).Returns("");
projectSystem = mockProjectSystem.Object;
}
var mock = new Mock<INuGetProjectSystemFactory>();
mock.Setup(f => f.CreateProject(It.IsAny<string>())).Returns(projectSystem);
return mock.Object;
}
private static void PerformXdtTransform(IPackageFile file, string targetPath, IProjectSystem projectSystem)
{
if (projectSystem.FileExists(targetPath))
{
string content = Preprocessor.Process(file, projectSystem);
try
{
using (var transformation = new XmlTransformation(content, isTransformAFile: false, logger: null))
{
using (var document = new XmlTransformableDocument())
{
document.PreserveWhitespace = true;
// make sure we close the input stream immediately so that we can override
// the file below when we save to it.
using (var inputStream = projectSystem.OpenFile(targetPath))
{
document.Load(inputStream);
}
bool succeeded = transformation.Apply(document);
if (succeeded)
{
using (var memoryStream = new MemoryStream())
{
// save the result into a memoryStream first so that if there is any
// exception during document.Save(), the original file won't be truncated.
document.Save(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
using (var fileStream = projectSystem.CreateFile(targetPath))
{
memoryStream.CopyTo(fileStream);
}
}
}
}
}
}
catch (Exception exception)
{
throw new InvalidDataException(
String.Format(
CultureInfo.CurrentCulture,
NuGetResources.XdtError + " " + exception.Message,
targetPath,
projectSystem.ProjectName),
exception);
}
}
}
public ExtensionReferenceRepository(IProjectSystem project, IPackageRepository sourceRepository, IExtensionManager extensionManager) {
if (project == null) {
throw new ArgumentNullException("project");
}
if (sourceRepository == null) {
throw new ArgumentNullException("sourceRepository");
}
if (extensionManager == null) {
throw new ArgumentNullException("extensionManager");
}
Project = project;
SourceRepository = sourceRepository;
_extensionManager = extensionManager;
}
public SharpDevelopPackageManager(
IPackageRepository sourceRepository,
IProjectSystem projectSystem,
ISolutionPackageRepository solutionPackageRepository,
IPackageOperationResolverFactory packageOperationResolverFactory)
: base(sourceRepository,
solutionPackageRepository.PackagePathResolver,
solutionPackageRepository.FileSystem,
solutionPackageRepository.Repository)
{
this.projectSystem = projectSystem;
this.packageOperationResolverFactory = packageOperationResolverFactory;
CreateProjectManager();
}
public SharpDevelopPackageManager(
IPackageRepository sourceRepository,
IProjectSystem projectSystem,
IFileSystem fileSystem,
ISharedPackageRepository localRepository,
IPackagePathResolver pathResolver)
: base(
sourceRepository,
pathResolver,
fileSystem,
localRepository)
{
this.projectSystem = projectSystem;
CreateProjectManager();
}
internal WebNuGetProject(IEnumerable<string> remoteSources, string siteRoot, Version targetFramework, INuGetProjectSystemFactory projectSystemFactory, INuGetPackageManagerFactory packageManagerFactory, INuGetProjectManagerFactory projectManagerFactory)
{
_projectSystem = projectSystemFactory.CreateProject(siteRoot);
// websites don't always know their target framework
if (_projectSystem is NuGetWebProjectSystem && targetFramework != null)
{
((NuGetWebProjectSystem)_projectSystem).TargetFramework = new FrameworkName(".NetFramework", targetFramework);
}
string webRepositoryDirectory = GetWebRepositoryDirectory(siteRoot);
var enumerable = remoteSources as IList<string> ?? remoteSources.ToList();
_packageManager = packageManagerFactory.CreatePackageManager(enumerable, webRepositoryDirectory);
_projectManager = projectManagerFactory.CreateProjectManager(enumerable, webRepositoryDirectory, _projectSystem);
}
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 void RevertFile(IPackageFile file, string targetPath, IEnumerable<IPackageFile> matchingFiles, IProjectSystem projectSystem)
{
// Get the xml snippet
XElement xmlFragment = GetXml(file, projectSystem);
XDocument document = XmlUtility.GetOrCreateDocument(xmlFragment.Name, projectSystem, targetPath);
// Merge the other xml elements into one element within this xml hierarchy (matching the config file path)
var mergedFragments = matchingFiles.Select(f => GetXml(f, projectSystem))
.Aggregate(new XElement(xmlFragment.Name), (left, right) => left.MergeWith(right, _nodeActions));
// Take the difference of the xml and remove it from the main xml file
document.Root.Except(xmlFragment.Except(mergedFragments));
// Save the new content to the file system
projectSystem.AddFile(targetPath, document.Save);
}
public IProjectManager CreateProjectManager(IEnumerable<string> remoteSources, string packagesPath, IProjectSystem project)
{
if(remoteSources == null)
{
throw new ArgumentNullException("remoteSources");
}
if (!remoteSources.Any())
{
throw new ArgumentException("Must provide at least one remote source");
}
var sourceRepo = new AggregateRepository(PackageRepositoryFactory.Default, remoteSources, true);
var pathResolver = new DefaultPackagePathResolver(packagesPath);
var packagesConfigRepo = new PackageReferenceRepository(project, project.ProjectName, new SharedPackageRepository(packagesPath));
return new ProjectManager(sourceRepository: sourceRepo,
pathResolver: pathResolver,
localRepository: packagesConfigRepo,
project: project);
}
public PluginReferenceRepository(IProjectSystem project, IPackageRepository sourceRepository, IPluginFinder pluginFinder)
: base(project, sourceRepository)
{
_pluginFinder = pluginFinder;
_descriptors = _pluginFinder.GetPluginDescriptors().ToList();
}
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));
}
}
}
}
}
public static void AddFiles(this IProjectSystem project,
IEnumerable <IPackageFile> files,
IDictionary <string, IPackageFileTransformer> fileTransformers)
{
// Convert files to a list
List <IPackageFile> fileList = files.ToList();
// See if the project system knows how to sort the files
var fileComparer = project as IComparer <IPackageFile>;
if (fileComparer != null)
{
fileList.Sort(fileComparer);
}
var batchProcessor = project as IBatchProcessor <string>;
try
{
if (batchProcessor != null)
{
var paths = fileList.Select(file => ResolvePath(fileTransformers, file.EffectivePath));
batchProcessor.BeginProcessing(paths, PackageAction.Install);
}
foreach (IPackageFile file in fileList)
{
if (file.IsEmptyFolder())
{
continue;
}
IPackageFileTransformer transformer;
// Resolve the target path
string path = ResolveTargetPath(project,
fileTransformers,
file.EffectivePath,
out transformer);
if (project.IsSupportedFile(path))
{
// Try to get the package file modifier for the extension
if (transformer != null)
{
// If the transform was done then continue
transformer.TransformFile(file, path, project);
}
else
{
TryAddFile(project, file, path);
}
}
}
}
finally
{
if (batchProcessor != null)
{
batchProcessor.EndProcessing();
}
}
}
private static void PerformXdtTransform(IPackageFile file, string targetPath, IProjectSystem projectSystem)
{
if (projectSystem.FileExists(targetPath))
{
string content = Preprocessor.Process(file, projectSystem);
try
{
using (var transformation = new XmlTransformation(content, isTransformAFile: false, logger: null))
{
using (var document = new XmlTransformableDocument())
{
document.PreserveWhitespace = true;
// make sure we close the input stream immediately so that we can override
// the file below when we save to it.
using (var inputStream = projectSystem.OpenFile(targetPath))
{
document.Load(inputStream);
}
bool succeeded = transformation.Apply(document);
if (succeeded)
{
using (var memoryStream = new MemoryStream())
{
// save the result into a memoryStream first so that if there is any
// exception during document.Save(), the original file won't be truncated.
document.Save(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
using (var fileStream = projectSystem.CreateFile(targetPath))
{
memoryStream.CopyTo(fileStream);
}
}
}
}
}
}
catch (Exception exception)
{
throw new InvalidDataException(
String.Format(
CultureInfo.CurrentCulture,
NuGetResources.XdtError + " " + exception.Message,
targetPath,
projectSystem.ProjectName),
exception);
}
}
}
public void RevertFile(IPackageFile file, string targetPath, IEnumerable<IPackageFile> matchingFiles, IProjectSystem projectSystem)
{
Func<Stream> streamFactory = () => Process(file, projectSystem).AsStream();
FileSystemExtensions.DeleteFileSafe(projectSystem, targetPath, streamFactory);
}
public void RevertFile(IPackageFile file, string targetPath, IEnumerable <IPackageFile> matchingFiles, IProjectSystem projectSystem)
{
Func <Stream> streamFactory = () => Process(file, projectSystem).AsStream();
FileSystemExtensions.DeleteFileSafe(projectSystem, targetPath, streamFactory);
}
internal static IEnumerable <T> GetCompatibleItemsCore <T>(this IProjectSystem projectSystem, IEnumerable <T> items) where T : IFrameworkTargetable
{
IEnumerable <T> enumerable;
return(!VersionUtility.TryGetCompatibleItems <T>(projectSystem.TargetFramework, items, out enumerable) ? Enumerable.Empty <T>() : enumerable);
}
public FilesService(IProjectSystem projectSystem)
{
_projectSystem = projectSystem;
}
public void TransformFile(IPackageFile file, string targetPath, IProjectSystem projectSystem)
{
PerformXdtTransform(file, targetPath, projectSystem);
}
public void RevertFile(IPackageFile file, string targetPath, IEnumerable<IPackageFile> matchingFiles, IProjectSystem projectSystem)
{
PerformXdtTransform(file, targetPath, projectSystem);
}
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);
}
}
}
}
}
private static XElement GetXml(IPackageFile file, IProjectSystem projectSystem)
{
var content = Preprocessor.Process(file, projectSystem);
return(XElement.Parse(content, LoadOptions.PreserveWhitespace));
}
private static XElement GetXml(IPackageFile file, IProjectSystem projectSystem)
{
var content = Preprocessor.Process(file, projectSystem);
return XElement.Parse(content, LoadOptions.PreserveWhitespace);
}
/// <summary>
/// The standard constructor. We'll just call the base constructor.
/// </summary>
/// <param name="sourceRepository"></param>
/// <param name="pathResolver"></param>
/// <param name="project"></param>
/// <param name="localRepository"></param>
public RockProjectManager(IPackageRepository sourceRepository, IPackagePathResolver pathResolver, IProjectSystem project, IPackageRepository localRepository)
: base(sourceRepository, pathResolver, project, localRepository)
{
}
public CurrentProjectFacts()
{
_workspace = new OmnisharpWorkspace(new HostServicesBuilder(Enumerable.Empty<ICodeActionProvider>()));
_context = new DnxContext();
_projectSystem = new DnxProjectSystem(_workspace, null, new FakeLoggerFactory(), null, null, null, null, _context);
}
public static void DeleteFiles(this IProjectSystem project,
IEnumerable <IPackageFile> files,
IEnumerable <IPackage> otherPackages,
IDictionary <FileTransformExtensions, IPackageFileTransformer> fileTransformers)
{
IPackageFileTransformer transformer;
// First get all directories that contain files
var directoryLookup = files.ToLookup(
p => Path.GetDirectoryName(ResolveTargetPath(project, fileTransformers, fte => fte.UninstallExtension, p.EffectivePath, out transformer)));
// Get all directories that this package may have added
var directories = from grouping in directoryLookup
from directory in FileSystemExtensions.GetDirectories(grouping.Key)
orderby directory.Length descending
select directory;
// Remove files from every directory
foreach (var directory in directories)
{
var directoryFiles = directoryLookup.Contains(directory) ? directoryLookup[directory] : Enumerable.Empty <IPackageFile>();
if (!project.DirectoryExists(directory))
{
continue;
}
var batchProcessor = project as IBatchProcessor <string>;
try
{
if (batchProcessor != null)
{
var paths = directoryFiles.Select(file => ResolvePath(fileTransformers, fte => fte.UninstallExtension, file.EffectivePath));
batchProcessor.BeginProcessing(paths, PackageAction.Uninstall);
}
foreach (var file in directoryFiles)
{
if (file.IsEmptyFolder())
{
continue;
}
// Resolve the path
string path = ResolveTargetPath(project,
fileTransformers,
fte => fte.UninstallExtension,
file.EffectivePath,
out transformer);
if (project.IsSupportedFile(path))
{
if (transformer != null)
{
var matchingFiles = from p in otherPackages
from otherFile in project.GetCompatibleItemsCore(p.GetContentFiles())
where otherFile.EffectivePath.Equals(file.EffectivePath, StringComparison.OrdinalIgnoreCase)
select otherFile;
try
{
transformer.RevertFile(file, path, matchingFiles, project);
}
catch (Exception e)
{
// Report a warning and move on
project.Logger.Log(MessageLevel.Warning, e.Message);
}
}
else
{
project.DeleteFileSafe(path, file.GetStream);
}
}
}
// If the directory is empty then delete it
if (!project.GetFilesSafe(directory).Any() &&
!project.GetDirectoriesSafe(directory).Any())
{
project.DeleteDirectorySafe(directory, recursive: false);
}
}
finally
{
if (batchProcessor != null)
{
batchProcessor.EndProcessing();
}
}
}
}
public CurrentProjectFacts()
{
_workspace = new OmnisharpWorkspace(new HostServicesBuilder(Enumerable.Empty <ICodeActionProvider>()));
_context = new DnxContext();
_projectSystem = new DnxProjectSystem(_workspace, null, new FakeLoggerFactory(), null, null, null, null, _context);
}
public ThemeReferenceRepository(IProjectSystem project, IPackageRepository sourceRepository, IThemeRegistry themeRegistry)
: base(project, sourceRepository)
{
_themeRegistry = themeRegistry;
_themeManifests = _themeRegistry.GetThemeManifests();
}
public ThemeReferenceRepository(IProjectSystem project, IPackageRepository sourceRepository, IThemeRegistry themeRegistry)
: base(project, sourceRepository)
{
_themeManifests = themeRegistry.GetThemeManifests(true);
}
private static void PerformXdtTransform(IPackageFile file, string targetPath, IProjectSystem projectSystem)
{
if (projectSystem.FileExists(targetPath))
{
string transform = Preprocessor.Process(file, projectSystem);
try
{
using (XmlTransformation transformation = new XmlTransformation(transform, false, null))
{
using (XmlTransformableDocument document = new XmlTransformableDocument())
{
document.PreserveWhitespace = true;
using (Stream stream = projectSystem.OpenFile(targetPath))
{
document.Load(stream);
}
if (transformation.Apply(document))
{
using (MemoryStream stream2 = new MemoryStream())
{
document.Save(stream2);
stream2.Seek(0L, SeekOrigin.Begin);
using (Stream stream3 = projectSystem.CreateFile(targetPath))
{
stream2.CopyTo(stream3);
}
}
}
}
}
}
catch (Exception exception)
{
object[] args = new object[] { targetPath, projectSystem.ProjectName };
throw new InvalidDataException(string.Format(CultureInfo.CurrentCulture, NuGetResources.XdtError + " " + exception.Message, args), exception);
}
}
}
public FilesController(IProjectSystem projectSystem)
{
_projectSystem = projectSystem;
}
public virtual void RevertFile(IPackageFile file, string targetPath, IEnumerable <IPackageFile> matchingFiles, IProjectSystem projectSystem)
{
XElement xml = GetXml(file, projectSystem);
XDocument document = XmlUtility.GetOrCreateDocument(xml.Name, projectSystem, targetPath);
document.Root.Except(xml.Except(Enumerable.Aggregate <XElement, XElement>(from f in matchingFiles select GetXml(f, projectSystem), new XElement(xml.Name), (left, right) => left.MergeWith(right, this._nodeActions))));
using (Stream stream = projectSystem.CreateFile(targetPath))
{
document.Save(stream);
}
}
private static XElement GetXml(IPackageFile file, IProjectSystem projectSystem)
{
var content = Preprocessor.Process(file, projectSystem);
return XElement.Parse(content);
}
public void TransformFile(IPackageFile file, string targetPath, IProjectSystem projectSystem)
{
PerformXdtTransform(file, targetPath, projectSystem);
}
internal void UpdatePackages(IPackageRepository localRepository,
IPackageRepository sourceRepository,
IPackageConstraintProvider constraintProvider,
IPackagePathResolver pathResolver,
IProjectSystem project)
{
var projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository)
{
ConstraintProvider = constraintProvider
};
if (Verbose)
{
projectManager.Logger = Console;
}
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);
}
}
}
}
public void RevertFile(IPackageFile file, string targetPath, IEnumerable <IPackageFile> matchingFiles, IProjectSystem projectSystem)
{
// Get the xml snippet
XElement xmlFragment = GetXml(file, projectSystem);
XDocument document = XmlUtility.GetOrCreateDocument(xmlFragment.Name, projectSystem, targetPath);
// Merge the other xml elements into one element within this xml hierarchy (matching the config file path)
var mergedFragments = matchingFiles.Select(f => GetXml(f, projectSystem))
.Aggregate(new XElement(xmlFragment.Name), (left, right) => left.MergeWith(right, _nodeActions));
// Take the difference of the xml and remove it from the main xml file
document.Root.Except(xmlFragment.Except(mergedFragments));
// Save the new content to the file system
projectSystem.AddFile(targetPath, document.Save);
}
private void CopyNativeBinaries(IProjectSystem projectSystem, IFileSystem packagesFileSystem, PackageName packageName)
{
const string nativeBinariesFolder = "NativeBinaries";
string nativeBinariesPath = Path.Combine(packageName.Name, nativeBinariesFolder);
if (packagesFileSystem.DirectoryExists(nativeBinariesPath))
{
IEnumerable<string> nativeFiles = packagesFileSystem.GetFiles(nativeBinariesPath, "*.*", recursive: true);
foreach (string file in nativeFiles)
{
string targetPath = Path.Combine(Constants.BinDirectory, file.Substring(nativeBinariesPath.Length + 1)); // skip over NativeBinaries/ word
using (Stream stream = packagesFileSystem.OpenFile(file))
{
projectSystem.AddFile(targetPath, stream);
}
}
}
}
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 static void DeleteFiles(this IProjectSystem project, IEnumerable <IPackageFile> files, IEnumerable <IPackage> otherPackages, IDictionary <FileTransformExtensions, IPackageFileTransformer> fileTransformers)
{
IPackageFileTransformer transformer;
ILookup <string, IPackageFile> lookup = Enumerable.ToLookup <IPackageFile, string>(files, p => Path.GetDirectoryName(ResolveTargetPath(project, fileTransformers, fte => fte.UninstallExtension, p.EffectivePath, out transformer)));
foreach (string str in from grouping in lookup
from directory in FileSystemExtensions.GetDirectories(grouping.Key)
orderby directory.Length descending
select directory)
{
IEnumerable <IPackageFile> enumerable = lookup.Contains(str) ? lookup[str] : Enumerable.Empty <IPackageFile>();
if (project.DirectoryExists(str))
{
IBatchProcessor <string> processor = project as IBatchProcessor <string>;
try
{
if (processor != null)
{
Func <IPackageFile, string> < > 9__6;
Func <IPackageFile, string> func5 = < > 9__6;
if (< > 9__6 == null)
{
Func <IPackageFile, string> local5 = < > 9__6;
func5 = < > 9__6 = file => ResolvePath(fileTransformers, fte => fte.UninstallExtension, file.EffectivePath);
}
processor.BeginProcessing(Enumerable.Select <IPackageFile, string>(enumerable, func5), PackageAction.Uninstall);
}
foreach (IPackageFile file in enumerable)
{
if (!file.IsEmptyFolder())
{
string path = ResolveTargetPath(project, fileTransformers, fte => fte.UninstallExtension, file.EffectivePath, out transformer);
if (project.IsSupportedFile(path))
{
Func <IPackage, IEnumerable <IPackageFile> > < > 9__9;
if (transformer == null)
{
project.DeleteFileSafe(path, new Func <Stream>(file.GetStream));
continue;
}
Func <IPackage, IEnumerable <IPackageFile> > func4 = < > 9__9;
if (< > 9__9 == null)
{
Func <IPackage, IEnumerable <IPackageFile> > local7 = < > 9__9;
func4 = < > 9__9 = p => project.GetCompatibleItemsCore <IPackageFile>(p.GetContentFiles());
}
IEnumerable <IPackageFile> matchingFiles = from <> h__TransparentIdentifier0 in Enumerable.SelectMany(otherPackages, func4, (p, otherFile) => new {
p = p,
otherFile = otherFile
})
where < > h__TransparentIdentifier0.otherFile.EffectivePath.Equals(file.EffectivePath, StringComparison.OrdinalIgnoreCase)
select <> h__TransparentIdentifier0.otherFile;
try
{
transformer.RevertFile(file, path, matchingFiles, project);
}
catch (Exception exception)
{
project.Logger.Log(MessageLevel.Warning, exception.Message, new object[0]);
}
}
}
}
if (!project.GetFilesSafe(str).Any <string>() && !project.GetDirectoriesSafe(str).Any <string>())
{
project.DeleteDirectorySafe(str, false);
}
}
finally
{
if (processor != null)
{
processor.EndProcessing();
}
}
}
}
}
private static XElement GetXml(IPackageFile file, IProjectSystem projectSystem)
{
var content = Preprocessor.Process(file, projectSystem);
return(XElement.Parse(content));
}
public void TransformFile(IPackageFile file, string targetPath, IProjectSystem projectSystem)
{
ProjectSystemExtensions.TryAddFile(projectSystem, targetPath, () => Process(file, projectSystem).AsStream());
}
public ProjectManager(IPackageRepository sourceRepository, IPackagePathResolver pathResolver, IProjectSystem project, IPackageRepository localRepository)
{
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
if (pathResolver == null)
{
throw new ArgumentNullException("pathResolver");
}
if (project == null)
{
throw new ArgumentNullException("project");
}
if (localRepository == null)
{
throw new ArgumentNullException("localRepository");
}
SourceRepository = sourceRepository;
Project = project;
PathResolver = pathResolver;
LocalRepository = localRepository;
_packageReferenceRepository = LocalRepository as IPackageReferenceRepository;
}
public NullProjectManager(IPackageManager packageManager)
{
_localRepository = new VirtualRepository(repo: null);
_project = new NullProjectSystem();
PackageManager = packageManager;
}
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 ProjectManager(IPackageManager packageManager, IPackagePathResolver pathResolver, IProjectSystem project, IPackageRepository localRepository)
{
Dictionary <FileTransformExtensions, IPackageFileTransformer> dictionary1 = new Dictionary <FileTransformExtensions, IPackageFileTransformer>();
dictionary1.Add(new FileTransformExtensions(".transform", ".transform"), new XmlTransformer(GetConfigMappings()));
dictionary1.Add(new FileTransformExtensions(".pp", ".pp"), new Preprocessor());
dictionary1.Add(new FileTransformExtensions(".install.xdt", ".uninstall.xdt"), new XdtTransformer());
this._fileTransformers = dictionary1;
if (pathResolver == null)
{
throw new ArgumentNullException("pathResolver");
}
if (project == null)
{
throw new ArgumentNullException("project");
}
if (localRepository == null)
{
throw new ArgumentNullException("localRepository");
}
this.PackageManager = packageManager;
this.Project = project;
this.PathResolver = pathResolver;
this.LocalRepository = localRepository;
this._packageReferenceRepository = this.LocalRepository as IPackageReferenceRepository;
}
public static void AddFiles(this IProjectSystem project,
IEnumerable <IPackageFile> files,
IDictionary <FileTransformExtensions, IPackageFileTransformer> fileTransformers)
{
// Convert files to a list
List <IPackageFile> fileList = files.ToList();
// See if the project system knows how to sort the files
var fileComparer = project as IComparer <IPackageFile>;
if (fileComparer != null)
{
fileList.Sort(fileComparer);
}
var batchProcessor = project as IBatchProcessor <string>;
try
{
if (batchProcessor != null)
{
var paths = fileList.Select(file => ResolvePath(fileTransformers, fte => fte.InstallExtension, file.EffectivePath));
batchProcessor.BeginProcessing(paths, PackageAction.Install);
}
foreach (IPackageFile file in fileList)
{
if (file.IsEmptyFolder())
{
continue;
}
// Resolve the target path
IPackageFileTransformer installTransformer;
string path = ResolveTargetPath(project, fileTransformers, fte => fte.InstallExtension, file.EffectivePath, out installTransformer);
if (project.IsSupportedFile(path))
{
if (installTransformer != null)
{
installTransformer.TransformFile(file, path, project);
}
else
{
// Ignore uninstall transform file during installation
string truncatedPath;
IPackageFileTransformer uninstallTransformer =
FindFileTransformer(fileTransformers, fte => fte.UninstallExtension, file.EffectivePath, out truncatedPath);
if (uninstallTransformer != null)
{
continue;
}
TryAddFile(project, path, file.GetStream);
}
}
}
}
finally
{
if (batchProcessor != null)
{
batchProcessor.EndProcessing();
}
}
}
public IProjectManager CreateProjectManager(IEnumerable <string> remoteSources, string packagesPath, IProjectSystem project)
{
if (remoteSources == null)
{
throw new ArgumentNullException("remoteSources");
}
if (!remoteSources.Any())
{
throw new ArgumentException("Must provide at least one remote source");
}
var sourceRepo = new AggregateRepository(PackageRepositoryFactory.Default, remoteSources, true);
var pathResolver = new DefaultPackagePathResolver(packagesPath);
var packagesConfigRepo = new PackageReferenceRepository(project, project.ProjectName, new SharedPackageRepository(packagesPath));
return(new ProjectManager(sourceRepository: sourceRepo,
pathResolver: pathResolver,
localRepository: packagesConfigRepo,
project: project));
}
public PluginReferenceRepository(IProjectSystem project, IPackageRepository sourceRepository, IPluginFinder pluginFinder)
: base(project, sourceRepository)
{
_pluginFinder = pluginFinder;
_descriptors = _pluginFinder.GetPluginDescriptors().ToList();
}
private static string ResolvePath(IProjectSystem projectSystem, string path)
{
return(projectSystem.ResolvePath(RemoveContentDirectory(path)));
}
public void TransformFile(IPackageFile file, string targetPath, IProjectSystem projectSystem)
{
ProjectSystemExtensions.TryAddFile(projectSystem, targetPath, () => Process(file, projectSystem).AsStream());
}
public static void DeleteFiles(this IProjectSystem project,
IEnumerable <IPackageFile> files,
IEnumerable <IPackage> otherPackages,
IDictionary <string, IPackageFileTransformer> fileTransformers)
{
// First get all directories that contain files
var directoryLookup = files.ToLookup(p => Path.GetDirectoryName(ResolvePath(project, p.Path)));
// Get all directories that this package may have added
var directories = from grouping in directoryLookup
from directory in FileSystemExtensions.GetDirectories(grouping.Key)
orderby directory.Length descending
select directory;
// Remove files from every directory
foreach (var directory in directories)
{
var directoryFiles = directoryLookup.Contains(directory) ? directoryLookup[directory] : Enumerable.Empty <IPackageFile>();
if (!project.DirectoryExists(directory))
{
continue;
}
foreach (var file in directoryFiles)
{
// Remove the content folder from the path
string path = ResolvePath(project, file.Path);
// Try to get the package file modifier for the extension
string extension = Path.GetExtension(file.Path);
IPackageFileTransformer transformer;
if (fileTransformers.TryGetValue(extension, out transformer))
{
// Remove the extension to get the target path
path = RemoveExtension(path);
if (project.IsSupportedFile(path))
{
var matchingFiles = from p in otherPackages
from otherFile in p.GetContentFiles()
where otherFile.Path.Equals(file.Path, StringComparison.OrdinalIgnoreCase)
select otherFile;
try {
transformer.RevertFile(file, path, matchingFiles, project);
}
catch (Exception e) {
// Report a warning and move on
project.Logger.Log(MessageLevel.Warning, e.Message);
}
}
}
else if (project.IsSupportedFile(path))
{
project.DeleteFileSafe(path, file.GetStream);
}
}
// If the directory is empty then delete it
if (!project.GetFilesSafe(directory).Any() &&
!project.GetDirectoriesSafe(directory).Any())
{
project.DeleteDirectorySafe(directory, recursive: false);
}
}
}
public ProjectManager(IPackageManager packageManager, IPackagePathResolver pathResolver, IProjectSystem project, IPackageRepository localRepository)
{
// !!! TODO: we should get rid of the parameter pathResolver. Use packageManager's path resolver
// instead.
if (pathResolver == null)
{
throw new ArgumentNullException("pathResolver");
}
if (project == null)
{
throw new ArgumentNullException("project");
}
if (localRepository == null)
{
throw new ArgumentNullException("localRepository");
}
PackageManager = packageManager;
Project = project;
PathResolver = pathResolver;
LocalRepository = localRepository;
_packageReferenceRepository = LocalRepository as IPackageReferenceRepository;
}
private static XElement GetXml(IPackageFile file, IProjectSystem projectSystem) => XElement.Parse(Preprocessor.Process(file, projectSystem), LoadOptions.PreserveWhitespace);
public void RevertFile(IPackageFile file, string targetPath, IEnumerable <IPackageFile> matchingFiles, IProjectSystem projectSystem)
{
PerformXdtTransform(file, targetPath, projectSystem);
}
public FilesController(IProjectSystem projectSystem)
{
_projectSystem = projectSystem;
}
