Beispiel #1
0
        private IReadOnlyList <DependencyGroupItem> GetDependencies(IPackageSearchMetadata package)
        {
            var groupItems = new List <DependencyGroupItem>();

            foreach (var set in package.DependencySets)
            {
                var item = new DependencyGroupItem
                {
                    TargetFramework = set.TargetFramework.Framework,
                    Dependencies    = new List <DependencyItem>()
                };

                foreach (var dependency in set.Packages)
                {
                    item.Dependencies.Add(new DependencyItem
                    {
                        Id    = dependency.Id,
                        Range = dependency.VersionRange.ToNormalizedString(),
                    });
                }

                groupItems.Add(item);
            }

            return(groupItems);
        }
        /// <summary>
        /// Parse the target framework as a <see cref="NuGetFramework" />.
        /// </summary>
        /// <param name="packageDependencyGroup">The package dependency group.</param>
        /// <returns>The framework.</returns>
        public static NuGetFramework ParseTargetFramework(this DependencyGroupItem packageDependencyGroup)
        {
            if (string.IsNullOrEmpty(packageDependencyGroup.TargetFramework))
            {
                return(NuGetFramework.AnyFramework);
            }

            return(NuGetFramework.Parse(packageDependencyGroup.TargetFramework));
        }
Beispiel #3
0
            private IReadOnlyList <DependencyGroupItem> ToDependencyItems(Package package)
            {
                List <DependencyGroupItem> groups = new List <DependencyGroupItem>();

                var targetFrameworks = package.Dependencies.Select(a => a.TargetFramework).Distinct();

                foreach (var tf in targetFrameworks)
                {
                    var depGroupId      = $"https://api.nuget.org/v3/catalog0/data/2015.02.01.06.24.15/{package.Id}.{package.Version}.json#dependencygroup/{tf}";
                    var dependencyItems = new List <DependencyItem>();
                    foreach (var dep in package.Dependencies.Where(a => a.TargetFramework == tf))
                    {
                        var depItem = new DependencyItem(depGroupId, dep.Id, dep.VersionRange);
                        dependencyItems.Add(depItem);
                    }
                    var groupItem = new DependencyGroupItem(depGroupId, tf, dependencyItems);

                    groups.Add(groupItem);
                }
                return(groups.Count > 0?groups.ToArray():null);
            }
Beispiel #4
0
        private IEnumerable <PackageDependency> FindDependenciesFromDependencyGroup(DependencyGroupItem group)
        {
            // BaGet stores a dependency group with no dependencies as a package dependency
            // with no package id nor package version.
            if ((group.Dependencies?.Count ?? 0) == 0)
            {
                return(new[]
                {
                    new PackageDependency
                    {
                        Id = null,
                        VersionRange = null,
                        TargetFramework = group.TargetFramework
                    }
                });
            }

            return(group.Dependencies.Select(d => new PackageDependency
            {
                Id = d.Id,
                VersionRange = d.Range,
                TargetFramework = group.TargetFramework
            }));
        }