/// <summary> /// Resolves a package from nuget using a specified name and version. /// </summary> /// <param name="name">Name of the package to find</param> /// <param name="version">Version of the package</param> /// <returns>File path if the nuget package is found</returns> protected string ResolvePackage(string name, Version version) { SemanticVersion vers = SemanticVersion.ParseOptionalVersion($"{version.Major}.{version.Minor}.*"); IPackage package = ResolvePackage(name, vers); if (package != null) { string installPath = packageManager.PathResolver.GetInstallPath(package); string libPath = Path.Combine(installPath, "lib", "net45", name + ".dll"); if (File.Exists(libPath)) { OnResolved?.Invoke(this, new NugetAssemblyResolvedEventArgs() { FilePath = libPath }); return(libPath); } else { var files = Directory.EnumerateFiles(installPath, "*.dll", SearchOption.AllDirectories); if (files.Count() == 1) { libPath = files.Single(); OnResolved?.Invoke(this, new NugetAssemblyResolvedEventArgs() { FilePath = libPath }); return(libPath); } } } return(null); }
private static void InstallPackage(string packageId, string packageVersion) { var realVersion = packageVersion != Constants.NuGetLatestVersion ? packageVersion : null; LogMessage($"Installing NuGet {packageId}.{packageVersion}"); packageManager.InstallPackage(packageId, SemanticVersion.ParseOptionalVersion(realVersion), ignoreDependencies: true, allowPrereleaseVersions: false); }
private void ExtractMetadataFromProject(PackageBuilder builder) { builder.Id = builder.Id ?? _project.GetPropertyValue("AssemblyName") ?? Path.GetFileNameWithoutExtension(_project.FullPath); string version = _project.GetPropertyValue("Version"); builder.Version = builder.Version ?? SemanticVersion.ParseOptionalVersion(version) ?? new SemanticVersion("1.0"); }
public override void Curate(Package galleryPackage, INupkg nugetPackage, bool commitChanges) { if (!galleryPackage.Dependencies.Any()) { return; } var curatedFeedService = GetService <ICuratedFeedService>(); var entitiesContext = GetService <IEntitiesContext>(); var curatedFeeds = entitiesContext.CuratedFeeds .ToList() .Select(feed => new { Match = curatedFeedNameParser.Match(feed.Name), Feed = feed }) .Where(x => x.Match.Success) .Select(x => new { Name = x.Match.Value, Id = x.Match.Groups["name"].Value, Version = SemanticVersion.ParseOptionalVersion(x.Match.Groups["version"].Value), x.Feed }) .ToList(); var feedDependencies = (from d in galleryPackage.Dependencies from cf in curatedFeeds where string.Equals(d.Id, cf.Id, StringComparison.OrdinalIgnoreCase) && (CuratedFeedWantsAllVersions(cf.Version) || CuratedFeedSatisfiesDependency(cf.Version, d)) select new { Dependency = d, cf.Feed, FeedId = cf.Id }).ToList(); // Packages that should also be curated to satisfy the dependencies var feedDependencyNames = feedDependencies.Select(fd => fd.FeedId).ToList(); var packageDependencies = (from d in galleryPackage.Dependencies where !feedDependencyNames.Contains(d.Id, StringComparer.OrdinalIgnoreCase) from p in GetMatchingPackages(d.Id, d.VersionSpec) select p).ToList(); foreach (var feedDependency in feedDependencies) { var curatedFeed = feedDependency.Feed; curatedFeedService.CreatedCuratedPackage(curatedFeed, galleryPackage, included: true, automaticallyCurated: true, commitChanges: commitChanges); // Now add all packageDependencies foreach (var packageDependency in packageDependencies) { curatedFeedService.CreatedCuratedPackage(curatedFeed, packageDependency, included: true, automaticallyCurated: true, commitChanges: commitChanges); } } }
public void InstallPackagesFromConfigFile(DeployMessage.Item[] items, out string packagesDirectory, out string packagesFile, out string version) { version = null; packagesFile = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + "\\packages.config"); packagesDirectory = Path.GetDirectoryName(packagesFile); if (!Directory.Exists(packagesDirectory)) { Directory.CreateDirectory(packagesDirectory); } var referenceFile = new PackageReferenceFile(packagesFile); foreach (var item in items) { referenceFile.AddEntry(item.PackageId, (SemanticVersion.ParseOptionalVersion(item.Version) ?? _emptySemanticVersion)); } }
/// <summary> /// Resolves a package from nuget using a specified name and version. /// </summary> /// <param name="name">Name of the package to find</param> /// <param name="version">Version of the package</param> /// <returns>File path if the nuget package is found</returns> protected string ResolvePackage(string name, Version version) { SemanticVersion vers = SemanticVersion.ParseOptionalVersion($"{version.Major}.{version.Minor}.*"); IPackage package = ResolvePackage(name, vers); if (package != null) { string installPath = packageManager.PathResolver.GetInstallPath(package); string libPath = Path.Combine(installPath, "lib", "net45", name + ".dll"); if (File.Exists(libPath)) { OnResolved?.Invoke(this, new NugetAssemblyResolvedEventArgs() { FilePath = libPath }); return(libPath); } else { var files = Directory.EnumerateFiles(installPath, "*.dll", SearchOption.AllDirectories); if (files.Count() == 1) { libPath = files.Single(); OnResolved?.Invoke(this, new NugetAssemblyResolvedEventArgs() { FilePath = libPath }); return(libPath); } } } else { foreach (var file in Directory.EnumerateFiles(Environment.CurrentDirectory, name + ".*")) { var extension = Path.GetExtension(file).ToLower(); if (new[] { ".exe", ".dll" }.Contains(extension)) { Console.WriteLine($" * Found {name} locally"); return(file); } } } return(null); }
public Tuple <SemanticVersion, string> Load(DllReference parentAssembly, string Dependency) { var path = parentAssembly.Id.Item1 + _sectionSeparator + parentAssembly.Id.Item2 + _sectionSeparator + Dependency + ".ini"; if (!File.Exists(@"cache\" + path)) { return(null); } var parser = new FileIniDataParser(); var iniData = parser.ReadFile(@"cache\" + path); var section = iniData.Sections["Dependency"]; var version = SemanticVersion.ParseOptionalVersion(section["version"]); var name = section["name"]; return(new Tuple <SemanticVersion, string>(version, name)); }
static PackageReference ParseExtraPackageReference(string input) { // Syntax: ID [ "@" VERSION ] ["++"] // Examples: // Foo => Latest release of Foo // [email protected] => Foo release 2.1 // Foo++ => Latest pre-release of Foo // [email protected]++ => Foo 3.0 pre-release const string plusplus = "++"; var prerelease = input.EndsWith(plusplus, StringComparison.Ordinal); if (prerelease) { input = input.Substring(0, input.Length - plusplus.Length); } return(input.Split('@', (id, version) => new PackageReference(id, SemanticVersion.ParseOptionalVersion(version), prerelease))); }
static T Compile <T>(string queryFilePath, IPackageRepository repo, string packagesPath, IEnumerable <PackageReference> extraPackageReferences, IEnumerable <string> extraImports, FrameworkName targetFramework, bool verbose, IndentingLineWriter writer, Func <QueryLanguage, string, IEnumerable <string>, IEnumerable <Reference>, T> selector) { var eomLineNumber = LinqPad.GetEndOfMetaLineNumber(queryFilePath); var lines = File.ReadLines(queryFilePath); var xml = string.Join(Environment.NewLine, // ReSharper disable once PossibleMultipleEnumeration lines.Take(eomLineNumber)); var query = XElement.Parse(xml); if (verbose) { writer.Write(query); } QueryLanguage queryKind; if (!Enum.TryParse((string)query.Attribute("Kind"), true, out queryKind) || (queryKind != QueryLanguage.Statements && queryKind != QueryLanguage.Expression && queryKind != QueryLanguage.Program)) { throw new NotSupportedException("Only LINQPad " + "C# Statements and Expression queries are fully supported " + "and C# Program queries partially in this version."); } var nrs = from nrsq in new[] { from nr in query.Elements("NuGetReference") select new PackageReference((string)nr, SemanticVersion.ParseOptionalVersion((string)nr.Attribute("Version")), (bool?)nr.Attribute("Prerelease") ?? false), extraPackageReferences, } from nr in nrsq select new { nr.Id, nr.Version, nr.IsPrereleaseAllowed, Title = string.Join(" ", Seq.Return(nr.Id, nr.Version?.ToString(), nr.IsPrereleaseAllowed ? "(pre-release)" : null) .Filter()), }; nrs = nrs.ToArray(); if (verbose && nrs.Any()) { writer.WriteLine($"Packages referenced ({nrs.Count():N0}):"); writer.Indent().WriteLines(from nr in nrs select nr.Title); } writer.WriteLine($"Packages directory: {packagesPath}"); var pm = new PackageManager(repo, packagesPath); pm.PackageInstalling += (_, ea) => writer.WriteLine($"Installing {ea.Package}..."); pm.PackageInstalled += (_, ea) => writer.Indent().WriteLine($"Installed at {ea.InstallPath}"); writer.WriteLine($"Packages target: {targetFramework}"); var resolutionList = Enumerable.Repeat(new { Package = default(IPackage), AssemblyPath = default(string) }, 0) .ToList(); foreach (var nr in nrs) { var pkg = pm.LocalRepository.FindPackage(nr.Id, nr.Version, allowPrereleaseVersions: nr.IsPrereleaseAllowed, allowUnlisted: false); if (pkg == null) { pkg = repo.FindPackage(nr.Id, nr.Version, allowPrereleaseVersions: nr.IsPrereleaseAllowed, allowUnlisted: false); if (pkg == null) { throw new Exception("Package not found: " + nr.Title); } pm.InstallPackage(pkg.Id, pkg.Version); } writer.WriteLine("Resolving references..."); resolutionList.AddRange(GetReferencesTree(pm.LocalRepository, pkg, targetFramework, writer.Indent(), (r, p) => new { Package = p, AssemblyPath = r != null ? Path.Combine(pm.PathResolver.GetInstallPath(p), r.Path) : null })); } var packagesPathWithTrailer = packagesPath + Path.DirectorySeparatorChar; var resolution = resolutionList .GroupBy(r => r.Package) .Select(g => g.First()) .Select(r => new { r.Package, AssemblyPath = r.AssemblyPath != null ? MakeRelativePath(queryFilePath, packagesPathWithTrailer) + MakeRelativePath(packagesPathWithTrailer, r.AssemblyPath) : null, }) .Partition(r => r.AssemblyPath == null, (ok, nok) => new { ResolvedReferences = ok, ReferencelessPackages = from r in nok select r.Package.GetFullName(), }); resolution.ReferencelessPackages.StartIter(e => { writer.WriteLine($"Warning! Packages with no references for {targetFramework}:"); writer.Indent().WriteLines(e.ResumeFromCurrent()); }); var references = resolution.ResolvedReferences.ToArray(); references.Select(r => r.AssemblyPath).StartIter(e => { writer.WriteLine($"Resolved references ({references.Length:N0}):"); writer.Indent().WriteLines(e.ResumeFromCurrent()); }); return (selector( queryKind, // ReSharper disable once PossibleMultipleEnumeration string.Join(Environment.NewLine, lines.Skip(eomLineNumber)), LinqPad.DefaultNamespaces .Concat(from ns in query.Elements("Namespace") select(string) ns) .Concat(extraImports), LinqPad.DefaultReferences.Select(r => new Reference(r)) .Concat(from r in query.Elements("Reference") select(string) r into r select r.StartsWith(LinqPad.RuntimeDirToken, StringComparison.OrdinalIgnoreCase) ? r.Substring(LinqPad.RuntimeDirToken.Length) : r into r select new Reference(r)) .Concat(from r in references select new Reference(r.AssemblyPath, r.Package)))); }
internal NuGetInfo(string id, string version = LatestVersion) { Name = id; Version = SemanticVersion.ParseOptionalVersion(version); }