示例#1
0
        static VersionRange GetVersionRange(PackageReferenceInfo package)
        {
            if (string.IsNullOrEmpty(package.VersionRange))
            {
                return(null);
            }

            return(VersionRange.Parse(package.VersionRange));
        }
示例#2
0
 static PackageReference CreatePackageReference(PackageReferenceInfo package)
 {
     return(new PackageReference(
                new PackageIdentity(package.Id, new NuGetVersion(package.Version)),
                NuGetFramework.Parse(package.TargetFramework),
                package.IsUserInstalled,
                package.IsDevelopmentDependency,
                package.RequireReinstallation,
                GetVersionRange(package)
                ));
 }
        private async Task LoadDependenciesAsync(PackageReferenceInfo entry, List <PackageReferenceInfo> packages, List <Task> tasks, IConsoleHost host)
        {
            var resource = await CreatePackageMetadataResourceAsync();

            try
            {
                var identity = new PackageIdentity(entry.Name, NuGetVersion.Parse(entry.Version));
                var result   = await resource.GetMetadataAsync(identity, new NullLogger(), CancellationToken.None);

                if (result != null)
                {
                    entry.LicenseUri = result.LicenseUrl;

                    if (IncludeTransitiveDependencies)
                    {
                        foreach (var dependentPackage in result.DependencySets.SelectMany(s => s.Packages))
                        {
                            lock (packages)
                            {
                                if (dependentPackage.Id != "NETStandard.Library" &&
                                    (!ExcludeSystem || !dependentPackage.Id.StartsWith("System.")) &&
                                    (!ExcludeMicrosoft || !dependentPackage.Id.StartsWith("Microsoft.")))
                                {
                                    var subEntry = packages.SingleOrDefault(p => p.Name == dependentPackage.Id &&
                                                                            p.Version == dependentPackage.VersionRange.MinVersion.ToFullString());

                                    if (subEntry == null)
                                    {
                                        var package = new PackageReferenceInfo {
                                            Name = dependentPackage.Id, Version = dependentPackage.VersionRange.MinVersion.ToFullString()
                                        };
                                        packages.Add(package);

                                        tasks.Add(LoadDependenciesAsync(package, packages, tasks, host));
                                    }
                                    else
                                    {
                                        subEntry.Count++;
                                    }
                                }
                            }
                        }
                    }
                }

                host.WriteMessage(".");
            }
            catch (Exception e)
            {
                host.WriteError(e + "\n");
            }
        }
示例#4
0
        private void LoadProjects(IConsoleHost host, List <PackageReferenceInfo> packages)
        {
            host.WriteMessage($"Loading projects ");

            var globalProperties = TryGetGlobalProperties();

            foreach (var projectPath in GetProjectPaths())
            {
                try
                {
                    using (var projectInformation = ProjectExtensions.LoadProject(projectPath, globalProperties))
                    {
                        foreach (var item in projectInformation.Project.Items.Where(i => i.ItemType == "PackageReference").ToList())
                        {
                            var packageName    = item.EvaluatedInclude;
                            var packageVersion = item.Metadata.SingleOrDefault(m => m.Name == "Version")?.EvaluatedValue ?? "Latest";

                            if (packageName != "NETStandard.Library" &&
                                (!ExcludeSystem || !packageName.StartsWith("System.")) &&
                                (!ExcludeMicrosoft || !packageName.StartsWith("Microsoft.")))
                            {
                                var entry = packages.SingleOrDefault(p => p.Name == packageName &&
                                                                     p.Version == packageVersion);

                                if (entry == null)
                                {
                                    entry = new PackageReferenceInfo {
                                        Name = packageName, Version = packageVersion, Type = "t"
                                    };
                                    packages.Add(entry);
                                }
                                else
                                {
                                    entry.Count++;
                                }

                                host.WriteMessage(".");
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    host.WriteError(e + "\n");
                }
            }

            host.WriteMessage($"\n");
        }
示例#5
0
        private bool IsAssemblyFromPackage(ParsedPath pathHint, PackageReferenceInfo package)
        {
            var ignoreCase = StringComparison.InvariantCultureIgnoreCase;
            var partText   = $"{package.PackageId}.{package.Version}";
            var partIndex  = pathHint.Parts
                             .TakeWhile(p => !p.Equals(partText, ignoreCase))
                             .Count();

            if (partIndex > 0 && partIndex < pathHint.Parts.Count - 1)
            {
                return(
                    pathHint.Parts[partIndex - 1].Equals("packages", ignoreCase) &&
                    pathHint.Parts[partIndex + 1].Equals("lib", ignoreCase));
            }

            return(false);
        }
        private static async Task LoadLicenseAsync(HttpClient httpClient, PackageReferenceInfo entry, IConsoleHost host)
        {
            try
            {
                if (entry.LicenseUri != null)
                {
                    var licenseUri = entry.LicenseUri?.ToString();
                    if (licenseUri?.Contains("apache.org") == true)
                    {
                        entry.License = "Apache";
                    }
                    if (licenseUri?.Contains("/LGPL-") == true)
                    {
                        entry.License = "LGPL";
                    }
                    if (licenseUri?.Contains("/GPL-") == true)
                    {
                        entry.License = "GPL";
                    }
                    else
                    {
                        var license = await httpClient.GetStringAsync(entry.LicenseUri);

                        if (license.Contains("www.apache.org"))
                        {
                            entry.License = "Apache";
                        }
                        else if (license.Contains("Lesser General Public License"))
                        {
                            entry.License = "LGPL";
                        }
                        else if (license.Contains("General Public License"))
                        {
                            entry.License = "GPL";
                        }
                        else
                        {
                            var n = "";

                            n = string.IsNullOrWhiteSpace(n) ?
                                Regex.Matches(license, "^\\s*([^><*]{1,20}[a-zA-Z] License)", RegexOptions.Multiline)
                                .OfType <Match>().FirstOrDefault(m => !m.Groups[1].Value.Contains("the License"))?.Groups[1].Value : n;
                            n = string.IsNullOrWhiteSpace(n) ?
                                Regex.Matches(license, ">\\s*([^><*]{1,20}[a-zA-Z] License)", RegexOptions.Multiline)
                                .OfType <Match>().FirstOrDefault(m => !m.Groups[1].Value.Contains("the License"))?.Groups[1].Value : n;
                            n = string.IsNullOrWhiteSpace(n) ?
                                Regex.Matches(license, "\n\\s*([^><*]{1,20}[a-zA-Z] License)", RegexOptions.Multiline)
                                .OfType <Match>().FirstOrDefault(m => !m.Groups[1].Value.Contains("the License"))?.Groups[1].Value : n;

                            n = n ?? "";

                            entry.License = n
                                            .Trim('\r', '\n', ' ', '?')
                                            .Replace("The ", string.Empty)
                                            .Replace(" License", string.Empty);
                        }
                    }

                    host.WriteMessage(".");
                }
            }
            catch (Exception e)
            {
                host.WriteError(e + "\n");
            }
        }