Reverse Dependencies

Reverse Dependencies.jl

using Pkg.TOML: parsefile
using Base.Iterators: flatten

pkgs = ((d for d in readdir(dir) if occursin(r"^[(aA-zZ|0-9)]+$", d))
           for dir in joinpath.(first(DEPOT_PATH),"registries","General", string.('A':'Z'))) |>
       flatten |>
       collect

"""
    cap(v::AbstractString)

    Return the upper bound of a semver.
"""
function cap(v::AbstractString)
    ver = VersionNumber(v)
    if occursin(r"^\d+$", v)
        output = VersionNumber(ver.major + one(ver.major))
    elseif occursin(r"^\d+\.\d+$", v)
        output = VersionNumber(ver.major, ver.minor + one(ver.minor))
    else
        output = VersionNumber(ver.major, ver.minor, ver.patch + one(ver.patch))
    end
    return output
end

"""
    find_dependencies(pkg::AbstractString,
                      version::Union{VersionNumber,Nothing} = nothing;
                      pkgs::AbstractVector{<:AbstractString} = Vector{String}())

    Return the registered dependencies for a package.
    If the version is not specified, it defaults to the latest one.
    `pkgs` is a list of registered packages to restrict the dependencies.
"""
function find_dependencies(pkg::AbstractString,
                           version::Union{VersionNumber,Nothing} = nothing;
                           pkgs = Vector{String}())
    letter = uppercase(pkg[1:1])
    if isa(version, Nothing)
        version = parsefile(joinpath(first(DEPOT_PATH),
                                     "registries",
                                     "General",
                                     letter,
                                     pkg,
                                     "Versions.toml")) |>
                  keys |>
                  maximum |>
                  VersionNumber
    end
    dir = joinpath(first(DEPOT_PATH),
                                 "registries",
                                 "General",
                                 letter,
                                 pkg)
    if "Deps.toml" ∈ readdir(dir)
        deps = parsefile(joinpath(first(DEPOT_PATH),
                                  "registries",
                                  "General",
                                  letter,
                                  pkg,
                                  "Deps.toml"))
        output = (keys(v) for (k, v) in deps if version < cap(getfield(match(r"\d+\.*\d*\.*\d*$", k), :match))) |>
                 Iterators.flatten |>
                 collect
        isempty(pkgs) || filter!(dep -> dep ∈ pkgs, output)
    else
        output = Vector{String}()
    end
    return output
end

deps = filter!(x -> "StatsModels" ∈ last(x), [(pkg, find_dependencies(pkg, pkgs = pkgs)) for pkg in pkgs])
println(first.(deps))

end