public void SetPreviewedPackage(NugetPackage package) { m_nugetPackage = package; var model = ScriptableObject.CreateInstance <PackageViewModel>(); model.Package = package; SerializedObject serializedObject = new SerializedObject(model); LogPropertyPaths(serializedObject); this.Bind(serializedObject); this.Query <Label>("package-view--title").First().text = package.Title; this.Query <Label>("package-view--author-text").First().text = package.Authors; this.Query <Label>("package-view--description-text").First().text = package.Description; this.Query <Label>("package-view--license-text").First().text = package.LicenseUrl; this.Query <VisualElement>("package-view--image").First().style.backgroundImage = package.Icon; bool isInstalled = NugetHelper.IsInstalled(package); this.Query <Button>("package-view--primary-action").First().text = isInstalled ? "Remove Package from Project" : "Add Package to Project"; }
private static void AddReferencesToNugetPackages(string solutionFolder) { var packageFolders = Directory.GetDirectories(solutionFolder + "/packages/"); var packages = new List <NugetPackage>(); foreach (var packageFolder in packageFolders) { var pattern = new Regex(@"(.+)\.(\d+\.\d+\.\d+.*)"); var captureGroups = pattern.Matches(packageFolder).GetEnumerator().Current as Match; // There can only be one var name = captureGroups.Groups[1].Value; var version = captureGroups.Groups[2].Value; var libFolder = packageFolder + "/lib/net45/"; var dllNames = Directory.GetFiles(libFolder).Where(f => f.EndsWith(".dll")).Select(Path.GetFileNameWithoutExtension); var package = new NugetPackage() { Name = name, Version = version, DllNames = dllNames.ToList() }; } }
[TestCase("CommonServiceLocator", "1.3", "portable-net4+sl5+netcore45+wpa81+wp8", "https://api.nuget.org/v3/index.json")] //Short version format. public void InstallPackage(string id, string version, string target, string source) { var p = new NugetPackage(id, version, target, source, null, NugetPackageType.DotNetImplementationAssembly, GetNugetCachePath()); var installed = NugetHelper.InstallPackages(new[] { p }, false, null); Assert.AreEqual(1, installed.Count(), "Invalid number of installed packages"); }
public MockGenerator MockToolsAndContentDlls() { var packageId = Path.GetFileNameWithoutExtension(NupkgFile); NugetPackage.Setup(x => x.GetSupportedFrameworks()).Returns(PackageFrameworks); NugetPackage.Setup(x => x.Id).Returns(packageId); NugetPackage.Setup(x => x.Version).Returns(new SemanticVersion("1.0.0.0")); var mockPackageFileTools = new Mock <IPackageFile>(MockBehavior.Strict); mockPackageFileTools.Setup(x => x.Path).Returns(@"tOols\myToolsSample.dLl"); var mockPackageFileContent = new Mock <IPackageFile>(MockBehavior.Strict); mockPackageFileContent.Setup(x => x.Path).Returns(@"contenT\myToolsSample.dLl"); PackageFiles.Add(mockPackageFileTools); PackageFiles.Add(mockPackageFileContent); var packageDir = Path.GetDirectoryName(NupkgFile); FileSystem.Setup(x => x.DirectoryGetFiles(packageDir, "*.dll", SearchOption.AllDirectories)) .Returns(PackageFiles.Select(x => Path.Combine(packageDir, x.Object.Path)).ToArray()); return(this); }
private void CreateNugetPackage(AgentComponents components, AgentComponents x86Components, string nuspecPath) { var rootDir = $@"{StagingDirectory}\Nuget{components.Platform}"; var stagingDir = $@"{rootDir}\content\newrelic"; FileHelpers.CopyFile(nuspecPath, rootDir); var package = new NugetPackage(rootDir, FilesToZipFolderName); package.SetVersion(components.Version); var configFilePath = $@"{rootDir}\content\newrelic\newrelic.config"; package.CopyToContent(components.RootInstallDirectoryComponents, @"newrelic"); package.CopyToContent(components.RootInstallDirectoryComponents.Where(x => !x.Contains("newrelic.config") && !x.Contains("newrelic.xsd")), @"newrelic\ProgramFiles\NewRelic\NetAgent"); package.CopyToContent(components.ExtensionDirectoryComponents.Where(x => x.Contains(".dll")), @"newrelic\ProgramFiles\NewRelic\NetAgent\Extensions"); package.CopyToContent(x86Components.RootInstallDirectoryComponents.Where(x => x.Contains("NewRelic.Profiler.dll")), @"newrelic\ProgramFiles\NewRelic\NetAgent\x86"); package.CopyToContent(components.WrapperXmlFiles, $@"newrelic\ProgramData\NewRelic\NetAgent\Extensions"); package.CopyToContent(components.ExtensionXsd, $@"newrelic\ProgramData\NewRelic\NetAgent\Extensions"); package.CopyToContent(components.NewRelicXsd, $@"newrelic\ProgramData\NewRelic\NetAgent"); package.CopyToContent(configFilePath, $@"newrelic\ProgramData\NewRelic\NetAgent"); //not sure why we create these folders Directory.CreateDirectory($@"{stagingDir}\Extensions"); Directory.CreateDirectory($@"{stagingDir}\ProgramData\NewRelic\NetAgent\NewRelic\NetAgent\Extensions"); Directory.CreateDirectory($@"{stagingDir}\ProgramData\NewRelic\NetAgent\NewRelic\NetAgent\Logs"); File.Delete(configFilePath); package.Pack(); }
public XamarinAndroidAppProject(string assemblyName, string appName, string packageName, Guid assemblyGuid, XamarinAndroidPlatform targetFrameworkVersion, int minSdkVersion, int targetSdkVersion, NugetPackage xamarinPackage, string rootNamespace = "") : base(assemblyName, assemblyGuid, "Library", targetFrameworkVersion, rootNamespace) { _minSdkVersion = minSdkVersion; _targetSdkVersion = targetSdkVersion; _packageName = packageName; _appName = appName; SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Ad-Hoc", "Any CPU")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Ad-Hoc", "iPhone")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Ad-Hoc", "iPhoneSimulator")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("AppStore", "Any CPU")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("AppStore", "iPhone")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("AppStore", "iPhoneSimulator")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Debug", "Any CPU")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Debug", "iPhone")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Debug", "iPhoneSimulator")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Release", "Any CPU")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Release", "iPhone")); SupportedBuildConfigurations.Add(new SupportedBuildConfiguration("Release", "iPhoneSimulator")); WithNugetPackage(xamarinPackage); WithNugetPackage(References.Nuget.Xamarin_Android_Support_Design__27_0_2_1); WithNugetPackage(References.Nuget.Xamarin_Android_Support_v7_AppCompat__27_0_2_1); WithNugetPackage(References.Nuget.Xamarin_Android_Support_v4__27_0_2_1); WithNugetPackage(References.Nuget.Xamarin_Android_Support_v7_CardView__27_0_2_1); WithNugetPackage(References.Nuget.Xamarin_Android_Support_v7_MediaRouter__27_0_2_1); AddDefaultAssemblyReferences(); AddDefaultFoldersAndFiles(); }
public static PackageResult Success(NugetPackage package, IReadOnlyList <PackageResult> dependencies, Option <MoreInformation> moreInformation) { var isAggregationPackage = package.SupportType == SupportType.NoDotNetLibraries && dependencies.Any() && dependencies.All(d => d.SupportType == SupportType.PreRelease || d.SupportType == SupportType.Supported || d.SupportType == SupportType.KnownReplacementAvailable || d.SupportType == SupportType.Unsupported ); var isSupportedAggregationPackage = isAggregationPackage && dependencies.All(d => d.SupportType == SupportType.PreRelease || d.SupportType == SupportType.Supported); var supportType = isSupportedAggregationPackage ? (package.IsPrerelease ? SupportType.Supported : SupportType.PreRelease) : (isAggregationPackage ? SupportType.Unsupported : package.SupportType); return(new PackageResult() { PackageName = package.Id, Dependencies = dependencies, SupportType = supportType, ProjectUrl = package.ProjectUrl, MoreInformation = moreInformation }); }
/// <summary> /// Loads a list of all currently installed packages by reading the packages.config file. /// </summary> /// <returns>A newly created <see cref="PackagesConfigFile"/>.</returns> public static PackagesConfigFile Load(string filepath) { PackagesConfigFile configFile = new PackagesConfigFile(); configFile.Packages = new List<NugetPackageIdentifier>(); // Create a package.config file, if there isn't already one in the project if (!File.Exists(filepath)) { Debug.LogFormat("No packages.config file found. Creating default at {0}", filepath); configFile.Save(filepath); AssetDatabase.Refresh(); } XDocument packagesFile = XDocument.Load(filepath); foreach (var packageElement in packagesFile.Root.Elements()) { NugetPackage package = new NugetPackage(); package.Id = packageElement.Attribute("id").Value; package.Version = packageElement.Attribute("version").Value; configFile.Packages.Add(package); } return configFile; }
public NugetAnalyzedPackage AnalyzePackage(string xml, Dictionary <string, INugetPackage> packagesOnConfig, params string[] relativePaths) { var nugetPackage = new NugetPackage() { Id = "TestPkg", Version = "1.999" }; var paths = new List <RelativePath>(); paths.Add(RelativePath.Create(m_context.StringTable, nugetPackage.Id + ".nuspec")); foreach (var relativePath in relativePaths) { paths.Add(RelativePath.Create(m_context.StringTable, relativePath)); } var packageOnDisk = new PackageOnDisk( m_context.PathTable, nugetPackage, PackageDownloadResult.FromRemote( new PackageIdentity("nuget", nugetPackage.Id, nugetPackage.Version, nugetPackage.Alias), AbsolutePath.Create(m_context.PathTable, A("X", "Pkgs", "TestPkg", "1.999", "TestPkg.nuspec")), paths)); return(NugetAnalyzedPackage.TryAnalyzeNugetPackage(m_context, m_monikers, XDocument.Parse(xml), packageOnDisk, packagesOnConfig, false)); }
public void CheckPackageLibraryContent() { var p = new NugetPackage("Unity", "4.0.1", "net45", "https://api.nuget.org/v3/index.json", null, NugetPackageType.DotNetImplementationAssembly, GetNugetCachePath()); var installed = NugetHelper.InstallPackages(new[] { p }, false, null).First(); Assert.AreEqual(6, installed.Libraries.Count()); }
/// <summary> /// New instance of <see cref="PackageMeta"/> from a nuget package <paramref name="metadata"/>. /// </summary> /// <param name="metadata">The nuget metadata used to initialized an instance of <see cref="PackageMeta"/>.</param> public static PackageMeta PackageMetaFromNugetPackage(NugetPackage metadata) { var meta = new PackageMeta { Name = metadata.Id, Version = new PackageVersion(metadata.Version.ToString()), Title = metadata.Title, IconUrl = metadata.IconUrl, LicenseUrl = metadata.LicenseUrl, ProjectUrl = metadata.ProjectUrl, RequireLicenseAcceptance = metadata.RequireLicenseAcceptance, Description = metadata.Description, Summary = metadata.Summary, Tags = metadata.Tags, Listed = metadata.Listed, Published = metadata.Published, ReportAbuseUrl = metadata.ReportAbuseUrl, DownloadCount = metadata.DownloadCount }; meta.Authors.AddRange(metadata.Authors); meta.Owners.AddRange(metadata.Owners); if (metadata.DependencySetsCount > 1) { throw new InvalidOperationException("Metadata loaded from nuspec cannot have more than one group of dependency"); } return(meta); }
public void CheckFramework() { var p = new NugetPackage("Unity.Container", "5.11.10", "net472", "https://api.nuget.org/v3/index.json", null, NugetPackageType.DotNetImplementationAssembly, GetNugetCachePath()); var ex = Assert.Throws <Exceptions.PackageInstallationException>(() => NugetHelper.InstallPackages(new[] { p }, false, null)); Assert.IsInstanceOf <Exceptions.TargetFrameworkNotFoundException>(ex.InnerException.InnerException); }
public NugetViewModel(NugetPackage nugetPackage, TreeViewItemViewModel parent, ISolutionManager solutionManager) : base(parent, true) { NugetPackage = nugetPackage; Name = $"{nugetPackage.Name} [{nugetPackage.Version}]"; FullName = Name; _solutionManager = solutionManager; }
public void Store(NugetPackage package) { if (package.Version.None) { return; } try { const string sql = "INSERT INTO dbo.NugetResultCache (Id, SupportType, Version, ProjectUrl, Dependencies, Frameworks) VALUES (@Id, @SupportType, @Version, @ProjectUrl, @Dependencies, @Frameworks)"; using (var con = new SqlConnection(_connectionString)) { con.Open(); using (var cmd = new SqlCommand(sql, con)) { cmd.Parameters.AddWithValue("Id", package.Id); cmd.Parameters.AddWithValue("SupportType", package.SupportType.ToString()); cmd.Parameters.AddWithValue("Version", package.Version.Value.ToNormalizedString()); cmd.Parameters.AddWithValue("ProjectUrl", (object)package.ProjectUrl ?? DBNull.Value); cmd.Parameters.AddWithValue("Dependencies", string.Join("|", package.Dependencies)); cmd.Parameters.AddWithValue("Frameworks", string.Join("|", package.Frameworks.Select(f => f.FullName))); cmd.ExecuteNonQuery(); } } } catch (Exception ex) { Log.Warning(ex, "Could not store {id} {version} in Nuget Package Cache", package.Id, package.Version.Value); } }
public HashSet <NugetPackage> GetNugetPackages(string projectFilePath, string projectAssetsFilePath, bool isTestProject) { var packages = new HashSet <NugetPackage>(); if (_fileSystem.File.Exists(projectAssetsFilePath)) { var assetFileReader = _assetFileReaderFactory(); var assetsFile = assetFileReader.Read(projectAssetsFilePath); foreach (var targetRuntime in assetsFile.Targets) { var directPackageDependencies = GetDirectPackageDependencies(targetRuntime.Name, projectFilePath); var runtimePackages = new HashSet <NugetPackage>(); foreach (var library in targetRuntime.Libraries.Where(lib => lib.Type != "project")) { var package = new NugetPackage { Name = library.Name, Version = library.Version.ToNormalizedString(), Scope = Component.ComponentScope.Required, Dependencies = new Dictionary <string, string>(), }; var topLevelReferenceKey = (package.Name, package.Version); if (directPackageDependencies.Contains(topLevelReferenceKey)) { package.IsDirectReference = true; } // is this a test project dependency or only a development dependency if ( isTestProject || ( library.CompileTimeAssemblies.Count == 0 && library.ContentFiles.Count == 0 && library.EmbedAssemblies.Count == 0 && library.FrameworkAssemblies.Count == 0 && library.NativeLibraries.Count == 0 && library.ResourceAssemblies.Count == 0 && library.ToolsAssemblies.Count == 0 ) ) { package.Scope = Component.ComponentScope.Excluded; } // include direct dependencies foreach (var dep in library.Dependencies) { package.Dependencies.Add(dep.Id, dep.VersionRange?.ToNormalizedString()); } runtimePackages.Add(package); } ResolveDependecyVersionRanges(runtimePackages); packages.UnionWith(runtimePackages); } } return(packages); }
public MockGenerator MockPackageId() { var packageId = Path.GetFileNameWithoutExtension(NupkgFile); NugetPackage.Setup(x => x.Id).Returns(packageId); return(this); }
public void InstallPackageRecursively(string id, string version, string target, string source) { var p = new NugetPackage(id, version, target, source, null, NugetPackageType.DotNetImplementationAssembly, GetNugetCachePath()); var installed = NugetHelper.InstallPackages(new[] { p }, true, null).ToList(); Assert.AreEqual(4, installed.Count(), "Invalid number of installed packages"); NugetHelper.CheckPackagesConsistency(installed); }
static string NugetResponse(NugetPackage package) { return(@"<?xml version=""1.0"" encoding=""utf-8""?> <package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd""> <metadata> <id>" + package.Name + @"</id> <version>" + package.Version + @"</version> </metadata> </package>"); }
private static async Task UninstallPackage(NugetStore store, NugetPackage package, ProgressReport progressReport) { await store.UninstallPackage(package, progressReport); // If package is GameStudio, then recursively delete its Stride/Xenko dependencies to save more disk space if (store.MainPackageIds.Contains(package.Id)) { await UninstallDependencies(store, package); } }
protected override void InternalBuild() { var rootDirectory = $@"{StagingDirectory}\content\newrelic"; var frameworkAgentComponents = AgentComponents.GetAgentComponents(AgentType.Framework, Configuration, "x64", RepoRootDirectory, HomeRootDirectory); var frameworkAgentX86Components = AgentComponents.GetAgentComponents(AgentType.Framework, Configuration, "x86", RepoRootDirectory, HomeRootDirectory); var coreAgentComponents = AgentComponents.GetAgentComponents(AgentType.Core, Configuration, "x64", RepoRootDirectory, HomeRootDirectory); var coreAgentX86Components = AgentComponents.GetAgentComponents(AgentType.Core, Configuration, "x86", RepoRootDirectory, HomeRootDirectory); frameworkAgentComponents.ValidateComponents(); frameworkAgentX86Components.ValidateComponents(); coreAgentComponents.ValidateComponents(); coreAgentX86Components.ValidateComponents(); var package = new NugetPackage(StagingDirectory, OutputDirectory); frameworkAgentComponents.CopyComponents($@"{package.ContentDirectory}\newrelic"); FileHelpers.CopyFile(frameworkAgentX86Components.WindowsProfiler, $@"{package.ContentDirectory}\newrelic\x86"); Directory.CreateDirectory($@"{rootDirectory}\logs"); System.IO.File.Create($@"{rootDirectory}\logs\placeholder").Dispose(); frameworkAgentComponents.CopyComponents($@"{package.GetContentFilesDirectory("any", "net45")}\newrelic"); FileHelpers.CopyFile(frameworkAgentX86Components.WindowsProfiler, $@"{package.GetContentFilesDirectory("any", "net45")}\newrelic\x86"); Directory.CreateDirectory($@"{StagingDirectory}\contentFiles\any\net45\newrelic\logs"); System.IO.File.Create($@"{StagingDirectory}\contentFiles\any\net45\newrelic\logs\placeholder").Dispose(); coreAgentComponents.CopyComponents($@"{package.GetContentFilesDirectory("any", "netstandard2.0")}\newrelic"); FileHelpers.CopyFile(coreAgentX86Components.WindowsProfiler, $@"{package.GetContentFilesDirectory("any", "netstandard2.0")}\newrelic\x86"); package.CopyToContentFiles(coreAgentComponents.LinuxProfiler, @"any\netstandard2.0\newrelic"); package.CopyToContentFiles(coreAgentComponents.GRPCExtensionsLibLinux, @"any\netstandard2.0\newrelic"); Directory.CreateDirectory($@"{StagingDirectory}\contentFiles\any\netstandard2.0\newrelic\logs"); System.IO.File.Create($@"{StagingDirectory}\contentFiles\any\netstandard2.0\newrelic\logs\placeholder").Dispose(); package.CopyAll(PackageDirectory); var agentInfo = new AgentInfo { InstallType = "NugetAgent" }; var newRelicConfigPaths = new[] { $@"{rootDirectory}\newrelic.config", $@"{StagingDirectory}\contentFiles\any\net45\newrelic\newrelic.config", $@"{StagingDirectory}\contentFiles\any\netstandard2.0\newrelic\newrelic.config", }; foreach (var newRelicConfigPath in newRelicConfigPaths) { TransformNewRelicConfig(newRelicConfigPath); agentInfo.WriteToDisk(Path.GetDirectoryName(newRelicConfigPath)); } package.SetVersion(frameworkAgentComponents.Version); package.Pack(); }
protected override void InternalBuild() { var targetFrameworkMoniker = "netstandard2.0"; var component = $@"{RepoRootDirectory}\src\AwsLambda\AwsLambdaOpenTracer\bin\{Configuration}\{targetFrameworkMoniker}-ILRepacked\NewRelic.OpenTracing.AmazonLambda.Tracer.dll"; var package = new NugetPackage(StagingDirectory, OutputDirectory); package.CopyAll($@"{PackageDirectory}"); package.CopyToLib(component, "netstandard2.0"); package.SetVersionFromDll(component); package.Pack(); }
public void NullNugetPackages_AreSortedFirst() { var nugetPackage = new NugetPackage { Name = "Package1", Version = "1.2.3", }; // cast null as string to flex CompareTo(object obj) and CompareTo(NugetPackage other) Assert.Equal(1, nugetPackage.CompareTo((string)null)); }
public void NullNugetPackage_IsNotEqual() { var nugetPackage1 = new NugetPackage { Name = "Package", Version = "1.2.3", }; // cast null as string to flex Equals(object obj) and Equals(NugetPackage other) Assert.False(nugetPackage1.Equals((string)null)); }
public MockGenerator MockPackageInfo() { var packageId = Path.GetFileNameWithoutExtension(NupkgFile); NugetPackage.Setup(x => x.GetSupportedFrameworks()).Returns(PackageFrameworks); NugetPackage.Setup(x => x.Id).Returns(packageId); NugetPackage.Setup(x => x.Version).Returns(new SemanticVersion("1.0.0.0")); NugetPackage.Setup(x => x.PackageAssemblyReferences).Returns(new List <PackageReferenceSet>()); return(this); }
protected override void InternalBuild() { var version = ReadVersionFromFile(); var package = new NugetPackage(StagingDirectory, OutputDirectory); package.CopyAll($@"{PackageDirectory}"); package.CopyToContent($@"{RepoRootDirectory}\build\NewRelic.NuGetHelper\bin\NewRelic.NuGetHelper.dll"); package.CopyToContent($@"{RepoRootDirectory}\build\NewRelic.NuGetHelper\bin\NuGet.Core.dll"); package.CopyToContent($@"{RepoRootDirectory}\build\NewRelic.NuGetHelper\bin\Microsoft.Web.XmlTransform.dll"); package.SetVersion(version); package.Pack(); }
public void VersionComparison(string smallerVersion, string greaterVersion) { var smallerPackage = new NugetPackage { Id = "TestPackage", Version = smallerVersion }; var greaterPackage = new NugetPackage { Id = "TestPackage", Version = greaterVersion }; Assert.IsTrue(smallerPackage.CompareTo(greaterPackage) < 0, "{0} was NOT smaller than {1}", smallerVersion, greaterVersion); Assert.IsTrue(greaterPackage.CompareTo(smallerPackage) > 0, "{0} was NOT greater than {1}", greaterVersion, smallerVersion); }
public HashSet <NugetPackage> GetNugetPackages(string projectAssetsFilePath, bool isTestProject) { var packages = new HashSet <NugetPackage>(); if (_fileSystem.File.Exists(projectAssetsFilePath)) { var assetFileReader = new AssetFileReader(); var assetsFile = assetFileReader.Read(projectAssetsFilePath); foreach (var targetRuntime in assetsFile.Targets) { foreach (var library in targetRuntime.Libraries) { if (library.Type != "project") { var package = new NugetPackage { Name = library.Name, Version = library.Version.ToNormalizedString(), Scope = Component.ComponentScope.Required, Dependencies = new Dictionary <string, string>(), }; // is this a test project dependency or only a development dependency if ( isTestProject || ( library.CompileTimeAssemblies.Count == 0 && library.ContentFiles.Count == 0 && library.EmbedAssemblies.Count == 0 && library.FrameworkAssemblies.Count == 0 && library.NativeLibraries.Count == 0 && library.ResourceAssemblies.Count == 0 && library.ToolsAssemblies.Count == 0 ) ) { package.Scope = Component.ComponentScope.Excluded; } // include direct dependencies foreach (var dep in library.Dependencies) { //Get the version from the nuget package as described here: https://github.com/NuGet/NuGet.Client/blob/ad81306fe7ada265cf44afb2a60a31fbfca978a2/src/NuGet.Core/NuGet.ProjectModel/JsonUtility.cs#L54 package.Dependencies.Add(dep.Id, dep.VersionRange?.ToLegacyShortString()); } packages.Add(package); } } } } return(packages); }
/// <summary> /// Analyzes a single Project file for NuGet package references. /// </summary> /// <param name="projectFilePath"></param> /// <returns></returns> public async Task <HashSet <NugetPackage> > GetProjectNugetPackagesAsync(string projectFilePath) { if (!_fileSystem.File.Exists(projectFilePath)) { Console.Error.WriteLine($"Project file \"{projectFilePath}\" does not exist"); return(new HashSet <NugetPackage>()); } Console.WriteLine(); Console.WriteLine($"» Analyzing: {projectFilePath}"); Console.WriteLine(" Getting packages"); var packages = new HashSet <NugetPackage>(); using (StreamReader fileReader = _fileSystem.File.OpenText(projectFilePath)) { using (XmlReader reader = XmlReader.Create(fileReader, _xmlReaderSettings)) { while (await reader.ReadAsync()) { if (reader.IsStartElement() && reader.Name == "PackageReference") { var package = new NugetPackage { Name = reader["Include"], Version = reader["Version"], }; if (!string.IsNullOrEmpty(package.Name) && !string.IsNullOrEmpty(package.Version)) { packages.Add(package); } } } } } // if there are no project file package references look for a packages.config if (!packages.Any()) { Console.WriteLine(" No packages found"); var directoryPath = _fileSystem.Path.GetDirectoryName(projectFilePath); var packagesPath = _fileSystem.Path.Combine(directoryPath, "packages.config"); if (_fileSystem.File.Exists(packagesPath)) { Console.WriteLine(" Found packages.config. Will attempt to process"); packages = await _packagesFileService.GetNugetPackagesAsync(packagesPath); } } return(packages); }
public void SameNugetPackageVersions_AreEqual() { var nugetPackage1 = new NugetPackage { Name = "Package", Version = "1.2.3", }; var nugetPackage2 = new NugetPackage { Name = "Package", Version = "1.2.3", }; Assert.True(nugetPackage1.Equals((object)nugetPackage2)); }
public void DifferentNugetPackages_WithSameVersions_AreNotEqual() { var nugetPackage1 = new NugetPackage { Name = "Package1", Version = "1.2.3", }; var nugetPackage2 = new NugetPackage { Name = "Package2", Version = "1.2.3", }; Assert.False(nugetPackage1.Equals((object)nugetPackage2)); }
public void NugetPackages_AreSortedByName() { var nugetPackage1 = new NugetPackage { Name = "Package1", Version = "1.2.3", }; var nugetPackage2 = new NugetPackage { Name = "Package2", Version = "1.2.3", }; Assert.Equal(-1, nugetPackage1.CompareTo(nugetPackage2)); }
private static void AddReferencesToNugetPackages(string solutionFolder) { var packageFolders = Directory.GetDirectories(solutionFolder + "/packages/"); var packages = new List<NugetPackage>(); foreach (var packageFolder in packageFolders) { var pattern = new Regex(@"(.+)\.(\d+\.\d+\.\d+.*)"); var captureGroups = pattern.Matches(packageFolder).GetEnumerator().Current as Match; // There can only be one var name = captureGroups.Groups[1].Value; var version = captureGroups.Groups[2].Value; var libFolder = packageFolder + "/lib/net45/"; var dllNames = Directory.GetFiles(libFolder).Where(f => f.EndsWith(".dll")).Select(Path.GetFileNameWithoutExtension); var package = new NugetPackage() { Name = name, Version = version, DllNames = dllNames.ToList() }; } }
private void DrawPackage(NugetPackage package) { if (package.Dependencies != null && package.Dependencies.Count > 0) { expanded[package] = EditorGUILayout.Foldout(expanded[package], string.Format("{0} {1}", package.Id, package.Version)); if (expanded[package]) { EditorGUI.indentLevel++; foreach (NugetPackageIdentifier dependency in package.Dependencies) { DrawDepencency(dependency); } EditorGUI.indentLevel--; } } else { EditorGUILayout.LabelField(string.Format("{0} {1}", package.Id, package.Version)); } }
/// <summary> /// Installs the given package. /// </summary> /// <param name="package">The package to install.</param> /// <param name="refreshAssets">True to refresh the Unity asset database. False to ignore the changes (temporarily).</param> public static void Install(NugetPackage package, bool refreshAssets = true) { try { LogVerbose("Installing: {0} {1}", package.Id, package.Version); // update packages.config PackagesConfigFile.AddPackage(package); PackagesConfigFile.Save(PackagesConfigFilePath); if (refreshAssets) EditorUtility.DisplayProgressBar(string.Format("Installing {0} {1}", package.Id, package.Version), "Installing Dependencies", 0.1f); foreach (var dependency in package.Dependencies) { LogVerbose("Installing Dependency: {0} {1}", dependency.Id, dependency.Version); InstallIdentifier(dependency); } // look to see if the package (any version) is already installed foreach (var installedPackage in installedPackages) { if (installedPackage.Id == package.Id) { if (installedPackage < package) { LogVerbose("{0} {1} is installed, but need {2} or greater. Updating to {3}", installedPackage.Id, installedPackage.Version, package.Version, package.Version); Update(installedPackage, package, false); } else if (installedPackage > package) { LogVerbose("{0} {1} is installed. {2} or greater is needed, so using installed version.", installedPackage.Id, installedPackage.Version, package.Version); } else { LogVerbose("Already installed: {0} {1}", package.Id, package.Version); } return; } } string cachedPackagePath = Path.Combine(PackOutputDirectory, string.Format("./{0}.{1}.nupkg", package.Id, package.Version)); if (NugetConfigFile.InstallFromCache && File.Exists(cachedPackagePath)) { LogVerbose("Cached package found for {0} {1}", package.Id, package.Version); } else { if (package.PackageSource.IsLocalPath) { LogVerbose("Caching local package {0} {1}", package.Id, package.Version); // copy the .nupkg from the local path to the cache File.Copy(Path.Combine(package.PackageSource.Path, string.Format("./{0}.{1}.nupkg", package.Id, package.Version)), cachedPackagePath, true); } else { // Mono doesn't have a Certificate Authority, so we have to provide all validation manually. Currently just accept anything. // See here: http://stackoverflow.com/questions/4926676/mono-webrequest-fails-with-https // remove all handlers //if (ServicePointManager.ServerCertificateValidationCallback != null) // foreach (var d in ServicePointManager.ServerCertificateValidationCallback.GetInvocationList()) // ServicePointManager.ServerCertificateValidationCallback -= (d as System.Net.Security.RemoteCertificateValidationCallback); ServicePointManager.ServerCertificateValidationCallback = null; // add anonymous handler ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, policyErrors) => true; LogVerbose("Downloading package {0} {1}", package.Id, package.Version); if (refreshAssets) EditorUtility.DisplayProgressBar(string.Format("Installing {0} {1}", package.Id, package.Version), "Downloading Package", 0.3f); HttpWebRequest getRequest = (HttpWebRequest)WebRequest.Create(package.DownloadUrl); Stream objStream = getRequest.GetResponse().GetResponseStream(); using (Stream file = File.Create(cachedPackagePath)) { CopyStream(objStream, file); } } } if (refreshAssets) EditorUtility.DisplayProgressBar(string.Format("Installing {0} {1}", package.Id, package.Version), "Extracting Package", 0.6f); if (File.Exists(cachedPackagePath)) { // unzip the package using (ZipFile zip = ZipFile.Read(cachedPackagePath)) { foreach (ZipEntry entry in zip) { entry.Extract(Path.Combine(NugetConfigFile.RepositoryPath, string.Format("{0}.{1}", package.Id, package.Version)), ExtractExistingFileAction.OverwriteSilently); } } // copy the .nupkg inside the Unity project File.Copy(cachedPackagePath, Path.Combine(NugetConfigFile.RepositoryPath, string.Format("{0}.{1}/{0}.{1}.nupkg", package.Id, package.Version)), true); } else { Debug.LogErrorFormat("File not found: {0}", cachedPackagePath); } if (refreshAssets) EditorUtility.DisplayProgressBar(string.Format("Installing {0} {1}", package.Id, package.Version), "Cleaning Package", 0.9f); // clean Clean(package); // update the installed packages list installedPackages.Add(package); } catch (Exception e) { Debug.LogErrorFormat("{0}", e.ToString()); } finally { if (refreshAssets) { EditorUtility.DisplayProgressBar(string.Format("Installing {0} {1}", package.Id, package.Version), "Importing Package", 0.95f); AssetDatabase.Refresh(); EditorUtility.ClearProgressBar(); } } }
/// <summary> /// Draws the given <see cref="NugetPackage"/>. /// </summary> /// <param name="package">The <see cref="NugetPackage"/> to draw.</param> private void DrawPackage(NugetPackage package) { EditorGUILayout.BeginHorizontal(); { // The Unity GUI system (in the Editor) is terrible. This probably requires some explanation. // Every time you use a Horizontal block, Unity appears to divide the space evenly. // (i.e. 2 components have half of the window width, 3 components have a third of the window width, etc) // GUILayoutUtility.GetRect is SUPPOSED to return a rect with the given height and width, but in the GUI layout. It doesn't. // We have to use GUILayoutUtility to get SOME rect properties, but then manually calculate others. EditorGUILayout.BeginHorizontal(); { const int iconSize = 32; const int leftPadding = 5; Rect rect = GUILayoutUtility.GetRect(iconSize, iconSize); // only use GetRect's Y position. It doesn't correctly set the width or X position. rect.x = leftPadding; rect.y += 3; rect.width = iconSize; rect.height = iconSize; if (package.Icon != null) { GUI.DrawTexture(rect, package.Icon, ScaleMode.StretchToFill); } else { GUI.DrawTexture(rect, defaultIcon, ScaleMode.StretchToFill); } rect = GUILayoutUtility.GetRect(position.width / 2 - (iconSize + leftPadding), 20); rect.x = iconSize + leftPadding; rect.y += 10; EditorStyles.label.fontStyle = FontStyle.Bold; EditorStyles.label.fontSize = 14; ////EditorGUILayout.LabelField(string.Format("{1} [{0}]", package.Version, package.Id), GUILayout.Height(20), GUILayout.Width(position.width / 2 - 32)); GUI.Label(rect, string.Format("{1} [{0}]", package.Version, package.Title), EditorStyles.label); EditorStyles.label.fontSize = 10; EditorStyles.label.fontStyle = FontStyle.Normal; } EditorGUILayout.EndHorizontal(); if (installedPackages.Contains(package)) { // This specific version is installed if (GUILayout.Button("Uninstall", installButtonWidth)) { // TODO: Perhaps use a "mark as dirty" system instead of updating all of the data all the time? NugetHelper.Uninstall(package); UpdateInstalledPackages(); UpdateUpdatePackages(); } } else { var installed = installedPackages.FirstOrDefault(p => p.Id == package.Id); if (installed != null) { if (installed < package) { // An older version is installed if (GUILayout.Button(string.Format("Update [{0}]", installed.Version), installButtonWidth)) { NugetHelper.Update(installed, package); UpdateInstalledPackages(); UpdateUpdatePackages(); } } else if (installed > package) { // A newer version is installed if (GUILayout.Button(string.Format("Downgrade [{0}]", installed.Version), installButtonWidth)) { NugetHelper.Update(installed, package); UpdateInstalledPackages(); UpdateUpdatePackages(); } } } else { if (GUILayout.Button("Install", installButtonWidth)) { NugetHelper.Install(package); AssetDatabase.Refresh(); UpdateInstalledPackages(); UpdateUpdatePackages(); } } } } EditorGUILayout.EndHorizontal(); // Show the package description EditorStyles.label.wordWrap = true; //EditorStyles.label.fontStyle = FontStyle.Bold; //EditorGUILayout.LabelField(string.Format("Description:")); EditorStyles.label.fontStyle = FontStyle.Normal; EditorGUILayout.LabelField(string.Format("{0}", package.Description)); // Show the package release notes if (!string.IsNullOrEmpty(package.ReleaseNotes)) { EditorStyles.label.wordWrap = true; EditorStyles.label.fontStyle = FontStyle.Bold; EditorGUILayout.LabelField(string.Format("Release Notes:")); EditorStyles.label.fontStyle = FontStyle.Normal; EditorGUILayout.LabelField(string.Format("{0}", package.ReleaseNotes)); } // Show the dependencies if (package.Dependencies.Count > 0) { EditorStyles.label.wordWrap = true; EditorStyles.label.fontStyle = FontStyle.Italic; StringBuilder builder = new StringBuilder(); foreach (var dependency in package.Dependencies) { builder.Append(string.Format(" {0} {1};", dependency.Id, dependency.Version)); } EditorGUILayout.Space(); EditorGUILayout.LabelField(string.Format("Depends on:{0}", builder.ToString())); EditorStyles.label.fontStyle = FontStyle.Normal; } // Show the license button if (!string.IsNullOrEmpty(package.LicenseUrl) && package.LicenseUrl != "http://your_license_url_here") { if (GUILayout.Button("View License", GUILayout.Width(120))) { Application.OpenURL(package.LicenseUrl); } } EditorGUILayout.Separator(); EditorGUILayout.Separator(); }
public override void Context() { repositoryMock = MockRepository.GenerateStub<IRepository>(); repository = new NugetPackageRepository(repositoryMock); expectedPackage = new NugetPackage(); }
public override void Because() { package = repository.FindOrCreate(0); }
/// <summary> /// Builds a list of NugetPackages from the XML returned from the HTTP GET request issued at the given URL. /// Note that NuGet uses an Atom-feed (XML Syndicaton) superset called OData. /// See here http://www.odata.org/documentation/odata-version-2-0/uri-conventions/ /// </summary> /// <param name="url"></param> /// <returns></returns> private List<NugetPackage> GetPackagesFromUrl(string url) { NugetHelper.LogVerbose("Getting packages from: {0}", url); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); HttpWebRequest getRequest = (HttpWebRequest)WebRequest.Create(url); getRequest.Timeout = 5000; getRequest.ReadWriteTimeout = 5000; Stream responseStream = getRequest.GetResponse().GetResponseStream(); StreamReader objReader = new StreamReader(responseStream); SyndicationFeed atomFeed = SyndicationFeed.Load(XmlReader.Create(objReader)); List<NugetPackage> packages = new List<NugetPackage>(); foreach (var item in atomFeed.Items) { var propertiesExtension = item.ElementExtensions.First(); var reader = propertiesExtension.GetReader(); var properties = (XElement)XDocument.ReadFrom(reader); NugetPackage package = new NugetPackage(); package.PackageSource = this; package.DownloadUrl = ((UrlSyndicationContent)item.Content).Url.ToString(); package.Id = item.Title.Text; package.Title = (string)properties.Element(XName.Get("Title", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty; package.Version = (string)properties.Element(XName.Get("Version", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty; package.Description = (string)properties.Element(XName.Get("Description", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty; package.ReleaseNotes = (string)properties.Element(XName.Get("ReleaseNotes", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty; package.LicenseUrl = (string)properties.Element(XName.Get("LicenseUrl", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty; string iconUrl = (string)properties.Element(XName.Get("IconUrl", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty; if (!string.IsNullOrEmpty(iconUrl)) { package.Icon = NugetHelper.DownloadImage(iconUrl); } // if there is no title, just use the ID as the title if (string.IsNullOrEmpty(package.Title)) { package.Title = package.Id; } // Get dependencies package.Dependencies = new List<NugetPackageIdentifier>(); string rawDependencies = (string)properties.Element(XName.Get("Dependencies", "http://schemas.microsoft.com/ado/2007/08/dataservices")) ?? string.Empty; if (!string.IsNullOrEmpty(rawDependencies)) { string[] dependencies = rawDependencies.Split('|'); foreach (var dependencyString in dependencies) { string[] details = dependencyString.Split(':'); string id = details[0]; string version = details[1]; string framework = string.Empty; if (details.Length > 2) { framework = details[2]; } // some packages (ex: FSharp.Data - 2.1.0) have inproper "semi-empty" dependencies such as: // "Zlib.Portable:1.10.0:portable-net40+sl50+wp80+win80|::net40" // so we need to only add valid dependencies and skip invalid ones if (!string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(version)) { // only use the dependency if there is no framework specified, or it is explicitly .NET 3.0 if (string.IsNullOrEmpty(framework) || framework == "net30") { NugetPackageIdentifier dependency = new NugetPackageIdentifier(id, version); package.Dependencies.Add(dependency); } } } } packages.Add(package); } stopwatch.Stop(); NugetHelper.LogVerbose("Retreived {0} packages in {1} ms", packages.Count, stopwatch.ElapsedMilliseconds); return packages; }
/// <summary> /// Updates a package by uninstalling the currently installed version and installing the "new" version. /// </summary> /// <param name="currentVersion">The current package to uninstall.</param> /// <param name="newVersion">The package to install.</param> /// <param name="refreshAssets">True to refresh the assets inside Unity. False to ignore them (for now). Defaults to true.</param> public static void Update(NugetPackageIdentifier currentVersion, NugetPackage newVersion, bool refreshAssets = true) { LogVerbose("Updating {0} {1} to {2}", currentVersion.Id, currentVersion.Version, newVersion.Version); Uninstall(currentVersion, false); Install(newVersion, refreshAssets); }