public static ICollection<InstalledPackageReference> GetInstalledPackageReferences(PackageReferenceFile configFile, bool requireVersion)
{
if (configFile == null)
{
throw new ArgumentNullException("configFile");
}
var packageReferences = configFile.GetPackageReferences(requireVersion);
foreach (var package in packageReferences)
{
// GetPackageReferences returns all records without validating values. We'll throw if we encounter packages
// with malformed ids / Versions.
if (String.IsNullOrEmpty(package.Id))
{
throw new InvalidDataException(
String.Format(CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandInvalidPackageReference"),
configFile.FullPath));
}
if (requireVersion && (package.Version == null))
{
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandPackageReferenceInvalidVersion"), package.Id));
}
}
return packageReferences.Select(pr => CoreConverters.SafeToInstalledPackageReference(pr)).ToList();
}
public IEnumerable<string> CreatePackageFile()
{
var packagesFile = Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFile);
var packageReferenceFile = new PackageReferenceFile(packagesFile);
var packagesFolder = Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFolder);
var repository = new LocalPackageRepository(packagesFolder);
var newestPackages = repository.GetPackages().GroupBy(p => p.Id)
.Select(g => g.OrderByDescending(p => p.Version).FirstOrDefault());
foreach (var package in newestPackages)
{
var newestFramework = GetNewestSupportedFramework(package);
packageReferenceFile.AddEntry(package.Id, package.Version, newestFramework);
if (newestFramework == null)
{
yield return string.Format("{0}, Version {1}", package.Id, package.Version);
}
else
{
yield return string.Format("{0}, Version {1}, .NET {2}", package.Id, package.Version, newestFramework.Version);
}
}
}
public static PackageReferenceFile CreateFromProject(string projectFileFullPath)
{
var fileSystem = new PhysicalFileSystem(Path.GetDirectoryName(projectFileFullPath));
string projectName = Path.GetFileNameWithoutExtension(projectFileFullPath);
var file = new PackageReferenceFile(fileSystem, Constants.PackageReferenceFile, projectName);
return file;
}
public static ICollection <PackageReference> GetPackageReferences(PackageReferenceFile file, string fileName, bool requireVersion)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
var packageReferences = file.GetPackageReferences(requireVersion).ToList();
foreach (var package in packageReferences)
{
// GetPackageReferences returns all records without validating values. We'll throw if we encounter packages
// with malformed ids / Versions.
if (String.IsNullOrEmpty(package.Id))
{
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, NuGetResources.InstallCommandInvalidPackageReference, fileName));
}
if (requireVersion && (package.Version == null))
{
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, NuGetResources.InstallCommandPackageReferenceInvalidVersion, package.Id));
}
}
return(packageReferences);
}
public static PackageReferenceFile CreateFromProject(string projectFileFullPath)
{
var fileSystem = new PhysicalFileSystem(Path.GetDirectoryName(projectFileFullPath));
string projectName = Path.GetFileNameWithoutExtension(projectFileFullPath);
var file = new PackageReferenceFile(fileSystem, Constants.PackageReferenceFile, projectName);
return(file);
}
public SharedPackageRepository(IPackagePathResolver resolver, IFileSystem fileSystem, IFileSystem configSettingsFileSystem)
: base(resolver, fileSystem)
{
if (configSettingsFileSystem == null)
{
throw new ArgumentNullException("configSettingsFileSystem");
}
_packageReferenceFile = new PackageReferenceFile(configSettingsFileSystem, Constants.PackageReferenceFile);
}
public SharedPackageRepository(IPackagePathResolver resolver, IFileSystem fileSystem, IFileSystem configSettingsFileSystem)
: base(resolver, fileSystem)
{
if (configSettingsFileSystem == null)
{
throw new ArgumentNullException("configSettingsFileSystem");
}
_packageReferenceFile = new PackageReferenceFile(configSettingsFileSystem, Constants.PackageReferenceFile);
}
public TestablePackageCompatibilityRunner (
IDotNetProject project,
IPackageManagementProgressMonitorFactory progressMonitorFactory,
IPackageManagementEvents packageManagementEvents)
: base (
project,
progressMonitorFactory,
packageManagementEvents)
{
PackageReferenceFile = new PackageReferenceFile (FileSystem, "packages.config");
}
public PackageReferenceRepository(IFileSystem fileSystem, string projectName, ISharedPackageRepository sourceRepository)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
this._packageReferenceFile = new PackageReferenceFile(fileSystem, Constants.PackageReferenceFile, projectName);
this.SourceRepository = sourceRepository;
}
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, Constants.PackageReferenceFile);
_fullPath = fileSystem.GetFullPath(Constants.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, PackageReferenceFile);
_fullPath = fileSystem.GetFullPath(PackageReferenceFile);
SourceRepository = sourceRepository;
}
/// <summary>
/// Returns true if the package has a dependency on a project-level package.
/// </summary>
/// <param name="package">The package to check.</param>
/// <returns>True if the package has a dependency on a project-level package.</returns>
private bool HasProjectLevelPackageDependency(IPackage package)
{
var dependencies = package.DependencySets.SelectMany(p => p.Dependencies);
if (dependencies.IsEmpty())
{
return(false);
}
HashSet <string> solutionLevelPackages = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
solutionLevelPackages.AddRange(
PackageReferenceFile.GetPackageReferences().Select(packageReference => packageReference.Id));
return(dependencies.Any(dependency => !solutionLevelPackages.Contains(dependency.Id)));
}
public IEnumerable<string> CreatePackageFile()
{
var packageReferenceFile = new PackageReferenceFile(Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFile));
var repository = new LocalPackageRepository(Path.Combine(_fileSystem.CurrentDirectory, Constants.PackagesFolder));
var arbitraryPackages = repository.GetPackages();
var result = new List<string>();
foreach (var package in arbitraryPackages.GroupBy(i => i.Id))
{
var p = package.OrderByDescending(i => i.Version).FirstOrDefault();
packageReferenceFile.AddEntry(p.Id, p.Version, VersionUtility.ParseFrameworkName("net45"));
result.Add(string.Format("{0}, Version {1}, .NET 4.5", p.Id, p.Version));
}
return result;
}
public void CheckProjectPackages (IDotNetProject project)
{
packageReferenceFile = CreatePackageReferenceFile (project.GetPackagesConfigFilePath ());
packageReferences = packageReferenceFile.GetPackageReferences ().ToList ();
var targetFramework = new ProjectTargetFramework (project);
compatibilityReport = new ProjectPackagesCompatibilityReport (targetFramework.TargetFrameworkName);
foreach (PackageReference packageReference in packageReferences) {
IPackage package = packageRepository.Repository.FindPackage (packageReference.Id);
if (package != null) {
if (PackageNeedsReinstall (project, package, packageReference.TargetFramework)) {
packagesRequiringReinstallation.Add (package);
}
}
}
}
public TestablePackageCompatibilityRunner (
IDotNetProject project,
IPackageManagementSolution solution,
IRegisteredPackageRepositories registeredRepositories,
IPackageManagementProgressMonitorFactory progressMonitorFactory,
IPackageManagementEvents packageManagementEvents,
IProgressProvider progressProvider)
: base (
project,
solution,
registeredRepositories,
progressMonitorFactory,
packageManagementEvents,
progressProvider)
{
PackageReferenceFile = new PackageReferenceFile (FileSystem, "packages.config");
}
public IEnumerable<IPackageReference> FindReferences(string path)
{
var packageReferenceFile = new PackageReferenceFile(path);
var references = packageReferenceFile.GetPackageReferences().ToList();
if (references.Any())
{
foreach (var packageReference in references)
{
yield return new PackageReference(
packageReference.Id,
packageReference.TargetFramework,
packageReference.Version.Version,
packageReference.Version.SpecialVersion);
}
yield break;
}
// No packages.config, check packages folder
var packagesFolder = Path.Combine(_fileSystem.GetWorkingDirectory(path), Constants.PackagesFolder);
if (!_fileSystem.DirectoryExists(packagesFolder))
{
yield break;
}
var repository = new LocalPackageRepository(packagesFolder);
var arbitraryPackages = repository.GetPackages();
if (!arbitraryPackages.Any())
{
yield break;
}
foreach (var arbitraryPackage in arbitraryPackages)
{
var newestFramework = GetNewestSupportedFramework(arbitraryPackage)
?? VersionUtility.EmptyFramework;
yield return new PackageReference(
arbitraryPackage.Id,
newestFramework,
arbitraryPackage.Version.Version,
arbitraryPackage.Version.SpecialVersion);
}
}
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 void CheckProjectPackages (IDotNetProject project)
{
IPackageManagementProject packageManagementProject = solution.GetProject (registeredRepositories.ActiveRepository, project);
packageReferenceFile = CreatePackageReferenceFile (project.GetPackagesConfigFilePath ());
packageReferences = packageReferenceFile.GetPackageReferences ().ToList ();
compatibilityReport = new ProjectPackagesCompatibilityReport (packageManagementProject.TargetFramework);
foreach (PackageReference packageReference in packageReferences) {
IPackage package = packageManagementProject.FindPackage (packageReference.Id);
if (package != null) {
if (PackageNeedsReinstall (project, package, packageReference.TargetFramework)) {
packagesRequiringReinstallation.Add (package);
}
}
}
}
public void CreatePackageFile()
{
var packagesFile = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFile);
var packageReferenceFile = new PackageReferenceFile(packagesFile);
var packagesFolder = Path.Combine(_fileSystem.CurrentDirectory, _fileSystem.PackagesFolder);
var repository = new LocalPackageRepository(packagesFolder);
var newestPackages = repository.GetPackages().GroupBy(p => p.Id)
.Select(g => g.OrderByDescending(p => p.Version).FirstOrDefault());
if (!newestPackages.Any())
{
_logger.Info("No packages found!");
return;
}
_logger.InfoFormat("{0} {1}...", (File.Exists(packagesFile) ? "Updating" : "Creating"), _fileSystem.PackagesFile);
foreach (var package in newestPackages)
{
var newestFramework = GetNewestSupportedFramework(package);
if (!packageReferenceFile.EntryExists(package.Id, package.Version))
{
packageReferenceFile.AddEntry(package.Id, package.Version, package.DevelopmentDependency, newestFramework);
if (newestFramework == null)
{
_logger.InfoFormat("Added {0} (v{1}) to {2}", package.Id, package.Version, _fileSystem.PackagesFile);
}
else
{
_logger.InfoFormat("Added {0} (v{1}, .NET {2}) to {3}", package.Id, package.Version, newestFramework.Version, _fileSystem.PackagesFile);
}
continue;
}
_logger.InfoFormat("Skipped {0} because it already exists.", package.Id);
}
_logger.InfoFormat("Successfully {0} {1}.", (File.Exists(packagesFile) ? "updated" : "created"), _fileSystem.PackagesFile);
}
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;
}
//string path)
//reads all the packages.config files provided as input
//and returns a map which contains every package mapped to list of project locations in which it is referenced.
public Dictionary<PackageElement, List<string>> readConfig(List<string> packageFilePaths, string root)
{
Dictionary<PackageElement, List<string>> map = new Dictionary<PackageElement, List<string>>();
string fileName;
Console.WriteLine("In read config");
foreach (string path in packageFilePaths)
{
//Ignore packages.config files in these folders
if (path.Contains(@"\.nuget") || path.Contains(@"\packages") || path.Contains(@"\Samples\"))
continue;
fileName = path + "packages.config";
var file = new PackageReferenceFile(fileName);
string path1 = path.Replace(root, "");
Console.WriteLine(path1);
foreach (PackageReference packageReference in file.GetPackageReferences())
{
PackageElement pe = new PackageElement(packageReference.Id, packageReference.Version);
if (!map.ContainsKey(pe))
{
//Console.WriteLine("add to map: "+packageReference.Id);
List<string> ans = new List<string>();
ans.Add(path1);
map.Add(pe, ans);
}
else
{
List<string> ans= map[pe];
ans.Add(path1);
map[pe] = ans;
//Console.WriteLine(" contains key "+ packageReference .Id+" "+ ans.Count);
}
Console.WriteLine("PackageId={0}, Version={1}", packageReference.Id, packageReference.Version);
}
}
return map;
}
public IEnumerable<IPackageReference> FindReferences(string path)
{
var packageReferenceFile = new PackageReferenceFile(path);
var references = packageReferenceFile.GetPackageReferences();
if (!references.Any())
{
var packagesFolder = Path.Combine(_fileSystem.GetWorkingDirectory(path), Constants.PackagesFolder);
if (_fileSystem.DirectoryExists(packagesFolder))
{
var repository = new LocalPackageRepository(packagesFolder);
var arbitraryPackages = repository.GetPackages().Where(i => i.GetSupportedFrameworks().Any(x => x.FullName == VersionUtility.ParseFrameworkName("net40").FullName)).ToList();
if (arbitraryPackages.Any())
{
return arbitraryPackages.Select(i => new PackageReference(i.Id, VersionUtility.ParseFrameworkName("net40"), i.Version.Version) { SpecialVersion = i.Version.SpecialVersion });
}
}
return Enumerable.Empty<IPackageReference>();
}
var packages = references.Select(i => new PackageReference(i.Id, i.TargetFramework, i.Version.Version) { SpecialVersion = i.Version.SpecialVersion });
return packages;
}
public static ICollection<PackageReference> GetPackageReferences(PackageReferenceFile file, string fileName, bool requireVersion)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
var packageReferences = file.GetPackageReferences(requireVersion).ToList();
foreach (var package in packageReferences)
{
// GetPackageReferences returns all records without validating values. We'll throw if we encounter packages
// with malformed ids / Versions.
if (String.IsNullOrEmpty(package.Id))
{
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, NuGetResources.InstallCommandInvalidPackageReference, fileName));
}
if (requireVersion && (package.Version == null))
{
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, NuGetResources.InstallCommandPackageReferenceInvalidVersion, package.Id));
}
}
return packageReferences;
}
void AssertPackageMarkedForReinstallationInPackagesConfigFile (string packageId, bool expectedReinstallationSetting)
{
var fileSystem = new FakeFileSystem ();
fileSystem.FileExistsReturnValue = true;
MemoryStream stream = runner.FileSystem.FilesAdded.First ().Value;
string file = UTF8Encoding.UTF8.GetString (stream.ToArray ());
fileSystem.FileToReturnFromOpenFile = file;
var packageReferenceFile = new PackageReferenceFile (fileSystem, "packages.config");
PackageReference matchedReference = packageReferenceFile
.GetPackageReferences ()
.FirstOrDefault (packageReference => packageReference.Id == packageId);
Assert.AreEqual (expectedReinstallationSetting, matchedReference.RequireReinstallation);
}
public PackageReferenceFile(string fileName)
{
this.fileName = fileName;
this.file = new NuGet.PackageReferenceFile(fileName);
}
private static void WriteLicenseInformationToOutputFile(List<string> configDirs, string packageDir, string outputFile)
{
var packageBuilder = new StringBuilder();
var licenseTemplate = EmbeddedResourceExtracter.LoadEmbeddedTextFile(
Assembly.GetExecutingAssembly(),
@"NTreva.Templates.LicenseInformation.xml");
// Determine all the packages we need to scan from the packages.config files
var usedPackages = new List<Tuple<string, string>>();
foreach (var dir in configDirs)
{
var configFile = Path.Combine(dir, "packages.config");
var file = new PackageReferenceFile(configFile);
var packageReferences = file.GetPackageReferences().ToList();
// Note that we ignore dependencies here because packages.config already contains the full closure
foreach (var package in packageReferences)
{
// GetPackageReferences returns all records without validating values. We'll throw if we encounter packages
// with malformed ids.
if (string.IsNullOrEmpty(package.Id))
{
throw new InvalidDataException(Resources.Exceptions_Messages_InvalidPackageId);
}
if (!usedPackages.Exists(t => string.Equals(t.Item1, package.Id)))
{
usedPackages.Add(new Tuple<string, string>(package.Id, package.Version.ToString()));
}
}
}
usedPackages.Sort();
foreach (var tuple in usedPackages)
{
WriteToConsole(
string.Format(
CultureInfo.CurrentCulture,
Resources.Output_ProcessingPackage,
tuple.Item1));
// Go find the package from the packages directory
var packageFilePath = Path.Combine(
Path.Combine(
packageDir,
string.Format(
CultureInfo.InvariantCulture,
"{0}.{1}",
tuple.Item1,
tuple.Item2)),
string.Format(
CultureInfo.InvariantCulture,
"{0}.{1}.{2}",
tuple.Item1,
tuple.Item2,
"nupkg"));
if (File.Exists(packageFilePath))
{
var packageFile = new ZipPackage(packageFilePath);
var licenseBuilder = new StringBuilder(licenseTemplate);
licenseBuilder.Replace(@"${Package.Id}$", packageFile.Id);
var version = packageFile.Version ?? new SemanticVersion(new Version());
licenseBuilder.Replace(@"${Package.Version}$", version.ToString());
var projectUrl = packageFile.ProjectUrl
?? new Uri(
string.Format(
CultureInfo.InvariantCulture,
Resources.GoogleSearchQuery,
tuple.Item1.Replace(' ', '+')));
licenseBuilder.Replace(@"${Package.Url}$", projectUrl.ToString());
var licenseUrl = packageFile.LicenseUrl
?? new Uri(
string.Format(
CultureInfo.InvariantCulture,
Resources.GoogleSearchQuery,
tuple.Item1.Replace(' ', '+')));
licenseBuilder.Replace(@"${Package.LicenseUrl}$", licenseUrl.ToString());
if (packageBuilder.Length > 0)
{
packageBuilder.Append(Environment.NewLine);
}
packageBuilder.Append(licenseBuilder);
}
}
var packagesTemplate = EmbeddedResourceExtracter.LoadEmbeddedTextFile(
Assembly.GetExecutingAssembly(),
@"NTreva.Templates.Packages.xml");
var builder = new StringBuilder(packagesTemplate);
builder.Replace(@"${Packages}$", packageBuilder.ToString());
using (var writer = new StreamWriter(new FileStream(outputFile, FileMode.Create, FileAccess.Write, FileShare.None), Encoding.UTF8))
{
writer.Write(builder.ToString());
}
WriteToConsole(
string.Format(
CultureInfo.CurrentCulture,
Resources.Output_Completed,
outputFile));
}
public static IEnumerable<PackageReference> GetPackageReferences(this ICakeContext context, DirectoryPath path)
{
if (!path.IsRelative)
{
throw new CakeException("DirectoryPath must be relative!");
}
var packagePath = path.CombineWithFilePath(new FilePath("packages.config"));
if (!System.IO.File.Exists(packagePath.FullPath))
{
throw new CakeException(string.Format("Could not find a packages.config file in '{0}'", path.FullPath));
}
var file = new PackageReferenceFile(packagePath.FullPath);
return file.GetPackageReferences();
}
public static PackageReference GetPackageReference(this ICakeContext context, DirectoryPath path, string packageId)
{
if (!path.IsRelative)
{
throw new CakeException("DirectoryPath must be relative!");
}
var packagePath = path.CombineWithFilePath(new FilePath("packages.config"));
if (!System.IO.File.Exists(packagePath.FullPath))
{
throw new CakeException(string.Format("Could not find a packages.config file in '{0}'", path.FullPath));
}
var file = new PackageReferenceFile(packagePath.FullPath);
return file.GetPackageReferences().FirstOrDefault(x => x.Id.Equals(packageId, StringComparison.OrdinalIgnoreCase));
}
public static ICollection <InstalledPackageReference> GetInstalledPackageReferences(PackageReferenceFile configFile, bool requireVersion)
{
if (configFile == null)
{
throw new ArgumentNullException("configFile");
}
var packageReferences = configFile.GetPackageReferences(requireVersion);
foreach (var package in packageReferences)
{
// GetPackageReferences returns all records without validating values. We'll throw if we encounter packages
// with malformed ids / Versions.
if (String.IsNullOrEmpty(package.Id))
{
throw new InvalidDataException(
String.Format(CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandInvalidPackageReference"),
configFile.FullPath));
}
if (requireVersion && (package.Version == null))
{
throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, LocalizedResourceManager.GetString("InstallCommandPackageReferenceInvalidVersion"), package.Id));
}
}
return(packageReferences.Select(pr => CoreConverters.SafeToInstalledPackageReference(pr)).ToList());
}
//writes new version of the package to packages.config file
public void writeToConfig(string fileName, string packageId, SemanticVersion newversion)
{
var file = new PackageReferenceFile(fileName);
file.DeleteEntry(packageId, null);
file.AddEntry(packageId, newversion);
}
protected virtual IEnumerable<PackageReference> GetPackageReferences ()
{
if (project.HasPackages ()) {
var packageReferenceFile = new PackageReferenceFile (project.GetPackagesConfigFilePath ());
return packageReferenceFile.GetPackageReferences ();
}
return new PackageReference [0];
}
public void RegisterRepository(PackageReferenceFile packageReferenceFile)
{
AddEntry(packageReferenceFile.FullPath);
}
public void UnregisterRepository(PackageReferenceFile packageReferenceFile)
{
DeleteEntry(packageReferenceFile.FullPath);
}
private static List<PackageReferenceFile> GetPackageReferenceFileList()
{
var x1 = @"<?xml version='1.0' encoding='utf-8'?>
<packages>
<package id='Package1' version='1.0' allowedVersions='[1.0, 2.0)' />
<package id='Package2' version='2.0' />
</packages>";
var x2 = @"<?xml version='1.0' encoding='utf-8'?>
<packages>
<package id='Package1' version='2.0' allowedVersions='[1.0, 3.0)' />
<package id='Package2' version='2.0' />
</packages>";
var mfs = new Mock<MockFileSystem>();
mfs.Setup(m => m.OpenFile("x1")).Returns(x1.AsStream());
mfs.Setup(m => m.OpenFile("x2")).Returns(x2.AsStream());
mfs.Setup(m => m.FileExists(It.IsAny<string>())).Returns(true);
var mpr1 = new PackageReferenceFile(mfs.Object, "x1");
var mpr2 = new PackageReferenceFile(mfs.Object, "x2");
var packageFiles = new List<PackageReferenceFile>();
packageFiles.Add(mpr1);
packageFiles.Add(mpr2);
return packageFiles;
}
/*<summary>
* Using Nuget.Core API, we gather all nuget`s packages that specific project depend on them.
* </summary>
* <returns></returns>
*/
private static void addDependencies(string projectName, Module module, string localSource, string[] packageConfigPath, string Configuration)
{
if (packageConfigPath.Length != 0)
{
var sharedPackages = new LocalPackageRepository(localSource);
var packageReferenceFile = new PackageReferenceFile(packageConfigPath[0]);
IEnumerable<PackageReference> projectPackages = packageReferenceFile.GetPackageReferences();
foreach (PackageReference package in projectPackages)
{
var pack = sharedPackages.FindPackage(package.Id, package.Version);
using (Stream packageStream = ((NuGet.OptimizedZipPackage)(pack)).GetStream())
{
byte[] buf = new byte[packageStream.Length];
int byteread = packageStream.Read(buf, 0, buf.Length);
module.Dependencies.Add(new Dependency
{
type = "nupkg",
md5 = MD5CheckSum.GenerateMD5(buf),
sha1 = Sha1Reference.GenerateSHA1(buf),
scopes = new List<string> { Configuration },
id = pack.Id + ":" + pack.Version
});
}
}
}
}
static IEnumerable<PackageReference> GetDependencies() {
if (string.IsNullOrEmpty(packages_config_path)) {
var currentDir = Directory.GetCurrentDirectory();
string[] files = Directory.GetFiles(currentDir, "packages.config");
if (files.Length == 1) {
packages_config_path = files[0];
log.DebugFormat("packages.config found: {0}", packages_config_path);
}
}
if (packages_config_path == null) return null;
var packageReferenceFile = new PackageReferenceFile(packages_config_path);
return packageReferenceFile.GetPackageReferences();
}
public void RegisterRepository(PackageReferenceFile packageReferenceFile)
{
AddEntry(packageReferenceFile.FullPath);
}
public void UnregisterRepository(PackageReferenceFile packageReferenceFile)
{
throw new NotImplementedException();
}
public void UnregisterRepository(PackageReferenceFile packageReferenceFile)
{
DeleteEntry(packageReferenceFile.FullPath);
}
public PackageReferenceFile(string fileName)
{
this.fileName = fileName;
this.file = new NuGet.PackageReferenceFile(fileName);
}
