From 7b140ee1ec750fe2611473a4117db5d532da64d3 Mon Sep 17 00:00:00 2001 From: Kristoffer Carlsson Date: Mon, 6 Aug 2018 11:03:12 +0100 Subject: [PATCH] delete OldPkg (#27930) --- .circleci/config.yml | 2 +- .freebsdci.sh | 2 +- .travis.yml | 2 +- appveyor.yml | 2 +- base/sysimg.jl | 1 - contrib/precompile_explicit.jl | 2 - doc/src/manual/environment-variables.md | 5 - stdlib/InteractiveUtils/test/runtests.jl | 14 +- stdlib/OldPkg/Project.toml | 12 - stdlib/OldPkg/src/OldPkg.jl | 311 --- stdlib/OldPkg/src/cache.jl | 94 - stdlib/OldPkg/src/dir.jl | 82 - stdlib/OldPkg/src/entry.jl | 770 ------ stdlib/OldPkg/src/query.jl | 590 ---- stdlib/OldPkg/src/read.jl | 255 -- stdlib/OldPkg/src/reqs.jl | 146 - stdlib/OldPkg/src/resolve.jl | 166 -- stdlib/OldPkg/src/resolve/fieldvalue.jl | 128 - stdlib/OldPkg/src/resolve/interface.jl | 364 --- stdlib/OldPkg/src/resolve/maxsum.jl | 524 ---- stdlib/OldPkg/src/resolve/versionweight.jl | 228 -- stdlib/OldPkg/src/types.jl | 258 -- stdlib/OldPkg/src/write.jl | 65 - stdlib/OldPkg/test/pkg.jl | 734 ----- stdlib/OldPkg/test/resolve.jl | 548 ---- stdlib/OldPkg/test/resolvedata1.jl | 2853 -------------------- stdlib/OldPkg/test/runtests.jl | 4 - stdlib/OldPkg/test/testgroups | 2 - stdlib/Pkg/bin/gitmeta.jl | 1 - stdlib/Pkg/bin/stdlib.toml | 1 - stdlib/REPL/test/replcompletions.jl | 51 - test/choosetests.jl | 2 - test/precompile.jl | 2 +- 33 files changed, 10 insertions(+), 8211 deletions(-) delete mode 100644 stdlib/OldPkg/Project.toml delete mode 100644 stdlib/OldPkg/src/OldPkg.jl delete mode 100644 stdlib/OldPkg/src/cache.jl delete mode 100644 stdlib/OldPkg/src/dir.jl delete mode 100644 stdlib/OldPkg/src/entry.jl delete mode 100644 stdlib/OldPkg/src/query.jl delete mode 100644 stdlib/OldPkg/src/read.jl delete mode 100644 stdlib/OldPkg/src/reqs.jl delete mode 100644 stdlib/OldPkg/src/resolve.jl delete mode 100644 stdlib/OldPkg/src/resolve/fieldvalue.jl delete mode 100644 stdlib/OldPkg/src/resolve/interface.jl delete mode 100644 stdlib/OldPkg/src/resolve/maxsum.jl delete mode 100644 stdlib/OldPkg/src/resolve/versionweight.jl delete mode 100644 stdlib/OldPkg/src/types.jl delete mode 100644 stdlib/OldPkg/src/write.jl delete mode 100644 stdlib/OldPkg/test/pkg.jl delete mode 100644 stdlib/OldPkg/test/resolve.jl delete mode 100644 stdlib/OldPkg/test/resolvedata1.jl delete mode 100644 stdlib/OldPkg/test/runtests.jl delete mode 100644 stdlib/OldPkg/test/testgroups diff --git a/.circleci/config.yml b/.circleci/config.yml index b91b57d9487be..e3506ac4e4024 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -59,7 +59,7 @@ jobs: pushd /tmp/julia/share/julia/test && if [ $(echo "$FILES_CHANGED" | grep -cv '^doc/') -gt 0 ]; then /tmp/julia/bin/julia --check-bounds=yes runtests.jl all --skip Sockets | bar -i 30 && - /tmp/julia/bin/julia --check-bounds=yes runtests.jl LibGit2/online OldPkg/pkg Pkg/pkg download; + /tmp/julia/bin/julia --check-bounds=yes runtests.jl LibGit2/online Pkg/pkg download; fi && popd && mkdir /tmp/embedding-test && diff --git a/.freebsdci.sh b/.freebsdci.sh index 436d883f80d3a..399ba8e92db2d 100755 --- a/.freebsdci.sh +++ b/.freebsdci.sh @@ -45,7 +45,7 @@ runtests(){ ./usr/bin/julia --check-bounds=yes test/runtests.jl all ./usr/bin/julia --check-bounds=yes test/runtests.jl \ - LibGit2/online OldPkg/pkg Pkg/pkg download + LibGit2/online Pkg/pkg download } test-embedding(){ diff --git a/.travis.yml b/.travis.yml index bad194ae2321b..322ff5c8fd21e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -134,7 +134,7 @@ script: # skip tests if only files within the "doc" dir have changed - if [ $(echo "$FILES_CHANGED" | grep -cv '^doc/') -gt 0 ]; then /tmp/julia/bin/julia --check-bounds=yes runtests.jl $TESTSTORUN && - /tmp/julia/bin/julia --check-bounds=yes runtests.jl LibGit2/online OldPkg/pkg Pkg/pkg download; fi + /tmp/julia/bin/julia --check-bounds=yes runtests.jl LibGit2/online Pkg/pkg download; fi - popd # test that the embedding code works on our installation - mkdir /tmp/embedding-test && diff --git a/appveyor.yml b/appveyor.yml index d64bc6f8b8211..7894b226de2db 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -63,6 +63,6 @@ test_script: - usr\bin\julia -e "Base.require(Main, :InteractiveUtils).versioninfo()" - usr\bin\julia --sysimage-native-code=no -e "true" - cd julia-* && .\bin\julia.exe --check-bounds=yes share\julia\test\runtests.jl all && - .\bin\julia.exe --check-bounds=yes share\julia\test\runtests.jl LibGit2/online OldPkg/pkg Pkg/pkg download + .\bin\julia.exe --check-bounds=yes share\julia\test\runtests.jl LibGit2/online Pkg/pkg download - cd .. - usr\bin\julia usr\share\julia\test\embedding\embedding-test.jl test\embedding\embedding.exe diff --git a/base/sysimg.jl b/base/sysimg.jl index fe3695c5609ff..5cf47c9d6967f 100644 --- a/base/sysimg.jl +++ b/base/sysimg.jl @@ -515,7 +515,6 @@ let :Random, :UUIDs, :Future, - :OldPkg, :LinearAlgebra, :SparseArrays, :SuiteSparse, diff --git a/contrib/precompile_explicit.jl b/contrib/precompile_explicit.jl index f0d83e491b7eb..38e581415cdc6 100644 --- a/contrib/precompile_explicit.jl +++ b/contrib/precompile_explicit.jl @@ -451,7 +451,6 @@ precompile(Tuple{typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, UInt6 precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Array{Any, 1}}) precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Int64}) precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, String}) -precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, typeof(OldPkg.dir)}) precompile(Tuple{typeof(Base.show), Base.IOContext{REPL.Terminals.TTYTerminal}, Base.MIME{Symbol("text/plain")}, Array{Float64, 1}}) precompile(Tuple{typeof(Base.show), Base.IOContext{REPL.Terminals.TTYTerminal}, Base.MIME{Symbol("text/plain")}, Array{Float64, 2}}) precompile(Tuple{typeof(Base.show), Base.IOContext{REPL.Terminals.TTYTerminal}, Base.MIME{Symbol("text/plain")}, Array{Int64, 1}}) @@ -606,7 +605,6 @@ precompile(Tuple{typeof(Markdown.terminline), Base.IOContext{Base.GenericIOBuffe precompile(Tuple{typeof(Markdown.terminline), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, String}) precompile(Tuple{typeof(Markdown.terminline_string), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Array{Any, 1}}) precompile(Tuple{typeof(Markdown.terminline_string), Base.IOContext{REPL.Terminals.TTYTerminal}, Array{Any, 1}}) -precompile(Tuple{typeof(OldPkg.dir)}) precompile(Tuple{typeof(Pkg.REPLMode.create_mode), REPL.LineEditREPL, REPL.LineEdit.Prompt}) precompile(Tuple{typeof(Pkg.REPLMode.repl_init), REPL.LineEditREPL}) precompile(Tuple{typeof(REPL.LineEdit.accept_result), REPL.LineEdit.MIState, REPL.LineEdit.PrefixHistoryPrompt}) diff --git a/doc/src/manual/environment-variables.md b/doc/src/manual/environment-variables.md index 853dd77179531..b27ff27729afc 100644 --- a/doc/src/manual/environment-variables.md +++ b/doc/src/manual/environment-variables.md @@ -121,11 +121,6 @@ over `$EDITOR`. If none of these environment variables is set, then the editor is taken to be `open` on Windows and OS X, or `/etc/alternatives/editor` if it exists, or `emacs` otherwise. -!!! note - - `$JULIA_EDITOR` is *not* used in the determination of the editor for - `OldPkg.edit`: this function checks `$VISUAL` and `$EDITOR` alone. - ## Parallelization ### `JULIA_CPU_THREADS` diff --git a/stdlib/InteractiveUtils/test/runtests.jl b/stdlib/InteractiveUtils/test/runtests.jl index 7c2148d9526e0..68cb9f7dc984b 100644 --- a/stdlib/InteractiveUtils/test/runtests.jl +++ b/stdlib/InteractiveUtils/test/runtests.jl @@ -175,16 +175,12 @@ end # PR #23075 @testset "versioninfo" begin # check that versioninfo(io; verbose=true) doesn't error, produces some output - # and doesn't invoke OldPkg.status which will error if JULIA_PKGDIR is set mktempdir() do dir - withenv("JULIA_PKGDIR" => dir) do - buf = PipeBuffer() - versioninfo(buf, verbose=true) - ver = read(buf, String) - @test startswith(ver, "Julia Version $VERSION") - @test occursin("Environment:", ver) - @test isempty(readdir(dir)) - end + buf = PipeBuffer() + versioninfo(buf, verbose=true) + ver = read(buf, String) + @test startswith(ver, "Julia Version $VERSION") + @test occursin("Environment:", ver) end let exename = `$(Base.julia_cmd()) --startup-file=no` @test !occursin("Environment:", read(setenv(`$exename -e 'using InteractiveUtils; versioninfo()'`, diff --git a/stdlib/OldPkg/Project.toml b/stdlib/OldPkg/Project.toml deleted file mode 100644 index c1244e2016d2f..0000000000000 --- a/stdlib/OldPkg/Project.toml +++ /dev/null @@ -1,12 +0,0 @@ -name = "OldPkg" -uuid = "fe1c5a76-5840-53d2-82f9-288dd83ce2ce" - -[deps] -LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433" - -[extras] -Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" -Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" - -[targets] -test = ["Test", "Random"] diff --git a/stdlib/OldPkg/src/OldPkg.jl b/stdlib/OldPkg/src/OldPkg.jl deleted file mode 100644 index 23c1670a53737..0000000000000 --- a/stdlib/OldPkg/src/OldPkg.jl +++ /dev/null @@ -1,311 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -""" - OldPkg - -The `OldPkg` module provides package management for Julia. -Use -`OldPkg.status()` for a list of installed packages, -`OldPkg.add("")` to add a package, -`OldPkg.update()` to update the installed packages. - -Please see the manual section on packages for more information. -""" -module OldPkg - -export Dir, Types, Reqs, Cache, Read, Query, Resolve, Write, Entry -export dir, init, add, available, installed, status, clone, checkout, - update, resolve, test, build, free, pin, PkgError, setprotocol! - -const DEFAULT_META = "https://github.com/JuliaLang/METADATA.jl" -const META_BRANCH = "metadata-v2" - -struct PkgError <: Exception - msg::AbstractString - ex::Union{Exception, Nothing} -end -PkgError(msg::AbstractString) = PkgError(msg, nothing) -function Base.showerror(io::IO, pkgerr::PkgError) - print(io, pkgerr.msg) - if pkgerr.ex !== nothing - pkgex = pkgerr.ex - if isa(pkgex, CompositeException) - for cex in pkgex - print(io, "\n=> ") - showerror(io, cex) - end - else - print(io, "\n") - showerror(io, pkgex) - end - end -end - -for file in split("dir types reqs cache read query resolve write entry") - include("$file.jl") -end -const cd = Dir.cd - -dir(path...) = Dir.path(path...) - -# remove extension .jl -const PKGEXT = ".jl" -splitjl(pkg::AbstractString) = endswith(pkg, PKGEXT) ? pkg[1:(end-length(PKGEXT))] : pkg - -""" - dir() -> AbstractString - -Returns the absolute path of the package directory. This defaults to -`joinpath(homedir(),".julia","v\$(VERSION.major).\$(VERSION.minor)")` on all platforms (i.e. -`~/.julia/v$(VERSION.major).$(VERSION.minor)` in UNIX shell syntax). If the `JULIA_PKGDIR` -environment variable is set, then that path is used in the returned value as -`joinpath(ENV["JULIA_PKGDIR"],"v\$(VERSION.major).\$(VERSION.minor)")`. If `JULIA_PKGDIR` is -a relative path, it is interpreted relative to whatever the current working directory is. -""" -dir() - -""" - dir(names...) -> AbstractString - -Equivalent to `normpath(OldPkg.dir(),names...)` – i.e. it appends path components to the -package directory and normalizes the resulting path. In particular, `OldPkg.dir(pkg)` returns -the path to the package `pkg`. -""" -dir(names...) - -""" - init(meta::AbstractString=DEFAULT_META, branch::AbstractString=META_BRANCH) - -Initialize `OldPkg.dir()` as a package directory. This will be done automatically when the -`JULIA_PKGDIR` is not set and `OldPkg.dir()` uses its default value. As part of this process, -clones a local METADATA git repository from the site and branch specified by its arguments, -which are typically not provided. Explicit (non-default) arguments can be used to support a -custom METADATA setup. -""" -init(meta::AbstractString=DEFAULT_META, branch::AbstractString=META_BRANCH) = Dir.init(meta,branch) - -""" - edit() - -Opens `OldPkg.dir("REQUIRE")` in the editor specified by the `VISUAL` or `EDITOR` environment -variables; when the editor command returns, it runs `OldPkg.resolve()` to determine and install -a new optimal set of installed package versions. -""" -edit() = cd(Entry.edit) - -""" - rm(pkg) - -Remove all requirement entries for `pkg` from `OldPkg.dir("REQUIRE")` and call `OldPkg.resolve()`. -""" -rm(pkg::AbstractString) = cd(Entry.rm,splitjl(pkg)) - -""" - add(pkg, vers...) - -Add a requirement entry for `pkg` to `OldPkg.dir("REQUIRE")` and call `OldPkg.resolve()`. If -`vers` are given, they must be `VersionNumber` objects and they specify acceptable version -intervals for `pkg`. -""" -add(pkg::AbstractString, vers::VersionNumber...) = cd(Entry.add,splitjl(pkg),vers...) - -""" - available() -> Vector{String} - -Returns the names of available packages. -""" -available() = cd(Entry.available) - -""" - available(pkg) -> Vector{VersionNumber} - -Returns the version numbers available for package `pkg`. -""" -available(pkg::AbstractString) = cd(Entry.available,splitjl(pkg)) - -""" - installed() -> Dict{String,VersionNumber} - -Returns a dictionary mapping installed package names to the installed version number of each -package. -""" -installed() = cd(Entry.installed) - -""" - installed(pkg) -> Nothing | VersionNumber - -If `pkg` is installed, return the installed version number. If `pkg` is registered, -but not installed, return `nothing`. -""" -installed(pkg::AbstractString) = cd(Entry.installed,splitjl(pkg)) - -""" - status() - -Prints out a summary of what packages are installed and what version and state they're in. -""" -status(io::IO=stdout) = cd(Entry.status,io) - -""" - status(pkg) - -Prints out a summary of what version and state `pkg`, specifically, is in. -""" -status(pkg::AbstractString, io::IO=stdout) = cd(Entry.status,io,splitjl(pkg)) - -""" - clone(pkg) - -If `pkg` has a URL registered in `OldPkg.dir("METADATA")`, clone it from that URL on the -default branch. The package does not need to have any registered versions. -""" -clone(url_or_pkg::AbstractString) = cd(Entry.clone,url_or_pkg) - -""" - clone(url, [pkg]) - -Clone a package directly from the git URL `url`. The package does not need to be registered -in `OldPkg.dir("METADATA")`. The package repo is cloned by the name `pkg` if provided; if not -provided, `pkg` is determined automatically from `url`. -""" -clone(url::AbstractString, pkg::AbstractString) = cd(Entry.clone,url,splitjl(pkg)) - -""" - checkout(pkg, [branch="master"]; merge=true, pull=true) - -Checkout the `OldPkg.dir(pkg)` repo to the branch `branch`. Defaults to checking out the -"master" branch. To go back to using the newest compatible released version, use -`OldPkg.free(pkg)`. Changes are merged (fast-forward only) if the keyword argument `merge == -true`, and the latest version is pulled from the upstream repo if `pull == true`. -""" -checkout(pkg::AbstractString, branch::AbstractString="master"; merge::Bool=true, pull::Bool=true) = - cd(Entry.checkout,splitjl(pkg),branch,merge,pull) - -""" - free(pkg) - -Free the package `pkg` to be managed by the package manager again. It calls `OldPkg.resolve()` -to determine optimal package versions after. This is an inverse for both `OldPkg.checkout` and -`OldPkg.pin`. - -You can also supply an iterable collection of package names, e.g., `OldPkg.free(("Pkg1", -"Pkg2"))` to free multiple packages at once. -""" -free(pkg) = cd(Entry.free,splitjl.(pkg)) - -""" - pin(pkg) - -Pin `pkg` at the current version. To go back to using the newest compatible released -version, use `OldPkg.free(pkg)` -""" -pin(pkg::AbstractString) = cd(Entry.pin,splitjl(pkg)) - -""" - pin(pkg, version) - -Pin `pkg` at registered version `version`. -""" -pin(pkg::AbstractString, ver::VersionNumber) = cd(Entry.pin,splitjl(pkg),ver) - -""" - update(pkgs...) - -Update the metadata repo – kept in `OldPkg.dir("METADATA")` – then update any fixed packages -that can safely be pulled from their origin; then call `OldPkg.resolve()` to determine a new -optimal set of packages versions. - -Without arguments, updates all installed packages. When one or more package names are provided as -arguments, only those packages and their dependencies are updated. -""" -update(upkgs::AbstractString...) = cd(Entry.update,Dir.getmetabranch(),Set{String}(splitjl.([upkgs...]))) - -""" - resolve() - -Determines an optimal, consistent set of package versions to install or upgrade to. The -optimal set of package versions is based on the contents of `OldPkg.dir("REQUIRE")` and the -state of installed packages in `OldPkg.dir()`, Packages that are no longer required are moved -into `OldPkg.dir(".trash")`. -""" -resolve() = cd(Entry.resolve) - -""" - build() - -Run the build scripts for all installed packages in depth-first recursive order. -""" -build() = cd(Entry.build) - -""" - build(pkgs...) - -Run the build script in `deps/build.jl` for each package in `pkgs` and all of their -dependencies in depth-first recursive order. This is called automatically by `OldPkg.resolve()` -on all installed or updated packages. -""" -build(pkgs::AbstractString...) = cd(Entry.build,[splitjl.(pkgs)...]) - -""" - test(; coverage=false) - -Run the tests for all installed packages ensuring that each package's test dependencies are -installed for the duration of the test. A package is tested by running its -`test/runtests.jl` file and test dependencies are specified in `test/REQUIRE`. -Coverage statistics for the packages may be generated by passing `coverage=true`. -The default behavior is not to run coverage. -""" -test(;coverage::Bool=false) = cd(Entry.test; coverage=coverage) - -""" - test(pkgs...; coverage=false) - -Run the tests for each package in `pkgs` ensuring that each package's test dependencies are -installed for the duration of the test. A package is tested by running its -`test/runtests.jl` file and test dependencies are specified in `test/REQUIRE`. -Coverage statistics for the packages may be generated by passing `coverage=true`. -The default behavior is not to run coverage. -""" -test(pkgs::AbstractString...; coverage::Bool=false) = cd(Entry.test,AbstractString[splitjl.(pkgs)...]; coverage=coverage) - -""" - dependents(pkg) - -List the packages that have `pkg` as a dependency. -""" -dependents(pkg::AbstractString) = Reqs.dependents(splitjl(pkg)) - -""" - setprotocol!(proto) - -Set the protocol used to access GitHub-hosted packages. Defaults to 'https', with a blank -`proto` delegating the choice to the package developer. -""" -setprotocol!(proto::AbstractString) = Cache.setprotocol!(proto) - -# point users to PkgDev -register(args...) = - error("OldPkg.register(pkg,[url]) has been moved to the package PkgDev.jl.\n", - "Run OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-") - -tag(pkg, ver=nothing, commit=nothing) = - error("OldPkg.tag(pkg, [ver, [commit]]) has been moved to the package PkgDev.jl.\n", - "Run OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-") - -publish() = - error("OldPkg.publish() has been moved to the package PkgDev.jl.\n", - "Run OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-") - -generate(pkg, license) = - error("OldPkg.generate(pkg, license) has been moved to the package PkgDev.jl.\n", - "Run OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-") - -license(lic=nothing) = - error("OldPkg.license([lic]) has been moved to the package PkgDev.jl.\n", - "Run OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-") - -submit(pkg, commit=nothing) = - error("OldPkg.submit(pkg[, commit]) has been moved to the package PkgDev.jl.\n", - "Run OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-") - -end # module diff --git a/stdlib/OldPkg/src/cache.jl b/stdlib/OldPkg/src/cache.jl deleted file mode 100644 index 800c02d643c28..0000000000000 --- a/stdlib/OldPkg/src/cache.jl +++ /dev/null @@ -1,94 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module Cache - -import LibGit2 -import ..Dir, ..PkgError -using ..Types - -rewrite_url_to = "https" - -const GITHUB_REGEX = - r"^(?:git@|git://|https://(?:[\w\.\+\-]+@)?)github.com[:/](([^/].+)/(.+?))(?:\.git)?$"i - -path(pkg::AbstractString) = abspath(".cache", pkg) - -function mkcachedir() - cache = joinpath(realpath("."), ".cache") - if isdir(cache) - return - end - - @static if Sys.isunix() - if Dir.isversioned(pwd()) - rootcache = joinpath(realpath(".."), ".cache") - if !isdir(rootcache) - mkdir(rootcache) - end - symlink(rootcache, cache) - return - end - end - mkdir(cache) -end - -function prefetch(pkg::AbstractString, url::AbstractString, sha1s::Vector) - isdir(".cache") || mkcachedir() - - cache = path(pkg) - normalized_url = normalize_url(url) - - repo = if isdir(cache) - LibGit2.GitRepo(cache) # open repo, free it at the end - else - @info "Cloning cache of $pkg from $normalized_url" - try - # clone repo, free it at the end - LibGit2.clone(normalized_url, cache, isbare = true, remote_cb = LibGit2.mirror_cb()) - catch err - errmsg = if isa(err, LibGit2.Error.GitError) - "Cannot clone $pkg from $normalized_url. $(err.msg)" - elseif isa(err, InterruptException) - "Package `$pkg` prefetching was interrupted." - else - "Unknown error: $err" - end - isdir(cache) && rm(cache, recursive=true) - throw(PkgError(errmsg)) - end - end - try - LibGit2.set_remote_url(repo, "origin", normalized_url) - in_cache = BitVector(map(sha1->LibGit2.iscommit(sha1, repo), sha1s)) - if !all(in_cache) - @info "Updating cache of $pkg..." - LibGit2.fetch(repo) - in_cache = BitVector(map(sha1->LibGit2.iscommit(sha1, repo), sha1s)) - end - sha1s[.!in_cache] - finally - close(repo) # closing repo opened/created above - end -end -prefetch(pkg::AbstractString, url::AbstractString, sha1::AbstractString...) = - prefetch(pkg, url, AbstractString[sha1...]) - -function setprotocol!(proto::AbstractString) - global rewrite_url_to - - if length(proto) == 0 - rewrite_url_to = nothing - else - rewrite_url_to = proto - end -end - -function normalize_url(url::AbstractString) - global rewrite_url_to - - m = match(GITHUB_REGEX,url) - (m === nothing || rewrite_url_to === nothing) ? - url : "$rewrite_url_to://github.com/$(m.captures[1]).git" -end - -end # module diff --git a/stdlib/OldPkg/src/dir.jl b/stdlib/OldPkg/src/dir.jl deleted file mode 100644 index ac1692f46cf80..0000000000000 --- a/stdlib/OldPkg/src/dir.jl +++ /dev/null @@ -1,82 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module Dir - -import OldPkg -import ..DEFAULT_META, ..META_BRANCH, ..PkgError -import LibGit2, LibGit2.with -const DIR_NAME = ".julia" - -_pkgroot() = abspath(get(ENV,"JULIA_PKGDIR",joinpath(homedir(),DIR_NAME))) -isversioned(p::AbstractString) = ((x,y) = (VERSION.major, VERSION.minor); basename(p) == "v$x.$y") - -function path() - b = _pkgroot() - x, y = VERSION.major, VERSION.minor - d = joinpath(b,"v$x.$y") - if isdir(d) || !isdir(b) || !isdir(joinpath(b, "METADATA")) - return d - end - return b -end -path(pkg::AbstractString...) = normpath(path(),pkg...) - -function cd(f::Function, args...; kws...) - dir = path() - metadata_dir = joinpath(dir, "METADATA") - if !isdir(metadata_dir) - !haskey(ENV,"JULIA_PKGDIR") ? init() : - throw(PkgError("Package metadata directory $metadata_dir doesn't exist; run OldPkg.init() to initialize it.")) - end - if haskey(ENV,"JULIA_PKGDIR") - withenv("JULIA_PKGDIR" => abspath(ENV["JULIA_PKGDIR"])) do - Base.cd(()->f(args...; kws...), dir) - end - else - Base.cd(()->f(args...; kws...), dir) - end -end - -function init(meta::AbstractString=DEFAULT_META, branch::AbstractString=META_BRANCH) - dir = path() - @info "Initializing package repository $dir" - metadata_dir = joinpath(dir, "METADATA") - if isdir(metadata_dir) - @info "Package directory $dir is already initialized" - LibGit2.set_remote_url(metadata_dir, "origin", meta) - return - end - local temp_dir = "" - try - mkpath(dir) - temp_dir = mktempdir(dir) - Base.cd(temp_dir) do - @info "Cloning METADATA from $meta" - with(LibGit2.clone(meta, "METADATA", branch = branch)) do metadata_repo - LibGit2.set_remote_url(metadata_repo, "origin", meta) - end - touch("REQUIRE") - touch("META_BRANCH") - write("META_BRANCH", branch) - end - #Move TEMP to METADATA - Base.mv(joinpath(temp_dir,"METADATA"), metadata_dir) - Base.mv(joinpath(temp_dir,"REQUIRE"), joinpath(dir,"REQUIRE")) - Base.mv(joinpath(temp_dir,"META_BRANCH"), joinpath(dir,"META_BRANCH")) - rm(temp_dir, recursive=true) - catch err - ispath(metadata_dir) && rm(metadata_dir, recursive=true) - ispath(temp_dir) && rm(temp_dir, recursive=true) - rethrow(err) - end -end - -function getmetabranch() - try - readline(joinpath(path(),"META_BRANCH")) - catch err - META_BRANCH - end -end - -end # module diff --git a/stdlib/OldPkg/src/entry.jl b/stdlib/OldPkg/src/entry.jl deleted file mode 100644 index 838d672d09623..0000000000000 --- a/stdlib/OldPkg/src/entry.jl +++ /dev/null @@ -1,770 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module Entry - -import Base: thispatch, nextpatch, nextminor, nextmajor, check_new_version -import OldPkg -import ..Reqs, ..Read, ..Query, ..Resolve, ..Cache, ..Write, ..Dir -using LibGit2 -import ..PkgError -using ..Types -using Base.Printf: @printf - -macro recover(ex) - quote - try $(esc(ex)) - catch err - show(err) - print('\n') - end - end -end - -function edit(f::Function, pkg::AbstractString, args...) - r = Reqs.read("REQUIRE") - reqs = Reqs.parse(r) - avail = Read.available() - !haskey(avail,pkg) && !haskey(reqs,pkg) && return false - rʹ = f(r,pkg,args...) - rʹ == r && return false - reqsʹ = Reqs.parse(rʹ) - reqsʹ != reqs && resolve(reqsʹ,avail) - Reqs.write("REQUIRE",rʹ) - @info "Package database updated" - return true -end - -function edit() - editor = get(ENV,"VISUAL",get(ENV,"EDITOR",nothing)) - editor !== nothing || - throw(PkgError("set the EDITOR environment variable to an edit command")) - editor = Base.shell_split(editor) - reqs = Reqs.parse("REQUIRE") - run(`$editor REQUIRE`) - reqsʹ = Reqs.parse("REQUIRE") - reqs == reqsʹ && return @info "Nothing to be done" - @info "Computing changes..." - resolve(reqsʹ) -end - -function add(pkg::AbstractString, vers::VersionSet) - outdated = :maybe - @sync begin - @async if !edit(Reqs.add,pkg,vers) - ispath(pkg) || throw(PkgError("unknown package $pkg")) - @info "Package $pkg is already installed" - end - branch = Dir.getmetabranch() - outdated = with(GitRepo, "METADATA") do repo - if LibGit2.branch(repo) == branch - if LibGit2.isdiff(repo, "origin/$branch") - outdated = :yes - else - try - LibGit2.fetch(repo) - outdated = LibGit2.isdiff(repo, "origin/$branch") ? (:yes) : (:no) - catch - end - end - else - :no # user is doing something funky with METADATA - end - end - end - if outdated != :no - is = outdated == :yes ? "is" : "might be" - @info """ - METADATA $is out-of-date — you may not have the latest version of $pkg - Use `OldPkg.update()` to get the latest versions of your packages - """ - end -end -add(pkg::AbstractString, vers::VersionNumber...) = add(pkg,VersionSet(vers...)) - -function rm(pkg::AbstractString) - edit(Reqs.rm,pkg) && return - ispath(pkg) || return @info "Package $pkg is not installed" - @info "Removing $pkg (unregistered)" - Write.remove(pkg) -end - -function available() - all_avail = Read.available() - avail = AbstractString[] - for (pkg, vers) in all_avail - any(x->Types.satisfies("julia", VERSION, x[2].requires), vers) && push!(avail, pkg) - end - sort!(avail, by=lowercase) -end - -function available(pkg::AbstractString) - avail = Read.available(pkg) - if !isempty(avail) || Read.isinstalled(pkg) - return sort!(collect(keys(avail))) - end - throw(PkgError("$pkg is not a package (not registered or installed)")) -end - -function installed() - pkgs = Dict{String,VersionNumber}() - for (pkg,(ver,fix)) in Read.installed() - pkgs[pkg] = ver - end - return pkgs -end - -function installed(pkg::AbstractString) - avail = Read.available(pkg) - if Read.isinstalled(pkg) - res = typemin(VersionNumber) - if ispath(joinpath(pkg,".git")) - LibGit2.with(GitRepo, pkg) do repo - res = Read.installed_version(pkg, repo, avail) - end - end - return res - end - isempty(avail) && throw(PkgError("$pkg is not a package (not registered or installed)")) - return nothing # registered but not installed -end - -function status(io::IO; pkgname::AbstractString = "") - if !isempty(pkgname) && !ispath(pkgname) - throw(PkgError("Package $pkgname does not exist")) - end - showpkg(pkg) = isempty(pkgname) ? true : (pkg == pkgname) - reqs = Reqs.parse("REQUIRE") - instd = Read.installed() - required = sort!(collect(keys(reqs))) - if !isempty(required) - showpkg("") && println(io, "$(length(required)) required packages:") - for pkg in required - if !haskey(instd, pkg) - showpkg(pkg) && status(io,pkg,"not found") - else - ver,fix = pop!(instd,pkg) - showpkg(pkg) && status(io,pkg,ver,fix) - end - end - end - additional = sort!(collect(keys(instd))) - if !isempty(additional) - showpkg("") && println(io, "$(length(additional)) additional packages:") - for pkg in additional - ver,fix = instd[pkg] - showpkg(pkg) && status(io,pkg,ver,fix) - end - end - if isempty(required) && isempty(additional) - println(io, "No packages installed") - end -end - -status(io::IO, pkg::AbstractString) = status(io, pkgname = pkg) - -function status(io::IO, pkg::AbstractString, ver::VersionNumber, fix::Bool) - if !isempty(pkg) && !ispath(pkg) - throw(PkgError("Package $pkg does not exist")) - end - @printf io " - %-29s " pkg - fix || return println(io,ver) - @printf io "%-19s" ver - if ispath(pkg,".git") - prepo = GitRepo(pkg) - try - with(LibGit2.head(prepo)) do phead - if LibGit2.isattached(prepo) - print(io, LibGit2.shortname(phead)) - else - print(io, string(LibGit2.GitHash(phead))[1:8]) - end - end - attrs = AbstractString[] - isfile("METADATA",pkg,"url") || push!(attrs,"unregistered") - LibGit2.isdirty(prepo) && push!(attrs,"dirty") - isempty(attrs) || print(io, " (",join(attrs,", "),")") - catch err - printstyled(io, " broken-repo (unregistered)", color=Base.error_color()) - finally - close(prepo) - end - else - printstyled(io, "non-repo (unregistered)", color=Base.warn_color()) - end - println(io) -end - -function status(io::IO, pkg::AbstractString, msg::AbstractString) - @printf io " - %-29s %-19s\n" pkg msg -end - -function clone(url::AbstractString, pkg::AbstractString) - @info "Cloning $pkg from $url" - ispath(pkg) && throw(PkgError("$pkg already exists")) - try - LibGit2.with(LibGit2.clone(url, pkg)) do repo - LibGit2.set_remote_url(repo, "origin", url) - end - catch err - isdir(pkg) && Base.rm(pkg, recursive=true) - rethrow(err) - end - @info "Computing changes..." - if !edit(Reqs.add, pkg) - isempty(Reqs.parse("$pkg/REQUIRE")) && return - resolve() - end -end - -function url_and_pkg(url_or_pkg::AbstractString) - if !(':' in url_or_pkg) - # no colon, could be a package name - url_file = joinpath("METADATA", url_or_pkg, "url") - isfile(url_file) && return readchomp(url_file), url_or_pkg - end - # try to parse as URL or local path - m = match(r"(?:^|[/\\])(\w+?)(?:\.jl)?(?:\.git)?$", url_or_pkg) - m === nothing && throw(PkgError("can't determine package name from URL: $url_or_pkg")) - return url_or_pkg, m.captures[1] -end - -clone(url_or_pkg::AbstractString) = clone(url_and_pkg(url_or_pkg)...) - -function checkout(pkg::AbstractString, branch::AbstractString, do_merge::Bool, do_pull::Bool) - ispath(pkg,".git") || throw(PkgError("$pkg is not a git repo")) - @info "Checking out $pkg $branch..." - with(GitRepo, pkg) do r - LibGit2.transact(r) do repo - LibGit2.isdirty(repo) && throw(PkgError("$pkg is dirty, bailing")) - LibGit2.branch!(repo, branch, track=LibGit2.Consts.REMOTE_ORIGIN) - do_merge && LibGit2.merge!(repo, fastforward=true) # merge changes - if do_pull - @info "Pulling $pkg latest $branch..." - LibGit2.fetch(repo) - LibGit2.merge!(repo, fastforward=true) - end - resolve() - end - end -end - -function free(pkg::AbstractString) - ispath(pkg,".git") || throw(PkgError("$pkg is not a git repo")) - Read.isinstalled(pkg) || throw(PkgError("$pkg cannot be freed – not an installed package")) - avail = Read.available(pkg) - isempty(avail) && throw(PkgError("$pkg cannot be freed – not a registered package")) - with(GitRepo, pkg) do repo - LibGit2.isdirty(repo) && throw(PkgError("$pkg cannot be freed – repo is dirty")) - @info "Freeing $pkg" - vers = sort!(collect(keys(avail)), rev=true) - while true - for ver in vers - sha1 = avail[ver].sha1 - LibGit2.iscommit(sha1, repo) || continue - return LibGit2.transact(repo) do r - LibGit2.isdirty(repo) && throw(PkgError("$pkg is dirty, bailing")) - LibGit2.checkout!(repo, sha1) - resolve() - end - end - isempty(Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail])) && continue - throw(PkgError("can't find any registered versions of $pkg to checkout")) - end - end -end - -function free(pkgs) - try - for pkg in pkgs - ispath(pkg,".git") || throw(PkgError("$pkg is not a git repo")) - Read.isinstalled(pkg) || throw(PkgError("$pkg cannot be freed – not an installed package")) - avail = Read.available(pkg) - isempty(avail) && throw(PkgError("$pkg cannot be freed – not a registered package")) - with(GitRepo, pkg) do repo - LibGit2.isdirty(repo) && throw(PkgError("$pkg cannot be freed – repo is dirty")) - @info "Freeing $pkg" - vers = sort!(collect(keys(avail)), rev=true) - for ver in vers - sha1 = avail[ver].sha1 - LibGit2.iscommit(sha1, repo) || continue - LibGit2.checkout!(repo, sha1) - break - end - end - isempty(Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail])) && continue - throw(PkgError("Can't find any registered versions of $pkg to checkout")) - end - finally - resolve() - end -end - -function pin(pkg::AbstractString, head::AbstractString) - ispath(pkg,".git") || throw(PkgError("$pkg is not a git repo")) - should_resolve = true - with(GitRepo, pkg) do repo - id = if isempty(head) # get HEAD commit - # no need to resolve, branch will be from HEAD - should_resolve = false - LibGit2.head_oid(repo) - else - LibGit2.revparseid(repo, head) - end - commit = LibGit2.GitCommit(repo, id) - try - # note: changing the following naming scheme requires a corresponding change in Read.ispinned() - branch = "pinned.$(string(id)[1:8]).tmp" - if LibGit2.isattached(repo) && LibGit2.branch(repo) == branch - @info "Package $pkg is already pinned" * (isempty(head) ? "" : " to the selected commit") - should_resolve = false - return - end - ref = LibGit2.lookup_branch(repo, branch) - try - if ref !== nothing - if LibGit2.revparseid(repo, branch) != id - throw(PkgError("Package $pkg: existing branch $branch has " * - "been edited and doesn't correspond to its original commit")) - end - @info "Package $pkg: checking out existing branch $branch" - else - @info "Creating $pkg branch $branch" - ref = LibGit2.create_branch(repo, branch, commit) - end - - # checkout selected branch - with(LibGit2.peel(LibGit2.GitTree, ref)) do btree - LibGit2.checkout_tree(repo, btree) - end - # switch head to the branch - LibGit2.head!(repo, ref) - finally - close(ref) - end - finally - close(commit) - end - end - should_resolve && resolve() - nothing -end -pin(pkg::AbstractString) = pin(pkg, "") - -function pin(pkg::AbstractString, ver::VersionNumber) - ispath(pkg,".git") || throw(PkgError("$pkg is not a git repo")) - Read.isinstalled(pkg) || throw(PkgError("$pkg cannot be pinned – not an installed package")) - avail = Read.available(pkg) - isempty(avail) && throw(PkgError("$pkg cannot be pinned – not a registered package")) - haskey(avail,ver) || throw(PkgError("$pkg – $ver is not a registered version")) - pin(pkg, avail[ver].sha1) -end - -function update(branch::AbstractString, upkgs::Set{String}) - @info "Updating METADATA..." - with(GitRepo, "METADATA") do repo - try - with(LibGit2.head(repo)) do h - if LibGit2.branch(h) != branch - if LibGit2.isdirty(repo) - throw(PkgError("METADATA is dirty and not on $branch, bailing")) - end - if !LibGit2.isattached(repo) - throw(PkgError("METADATA is detached not on $branch, bailing")) - end - LibGit2.fetch(repo) - LibGit2.checkout_head(repo) - LibGit2.branch!(repo, branch, track="refs/remotes/origin/$branch") - LibGit2.merge!(repo) - end - end - - LibGit2.fetch(repo) - ff_succeeded = LibGit2.merge!(repo, fastforward=true) - if !ff_succeeded - LibGit2.rebase!(repo, "origin/$branch") - end - catch err - cex = CapturedException(err, catch_backtrace()) - throw(PkgError("METADATA cannot be updated. Resolve problems manually in " * - OldPkg.dir("METADATA") * ".", cex)) - end - end - deferred_errors = CompositeException() - avail = Read.available() - # this has to happen before computing free/fixed - for pkg in filter(Read.isinstalled, collect(keys(avail))) - try - Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail[pkg]]) - catch err - cex = CapturedException(err, catch_backtrace()) - push!(deferred_errors, PkgError("Package $pkg: unable to update cache.", cex)) - end - end - instd = Read.installed(avail) - reqs = Reqs.parse("REQUIRE") - if !isempty(upkgs) - for (pkg, (v,f)) in instd - satisfies(pkg, v, reqs) || throw(PkgError("Package $pkg: current " * - "package status does not satisfy the requirements, cannot do " * - "a partial update; use `OldPkg.update()`")) - end - end - dont_update = Query.partial_update_mask(instd, avail, upkgs) - free = Read.free(instd,dont_update) - for (pkg,ver) in free - try - Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail[pkg]]) - catch err - cex = CapturedException(err, catch_backtrace()) - push!(deferred_errors, PkgError("Package $pkg: unable to update cache.", cex)) - end - end - fixed = Read.fixed(avail,instd,dont_update) - Base.shred!(LibGit2.CachedCredentials()) do creds - stopupdate = false - for (pkg,ver) in fixed - ispath(pkg,".git") || continue - pkg in dont_update && continue - with(GitRepo, pkg) do repo - if LibGit2.isattached(repo) - if LibGit2.isdirty(repo) - @warn "Package $pkg: skipping update (dirty)..." - elseif Read.ispinned(repo) - @info "Package $pkg: skipping update (pinned)..." - else - prev_sha = string(LibGit2.head_oid(repo)) - success = true - try - LibGit2.fetch(repo, credentials=creds) - LibGit2.merge!(repo, fastforward=true) - catch err - cex = CapturedException(err, catch_backtrace()) - push!(deferred_errors, PkgError("Package $pkg cannot be updated.", cex)) - success = false - stopupdate = isa(err, InterruptException) - end - if success - post_sha = string(LibGit2.head_oid(repo)) - branch = LibGit2.branch(repo) - @info "Updating $pkg $branch..." * (prev_sha != post_sha ? - " $(prev_sha[1:8]) → $(post_sha[1:8])" : "") - end - end - end - end - stopupdate && break - if haskey(avail,pkg) - try - Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail[pkg]]) - catch err - cex = CapturedException(err, catch_backtrace()) - push!(deferred_errors, PkgError("Package $pkg: unable to update cache.", cex)) - end - end - end - end - @info "Computing changes..." - resolve(reqs, avail, instd, fixed, free, upkgs) - # Don't use instd here since it may have changed - updatehook(sort!(collect(keys(installed())))) - - # Print deferred errors - length(deferred_errors) > 0 && throw(PkgError("Update finished with errors.", deferred_errors)) - nothing -end - - -function resolve( - reqs :: Dict = Reqs.parse("REQUIRE"), - avail :: Dict = Read.available(), - instd :: Dict = Read.installed(avail), - fixed :: Dict = Read.fixed(avail, instd), - have :: Dict = Read.free(instd), - upkgs :: Set{String} = Set{String}() -) - bktrc = Query.init_resolve_backtrace(reqs, fixed) - orig_reqs = deepcopy(reqs) - Query.check_fixed(reqs, fixed, avail) - Query.propagate_fixed!(reqs, bktrc, fixed) - deps, conflicts = Query.dependencies(avail, fixed) - - for pkg in keys(reqs) - if !haskey(deps,pkg) - if "julia" in conflicts[pkg] - throw(PkgError("$pkg can't be installed because it has no versions that support $VERSION " * - "of julia. You may need to update METADATA by running `OldPkg.update()`")) - else - sconflicts = join(conflicts[pkg], ", ", " and ") - throw(PkgError("$pkg's requirements can't be satisfied because " * - "of the following fixed packages: $sconflicts")) - end - end - end - - Query.check_requirements(reqs, deps, fixed) - - deps = Query.prune_dependencies(reqs, deps, bktrc) - want = Resolve.resolve(reqs, deps) - - if !isempty(upkgs) - orig_deps, _ = Query.dependencies(avail) - Query.check_partial_updates(orig_reqs, orig_deps, want, fixed, upkgs) - end - - # compare what is installed with what should be - changes = Query.diff(have, want, avail, fixed) - isempty(changes) && return @info "No packages to install, update or remove" - - # prefetch phase isolates network activity, nothing to roll back - missing = [] - for (pkg,(ver1,ver2)) in changes - vers = String[] - ver1 !== nothing && push!(vers,LibGit2.head(pkg)) - ver2 !== nothing && push!(vers,Read.sha1(pkg,ver2)) - append!(missing, - map(sha1->(pkg,(ver1,ver2),sha1), - Cache.prefetch(pkg, Read.url(pkg), vers))) - end - if !isempty(missing) - msg = "Missing package versions (possible metadata misconfiguration):" - for (pkg,ver,sha1) in missing - msg *= " $pkg v$ver [$sha1[1:10]]\n" - end - throw(PkgError(msg)) - end - - # try applying changes, roll back everything if anything fails - changed = [] - imported = String[] - try - for (pkg,(ver1,ver2)) in changes - if ver1 === nothing - @info "Installing $pkg v$ver2" - Write.install(pkg, Read.sha1(pkg,ver2)) - elseif ver2 === nothing - @info "Removing $pkg v$ver1" - Write.remove(pkg) - else - up = ver1 <= ver2 ? "Up" : "Down" - @info "$(up)grading $pkg: v$ver1 => v$ver2" - Write.update(pkg, Read.sha1(pkg,ver2)) - if Base.root_module_exists(Base.PkgId(pkg)) - push!(imported, "- $pkg") - end - end - push!(changed,(pkg,(ver1,ver2))) - end - catch err - for (pkg,(ver1,ver2)) in reverse!(changed) - if ver1 === nothing - @info "Rolling back install of $pkg" - @recover Write.remove(pkg) - elseif ver2 === nothing - @info "Rolling back deleted $pkg to v$ver1" - @recover Write.install(pkg, Read.sha1(pkg,ver1)) - else - @info "Rolling back $pkg from v$ver2 to v$ver1" - @recover Write.update(pkg, Read.sha1(pkg,ver1)) - end - end - rethrow(err) - end - if !isempty(imported) - @warn join(["The following packages have been updated but were already imported:", - imported..., "Restart Julia to use the updated versions."], "\n") - end - # re/build all updated/installed packages - build(map(x->x[1], filter(x -> x[2][2] !== nothing, changes))) -end - -function build(pkg::AbstractString, build_file::AbstractString, errfile::AbstractString) - # To isolate the build from the running Julia process, we execute each build.jl file in - # a separate process. Errors are written to errfile for later reporting. - code = """ - import OldPkg - $(Base.load_path_setup_code()) - open("$(escape_string(errfile))", "a") do f - pkg, build_file = "$pkg", "$(escape_string(build_file))" - try - @info "Building \$pkg" - cd(dirname(build_file)) do - evalfile(build_file) - end - catch err - @error \""" - ------------------------------------------------------------ - # Build failed for \$pkg - \""" exception=err,catch_backtrace() - write(f, pkg); write(f, 0x00) - write(f, sprint(showerror, err)); write(f, 0x00) - end - end - """ - cmd = ``` - $(Base.julia_cmd()) -O0 - --color=$(Base.have_color ? "yes" : "no") - --compiled-modules=$(Bool(Base.JLOptions().use_compiled_modules) ? "yes" : "no") - --history-file=no - --startup-file=$(Base.JLOptions().startupfile != 2 ? "yes" : "no") - --eval $code - ``` - - success(pipeline(cmd, stdout=stdout, stderr=stderr)) -end - -function build!(pkgs::Vector, seen::Set, errfile::AbstractString) - for pkg in pkgs - pkg == "julia" && continue - pkg in seen ? continue : push!(seen,pkg) - Read.isinstalled(pkg) || throw(PkgError("$pkg is not an installed package")) - build!(Read.requires_list(pkg), seen, errfile) - path = abspath(pkg,"deps","build.jl") - isfile(path) || continue - build(pkg, path, errfile) || error("Build process failed.") - end -end - -function build!(pkgs::Vector, errs::Dict, seen::Set=Set()) - mktemp() do errfile, f - build!(pkgs, seen, errfile) - while !eof(f) - pkg = readuntil(f, '\0') - err = readuntil(f, '\0') - errs[pkg] = err - end - end -end - -function build(pkgs::Vector) - errs = Dict() - build!(pkgs,errs) - isempty(errs) && return - @warn """ - ------------------------------------------------------------ - # Build error summary - - $(join(keys(errs),", "," and ")) had build errors. - - - packages with build errors remain installed in $(pwd()) - - build the package(s) and all dependencies with `OldPkg.build("$(join(keys(errs),"\", \""))")` - - build a single package by running its `deps/build.jl` script - """ -end -build() = build(sort!(collect(keys(installed())))) - -function updatehook!(pkgs::Vector, errs::Dict, seen::Set=Set()) - for pkg in pkgs - pkg in seen && continue - updatehook!(Read.requires_list(pkg),errs,push!(seen,pkg)) - path = abspath(pkg,"deps","update.jl") - isfile(path) || continue - @info "Running update script for $pkg" - cd(dirname(path)) do - try evalfile(path) - catch err - @error """ - ------------------------------------------------------------ - # Update hook failed for $pkg - """ exception=err,catch_backtrace() - errs[pkg] = err - end - end - end -end - -function updatehook(pkgs::Vector) - errs = Dict() - updatehook!(pkgs,errs) - isempty(errs) && return - println(stderr) - @warn """ - ------------------------------------------------------------ - # Update hook summary - - $(join(keys(errs),", "," and ")) had update errors. - - - Unrelated packages are unaffected - - To retry, run OldPkg.update() again - """ -end - -function test!(pkg::AbstractString, - errs::Vector{AbstractString}, - nopkgs::Vector{AbstractString}, - notests::Vector{AbstractString}; coverage::Bool=false) - reqs_path = abspath(pkg,"test","REQUIRE") - if isfile(reqs_path) - tests_require = Reqs.parse(reqs_path) - if (!isempty(tests_require)) - @info "Computing test dependencies for $pkg..." - resolve(merge(Reqs.parse("REQUIRE"), tests_require)) - end - end - test_path = abspath(pkg,"test","runtests.jl") - if !isdir(pkg) - push!(nopkgs, pkg) - elseif !isfile(test_path) - push!(notests, pkg) - else - @info "Testing $pkg" - cd(dirname(test_path)) do - try - cmd = ``` - $(Base.julia_cmd()) - --code-coverage=$(coverage ? "user" : "none") - --color=$(Base.have_color ? "yes" : "no") - --compiled-modules=$(Bool(Base.JLOptions().use_compiled_modules) ? "yes" : "no") - --check-bounds=yes - --warn-overwrite=yes - --startup-file=$(Base.JLOptions().startupfile != 2 ? "yes" : "no") - $test_path - ``` - run(cmd) - @info "$pkg tests passed" - catch err - @error """ - ------------------------------------------------------------ - # Testing failed for $pkg - """ exception=err,catch_backtrace() - push!(errs,pkg) - end - end - end - isfile(reqs_path) && resolve() -end - -struct PkgTestError <: Exception - msg::AbstractString -end - -function Base.showerror(io::IO, ex::PkgTestError, bt; backtrace=true) - printstyled(io, ex.msg, color=Base.error_color()) -end - -function test(pkgs::Vector{AbstractString}; coverage::Bool=false) - errs = AbstractString[] - nopkgs = AbstractString[] - notests = AbstractString[] - for pkg in pkgs - test!(pkg,errs,nopkgs,notests; coverage=coverage) - end - if !all(isempty, (errs, nopkgs, notests)) - messages = AbstractString[] - if !isempty(errs) - push!(messages, "$(join(errs,", "," and ")) had test errors") - end - if !isempty(nopkgs) - msg = length(nopkgs) > 1 ? " are not installed packages" : - " is not an installed package" - push!(messages, string(join(nopkgs,", ", " and "), msg)) - end - if !isempty(notests) - push!(messages, "$(join(notests,", "," and ")) did not provide a test/runtests.jl file") - end - throw(PkgTestError(join(messages, "and"))) - end -end - -test(;coverage::Bool=false) = test(sort!(AbstractString[keys(installed())...]); coverage=coverage) - -end # module diff --git a/stdlib/OldPkg/src/query.jl b/stdlib/OldPkg/src/query.jl deleted file mode 100644 index c4633c780f408..0000000000000 --- a/stdlib/OldPkg/src/query.jl +++ /dev/null @@ -1,590 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module Query - -import OldPkg -import ..PkgError -using ..Types - -function init_resolve_backtrace(reqs::Requires, fix::Dict{String,Fixed} = Dict{String,Fixed}()) - bktrc = ResolveBacktrace() - for (p,f) in fix - bktrc[p] = ResolveBacktraceItem(:fixed, f.version) - end - for (p,vs) in reqs - bktrcp = get!(bktrc, p) do; ResolveBacktraceItem() end - push!(bktrcp, :required, vs) - end - return bktrc -end - -function check_fixed(reqs::Requires, fix::Dict{String,Fixed}, avail::Dict) - for (p1,f1) in fix - for p2 in keys(f1.requires) - haskey(avail, p2) || haskey(fix, p2) || throw(PkgError("unknown package $p2 required by $p1")) - end - satisfies(p1, f1.version, reqs) || - @warn "$p1 is fixed at $(f1.version) conflicting with top-level requirement: $(reqs[p1])" - for (p2,f2) in fix - satisfies(p1, f1.version, f2.requires) || - @warn "$p1 is fixed at $(f1.version) conflicting with requirement for $p2: $(f2.requires[p1])" - end - end -end - -function propagate_fixed!(reqs::Requires, bktrc::ResolveBacktrace, fix::Dict{String,Fixed}) - for (p,f) in fix - merge_requires!(reqs, f.requires) - for (rp,rvs) in f.requires - bktrcp = get!(bktrc, rp) do; ResolveBacktraceItem() end - push!(bktrcp, p=>bktrc[p], rvs) - end - end - for (p,f) in fix - delete!(reqs, p) - end - reqs -end - -# Specialized copy for the avail argument below because the deepcopy is slow -function availcopy(avail) - new_avail = empty(avail) - for (pkg, vers_avail) in avail - new_vers_avail = empty(vers_avail) - for (version, pkg_avail) in vers_avail - new_vers_avail[version] = copy(pkg_avail) - end - new_avail[pkg] = new_vers_avail - end - return new_avail -end - -# Generate a reverse dependency graph (package names only) -function gen_backdeps(avail::Dict) - backdeps = Dict{String,Set{String}}() - for (ap,av) in avail, (v,a) in av, rp in keys(a.requires) - s = get!(backdeps, rp) do; Set{String}() end - push!(s, ap) - end - return backdeps -end - -function dependencies(avail::Dict, fix::Dict = Dict{String,Fixed}("julia"=>Fixed(VERSION))) - avail = availcopy(avail) - conflicts = Dict{String,Set{String}}() - to_expunge = VersionNumber[] - emptied = String[] - backdeps = gen_backdeps(avail) - - for (fp,fx) in fix - delete!(avail, fp) - haskey(backdeps, fp) || continue - # for (ap,av) in avail - for ap in backdeps[fp] - haskey(avail, ap) || continue - av = avail[ap] - empty!(to_expunge) - for (v,a) in av - if satisfies(fp, fx.version, a.requires) - delete!(a.requires, fp) - else - conflicts_ap = get!(conflicts, ap) do; Set{String}() end - push!(conflicts_ap, fp) - # don't delete v from av right away so as not to screw up iteration - push!(to_expunge, v) - end - end - for v in to_expunge - delete!(av, v) - end - isempty(av) && push!(emptied, ap) - end - end - while !isempty(emptied) - deleted_pkgs = String[] - for ap in emptied - delete!(avail, ap) - push!(deleted_pkgs, ap) - end - empty!(emptied) - - for dp in deleted_pkgs - haskey(backdeps, dp) || continue - for ap in backdeps[dp] - haskey(avail, ap) || continue - av = avail[ap] - empty!(to_expunge) - for (v,a) in av - haskey(a.requires, dp) || continue - conflicts_ap = get!(conflicts, ap) do; Set{String}() end - union!(conflicts_ap, conflicts[dp]) - push!(to_expunge, v) - end - for v in to_expunge - delete!(av, v) - end - isempty(av) && push!(emptied, ap) - end - end - end - avail, conflicts -end - -function partial_update_mask(instd::Dict{String,Tuple{VersionNumber,Bool}}, - avail::Dict{String,Dict{VersionNumber,Available}}, upkgs::Set{String}) - dont_update = Set{String}() - isempty(upkgs) && return dont_update - avail_new = deepcopy(avail) - for p in upkgs - haskey(instd, p) || throw(PkgError("Package $p is not installed")) - v = instd[p][1] - if haskey(avail, p) - for vn in keys(avail[p]) - vn < v && delete!(avail_new[p], vn) - end - end - end - avail_new = dependencies_subset(avail_new, upkgs) - - for p in keys(avail) - !haskey(avail_new, p) && push!(dont_update, p) - end - for p in keys(instd) - !haskey(avail_new, p) && p ∉ upkgs && push!(dont_update, p) - end - return dont_update -end - -# Try to produce some helpful message in case of a partial update which does not go all the way -# (Does not do a full analysis, it only checks requirements and direct dependents.) -function check_partial_updates(reqs::Requires, - deps::Dict{String,Dict{VersionNumber,Available}}, - want::Dict{String,VersionNumber}, - fixed::Dict{String,Fixed}, - upkgs::Set{String}) - for p in upkgs - if !haskey(want, p) - if !haskey(fixed, p) - @warn "Something went wrong with the update of package $p, please submit a bug report" - continue - end - v = fixed[p].version - else - v = want[p] - if haskey(fixed, p) && v != fixed[p].version - @warn "Something went wrong with the update of package $p, please submit a bug report" - continue - end - end - haskey(deps, p) || continue - vers = sort!(collect(keys(deps[p]))) - higher_vers = vers[vers .> v] - isempty(higher_vers) && continue # package p has been set to the highest available version - - # Determine if there are packages which depend on `p` and somehow prevent its update to - # the latest version - blocking_parents = Set{String}() - for (p1,d1) in deps - p1 in upkgs && continue # package `p1` is among the ones to be updated, skip the check - haskey(fixed, p1) || continue # if package `p1` is not fixed, it can't be blocking - r1 = fixed[p1].requires # get `p1` requirements - haskey(r1, p) || continue # check if package `p1` requires `p` - vs1 = r1[p] # get the versions of `p` allowed by `p1` requirements - any(hv in vs1 for hv in higher_vers) && continue # package `p1` would allow some of the higher versions, - # therefore it's not responsible for blocking `p` - push!(blocking_parents, p1) # package `p1` is blocking the update of `p` - end - - # Determine if the update of `p` is prevented by explicit user-provided requirements - blocking_reqs = (haskey(reqs, p) && all(hv ∉ reqs[p] for hv in higher_vers)) - - # Determine if the update of `p` is prevented by it being fixed (e.g. it's dirty, or pinned...) - isfixed = haskey(fixed, p) - - @info begin - "Package $p was set to version $v, but a higher version $(vers[end]) exists.\n" * - if isfixed - "The package is fixed. You can try using `OldPkg.free(\"$p\")` to update it." - elseif blocking_reqs - "The update is prevented by explicit requirements constraints. Edit your REQUIRE file to change this." - elseif !isempty(blocking_parents) - string("To install the latest version, you could try updating these packages as well: ", join(blocking_parents, ", ", " and "), ".") - else - "To install the latest version, you could try doing a full update with `OldPkg.update()`." - end - end - end -end - -const PackageState = Union{Nothing,VersionNumber} - -function diff(have::Dict, want::Dict, avail::Dict, fixed::Dict) - change = Vector{Tuple{String,Tuple{PackageState,PackageState}}}() - remove = Vector{Tuple{String,Tuple{PackageState,PackageState}}}() - - for pkg in collect(union(keys(have),keys(want))) - h, w = haskey(have,pkg), haskey(want,pkg) - if h && w - if have[pkg] != want[pkg] - push!(change, (pkg,(have[pkg], want[pkg]))) - end - elseif h - push!(remove, (pkg,(have[pkg],nothing))) - elseif w - push!(change, (pkg,(nothing,want[pkg]))) - end - end - append!(sort!(change), sort!(remove)) -end - -function check_requirements(reqs::Requires, deps::Dict{String,Dict{VersionNumber,Available}}, fix::Dict) - for (p,vs) in reqs - if !any(vn->(vn in vs), keys(deps[p])) - remaining_vs = VersionSet() - err_msg = "fixed packages introduce conflicting requirements for $p: \n" - available_list = sort!(collect(keys(deps[p]))) - for (p1,f1) in fix - f1r = f1.requires - haskey(f1r, p) || continue - err_msg *= " $p1 requires versions $(f1r[p])" - if !any([vn in f1r[p] for vn in available_list]) - err_msg *= " [none of the available versions can satisfy this requirement]" - end - err_msg *= "\n" - remaining_vs = intersect(remaining_vs, f1r[p]) - end - if isempty(remaining_vs) - err_msg *= " the requirements are unsatisfiable because their intersection is empty" - else - err_msg *= " available versions are $(join(available_list, ", ", " and "))" - end - throw(PkgError(err_msg)) - end - end -end - -# If there are explicitly required packages, dicards all versions outside -# the allowed range. -# It also propagates requirements: when all allowed versions of a required package -# require some other package, this creates a new implicit requirement. -# The propagation is tracked so that in case a contradiction is detected the error -# message allows to determine the cause. -# This is a pre-pruning step, so it also creates some structures which are later used by pruning -function filter_versions(reqs::Requires, deps::Dict{String,Dict{VersionNumber,Available}}, bktrc::ResolveBacktrace) - allowed = Dict{String,Dict{VersionNumber,Bool}}() - staged = copy(reqs) - while !isempty(staged) - staged_next = Requires() - for (p,vs) in staged - # Parse requirements and store allowed versions. - depsp = deps[p] - if !haskey(allowed, p) - allowedp = Dict{VersionNumber,Bool}(vn=>true for vn in keys(depsp)) - allowed[p] = allowedp - seen = false - else - allowedp = allowed[p] - oldallowedp = copy(allowedp) - seen = true - end - for vn in keys(depsp) - allowedp[vn] &= vn ∈ vs - end - @assert !isempty(allowedp) - if !any(values(allowedp)) - err_msg = "Unsatisfiable requirements detected for package $p:\n" - err_msg *= string(bktrc[p]) - err_msg *= """The intersection of the requirements is $(bktrc[p].versionreq). - None of the available versions can satisfy this requirement.""" - throw(PkgError(err_msg)) - end - - # If we've seen this package already and nothing has changed since - # the last time, we stop here. - seen && allowedp == oldallowedp && continue - - # Propagate requirements: - # if all allowed versions of a required package require some other package, - # then compute the union of the allowed versions for that other package, and - # treat that as a new requirement. - # Start by filtering out the non-allowed versions - fdepsp = Dict{VersionNumber,Available}(vn=>depsp[vn] for vn in keys(depsp) if allowedp[vn]) - # Collect all required packages - isreq = Dict{String,Bool}(rp=>true for a in values(fdepsp) for rp in keys(a.requires)) - # Compute whether a required package appears in all requirements - for rp in keys(isreq) - isreq[rp] = all(haskey(a.requires, rp) for a in values(fdepsp)) - end - - # Create a list of candidates for new implicit requirements - staged_new = Set{String}() - for a in values(fdepsp), (rp,rvs) in a.requires - # Skip packages that may not be required - isreq[rp] || continue - # Compute the union of the version sets - if haskey(staged_next, rp) - snvs = staged_next[rp] - union!(snvs, rvs) - else - snvs = copy(rvs) - staged_next[rp] = snvs - end - push!(staged_new, rp) - end - for rp in staged_new - @assert isreq[rp] - srvs = staged_next[rp] - bktrcp = get!(bktrc, rp) do; ResolveBacktraceItem(); end - push!(bktrcp, p=>bktrc[p], srvs) - if isa(bktrcp.versionreq, VersionSet) && isempty(bktrcp.versionreq) - err_msg = "Unsatisfiable requirements detected for package $rp:\n" - err_msg *= string(bktrcp) - err_msg *= "The intersection of the requirements is empty." - throw(PkgError(err_msg)) - end - end - end - staged = staged_next - end - - filtered_deps = Dict{String,Dict{VersionNumber,Available}}() - for (p,depsp) in deps - filtered_deps[p] = Dict{VersionNumber,Available}() - allowedp = get(allowed, p) do; Dict{VersionNumber,Bool}() end - fdepsp = filtered_deps[p] - for (vn,a) in depsp - get(allowedp, vn, true) || continue - fdepsp[vn] = a - end - end - - return filtered_deps, allowed -end - -# Reduce the number of versions by creating equivalence classes, and retaining -# only the highest version for each equivalence class. -# Two versions are equivalent if: -# 1) They appear together as dependencies of another package (i.e. for each -# dependency relation, they are both required or both not required) -# 2) They have the same dependencies -# Preliminarily calls filter_versions. -function prune_versions(reqs::Requires, deps::Dict{String,Dict{VersionNumber,Available}}, bktrc::ResolveBacktrace) - filtered_deps, allowed = filter_versions(reqs, deps, bktrc) - if !isempty(reqs) - filtered_deps = dependencies_subset(filtered_deps, Set{String}(keys(reqs))) - end - - # To each version in each package, we associate a BitVector. - # It is going to hold a pattern such that all versions with - # the same pattern are equivalent. - vmask = Dict{String,Dict{VersionNumber, BitVector}}() - - # For each package, we examine the dependencies of its versions - # and put together those which are equal. - # While we're at it, we also collect all dependencies into alldeps - alldeps = Dict{String,Set{VersionSet}}() - for (p,fdepsp) in filtered_deps - # Extract unique dependencies lists (aka classes), thereby - # assigning an index to each class. - uniqdepssets = unique(a.requires for a in values(fdepsp)) - - # Store all dependencies seen so far for later use - for r in uniqdepssets, (rp,rvs) in r - get!(alldeps, rp) do; Set{VersionSet}() end - push!(alldeps[rp], rvs) - end - - # If the package has just one version, it's uninteresting - length(deps[p]) == 1 && continue - - # Grow the pattern by the number of classes - luds = length(uniqdepssets) - @assert !haskey(vmask, p) - vmask[p] = Dict{VersionNumber,BitVector}() - vmaskp = vmask[p] - for vn in keys(fdepsp) - vmaskp[vn] = falses(luds) - end - for (vn,a) in fdepsp - vmind = findfirst(isequal(a.requires), uniqdepssets) - @assert vmind !== nothing - vm = vmaskp[vn] - vm[vmind] = true - end - end - - # Produce dependency patterns. - for (p,vss) in alldeps, vs in vss - # packages with just one version, or dependencies - # which do not distinguish between versions, are not - # interesting - (length(deps[p]) == 1 || vs == VersionSet()) && continue - - # Store the dependency info in the patterns - @assert haskey(vmask, p) - for (vn,vm) in vmask[p] - push!(vm, vn in vs) - end - end - - # At this point, the vmask patterns are computed. We divide them into - # classes so that we can keep just one version for each class. - pruned_vers = Dict{String,Vector{VersionNumber}}() - eq_classes = Dict{String,Dict{VersionNumber,Vector{VersionNumber}}}() - for (p, vmaskp) in vmask - vmask0_uniq = unique(values(vmaskp)) - nc = length(vmask0_uniq) - classes = [VersionNumber[] for c0 = 1:nc] - for (vn,vm) in vmaskp - c0 = findfirst(isequal(vm), vmask0_uniq)::Int - push!(classes[c0], vn) - end - map(sort!, classes) - - # For each nonempty class, we store only the highest version) - pruned_vers[p] = VersionNumber[] - prunedp = pruned_vers[p] - eq_classes[p] = Dict{VersionNumber,Vector{VersionNumber}}() - eqclassp = eq_classes[p] - for cl in classes - if !isempty(cl) - vtop = maximum(cl) - push!(prunedp, vtop) - @assert !haskey(eqclassp, vtop) - eqclassp[vtop] = cl - end - end - sort!(prunedp) - end - # Put non-allowed versions into eq_classes - for (p, allowedp) in allowed - haskey(eq_classes, p) || continue - eqclassp = eq_classes[p] - for (vn, a) in allowedp - a && continue - eqclassp[vn] = [vn] - end - end - # Put all remaining packages into eq_classes - for (p, depsp) in deps - haskey(eq_classes, p) && continue - eq_classes[p] = Dict{VersionNumber,Vector{VersionNumber}}() - eqclassp = eq_classes[p] - for vn in keys(depsp) - eqclassp[vn] = [vn] - end - end - - - # Recompute deps. We could simplify them, but it's not worth it - new_deps = Dict{String,Dict{VersionNumber,Available}}() - - for (p,depsp) in filtered_deps - @assert !haskey(new_deps, p) - if !haskey(pruned_vers, p) - new_deps[p] = depsp - continue - end - new_deps[p] = Dict{VersionNumber,Available}() - pruned_versp = pruned_vers[p] - for (vn,a) in depsp - vn ∈ pruned_versp || continue - new_deps[p][vn] = a - end - end - - #println("pruning stats:") - #numvers = 0 - #numdeps = 0 - #for (p,d) in deps, (vn,a) in d - # numvers += 1 - # for r in a.requires - # numdeps += 1 - # end - #end - #numnewvers = 0 - #numnewdeps = 0 - #for (p,d) in new_deps, (vn,a) in d - # numnewvers += 1 - # for r in a.requires - # numnewdeps += 1 - # end - #end - #println(" before: vers=$numvers deps=$numdeps") - #println(" after: vers=$numnewvers deps=$numnewdeps") - #println() - - return new_deps, eq_classes -end -prune_versions(deps::Dict{String,Dict{VersionNumber,Available}}) = - prune_versions(Dict{String,VersionSet}(), deps, ResolveBacktrace()) -prune_versions(deps::Dict{String,Dict{VersionNumber,Available}}, bktrc::ResolveBacktrace) = - prune_versions(Dict{String,VersionSet}(), deps, bktrc) - -# Build a graph restricted to a subset of the packages -function subdeps(deps::Dict{String,Dict{VersionNumber,Available}}, pkgs::Set{String}) - sub_deps = Dict{String,Dict{VersionNumber,Available}}() - for p in pkgs - haskey(sub_deps, p) || (sub_deps[p] = Dict{VersionNumber,Available}()) - sub_depsp = sub_deps[p] - for (vn,a) in deps[p] - sub_depsp[vn] = a - end - end - - return sub_deps -end - -# Build a subgraph including only the (direct and indirect) dependencies -# of a given package set -function dependencies_subset(deps::Dict{String,Dict{VersionNumber,Available}}, pkgs::Set{String}) - staged::Set{String} = filter(p->p in keys(deps), pkgs) - allpkgs = copy(staged) - while !isempty(staged) - staged_next = Set{String}() - for p in staged, a in values(get(deps, p, Dict{VersionNumber,Available}())), rp in keys(a.requires) - rp ∉ allpkgs && rp ≠ "julia" && push!(staged_next, rp) - end - union!(allpkgs, staged_next) - staged = staged_next - end - - return subdeps(deps, allpkgs) -end - -# Build a subgraph including only the (direct and indirect) dependencies and dependants -# of a given package set -function undirected_dependencies_subset(deps::Dict{String,Dict{VersionNumber,Available}}, pkgs::Set{String}) - graph = Dict{String, Set{String}}() - - for (p,d) in deps - haskey(graph, p) || (graph[p] = Set{String}()) - for a in values(d), rp in keys(a.requires) - push!(graph[p], rp) - haskey(graph, rp) || (graph[rp] = Set{String}()) - push!(graph[rp], p) - end - end - - staged = pkgs - allpkgs = copy(pkgs) - while !isempty(staged) - staged_next = Set{String}() - for p in staged, rp in graph[p] - rp ∉ allpkgs && push!(staged_next, rp) - end - union!(allpkgs, staged_next) - staged = staged_next - end - - return subdeps(deps, allpkgs) -end - -function prune_dependencies(reqs::Requires, - deps::Dict{String,Dict{VersionNumber,Available}}, - bktrc::ResolveBacktrace = init_resolve_backtrace(reqs)) - deps, _ = prune_versions(reqs, deps, bktrc) - return deps -end - -end # module diff --git a/stdlib/OldPkg/src/read.jl b/stdlib/OldPkg/src/read.jl deleted file mode 100644 index a892c26389c25..0000000000000 --- a/stdlib/OldPkg/src/read.jl +++ /dev/null @@ -1,255 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module Read - -import OldPkg -import LibGit2 -import ..Cache, ..Reqs, ..PkgError, ..Dir -using ..Types - -readstrip(path...) = strip(read(joinpath(path...), String)) - -url(pkg::AbstractString) = readstrip(Dir.path("METADATA"), pkg, "url") -sha1(pkg::AbstractString, ver::VersionNumber) = - readstrip(Dir.path("METADATA"), pkg, "versions", string(ver), "sha1") - -function available(names=readdir("METADATA")) - pkgs = Dict{String,Dict{VersionNumber,Available}}() - for pkg in names - isfile("METADATA", pkg, "url") || continue - versdir = joinpath("METADATA", pkg, "versions") - isdir(versdir) || continue - for ver in readdir(versdir) - occursin(Base.VERSION_REGEX, ver) || continue - isfile(versdir, ver, "sha1") || continue - haskey(pkgs,pkg) || (pkgs[pkg] = Dict{VersionNumber,Available}()) - pkgs[pkg][VersionNumber(ver)] = Available( - readchomp(joinpath(versdir,ver,"sha1")), - Reqs.parse(joinpath(versdir,ver,"requires")) - ) - end - end - return pkgs -end -available(pkg::AbstractString) = get(available([pkg]),pkg,Dict{VersionNumber,Available}()) - -function latest(names=readdir("METADATA")) - pkgs = Dict{String,Available}() - for pkg in names - isfile("METADATA", pkg, "url") || continue - versdir = joinpath("METADATA", pkg, "versions") - isdir(versdir) || continue - pkgversions = VersionNumber[] - for ver in readdir(versdir) - occursin(Base.VERSION_REGEX, ver) || continue - isfile(versdir, ver, "sha1") || continue - push!(pkgversions, VersionNumber(ver)) - end - isempty(pkgversions) && continue - ver = string(maximum(pkgversions)) - pkgs[pkg] = Available( - readchomp(joinpath(versdir,ver,"sha1")), - Reqs.parse(joinpath(versdir,ver,"requires")) - ) - end - return pkgs -end - -isinstalled(pkg::AbstractString) = - pkg != "METADATA" && pkg != "REQUIRE" && pkg[1] != '.' && isdir(pkg) - -function isfixed(pkg::AbstractString, prepo::LibGit2.GitRepo, avail::Dict=available(pkg)) - isinstalled(pkg) || throw(PkgError("$pkg is not an installed package.")) - isfile("METADATA", pkg, "url") || return true - ispath(pkg, ".git") || return true - - LibGit2.isdirty(prepo) && return true - LibGit2.isattached(prepo) && return true - LibGit2.need_update(prepo) - if findall("REQUIRE", LibGit2.GitIndex(prepo)) === nothing - isfile(pkg,"REQUIRE") && return true - end - head = string(LibGit2.head_oid(prepo)) - for (ver,info) in avail - head == info.sha1 && return false - end - - cache = Cache.path(pkg) - cache_has_head = if isdir(cache) - crepo = LibGit2.GitRepo(cache) - LibGit2.iscommit(head, crepo) - else - false - end - res = true - try - for (ver,info) in avail - if cache_has_head && LibGit2.iscommit(info.sha1, crepo) - if LibGit2.is_ancestor_of(head, info.sha1, crepo) - res = false - break - end - elseif LibGit2.iscommit(info.sha1, prepo) - if LibGit2.is_ancestor_of(head, info.sha1, prepo) - res = false - break - end - else - @warn """Unknown $pkg commit $(info.sha1[1:8]), metadata may be - ahead of package cache""" maxlog=1 - end - end - finally - cache_has_head && LibGit2.close(crepo) - end - return res -end - -function ispinned(pkg::AbstractString) - ispath(pkg,".git") || return false - LibGit2.with(LibGit2.GitRepo, pkg) do repo - return ispinned(repo) - end -end - -function ispinned(prepo::LibGit2.GitRepo) - LibGit2.isattached(prepo) || return false - br = LibGit2.branch(prepo) - # note: regex is based on the naming scheme used in Entry.pin() - return occursin(r"^pinned\.[0-9a-f]{8}\.tmp$", br) -end - -function installed_version(pkg::AbstractString, prepo::LibGit2.GitRepo, avail::Dict=available(pkg)) - ispath(pkg,".git") || return typemin(VersionNumber) - - # get package repo head hash - local head - try - head = string(LibGit2.head_oid(prepo)) - catch ex - # refs/heads/master does not exist - if isa(ex,LibGit2.GitError) && - ex.code == LibGit2.Error.EUNBORNBRANCH - head = "" - else - rethrow(ex) - end - end - isempty(head) && return typemin(VersionNumber) - - vers = collect(keys(filter(#=ver,info=#p->p[2].sha1==head, avail))) - !isempty(vers) && return maximum(vers) - - cache = Cache.path(pkg) - cache_has_head = if isdir(cache) - crepo = LibGit2.GitRepo(cache) - LibGit2.iscommit(head, crepo) - else - false - end - ancestors = VersionNumber[] - descendants = VersionNumber[] - try - for (ver,info) in avail - sha1 = info.sha1 - base = if cache_has_head && LibGit2.iscommit(sha1, crepo) - LibGit2.merge_base(crepo, head, sha1) - elseif LibGit2.iscommit(sha1, prepo) - LibGit2.merge_base(prepo, head, sha1) - else - @warn """Unknown $pkg commit $(sha1[1:8]), metadata may be ahead - of package cache""" maxlog=1 - continue - end - string(base) == sha1 && push!(ancestors,ver) - string(base) == head && push!(descendants,ver) - end - finally - cache_has_head && LibGit2.close(crepo) - end - both = sort!(intersect(ancestors,descendants)) - isempty(both) || @warn "$pkg: some versions are both ancestors and descendants of head: $both" - if !isempty(descendants) - v = minimum(descendants) - return VersionNumber(v.major, v.minor, v.patch, ("",), ()) - elseif !isempty(ancestors) - v = maximum(ancestors) - return VersionNumber(v.major, v.minor, v.patch, (), ("",)) - else - return typemin(VersionNumber) - end -end - -function requires_path(pkg::AbstractString, avail::Dict=available(pkg)) - pkgreq = joinpath(pkg,"REQUIRE") - ispath(pkg,".git") || return pkgreq - repo = LibGit2.GitRepo(pkg) - head = LibGit2.with(LibGit2.GitRepo, pkg) do repo - LibGit2.isdirty(repo, "REQUIRE") && return pkgreq - LibGit2.need_update(repo) - if findall("REQUIRE", LibGit2.GitIndex(repo)) === nothing - isfile(pkgreq) && return pkgreq - end - string(LibGit2.head_oid(repo)) - end - for (ver,info) in avail - if head == info.sha1 - return joinpath("METADATA", pkg, "versions", string(ver), "requires") - end - end - return pkgreq -end - -requires_list(pkg::AbstractString, avail::Dict=available(pkg)) = - collect(keys(Reqs.parse(requires_path(pkg,avail)))) - -requires_dict(pkg::AbstractString, avail::Dict=available(pkg)) = - Reqs.parse(requires_path(pkg,avail)) - -function installed(avail::Dict=available()) - pkgs = Dict{String,Tuple{VersionNumber,Bool}}() - for pkg in readdir() - isinstalled(pkg) || continue - ap = get(avail,pkg,Dict{VersionNumber,Available}()) - if ispath(pkg,".git") - LibGit2.with(LibGit2.GitRepo, pkg) do repo - ver = installed_version(pkg, repo, ap) - fixed = isfixed(pkg, repo, ap) - pkgs[pkg] = (ver, fixed) - end - else - pkgs[pkg] = (typemin(VersionNumber), true) - end - end - return pkgs -end - -function fixed(avail::Dict=available(), inst::Dict=installed(avail), dont_update::Set{String}=Set{String}(), - julia_version::VersionNumber=VERSION) - pkgs = Dict{String,Fixed}() - for (pkg,(ver,fix)) in inst - (fix || pkg in dont_update) || continue - ap = get(avail,pkg,Dict{VersionNumber,Available}()) - pkgs[pkg] = Fixed(ver,requires_dict(pkg,ap)) - end - pkgs["julia"] = Fixed(julia_version) - return pkgs -end - -function free(inst::Dict=installed(), dont_update::Set{String}=Set{String}()) - pkgs = Dict{String,VersionNumber}() - for (pkg,(ver,fix)) in inst - (fix || pkg in dont_update) && continue - pkgs[pkg] = ver - end - return pkgs -end - -function issue_url(pkg::AbstractString) - ispath(pkg,".git") || return "" - m = match(LibGit2.GITHUB_REGEX, url(pkg)) - m === nothing && return "" - return "https://github.com/" * m.captures[1] * "/issues" -end - -end # module diff --git a/stdlib/OldPkg/src/reqs.jl b/stdlib/OldPkg/src/reqs.jl deleted file mode 100644 index a2404bf314814..0000000000000 --- a/stdlib/OldPkg/src/reqs.jl +++ /dev/null @@ -1,146 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module Reqs - -import Base: == -import OldPkg -import ..PkgError -using ..Types - -# representing lines of REQUIRE files - -abstract type Line end -struct Comment <: Line - content::AbstractString -end -struct Requirement <: Line - content::AbstractString - package::AbstractString - versions::VersionSet - system::Vector{AbstractString} - - function Requirement(content::AbstractString) - fields = split(replace(content, r"#.*$" => "")) - system = AbstractString[] - while !isempty(fields) && fields[1][1] == '@' - push!(system,popfirst!(fields)[2:end]) - end - isempty(fields) && throw(PkgError("invalid requires entry: $content")) - package = popfirst!(fields) - all(field->occursin(Base.VERSION_REGEX, field), fields) || - throw(PkgError("invalid requires entry for $package: $content")) - versions = map(VersionNumber, fields) - issorted(versions) || throw(PkgError("invalid requires entry for $package: $content")) - new(content, package, VersionSet(versions), system) - end - function Requirement(package::AbstractString, versions::VersionSet, system::Vector{AbstractString}=AbstractString[]) - content = "" - for os in system - content *= "@$os " - end - content *= package - if versions != VersionSet() - for ival in versions.intervals - (content *= " $(ival.lower)") - ival.upper < typemax(VersionNumber) && - (content *= " $(ival.upper)") - end - end - new(content, package, versions, system) - end -end - -==(a::Line, b::Line) = a.content == b.content -hash(s::Line, h::UInt) = hash(s.content, h + (0x3f5a631add21cb1a % UInt)) - -# general machinery for parsing REQUIRE files - -function read(readable::Vector{<:AbstractString}) - lines = Line[] - for line in readable - line = chomp(line) - push!(lines, occursin(r"^\s*(?:#|$)", line) ? Comment(line) : Requirement(line)) - end - return lines -end - -function read(readable::Union{IO,Base.AbstractCmd}) - lines = Line[] - for line in eachline(readable) - push!(lines, occursin(r"^\s*(?:#|$)", line) ? Comment(line) : Requirement(line)) - end - return lines -end -read(file::AbstractString) = isfile(file) ? open(read,file) : Line[] - -function write(io::IO, lines::Vector{Line}) - for line in lines - println(io, line.content) - end -end -function write(io::IO, reqs::Requires) - for pkg in sort!(collect(keys(reqs)), by=lowercase) - println(io, Requirement(pkg, reqs[pkg]).content) - end -end -write(file::AbstractString, r::Union{Vector{Line},Requires}) = open(io->write(io,r), file, "w") - -function parse(lines::Vector{Line}) - reqs = Requires() - for line in lines - if isa(line,Requirement) - if !isempty(line.system) - applies = false - if Sys.iswindows(); applies |= ("windows" in line.system); end - if Sys.isunix(); applies |= ("unix" in line.system); end - if Sys.isapple(); applies |= ("osx" in line.system); end - if Sys.islinux(); applies |= ("linux" in line.system); end - if Sys.isbsd(); applies |= ("bsd" in line.system); end - if Sys.iswindows(); applies &= !("!windows" in line.system); end - if Sys.isunix(); applies &= !("!unix" in line.system); end - if Sys.isapple(); applies &= !("!osx" in line.system); end - if Sys.islinux(); applies &= !("!linux" in line.system); end - if Sys.isbsd(); applies &= !("!bsd" in line.system); end - applies || continue - end - reqs[line.package] = haskey(reqs, line.package) ? - intersect(reqs[line.package], line.versions) : line.versions - end - end - return reqs -end -parse(x) = parse(read(x)) - -function dependents(packagename::AbstractString) - pkgs = AbstractString[] - cd(OldPkg.dir()) do - for (pkg,latest) in OldPkg.Read.latest() - if haskey(latest.requires, packagename) - push!(pkgs, pkg) - end - end - end - pkgs -end - -# add & rm – edit the content a requires file - -function add(lines::Vector{Line}, pkg::AbstractString, versions::VersionSet=VersionSet()) - v = VersionSet[] - filtered = filter(lines) do line - if !isa(line,Comment) && line.package == pkg && isempty(line.system) - push!(v, line.versions) - return false - end - return true - end - length(v) == 1 && v[1] == intersect(v[1],versions) && return copy(lines) - versions = reduce(intersect, v; init=versions) - push!(filtered, Requirement(pkg, versions)) -end - -rm(lines::Vector{Line}, pkg::AbstractString) = filter(lines) do line - isa(line,Comment) || line.package != pkg -end - -end # module diff --git a/stdlib/OldPkg/src/resolve.jl b/stdlib/OldPkg/src/resolve.jl deleted file mode 100644 index 6ef92cb2d7a09..0000000000000 --- a/stdlib/OldPkg/src/resolve.jl +++ /dev/null @@ -1,166 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module Resolve - -import OldPkg - -include("resolve/versionweight.jl") -include("resolve/interface.jl") -include("resolve/maxsum.jl") - -using ..Types, ..Query, .PkgToMaxSumInterface, .MaxSum -import ..PkgError - -export resolve, sanity_check - -# Use the max-sum algorithm to resolve packages dependencies -function resolve(reqs::Requires, deps::Dict{String,Dict{VersionNumber,Available}}) - # init interface structures - interface = Interface(reqs, deps) - - # attempt trivial solution first - ok, sol = greedysolver(interface) - if !ok - # trivial solution failed, use maxsum solver - graph = Graph(interface) - msgs = Messages(interface, graph) - - try - sol = maxsum(graph, msgs) - catch err - isa(err, UnsatError) || rethrow(err) - p = interface.pkgs[err.info] - # TODO: build tools to analyze the problem, and suggest to use them here. - msg = - """ - resolve is unable to satisfy package requirements. - The problem was detected when trying to find a feasible version - for package $p. - However, this only means that package $p is involved in an - unsatisfiable or difficult dependency relation, and the root of - the problem may be elsewhere. - """ - if msgs.num_nondecimated != graph.np - msg *= """ - (you may try increasing the value of the JULIA_PKGRESOLVE_ACCURACY - environment variable) - """ - end - ## @info "ERROR MESSAGE:\n" * msg - throw(PkgError(msg)) - end - - # verify solution (debug code) and enforce its optimality - @assert verify_solution(sol, interface) - enforce_optimality!(sol, interface) - @assert verify_solution(sol, interface) - end - - # return the solution as a Dict mapping package_name => sha1 - return compute_output_dict(sol, interface) -end - -# Scan dependencies for (explicit or implicit) contradictions -function sanity_check(deps::Dict{String,Dict{VersionNumber,Available}}, - pkgs::Set{String} = Set{String}()) - isempty(pkgs) || (deps = Query.undirected_dependencies_subset(deps, pkgs)) - - deps, eq_classes = Query.prune_versions(deps) - - ndeps = Dict{String,Dict{VersionNumber,Int}}() - - for (p,depsp) in deps - ndeps[p] = ndepsp = Dict{VersionNumber,Int}() - for (vn,a) in depsp - ndepsp[vn] = length(a.requires) - end - end - - vers = [(p,vn) for (p,d) in deps for vn in keys(d)] - sort!(vers, by=pvn->(-ndeps[pvn[1]][pvn[2]])) - - nv = length(vers) - - svdict = Dict{Tuple{String,VersionNumber},Int}(vers[i][1:2]=>i for i = 1:nv) - - checked = falses(nv) - - problematic = Vector{Tuple{String,VersionNumber,String}}() - - i = 1 - for (p,vn) in vers - ndeps[p][vn] == 0 && break - checked[i] && (i += 1; continue) - - fixed = Dict{String,Fixed}(p=>Fixed(vn, deps[p][vn].requires), "julia"=>Fixed(VERSION)) - sub_reqs = Dict{String,VersionSet}() - bktrc = Query.init_resolve_backtrace(sub_reqs, fixed) - Query.propagate_fixed!(sub_reqs, bktrc, fixed) - sub_deps = Query.dependencies_subset(deps, Set{String}([p])) - sub_deps, conflicts = Query.dependencies(sub_deps, fixed) - - try - for pkg in keys(sub_reqs) - if !haskey(sub_deps, pkg) - if "julia" in conflicts[pkg] - throw(PkgError("$pkg can't be installed because it has no versions that support $VERSION " * - "of julia. You may need to update METADATA by running `OldPkg.update()`")) - else - sconflicts = join(conflicts[pkg], ", ", " and ") - throw(PkgError("$pkg's requirements can't be satisfied because " * - "of the following fixed packages: $sconflicts")) - end - end - end - Query.check_requirements(sub_reqs, sub_deps, fixed) - sub_deps = Query.prune_dependencies(sub_reqs, sub_deps, bktrc) - catch err - isa(err, PkgError) || rethrow(err) - ## @info "ERROR MESSAGE:\n" * err.msg - for vneq in eq_classes[p][vn] - push!(problematic, (p, vneq, "")) - end - i += 1 - continue - end - interface = Interface(sub_reqs, sub_deps) - - red_pkgs = interface.pkgs - red_np = interface.np - red_spp = interface.spp - red_pvers = interface.pvers - - ok, sol = greedysolver(interface) - - if !ok - try - graph = Graph(interface) - msgs = Messages(interface, graph) - sol = maxsum(graph, msgs) - ok = verify_solution(sol, interface) - @assert ok - catch err - isa(err, UnsatError) || rethrow(err) - pp = red_pkgs[err.info] - for vneq in eq_classes[p][vn] - push!(problematic, (p, vneq, pp)) - end - end - end - if ok - for p0 = 1:red_np - s0 = sol[p0] - if s0 != red_spp[p0] - j = svdict[(red_pkgs[p0], red_pvers[p0][s0])] - checked[j] = true - end - end - checked[i] = true - end - i += 1 - end - - return sort!(problematic) -end - -end # module diff --git a/stdlib/OldPkg/src/resolve/fieldvalue.jl b/stdlib/OldPkg/src/resolve/fieldvalue.jl deleted file mode 100644 index adaf53e91d62d..0000000000000 --- a/stdlib/OldPkg/src/resolve/fieldvalue.jl +++ /dev/null @@ -1,128 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module FieldValues - -using ...VersionWeights - -export FieldValue, Field, validmax, secondmax - -# FieldValue is a hierarchical numeric type with 6 levels. -# When summing two FieldValues, the levels are summed independently. -# When comparing them, lower levels take precedence. -# The levels are used as such: -# l0 : for hard constraints (dependencies and requirements) -# l1 : for favoring higher versions of the explicitly required -# packages -# l2 : for favoring higher versions of all other packages -# l3 : for favoring uninstallation of non-needed packages -# l4 : for favoring dependants over dependencies -# l5 : for symmetry-breaking random noise -# -struct FieldValue - l0::Int - l1::VersionWeight - l2::VersionWeight - l3::Int - l4::Int - l5::Int128 -end -FieldValue(l0::Integer, l1::VersionWeight, l2::VersionWeight, l3::Integer, l4::Integer) = FieldValue(l0, l1, l2, l3, l4, Int128(0)) -FieldValue(l0::Integer, l1::VersionWeight, l2::VersionWeight, l3::Integer) = FieldValue(l0, l1, l2, l3, 0) -FieldValue(l0::Integer, l1::VersionWeight, l2::VersionWeight) = FieldValue(l0, l1, l2, 0) -FieldValue(l0::Integer, l1::VersionWeight) = FieldValue(l0, l1, zero(VersionWeight)) -FieldValue(l0::Integer) = FieldValue(l0, zero(VersionWeight)) -FieldValue() = FieldValue(0) - -# This isn't nice, but it's for debugging only anyway -function Base.show(io::IO, a::FieldValue) - print(io, a.l0) - a == FieldValue(a.l0) && return - print(io, ".", a.l1) - a == FieldValue(a.l0, a.l1) && return - print(io, ".", a.l2) - a == FieldValue(a.l0, a.l1, a.l2) && return - print(io, ".", a.l3) - a == FieldValue(a.l0, a.l1, a.l2, a.l3) && return - print(io, ".", a.l4) - a == FieldValue(a.l0, a.l1, a.l2, a.l3, a.l4) && return - print(io, ".", a.l5) - return -end - -const Field = Vector{FieldValue} - -Base.zero(::Type{FieldValue}) = FieldValue() - -Base.typemin(::Type{FieldValue}) = (x=typemin(Int); y=typemin(VersionWeight); FieldValue(x, y, y, x, x, typemin(Int128))) - -Base.:-(a::FieldValue, b::FieldValue) = FieldValue(a.l0-b.l0, a.l1-b.l1, a.l2-b.l2, a.l3-b.l3, a.l4-b.l4, a.l5-b.l5) -Base.:+(a::FieldValue, b::FieldValue) = FieldValue(a.l0+b.l0, a.l1+b.l1, a.l2+b.l2, a.l3+b.l3, a.l4+b.l4, a.l5+b.l5) - -function Base.isless(a::FieldValue, b::FieldValue) - a.l0 < b.l0 && return true - a.l0 > b.l0 && return false - c = cmp(a.l1, b.l1) - c < 0 && return true - c > 0 && return false - c = cmp(a.l2, b.l2) - c < 0 && return true - c > 0 && return false - a.l3 < b.l3 && return true - a.l3 > b.l3 && return false - a.l4 < b.l4 && return true - a.l4 > b.l4 && return false - a.l5 < b.l5 && return true - return false -end - -Base.:(==)(a::FieldValue, b::FieldValue) = - a.l0 == b.l0 && a.l1 == b.l1 && a.l2 == b.l2 && a.l3 == b.l3 && a.l4 == b.l4 && a.l5 == b.l5 - -Base.abs(a::FieldValue) = FieldValue(abs(a.l0), abs(a.l1), abs(a.l2), abs(a.l3), abs(a.l4), abs(a.l5)) - -Base.copy(a::FieldValue) = FieldValue(a.l0, copy(a.l1), copy(a.l2), a.l3, a.l4, a.l5) - -function Base.unsafe_copyto!(dest::Field, doffs, src::Field, soffs, n) - for i = 1:n - dest[doffs+i-1] = copy(src[soffs+i-1]) - end - return dest -end - -# if the maximum field has l0 < 0, it means that -# some hard constraint is being violated -validmax(a::FieldValue) = a.l0 >= 0 - -# like usual argmax, but favors the highest indices -# in case of a tie -function Base.argmax(f::Field) - m = typemin(FieldValue) - mi = 0 - for j = length(f):-1:1 - if f[j] > m - m = f[j] - mi = j - end - end - @assert mi != 0 - return mi -end - -# secondmax returns the (normalized) value of the second maximum in a -# field. It's used to determine the most polarized field. -function secondmax(f::Field) - m = typemin(FieldValue) - m2 = typemin(FieldValue) - for i = 1:length(f) - a = f[i] - if a > m - m2 = m - m = a - elseif a > m2 - m2 = a - end - end - return m2 - m -end - -end diff --git a/stdlib/OldPkg/src/resolve/interface.jl b/stdlib/OldPkg/src/resolve/interface.jl deleted file mode 100644 index aca3c12f42a1f..0000000000000 --- a/stdlib/OldPkg/src/resolve/interface.jl +++ /dev/null @@ -1,364 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module PkgToMaxSumInterface - -using ...Types, ...Query, ..VersionWeights - -export Interface, compute_output_dict, greedysolver, - verify_solution, enforce_optimality! - -# A collection of objects which allow interfacing external (Pkg) and -# internal (MaxSum) representation -mutable struct Interface - # requirements and dependencies, in external representation - reqs::Requires - deps::Dict{String,Dict{VersionNumber,Available}} - - # packages list - pkgs::Vector{String} - - # number of packages - np::Int - - # states per package: one per version + uninstalled - spp::Vector{Int} - - # package dict: associates an index to each package name - pdict::Dict{String,Int} - - # package versions: for each package, keep the list of the - # possible version numbers; this defines a - # mapping from version numbers of a package - # to indices - pvers::Vector{Vector{VersionNumber}} - - # versions dict: associates a version index to each package - # version; such that - # pvers[p0][vdict[p0][vn]] = vn - vdict::Vector{Dict{VersionNumber,Int}} - - # version weights: the weight for each version of each package - # (versions include the uninstalled state; the - # higher the weight, the more favored the version) - vweight::Vector{Vector{VersionWeight}} - - function Interface(reqs::Requires, deps::Dict{String,Dict{VersionNumber,Available}}) - # generate pkgs - pkgs = sort!(String[keys(deps)...]) - - np = length(pkgs) - - # generate pdict - pdict = Dict{String,Int}(pkgs[i] => i for i = 1:np) - - # generate spp and pvers - spp = Vector{Int}(undef, np) - - pvers = [VersionNumber[] for i = 1:np] - - for (p,depsp) in deps, vn in keys(depsp) - p0 = pdict[p] - push!(pvers[p0], vn) - end - for p0 = 1:np - sort!(pvers[p0]) - spp[p0] = length(pvers[p0]) + 1 - end - - # generate vdict - vdict = [Dict{VersionNumber,Int}() for p0 = 1:np] - for (p,depsp) in deps - p0 = pdict[p] - vdict0 = vdict[p0] - pvers0 = pvers[p0] - for vn in keys(depsp) - for v0 in 1:length(pvers0) - if pvers0[v0] == vn - vdict0[vn] = v0 - break - end - end - end - end - - ## generate wveights: - vweight = Vector{Vector{VersionWeight}}(undef, np) - for p0 = 1:np - pvers0 = pvers[p0] - spp0 = spp[p0] - vweight0 = vweight[p0] = Vector{VersionWeight}(undef, spp0) - for v0 = 1:spp0-1 - vweight0[v0] = VersionWeight(pvers0[v0]) - end - vweight0[spp0] = VersionWeight(v"0") # last version means uninstalled - end - - return new(reqs, deps, pkgs, np, spp, pdict, pvers, vdict, vweight) - end -end - -# The output format is a Dict which associates a VersionNumber to each installed package name -function compute_output_dict(sol::Vector{Int}, interface::Interface) - pkgs = interface.pkgs - np = interface.np - pvers = interface.pvers - spp = interface.spp - - want = Dict{String,VersionNumber}() - for p0 = 1:np - p = pkgs[p0] - s = sol[p0] - if s != spp[p0] - v = pvers[p0][s] - want[p] = v - end - end - - return want -end - -# Produce a trivial solution: try to maximize each version; -# bail out as soon as some non-trivial requirements are detected. -function greedysolver(interface::Interface) - reqs = interface.reqs - deps = interface.deps - spp = interface.spp - pdict = interface.pdict - pvers = interface.pvers - np = interface.np - - # initialize solution: all uninstalled - sol = [spp[p0] for p0 = 1:np] - - # set up required packages to their highest allowed versions - for (rp,rvs) in reqs - rp0 = pdict[rp] - # look for the highest version which satisfies the requirements - rv = spp[rp0] - 1 - while rv > 0 - rvn = pvers[rp0][rv] - rvn ∈ rvs && break - rv -= 1 - end - @assert rv > 0 - sol[rp0] = rv - end - - # we start from required packages and explore the graph - # following dependencies - staged = Set{String}(keys(reqs)) - seen = copy(staged) - - while !isempty(staged) - staged_next = Set{String}() - for p in staged - p0 = pdict[p] - @assert sol[p0] < spp[p0] - vn = pvers[p0][sol[p0]] - a = deps[p][vn] - - # scan dependencies - for (rp,rvs) in a.requires - rp0 = pdict[rp] - # look for the highest version which satisfies the requirements - rv = spp[rp0] - 1 - while rv > 0 - rvn = pvers[rp0][rv] - rvn ∈ rvs && break - rv -= 1 - end - # if we found a version, and the package was uninstalled - # or the same version was already selected, we're ok; - # otherwise we can't be sure what the optimal configuration is - # and we bail out - if rv > 0 && (sol[rp0] == spp[rp0] || sol[rp0] == rv) - sol[rp0] = rv - else - return (false, Int[]) - end - - rp ∈ seen || push!(staged_next, rp) - end - end - union!(seen, staged_next) - staged = staged_next - end - - @assert verify_solution(sol, interface) - - return true, sol -end - -# verifies that the solution fulfills all hard constraints -# (requirements and dependencies) -function verify_solution(sol::Vector{Int}, interface::Interface) - reqs = interface.reqs - deps = interface.deps - spp = interface.spp - pdict = interface.pdict - pvers = interface.pvers - vdict = interface.vdict - - # verify requirements - for (p,vs) in reqs - p0 = pdict[p] - sol[p0] != spp[p0] || return false - vn = pvers[p0][sol[p0]] - vn ∈ vs || return false - end - - # verify dependencies - for (p,d) in deps - p0 = pdict[p] - vdict0 = vdict[p0] - for (vn,a) in d - v0 = vdict0[vn] - if sol[p0] == v0 - for (rp, rvs) in a.requires - p1 = pdict[rp] - if sol[p1] == spp[p1] - println(""" - VERIFICATION ERROR: REQUIRED DEPENDENCY NOT INSTALLED - package p=$p (p0=$p0) version=$vn (v0=$v0) requires package rp=$rp in version set rvs=$rvs - but package $rp is not being installed (p1=$p1 sol[p1]=$(sol[p1]) == spp[p1]=$(spp[p1])) - """) - return false - end - vn1 = pvers[p1][sol[p1]] - if vn1 ∉ rvs - println(""" - VERIFICATION ERROR: INVALID VERSION - package p=$p (p0=$p0) version=$vn (v0=$v0) requires package rp=$rp in version set rvs=$rvs - but package $rp version is being set to $vn1 (p1=$p1 sol[p1]=$(sol[p1]) spp[p1]=$(spp[p1])) - """) - return false - end - end - end - end - end - return true -end - -# Push the given solution to a local optimium if needed -function enforce_optimality!(sol::Vector{Int}, interface::Interface) - np = interface.np - - reqs = interface.reqs - deps = interface.deps - pkgs = interface.pkgs - spp = interface.spp - pdict = interface.pdict - pvers = interface.pvers - vdict = interface.vdict - - # prepare some useful structures - # pdeps[p0][v0] has all dependencies of package p0 version v0 - pdeps = [Vector{Requires}(undef, spp[p0]-1) for p0 = 1:np] - # prevdeps[p1][p0][v0] is the VersionSet of package p1 which package p0 version v0 - # depends upon - prevdeps = [Dict{Int,Dict{Int,VersionSet}}() for p0 = 1:np] - - for (p,d) in deps - p0 = pdict[p] - vdict0 = vdict[p0] - for (vn,a) in d - v0 = vdict0[vn] - pdeps[p0][v0] = a.requires - for (rp, rvs) in a.requires - p1 = pdict[rp] - if !haskey(prevdeps[p1], p0) - prevdeps[p1][p0] = Dict{Int,VersionSet}() - end - prevdeps[p1][p0][v0] = rvs - end - end - end - - restart = true - while restart - restart = false - for p0 = 1:np - s0 = sol[p0] - if s0 >= spp[p0] - 1 - # either the package is not installed, - # or it's already at the maximum version - continue - end - viol = false - # check if the higher version has a depencency which - # would be violated by the state of the remaining packages - for (p,vs) in pdeps[p0][s0+1] - p1 = pdict[p] - if sol[p1] == spp[p1] - # the dependency is violated because - # the other package is not being installed - viol = true - break - end - vn = pvers[p1][sol[p1]] - if vn ∉ vs - # the dependency is violated because - # the other package version is invalid - viol = true - break - end - end - viol && continue - - # check if bumping the version would violate some - # dependency of another package - for (p1,d) in prevdeps[p0] - vs = get(d, sol[p1], nothing) - vs === nothing && continue - vn = pvers[p0][s0+1] - if vn ∉ vs - # bumping the version would violate - # the dependency - viol = true - break - end - end - viol && continue - # So the solution is non-optimal: we bump it manually - #@debug "Nonoptimal solution for package `$(interface.pkgs[p0])`: sol=$s0" - sol[p0] += 1 - restart = true - end - end - - # Finally uninstall unneeded packages: - # start from the required ones and keep only - # the packages reachable from them along the graph - uninst = trues(np) - staged = Set{String}(keys(reqs)) - seen = copy(staged) - - while !isempty(staged) - staged_next = Set{String}() - for p in staged - p0 = pdict[p] - uninst[p0] = false - @assert sol[p0] < spp[p0] - vn = pvers[p0][sol[p0]] - a = deps[p][vn] - - # scan dependencies - for (rp,rvs) in a.requires - rp0 = pdict[rp] - @assert sol[rp0] < spp[rp0] && pvers[rp0][sol[rp0]] ∈ rvs - rp ∈ seen || push!(staged_next, rp) - end - end - union!(seen, staged_next) - staged = staged_next - end - - for p0 in findall(uninst) - sol[p0] = spp[p0] - end - - return -end - -end diff --git a/stdlib/OldPkg/src/resolve/maxsum.jl b/stdlib/OldPkg/src/resolve/maxsum.jl deleted file mode 100644 index 50c802a3dff2d..0000000000000 --- a/stdlib/OldPkg/src/resolve/maxsum.jl +++ /dev/null @@ -1,524 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module MaxSum - -include("fieldvalue.jl") - -using .FieldValues, ..VersionWeights, ..PkgToMaxSumInterface - -export UnsatError, Graph, Messages, maxsum - -# An exception type used internally to signal that an unsatisfiable -# constraint was detected -struct UnsatError <: Exception - info -end - -# Some parameters to drive the decimation process -mutable struct MaxSumParams - nondec_iterations # number of initial iterations before starting - # decimation - dec_interval # number of iterations between decimations - dec_fraction # fraction of nodes to decimate at every decimation - # step - - function MaxSumParams() - accuracy = parse(Int, get(ENV, "JULIA_PKGRESOLVE_ACCURACY", "1")) - if accuracy <= 0 - error("JULIA_PKGRESOLVE_ACCURACY must be > 0") - end - nondec_iterations = accuracy * 20 - dec_interval = accuracy * 10 - dec_fraction = 0.05 / accuracy - return new(nondec_iterations, dec_interval, dec_fraction) - end -end - -# Graph holds the graph structure onto which max-sum is run, in -# sparse format -mutable struct Graph - # adjacency matrix: - # for each package, has the list of neighbors - # indices (both dependencies and dependants) - gadj::Vector{Vector{Int}} - - # compatibility mask: - # for each package p0 has a list of bool masks. - # Each entry in the list gmsk[p0] is relative to the - # package p1 as read from gadj[p0]. - # Each mask has dimension spp1 x spp0, where - # spp0 is the number of states of p0, and - # spp1 is the number of states of p1. - gmsk::Vector{Vector{BitMatrix}} - - # dependency direction: - # keeps track of which direction the dependency goes - # takes 3 values: - # 1 = dependant - # -1 = dependency - # 0 = both - # Used to break symmetry between dependants and - # dependencies (introduces a FieldValue at level l3). - # The "both" case is for when there are dependency - # relations which go both ways, in which case the - # noise is left to discriminate in case of ties - gdir::Vector{Vector{Int}} - - # adjacency dict: - # allows one to retrieve the indices in gadj, so that - # gadj[p0][adjdict[p1][p0]] = p1 - # ("At which index does package p1 appear in gadj[p0]?") - adjdict::Vector{Dict{Int,Int}} - - # states per package: same as in Interface - spp::Vector{Int} - - # update order: shuffled at each iteration - perm::Vector{Int} - - # number of packages (all Vectors above have this length) - np::Int - - function Graph(interface::Interface) - deps = interface.deps - np = interface.np - - spp = interface.spp - pdict = interface.pdict - pvers = interface.pvers - vdict = interface.vdict - - gadj = [Int[] for i = 1:np] - gmsk = [BitMatrix[] for i = 1:np] - gdir = [Int[] for i = 1:np] - adjdict = [Dict{Int,Int}() for i = 1:np] - - for (p,d) in deps - p0 = pdict[p] - vdict0 = vdict[p0] - for (vn,a) in d - v0 = vdict0[vn] - for (rp, rvs) in a.requires - p1 = pdict[rp] - - j0 = 1 - while j0 <= length(gadj[p0]) && gadj[p0][j0] != p1 - j0 += 1 - end - j1 = 1 - while j1 <= length(gadj[p1]) && gadj[p1][j1] != p0 - j1 += 1 - end - @assert (j0 > length(gadj[p0]) && j1 > length(gadj[p1])) || - (j0 <= length(gadj[p0]) && j1 <= length(gadj[p1])) - - if j0 > length(gadj[p0]) - push!(gadj[p0], p1) - push!(gadj[p1], p0) - j0 = length(gadj[p0]) - j1 = length(gadj[p1]) - - adjdict[p1][p0] = j0 - adjdict[p0][p1] = j1 - - bm = trues(spp[p1], spp[p0]) - bmt = trues(spp[p0], spp[p1]) - - push!(gmsk[p0], bm) - push!(gmsk[p1], bmt) - - push!(gdir[p0], 1) - push!(gdir[p1], -1) - else - bm = gmsk[p0][j0] - bmt = gmsk[p1][j1] - if gdir[p0][j0] == -1 - gdir[p0][j0] = 0 - gdir[p1][j1] = 0 - end - end - - for v1 = 1:length(pvers[p1]) - if pvers[p1][v1] ∉ rvs - bm[v1, v0] = false - bmt[v0, v1] = false - end - end - bm[end,v0] = false - bmt[v0,end] = false - end - end - end - - perm = [1:np;] - - return new(gadj, gmsk, gdir, adjdict, spp, perm, np) - end -end - -# Messages has the cavity messages and the total fields, and -# gets updated iteratively (and occasionally decimated) until -# convergence -mutable struct Messages - # cavity incoming messages: for each package p0, - # for each neighbor p1 of p0, - # msg[p0][p1] is a vector of length spp[p0] - # messages are normalized (i.e. the max is always 0) - msg::Vector{Vector{Field}} - - # overall fields: for each package p0, - # fld[p0] is a vector of length spp[p0] - # fields are not normalized - fld::Vector{Field} - - # backup of the initial value of fld, to be used when resetting - initial_fld::Vector{Field} - - # keep track of which variables have been decimated - decimated::BitVector - num_nondecimated::Int - - function Messages(interface::Interface, graph::Graph) - reqs = interface.reqs - pkgs = interface.pkgs - np = interface.np - spp = interface.spp - pvers = interface.pvers - pdict = interface.pdict - vweight = interface.vweight - - # a "deterministic noise" function based on hashes - function noise(p0::Int, v0::Int) - s = pkgs[p0] * string(v0 == spp[p0] ? "UNINST" : pvers[p0][v0]) - Int128(hash(s)) - end - - # external fields: there are 2 terms, a noise to break potential symmetries - # and one to favor newest versions over older, and no-version over all - fld = [[FieldValue(0, zero(VersionWeight), vweight[p0][v0], (v0==spp[p0]), 0, noise(p0,v0)) for v0 = 1:spp[p0]] for p0 = 1:np] - - # enforce requirements - for (rp, rvs) in reqs - p0 = pdict[rp] - pvers0 = pvers[p0] - fld0 = fld[p0] - for v0 = 1:spp[p0]-1 - vn = pvers0[v0] - if !in(vn, rvs) - # the state is forbidden by requirements - fld0[v0] = FieldValue(-1) - else - # the state is one of those explicitly requested: - # favor it at a higher level than normal (upgrade - # FieldValue from l2 to l1) - fld0[v0] += FieldValue(0, vweight[p0][v0], -vweight[p0][v0]) - end - end - # the uninstalled state is forbidden by requirements - fld0[spp[p0]] = FieldValue(-1) - end - # normalize fields - for p0 = 1:np - m = maximum(fld[p0]) - for v0 = 1:spp[p0] - fld[p0][v0] -= m - end - end - - initial_fld = deepcopy(fld) - - # initialize cavity messages to 0 - gadj = graph.gadj - msg = [[zeros(FieldValue, spp[p0]) for p1 = 1:length(gadj[p0])] for p0 = 1:np] - - return new(msg, fld, initial_fld, falses(np), np) - end -end - -function getsolution(msgs::Messages) - # the solution is just the location of the maximum in - # each field - - fld = msgs.fld - np = length(fld) - sol = Vector{Int}(undef, np) - for p0 = 1:np - fld0 = fld[p0] - s0 = argmax(fld0) - if !validmax(fld0[s0]) - throw(UnsatError(p0)) - end - sol[p0] = s0 - end - return sol -end - -# This is the core of the max-sum solver: -# for a given node p0 (i.e. a package) updates all -# input cavity messages and fields of its neighbors -function update(p0::Int, graph::Graph, msgs::Messages) - gadj = graph.gadj - gmsk = graph.gmsk - gdir = graph.gdir - adjdict = graph.adjdict - spp = graph.spp - np = graph.np - msg = msgs.msg - fld = msgs.fld - decimated = msgs.decimated - - maxdiff = zero(FieldValue) - - gadj0 = gadj[p0] - msg0 = msg[p0] - fld0 = fld[p0] - spp0 = spp[p0] - adjdict0 = adjdict[p0] - - # iterate over all neighbors of p0 - for j0 in 1:length(gadj0) - - p1 = gadj0[j0] - decimated[p1] && continue - j1 = adjdict0[p1] - #@assert j0 == adjdict[p1][p0] - bm1 = gmsk[p1][j1] - dir1 = gdir[p1][j1] - spp1 = spp[p1] - msg1 = msg[p1] - - # compute the output cavity message p0->p1 - cavmsg = fld0 - msg0[j0] - - if dir1 == -1 - # p0 depends on p1 - for v0 = 1:spp0-1 - cavmsg[v0] += FieldValue(0, VersionWeight(0), VersionWeight(0), 0, v0) - end - end - - # keep the old input cavity message p0->p1 - oldmsg = msg1[j1] - - # init the new message to minus infinity - newmsg = [FieldValue(-1) for v1 = 1:spp1] - - # compute the new message by passing cavmsg - # through the constraint encoded in the bitmask - # (nearly equivalent to: - # newmsg = [maximum(cavmsg[bm1[:,v1]]) for v1 = 1:spp1] - # except for the gnrg term) - m = FieldValue(-1) - for v1 = 1:spp1 - for v0 = 1:spp0 - if bm1[v0, v1] - newmsg[v1] = max(newmsg[v1], cavmsg[v0]) - end - end - if dir1 == 1 && v1 != spp1 - # p1 depends on p0 - newmsg[v1] += FieldValue(0, VersionWeight(0), VersionWeight(0), 0, v1) - end - m = max(m, newmsg[v1]) - end - if !validmax(m) - # No state available without violating some - # hard constraint - throw(UnsatError(p1)) - end - - # normalize the new message - for v1 = 1:spp1 - newmsg[v1] -= m - end - - diff = newmsg - oldmsg - maxdiff = max(maxdiff, maximum(abs.(diff))) - - # update the field of p1 - fld1 = fld[p1] - for v1 = 1:spp1 - fld1[v1] += diff[v1] - end - - # put the newly computed message in place - msg1[j1] = newmsg - end - return maxdiff -end - -# A simple shuffling machinery for the update order in iterate() -# (woulnd't pass any random quality test but it's arguably enough) -let step=1 -global shuffleperm, shuffleperminit -shuffleperminit() = (step = 1) -function shuffleperm(graph::Graph) - perm = graph.perm - np = graph.np - for j = np:-1:2 - k = mod(step,j)+1 - perm[j], perm[k] = perm[k], perm[j] - step += isodd(j) ? 1 : k - end - #@assert isperm(perm) -end -end - -# Call update for all nodes (i.e. packages) in -# random order -function iterate(graph::Graph, msgs::Messages) - np = graph.np - - maxdiff = zero(FieldValue) - shuffleperm(graph) - perm = graph.perm - for p0 in perm - maxdiff0 = update(p0, graph, msgs) - maxdiff = max(maxdiff, maxdiff0) - end - return maxdiff -end - -function decimate1(p0::Int, graph::Graph, msgs::Messages) - decimated = msgs.decimated - fld = msgs.fld - adjdict = graph.adjdict - gmsk = graph.gmsk - - @assert !decimated[p0] - fld0 = fld[p0] - s0 = argmax(fld0) - # only do the decimation if it is consistent with - # the previously decimated nodes - for p1 in findall(decimated) - haskey(adjdict[p0], p1) || continue - s1 = argmax(fld[p1]) - j1 = adjdict[p0][p1] - gmsk[p1][j1][s0,s1] || return false - end - #println("DECIMATING $p0 (s0=$s0 fld=$fld0)") - for v0 = 1:length(fld0) - v0 == s0 && continue - fld0[v0] = FieldValue(-1) - end - msgs.decimated[p0] = true - msgs.num_nondecimated -= 1 - return true -end - -function reset_messages!(msgs::Messages) - msg = msgs.msg - fld = msgs.fld - initial_fld = msgs.initial_fld - decimated = msgs.decimated - np = length(fld) - for p0 = 1:np - map(m->fill!(m, zero(FieldValue)), msg[p0]) - decimated[p0] && continue - fld[p0] = copy(initial_fld[p0]) - end - return msgs -end - -# If normal convergence fails (or is too slow) fix the most -# polarized packages by adding extra infinite fields on every state -# but the maximum -function decimate(n::Int, graph::Graph, msgs::Messages) - #println("DECIMATING $n NODES") - adjdict = graph.adjdict - fld = msgs.fld - decimated = msgs.decimated - fldorder = sortperm(fld, by=secondmax) - did_dec = false - for p0 in fldorder - decimated[p0] && continue - did_dec |= decimate1(p0, graph, msgs) - n -= 1 - n == 0 && break - end - @assert n == 0 - if !did_dec - # did not succeed in decimating anything; - # try to decimate at least one node - for p0 in fldorder - decimated[p0] && continue - if decimate1(p0, graph, msgs) - did_dec = true - break - end - end - end - if !did_dec - # still didn't succeed, give up - p0 = first(fldorder[.~(decimated)]) - throw(UnsatError(p0)) - end - - reset_messages!(msgs) - return -end - -# In case ties still exist at convergence, break them and -# keep converging -function break_ties(msgs::Messages) - fld = msgs.fld - unbroken_ties = Int[] - for p0 = 1:length(fld) - fld0 = fld[p0] - z = 0 - m = typemin(FieldValue) - for v0 = 1:length(fld0) - if fld0[v0] > m - m = fld0[v0] - z = 1 - elseif fld0[v0] == m - z += 1 - end - end - if z > 1 - #println("TIE! p0=$p0") - decimate1(p0, msgs) && return false - push!(unbroken_ties, p0) - end - end - # If there were ties, but none were broken, bail out - isempty(unbroken_ties) || throw(PkgError(first(unbroken_ties))) - return true -end - -# Iterative solver: run iterate() until convergence -# (occasionally calling decimate()) -function maxsum(graph::Graph, msgs::Messages) - params = MaxSumParams() - - it = 0 - shuffleperminit() - while true - it += 1 - maxdiff = iterate(graph, msgs) - #println("it = $it maxdiff = $maxdiff") - - if maxdiff == zero(FieldValue) - break_ties(msgs) && break - continue - end - if it >= params.nondec_iterations && - (it - params.nondec_iterations) % params.dec_interval == 0 - numdec = clamp(floor(Int, params.dec_fraction * graph.np), 1, msgs.num_nondecimated) - decimate(numdec, graph, msgs) - msgs.num_nondecimated == 0 && break - end - end - - # Finally, decimate everything just to - # check against inconsistencies - # (old_numnondec is saved just to prevent - # wrong messages about accuracy) - old_numnondec = msgs.num_nondecimated - decimate(msgs.num_nondecimated, graph, msgs) - msgs.num_nondecimated = old_numnondec - - return getsolution(msgs) -end - -end diff --git a/stdlib/OldPkg/src/resolve/versionweight.jl b/stdlib/OldPkg/src/resolve/versionweight.jl deleted file mode 100644 index 07ecfeb2eee18..0000000000000 --- a/stdlib/OldPkg/src/resolve/versionweight.jl +++ /dev/null @@ -1,228 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module VersionWeights - -export VersionWeight - -struct HierarchicalValue{T} - v::Vector{T} - rest::T -end - -HierarchicalValue(v::Vector{T}) where {T} = HierarchicalValue{T}(v, zero(T)) -HierarchicalValue(T::Type) = HierarchicalValue(T[]) - -Base.zero(::Type{HierarchicalValue{T}}) where {T} = HierarchicalValue(T) - -Base.typemin(::Type{HierarchicalValue{T}}) where {T} = HierarchicalValue(T[], typemin(T)) - -for f in (:-, :+) - @eval function Base.$f(a::HierarchicalValue{T}, b::HierarchicalValue{T}) where T - av = a.v - bv = b.v - la = length(a.v) - lb = length(b.v) - l0 = min(la, lb) - l1 = max(la, lb) - ld = la - lb - rv = Vector{T}(undef, l1) - rf = ($f)(a.rest, b.rest) - @inbounds for i = 1:l0 - rv[i] = ($f)(av[i], bv[i]) - end - @inbounds for i = l0+1:l0+ld - rv[i] = ($f)(av[i], b.rest) - end - @inbounds for i = l0+1:l0-ld - rv[i] = ($f)(a.rest, bv[i]) - end - return HierarchicalValue(rv, rf) - end -end - -Base.:-(a::HierarchicalValue) = HierarchicalValue(-a.v, -a.rest) - -function Base.cmp(a::HierarchicalValue{T}, b::HierarchicalValue{T}) where T - av = a.v - bv = b.v - la = length(a.v) - lb = length(b.v) - l0 = min(la, lb) - l1 = max(la, lb) - ld = la - lb - @inbounds for i = 1:l0 - c = cmp(av[i], bv[i]); c != 0 && return c - end - @inbounds for i = l0+1:l0+ld - c = cmp(av[i], b.rest); c != 0 && return c - end - @inbounds for i = l0+1:l0-ld - c = cmp(a.rest, bv[i]); c != 0 && return c - end - return cmp(a.rest, b.rest) -end -Base.isless(a::HierarchicalValue{T}, b::HierarchicalValue{T}) where {T} = cmp(a,b) < 0 -Base.:(==)(a::HierarchicalValue{T}, b::HierarchicalValue{T}) where {T} = cmp(a,b) == 0 - -Base.abs(a::HierarchicalValue{T}) where {T} = HierarchicalValue(T[abs(x) for x in a.v], abs(a.rest)) - -Base.copy(a::HierarchicalValue{T}) where {T} = HierarchicalValue(T[copy(x) for x in a.v], copy(a.rest)) - -struct VWPreBuildItem - nonempty::Int - s::HierarchicalValue{Int} - i::Int -end -VWPreBuildItem() = VWPreBuildItem(0, HierarchicalValue(Int), 0) -VWPreBuildItem(i::Integer) = VWPreBuildItem(1, HierarchicalValue(Int), i) -VWPreBuildItem(s::String) = VWPreBuildItem(1, HierarchicalValue(Int[s...]), 0) - -Base.zero(::Type{VWPreBuildItem}) = VWPreBuildItem() - -Base.typemin(::Type{VWPreBuildItem}) = (x=typemin(Int); VWPreBuildItem(x, typemin(HierarchicalValue{Int}), x)) - -Base.:-(a::VWPreBuildItem, b::VWPreBuildItem) = VWPreBuildItem(a.nonempty-b.nonempty, a.s-b.s, a.i-b.i) -Base.:+(a::VWPreBuildItem, b::VWPreBuildItem) = VWPreBuildItem(a.nonempty+b.nonempty, a.s+b.s, a.i+b.i) - -Base.:-(a::VWPreBuildItem) = VWPreBuildItem(-a.nonempty, -a.s, -a.i) - -function Base.cmp(a::VWPreBuildItem, b::VWPreBuildItem) - c = cmp(a.nonempty, b.nonempty); c != 0 && return c - c = cmp(a.s, b.s); c != 0 && return c - return cmp(a.i, b.i) -end -Base.isless(a::VWPreBuildItem, b::VWPreBuildItem) = cmp(a,b) < 0 -Base.:(==)(a::VWPreBuildItem, b::VWPreBuildItem) = cmp(a,b) == 0 - -Base.abs(a::VWPreBuildItem) = VWPreBuildItem(abs(a.nonempty), abs(a.s), abs(a.i)) - -Base.copy(a::VWPreBuildItem) = VWPreBuildItem(a.nonempty, copy(a.s), a.i) - -struct VWPreBuild - nonempty::Int - w::HierarchicalValue{VWPreBuildItem} -end - -const _vwprebuild_zero = VWPreBuild(0, HierarchicalValue(VWPreBuildItem)) - -function VWPreBuild(ispre::Bool, desc::Tuple{Vararg{Union{Integer,String}}}) - isempty(desc) && return _vwprebuild_zero - desc == ("",) && return VWPreBuild(ispre ? -1 : 1, HierarchicalValue(VWPreBuildItem[])) - hv = HierarchicalValue([VWPreBuildItem(item) for item in desc]) - return VWPreBuild(ispre ? -1 : 0, hv) -end -VWPreBuild() = _vwprebuild_zero - -Base.zero(::Type{VWPreBuild}) = VWPreBuild() - -const _vwprebuild_min = VWPreBuild(typemin(Int), typemin(HierarchicalValue{VWPreBuildItem})) -Base.typemin(::Type{VWPreBuild}) = _vwprebuild_min - -function Base.:(-)(a::VWPreBuild, b::VWPreBuild) - b === _vwprebuild_zero && return a - a === _vwprebuild_zero && return -b - VWPreBuild(a.nonempty-b.nonempty, a.w-b.w) -end -function Base.:(+)(a::VWPreBuild, b::VWPreBuild) - b === _vwprebuild_zero && return a - a === _vwprebuild_zero && return b - VWPreBuild(a.nonempty+b.nonempty, a.w+b.w) -end - -function Base.:(-)(a::VWPreBuild) - a === _vwprebuild_zero && return a - VWPreBuild(-a.nonempty, -a.w) -end - -@inline function Base.cmp(a::VWPreBuild, b::VWPreBuild) - a === _vwprebuild_zero && b === _vwprebuild_zero && return 0 - c = cmp(a.nonempty, b.nonempty); c != 0 && return c - return cmp(a.w, b.w) -end -Base.isless(a::VWPreBuild, b::VWPreBuild) = cmp(a,b) < 0 -Base.:(==)(a::VWPreBuild, b::VWPreBuild) = cmp(a,b) == 0 - -function Base.abs(a::VWPreBuild) - a === _vwprebuild_zero && return a - VWPreBuild(abs(a.nonempty), abs(a.w)) -end - -function Base.copy(a::VWPreBuild) - a === _vwprebuild_zero && return a - VWPreBuild(a.nonempty, copy(a.w)) -end - -function Base.deepcopy_internal(a::VWPreBuild, dict::IdDict) - haskey(dict, a) && return dict[a] - b = (a === _vwprebuild_zero) ? _vwprebuild_zero : VWPreBuild(a.nonempty, Base.deepcopy_internal(a.w, dict)) - dict[a] = b - return b -end - -# The numeric type used to determine how the different -# versions of a package should be weighed -struct VersionWeight - major::Int - minor::Int - patch::Int - prerelease::VWPreBuild - build::VWPreBuild -end -VersionWeight(major::Int, minor::Int, patch::Int, prerelease::VWPreBuild) = VersionWeight(major, minor, patch, prerelease, zero(VWPreBuild)) -VersionWeight(major::Int, minor::Int, patch::Int) = VersionWeight(major, minor, patch, zero(VWPreBuild)) -VersionWeight(major::Int, minor::Int) = VersionWeight(major, minor, 0) -VersionWeight(major::Int) = VersionWeight(major, 0) -VersionWeight() = VersionWeight(0) - -VersionWeight(vn::VersionNumber) = - VersionWeight(vn.major, vn.minor, vn.patch, - VWPreBuild(true, vn.prerelease), VWPreBuild(false, vn.build)) - -Base.zero(::Type{VersionWeight}) = VersionWeight() - -Base.typemin(::Type{VersionWeight}) = (x=typemin(Int); y=typemin(VWPreBuild); VersionWeight(x, x, x, y, y)) - -Base.:(-)(a::VersionWeight, b::VersionWeight) = - VersionWeight(a.major-b.major, a.minor-b.minor, a.patch-b.patch, - a.prerelease-b.prerelease, a.build-b.build) - -Base.:(+)(a::VersionWeight, b::VersionWeight) = - VersionWeight(a.major+b.major, a.minor+b.minor, a.patch+b.patch, - a.prerelease+b.prerelease, a.build+b.build) - -Base.:(-)(a::VersionWeight) = - VersionWeight(-a.major, -a.minor, -a.patch, - -a.prerelease, -a.build) - -function Base.cmp(a::VersionWeight, b::VersionWeight) - c = cmp(a.major, b.major); c != 0 && return c - c = cmp(a.minor, b.minor); c != 0 && return c - c = cmp(a.patch, b.patch); c != 0 && return c - c = cmp(a.prerelease, b.prerelease); c != 0 && return c - return cmp(a.build, b.build) -end -Base.isless(a::VersionWeight, b::VersionWeight) = cmp(a,b) < 0 -Base.:(==)(a::VersionWeight, b::VersionWeight) = cmp(a,b) == 0 - -Base.abs(a::VersionWeight) = - VersionWeight(abs(a.major), abs(a.minor), abs(a.patch), - abs(a.prerelease), abs(a.build)) - -Base.copy(a::VersionWeight) = - VersionWeight(a.major, a.minor, a.patch, - copy(a.prerelease), copy(a.build)) - -# This isn't nice, but it's for debugging only anyway -function Base.show(io::IO, a::VersionWeight) - print(io, "(", a.major) - a == VersionWeight(a.major) && @goto done - print(io, ".", a.minor) - a == VersionWeight(a.major, a.minor) && @goto done - print(io, ".", a.patch) - a.prerelease ≠ _vwprebuild_zero && print(io, "-", a.prerelease) - a.build ≠ _vwprebuild_zero && print(io, "+", a.build) - @label done - print(io, ")") -end - -end diff --git a/stdlib/OldPkg/src/types.jl b/stdlib/OldPkg/src/types.jl deleted file mode 100644 index 082702aa88233..0000000000000 --- a/stdlib/OldPkg/src/types.jl +++ /dev/null @@ -1,258 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module Types - -import OldPkg - -export VersionInterval, VersionSet, Requires, Available, Fixed, merge_requires!, satisfies, - ResolveBacktraceItem, ResolveBacktrace -import Base: show, isempty, in, intersect, union!, union, ==, hash, copy, deepcopy_internal, push! - -struct VersionInterval - lower::VersionNumber - upper::VersionNumber -end -VersionInterval(lower::VersionNumber) = VersionInterval(lower,typemax(VersionNumber)) -VersionInterval() = VersionInterval(typemin(VersionNumber)) - -show(io::IO, i::VersionInterval) = print(io, "[$(i.lower),$(i.upper))") -isempty(i::VersionInterval) = i.upper <= i.lower -in(v::VersionNumber, i::VersionInterval) = i.lower <= v < i.upper -intersect(a::VersionInterval, b::VersionInterval) = VersionInterval(max(a.lower,b.lower), min(a.upper,b.upper)) -==(a::VersionInterval, b::VersionInterval) = a.lower == b.lower && a.upper == b.upper -hash(i::VersionInterval, h::UInt) = hash((i.lower, i.upper), h + (0x0f870a92db508386 % UInt)) - -function normalize!(ivals::Vector{VersionInterval}) - # VersionSet internal normalization: - # removes empty intervals and fuses intervals without gaps - # e.g.: - # [0.0.0,1.0.0) ∪ [1.0.0,1.5.0) ∪ [1.6.0,1.6.0) ∪ [2.0.0,∞) - # becomes: - # [0.0.0,1.5.0) ∪ [2.0.0,∞) - # (still assumes that lower bounds are sorted, and intervals do - # not overlap) - l = length(ivals) - l == 0 && return ivals - - lo, up, k0 = ivals[1].lower, ivals[1].upper, 1 - fusing = false - for k = 2:l - lo1, up1 = ivals[k].lower, ivals[k].upper - if lo1 == up - up = up1 - fusing = true - continue - end - if lo < up - # The only purpose of the "fusing" check is to avoid - # extra allocations - ivals[k0] = fusing ? VersionInterval(lo, up) : ivals[k-1] - k0 += 1 - end - fusing = false - lo, up = lo1, up1 - end - if lo < up - ivals[k0] = fusing ? VersionInterval(lo, up) : ivals[l] - k0 += 1 - end - resize!(ivals, k0 - 1) - return ivals -end - -struct VersionSet - intervals::Vector{VersionInterval} - VersionSet(intervals::Vector{VersionInterval}) = new(normalize!(intervals)) - # copy is defined inside the struct block to call `new` directly - # without going through `normalize!` - Base.copy(vset::VersionSet) = new(copy(vset.intervals)) -end -function VersionSet(versions::Vector{VersionNumber}) - intervals = VersionInterval[] - if isempty(versions) - push!(intervals, VersionInterval()) - else - isodd(length(versions)) && push!(versions, typemax(VersionNumber)) - while !isempty(versions) - push!(intervals, VersionInterval(popfirst!(versions), popfirst!(versions))) - end - end - VersionSet(intervals) -end -VersionSet(versions::VersionNumber...) = VersionSet(VersionNumber[versions...]) - -const empty_versionset = VersionSet(VersionInterval[]) - -# Windows console doesn't like Unicode -const _empty_symbol = @static Sys.iswindows() ? "empty" : "∅" -const _union_symbol = @static Sys.iswindows() ? " or " : " ∪ " -show(io::IO, s::VersionSet) = isempty(s) ? print(io, _empty_symbol) : - join(io, s.intervals, _union_symbol) -isempty(s::VersionSet) = all(isempty, s.intervals) -in(v::VersionNumber, s::VersionSet) = any(i->in(v,i), s.intervals) -function intersect(A::VersionSet, B::VersionSet) - (isempty(A) || isempty(B)) && return copy(empty_versionset) - ivals = [intersect(a,b) for a in A.intervals for b in B.intervals] - sort!(ivals, by=i->i.lower) - VersionSet(ivals) -end - -union(A::VersionSet, B::VersionSet) = union!(copy(A), B) -function union!(A::VersionSet, B::VersionSet) - A == B && return A - ivals = A.intervals - for intB in B.intervals - lB, uB = intB.lower, intB.upper - k0 = findfirst(i->(i.upper > lB), ivals) - if k0 === nothing - push!(ivals, intB) - continue - end - lB = min(lB, ivals[k0].lower) - for k1 = k0:length(ivals) - intA = ivals[k1] - if uB < intA.lower - splice!(ivals, k0:(k1-1), (VersionInterval(lB, uB),)) - break - elseif uB ∈ intA || k1 == length(ivals) - splice!(ivals, k0:k1, (VersionInterval(lB, max(uB, intA.upper)),)) - break - end - end - end - normalize!(ivals) - return A -end - -==(A::VersionSet, B::VersionSet) = A.intervals == B.intervals -hash(s::VersionSet, h::UInt) = hash(s.intervals, h + (0x2fd2ca6efa023f44 % UInt)) -deepcopy_internal(vs::VersionSet, ::IdDict) = copy(vs) - -const Requires = Dict{String,VersionSet} - -function merge_requires!(A::Requires, B::Requires) - for (pkg,vers) in B - A[pkg] = haskey(A,pkg) ? intersect(A[pkg],vers) : vers - end - return A -end - -satisfies(pkg::AbstractString, ver::VersionNumber, reqs::Requires) = - !haskey(reqs, pkg) || in(ver, reqs[pkg]) - -struct Available - sha1::String - requires::Requires -end - -==(a::Available, b::Available) = a.sha1 == b.sha1 && a.requires == b.requires -hash(a::Available, h::UInt) = hash((a.sha1, a.requires), h + (0xbc8ae0de9d11d972 % UInt)) -copy(a::Available) = Available(a.sha1, copy(a.requires)) - -show(io::IO, a::Available) = isempty(a.requires) ? - print(io, "Available(", repr(a.sha1), ")") : - print(io, "Available(", repr(a.sha1), ",", a.requires, ")") - -struct Fixed - version::VersionNumber - requires::Requires -end -Fixed(v::VersionNumber) = Fixed(v,Requires()) - -==(a::Fixed, b::Fixed) = a.version == b.version && a.requires == b.requires -hash(f::Fixed, h::UInt) = hash((f.version, f.requires), h + (0x68628b809fd417ca % UInt)) - -show(io::IO, f::Fixed) = isempty(f.requires) ? - print(io, "Fixed(", repr(f.version), ")") : - print(io, "Fixed(", repr(f.version), ",", f.requires, ")") - -# TODO: Available & Fixed are almost the same – merge them? -# Free could include the same information too, it just isn't -# required by anything that processes these things. - - -const VersionReq = Union{VersionNumber,VersionSet} -const WhyReq = Tuple{VersionReq,Any} - -# This is used to keep track of dependency relations when propagating -# requirements, so as to emit useful information in case of unsatisfiable -# conditions. -# The `versionreq` field keeps track of the remaining allowed versions, -# intersecting all requirements. -# The `why` field is a Vector which keeps track of the requirements. Each -# entry is a Tuple of two elements: -# 1) the first element is the version requirement (can be a single VersionNumber -# or a VersionSet). -# 2) the second element can be either :fixed (for requirements induced by -# fixed packages), :required (for requirements induced by explicitly -# required packages), or a Pair p=>backtrace_item (for requirements induced -# indirectly, where `p` is the package name and `backtrace_item` is -# another ResolveBacktraceItem. -mutable struct ResolveBacktraceItem - versionreq::VersionReq - why::Vector{WhyReq} - ResolveBacktraceItem() = new(VersionSet(), WhyReq[]) - ResolveBacktraceItem(reason, versionreq::VersionReq) = new(versionreq, WhyReq[(versionreq,reason)]) -end - -function push!(ritem::ResolveBacktraceItem, reason, versionset::VersionSet) - if isa(ritem.versionreq, VersionSet) - ritem.versionreq = ritem.versionreq ∩ versionset - elseif ritem.versionreq ∉ versionset - ritem.versionreq = copy(empty_versionset) - end - push!(ritem.why, (versionset,reason)) -end - -function push!(ritem::ResolveBacktraceItem, reason, version::VersionNumber) - if isa(ritem.versionreq, VersionSet) - if version ∈ ritem.versionreq - ritem.versionreq = version - else - ritem.versionreq = copy(empty_versionset) - end - elseif ritem.versionreq ≠ version - ritem.versionreq = copy(empty_versionset) - end - push!(ritem.why, (version,reason)) -end - - -show(io::IO, ritem::ResolveBacktraceItem) = _show(io, ritem, "", Set{ResolveBacktraceItem}([ritem])) - -function _show(io::IO, ritem::ResolveBacktraceItem, indent::String, seen::Set{ResolveBacktraceItem}) - l = length(ritem.why) - for (i,(vs,w)) in enumerate(ritem.why) - print(io, indent, (i==l ? '└' : '├'), '─') - if w ≡ :fixed - @assert isa(vs, VersionNumber) - println(io, "version $vs set by fixed requirement (package is checked out, dirty or pinned)") - elseif w ≡ :required - @assert isa(vs, VersionSet) - println(io, "version range $vs set by an explicit requirement") - else - @assert isa(w, Pair{<:AbstractString,ResolveBacktraceItem}) - if isa(vs, VersionNumber) - print(io, "version $vs ") - else - print(io, "version range $vs ") - end - print(io, "required by package $(w[1]), ") - if isa(w[2].versionreq, VersionSet) - println(io, "whose allowed version range is $(w[2].versionreq):") - else - println(io, "whose only allowed version is $(w[2].versionreq):") - end - if w[2] ∈ seen - println(io, (i==l ? " " : "│ ") * indent, "└─[see above for $(w[1]) backtrace]") - continue - end - push!(seen, w[2]) - _show(io, w[2], (i==l ? " " : "│ ") * indent, seen) - end - end -end - -const ResolveBacktrace = Dict{AbstractString,ResolveBacktraceItem} - -end # module diff --git a/stdlib/OldPkg/src/write.jl b/stdlib/OldPkg/src/write.jl deleted file mode 100644 index 4db244a147dcf..0000000000000 --- a/stdlib/OldPkg/src/write.jl +++ /dev/null @@ -1,65 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module Write - -import OldPkg -import ..Cache, ..Read, ..PkgError -using LibGit2 - -function prefetch(pkg::AbstractString, sha1::AbstractString) - isempty(Cache.prefetch(pkg, Read.url(pkg), sha1)) && return - throw(PkgError("$pkg: couldn't find commit $(sha1[1:10])")) -end - -function fetch(repo::GitRepo, pkg::AbstractString, sha1::AbstractString) - cache = Cache.path(pkg) - LibGit2.fetch(repo, remoteurl=cache, refspecs=["+refs/*:refs/remotes/cache/*"]) - LibGit2.need_update(repo) - LibGit2.iscommit(sha1, repo) && return - f = with(GitRepo, cache) do repo - LibGit2.iscommit(sha1, repo) - end ? "fetch" : "prefetch" - url = Read.issue_url(pkg) - if isempty(url) - throw(PkgError("$pkg: $f failed to get commit $(sha1[1:10]), please file a bug report with the package author.")) - else - throw(PkgError("$pkg: $f failed to get commit $(sha1[1:10]), please file an issue at $url")) - end -end - -function checkout(repo::GitRepo, pkg::AbstractString, sha1::AbstractString) - LibGit2.set_remote_url(repo, "origin", Cache.normalize_url(Read.url(pkg))) - LibGit2.checkout!(repo, sha1) -end - -function install(pkg::AbstractString, sha1::AbstractString) - prefetch(pkg, sha1) - repo = if isdir(".trash/$pkg") - mv(".trash/$pkg", "./$pkg") #TODO check for newer version in cache before moving - GitRepo(pkg) - else - LibGit2.clone(Cache.path(pkg), pkg) - end - try - fetch(repo, pkg, sha1) - checkout(repo, pkg, sha1) - finally - close(repo) - end -end - -function update(pkg::AbstractString, sha1::AbstractString) - prefetch(pkg, sha1) - with(GitRepo, pkg) do repo - fetch(repo, pkg, sha1) - checkout(repo, pkg, sha1) - end -end - -function remove(pkg::AbstractString) - isdir(".trash") || mkdir(".trash") - ispath(".trash/$pkg") && rm(".trash/$pkg", recursive=true) - mv(pkg, ".trash/$pkg") -end - -end # module diff --git a/stdlib/OldPkg/test/pkg.jl b/stdlib/OldPkg/test/pkg.jl deleted file mode 100644 index 9cc31239e10aa..0000000000000 --- a/stdlib/OldPkg/test/pkg.jl +++ /dev/null @@ -1,734 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module PkgTests - -using Test -import OldPkg -import OldPkg.PkgError -using LibGit2 -using Random: randstring - -function capture_stdout(f::Function) - let fname = tempname() - try - open(fname, "w") do fout - redirect_stdout(fout) do - f() - end - end - return read(fname, String) - finally - rm(fname, force=true) - end - end -end - - -function temp_pkg_dir(fn::Function, tmp_dir=joinpath(tempdir(), randstring()), - remove_tmp_dir::Bool=true; initialize::Bool=true) - - # Used in tests below to set up and tear down a sandboxed package directory - withenv("JULIA_PKGDIR" => tmp_dir) do - @test !isdir(OldPkg.dir()) - try - if initialize - OldPkg.init() - @test isdir(OldPkg.dir()) - OldPkg.resolve() - else - mkpath(OldPkg.dir()) - end - fn() - finally - remove_tmp_dir && rm(tmp_dir, recursive=true) - end - end -end - -function write_build(pkg, content) - build_filename = OldPkg.dir(pkg, "deps", "build.jl") - mkpath(dirname(build_filename)) - write(build_filename, content) -end - -# Test basic operations: adding or removing a package, status, free -# Also test for the existence of REQUIRE and META_BRANCH -temp_pkg_dir() do - @test isfile(joinpath(OldPkg.dir(),"REQUIRE")) - @test isfile(joinpath(OldPkg.dir(),"META_BRANCH")) - @test isempty(OldPkg.installed()) - @test sprint(OldPkg.status) == "No packages installed\n" - @test !isempty(OldPkg.available()) - - # 18325 - cd(OldPkg.dir()) do - avail = OldPkg.Read.available() - avail_copy = OldPkg.Query.availcopy(avail); - delete!(avail_copy["Example"][v"0.0.1"].requires, "julia") - @test haskey(avail["Example"][v"0.0.1"].requires, "julia") - end - - @test_throws PkgError OldPkg.installed("MyFakePackage") - @test_throws PkgError OldPkg.status("MyFakePackage") - @test OldPkg.installed("Example") === nothing - - # Check that setprotocol! works. - begin - try - OldPkg.setprotocol!("notarealprotocol") - OldPkg.add("Example") - error("unexpected") - catch ex - if isa(ex, CompositeException) - ex = ex.exceptions[1] - - if isa(ex, CapturedException) - ex = ex.ex - end - end - @test isa(ex,OldPkg.PkgError) - @test occursin("Cannot clone Example from notarealprotocol://github.com/JuliaLang/Example.jl.git", ex.msg) - end - end - - OldPkg.setprotocol!("") - @test OldPkg.Cache.rewrite_url_to === nothing - OldPkg.setprotocol!("https") - OldPkg.add("Example") - @test [keys(OldPkg.installed())...] == ["Example"] - iob = IOBuffer() - OldPkg.checkout("Example") - OldPkg.status("Example", iob) - str = chomp(String(take!(iob))) - @test startswith(str, " - Example") - @test endswith(str, "master") - OldPkg.free("Example") - OldPkg.status("Example", iob) - str = chomp(String(take!(iob))) - @test endswith(str, string(OldPkg.installed("Example"))) - OldPkg.checkout("Example") - OldPkg.free(("Example",)) - OldPkg.status("Example", iob) - str = chomp(String(take!(iob))) - @test endswith(str, string(OldPkg.installed("Example"))) - OldPkg.rm("Example") - @test isempty(OldPkg.installed()) - @test !isempty(OldPkg.available("Example")) - @test !in("Example", keys(OldPkg.installed())) - OldPkg.rm("Example") - @test isempty(OldPkg.installed()) - @test !isempty(OldPkg.available("Example")) - @test !in("Example", keys(OldPkg.installed())) - OldPkg.clone("https://github.com/JuliaLang/Example.jl.git") - @test [keys(OldPkg.installed())...] == ["Example"] - OldPkg.status("Example", iob) - str = chomp(String(take!(iob))) - @test startswith(str, " - Example") - @test endswith(str, "master") - OldPkg.free("Example") - OldPkg.status("Example", iob) - str = chomp(String(take!(iob))) - @test endswith(str, string(OldPkg.installed("Example"))) - OldPkg.checkout("Example") - OldPkg.free(("Example",)) - OldPkg.status("Example", iob) - str = chomp(String(take!(iob))) - @test endswith(str, string(OldPkg.installed("Example"))) - - # 17364 - a, OldPkg.checkout with specific local branch - let branch_name = "test-branch-1", - branch_commit = "ba3888212e30a7974ac6803a89e64c7098f4865e" - - # create a branch in Example package - LibGit2.with(LibGit2.GitRepo, OldPkg.dir("Example")) do repo - LibGit2.branch!(repo, branch_name, branch_commit, set_head=false) - end - - OldPkg.clone(OldPkg.dir("Example"), "Example2") - OldPkg.clone(OldPkg.dir("Example"), "Example3") - open(OldPkg.dir("Example3", "README.md"), "w") do f - println(f, "overwritten") - end - LibGit2.with(LibGit2.GitRepo, OldPkg.dir("Example3")) do repo - LibGit2.add!(repo, "README.md") - test_sig = LibGit2.Signature("TEST", "TEST@TEST.COM", round(time()), 0) - LibGit2.commit(repo, "testmsg"; author=test_sig, committer=test_sig) - end - - OldPkg.checkout("Example2", branch_name) - OldPkg.checkout("Example3", branch_name) - - LibGit2.with(LibGit2.GitRepo, OldPkg.dir("Example2")) do repo - @test LibGit2.head_oid(repo) == LibGit2.GitHash(branch_commit) - end - LibGit2.with(LibGit2.GitRepo, OldPkg.dir("Example3")) do repo - @test LibGit2.head_oid(repo) == LibGit2.GitHash(branch_commit) - end - end - - # 17364 - b, remote off-tree branch - let branch_name = "test-branch-2", - branch_commit = "ba3888212e30a7974ac6803a89e64c7098f4865e" - - # create a branch in Example package - LibGit2.with(LibGit2.GitRepo, OldPkg.dir("Example")) do repo - LibGit2.branch!(repo, branch_name, branch_commit, set_head=true) - end - - # Make changes to local branch - open(OldPkg.dir("Example", "README.md"), "w") do f - println(f, "overwritten") - end - - test_commit = LibGit2.with(LibGit2.GitRepo, OldPkg.dir("Example")) do repo - LibGit2.add!(repo, "README.md") - test_sig = LibGit2.Signature("TEST", "TEST@TEST.COM", round(time()), 0) - LibGit2.commit(repo, "testmsg"; author=test_sig, committer=test_sig) - end - OldPkg.checkout("Example") - - OldPkg.clone(OldPkg.dir("Example"), "Example4") - OldPkg.checkout("Example4", branch_name) - - LibGit2.with(LibGit2.GitRepo, OldPkg.dir("Example4")) do repo - @test LibGit2.head_oid(repo) == test_commit - end - end - - # adding a package with unsatisfiable julia version requirements (REPL.jl) errors - try - OldPkg.add("REPL") - error("unexpected") - catch err - @test isa(err.exceptions[1].ex, PkgError) - @test err.exceptions[1].ex.msg == "REPL can't be installed because " * - "it has no versions that support $VERSION of julia. You may " * - "need to update METADATA by running `OldPkg.update()`" - end - - # trying to add, check availability, or pin a nonexistent package errors - try - OldPkg.add("NonexistentPackage") - error("unexpected") - catch err - @test isa(err.exceptions[1].ex, PkgError) - @test err.exceptions[1].ex.msg == "unknown package NonexistentPackage" - end - try - OldPkg.available("NonexistentPackage") - error("unexpected") - catch err - @test isa(err, PkgError) - @test err.msg == "NonexistentPackage is not a package (not registered or installed)" - end - try - OldPkg.pin("NonexistentPackage", v"1.0.0") - error("unexpected") - catch err - @test isa(err, PkgError) - @test err.msg == "NonexistentPackage is not a git repo" - end - - # trying to pin a git repo under OldPkg.dir that is not an installed package errors - try - OldPkg.pin("METADATA", v"1.0.0") - error("unexpected") - catch err - @test isa(err, PkgError) - @test err.msg == "METADATA cannot be pinned – not an installed package" - end - - # trying to pin an installed, registered package to an unregistered version errors - try - OldPkg.pin("Example", v"2147483647.0.0") - error("unexpected") - catch err - @test isa(err, PkgError) - @test err.msg == "Example – 2147483647.0.0 is not a registered version" - end - - # PR #13572, handling of versions with untagged detached heads - LibGit2.with(LibGit2.GitRepo, OldPkg.dir("Example")) do repo - LibGit2.checkout!(repo, "72f09c7d0099793378c645929a9961155faae6d2") - end - @test OldPkg.installed()["Example"] > v"0.0.0" - - # issue #13583 - begin - try - OldPkg.test("IDoNotExist") - error("unexpected") - catch ex - @test isa(ex,OldPkg.Entry.PkgTestError) - @test ex.msg == "IDoNotExist is not an installed package" - end - - try - OldPkg.test("IDoNotExist1", "IDoNotExist2") - error("unexpected") - catch ex - @test isa(ex,OldPkg.Entry.PkgTestError) - @test ex.msg == "IDoNotExist1 and IDoNotExist2 are not installed packages" - end - end - - # Various pin/free/re-pin/change-pin patterns (issue #17176) - @test "" == capture_stdout() do - nothingtodomsg = (:info,"No packages to install, update or remove") - - @test_logs((:info,"Freeing Example"), - nothingtodomsg, - OldPkg.free("Example")) - - @test_logs (:info,r"^Creating Example branch pinned\.[0-9a-f]{8}\.tmp$") OldPkg.pin("Example") - vers = OldPkg.installed("Example") - branch = LibGit2.with(LibGit2.GitRepo, OldPkg.dir("Example")) do repo - LibGit2.branch(repo) - end - - @test_logs((:info,"Freeing Example"), - nothingtodomsg, - OldPkg.free("Example")) - - @test_logs((:info,"Creating Example branch pinned.b1990792.tmp"), - nothingtodomsg, OldPkg.pin("Example", v"0.4.0")) - @test OldPkg.installed("Example") == v"0.4.0" - - @test_logs (:info,r"^Package Example is already pinned to the selected commit$") OldPkg.pin("Example", v"0.4.0") - @test OldPkg.installed("Example") == v"0.4.0" - - @test_logs (:info,r"^Package Example is already pinned$") OldPkg.pin("Example") - @test OldPkg.installed("Example") == v"0.4.0" - - @test_logs (:info,"Package Example: skipping update (pinned)...") match_mode=:any OldPkg.update() - @test OldPkg.installed("Example") == v"0.4.0" - - @test_logs((:info,"Creating Example branch pinned.d1ef7b00.tmp"), - nothingtodomsg, OldPkg.pin("Example", v"0.3.1")) - @test OldPkg.installed("Example") == v"0.3.1" - - @test_logs((:info,"Package Example: checking out existing branch pinned.b1990792.tmp"), - nothingtodomsg, OldPkg.pin("Example", v"0.4.0")) - @test OldPkg.installed("Example") == v"0.4.0" - - @test_logs((:info,"Freeing Example"), - nothingtodomsg, OldPkg.free("Example")) - @test OldPkg.installed("Example") == vers - - @test_logs (:info,Regex("^Package Example: checking out existing branch $branch\$")) OldPkg.pin("Example") - @test OldPkg.installed("Example") == vers - - @test_logs((:info,"Freeing Example"), - nothingtodomsg, OldPkg.free("Example")) - @test OldPkg.installed("Example") == vers - end - - begin - # bug identified in #16850, Base.url \ vs / for non-Base methods - include(OldPkg.dir("Example","src","Example.jl")) - meth = first(methods(Example.domath)) - fname = string(meth.file) - @test ('\\' in fname) == Sys.iswindows() - @test startswith(Base.url(meth), "https://github.com/JuliaLang/Example.jl/tree") - end - - # add a directory that is not a git repository - begin - mkdir(joinpath(OldPkg.dir(), "NOTGIT")) - OldPkg.installed("NOTGIT") == typemin(VersionNumber) - OldPkg.installed()["NOTGIT"] == typemin(VersionNumber) - end - - begin - # don't bork when a Pkg repo is bare, issue #13804 - pth = joinpath(OldPkg.dir(), "BAREGIT") - mkdir(pth) - # create a bare repo (isbare = true) - repo = LibGit2.init(pth, true) - @test repo.ptr != C_NULL - close(repo) - OldPkg.update() - end - - #test PkgDev redirects - begin - try - OldPkg.register("IDoNotExist") - error("unexpected") - catch ex - @test ex.msg == "OldPkg.register(pkg,[url]) has been moved to the package PkgDev.jl.\nRun OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-" - end - - try - OldPkg.tag("IDoNotExist") - error("unexpected") - catch ex - @test ex.msg == "OldPkg.tag(pkg, [ver, [commit]]) has been moved to the package PkgDev.jl.\nRun OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-" - end - - try - OldPkg.generate("IDoNotExist","MIT") - error("unexpected") - catch ex - @test ex.msg == "OldPkg.generate(pkg, license) has been moved to the package PkgDev.jl.\nRun OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-" - end - - try - OldPkg.publish() - error("unexpected") - catch ex - @test ex.msg == "OldPkg.publish() has been moved to the package PkgDev.jl.\nRun OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-" - end - - try - OldPkg.license() - error("unexpected") - catch ex - @test ex.msg == "OldPkg.license([lic]) has been moved to the package PkgDev.jl.\nRun OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-" - end - try - OldPkg.submit("IDoNotExist") - error("unexpected") - catch ex - @test ex.msg == "OldPkg.submit(pkg[, commit]) has been moved to the package PkgDev.jl.\nRun OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-" - end - try - OldPkg.submit("IDoNotExist", "nonexistentcommit") - error("unexpected") - catch ex - @test ex.msg == "OldPkg.submit(pkg[, commit]) has been moved to the package PkgDev.jl.\nRun OldPkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-" - end - end - - # Test OldPkg.Read.url works - @test OldPkg.Read.url("Example") == "git://github.com/JuliaLang/Example.jl.git" - - # issue #15789, build failure warning are printed correctly. - # Also makes sure `OldPkg.build()` works even for non-git repo - begin - pth = joinpath(OldPkg.dir(), "BuildFail") - mkdir(pth) - depspath = joinpath(pth, "deps") - mkdir(depspath) - depsbuild = joinpath(depspath, "build.jl") - touch(depsbuild) - # OldPkg.build works without the src directory now - # but it's probably fine to require it. - msg = read(`$(Base.julia_cmd()) --startup-file=no -e 'redirect_stderr(stdout); using Logging; global_logger(SimpleLogger(stdout)); import OldPkg; OldPkg.build("BuildFail")'`, String) - @test occursin("Building BuildFail", msg) - @test !occursin("Build failed for BuildFail", msg) - open(depsbuild, "w") do fd - println(fd, "error(\"Throw build error\")") - end - msg = read(`$(Base.julia_cmd()) --startup-file=no -e 'redirect_stderr(stdout); using Logging; global_logger(SimpleLogger(stdout)); import OldPkg; OldPkg.build("BuildFail")'`, String) - @test occursin("Building BuildFail", msg) - @test occursin("Build failed for BuildFail", msg) - @test occursin("OldPkg.build(\"BuildFail\")", msg) - @test occursin("Throw build error", msg) - end - - # issue #15948 - let package = "Example" - OldPkg.rm(package) # Remove package if installed - @test OldPkg.installed(package) === nothing # Registered with METADATA but not installed - msg = read(ignorestatus(`$(Base.julia_cmd()) --startup-file=no -e "redirect_stderr(stdout); using Logging; global_logger(SimpleLogger(stdout)); import OldPkg; OldPkg.build(\"$package\")"`), String) - @test occursin("$package is not an installed package", msg) - @test !occursin("signal (15)", msg) - end - - # issue #20695 - OldPkg.cd() do - @test OldPkg.Entry.url_and_pkg("Example") == ("git://github.com/JuliaLang/Example.jl.git", "Example") - for url = [ - "https://github.com/Org/Nonsense", - "git@github.com:Org/Nonsense", - "file:///home/user/Nonsense", - "/home/user/Nonsense", - ] - @test OldPkg.Entry.url_and_pkg(url) == (url, "Nonsense") - @test OldPkg.Entry.url_and_pkg("$url.jl") == ("$url.jl", "Nonsense") - @test OldPkg.Entry.url_and_pkg("$url.git") == ("$url.git", "Nonsense") - @test OldPkg.Entry.url_and_pkg("$url.jl.git") == ("$url.jl.git", "Nonsense") - end - pkg = randstring(20) - @test OldPkg.Entry.url_and_pkg(pkg) == (pkg, pkg) - end - - # partial OldPkg.update - @test "" == capture_stdout() do - nothingtodomsg = (:info,"No packages to install, update or remove") - - @test_logs (:info,r"Installing Example v") match_mode=:any begin - OldPkg.rm("Example") - OldPkg.add("Example") - end - - @test_logs nothingtodomsg match_mode=:any OldPkg.update("Example") - - @test_logs (:info,"Installing Example v0.4.0") match_mode=:any begin - OldPkg.rm("Example") - OldPkg.add("Example", v"0", v"0.4.1-") # force version to be < 0.4.1 - end - - - @test_logs((:info,r"""Package Example was set to version 0\.4\.0, but a higher version \d+\.\d+\.\d+\S* exists. - The update is prevented by explicit requirements constraints. Edit your REQUIRE file to change this."""), - nothingtodomsg, match_mode=:any, OldPkg.update("Example")) - - @test_logs (:info,r"Installing Example") match_mode=:any begin - OldPkg.rm("Example") - OldPkg.add("Example") - OldPkg.pin("Example", v"0.4.0") - end - - @test_logs((:info,"Package Example: skipping update (pinned)..."), - (:info,r"""Package Example was set to version 0\.4\.0, but a higher version \d+\.\d+\.\d+\S* exists. - The package is fixed. You can try using `OldPkg.free\("Example"\)` to update it."""), - nothingtodomsg, match_mode=:any, OldPkg.update("Example")) - - metadata_dir = OldPkg.dir("METADATA") - old_commit = "313bfaafa301e82d40574a778720e893c559a7e2" - - # Force a METADATA rollback to an old version, so that we will install some - # outdated versions of some packages and then update some of those - # (note that the following OldPkg.update calls will update METADATA to the - # latest version even though they don't update all packages) - LibGit2.with(LibGit2.GitRepo, metadata_dir) do repo - LibGit2.reset!(repo, LibGit2.GitHash(old_commit), LibGit2.Consts.RESET_HARD) - end - - # run these at an old metadata commit where it's guaranteed no - # packages depend on Example.jl - @test isempty(OldPkg.dependents("Example")) - @test isempty(OldPkg.dependents("Example.jl")) - - logs,_ = Test.collect_test_logs() do - OldPkg.add("Iterators") - OldPkg.update("Iterators") - end - @test all(!occursin("updated but were already imported", l.message) for l in logs) - - # Do it again, because the above Iterators test will update things prematurely - LibGit2.with(LibGit2.GitRepo, metadata_dir) do repo - LibGit2.reset!(repo, LibGit2.GitHash(old_commit), LibGit2.Consts.RESET_HARD) - end - - @test_logs((:info,"Installing Colors v0.6.4"), - (:info,"Installing ColorTypes v0.2.2"), - (:info,"Installing FixedPointNumbers v0.1.3"), - (:info,"Installing Compat v0.7.18"), - (:info,"Installing Reexport v0.0.3"), match_mode=:any, OldPkg.add("Colors")) - - logs,_ = Test.collect_test_logs() do - OldPkg.update("ColorTypes") - end - @test any(occursin((:info, r"Upgrading ColorTypes: v0\.2\.2 => v\d+\.\d+\.\d+"), l) for l in logs) - @test any(occursin((:info, r"Upgrading Compat: v0\.7\.18 => v\d+\.\d+\.\d+"), l) for l in logs) - @test !any(occursin((:info, r"Upgrading Colors"), l) for l in logs) - - @test OldPkg.installed("Colors") == v"0.6.4" - - @test_logs nothingtodomsg match_mode=:any OldPkg.update("FixedPointNumbers") - end - - # issue #18239 - let package = "Example" - OldPkg.free(package) - OldPkg.rm(package) # Remove package if installed - - metadata_dir = OldPkg.dir("METADATA") - old_commit = "83ff7116e51fc9cdbd7e67affbd344b9f5c9dbf2" - - # Reset METADATA to the second to last update of Example.jl - LibGit2.with(LibGit2.GitRepo, metadata_dir) do repo - LibGit2.reset!(repo, LibGit2.GitHash(old_commit), LibGit2.Consts.RESET_HARD) - end - - OldPkg.add(package) - msg = read(ignorestatus(`$(Base.julia_cmd()) --startup-file=no -e - "import OldPkg; push!(LOAD_PATH, OldPkg.dir()); redirect_stderr(stdout); using Logging; global_logger(SimpleLogger(stdout)); using Example; OldPkg.update(\"$package\")"`), String) - @test occursin(Regex("- $package.*Restart Julia to use the updated versions","s"), msg) - end - - # Verify that the --startup-file flag is respected by OldPkg.build / OldPkg.test - let package = "StartupFile" - content = """ - @info "JULIA_RC_LOADED defined \$(isdefined(@__MODULE__, :JULIA_RC_LOADED))" - @info "Main.JULIA_RC_LOADED defined \$(isdefined(Main, :JULIA_RC_LOADED))" - """ - - write_build(package, content) - - test_filename = OldPkg.dir(package, "test", "runtests.jl") - mkpath(dirname(test_filename)) - write(test_filename, content) - - # Make a ~/.julia/config/startup.jl - home = OldPkg.dir(".home") - mkpath(joinpath(home, ".julia", "config")) - write(joinpath(home, ".julia", "config", "startup.jl"), - "const JULIA_RC_LOADED = true") - - withenv((Sys.iswindows() ? "USERPROFILE" : "HOME") => home) do - code = "redirect_stderr(stdout); using Logging; global_logger(SimpleLogger(stdout)); import OldPkg; OldPkg.build(\"$package\")" - msg = read(`$(Base.julia_cmd()) --startup-file=no -e $code`, String) - @test occursin("JULIA_RC_LOADED defined false", msg) - @test occursin("Main.JULIA_RC_LOADED defined false", msg) - - msg = read(`$(Base.julia_cmd()) --startup-file=yes -e $code`, String) - @test occursin("JULIA_RC_LOADED defined false", msg) - @test occursin("Main.JULIA_RC_LOADED defined true", msg) - - code = "redirect_stderr(stdout); using Logging; global_logger(SimpleLogger(stdout)); import OldPkg; OldPkg.test(\"$package\")" - - msg = read(`$(Base.julia_cmd()) --startup-file=no -e $code`, String) - @test occursin("JULIA_RC_LOADED defined false", msg) - @test occursin("Main.JULIA_RC_LOADED defined false", msg) - - # Note: Since both the startup-file and "runtests.jl" are run in the Main - # module any global variables created in the startup file can be referenced. - msg = read(`$(Base.julia_cmd()) --startup-file=yes -e $code`, String) - @test occursin("JULIA_RC_LOADED defined true", msg) - @test occursin("Main.JULIA_RC_LOADED defined true", msg) - end - end - - let package = "Output" - stdout_file = OldPkg.dir(package, "stdout.txt") - stderr_file = OldPkg.dir(package, "stderr.txt") - content = """ - println(stdout, "stdout") - println(stderr, "stderr") - """ - write_build(package, content) - - code = "import OldPkg; OldPkg.build(\"$package\")" - msg = run(pipeline( - `$(Base.julia_cmd()) --startup-file=no -e $code`, - stdout=stdout_file, stderr=stderr_file)) - @test last(readlines(stdout_file)) == "stdout" - @test last(readlines(stderr_file)) == "stderr" - end -end - -@testset "Pkg functions with .jl extension" begin - temp_pkg_dir() do - @test OldPkg.installed("Example.jl") === nothing - OldPkg.add("Example.jl") - @test [keys(OldPkg.installed())...] == ["Example"] - iob = IOBuffer() - OldPkg.update("Example.jl") - OldPkg.checkout("Example.jl") - OldPkg.status("Example.jl", iob) - str = chomp(String(take!(iob))) - @test startswith(str, " - Example") - @test endswith(str, "master") - OldPkg.free("Example.jl") - OldPkg.status("Example.jl", iob) - str = chomp(String(take!(iob))) - @test endswith(str, string(OldPkg.installed("Example.jl"))) - OldPkg.checkout("Example.jl") - OldPkg.free(("Example.jl",)) - OldPkg.status("Example.jl", iob) - str = chomp(String(take!(iob))) - @test endswith(str, string(OldPkg.installed("Example.jl"))) - OldPkg.rm("Example.jl") - @test isempty(OldPkg.installed()) - @test !isempty(OldPkg.available("Example.jl")) - @test !in("Example", keys(OldPkg.installed())) - OldPkg.rm("Example.jl") - @test isempty(OldPkg.installed()) - @test !isempty(OldPkg.available("Example.jl")) - @test !in("Example", keys(OldPkg.installed())) - OldPkg.clone("https://github.com/JuliaLang/Example.jl.git") - @test [keys(OldPkg.installed())...] == ["Example"] - OldPkg.status("Example.jl", iob) - str = chomp(String(take!(iob))) - @test startswith(str, " - Example") - @test endswith(str, "master") - OldPkg.free("Example.jl") - OldPkg.status("Example.jl", iob) - str = chomp(String(take!(iob))) - @test endswith(str, string(OldPkg.installed("Example.jl"))) - OldPkg.checkout("Example.jl") - OldPkg.free(("Example.jl",)) - OldPkg.status("Example.jl", iob) - str = chomp(String(take!(iob))) - @test endswith(str, string(OldPkg.installed("Example.jl"))) - end -end - -let io = IOBuffer() - Base.showerror(io, OldPkg.Entry.PkgTestError("ppp"), backtrace()) - @test !occursin("backtrace()", String(take!(io))) -end - -@testset "Relative path operations" begin - cd(tempdir()) do - temp_pkg_dir(randstring()) do - OldPkg.add("Example") - @test [keys(OldPkg.installed())...] == ["Example"] - end - end -end - -temp_pkg_dir(initialize=false) do - write_build("Normal", "") - write_build("Error", "error(\"An error has occurred while building a package\")") - write_build("Exit", "exit()") - - cd(OldPkg.dir()) do - errors = Dict() - - # Log forwarding TODO - port these to @test_logs - empty!(errors) - @test_warn ("Building Error", - "Building Normal") OldPkg.Entry.build!(["Error", "Normal"], errors) - - empty!(errors) - @test_warn ("Building Exit", - "Building Normal") OldPkg.Entry.build!(["Exit", "Normal"], errors) - - empty!(errors) - @test_warn ("Building Exit", - "Building Normal", - "Building Exit", - "Building Normal") OldPkg.Entry.build!(["Exit", "Normal", "Exit", "Normal"], errors) - end -end - -# VersionSet tests -import OldPkg.Types: VersionSet, VersionInterval - -function chkint(a::VersionSet) - ints = a.intervals - for k = 1:length(ints) - ints[k].lower < ints[k].upper || return false - k < length(ints) && (ints[k].upper < ints[k+1].lower || return false) - end - return true -end - -const empty_versionset = VersionSet(VersionInterval[]) -@test isempty(empty_versionset) - -# VersionSet intersections and unions -@test empty_versionset ∩ empty_versionset == empty_versionset -@test empty_versionset ∪ empty_versionset == empty_versionset -for t = 1:1_000 - a = VersionSet(sort!(map(v->VersionNumber(v...), [(rand(0:8),rand(0:3)) for i = 1:rand(0:10)]))...) - b = VersionSet(sort!(map(v->VersionNumber(v...), [(rand(0:8),rand(0:3)) for i = 1:rand(0:10)]))...) - @assert chkint(a) - @assert chkint(b) - u = a ∪ b - @test chkint(u) - i = a ∩ b - @test chkint(i) - for vM = 0:9, vm = 0:5 - v = VersionNumber(vM, vm) - @test (v ∈ a || v ∈ b) ? (v ∈ u) : (v ∉ u) - @test (v ∈ a && v ∈ b) ? (v ∈ i) : (v ∉ i) - end -end - -end # module diff --git a/stdlib/OldPkg/test/resolve.jl b/stdlib/OldPkg/test/resolve.jl deleted file mode 100644 index 40b7b784d65ad..0000000000000 --- a/stdlib/OldPkg/test/resolve.jl +++ /dev/null @@ -1,548 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -module PkgResolveTests - -using Test -import OldPkg -using OldPkg.Types -using OldPkg.Query -using OldPkg.Resolve -using OldPkg.Resolve.VersionWeights -import OldPkg.PkgError - -# Check that VersionWeight keeps the same ordering as VersionNumber - -vlst = [ - v"0.0.0", - v"0.0.1", - v"0.1.0", - v"0.1.1", - v"1.0.0", - v"1.0.1", - v"1.1.0", - v"1.1.1", - v"1.0.0-pre", - v"1.0.0-pre1", - v"1.0.1-pre", - v"1.0.0-0.pre.2", - v"1.0.0-0.pre.3", - v"1.0.0-0.pre1.tst", - v"1.0.0-pre.1+0.1", - v"1.0.0-pre.1+0.1plus", - v"1.0.0-pre.1-+0.1plus", - v"1.0.0-pre.1-+0.1Plus", - v"1.0.0-pre.1-+0.1pLUs", - v"1.0.0-pre.1-+0.1pluS", - v"1.0.0+0.1plus", - v"1.0.0+0.1plus-", - v"1.0.0+-", - v"1.0.0-", - v"1.0.0+", - v"1.0.0--", - v"1.0.0---", - v"1.0.0--+-", - v"1.0.0+--", - v"1.0.0+-.-", - v"1.0.0+0.-", - v"1.0.0+-.0", - v"1.0.0-a+--", - v"1.0.0-a+-.-", - v"1.0.0-a+0.-", - v"1.0.0-a+-.0" - ] - -for v1 in vlst, v2 in vlst - vw1 = VersionWeight(v1) - vw2 = VersionWeight(v2) - clt = v1 < v2 - @test clt == (vw1 < vw2) - ceq = v1 == v2 - @test ceq == (vw1 == vw2) -end - -# auxiliary functions - -function deps_from_data(deps_data) - deps = Dict{String,Dict{VersionNumber,Available}}() - for d in deps_data - p = d[1]; vn = d[2]; r = d[3:end] - if !haskey(deps, p) - deps[p] = Dict{VersionNumber,Available}() - end - if !haskey(deps[p], vn) - deps[p][vn] = Available("$(p)_$(vn)_sha1", Dict{String,VersionSet}()) - end - isempty(r) && continue - rp = r[1] - if length(r) > 1 - rvs = VersionSet(VersionNumber[r[2:end]...]) - else - rvs = VersionSet() - end - deps[p][vn].requires[rp] = rvs - end - deps -end -function reqs_from_data(reqs_data) - reqs = Dict{String,VersionSet}() - for r in reqs_data - p = r[1] - reqs[p] = VersionSet(VersionNumber[r[2:end]...]) - end - reqs -end -function sanity_tst(deps_data, expected_result; pkgs=[]) - deps = deps_from_data(deps_data) - #println("deps=$deps") - #println() - result = sanity_check(deps, Set(String[pkgs...])) - length(result) == length(expected_result) || return false - for (p, vn, pp) in result - (p, vn) ∈ expected_result || return false - end - return true -end -sanity_tst(deps_data; kw...) = sanity_tst(deps_data, []; kw...) - -function resolve_tst(deps_data, reqs_data, want_data = nothing) - deps = deps_from_data(deps_data) - reqs = reqs_from_data(reqs_data) - - #println() - #println("deps=$deps") - #println("reqs=$reqs") - deps = Query.prune_dependencies(reqs, deps) - want = resolve(reqs, deps) - return want == want_data -end - -## DEPENDENCY SCHEME 1: TWO PACKAGES, DAG -deps_data = Any[ - ["A", v"1", "B", v"1"], - ["A", v"2", "B", v"2"], - ["B", v"1"], - ["B", v"2"] -] - -@test sanity_tst(deps_data) -@test sanity_tst(deps_data, pkgs=["A", "B"]) -@test sanity_tst(deps_data, pkgs=["B"]) -@test sanity_tst(deps_data, pkgs=["A"]) - -# require just B -reqs_data = Any[ - ["B"] -] - -want_data = Dict("B"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require just A: must bring in B -reqs_data = Any[ - ["A"] -] -want_data = Dict("A"=>v"2", "B"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - - -## DEPENDENCY SCHEME 2: TWO PACKAGES, CYCLIC -deps_data = Any[ - ["A", v"1", "B", v"2"], - ["A", v"2", "B", v"1"], - ["B", v"1", "A", v"2"], - ["B", v"2", "A", v"1"] -] - -@test sanity_tst(deps_data) - -# require just A -reqs_data = Any[ - ["A"] -] -want_data = Dict("A"=>v"2", "B"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require just B, force lower version -reqs_data = Any[ - ["B", v"1", v"2"] -] -want_data = Dict("A"=>v"2", "B"=>v"1") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require just A, force lower version -reqs_data = Any[ - ["A", v"1", v"2"] -] -want_data = Dict("A"=>v"1", "B"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - - -## DEPENDENCY SCHEME 3: THREE PACKAGES, CYCLIC, TWO MUTUALLY EXCLUSIVE SOLUTIONS -deps_data = Any[ - ["A", v"1", "B", v"2"], - ["A", v"2", "B", v"1", v"2"], - ["B", v"1", "C", v"2"], - ["B", v"2", "C", v"1", v"2"], - ["C", v"1", "A", v"1", v"2"], - ["C", v"2", "A", v"2"] -] - -@test sanity_tst(deps_data) - -# require just A (must choose solution which has the highest version for A) -reqs_data = Any[ - ["A"] -] -want_data = Dict("A"=>v"2", "B"=>v"1", "C"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require just B (must choose solution which has the highest version for B) -reqs_data = Any[ - ["B"] -] -want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"1") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require just A, force lower version -reqs_data = Any[ - ["A", v"1", v"2"] -] -want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"1") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require A and C, incompatible versions -reqs_data = Any[ - ["A", v"1", v"2"], - ["C", v"2"] -] -@test_throws PkgError resolve_tst(deps_data, reqs_data) - - -## DEPENDENCY SCHEME 4: TWO PACKAGES, DAG, WITH TRIVIAL INCONSISTENCY -deps_data = Any[ - ["A", v"1", "B", v"2"], - ["B", v"1"] -] - -@test sanity_tst(deps_data, [("A", v"1")]) -@test sanity_tst(deps_data, [("A", v"1")], pkgs=["B"]) - -# require B (must not give errors) -reqs_data = Any[ - ["B"] -] -want_data = Dict("B"=>v"1") -@test resolve_tst(deps_data, reqs_data, want_data) - - -## DEPENDENCY SCHEME 5: THREE PACKAGES, DAG, WITH IMPLICIT INCONSISTENCY -deps_data = Any[ - ["A", v"1", "B", v"2"], - ["A", v"1", "C", v"2"], - ["A", v"2", "B", v"1", v"2"], - ["A", v"2", "C", v"1", v"2"], - ["B", v"1", "C", v"2"], - ["B", v"2", "C", v"2"], - ["C", v"1"], - ["C", v"2"] -] - -@test sanity_tst(deps_data, [("A", v"2")]) -@test sanity_tst(deps_data, [("A", v"2")], pkgs=["B"]) -@test sanity_tst(deps_data, [("A", v"2")], pkgs=["C"]) - -# require A, any version (must use the highest non-inconsistent) -reqs_data = Any[ - ["A"] -] -want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require A, force highest version (impossible) -reqs_data = Any[ - ["A", v"2"] -] -@test_throws PkgError resolve_tst(deps_data, reqs_data) - - -## DEPENDENCY SCHEME 6: TWO PACKAGES, CYCLIC, TOTALLY INCONSISTENT -deps_data = Any[ - ["A", v"1", "B", v"2"], - ["A", v"2", "B", v"1", v"2"], - ["B", v"1", "A", v"1", v"2"], - ["B", v"2", "A", v"2"] -] - -@test sanity_tst(deps_data, [("A", v"1"), ("A", v"2"), - ("B", v"1"), ("B", v"2")]) - -# require A (impossible) -reqs_data = Any[ - ["A"] -] -@test_throws PkgError resolve_tst(deps_data, reqs_data) - -# require B (impossible) -reqs_data = Any[ - ["B"] -] -@test_throws PkgError resolve_tst(deps_data, reqs_data) - - -## DEPENDENCY SCHEME 7: THREE PACKAGES, CYCLIC, WITH INCONSISTENCY -deps_data = Any[ - ["A", v"1", "B", v"1", v"2"], - ["A", v"2", "B", v"2"], - ["B", v"1", "C", v"1", v"2"], - ["B", v"2", "C", v"2"], - ["C", v"1", "A", v"2"], - ["C", v"2", "A", v"2"], -] - -@test sanity_tst(deps_data, [("A", v"1"), ("B", v"1"), - ("C", v"1")]) - -# require A -reqs_data = Any[ - ["A"] -] -want_data = Dict("A"=>v"2", "B"=>v"2", "C"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require C -reqs_data = Any[ - ["C"] -] -want_data = Dict("A"=>v"2", "B"=>v"2", "C"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require C, lowest version (impossible) -reqs_data = Any[ - ["C", v"1", v"2"] -] -@test_throws PkgError resolve_tst(deps_data, reqs_data) - - -## DEPENDENCY SCHEME 8: THREE PACKAGES, CYCLIC, TOTALLY INCONSISTENT -deps_data = Any[ - ["A", v"1", "B", v"1", v"2"], - ["A", v"2", "B", v"2"], - ["B", v"1", "C", v"1", v"2"], - ["B", v"2", "C", v"2"], - ["C", v"1", "A", v"2"], - ["C", v"2", "A", v"1", v"2"], -] - -@test sanity_tst(deps_data, [("A", v"1"), ("A", v"2"), - ("B", v"1"), ("B", v"2"), - ("C", v"1"), ("C", v"2")]) - -# require A (impossible) -reqs_data = Any[ - ["A"] -] -@test_throws PkgError resolve_tst(deps_data, reqs_data) - -# require B (impossible) -reqs_data = Any[ - ["B"] -] -@test_throws PkgError resolve_tst(deps_data, reqs_data) - -# require C (impossible) -reqs_data = Any[ - ["C"] -] -@test_throws PkgError resolve_tst(deps_data, reqs_data) - -## DEPENDENCY SCHEME 9: SIX PACKAGES, DAG -deps_data = Any[ - ["A", v"1"], - ["A", v"2"], - ["A", v"3"], - ["B", v"1", "A", v"1", v"2"], - ["B", v"2", "A"], - ["C", v"1", "A", v"2", v"3"], - ["C", v"2", "A", v"2"], - ["D", v"1", "B", v"1"], - ["D", v"2", "B", v"2"], - ["E", v"1", "D"], - ["F", v"1", "A", v"1", v"3"], - ["F", v"1", "E"], - ["F", v"2", "C", v"2"], - ["F", v"2", "E"], -] - -@test sanity_tst(deps_data) - -# require just F -reqs_data = Any[ - ["F"] -] -want_data = Dict("A"=>v"3", "B"=>v"2", "C"=>v"2", - "D"=>v"2", "E"=>v"1", "F"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require just F, lower version -reqs_data = Any[ - ["F", v"1", v"2"] -] -want_data = Dict("A"=>v"2", "B"=>v"2", "D"=>v"2", - "E"=>v"1", "F"=>v"1") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require F and B; force lower B version -> must bring down F, A, and D versions too -reqs_data = Any[ - ["F"], - ["B", v"1", v"2"] -] -want_data = Dict("A"=>v"1", "B"=>v"1", "D"=>v"1", - "E"=>v"1", "F"=>v"1") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require F and D; force lower D version -> must not bring down F version -reqs_data = Any[ - ["F"], - ["D", v"1", v"2"] -] -want_data = Dict("A"=>v"3", "B"=>v"2", "C"=>v"2", - "D"=>v"1", "E"=>v"1", "F"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require F and C; force lower C version -> must bring down F and A versions -reqs_data = Any[ - ["F"], - ["C", v"1", v"2"] -] -want_data = Dict("A"=>v"2", "B"=>v"2", "C"=>v"1", - "D"=>v"2", "E"=>v"1", "F"=>v"1") -@test resolve_tst(deps_data, reqs_data, want_data) - -## DEPENDENCY SCHEME 10: SIX PACKAGES, DAG, WITH PRERELEASE/BUILD VERSIONS -deps_data = Any[ - ["A", v"1"], - ["A", v"2-rc.1"], - ["A", v"2-rc.1+bld"], - ["A", v"2"], - ["A", v"2.1.0"], - ["B", v"1", "A", v"1", v"2-"], - ["B", v"1.0.1-beta", "A", v"2-rc"], - ["B", v"1.0.1", "A"], - ["C", v"1", "A", v"2-", v"2.1"], - ["C", v"1+BLD", "A", v"2-rc.1", v"2.1"], - ["C", v"2", "A", v"2-rc.1"], - ["D", v"1", "B", v"1"], - ["D", v"2", "B", v"1.0.1-"], - ["E", v"1-plztst", "D"], - ["E", v"1", "D"], - ["F", v"1.1", "A", v"1", v"2.1"], - ["F", v"1.1", "E", v"1"], - ["F", v"2-rc.1", "A", v"2-", v"2.1"], - ["F", v"2-rc.1", "C", v"1"], - ["F", v"2-rc.1", "E"], - ["F", v"2-rc.2", "A", v"2-", v"2.1"], - ["F", v"2-rc.2", "C", v"2"], - ["F", v"2-rc.2", "E"], - ["F", v"2", "C", v"2"], - ["F", v"2", "E"], -] - -@test sanity_tst(deps_data) - -# require just F -reqs_data = Any[ - ["F"] -] -want_data = Dict("A"=>v"2.1", "B"=>v"1.0.1", "C"=>v"2", - "D"=>v"2", "E"=>v"1", "F"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require just F, lower version -reqs_data = Any[ - ["F", v"1", v"2-"] -] -want_data = Dict("A"=>v"2", "B"=>v"1.0.1", "D"=>v"2", - "E"=>v"1", "F"=>v"1.1") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require F and B; force lower B version -> must bring down F, A, and D versions too -reqs_data = Any[ - ["F"], - ["B", v"1", v"1.0.1-"] -] -want_data = Dict("A"=>v"1", "B"=>v"1", "D"=>v"1", - "E"=>v"1", "F"=>v"1.1") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require F and D; force lower D version -> must not bring down F version -reqs_data = Any[ - ["F"], - ["D", v"1", v"2"] -] -want_data = Dict("A"=>v"2.1", "B"=>v"1.0.1", "C"=>v"2", - "D"=>v"1", "E"=>v"1", "F"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require F and C; force lower C version -> must bring down F and A versions -reqs_data = Any[ - ["F"], - ["C", v"1", v"2"] -] -want_data = Dict("A"=>v"2", "B"=>v"1.0.1", "C"=>v"1+BLD", - "D"=>v"2", "E"=>v"1", "F"=>v"2-rc.1") -@test resolve_tst(deps_data, reqs_data, want_data) - -## DEPENDENCY SCHEME 11: FIVE PACKAGES, SAME AS SCHEMES 5 + 1, UNCONNECTED -deps_data = Any[ - ["A", v"1", "B", v"2"], - ["A", v"1", "C", v"2"], - ["A", v"2", "B", v"1", v"2"], - ["A", v"2", "C", v"1", v"2"], - ["B", v"1", "C", v"2"], - ["B", v"2", "C", v"2"], - ["C", v"1"], - ["C", v"2"], - ["D", v"1", "E", v"1"], - ["D", v"2", "E", v"2"], - ["E", v"1"], - ["E", v"2"] -] - -@test sanity_tst(deps_data, [("A", v"2")]) -@test sanity_tst(deps_data, [("A", v"2")], pkgs=["B"]) -@test sanity_tst(deps_data, pkgs=["D"]) -@test sanity_tst(deps_data, pkgs=["E"]) -@test sanity_tst(deps_data, [("A", v"2")], pkgs=["B", "D"]) - -# require A, any version (must use the highest non-inconsistent) -reqs_data = Any[ - ["A"] -] -want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -# require just D: must bring in E -reqs_data = Any[ - ["D"] -] -want_data = Dict("D"=>v"2", "E"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - - -# require A and D, must be the merge of the previous two cases -reqs_data = Any[ - ["A"], - ["D"] -] -want_data = Dict("A"=>v"1", "B"=>v"2", "C"=>v"2", "D"=>v"2", "E"=>v"2") -@test resolve_tst(deps_data, reqs_data, want_data) - -## DEPENDENCY SCHEME 12: A REALISTIC EXAMPLE -## ref issue #21485 - -include("resolvedata1.jl") - -@test sanity_tst(deps_data, problematic_data) -@test resolve_tst(deps_data, reqs_data, want_data) - -end # module diff --git a/stdlib/OldPkg/test/resolvedata1.jl b/stdlib/OldPkg/test/resolvedata1.jl deleted file mode 100644 index 26d6c649f29e8..0000000000000 --- a/stdlib/OldPkg/test/resolvedata1.jl +++ /dev/null @@ -1,2853 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -deps_data = Any[ - ["ASTInterpreter", v"0.0.1", "AbstractTrees", v"0.0.1", v"0.1.0"], - ["ASTInterpreter", v"0.0.1", "JuliaParser", v"0.7.1"], - ["ASTInterpreter", v"0.0.3", "AbstractTrees", v"0.0.2", v"0.1.0"], - ["ASTInterpreter", v"0.0.3", "JuliaParser", v"0.7.2"], - ["ASTInterpreter", v"0.0.4", "AbstractTrees", v"0.0.4", v"0.1.0"], - ["ASTInterpreter", v"0.0.4", "JuliaParser", v"0.7.2"], - ["AbstractTrees", v"0.0.1"], - ["AbstractTrees", v"0.0.3"], - ["AbstractTrees", v"0.0.4"], - ["AbstractTrees", v"0.1.0", "Compat", v"0.17.0"], - ["AlgebraicDiffEq", v"0.0.1", "DiffEqBase"], - ["AlgebraicDiffEq", v"0.0.1", "Parameters", v"0.5.0"], - ["AlgebraicDiffEq", v"0.0.1", "Sundials", v"0.3.0"], - ["AlgebraicDiffEq", v"0.0.2", "DiffEqBase"], - ["AlgebraicDiffEq", v"0.0.2", "Parameters", v"0.5.0"], - ["AlgebraicDiffEq", v"0.0.2", "Sundials", v"0.3.0"], - ["AlgebraicDiffEq", v"0.1.0", "DiffEqBase", v"0.2.0"], - ["AlgebraicDiffEq", v"0.1.0", "Parameters", v"0.5.0"], - ["AnsiColor", v"0.0.2"], - ["ArgParse", v"0.2.9", "Options"], - ["ArgParse", v"0.2.9", "TextWrap", v"0.1.0-"], - ["ArgParse", v"0.2.10", "Compat"], - ["ArgParse", v"0.2.10", "Options"], - ["ArgParse", v"0.2.10", "TextWrap", v"0.1.0-"], - ["ArgParse", v"0.2.12", "Options"], - ["ArgParse", v"0.2.12", "Compat", v"0.2.9"], - ["ArgParse", v"0.2.12", "TextWrap", v"0.1.0-"], - ["ArgParse", v"0.2.13", "Options"], - ["ArgParse", v"0.2.13", "Compat", v"0.7.3"], - ["ArgParse", v"0.2.13", "TextWrap", v"0.1.4"], - ["ArgParse", v"0.3.0", "Compat", v"0.7.3"], - ["ArgParse", v"0.3.0", "TextWrap", v"0.1.4"], - ["ArgParse", v"0.4.0", "Compat", v"0.8.0"], - ["ArgParse", v"0.4.0", "TextWrap", v"0.1.4"], - ["ArrayViews", v"0.1.1"], - ["ArrayViews", v"0.3.0"], - ["ArrayViews", v"0.4.5"], - ["ArrayViews", v"0.4.7"], - ["ArrayViews", v"0.4.8"], - ["ArrayViews", v"0.4.9"], - ["ArrayViews", v"0.4.11"], - ["ArrayViews", v"0.6.3"], - ["ArrayViews", v"0.6.4", "Compat"], - ["Atom", v"0.2.1", "CodeTools"], - ["Atom", v"0.2.1", "Hiccup"], - ["Atom", v"0.2.1", "JSON"], - ["Atom", v"0.2.1", "LNR"], - ["Atom", v"0.2.1", "Lazy"], - ["Atom", v"0.2.1", "Media"], - ["Atom", v"0.4.0", "Blink"], - ["Atom", v"0.4.0", "CodeTools"], - ["Atom", v"0.4.0", "Hiccup"], - ["Atom", v"0.4.0", "JSON"], - ["Atom", v"0.4.0", "LNR"], - ["Atom", v"0.4.0", "Lazy"], - ["Atom", v"0.4.0", "Media"], - ["Atom", v"0.4.0", "Reexport"], - ["Atom", v"0.4.6", "Blink"], - ["Atom", v"0.4.6", "CodeTools"], - ["Atom", v"0.4.6", "Hiccup"], - ["Atom", v"0.4.6", "JSON"], - ["Atom", v"0.4.6", "LNR"], - ["Atom", v"0.4.6", "Lazy"], - ["Atom", v"0.4.6", "MacroTools"], - ["Atom", v"0.4.6", "Media"], - ["Atom", v"0.4.6", "Reexport"], - ["Atom", v"0.4.6", "Requires"], - ["Atom", v"0.5.0", "ASTInterpreter"], - ["Atom", v"0.5.0", "Blink"], - ["Atom", v"0.5.0", "CodeTools"], - ["Atom", v"0.5.0", "Gallium"], - ["Atom", v"0.5.0", "Hiccup"], - ["Atom", v"0.5.0", "JSON"], - ["Atom", v"0.5.0", "LNR"], - ["Atom", v"0.5.0", "Lazy"], - ["Atom", v"0.5.0", "MacroTools"], - ["Atom", v"0.5.0", "Media"], - ["Atom", v"0.5.0", "Reexport"], - ["Atom", v"0.5.0", "Requires"], - ["Atom", v"0.5.2", "ASTInterpreter"], - ["Atom", v"0.5.2", "Blink"], - ["Atom", v"0.5.2", "CodeTools"], - ["Atom", v"0.5.2", "Gallium"], - ["Atom", v"0.5.2", "Hiccup"], - ["Atom", v"0.5.2", "JSON"], - ["Atom", v"0.5.2", "Juno"], - ["Atom", v"0.5.2", "LNR"], - ["Atom", v"0.5.2", "Lazy"], - ["Atom", v"0.5.2", "MacroTools"], - ["Atom", v"0.5.2", "Media"], - ["Atom", v"0.5.2", "Reexport"], - ["Atom", v"0.5.2", "Requires"], - ["Atom", v"0.5.8", "ASTInterpreter"], - ["Atom", v"0.5.8", "Blink"], - ["Atom", v"0.5.8", "CodeTools"], - ["Atom", v"0.5.8", "Gallium"], - ["Atom", v"0.5.8", "Hiccup"], - ["Atom", v"0.5.8", "JSON"], - ["Atom", v"0.5.8", "Juno"], - ["Atom", v"0.5.8", "LNR"], - ["Atom", v"0.5.8", "MacroTools"], - ["Atom", v"0.5.8", "Media"], - ["Atom", v"0.5.8", "Reexport"], - ["Atom", v"0.5.8", "Lazy", v"0.11.3"], - ["Atom", v"0.5.10", "ASTInterpreter"], - ["Atom", v"0.5.10", "Blink"], - ["Atom", v"0.5.10", "CodeTools"], - ["Atom", v"0.5.10", "Gallium"], - ["Atom", v"0.5.10", "Hiccup"], - ["Atom", v"0.5.10", "JSON"], - ["Atom", v"0.5.10", "LNR"], - ["Atom", v"0.5.10", "MacroTools"], - ["Atom", v"0.5.10", "Media"], - ["Atom", v"0.5.10", "Reexport"], - ["Atom", v"0.5.10", "Juno", v"0.2.6"], - ["Atom", v"0.5.10", "Lazy", v"0.11.3"], - ["AxisAlgorithms", v"0.1.6", "WoodburyMatrices"], - ["AxisAlgorithms", v"0.1.6", "Compat", v"0.8.0"], - ["AxisArrays", v"0.0.3", "IntervalSets"], - ["AxisArrays", v"0.0.3", "Iterators"], - ["AxisArrays", v"0.0.3", "RangeArrays"], - ["AxisArrays", v"0.1.2", "Compat", v"0.19.0"], - ["AxisArrays", v"0.1.2", "IntervalSets"], - ["AxisArrays", v"0.1.2", "Iterators"], - ["AxisArrays", v"0.1.2", "RangeArrays"], - ["BinDeps", v"0.2.0"], - ["BinDeps", v"0.2.4", "URIParser"], - ["BinDeps", v"0.2.14", "URIParser"], - ["BinDeps", v"0.3.4", "URIParser"], - ["BinDeps", v"0.3.4", "SHA", v"0.0.0", v"0.0.3"], - ["BinDeps", v"0.3.5", "URIParser"], - ["BinDeps", v"0.3.5", "SHA", v"0.0.3"], - ["BinDeps", v"0.3.8", "SHA"], - ["BinDeps", v"0.3.8", "URIParser"], - ["BinDeps", v"0.3.10", "Compat", v"0.3.6"], - ["BinDeps", v"0.3.10", "SHA"], - ["BinDeps", v"0.3.10", "URIParser"], - ["BinDeps", v"0.3.15", "Compat", v"0.4.0"], - ["BinDeps", v"0.3.15", "SHA"], - ["BinDeps", v"0.3.15", "URIParser"], - ["BinDeps", v"0.3.21", "Compat", v"0.7.1"], - ["BinDeps", v"0.3.21", "SHA"], - ["BinDeps", v"0.3.21", "URIParser"], - ["BinDeps", v"0.3.23", "URIParser"], - ["BinDeps", v"0.3.23", "Compat", v"0.8.4"], - ["BinDeps", v"0.3.23", "SHA"], - ["BinDeps", v"0.4.2", "Compat", v"0.8.4"], - ["BinDeps", v"0.4.2", "SHA"], - ["BinDeps", v"0.4.2", "URIParser"], - ["BinDeps", v"0.4.5", "Compat", v"0.8.4"], - ["BinDeps", v"0.4.5", "SHA"], - ["BinDeps", v"0.4.5", "URIParser"], - ["BinDeps", v"0.4.7", "Compat", v"0.17.0"], - ["BinDeps", v"0.4.7", "SHA"], - ["BinDeps", v"0.4.7", "URIParser"], - ["Blink", v"0.1.4", "JSON"], - ["Blink", v"0.1.4", "Lazy"], - ["Blink", v"0.1.4", "Requires"], - ["Blink", v"0.1.5", "JSON"], - ["Blink", v"0.1.5", "Lazy"], - ["Blink", v"0.1.5", "MacroTools"], - ["Blink", v"0.1.5", "Requires"], - ["Blink", v"0.2.0", "HttpServer"], - ["Blink", v"0.2.0", "JSON"], - ["Blink", v"0.2.0", "Lazy"], - ["Blink", v"0.2.0", "MacroTools"], - ["Blink", v"0.2.0", "Mustache"], - ["Blink", v"0.2.0", "Reexport"], - ["Blink", v"0.2.0", "Requires"], - ["Blink", v"0.2.0", "WebSockets"], - ["Blink", v"0.2.1", "HttpServer"], - ["Blink", v"0.2.1", "JSON"], - ["Blink", v"0.2.1", "Lazy"], - ["Blink", v"0.2.1", "MacroTools"], - ["Blink", v"0.2.1", "Mustache"], - ["Blink", v"0.2.1", "Mux"], - ["Blink", v"0.2.1", "Reexport"], - ["Blink", v"0.2.1", "Requires"], - ["Blink", v"0.2.1", "WebSockets"], - ["Blink", v"0.3.4", "BinDeps"], - ["Blink", v"0.3.4", "HttpServer"], - ["Blink", v"0.3.4", "JSON"], - ["Blink", v"0.3.4", "Lazy"], - ["Blink", v"0.3.4", "MacroTools"], - ["Blink", v"0.3.4", "Mustache"], - ["Blink", v"0.3.4", "Mux"], - ["Blink", v"0.3.4", "Reexport"], - ["Blink", v"0.3.4", "Requires"], - ["Blink", v"0.3.4", "WebSockets"], - ["Blink", v"0.4.1", "BinDeps"], - ["Blink", v"0.4.1", "HttpServer"], - ["Blink", v"0.4.1", "Mustache"], - ["Blink", v"0.4.1", "Reexport"], - ["Blink", v"0.4.1", "Requires"], - ["Blink", v"0.4.1", "Compat", v"0.8.6"], - ["Blink", v"0.4.1", "JSON"], - ["Blink", v"0.4.1", "Lazy"], - ["Blink", v"0.4.1", "MacroTools"], - ["Blink", v"0.4.1", "Mux"], - ["Blink", v"0.4.1", "WebSockets"], - ["Blink", v"0.5.1", "BinDeps"], - ["Blink", v"0.5.1", "HttpServer"], - ["Blink", v"0.5.1", "Compat", v"0.8.6"], - ["Blink", v"0.5.1", "JSON"], - ["Blink", v"0.5.1", "MacroTools"], - ["Blink", v"0.5.1", "Mustache"], - ["Blink", v"0.5.1", "Lazy", v"0.11.3"], - ["Blink", v"0.5.1", "Mux"], - ["Blink", v"0.5.1", "Reexport"], - ["Blink", v"0.5.1", "WebSockets"], - ["Blocks", v"0.0.4"], - ["Blocks", v"0.1.0", "Compat"], - ["Blosc", v"0.1.1", "BinDeps"], - ["Blosc", v"0.1.5", "BinDeps"], - ["Blosc", v"0.1.5", "Compat"], - ["Blosc", v"0.2.0", "BinDeps"], - ["Blosc", v"0.2.0", "Compat", v"0.8.0"], - ["COFF", v"0.0.2", "DWARF"], - ["COFF", v"0.0.2", "ObjFileBase"], - ["COFF", v"0.0.2", "StructIO"], - ["CRC", v"0.1.0", "ArgParse"], - ["CRC", v"0.1.0", "Zlib"], - ["CRC", v"1.1.1", "ArgParse"], - ["CRC", v"1.1.1", "Compat"], - ["CRC", v"1.2.0", "ArgParse"], - ["Calculus", v"0.1.5"], - ["Calculus", v"0.1.6", "Compat"], - ["Calculus", v"0.1.14", "Compat", v"0.4.0"], - ["Calculus", v"0.1.15", "Compat", v"0.4.0"], - ["Calculus", v"0.2.0", "Compat", v"0.4.0"], - ["Calculus", v"0.2.2", "Compat", v"0.17.0"], - ["Calendar", v"0.4.3", "ICU"], - ["CatIndices", v"0.0.2", "CustomUnitRanges"], - ["CatIndices", v"0.0.2", "OffsetArrays"], - ["ChunkedArrays", v"0.0.1", "Compat"], - ["ChunkedArrays", v"0.0.1", "EllipsisNotation"], - ["ChunkedArrays", v"0.0.2", "Compat"], - ["ChunkedArrays", v"0.0.2", "EllipsisNotation"], - ["ChunkedArrays", v"0.1.0", "Compat"], - ["ChunkedArrays", v"0.1.0", "EllipsisNotation"], - ["ChunkedArrays", v"0.1.1", "EllipsisNotation", v"0.0.2"], - ["CodeTools", v"0.1.0", "JuliaParser"], - ["CodeTools", v"0.1.0", "LNR"], - ["CodeTools", v"0.1.0", "Lazy"], - ["CodeTools", v"0.1.0", "MacroTools"], - ["CodeTools", v"0.2.0", "Compat"], - ["CodeTools", v"0.2.0", "JuliaParser"], - ["CodeTools", v"0.2.0", "LNR"], - ["CodeTools", v"0.2.0", "Lazy"], - ["CodeTools", v"0.2.0", "MacroTools"], - ["CodeTools", v"0.4.1", "Compat"], - ["CodeTools", v"0.4.1", "JuliaParser"], - ["CodeTools", v"0.4.1", "LNR"], - ["CodeTools", v"0.4.1", "Lazy"], - ["CodeTools", v"0.4.1", "MacroTools"], - ["CodeTools", v"0.4.1", "Requires"], - ["CodeTools", v"0.4.3", "LNR"], - ["CodeTools", v"0.4.3", "Lazy"], - ["CodeTools", v"0.4.3", "MacroTools"], - ["Codecs", v"0.1.0", "Iterators"], - ["Codecs", v"0.1.3"], - ["Codecs", v"0.1.5", "Compat"], - ["Codecs", v"0.2.0", "Compat", v"0.7.20"], - ["Codecs", v"0.3.0", "Compat", v"0.17.0"], - ["ColorTypes", v"0.0.1", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["ColorTypes", v"0.0.1", "FixedSizeArrays"], - ["ColorTypes", v"0.1.7", "Compat"], - ["ColorTypes", v"0.1.7", "Docile"], - ["ColorTypes", v"0.1.7", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["ColorTypes", v"0.2.6", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["ColorTypes", v"0.2.8", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["ColorTypes", v"0.2.12", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["ColorTypes", v"0.3.0", "FixedPointNumbers", v"0.3.0"], - ["ColorTypes", v"0.3.2", "Compat", v"0.16.0"], - ["ColorTypes", v"0.3.2", "FixedPointNumbers", v"0.3.0"], - ["ColorTypes", v"0.3.3", "Compat", v"0.17.0"], - ["ColorTypes", v"0.3.3", "FixedPointNumbers", v"0.3.0"], - ["ColorTypes", v"0.3.5", "Compat", v"0.18.0"], - ["ColorTypes", v"0.3.5", "FixedPointNumbers", v"0.3.0"], - ["ColorTypes", v"0.4.1", "Compat", v"0.18.0"], - ["ColorTypes", v"0.4.1", "FixedPointNumbers", v"0.3.0"], - ["ColorVectorSpace", v"0.0.5", "ColorTypes"], - ["ColorVectorSpace", v"0.0.5", "Compat"], - ["ColorVectorSpace", v"0.0.5", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["ColorVectorSpace", v"0.1.7", "ColorTypes", v"0.2.0"], - ["ColorVectorSpace", v"0.1.7", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["ColorVectorSpace", v"0.1.8", "ColorTypes", v"0.2.0"], - ["ColorVectorSpace", v"0.1.8", "Compat", v"0.9.1"], - ["ColorVectorSpace", v"0.1.8", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["ColorVectorSpace", v"0.1.10", "ColorTypes", v"0.2.7"], - ["ColorVectorSpace", v"0.1.10", "Compat", v"0.9.1"], - ["ColorVectorSpace", v"0.1.10", "FixedPointNumbers", v"0.1.8", v"0.3.0"], - ["ColorVectorSpace", v"0.1.12", "ColorTypes", v"0.2.7"], - ["ColorVectorSpace", v"0.1.12", "Compat", v"0.9.1"], - ["ColorVectorSpace", v"0.1.12", "FixedPointNumbers", v"0.1.8", v"0.3.0"], - ["ColorVectorSpace", v"0.2.0", "ColorTypes", v"0.3.0"], - ["ColorVectorSpace", v"0.2.0", "Compat", v"0.9.1"], - ["ColorVectorSpace", v"0.2.0", "FixedPointNumbers", v"0.3.0"], - ["ColorVectorSpace", v"0.3.0", "ColorTypes", v"0.3.3"], - ["ColorVectorSpace", v"0.3.0", "Colors", v"0.7.1"], - ["ColorVectorSpace", v"0.3.0", "Compat", v"0.9.1"], - ["ColorVectorSpace", v"0.3.0", "FixedPointNumbers", v"0.3.0"], - ["ColorVectorSpace", v"0.3.0", "StatsBase", v"0.8.2"], - ["ColorVectorSpace", v"0.4.0", "ColorTypes", v"0.3.3"], - ["ColorVectorSpace", v"0.4.0", "Colors", v"0.7.1"], - ["ColorVectorSpace", v"0.4.0", "Compat", v"0.18.0"], - ["ColorVectorSpace", v"0.4.0", "FixedPointNumbers", v"0.3.0"], - ["ColorVectorSpace", v"0.4.0", "StatsBase", v"0.8.2"], - ["ColorVectorSpace", v"0.4.2", "ColorTypes", v"0.4.0"], - ["ColorVectorSpace", v"0.4.2", "Colors", v"0.7.1"], - ["ColorVectorSpace", v"0.4.2", "Compat", v"0.18.0"], - ["ColorVectorSpace", v"0.4.2", "FixedPointNumbers", v"0.3.0"], - ["ColorVectorSpace", v"0.4.2", "StatsBase", v"0.8.2"], - ["Colors", v"0.4.7", "Compat", v"0.2.0"], - ["Colors", v"0.4.7", "Graphics", v"0.1.0"], - ["Colors", v"0.4.7", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["Colors", v"0.5.0", "ColorTypes"], - ["Colors", v"0.5.0", "Reexport"], - ["Colors", v"0.5.0", "Compat", v"0.2.0"], - ["Colors", v"0.5.0", "Graphics", v"0.1.0"], - ["Colors", v"0.5.0", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["Colors", v"0.5.4", "ColorTypes"], - ["Colors", v"0.5.4", "Reexport"], - ["Colors", v"0.5.4", "Compat", v"0.2.0"], - ["Colors", v"0.5.4", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["Colors", v"0.6.2", "Reexport"], - ["Colors", v"0.6.2", "ColorTypes", v"0.2.0"], - ["Colors", v"0.6.2", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["Colors", v"0.6.4", "Compat"], - ["Colors", v"0.6.4", "Reexport"], - ["Colors", v"0.6.4", "ColorTypes", v"0.2.0"], - ["Colors", v"0.6.4", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["Colors", v"0.6.6", "Reexport"], - ["Colors", v"0.6.6", "ColorTypes", v"0.2.0"], - ["Colors", v"0.6.6", "Compat", v"0.8.0"], - ["Colors", v"0.6.6", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["Colors", v"0.6.7", "Reexport"], - ["Colors", v"0.6.7", "ColorTypes", v"0.2.0"], - ["Colors", v"0.6.7", "Compat", v"0.9.1"], - ["Colors", v"0.6.7", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["Colors", v"0.6.8", "Reexport"], - ["Colors", v"0.6.8", "ColorTypes", v"0.2.7"], - ["Colors", v"0.6.8", "Compat", v"0.9.1"], - ["Colors", v"0.6.8", "FixedPointNumbers", v"0.1.8", v"0.3.0"], - ["Colors", v"0.6.9", "Reexport"], - ["Colors", v"0.6.9", "ColorTypes", v"0.2.9"], - ["Colors", v"0.6.9", "Compat", v"0.9.1"], - ["Colors", v"0.6.9", "FixedPointNumbers", v"0.1.8", v"0.3.0"], - ["Colors", v"0.7.0", "Reexport"], - ["Colors", v"0.7.0", "ColorTypes", v"0.3.0"], - ["Colors", v"0.7.0", "Compat", v"0.9.1"], - ["Colors", v"0.7.0", "FixedPointNumbers", v"0.3.0"], - ["Colors", v"0.7.1", "Reexport"], - ["Colors", v"0.7.1", "ColorTypes", v"0.3.0"], - ["Colors", v"0.7.1", "Compat", v"0.9.1"], - ["Colors", v"0.7.1", "FixedPointNumbers", v"0.3.0"], - ["Colors", v"0.7.2", "Reexport"], - ["Colors", v"0.7.2", "ColorTypes", v"0.3.0"], - ["Colors", v"0.7.2", "Compat", v"0.17.0"], - ["Colors", v"0.7.2", "FixedPointNumbers", v"0.3.0"], - ["Colors", v"0.7.3", "ColorTypes", v"0.3.0"], - ["Colors", v"0.7.3", "Compat", v"0.18.0"], - ["Colors", v"0.7.3", "FixedPointNumbers", v"0.3.0"], - ["Colors", v"0.7.3", "Reexport"], - ["Combinatorics", v"0.2.0", "Compat"], - ["Combinatorics", v"0.2.0", "Iterators"], - ["Combinatorics", v"0.2.0", "Polynomials"], - ["Combinatorics", v"0.3.2", "Iterators"], - ["Combinatorics", v"0.3.2", "Polynomials"], - ["Combinatorics", v"0.4.0", "Compat", v"0.18.0"], - ["Combinatorics", v"0.4.0", "Iterators"], - ["Combinatorics", v"0.4.0", "Polynomials"], - ["Compat", v"0.8.1"], - ["Compat", v"0.8.3"], - ["Compat", v"0.8.4"], - ["Compat", v"0.8.5"], - ["Compat", v"0.8.6"], - ["Compat", v"0.8.7"], - ["Compat", v"0.8.8"], - ["Compat", v"0.9.0"], - ["Compat", v"0.9.1"], - ["Compat", v"0.9.3"], - ["Compat", v"0.9.4"], - ["Compat", v"0.10.0"], - ["Compat", v"0.11.0"], - ["Compat", v"0.12.0"], - ["Compat", v"0.13.0"], - ["Compat", v"0.15.0"], - ["Compat", v"0.16.2"], - ["Compat", v"0.17.0"], - ["Compat", v"0.18.0"], - ["Compat", v"0.23.0"], - ["Compat", v"0.24.0"], - ["ComputationalResources", v"0.0.1"], - ["ComputationalResources", v"0.0.2", "Compat", v"0.17.0"], - ["Conda", v"0.1.5", "BinDeps"], - ["Conda", v"0.1.5", "Compat"], - ["Conda", v"0.1.5", "JSON"], - ["Conda", v"0.1.9", "BinDeps"], - ["Conda", v"0.1.9", "Compat"], - ["Conda", v"0.1.9", "JSON"], - ["Conda", v"0.2.2", "BinDeps"], - ["Conda", v"0.2.2", "Compat", v"0.7.15"], - ["Conda", v"0.2.2", "JSON"], - ["Conda", v"0.2.4", "BinDeps"], - ["Conda", v"0.2.4", "Compat", v"0.8.0"], - ["Conda", v"0.2.4", "JSON"], - ["Conda", v"0.2.5", "BinDeps"], - ["Conda", v"0.2.5", "Compat", v"0.7.20"], - ["Conda", v"0.2.5", "JSON"], - ["Conda", v"0.3.2", "BinDeps"], - ["Conda", v"0.3.2", "Compat", v"0.8.0"], - ["Conda", v"0.3.2", "JSON"], - ["Conda", v"0.5.3", "BinDeps"], - ["Conda", v"0.5.3", "Compat", v"0.8.0"], - ["Conda", v"0.5.3", "JSON"], - ["CoordinateTransformations", v"0.1.0", "FixedSizeArrays"], - ["CoordinateTransformations", v"0.1.0", "Rotations"], - ["CoordinateTransformations", v"0.2.0", "Compat", v"0.8.0", v"0.11.0"], - ["CoordinateTransformations", v"0.2.0", "FixedSizeArrays", v"0.2.2"], - ["CoordinateTransformations", v"0.2.0", "Rotations", v"0.1.0", v"0.2.0+"], - ["CoordinateTransformations", v"0.3.2", "Rotations", v"0.3.0"], - ["CoordinateTransformations", v"0.3.2", "StaticArrays"], - ["CoordinateTransformations", v"0.4.0", "Rotations", v"0.3.0"], - ["CoordinateTransformations", v"0.4.0", "StaticArrays"], - ["CoordinateTransformations", v"0.4.1", "Compat", v"0.17.0"], - ["CoordinateTransformations", v"0.4.1", "Rotations", v"0.3.0"], - ["CoordinateTransformations", v"0.4.1", "StaticArrays"], - ["CustomUnitRanges", v"0.0.4"], - ["DWARF", v"0.0.0", "ELF"], - ["DWARF", v"0.0.0", "StrPack"], - ["DWARF", v"0.1.0", "AbstractTrees"], - ["DWARF", v"0.1.0", "ObjFileBase"], - ["DWARF", v"0.1.0", "StructIO"], - ["DataArrays", v"0.4.0", "Reexport"], - ["DataArrays", v"0.4.0", "SpecialFunctions"], - ["DataArrays", v"0.4.0", "Compat", v"0.8.6"], - ["DataArrays", v"0.4.0", "StatsBase", v"0.3.0"], - ["DataFrames", v"0.0.0", "Options"], - ["DataFrames", v"0.0.0", "StatsBase", v"0.0.0", v"0.8.3"], - ["DataFrames", v"0.2.2", "GZip"], - ["DataFrames", v"0.2.2", "Options"], - ["DataFrames", v"0.2.2", "StatsBase", v"0.0.0", v"0.8.3"], - ["DataFrames", v"0.3.10", "GZip"], - ["DataFrames", v"0.3.10", "StatsBase", v"0.0.0", v"0.8.3"], - ["DataFrames", v"0.3.11", "Blocks"], - ["DataFrames", v"0.3.11", "GZip"], - ["DataFrames", v"0.3.11", "StatsBase", v"0.0.0", v"0.8.3"], - ["DataFrames", v"0.3.16", "Blocks"], - ["DataFrames", v"0.3.16", "GZip"], - ["DataFrames", v"0.3.16", "SortingAlgorithms"], - ["DataFrames", v"0.3.16", "StatsBase", v"0.0.0", v"0.8.3"], - ["DataFrames", v"0.4.2", "Blocks"], - ["DataFrames", v"0.4.2", "DataArrays"], - ["DataFrames", v"0.4.2", "GZip"], - ["DataFrames", v"0.4.2", "SortingAlgorithms"], - ["DataFrames", v"0.4.2", "Stats"], - ["DataFrames", v"0.5.0", "Blocks"], - ["DataFrames", v"0.5.0", "GZip"], - ["DataFrames", v"0.5.0", "SortingAlgorithms"], - ["DataFrames", v"0.5.0", "DataArrays", v"0.1.0-"], - ["DataFrames", v"0.5.0", "StatsBase", v"0.3.0-", v"0.8.3"], - ["DataFrames", v"0.5.3", "Blocks"], - ["DataFrames", v"0.5.3", "DataArrays"], - ["DataFrames", v"0.5.3", "GZip"], - ["DataFrames", v"0.5.3", "SortingAlgorithms"], - ["DataFrames", v"0.5.3", "StatsBase", v"0.0.0", v"0.8.3"], - ["DataFrames", v"0.5.4", "Blocks"], - ["DataFrames", v"0.5.4", "DataArrays"], - ["DataFrames", v"0.5.4", "GZip"], - ["DataFrames", v"0.5.4", "Reexport"], - ["DataFrames", v"0.5.4", "SortingAlgorithms"], - ["DataFrames", v"0.5.4", "StatsBase", v"0.3.9+", v"0.8.3"], - ["DataFrames", v"0.5.11", "DataArrays"], - ["DataFrames", v"0.5.11", "GZip"], - ["DataFrames", v"0.5.11", "Reexport"], - ["DataFrames", v"0.5.11", "SortingAlgorithms"], - ["DataFrames", v"0.5.11", "StatsBase", v"0.3.9+", v"0.8.3"], - ["DataFrames", v"0.6.1", "Compat"], - ["DataFrames", v"0.6.1", "DataArrays"], - ["DataFrames", v"0.6.1", "GZip"], - ["DataFrames", v"0.6.1", "Reexport"], - ["DataFrames", v"0.6.1", "SortingAlgorithms"], - ["DataFrames", v"0.6.1", "StatsBase", v"0.3.9+", v"0.8.3"], - ["DataFrames", v"0.6.5", "Compat"], - ["DataFrames", v"0.6.5", "DataArrays"], - ["DataFrames", v"0.6.5", "Docile"], - ["DataFrames", v"0.6.5", "GZip"], - ["DataFrames", v"0.6.5", "Reexport"], - ["DataFrames", v"0.6.5", "SortingAlgorithms"], - ["DataFrames", v"0.6.5", "StatsBase", v"0.3.9+", v"0.8.3"], - ["DataFrames", v"0.6.10", "Compat"], - ["DataFrames", v"0.6.10", "Docile"], - ["DataFrames", v"0.6.10", "GZip"], - ["DataFrames", v"0.6.10", "Reexport"], - ["DataFrames", v"0.6.10", "SortingAlgorithms"], - ["DataFrames", v"0.6.10", "DataArrays", v"0.2.15"], - ["DataFrames", v"0.6.10", "StatsBase", v"0.3.9+", v"0.8.3"], - ["DataFrames", v"0.7.0", "Docile"], - ["DataFrames", v"0.7.0", "GZip"], - ["DataFrames", v"0.7.0", "Reexport"], - ["DataFrames", v"0.7.0", "SortingAlgorithms"], - ["DataFrames", v"0.7.0", "Compat", v"0.7.12"], - ["DataFrames", v"0.7.0", "DataArrays", v"0.2.15"], - ["DataFrames", v"0.7.0", "StatsBase", v"0.8.0", v"0.8.3"], - ["DataFrames", v"0.7.2", "Docile"], - ["DataFrames", v"0.7.2", "GZip"], - ["DataFrames", v"0.7.2", "Reexport"], - ["DataFrames", v"0.7.2", "SortingAlgorithms"], - ["DataFrames", v"0.7.2", "Compat", v"0.7.17"], - ["DataFrames", v"0.7.2", "DataArrays", v"0.2.15"], - ["DataFrames", v"0.7.2", "StatsBase", v"0.8.0", v"0.8.3"], - ["DataFrames", v"0.7.3", "Docile"], - ["DataFrames", v"0.7.3", "GZip"], - ["DataFrames", v"0.7.3", "Reexport"], - ["DataFrames", v"0.7.3", "SortingAlgorithms"], - ["DataFrames", v"0.7.3", "Compat", v"0.7.19"], - ["DataFrames", v"0.7.3", "DataArrays", v"0.2.15"], - ["DataFrames", v"0.7.3", "StatsBase", v"0.8.0", v"0.8.3"], - ["DataFrames", v"0.7.4", "Docile"], - ["DataFrames", v"0.7.4", "GZip"], - ["DataFrames", v"0.7.4", "Reexport"], - ["DataFrames", v"0.7.4", "SortingAlgorithms"], - ["DataFrames", v"0.7.4", "Compat", v"0.7.19"], - ["DataFrames", v"0.7.4", "DataArrays", v"0.3.4"], - ["DataFrames", v"0.7.4", "StatsBase", v"0.8.0", v"0.8.3"], - ["DataFrames", v"0.7.6", "Docile"], - ["DataFrames", v"0.7.6", "GZip"], - ["DataFrames", v"0.7.6", "Reexport"], - ["DataFrames", v"0.7.6", "SortingAlgorithms"], - ["DataFrames", v"0.7.6", "Compat", v"0.7.19"], - ["DataFrames", v"0.7.6", "DataArrays", v"0.3.4"], - ["DataFrames", v"0.7.6", "StatsBase", v"0.8.3"], - ["DataFrames", v"0.7.8", "GZip"], - ["DataFrames", v"0.7.8", "Reexport"], - ["DataFrames", v"0.7.8", "SortingAlgorithms"], - ["DataFrames", v"0.7.8", "Compat", v"0.8.0"], - ["DataFrames", v"0.7.8", "DataArrays", v"0.3.4"], - ["DataFrames", v"0.7.8", "StatsBase", v"0.8.3"], - ["DataFrames", v"0.8.0", "GZip"], - ["DataFrames", v"0.8.0", "Reexport"], - ["DataFrames", v"0.8.0", "SortingAlgorithms"], - ["DataFrames", v"0.8.0", "Compat", v"0.8.4"], - ["DataFrames", v"0.8.0", "DataArrays", v"0.3.4"], - ["DataFrames", v"0.8.0", "StatsBase", v"0.8.3"], - ["DataFrames", v"0.8.3", "GZip"], - ["DataFrames", v"0.8.3", "Reexport"], - ["DataFrames", v"0.8.3", "SortingAlgorithms"], - ["DataFrames", v"0.8.3", "Compat", v"0.8.4"], - ["DataFrames", v"0.8.3", "DataArrays", v"0.3.4"], - ["DataFrames", v"0.8.3", "FileIO", v"0.1.2"], - ["DataFrames", v"0.8.3", "StatsBase", v"0.8.3"], - ["DataFrames", v"0.8.4", "GZip"], - ["DataFrames", v"0.8.4", "Reexport"], - ["DataFrames", v"0.8.4", "SortingAlgorithms"], - ["DataFrames", v"0.8.4", "Compat", v"0.8.4"], - ["DataFrames", v"0.8.4", "DataArrays", v"0.3.4"], - ["DataFrames", v"0.8.4", "FileIO", v"0.1.2"], - ["DataFrames", v"0.8.4", "StatsBase", v"0.11.0"], - ["DataFrames", v"0.8.5", "GZip"], - ["DataFrames", v"0.8.5", "Reexport"], - ["DataFrames", v"0.8.5", "SortingAlgorithms"], - ["DataFrames", v"0.8.5", "Compat", v"0.8.4"], - ["DataFrames", v"0.8.5", "DataArrays", v"0.3.4"], - ["DataFrames", v"0.8.5", "FileIO", v"0.1.2"], - ["DataFrames", v"0.8.5", "Juno", v"0.2.4"], - ["DataFrames", v"0.8.5", "StatsBase", v"0.11.0"], - ["DataFrames", v"0.9.1", "GZip"], - ["DataFrames", v"0.9.1", "Reexport"], - ["DataFrames", v"0.9.1", "SortingAlgorithms"], - ["DataFrames", v"0.9.1", "Compat", v"0.18.0"], - ["DataFrames", v"0.9.1", "DataArrays", v"0.3.4"], - ["DataFrames", v"0.9.1", "FileIO", v"0.1.2"], - ["DataFrames", v"0.9.1", "StatsBase", v"0.11.0"], - ["DataStructures", v"0.4.5"], - ["DataStructures", v"0.4.6", "Compat", v"0.8.5"], - ["DataStructures", v"0.5.1", "Compat", v"0.9.4"], - ["DataStructures", v"0.5.2", "Compat", v"0.9.4"], - ["DataStructures", v"0.5.3", "Compat", v"0.17.0"], - ["Dates", v"0.4.4"], - ["DelayDiffEq", v"0.0.1", "Combinatorics"], - ["DelayDiffEq", v"0.0.1", "DataStructures", v"0.4.6"], - ["DelayDiffEq", v"0.0.1", "DiffEqBase", v"0.5.0", v"0.7.0"], - ["DelayDiffEq", v"0.0.1", "RecursiveArrayTools", v"0.1.2"], - ["DelayDiffEq", v"0.0.1", "OrdinaryDiffEq", v"1.0.0", v"1.2.0"], - ["DelayDiffEq", v"0.1.0", "Combinatorics"], - ["DelayDiffEq", v"0.1.0", "DataStructures", v"0.4.6"], - ["DelayDiffEq", v"0.1.0", "DiffEqBase", v"0.8.0", v"0.15.0"], - ["DelayDiffEq", v"0.1.0", "OrdinaryDiffEq", v"1.2.0"], - ["DelayDiffEq", v"0.1.0", "RecursiveArrayTools", v"0.2.0"], - ["DelayDiffEq", v"0.2.0", "Combinatorics"], - ["DelayDiffEq", v"0.2.0", "DataStructures", v"0.4.6"], - ["DelayDiffEq", v"0.2.0", "DiffEqBase", v"0.8.0", v"0.15.0"], - ["DelayDiffEq", v"0.2.0", "OrdinaryDiffEq", v"1.6.0"], - ["DelayDiffEq", v"0.2.0", "RecursiveArrayTools", v"0.2.0"], - ["DelayDiffEq", v"0.3.0", "Combinatorics"], - ["DelayDiffEq", v"0.3.0", "DataStructures", v"0.4.6"], - ["DelayDiffEq", v"0.3.0", "DiffEqBase", v"0.15.0"], - ["DelayDiffEq", v"0.3.0", "OrdinaryDiffEq", v"1.6.0"], - ["DelayDiffEq", v"0.3.0", "RecursiveArrayTools", v"0.2.0"], - ["DiffBase", v"0.0.2", "Compat", v"0.7.15"], - ["DiffBase", v"0.1.0", "Compat", v"0.7.15"], - ["DiffEqBase", v"0.0.1", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.0.4", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.0.4", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.1.0", "Parameters"], - ["DiffEqBase", v"0.1.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.1.0", "RecursiveArrayTools"], - ["DiffEqBase", v"0.1.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.1.1", "Parameters"], - ["DiffEqBase", v"0.1.1", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.1.1", "RecursiveArrayTools"], - ["DiffEqBase", v"0.1.1", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.1.2", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.1.2", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.1.2", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.1.2", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqBase", v"0.1.3", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.1.3", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.1.3", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.1.3", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqBase", v"0.2.0", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.2.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.2.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.2.0", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqBase", v"0.3.2", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.3.2", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.3.2", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.3.2", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqBase", v"0.3.2", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.4.0", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.4.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.4.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.4.0", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqBase", v"0.4.0", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.4.1", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.4.1", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.4.1", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.4.1", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqBase", v"0.4.1", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.5.0", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.5.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.5.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.5.0", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqBase", v"0.5.0", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.6.0", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.6.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.6.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.6.0", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqBase", v"0.6.0", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.7.0", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.7.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.7.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.7.0", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqBase", v"0.7.0", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.10.0", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.10.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.10.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.10.0", "RecursiveArrayTools", v"0.2.0"], - ["DiffEqBase", v"0.10.0", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.11.0", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.11.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.11.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.11.0", "RecursiveArrayTools", v"0.2.0"], - ["DiffEqBase", v"0.11.0", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.12.1", "Compat", v"0.19.0"], - ["DiffEqBase", v"0.12.1", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.12.1", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.12.1", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.12.1", "RecursiveArrayTools", v"0.2.0"], - ["DiffEqBase", v"0.12.1", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.13.0", "Compat", v"0.19.0"], - ["DiffEqBase", v"0.13.0", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.13.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.13.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.13.0", "RecursiveArrayTools", v"0.2.0"], - ["DiffEqBase", v"0.13.0", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.14.0", "Compat", v"0.19.0"], - ["DiffEqBase", v"0.14.0", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.14.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.14.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.14.0", "RecursiveArrayTools", v"0.2.0"], - ["DiffEqBase", v"0.14.0", "SimpleTraits", v"0.1.1"], - ["DiffEqBase", v"0.15.0", "Compat", v"0.19.0"], - ["DiffEqBase", v"0.15.0", "Parameters", v"0.5.0"], - ["DiffEqBase", v"0.15.0", "Ranges", v"0.0.1"], - ["DiffEqBase", v"0.15.0", "RecipesBase", v"0.1.0"], - ["DiffEqBase", v"0.15.0", "RecursiveArrayTools", v"0.2.0"], - ["DiffEqBase", v"0.15.0", "SimpleTraits", v"0.1.1"], - ["DiffEqBiological", v"0.0.1", "DiffEqBase"], - ["DiffEqBiological", v"0.0.1", "DiffEqJump"], - ["DiffEqCallbacks", v"0.0.2", "DiffEqBase", v"0.6.0"], - ["DiffEqDevTools", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.5.0"], - ["DiffEqDevTools", v"0.0.1", "FiniteElementDiffEq"], - ["DiffEqDevTools", v"0.0.1", "OrdinaryDiffEq"], - ["DiffEqDevTools", v"0.0.1", "StochasticDiffEq"], - ["DiffEqDevTools", v"0.0.1", "RecipesBase", v"0.1.0"], - ["DiffEqDevTools", v"0.1.0", "DiffEqBase", v"0.0.0", v"0.5.0"], - ["DiffEqDevTools", v"0.1.0", "FiniteElementDiffEq"], - ["DiffEqDevTools", v"0.1.0", "OrdinaryDiffEq"], - ["DiffEqDevTools", v"0.1.0", "RecursiveArrayTools"], - ["DiffEqDevTools", v"0.1.0", "StochasticDiffEq"], - ["DiffEqDevTools", v"0.1.0", "RecipesBase", v"0.1.0"], - ["DiffEqDevTools", v"0.1.1", "DiffEqBase", v"0.1.3", v"0.5.0"], - ["DiffEqDevTools", v"0.1.1", "FiniteElementDiffEq", v"0.0.5"], - ["DiffEqDevTools", v"0.1.1", "OrdinaryDiffEq", v"0.1.1"], - ["DiffEqDevTools", v"0.1.1", "RecipesBase", v"0.1.0"], - ["DiffEqDevTools", v"0.1.1", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqDevTools", v"0.1.1", "StochasticDiffEq", v"0.0.5"], - ["DiffEqDevTools", v"0.2.0", "DiffEqBase", v"0.2.0", v"0.5.0"], - ["DiffEqDevTools", v"0.2.0", "FiniteElementDiffEq", v"0.0.5"], - ["DiffEqDevTools", v"0.2.0", "RecipesBase", v"0.1.0"], - ["DiffEqDevTools", v"0.2.0", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqDevTools", v"0.3.0", "DiffEqBase", v"0.3.0", v"0.5.0"], - ["DiffEqDevTools", v"0.3.0", "RecipesBase", v"0.1.0"], - ["DiffEqDevTools", v"0.3.0", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqDevTools", v"0.4.0", "DiffEqBase", v"0.4.0", v"0.5.0"], - ["DiffEqDevTools", v"0.4.0", "RecipesBase", v"0.1.0"], - ["DiffEqDevTools", v"0.4.0", "RecursiveArrayTools", v"0.1.2"], - ["DiffEqDevTools", v"0.5.0", "DiffEqBase", v"0.4.0", v"0.5.0"], - ["DiffEqDevTools", v"0.5.0", "DiffEqPDEBase"], - ["DiffEqDevTools", v"0.5.0", "RecipesBase", v"0.1.0"], - ["DiffEqDevTools", v"0.5.0", "RecursiveArrayTools", v"0.1.2"], - ["DiffEqDevTools", v"0.6.0", "DiffEqBase", v"0.5.0", v"0.15.0"], - ["DiffEqDevTools", v"0.6.0", "DiffEqPDEBase"], - ["DiffEqDevTools", v"0.6.0", "RecipesBase", v"0.1.0"], - ["DiffEqDevTools", v"0.6.0", "RecursiveArrayTools", v"0.1.2"], - ["DiffEqDevTools", v"0.7.0", "DiffEqBase", v"0.15.0"], - ["DiffEqDevTools", v"0.7.0", "DiffEqPDEBase"], - ["DiffEqDevTools", v"0.7.0", "RecipesBase", v"0.1.0"], - ["DiffEqDevTools", v"0.7.0", "RecursiveArrayTools", v"0.1.2"], - ["DiffEqFinancial", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["DiffEqFinancial", v"0.0.1", "StochasticDiffEq"], - ["DiffEqFinancial", v"0.1.0", "DiffEqBase", v"0.15.0"], - ["DiffEqFinancial", v"0.1.0", "StochasticDiffEq"], - ["DiffEqJump", v"0.0.1", "DiffEqBase"], - ["DiffEqJump", v"0.2.0", "DiffEqBase"], - ["DiffEqJump", v"0.2.0", "RecursiveArrayTools"], - ["DiffEqJump", v"0.3.0", "DiffEqBase", v"0.13.0"], - ["DiffEqJump", v"0.3.0", "RecursiveArrayTools"], - ["DiffEqMonteCarlo", v"0.1.0", "DiffEqBase", v"0.6.0", v"0.14.0"], - ["DiffEqMonteCarlo", v"0.1.0", "RecipesBase", v"0.1.0"], - ["DiffEqMonteCarlo", v"0.2.0", "DiffEqBase", v"0.14.0"], - ["DiffEqPDEBase", v"0.0.1", "ChunkedArrays"], - ["DiffEqPDEBase", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["DiffEqPDEBase", v"0.0.1", "RecipesBase"], - ["DiffEqPDEBase", v"0.0.1", "VectorizedRoutines"], - ["DiffEqPDEBase", v"0.0.3", "ChunkedArrays"], - ["DiffEqPDEBase", v"0.0.3", "DiffEqBase", v"0.4.1", v"0.15.0"], - ["DiffEqPDEBase", v"0.0.3", "RecipesBase"], - ["DiffEqPDEBase", v"0.0.3", "VectorizedRoutines"], - ["DiffEqPDEBase", v"0.1.0", "ChunkedArrays"], - ["DiffEqPDEBase", v"0.1.0", "Compat", v"0.17.0"], - ["DiffEqPDEBase", v"0.1.0", "DiffEqBase", v"0.4.1", v"0.15.0"], - ["DiffEqPDEBase", v"0.1.0", "RecipesBase"], - ["DiffEqPDEBase", v"0.1.0", "VectorizedRoutines"], - ["DiffEqPDEBase", v"0.2.0", "ChunkedArrays"], - ["DiffEqPDEBase", v"0.2.0", "Compat", v"0.17.0"], - ["DiffEqPDEBase", v"0.2.0", "DiffEqBase", v"0.15.0"], - ["DiffEqPDEBase", v"0.2.0", "RecipesBase"], - ["DiffEqPDEBase", v"0.2.0", "VectorizedRoutines"], - ["DiffEqParamEstim", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.14.0"], - ["DiffEqParamEstim", v"0.0.1", "LossFunctions"], - ["DiffEqParamEstim", v"0.0.1", "LsqFit"], - ["DiffEqParamEstim", v"0.0.1", "OrdinaryDiffEq"], - ["DiffEqParamEstim", v"0.0.1", "RecursiveArrayTools"], - ["DiffEqParamEstim", v"0.0.2", "DiffEqBase", v"0.1.2", v"0.14.0"], - ["DiffEqParamEstim", v"0.0.2", "LossFunctions", v"0.0.2"], - ["DiffEqParamEstim", v"0.0.2", "LsqFit", v"0.0.2"], - ["DiffEqParamEstim", v"0.0.2", "OrdinaryDiffEq", v"0.1.1"], - ["DiffEqParamEstim", v"0.0.2", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqParamEstim", v"0.0.4", "DiffEqBase", v"0.1.2", v"0.14.0"], - ["DiffEqParamEstim", v"0.0.4", "LossFunctions", v"0.0.2"], - ["DiffEqParamEstim", v"0.0.4", "LsqFit", v"0.0.2"], - ["DiffEqParamEstim", v"0.0.4", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqParamEstim", v"0.1.0", "Calculus"], - ["DiffEqParamEstim", v"0.1.0", "DiffEqBase", v"0.1.2", v"0.14.0"], - ["DiffEqParamEstim", v"0.1.0", "ForwardDiff"], - ["DiffEqParamEstim", v"0.1.0", "LossFunctions", v"0.0.2"], - ["DiffEqParamEstim", v"0.1.0", "LsqFit", v"0.0.2"], - ["DiffEqParamEstim", v"0.1.0", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqParamEstim", v"0.2.0", "Calculus"], - ["DiffEqParamEstim", v"0.2.0", "Optim"], - ["DiffEqParamEstim", v"0.2.0", "Compat", v"0.17.0"], - ["DiffEqParamEstim", v"0.2.0", "DiffEqBase", v"0.14.0"], - ["DiffEqParamEstim", v"0.2.0", "ForwardDiff"], - ["DiffEqParamEstim", v"0.2.0", "LossFunctions", v"0.0.2"], - ["DiffEqParamEstim", v"0.2.0", "LsqFit", v"0.0.2"], - ["DiffEqParamEstim", v"0.2.0", "RecursiveArrayTools", v"0.0.2"], - ["DiffEqProblemLibrary", v"0.0.1", "AlgebraicDiffEq"], - ["DiffEqProblemLibrary", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["DiffEqProblemLibrary", v"0.0.1", "FiniteElementDiffEq"], - ["DiffEqProblemLibrary", v"0.0.1", "JLD", v"0.6.5"], - ["DiffEqProblemLibrary", v"0.0.1", "OrdinaryDiffEq"], - ["DiffEqProblemLibrary", v"0.0.1", "ParameterizedFunctions", v"0.2.0"], - ["DiffEqProblemLibrary", v"0.0.1", "StochasticDiffEq"], - ["DiffEqProblemLibrary", v"0.1.0", "AlgebraicDiffEq"], - ["DiffEqProblemLibrary", v"0.1.0", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["DiffEqProblemLibrary", v"0.1.0", "FiniteElementDiffEq"], - ["DiffEqProblemLibrary", v"0.1.0", "JLD", v"0.6.5"], - ["DiffEqProblemLibrary", v"0.1.0", "ParameterizedFunctions", v"0.2.0"], - ["DiffEqProblemLibrary", v"0.1.0", "StochasticDiffEq"], - ["DiffEqProblemLibrary", v"0.2.0", "AlgebraicDiffEq", v"0.0.2"], - ["DiffEqProblemLibrary", v"0.2.0", "DiffEqBase", v"0.2.0", v"0.15.0"], - ["DiffEqProblemLibrary", v"0.2.0", "FiniteElementDiffEq", v"0.0.5"], - ["DiffEqProblemLibrary", v"0.2.0", "JLD", v"0.6.5"], - ["DiffEqProblemLibrary", v"0.2.0", "ParameterizedFunctions", v"0.2.0"], - ["DiffEqProblemLibrary", v"0.2.0", "StochasticDiffEq", v"0.1.0"], - ["DiffEqProblemLibrary", v"0.3.2", "AlgebraicDiffEq", v"0.0.2"], - ["DiffEqProblemLibrary", v"0.3.2", "DiffEqBase", v"0.2.0", v"0.15.0"], - ["DiffEqProblemLibrary", v"0.3.2", "FiniteElementDiffEq", v"0.0.5"], - ["DiffEqProblemLibrary", v"0.3.2", "JLD", v"0.6.5"], - ["DiffEqProblemLibrary", v"0.3.2", "ParameterizedFunctions", v"0.2.0"], - ["DiffEqProblemLibrary", v"0.4.0", "DiffEqBase", v"0.2.0", v"0.15.0"], - ["DiffEqProblemLibrary", v"0.4.0", "DiffEqPDEBase"], - ["DiffEqProblemLibrary", v"0.4.0", "FiniteElementDiffEq", v"0.0.5"], - ["DiffEqProblemLibrary", v"0.4.0", "JLD", v"0.6.5"], - ["DiffEqProblemLibrary", v"0.4.0", "ParameterizedFunctions", v"0.5.0"], - ["DiffEqProblemLibrary", v"0.5.0", "DiffEqBase", v"0.15.0"], - ["DiffEqProblemLibrary", v"0.5.0", "DiffEqPDEBase"], - ["DiffEqProblemLibrary", v"0.5.0", "JLD", v"0.6.5"], - ["DiffEqProblemLibrary", v"0.5.0", "ParameterizedFunctions", v"0.5.0"], - ["DiffEqSensitivity", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["DiffEqSensitivity", v"0.0.2", "DiffEqBase", v"0.1.2", v"0.15.0"], - ["DiffEqSensitivity", v"0.0.4", "DiffEqBase", v"0.2.0", v"0.15.0"], - ["DiffEqSensitivity", v"0.1.0", "DiffEqBase", v"0.15.0"], - ["DifferentialEquations", v"0.4.0", "ChunkedArrays", v"0.0.2"], - ["DifferentialEquations", v"0.4.0", "Compat", v"0.8.8"], - ["DifferentialEquations", v"0.4.0", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["DifferentialEquations", v"0.4.0", "ForwardDiff", v"0.2.4"], - ["DifferentialEquations", v"0.4.0", "GenericSVD", v"0.0.2"], - ["DifferentialEquations", v"0.4.0", "InplaceOps", v"0.0.5"], - ["DifferentialEquations", v"0.4.0", "IterativeSolvers", v"0.2.2"], - ["DifferentialEquations", v"0.4.0", "Parameters", v"0.3.1"], - ["DifferentialEquations", v"0.4.0", "OrdinaryDiffEq", v"0.0.0", v"1.2.0"], - ["DifferentialEquations", v"0.4.0", "Plots", v"0.9.2"], - ["DifferentialEquations", v"0.4.0", "SIUnits", v"0.0.6"], - ["DifferentialEquations", v"0.4.0", "StochasticDiffEq", v"0.0.0", v"1.0.0"], - ["DifferentialEquations", v"0.4.2", "ChunkedArrays", v"0.0.2"], - ["DifferentialEquations", v"0.4.2", "Compat", v"0.8.8"], - ["DifferentialEquations", v"0.4.2", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["DifferentialEquations", v"0.4.2", "ForwardDiff", v"0.2.4"], - ["DifferentialEquations", v"0.4.2", "GenericSVD", v"0.0.2"], - ["DifferentialEquations", v"0.4.2", "InplaceOps", v"0.0.5"], - ["DifferentialEquations", v"0.4.2", "IterativeSolvers", v"0.2.2"], - ["DifferentialEquations", v"0.4.2", "Parameters", v"0.5.0"], - ["DifferentialEquations", v"0.4.2", "OrdinaryDiffEq", v"0.0.0", v"1.2.0"], - ["DifferentialEquations", v"0.4.2", "Plots", v"0.9.2"], - ["DifferentialEquations", v"0.4.2", "SIUnits", v"0.0.6"], - ["DifferentialEquations", v"0.4.2", "StochasticDiffEq", v"0.0.0", v"1.0.0"], - ["DifferentialEquations", v"0.5.0", "ChunkedArrays", v"0.0.2"], - ["DifferentialEquations", v"0.5.0", "Compat", v"0.8.8"], - ["DifferentialEquations", v"0.5.0", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["DifferentialEquations", v"0.5.0", "ForwardDiff", v"0.2.4"], - ["DifferentialEquations", v"0.5.0", "GenericSVD", v"0.0.2"], - ["DifferentialEquations", v"0.5.0", "InplaceOps", v"0.0.5"], - ["DifferentialEquations", v"0.5.0", "IterativeSolvers", v"0.2.2"], - ["DifferentialEquations", v"0.5.0", "NLsolve", v"0.7.3"], - ["DifferentialEquations", v"0.5.0", "Parameters", v"0.5.0"], - ["DifferentialEquations", v"0.5.0", "OrdinaryDiffEq", v"0.0.0", v"1.2.0"], - ["DifferentialEquations", v"0.5.0", "Plots", v"0.9.2"], - ["DifferentialEquations", v"0.5.0", "Ranges", v"0.0.1"], - ["DifferentialEquations", v"0.5.0", "StochasticDiffEq", v"0.0.0", v"1.0.0"], - ["DifferentialEquations", v"0.5.0", "Sundials", v"0.3.0"], - ["DifferentialEquations", v"1.0.0", "AlgebraicDiffEq"], - ["DifferentialEquations", v"1.0.0", "DiffEqDevTools"], - ["DifferentialEquations", v"1.0.0", "DiffEqParamEstim"], - ["DifferentialEquations", v"1.0.0", "DiffEqSensitivity"], - ["DifferentialEquations", v"1.0.0", "FiniteElementDiffEq"], - ["DifferentialEquations", v"1.0.0", "Reexport"], - ["DifferentialEquations", v"1.0.0", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["DifferentialEquations", v"1.0.0", "OrdinaryDiffEq", v"0.0.0", v"1.2.0"], - ["DifferentialEquations", v"1.0.0", "StochasticDiffEq", v"0.0.0", v"1.0.0"], - ["DifferentialEquations", v"1.0.0", "StokesDiffEq"], - ["DifferentialEquations", v"1.0.0", "Sundials"], - ["DifferentialEquations", v"1.1.0", "AlgebraicDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.1.0", "DiffEqBase", v"0.1.3", v"0.15.0"], - ["DifferentialEquations", v"1.1.0", "DiffEqDevTools", v"0.1.1"], - ["DifferentialEquations", v"1.1.0", "DiffEqParamEstim", v"0.0.2"], - ["DifferentialEquations", v"1.1.0", "DiffEqSensitivity", v"0.0.2"], - ["DifferentialEquations", v"1.1.0", "FiniteElementDiffEq", v"0.0.5"], - ["DifferentialEquations", v"1.1.0", "OrdinaryDiffEq", v"0.1.1", v"1.2.0"], - ["DifferentialEquations", v"1.1.0", "ParameterizedFunctions", v"0.3.2"], - ["DifferentialEquations", v"1.1.0", "Reexport", v"0.0.3"], - ["DifferentialEquations", v"1.1.0", "StochasticDiffEq", v"0.0.5", v"1.0.0"], - ["DifferentialEquations", v"1.1.0", "StokesDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.1.0", "Sundials", v"0.3.0"], - ["DifferentialEquations", v"1.4.0", "AlgebraicDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.4.0", "DiffEqBase", v"0.2.0", v"0.15.0"], - ["DifferentialEquations", v"1.4.0", "DiffEqDevTools", v"0.2.0"], - ["DifferentialEquations", v"1.4.0", "DiffEqParamEstim", v"0.0.2"], - ["DifferentialEquations", v"1.4.0", "DiffEqProblemLibrary", v"0.2.0"], - ["DifferentialEquations", v"1.4.0", "DiffEqSensitivity", v"0.0.2"], - ["DifferentialEquations", v"1.4.0", "FiniteElementDiffEq", v"0.0.5"], - ["DifferentialEquations", v"1.4.0", "OrdinaryDiffEq", v"0.2.0", v"1.2.0"], - ["DifferentialEquations", v"1.4.0", "ParameterizedFunctions", v"0.3.2"], - ["DifferentialEquations", v"1.4.0", "Reexport", v"0.0.3"], - ["DifferentialEquations", v"1.4.0", "StochasticDiffEq", v"0.1.0", v"1.0.0"], - ["DifferentialEquations", v"1.4.0", "StokesDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.4.0", "Sundials", v"0.4.1"], - ["DifferentialEquations", v"1.5.0", "DiffEqPDEBase"], - ["DifferentialEquations", v"1.5.0", "AlgebraicDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.5.0", "DiffEqBase", v"0.2.0", v"0.15.0"], - ["DifferentialEquations", v"1.5.0", "DiffEqDevTools", v"0.2.0"], - ["DifferentialEquations", v"1.5.0", "DiffEqParamEstim", v"0.0.2"], - ["DifferentialEquations", v"1.5.0", "DiffEqSensitivity", v"0.0.2"], - ["DifferentialEquations", v"1.5.0", "FiniteElementDiffEq", v"0.0.5"], - ["DifferentialEquations", v"1.5.0", "OrdinaryDiffEq", v"0.2.0", v"1.2.0"], - ["DifferentialEquations", v"1.5.0", "ParameterizedFunctions", v"0.3.2"], - ["DifferentialEquations", v"1.5.0", "Reexport", v"0.0.3"], - ["DifferentialEquations", v"1.5.0", "StochasticDiffEq", v"0.1.0", v"1.0.0"], - ["DifferentialEquations", v"1.5.0", "StokesDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.5.0", "Sundials", v"0.4.1"], - ["DifferentialEquations", v"1.6.0", "AlgebraicDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.6.0", "DelayDiffEq"], - ["DifferentialEquations", v"1.6.0", "DiffEqBase", v"0.2.0", v"0.15.0"], - ["DifferentialEquations", v"1.6.0", "DiffEqCallbacks"], - ["DifferentialEquations", v"1.6.0", "DiffEqMonteCarlo"], - ["DifferentialEquations", v"1.6.0", "DiffEqPDEBase"], - ["DifferentialEquations", v"1.6.0", "DiffEqDevTools", v"0.2.0"], - ["DifferentialEquations", v"1.6.0", "DiffEqParamEstim", v"0.0.2"], - ["DifferentialEquations", v"1.6.0", "DiffEqSensitivity", v"0.0.2"], - ["DifferentialEquations", v"1.6.0", "FiniteElementDiffEq", v"0.0.5"], - ["DifferentialEquations", v"1.6.0", "Reexport", v"0.0.3"], - ["DifferentialEquations", v"1.6.0", "OrdinaryDiffEq", v"0.2.0", v"1.2.0"], - ["DifferentialEquations", v"1.6.0", "ParameterizedFunctions", v"0.3.2"], - ["DifferentialEquations", v"1.6.0", "StochasticDiffEq", v"0.1.0", v"1.0.0"], - ["DifferentialEquations", v"1.6.0", "StokesDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.6.0", "Sundials", v"0.4.1"], - ["DifferentialEquations", v"1.7.0", "DiffEqCallbacks"], - ["DifferentialEquations", v"1.7.0", "DiffEqMonteCarlo"], - ["DifferentialEquations", v"1.7.0", "DiffEqPDEBase"], - ["DifferentialEquations", v"1.7.0", "AlgebraicDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.7.0", "DelayDiffEq", v"0.1.0"], - ["DifferentialEquations", v"1.7.0", "DiffEqDevTools", v"0.2.0"], - ["DifferentialEquations", v"1.7.0", "DiffEqParamEstim", v"0.0.2"], - ["DifferentialEquations", v"1.7.0", "DiffEqSensitivity", v"0.0.2"], - ["DifferentialEquations", v"1.7.0", "FiniteElementDiffEq", v"0.0.5"], - ["DifferentialEquations", v"1.7.0", "OrdinaryDiffEq", v"1.2.0"], - ["DifferentialEquations", v"1.7.0", "ParameterizedFunctions", v"0.3.2"], - ["DifferentialEquations", v"1.7.0", "Reexport", v"0.0.3"], - ["DifferentialEquations", v"1.7.0", "DiffEqBase", v"0.8.0", v"0.15.0"], - ["DifferentialEquations", v"1.7.0", "StochasticDiffEq", v"1.0.0"], - ["DifferentialEquations", v"1.7.0", "StokesDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.7.0", "Sundials", v"0.4.1"], - ["DifferentialEquations", v"1.9.0", "DiffEqBiological"], - ["DifferentialEquations", v"1.9.0", "DiffEqCallbacks"], - ["DifferentialEquations", v"1.9.0", "AlgebraicDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.9.0", "DelayDiffEq", v"0.1.0"], - ["DifferentialEquations", v"1.9.0", "DiffEqBase", v"0.8.0", v"0.15.0"], - ["DifferentialEquations", v"1.9.0", "DiffEqFinancial"], - ["DifferentialEquations", v"1.9.0", "DiffEqJump"], - ["DifferentialEquations", v"1.9.0", "DiffEqMonteCarlo"], - ["DifferentialEquations", v"1.9.0", "DiffEqPDEBase"], - ["DifferentialEquations", v"1.9.0", "DiffEqDevTools", v"0.2.0"], - ["DifferentialEquations", v"1.9.0", "DiffEqParamEstim", v"0.0.2"], - ["DifferentialEquations", v"1.9.0", "DiffEqSensitivity", v"0.0.2"], - ["DifferentialEquations", v"1.9.0", "FiniteElementDiffEq", v"0.0.5"], - ["DifferentialEquations", v"1.9.0", "MultiScaleArrays"], - ["DifferentialEquations", v"1.9.0", "OrdinaryDiffEq", v"1.2.0"], - ["DifferentialEquations", v"1.9.0", "PyDSTool"], - ["DifferentialEquations", v"1.9.0", "ParameterizedFunctions", v"0.3.2"], - ["DifferentialEquations", v"1.9.0", "Reexport", v"0.0.3"], - ["DifferentialEquations", v"1.9.0", "StochasticDiffEq", v"1.0.0"], - ["DifferentialEquations", v"1.9.0", "StokesDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.9.0", "Sundials", v"0.4.1"], - ["DifferentialEquations", v"1.9.1", "DiffEqBiological"], - ["DifferentialEquations", v"1.9.1", "DiffEqCallbacks"], - ["DifferentialEquations", v"1.9.1", "AlgebraicDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.9.1", "DelayDiffEq", v"0.1.0"], - ["DifferentialEquations", v"1.9.1", "DiffEqBase", v"0.8.0", v"0.15.0"], - ["DifferentialEquations", v"1.9.1", "DiffEqFinancial"], - ["DifferentialEquations", v"1.9.1", "DiffEqJump"], - ["DifferentialEquations", v"1.9.1", "DiffEqMonteCarlo"], - ["DifferentialEquations", v"1.9.1", "DiffEqPDEBase"], - ["DifferentialEquations", v"1.9.1", "DiffEqDevTools", v"0.2.0"], - ["DifferentialEquations", v"1.9.1", "DiffEqParamEstim", v"0.0.2"], - ["DifferentialEquations", v"1.9.1", "DiffEqSensitivity", v"0.0.2"], - ["DifferentialEquations", v"1.9.1", "FiniteElementDiffEq", v"0.0.5"], - ["DifferentialEquations", v"1.9.1", "MultiScaleArrays"], - ["DifferentialEquations", v"1.9.1", "OrdinaryDiffEq", v"1.2.0"], - ["DifferentialEquations", v"1.9.1", "ParameterizedFunctions", v"0.3.2"], - ["DifferentialEquations", v"1.9.1", "Reexport", v"0.0.3"], - ["DifferentialEquations", v"1.9.1", "StochasticDiffEq", v"1.0.0"], - ["DifferentialEquations", v"1.9.1", "StokesDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.9.1", "Sundials", v"0.4.1"], - ["DifferentialEquations", v"1.10.1", "DiffEqBase", v"0.15.0"], - ["DifferentialEquations", v"1.10.1", "DiffEqBiological"], - ["DifferentialEquations", v"1.10.1", "DiffEqCallbacks"], - ["DifferentialEquations", v"1.10.1", "AlgebraicDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.10.1", "DiffEqFinancial"], - ["DifferentialEquations", v"1.10.1", "DiffEqJump"], - ["DifferentialEquations", v"1.10.1", "DiffEqMonteCarlo"], - ["DifferentialEquations", v"1.10.1", "DiffEqPDEBase"], - ["DifferentialEquations", v"1.10.1", "MultiScaleArrays"], - ["DifferentialEquations", v"1.10.1", "DelayDiffEq", v"0.1.0"], - ["DifferentialEquations", v"1.10.1", "DiffEqDevTools", v"0.2.0"], - ["DifferentialEquations", v"1.10.1", "DiffEqParamEstim", v"0.0.2"], - ["DifferentialEquations", v"1.10.1", "DiffEqSensitivity", v"0.0.2"], - ["DifferentialEquations", v"1.10.1", "FiniteElementDiffEq", v"0.0.5"], - ["DifferentialEquations", v"1.10.1", "OrdinaryDiffEq", v"1.2.0"], - ["DifferentialEquations", v"1.10.1", "ParameterizedFunctions", v"0.3.2"], - ["DifferentialEquations", v"1.10.1", "Reexport", v"0.0.3"], - ["DifferentialEquations", v"1.10.1", "StochasticDiffEq", v"1.0.0"], - ["DifferentialEquations", v"1.10.1", "StokesDiffEq", v"0.0.2"], - ["DifferentialEquations", v"1.10.1", "Sundials", v"0.4.1"], - ["Distances", v"0.1.1", "ArrayViews", v"0.4.0-"], - ["Distances", v"0.2.0", "ArrayViews", v"0.4.8-"], - ["Distances", v"0.2.2", "Compat"], - ["Distances", v"0.2.2", "ArrayViews", v"0.4.8-"], - ["Distances", v"0.3.2", "Compat", v"0.8.4"], - ["Distances", v"0.4.0"], - ["Distances", v"0.4.1", "Compat", v"0.18.0"], - ["Distributions", v"0.6.4", "ArrayViews", v"0.4.8"], - ["Distributions", v"0.6.4", "Compat", v"0.2.4"], - ["Distributions", v"0.6.4", "PDMats", v"0.3.1", v"0.4.0"], - ["Distributions", v"0.6.4", "StatsBase", v"0.6.10"], - ["Distributions", v"0.6.4", "StatsFuns", v"0.0.0", v"0.3.0"], - ["Distributions", v"0.6.5", "ArrayViews", v"0.4.9"], - ["Distributions", v"0.6.5", "Compat", v"0.3.1"], - ["Distributions", v"0.6.5", "PDMats", v"0.3.1", v"0.4.0"], - ["Distributions", v"0.6.5", "StatsBase", v"0.6.10"], - ["Distributions", v"0.6.5", "StatsFuns", v"0.0.0", v"0.3.0"], - ["Distributions", v"0.6.7", "ArrayViews", v"0.4.10"], - ["Distributions", v"0.6.7", "Compat", v"0.3.2"], - ["Distributions", v"0.6.7", "PDMats", v"0.3.1", v"0.4.0"], - ["Distributions", v"0.6.7", "StatsBase", v"0.6.13"], - ["Distributions", v"0.6.7", "StatsFuns", v"0.0.0", v"0.3.0"], - ["Distributions", v"0.7.6", "ArrayViews", v"0.4.12"], - ["Distributions", v"0.7.6", "Compat", v"0.4.0"], - ["Distributions", v"0.7.6", "PDMats", v"0.3.2", v"0.4.0"], - ["Distributions", v"0.7.6", "StatsBase", v"0.6.14"], - ["Distributions", v"0.7.6", "StatsFuns", v"0.0.0", v"0.3.0"], - ["Distributions", v"0.8.9", "ArrayViews", v"0.4.12"], - ["Distributions", v"0.8.9", "Compat", v"0.4.0"], - ["Distributions", v"0.8.9", "PDMats", v"0.3.2", v"0.4.0"], - ["Distributions", v"0.8.9", "StatsBase", v"0.7.0"], - ["Distributions", v"0.8.9", "StatsFuns", v"0.1.1", v"0.3.0"], - ["Distributions", v"0.8.10", "ArrayViews", v"0.4.12"], - ["Distributions", v"0.8.10", "Compat", v"0.4.0"], - ["Distributions", v"0.8.10", "PDMats", v"0.4.0", v"0.5.0"], - ["Distributions", v"0.8.10", "StatsBase", v"0.7.0"], - ["Distributions", v"0.8.10", "StatsFuns", v"0.1.1", v"0.3.0"], - ["Distributions", v"0.9.0", "Compat", v"0.2.17"], - ["Distributions", v"0.9.0", "PDMats", v"0.4.1", v"0.5.0"], - ["Distributions", v"0.9.0", "StatsBase", v"0.7.0"], - ["Distributions", v"0.9.0", "StatsFuns", v"0.1.1", v"0.3.0"], - ["Distributions", v"0.10.2", "Calculus"], - ["Distributions", v"0.10.2", "Compat", v"0.8.4"], - ["Distributions", v"0.10.2", "PDMats", v"0.4.2", v"0.5.0"], - ["Distributions", v"0.10.2", "StatsBase", v"0.8.3"], - ["Distributions", v"0.10.2", "StatsFuns", v"0.3.0"], - ["Distributions", v"0.11.1", "Calculus"], - ["Distributions", v"0.11.1", "Compat", v"0.9.2"], - ["Distributions", v"0.11.1", "PDMats", v"0.5.0"], - ["Distributions", v"0.11.1", "StatsBase", v"0.8.3"], - ["Distributions", v"0.11.1", "StatsFuns", v"0.3.1"], - ["Distributions", v"0.12.0", "Calculus"], - ["Distributions", v"0.12.0", "Compat", v"0.14.0"], - ["Distributions", v"0.12.0", "PDMats", v"0.5.4"], - ["Distributions", v"0.12.0", "QuadGK", v"0.1.1"], - ["Distributions", v"0.12.0", "StatsBase", v"0.8.3"], - ["Distributions", v"0.12.0", "StatsFuns", v"0.3.1"], - ["Distributions", v"0.12.4", "Calculus"], - ["Distributions", v"0.12.4", "Compat", v"0.18.0"], - ["Distributions", v"0.12.4", "PDMats", v"0.5.4"], - ["Distributions", v"0.12.4", "QuadGK", v"0.1.1"], - ["Distributions", v"0.12.4", "SpecialFunctions", v"0.1.0"], - ["Distributions", v"0.12.4", "StatsBase", v"0.8.3"], - ["Distributions", v"0.12.4", "StatsFuns", v"0.3.1"], - ["Distributions", v"0.12.5", "Calculus"], - ["Distributions", v"0.12.5", "Compat", v"0.18.0"], - ["Distributions", v"0.12.5", "PDMats", v"0.6.0"], - ["Distributions", v"0.12.5", "QuadGK", v"0.1.1"], - ["Distributions", v"0.12.5", "SpecialFunctions", v"0.1.0"], - ["Distributions", v"0.12.5", "StatsBase", v"0.8.3"], - ["Distributions", v"0.12.5", "StatsFuns", v"0.3.1"], - ["Docile", v"0.1.0", "AnsiColor"], - ["Docile", v"0.1.0", "Markdown"], - ["Docile", v"0.3.1"], - ["Docile", v"0.3.2", "Compat"], - ["Docile", v"0.4.6", "Compat"], - ["Docile", v"0.4.13", "Compat", v"0.3.3"], - ["Docile", v"0.5.18", "Compat", v"0.3.5"], - ["Docile", v"0.5.23", "Compat", v"0.7.1"], - ["DualNumbers", v"0.1.0", "Calculus"], - ["DualNumbers", v"0.1.3", "Calculus"], - ["DualNumbers", v"0.1.3", "NaNMath"], - ["DualNumbers", v"0.1.5", "Calculus"], - ["DualNumbers", v"0.1.5", "Compat"], - ["DualNumbers", v"0.1.5", "NaNMath"], - ["DualNumbers", v"0.2.2", "Calculus"], - ["DualNumbers", v"0.2.2", "NaNMath"], - ["DualNumbers", v"0.3.0", "Calculus"], - ["DualNumbers", v"0.3.0", "NaNMath"], - ["DualNumbers", v"0.3.0", "Compat", v"0.9.1"], - ["ELF", v"0.0.0", "StrPack"], - ["ELF", v"0.1.0", "DWARF"], - ["ELF", v"0.1.0", "FileIO"], - ["ELF", v"0.1.0", "ObjFileBase"], - ["ELF", v"0.1.0", "StructIO"], - ["EllipsisNotation", v"0.0.1"], - ["EllipsisNotation", v"0.1.0"], - ["FFTViews", v"0.0.1", "CustomUnitRanges"], - ["FFTViews", v"0.0.2", "CustomUnitRanges"], - ["FFTViews", v"0.0.2", "Compat", v"0.17.0"], - ["FactCheck", v"0.0.0"], - ["FactCheck", v"0.0.2"], - ["FactCheck", v"0.2.2"], - ["FactCheck", v"0.4.2", "Compat"], - ["FactCheck", v"0.4.3", "Compat", v"0.7.18"], - ["FileIO", v"0.0.5", "Compat"], - ["FileIO", v"0.0.5", "Docile"], - ["FileIO", v"0.0.6", "Docile"], - ["FileIO", v"0.0.6", "Compat", v"0.7.15"], - ["FileIO", v"0.1.1", "Compat", v"0.7.19"], - ["FileIO", v"0.2.1", "Compat", v"0.7.19"], - ["FileIO", v"0.3.0", "Compat", v"0.9.5"], - ["FileIO", v"0.3.1", "Compat", v"0.17.0"], - ["FiniteElementDiffEq", v"0.0.3", "ChunkedArrays", v"0.1.0"], - ["FiniteElementDiffEq", v"0.0.3", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["FiniteElementDiffEq", v"0.0.3", "ForwardDiff", v"0.2.4"], - ["FiniteElementDiffEq", v"0.0.3", "GenericSVD", v"0.0.2"], - ["FiniteElementDiffEq", v"0.0.3", "IterativeSolvers", v"0.2.2"], - ["FiniteElementDiffEq", v"0.0.3", "NLsolve", v"0.7.3"], - ["FiniteElementDiffEq", v"0.0.3", "Parameters", v"0.5.0"], - ["FiniteElementDiffEq", v"0.0.3", "Plots", v"0.9.2"], - ["FiniteElementDiffEq", v"0.0.3", "RecipesBase", v"0.1.0"], - ["FiniteElementDiffEq", v"0.0.3", "VectorizedRoutines", v"0.0.2"], - ["FiniteElementDiffEq", v"0.0.4", "ChunkedArrays", v"0.1.0"], - ["FiniteElementDiffEq", v"0.0.4", "DiffEqBase", v"0.0.0", v"0.15.0"], - ["FiniteElementDiffEq", v"0.0.4", "ForwardDiff", v"0.2.4"], - ["FiniteElementDiffEq", v"0.0.4", "GenericSVD", v"0.0.2"], - ["FiniteElementDiffEq", v"0.0.4", "IterativeSolvers", v"0.2.2"], - ["FiniteElementDiffEq", v"0.0.4", "NLsolve", v"0.7.3"], - ["FiniteElementDiffEq", v"0.0.4", "Parameters", v"0.5.0"], - ["FiniteElementDiffEq", v"0.0.4", "RecipesBase", v"0.1.0"], - ["FiniteElementDiffEq", v"0.0.4", "VectorizedRoutines", v"0.0.2"], - ["FiniteElementDiffEq", v"0.0.5", "ChunkedArrays", v"0.1.0"], - ["FiniteElementDiffEq", v"0.0.5", "DiffEqBase", v"0.1.1", v"0.15.0"], - ["FiniteElementDiffEq", v"0.0.5", "ForwardDiff", v"0.2.4"], - ["FiniteElementDiffEq", v"0.0.5", "GenericSVD", v"0.0.2"], - ["FiniteElementDiffEq", v"0.0.5", "IterativeSolvers", v"0.2.2"], - ["FiniteElementDiffEq", v"0.0.5", "Juno", v"0.2.4"], - ["FiniteElementDiffEq", v"0.0.5", "NLsolve", v"0.7.3"], - ["FiniteElementDiffEq", v"0.0.5", "Parameters", v"0.5.0"], - ["FiniteElementDiffEq", v"0.0.5", "RecipesBase", v"0.1.0"], - ["FiniteElementDiffEq", v"0.0.5", "VectorizedRoutines", v"0.0.2"], - ["FiniteElementDiffEq", v"0.2.0", "ChunkedArrays", v"0.1.0"], - ["FiniteElementDiffEq", v"0.2.0", "DiffEqBase", v"0.4.0", v"0.15.0"], - ["FiniteElementDiffEq", v"0.2.0", "ForwardDiff", v"0.2.4"], - ["FiniteElementDiffEq", v"0.2.0", "GenericSVD", v"0.0.2"], - ["FiniteElementDiffEq", v"0.2.0", "IterativeSolvers", v"0.2.2"], - ["FiniteElementDiffEq", v"0.2.0", "Juno", v"0.2.4"], - ["FiniteElementDiffEq", v"0.2.0", "NLsolve", v"0.7.3"], - ["FiniteElementDiffEq", v"0.2.0", "Parameters", v"0.5.0"], - ["FiniteElementDiffEq", v"0.2.0", "RecipesBase", v"0.1.0"], - ["FiniteElementDiffEq", v"0.2.0", "VectorizedRoutines", v"0.0.2"], - ["FiniteElementDiffEq", v"0.2.1", "ChunkedArrays", v"0.1.0"], - ["FiniteElementDiffEq", v"0.2.1", "DiffEqBase", v"0.4.0", v"0.15.0"], - ["FiniteElementDiffEq", v"0.2.1", "DiffEqPDEBase"], - ["FiniteElementDiffEq", v"0.2.1", "ForwardDiff", v"0.2.4"], - ["FiniteElementDiffEq", v"0.2.1", "GenericSVD", v"0.0.2"], - ["FiniteElementDiffEq", v"0.2.1", "IterativeSolvers", v"0.2.2"], - ["FiniteElementDiffEq", v"0.2.1", "Juno", v"0.2.4"], - ["FiniteElementDiffEq", v"0.2.1", "NLsolve", v"0.7.3"], - ["FiniteElementDiffEq", v"0.2.1", "Parameters", v"0.5.0"], - ["FiniteElementDiffEq", v"0.2.1", "VectorizedRoutines", v"0.0.2"], - ["FiniteElementDiffEq", v"0.3.0", "ChunkedArrays", v"0.1.0"], - ["FiniteElementDiffEq", v"0.3.0", "DiffEqBase", v"0.15.0"], - ["FiniteElementDiffEq", v"0.3.0", "DiffEqPDEBase"], - ["FiniteElementDiffEq", v"0.3.0", "ForwardDiff", v"0.2.4"], - ["FiniteElementDiffEq", v"0.3.0", "GenericSVD", v"0.0.2"], - ["FiniteElementDiffEq", v"0.3.0", "IterativeSolvers", v"0.2.2"], - ["FiniteElementDiffEq", v"0.3.0", "Juno", v"0.2.4"], - ["FiniteElementDiffEq", v"0.3.0", "NLsolve", v"0.7.3"], - ["FiniteElementDiffEq", v"0.3.0", "Parameters", v"0.5.0"], - ["FiniteElementDiffEq", v"0.3.0", "VectorizedRoutines", v"0.0.2"], - ["FixedPointNumbers", v"0.0.5"], - ["FixedPointNumbers", v"0.0.12", "Compat", v"0.2.2"], - ["FixedPointNumbers", v"0.1.2"], - ["FixedPointNumbers", v"0.1.4", "Compat", v"0.7.14"], - ["FixedPointNumbers", v"0.1.7", "Compat", v"0.9.1"], - ["FixedPointNumbers", v"0.2.1", "Compat", v"0.9.1"], - ["FixedPointNumbers", v"0.3.0", "Compat", v"0.9.1"], - ["FixedPointNumbers", v"0.3.2", "Compat", v"0.9.5"], - ["FixedPointNumbers", v"0.3.6", "Compat", v"0.17.0"], - ["FixedSizeArrays", v"0.1.0"], - ["FixedSizeArrays", v"0.1.1", "Compat"], - ["FixedSizeArrays", v"0.2.1", "Compat", v"0.7.15"], - ["FixedSizeArrays", v"0.2.2", "Compat", v"0.7.15"], - ["FixedSizeArrays", v"0.2.5", "Compat", v"0.8.7"], - ["ForwardDiff", v"0.2.5", "Calculus"], - ["ForwardDiff", v"0.2.5", "NaNMath"], - ["ForwardDiff", v"0.2.5", "Compat", v"0.8.6"], - ["ForwardDiff", v"0.3.4", "Calculus", v"0.2.0"], - ["ForwardDiff", v"0.3.4", "Compat", v"0.8.6"], - ["ForwardDiff", v"0.3.4", "DiffBase", v"0.0.3"], - ["ForwardDiff", v"0.3.4", "NaNMath", v"0.2.2"], - ["ForwardDiff", v"0.3.5", "Calculus", v"0.1.15"], - ["ForwardDiff", v"0.3.5", "Compat", v"0.8.6"], - ["ForwardDiff", v"0.3.5", "DiffBase", v"0.0.1"], - ["ForwardDiff", v"0.3.5", "NaNMath", v"0.2.1"], - ["ForwardDiff", v"0.4.2", "Calculus", v"0.2.0"], - ["ForwardDiff", v"0.4.2", "Compat", v"0.19.0"], - ["ForwardDiff", v"0.4.2", "DiffBase", v"0.0.3"], - ["ForwardDiff", v"0.4.2", "NaNMath", v"0.2.2"], - ["ForwardDiff", v"0.4.2", "SpecialFunctions", v"0.1.0"], - ["GZip", v"0.2.13"], - ["GZip", v"0.2.16", "Compat"], - ["GZip", v"0.2.18", "Compat", v"0.4.8"], - ["GZip", v"0.2.19", "Compat", v"0.7.9"], - ["GZip", v"0.2.20", "Compat", v"0.8.0"], - ["GZip", v"0.3.0", "Compat", v"0.9.5"], - ["Gallium", v"0.0.1", "ASTInterpreter"], - ["Gallium", v"0.0.1", "AbstractTrees"], - ["Gallium", v"0.0.1", "DWARF"], - ["Gallium", v"0.0.1", "ELF"], - ["Gallium", v"0.0.1", "MachO"], - ["Gallium", v"0.0.1", "TerminalUI"], - ["Gallium", v"0.0.2", "ASTInterpreter"], - ["Gallium", v"0.0.2", "AbstractTrees"], - ["Gallium", v"0.0.2", "DWARF"], - ["Gallium", v"0.0.2", "ELF"], - ["Gallium", v"0.0.2", "MachO"], - ["Gallium", v"0.0.2", "ObjFileBase"], - ["Gallium", v"0.0.2", "TerminalUI"], - ["Gallium", v"0.0.4", "ASTInterpreter"], - ["Gallium", v"0.0.4", "AbstractTrees"], - ["Gallium", v"0.0.4", "COFF"], - ["Gallium", v"0.0.4", "CRC"], - ["Gallium", v"0.0.4", "DWARF"], - ["Gallium", v"0.0.4", "ELF"], - ["Gallium", v"0.0.4", "MachO"], - ["Gallium", v"0.0.4", "ObjFileBase"], - ["Gallium", v"0.0.4", "TerminalUI"], - ["GenericSVD", v"0.0.2", "Compat", v"0.8.6"], - ["GnuTLS", v"0.0.1", "Nettle"], - ["GnuTLS", v"0.0.1", "BinDeps", v"0.2.1-"], - ["GnuTLS", v"0.0.4", "Compat"], - ["GnuTLS", v"0.0.4", "Nettle"], - ["GnuTLS", v"0.0.4", "BinDeps", v"0.2.1-"], - ["GnuTLS", v"0.0.5", "BinDeps"], - ["GnuTLS", v"0.0.5", "Compat"], - ["GnuTLS", v"0.0.5", "Nettle"], - ["Graphics", v"0.1.1"], - ["Graphics", v"0.1.3", "Colors"], - ["Graphics", v"0.1.4", "Colors"], - ["Graphics", v"0.1.4", "Compat", v"0.17.0"], - ["Graphics", v"0.2.0", "Colors"], - ["Graphics", v"0.2.0", "Compat", v"0.17.0"], - ["Graphics", v"0.2.0", "NaNMath", v"0.2.4"], - ["HDF5", v"0.2.1", "StrPack"], - ["HDF5", v"0.2.9"], - ["HDF5", v"0.4.6", "BinDeps"], - ["HDF5", v"0.5.2", "BinDeps"], - ["HDF5", v"0.5.2", "Blosc"], - ["HDF5", v"0.5.2", "Compat"], - ["HDF5", v"0.5.5", "BinDeps"], - ["HDF5", v"0.5.5", "Blosc"], - ["HDF5", v"0.5.5", "Compat", v"0.4.11"], - ["HDF5", v"0.6.0", "BinDeps"], - ["HDF5", v"0.6.0", "Blosc"], - ["HDF5", v"0.6.0", "Compat", v"0.7.1"], - ["HDF5", v"0.6.1", "BinDeps"], - ["HDF5", v"0.6.1", "Blosc"], - ["HDF5", v"0.6.1", "Compat", v"0.7.16"], - ["HDF5", v"0.7.3", "BinDeps"], - ["HDF5", v"0.7.3", "Blosc"], - ["HDF5", v"0.7.3", "Compat", v"0.8.0"], - ["HDF5", v"0.8.0", "BinDeps"], - ["HDF5", v"0.8.0", "Blosc"], - ["HDF5", v"0.8.0", "Compat", v"0.17.0"], - ["Hiccup", v"0.0.0", "Lazy"], - ["Hiccup", v"0.0.1", "Lazy"], - ["Hiccup", v"0.0.1", "MacroTools"], - ["Hiccup", v"0.0.2", "Compat"], - ["Hiccup", v"0.0.2", "Lazy"], - ["Hiccup", v"0.0.2", "MacroTools"], - ["Hiccup", v"0.0.3", "Lazy"], - ["Hiccup", v"0.0.3", "MacroTools"], - ["Hiccup", v"0.0.3", "Compat", v"0.8.2"], - ["Hiccup", v"0.1.1", "Compat", v"0.8.2"], - ["Hiccup", v"0.1.1", "MacroTools", v"0.3.4"], - ["HttpCommon", v"0.0.1"], - ["HttpCommon", v"0.0.2", "Calendar"], - ["HttpCommon", v"0.0.2", "FactCheck", v"0.0.1"], - ["HttpCommon", v"0.0.5", "Calendar"], - ["HttpCommon", v"0.0.5", "FactCheck", v"0.1.0-"], - ["HttpCommon", v"0.0.12", "Dates"], - ["HttpCommon", v"0.1.1", "Compat"], - ["HttpCommon", v"0.1.1", "Dates"], - ["HttpCommon", v"0.2.0", "Compat"], - ["HttpCommon", v"0.2.0", "Dates"], - ["HttpCommon", v"0.2.0", "URIParser"], - ["HttpCommon", v"0.2.4", "URIParser"], - ["HttpCommon", v"0.2.7", "URIParser"], - ["HttpCommon", v"0.2.7", "Compat", v"0.7.20"], - ["HttpParser", v"0.0.0", "HttpCommon"], - ["HttpParser", v"0.0.1", "BinDeps"], - ["HttpParser", v"0.0.1", "HttpCommon"], - ["HttpParser", v"0.0.2"], - ["HttpParser", v"0.0.3", "HttpCommon"], - ["HttpParser", v"0.0.3", "BinDeps", v"0.2.1-"], - ["HttpParser", v"0.0.4", "HttpCommon"], - ["HttpParser", v"0.0.4", "BinDeps", v"0.2.5-"], - ["HttpParser", v"0.0.11", "BinDeps", v"0.2.5-"], - ["HttpParser", v"0.0.11", "HttpCommon", v"0.0.3-"], - ["HttpParser", v"0.1.0", "BinDeps"], - ["HttpParser", v"0.1.0", "Compat"], - ["HttpParser", v"0.1.0", "HttpCommon"], - ["HttpParser", v"0.1.1", "BinDeps"], - ["HttpParser", v"0.1.1", "HttpCommon"], - ["HttpParser", v"0.2.0", "BinDeps"], - ["HttpParser", v"0.2.0", "HttpCommon"], - ["HttpParser", v"0.2.0", "Compat", v"0.7.20"], - ["HttpServer", v"0.0.1", "HttpCommon"], - ["HttpServer", v"0.0.1", "HttpParser"], - ["HttpServer", v"0.0.3", "GnuTLS"], - ["HttpServer", v"0.0.3", "HttpCommon"], - ["HttpServer", v"0.0.3", "HttpParser"], - ["HttpServer", v"0.0.7", "GnuTLS"], - ["HttpServer", v"0.0.7", "HttpCommon", v"0.0.3-"], - ["HttpServer", v"0.0.7", "HttpParser", v"0.0.5-"], - ["HttpServer", v"0.0.8", "GnuTLS"], - ["HttpServer", v"0.0.8", "HttpCommon"], - ["HttpServer", v"0.0.8", "HttpParser"], - ["HttpServer", v"0.0.11", "Docile"], - ["HttpServer", v"0.0.11", "GnuTLS"], - ["HttpServer", v"0.0.11", "HttpCommon"], - ["HttpServer", v"0.0.11", "HttpParser"], - ["HttpServer", v"0.1.2", "Compat"], - ["HttpServer", v"0.1.2", "Docile"], - ["HttpServer", v"0.1.2", "GnuTLS"], - ["HttpServer", v"0.1.2", "HttpCommon"], - ["HttpServer", v"0.1.2", "HttpParser"], - ["HttpServer", v"0.1.5", "HttpCommon"], - ["HttpServer", v"0.1.5", "HttpParser"], - ["HttpServer", v"0.1.5", "MbedTLS"], - ["HttpServer", v"0.1.7", "HttpCommon"], - ["HttpServer", v"0.1.7", "HttpParser"], - ["HttpServer", v"0.1.7", "MbedTLS"], - ["HttpServer", v"0.1.7", "Compat", v"0.7.16"], - ["HttpServer", v"0.2.0", "HttpCommon"], - ["HttpServer", v"0.2.0", "HttpParser"], - ["HttpServer", v"0.2.0", "MbedTLS"], - ["HttpServer", v"0.2.0", "Compat", v"0.17.0"], - ["ICU", v"0.2.1"], - ["ICU", v"0.4.4", "BinDeps"], - ["ImageAxes", v"0.0.2", "AxisArrays"], - ["ImageAxes", v"0.0.2", "Colors"], - ["ImageAxes", v"0.0.2", "ImageCore"], - ["ImageAxes", v"0.0.2", "Reexport"], - ["ImageAxes", v"0.0.2", "SimpleTraits"], - ["ImageAxes", v"0.1.1", "AxisArrays"], - ["ImageAxes", v"0.1.1", "Colors"], - ["ImageAxes", v"0.1.1", "FixedPointNumbers", v"0.3.0"], - ["ImageAxes", v"0.1.1", "ImageCore"], - ["ImageAxes", v"0.1.1", "Reexport"], - ["ImageAxes", v"0.1.1", "SimpleTraits"], - ["ImageAxes", v"0.2.1", "AxisArrays"], - ["ImageAxes", v"0.2.1", "Colors"], - ["ImageAxes", v"0.2.1", "FixedPointNumbers", v"0.3.0"], - ["ImageAxes", v"0.2.1", "MappedArrays"], - ["ImageAxes", v"0.2.1", "Reexport"], - ["ImageAxes", v"0.2.1", "SimpleTraits"], - ["ImageAxes", v"0.2.1", "ImageCore", v"0.2.0"], - ["ImageCore", v"0.0.3", "Colors"], - ["ImageCore", v"0.0.3", "Graphics"], - ["ImageCore", v"0.0.3", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["ImageCore", v"0.0.3", "MappedArrays"], - ["ImageCore", v"0.0.4", "Colors"], - ["ImageCore", v"0.0.4", "Graphics"], - ["ImageCore", v"0.0.4", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["ImageCore", v"0.0.4", "MappedArrays", v"0.0.3"], - ["ImageCore", v"0.0.5", "Colors"], - ["ImageCore", v"0.0.5", "Graphics"], - ["ImageCore", v"0.0.5", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["ImageCore", v"0.0.5", "MappedArrays", v"0.0.3"], - ["ImageCore", v"0.0.5", "OffsetArrays"], - ["ImageCore", v"0.0.5", "ShowItLikeYouBuildIt"], - ["ImageCore", v"0.1.1", "Colors"], - ["ImageCore", v"0.1.1", "Graphics"], - ["ImageCore", v"0.1.1", "FixedPointNumbers", v"0.3.0"], - ["ImageCore", v"0.1.1", "MappedArrays", v"0.0.3"], - ["ImageCore", v"0.1.1", "OffsetArrays"], - ["ImageCore", v"0.1.1", "ShowItLikeYouBuildIt"], - ["ImageCore", v"0.1.2", "ColorTypes"], - ["ImageCore", v"0.1.2", "Colors"], - ["ImageCore", v"0.1.2", "Graphics"], - ["ImageCore", v"0.1.2", "FixedPointNumbers", v"0.3.0"], - ["ImageCore", v"0.1.2", "MappedArrays", v"0.0.3"], - ["ImageCore", v"0.1.2", "OffsetArrays"], - ["ImageCore", v"0.1.2", "ShowItLikeYouBuildIt"], - ["ImageCore", v"0.1.5", "ColorTypes"], - ["ImageCore", v"0.1.5", "Colors"], - ["ImageCore", v"0.1.5", "Graphics"], - ["ImageCore", v"0.1.5", "Compat", v"0.19.0"], - ["ImageCore", v"0.1.5", "FixedPointNumbers", v"0.3.0"], - ["ImageCore", v"0.1.5", "MappedArrays", v"0.0.3"], - ["ImageCore", v"0.1.5", "OffsetArrays"], - ["ImageCore", v"0.1.5", "ShowItLikeYouBuildIt"], - ["ImageCore", v"0.2.0", "ColorTypes"], - ["ImageCore", v"0.2.0", "Colors"], - ["ImageCore", v"0.2.0", "Graphics"], - ["ImageCore", v"0.2.0", "Compat", v"0.19.0"], - ["ImageCore", v"0.2.0", "FixedPointNumbers", v"0.3.0"], - ["ImageCore", v"0.2.0", "MappedArrays", v"0.0.3"], - ["ImageCore", v"0.2.0", "OffsetArrays"], - ["ImageCore", v"0.2.0", "ShowItLikeYouBuildIt"], - ["ImageCore", v"0.3.0", "Colors"], - ["ImageCore", v"0.3.0", "Graphics"], - ["ImageCore", v"0.3.0", "ColorTypes", v"0.4.0"], - ["ImageCore", v"0.3.0", "Compat", v"0.19.0"], - ["ImageCore", v"0.3.0", "FixedPointNumbers", v"0.3.0"], - ["ImageCore", v"0.3.0", "MappedArrays", v"0.0.3"], - ["ImageCore", v"0.3.0", "OffsetArrays"], - ["ImageCore", v"0.3.0", "ShowItLikeYouBuildIt"], - ["ImageFiltering", v"0.0.2", "CatIndices"], - ["ImageFiltering", v"0.0.2", "ColorVectorSpace"], - ["ImageFiltering", v"0.0.2", "Colors"], - ["ImageFiltering", v"0.0.2", "ComputationalResources"], - ["ImageFiltering", v"0.0.2", "ImageCore"], - ["ImageFiltering", v"0.0.2", "DataStructures", v"0.4.6"], - ["ImageFiltering", v"0.0.2", "FFTViews"], - ["ImageFiltering", v"0.0.2", "MappedArrays"], - ["ImageFiltering", v"0.0.2", "OffsetArrays"], - ["ImageFiltering", v"0.0.2", "StaticArrays", v"0.0.5"], - ["ImageFiltering", v"0.0.2", "TiledIteration"], - ["ImageFiltering", v"0.0.2", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["ImageFiltering", v"0.1.2", "CatIndices"], - ["ImageFiltering", v"0.1.2", "ColorVectorSpace"], - ["ImageFiltering", v"0.1.2", "Colors"], - ["ImageFiltering", v"0.1.2", "ComputationalResources"], - ["ImageFiltering", v"0.1.2", "FFTViews"], - ["ImageFiltering", v"0.1.2", "ImageCore"], - ["ImageFiltering", v"0.1.2", "DataStructures", v"0.4.6"], - ["ImageFiltering", v"0.1.2", "MappedArrays"], - ["ImageFiltering", v"0.1.2", "OffsetArrays"], - ["ImageFiltering", v"0.1.2", "FixedPointNumbers", v"0.3.0"], - ["ImageFiltering", v"0.1.2", "StaticArrays", v"0.0.5"], - ["ImageFiltering", v"0.1.2", "TiledIteration"], - ["ImageFiltering", v"0.1.4", "CatIndices"], - ["ImageFiltering", v"0.1.4", "ColorVectorSpace"], - ["ImageFiltering", v"0.1.4", "Colors"], - ["ImageFiltering", v"0.1.4", "ComputationalResources"], - ["ImageFiltering", v"0.1.4", "Compat", v"0.18.0"], - ["ImageFiltering", v"0.1.4", "DataStructures", v"0.4.6"], - ["ImageFiltering", v"0.1.4", "FFTViews"], - ["ImageFiltering", v"0.1.4", "ImageCore"], - ["ImageFiltering", v"0.1.4", "MappedArrays"], - ["ImageFiltering", v"0.1.4", "OffsetArrays"], - ["ImageFiltering", v"0.1.4", "TiledIteration"], - ["ImageFiltering", v"0.1.4", "FixedPointNumbers", v"0.3.0"], - ["ImageFiltering", v"0.1.4", "StaticArrays", v"0.0.5"], - ["ImageMagick", v"0.0.1", "BinDeps"], - ["ImageMagick", v"0.0.1", "ColorTypes"], - ["ImageMagick", v"0.0.1", "Compat"], - ["ImageMagick", v"0.0.1", "FileIO"], - ["ImageMagick", v"0.0.1", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["ImageMagick", v"0.0.1", "Images", v"0.0.0-", v"0.6.0"], - ["ImageMagick", v"0.1.3", "BinDeps"], - ["ImageMagick", v"0.1.3", "ColorTypes", v"0.2.0"], - ["ImageMagick", v"0.1.3", "FileIO"], - ["ImageMagick", v"0.1.3", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["ImageMagick", v"0.1.3", "Images", v"0.0.0-", v"0.6.0"], - ["ImageMagick", v"0.1.6", "BinDeps"], - ["ImageMagick", v"0.1.6", "ColorTypes", v"0.2.0"], - ["ImageMagick", v"0.1.6", "Compat", v"0.7.7"], - ["ImageMagick", v"0.1.6", "FileIO"], - ["ImageMagick", v"0.1.6", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["ImageMagick", v"0.1.6", "Images", v"0.0.0-", v"0.6.0"], - ["ImageMagick", v"0.1.7", "BinDeps"], - ["ImageMagick", v"0.1.7", "ColorTypes", v"0.2.0"], - ["ImageMagick", v"0.1.7", "Compat", v"0.8.4"], - ["ImageMagick", v"0.1.7", "FileIO"], - ["ImageMagick", v"0.1.7", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["ImageMagick", v"0.1.7", "Images", v"0.0.0-", v"0.6.0"], - ["ImageMagick", v"0.1.8", "BinDeps"], - ["ImageMagick", v"0.1.8", "ColorTypes", v"0.2.7"], - ["ImageMagick", v"0.1.8", "Compat", v"0.8.4"], - ["ImageMagick", v"0.1.8", "FileIO"], - ["ImageMagick", v"0.1.8", "FixedPointNumbers", v"0.1.8", v"0.3.0"], - ["ImageMagick", v"0.1.8", "Images", v"0.0.0-", v"0.6.0"], - ["ImageMagick", v"0.2.1", "BinDeps"], - ["ImageMagick", v"0.2.1", "ColorTypes", v"0.2.7"], - ["ImageMagick", v"0.2.1", "FileIO"], - ["ImageMagick", v"0.2.1", "FixedPointNumbers", v"0.3.0"], - ["ImageMagick", v"0.2.3", "BinDeps"], - ["ImageMagick", v"0.2.3", "ColorTypes", v"0.2.7"], - ["ImageMagick", v"0.2.3", "Compat", v"0.18.0"], - ["ImageMagick", v"0.2.3", "FileIO"], - ["ImageMagick", v"0.2.3", "FixedPointNumbers", v"0.3.0"], - ["ImageMagick", v"0.2.3", "ImageCore", v"0.1.0"], - ["ImageMagick", v"0.2.4", "BinDeps"], - ["ImageMagick", v"0.2.4", "ColorTypes", v"0.2.7"], - ["ImageMagick", v"0.2.4", "Compat", v"0.24.0"], - ["ImageMagick", v"0.2.4", "FileIO"], - ["ImageMagick", v"0.2.4", "FixedPointNumbers", v"0.3.0"], - ["ImageMagick", v"0.2.4", "Images", v"0.6.0"], - ["ImageMetadata", v"0.0.1", "Colors"], - ["ImageMetadata", v"0.0.1", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["ImageMetadata", v"0.0.1", "ImageAxes"], - ["ImageMetadata", v"0.0.1", "ColorVectorSpace", v"0.1.11"], - ["ImageMetadata", v"0.0.1", "ImageCore"], - ["ImageMetadata", v"0.0.1", "IndirectArrays"], - ["ImageMetadata", v"0.2.0", "Colors"], - ["ImageMetadata", v"0.2.0", "ImageAxes"], - ["ImageMetadata", v"0.2.0", "ColorVectorSpace", v"0.1.11"], - ["ImageMetadata", v"0.2.0", "FixedPointNumbers", v"0.3.0"], - ["ImageMetadata", v"0.2.0", "ImageCore"], - ["ImageMetadata", v"0.2.0", "IndirectArrays"], - ["ImageMetadata", v"0.2.3", "Colors"], - ["ImageMetadata", v"0.2.3", "ImageAxes"], - ["ImageMetadata", v"0.2.3", "ColorVectorSpace", v"0.1.11"], - ["ImageMetadata", v"0.2.3", "Compat", v"0.19.0"], - ["ImageMetadata", v"0.2.3", "FixedPointNumbers", v"0.3.0"], - ["ImageMetadata", v"0.2.3", "ImageCore"], - ["ImageMetadata", v"0.2.3", "IndirectArrays"], - ["ImageTransformations", v"0.0.1", "ColorVectorSpace", v"0.2.0"], - ["ImageTransformations", v"0.0.1", "Colors", v"0.7.0"], - ["ImageTransformations", v"0.0.1", "CoordinateTransformations", v"0.4.0"], - ["ImageTransformations", v"0.0.1", "ImageCore", v"0.1.2"], - ["ImageTransformations", v"0.0.1", "Interpolations", v"0.3.7"], - ["ImageTransformations", v"0.0.1", "OffsetArrays"], - ["ImageTransformations", v"0.0.1", "StaticArrays"], - ["ImageTransformations", v"0.1.0", "ColorVectorSpace", v"0.2.0"], - ["ImageTransformations", v"0.1.0", "Colors", v"0.7.0"], - ["ImageTransformations", v"0.1.0", "CoordinateTransformations", v"0.4.0"], - ["ImageTransformations", v"0.1.0", "FixedPointNumbers", v"0.3.0"], - ["ImageTransformations", v"0.1.0", "ImageCore", v"0.1.2"], - ["ImageTransformations", v"0.1.0", "Interpolations", v"0.3.7"], - ["ImageTransformations", v"0.1.0", "OffsetArrays"], - ["ImageTransformations", v"0.1.0", "StaticArrays"], - ["ImageTransformations", v"0.2.2", "AxisAlgorithms"], - ["ImageTransformations", v"0.2.2", "ColorVectorSpace", v"0.2.0"], - ["ImageTransformations", v"0.2.2", "Colors", v"0.7.0"], - ["ImageTransformations", v"0.2.2", "Compat", v"0.18.0"], - ["ImageTransformations", v"0.2.2", "CoordinateTransformations", v"0.4.0"], - ["ImageTransformations", v"0.2.2", "OffsetArrays"], - ["ImageTransformations", v"0.2.2", "StaticArrays"], - ["ImageTransformations", v"0.2.2", "FixedPointNumbers", v"0.3.0"], - ["ImageTransformations", v"0.2.2", "ImageCore", v"0.1.2"], - ["ImageTransformations", v"0.2.2", "Interpolations", v"0.4.0"], - ["Images", v"0.4.50", "BinDeps"], - ["Images", v"0.4.50", "ColorVectorSpace"], - ["Images", v"0.4.50", "Colors"], - ["Images", v"0.4.50", "SIUnits"], - ["Images", v"0.4.50", "Compat", v"0.4.0"], - ["Images", v"0.4.50", "FixedPointNumbers", v"0.0.0-", v"0.3.0"], - ["Images", v"0.4.50", "Graphics", v"0.1.0"], - ["Images", v"0.4.50", "Zlib"], - ["Images", v"0.5.4", "FileIO"], - ["Images", v"0.5.4", "SIUnits"], - ["Images", v"0.5.4", "ColorVectorSpace", v"0.1.0"], - ["Images", v"0.5.4", "Colors", v"0.6.0"], - ["Images", v"0.5.4", "Graphics", v"0.1.0"], - ["Images", v"0.5.4", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["Images", v"0.5.4", "Zlib"], - ["Images", v"0.5.5", "ColorVectorSpace", v"0.1.0"], - ["Images", v"0.5.5", "Colors", v"0.6.0"], - ["Images", v"0.5.5", "Compat", v"0.7.15"], - ["Images", v"0.5.5", "FileIO"], - ["Images", v"0.5.5", "Graphics", v"0.1.0"], - ["Images", v"0.5.5", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["Images", v"0.5.5", "SIUnits"], - ["Images", v"0.5.5", "Zlib"], - ["Images", v"0.5.9", "ColorVectorSpace", v"0.1.0"], - ["Images", v"0.5.9", "Colors", v"0.6.0"], - ["Images", v"0.5.9", "Compat", v"0.8.4"], - ["Images", v"0.5.9", "FileIO"], - ["Images", v"0.5.9", "Graphics", v"0.1.0"], - ["Images", v"0.5.9", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["Images", v"0.5.9", "SIUnits"], - ["Images", v"0.5.9", "StatsBase"], - ["Images", v"0.5.9", "Zlib"], - ["Images", v"0.5.14", "ColorVectorSpace", v"0.1.0"], - ["Images", v"0.5.14", "Colors", v"0.6.0"], - ["Images", v"0.5.14", "Compat", v"0.9.1"], - ["Images", v"0.5.14", "FileIO"], - ["Images", v"0.5.14", "Graphics", v"0.1.0"], - ["Images", v"0.5.14", "FixedPointNumbers", v"0.1.0", v"0.3.0"], - ["Images", v"0.5.14", "SIUnits"], - ["Images", v"0.5.14", "StatsBase"], - ["Images", v"0.5.14", "Zlib"], - ["Images", v"0.6.0", "AxisArrays"], - ["Images", v"0.6.0", "FileIO"], - ["Images", v"0.6.0", "ImageAxes"], - ["Images", v"0.6.0", "ImageCore"], - ["Images", v"0.6.0", "ImageFiltering"], - ["Images", v"0.6.0", "ImageMetadata"], - ["Images", v"0.6.0", "IndirectArrays"], - ["Images", v"0.6.0", "MappedArrays"], - ["Images", v"0.6.0", "Reexport"], - ["Images", v"0.6.0", "SIUnits"], - ["Images", v"0.6.0", "StatsBase"], - ["Images", v"0.6.0", "Zlib"], - ["Images", v"0.6.0", "ColorVectorSpace", v"0.2.0"], - ["Images", v"0.6.0", "Colors", v"0.7.0"], - ["Images", v"0.6.0", "Compat", v"0.9.1"], - ["Images", v"0.6.0", "FixedPointNumbers", v"0.3.0"], - ["Images", v"0.6.0", "Graphics", v"0.1.0"], - ["Images", v"0.7.0", "AxisArrays"], - ["Images", v"0.7.0", "FileIO"], - ["Images", v"0.7.0", "ColorVectorSpace", v"0.2.0"], - ["Images", v"0.7.0", "Colors", v"0.7.0"], - ["Images", v"0.7.0", "Compat", v"0.9.1"], - ["Images", v"0.7.0", "Graphics", v"0.1.0"], - ["Images", v"0.7.0", "ImageAxes"], - ["Images", v"0.7.0", "ImageCore"], - ["Images", v"0.7.0", "ImageFiltering"], - ["Images", v"0.7.0", "ImageMetadata"], - ["Images", v"0.7.0", "IndirectArrays"], - ["Images", v"0.7.0", "MappedArrays"], - ["Images", v"0.7.0", "Reexport"], - ["Images", v"0.7.0", "SIUnits"], - ["Images", v"0.7.0", "StatsBase"], - ["Images", v"0.7.0", "FixedPointNumbers", v"0.3.0"], - ["Images", v"0.8.0", "AxisArrays"], - ["Images", v"0.8.0", "FileIO"], - ["Images", v"0.8.0", "ImageAxes"], - ["Images", v"0.8.0", "ImageCore"], - ["Images", v"0.8.0", "ColorVectorSpace", v"0.2.0"], - ["Images", v"0.8.0", "Colors", v"0.7.0"], - ["Images", v"0.8.0", "Compat", v"0.9.1"], - ["Images", v"0.8.0", "Graphics", v"0.1.0"], - ["Images", v"0.8.0", "ImageFiltering"], - ["Images", v"0.8.0", "ImageMetadata"], - ["Images", v"0.8.0", "ImageTransformations"], - ["Images", v"0.8.0", "IndirectArrays"], - ["Images", v"0.8.0", "MappedArrays"], - ["Images", v"0.8.0", "Reexport"], - ["Images", v"0.8.0", "SIUnits"], - ["Images", v"0.8.0", "StatsBase"], - ["Images", v"0.8.0", "FixedPointNumbers", v"0.3.0"], - ["Images", v"0.9.0", "AxisArrays"], - ["Images", v"0.9.0", "FileIO"], - ["Images", v"0.9.0", "Graphics", v"0.1.0"], - ["Images", v"0.9.0", "ImageAxes"], - ["Images", v"0.9.0", "ImageCore"], - ["Images", v"0.9.0", "ColorVectorSpace", v"0.2.0"], - ["Images", v"0.9.0", "Colors", v"0.7.0"], - ["Images", v"0.9.0", "Compat", v"0.18.0"], - ["Images", v"0.9.0", "ImageFiltering"], - ["Images", v"0.9.0", "ImageMetadata"], - ["Images", v"0.9.0", "ImageTransformations"], - ["Images", v"0.9.0", "IndirectArrays"], - ["Images", v"0.9.0", "MappedArrays"], - ["Images", v"0.9.0", "Reexport"], - ["Images", v"0.9.0", "SIUnits"], - ["Images", v"0.9.0", "StatsBase"], - ["Images", v"0.9.0", "FixedPointNumbers", v"0.3.0"], - ["Images", v"0.9.1", "AxisArrays"], - ["Images", v"0.9.1", "FileIO"], - ["Images", v"0.9.1", "ImageAxes"], - ["Images", v"0.9.1", "ImageCore"], - ["Images", v"0.9.1", "ColorVectorSpace", v"0.2.0"], - ["Images", v"0.9.1", "Colors", v"0.7.0"], - ["Images", v"0.9.1", "Compat", v"0.19.0"], - ["Images", v"0.9.1", "ImageFiltering"], - ["Images", v"0.9.1", "ImageMetadata"], - ["Images", v"0.9.1", "ImageTransformations"], - ["Images", v"0.9.1", "IndirectArrays"], - ["Images", v"0.9.1", "MappedArrays"], - ["Images", v"0.9.1", "Reexport"], - ["Images", v"0.9.1", "SIUnits"], - ["Images", v"0.9.1", "StatsBase"], - ["Images", v"0.9.1", "FixedPointNumbers", v"0.3.0"], - ["Images", v"0.9.1", "Graphics", v"0.1.0"], - ["IndirectArrays", v"0.1.0"], - ["IndirectArrays", v"0.1.1", "Compat", v"0.19.0"], - ["InplaceOps", v"0.1.0"], - ["Interpolations", v"0.0.1-beta", "Compat"], - ["Interpolations", v"0.0.1-beta", "WoodburyMatrices"], - ["Interpolations", v"0.1.0", "WoodburyMatrices"], - ["Interpolations", v"0.3.4", "AxisAlgorithms"], - ["Interpolations", v"0.3.4", "Ratios"], - ["Interpolations", v"0.3.4", "WoodburyMatrices", v"0.1.0"], - ["Interpolations", v"0.3.5", "AxisAlgorithms"], - ["Interpolations", v"0.3.5", "Ratios"], - ["Interpolations", v"0.3.5", "WoodburyMatrices", v"0.1.5"], - ["Interpolations", v"0.3.6", "AxisAlgorithms"], - ["Interpolations", v"0.3.6", "Ratios"], - ["Interpolations", v"0.3.6", "Compat", v"0.8.0"], - ["Interpolations", v"0.3.6", "WoodburyMatrices", v"0.1.5"], - ["Interpolations", v"0.3.7", "AxisAlgorithms"], - ["Interpolations", v"0.3.7", "DualNumbers"], - ["Interpolations", v"0.3.7", "Ratios"], - ["Interpolations", v"0.3.7", "Compat", v"0.8.0"], - ["Interpolations", v"0.3.7", "WoodburyMatrices", v"0.1.5"], - ["Interpolations", v"0.3.8", "AxisAlgorithms"], - ["Interpolations", v"0.3.8", "DualNumbers"], - ["Interpolations", v"0.3.8", "Ratios"], - ["Interpolations", v"0.3.8", "Compat", v"0.19.0"], - ["Interpolations", v"0.3.8", "WoodburyMatrices", v"0.1.5"], - ["Interpolations", v"0.4.0", "AxisAlgorithms"], - ["Interpolations", v"0.4.0", "DualNumbers"], - ["Interpolations", v"0.4.0", "Ratios"], - ["Interpolations", v"0.4.0", "Compat", v"0.19.0"], - ["Interpolations", v"0.4.0", "WoodburyMatrices", v"0.1.5"], - ["Interpolations", v"0.5.0", "AxisAlgorithms"], - ["Interpolations", v"0.5.0", "DualNumbers"], - ["Interpolations", v"0.5.0", "Ratios"], - ["Interpolations", v"0.5.0", "ShowItLikeYouBuildIt"], - ["Interpolations", v"0.5.0", "Compat", v"0.19.0"], - ["Interpolations", v"0.5.0", "WoodburyMatrices", v"0.1.5"], - ["IntervalSets", v"0.0.2"], - ["IntervalSets", v"0.0.5", "Compat", v"0.17.0"], - ["IterativeSolvers", v"0.0.1", "Compat"], - ["IterativeSolvers", v"0.0.1", "Docile"], - ["IterativeSolvers", v"0.2.1", "Compat"], - ["IterativeSolvers", v"0.2.2", "Compat"], - ["Iterators", v"0.1.10", "Compat"], - ["Iterators", v"0.3.0"], - ["JLD", v"0.6.4", "Compat", v"0.8.0"], - ["JLD", v"0.6.4", "FileIO"], - ["JLD", v"0.6.4", "HDF5"], - ["JLD", v"0.6.4", "LegacyStrings"], - ["JLD", v"0.6.10", "Compat", v"0.8.0"], - ["JLD", v"0.6.10", "FileIO"], - ["JLD", v"0.6.10", "HDF5"], - ["JLD", v"0.6.10", "LegacyStrings"], - ["JSON", v"0.3.9"], - ["JSON", v"0.4.4", "Compat"], - ["JSON", v"0.4.5", "Compat", v"0.4.12"], - ["JSON", v"0.5.0", "Compat", v"0.7.1"], - ["JSON", v"0.5.4", "Compat", v"0.7.16"], - ["JSON", v"0.6.0", "Compat", v"0.7.20"], - ["JSON", v"0.8.0", "Compat", v"0.8.4"], - ["JSON", v"0.8.2", "Compat", v"0.9.5"], - ["JSON", v"0.8.3", "Compat", v"0.17.0"], - ["JSON", v"0.9.0", "Compat", v"0.17.0"], - ["JuliaParser", v"0.5.3", "FactCheck"], - ["JuliaParser", v"0.6.4", "Compat"], - ["JuliaParser", v"0.6.4", "FactCheck"], - ["JuliaParser", v"0.7.0", "AbstractTrees"], - ["JuliaParser", v"0.7.0", "Compat"], - ["JuliaParser", v"0.7.1", "AbstractTrees"], - ["JuliaParser", v"0.7.1", "Compat"], - ["JuliaParser", v"0.7.4", "AbstractTrees"], - ["JuliaParser", v"0.7.4", "Compat"], - ["Juno", v"0.2.3", "Hiccup"], - ["Juno", v"0.2.3", "MacroTools"], - ["Juno", v"0.2.3", "Media"], - ["Juno", v"0.2.4", "Hiccup"], - ["Juno", v"0.2.4", "MacroTools"], - ["Juno", v"0.2.4", "Media"], - ["Juno", v"0.2.5", "Hiccup"], - ["Juno", v"0.2.5", "MacroTools"], - ["Juno", v"0.2.5", "Media"], - ["Juno", v"0.2.7", "Hiccup"], - ["Juno", v"0.2.7", "MacroTools"], - ["Juno", v"0.2.7", "Media"], - ["LNR", v"0.0.0"], - ["LNR", v"0.0.1", "Lazy"], - ["LNR", v"0.0.2", "Compat"], - ["LNR", v"0.0.2", "Lazy"], - ["Lazy", v"0.9.1"], - ["Lazy", v"0.10.0", "MacroTools"], - ["Lazy", v"0.10.1", "Compat"], - ["Lazy", v"0.10.1", "MacroTools"], - ["Lazy", v"0.11.2", "MacroTools"], - ["Lazy", v"0.11.2", "Compat", v"0.8.0"], - ["Lazy", v"0.11.6", "MacroTools"], - ["Lazy", v"0.11.6", "Compat", v"0.8.0"], - ["LearnBase", v"0.1.0", "StatsBase"], - ["LearnBase", v"0.1.1", "Distributions"], - ["LearnBase", v"0.1.1", "StatsBase"], - ["LearnBase", v"0.1.2", "Distributions"], - ["LearnBase", v"0.1.2", "StatsBase", v"0.8.0"], - ["LearnBase", v"0.1.3", "Distributions"], - ["LearnBase", v"0.1.3", "Compat", v"0.17.0"], - ["LearnBase", v"0.1.3", "StatsBase", v"0.8.0"], - ["LearnBase", v"0.1.5", "Distributions"], - ["LearnBase", v"0.1.5", "Compat", v"0.18.0"], - ["LearnBase", v"0.1.5", "StatsBase", v"0.8.0"], - ["LegacyStrings", v"0.1.0"], - ["LegacyStrings", v"0.2.0", "Compat", v"0.8.4"], - ["LegacyStrings", v"0.2.1", "Compat", v"0.18.0"], - ["LineSearches", v"0.0.2"], - ["LineSearches", v"0.1.1"], - ["LineSearches", v"0.1.5"], - ["LossFunctions", v"0.0.1", "LearnBase", v"0.0.1", v"0.2.0"], - ["LossFunctions", v"0.0.1", "RecipesBase"], - ["LossFunctions", v"0.0.1", "Reexport"], - ["LossFunctions", v"0.0.2", "LearnBase", v"0.0.1", v"0.2.0"], - ["LossFunctions", v"0.0.2", "RecipesBase"], - ["LossFunctions", v"0.0.2", "Reexport"], - ["LossFunctions", v"0.0.3", "LearnBase", v"0.1.2", v"0.2.0"], - ["LossFunctions", v"0.0.3", "RecipesBase"], - ["LossFunctions", v"0.0.3", "StatsBase", v"0.8.0"], - ["LossFunctions", v"0.1.0", "LearnBase", v"0.1.3", v"0.2.0"], - ["LossFunctions", v"0.1.0", "RecipesBase"], - ["LossFunctions", v"0.1.0", "StatsBase", v"0.8.0"], - ["LsqFit", v"0.0.1", "Calculus"], - ["LsqFit", v"0.0.1", "Distributions"], - ["LsqFit", v"0.0.1", "Optim", v"0.0.0", v"0.5.0"], - ["LsqFit", v"0.0.2", "Calculus"], - ["LsqFit", v"0.0.2", "Distributions"], - ["LsqFit", v"0.0.2", "Optim"], - ["LsqFit", v"0.1.0", "Calculus"], - ["LsqFit", v"0.1.0", "Distributions"], - ["LsqFit", v"0.1.0", "Optim", v"0.6.0"], - ["LsqFit", v"0.1.1", "Calculus"], - ["LsqFit", v"0.1.1", "Distributions"], - ["LsqFit", v"0.1.1", "Optim", v"0.7.0"], - ["LsqFit", v"0.2.0", "Calculus"], - ["LsqFit", v"0.2.0", "Distributions"], - ["LsqFit", v"0.2.0", "Compat", v"0.9.1"], - ["LsqFit", v"0.2.0", "Optim", v"0.7.5"], - ["MachO", v"0.0.4", "ObjFileBase"], - ["MachO", v"0.0.4", "StructIO"], - ["MacroTools", v"0.1.0"], - ["MacroTools", v"0.3.0"], - ["MacroTools", v"0.3.1", "Compat"], - ["MacroTools", v"0.3.3", "Compat"], - ["MacroTools", v"0.3.6", "Compat", v"0.7.9"], - ["MappedArrays", v"0.0.2"], - ["MappedArrays", v"0.0.5"], - ["MappedArrays", v"0.0.7", "Compat", v"0.19.0"], - ["Markdown", v"0.1.0"], - ["Markdown", v"0.3.0", "Lazy"], - ["MbedTLS", v"0.2.3", "BinDeps"], - ["MbedTLS", v"0.2.3", "Compat", v"0.7.9"], - ["MbedTLS", v"0.3.0", "BinDeps"], - ["MbedTLS", v"0.3.0", "Compat", v"0.8.0"], - ["MbedTLS", v"0.4.4", "BinDeps"], - ["MbedTLS", v"0.4.5", "BinDeps"], - ["MbedTLS", v"0.4.5", "Compat", v"0.9.5"], - ["Measures", v"0.0.2"], - ["Measures", v"0.0.3", "Compat", v"0.7.15"], - ["Measures", v"0.1.0", "Compat", v"0.18.0"], - ["Media", v"0.1.0", "Lazy"], - ["Media", v"0.1.0", "Requires"], - ["Media", v"0.2.2", "Lazy"], - ["Media", v"0.2.2", "MacroTools"], - ["Media", v"0.2.2", "Requires"], - ["Media", v"0.2.3", "MacroTools"], - ["Media", v"0.2.3", "Lazy", v"0.11.3"], - ["Media", v"0.2.7", "MacroTools"], - ["MultiScaleArrays", v"0.0.1", "Iterators"], - ["MultiScaleArrays", v"0.0.1", "RecursiveArrayTools", v"0.0.2"], - ["MultiScaleArrays", v"0.1.0", "DiffEqBase", v"0.11.0"], - ["MultiScaleArrays", v"0.1.0", "Iterators"], - ["MultiScaleArrays", v"0.1.0", "RecursiveArrayTools", v"0.0.2"], - ["Mustache", v"0.0.1", "DataFrames"], - ["Mustache", v"0.0.7", "Compat"], - ["Mustache", v"0.0.7", "Requires"], - ["Mustache", v"0.0.14", "Requires"], - ["Mustache", v"0.0.14", "Compat", v"0.4.0"], - ["Mustache", v"0.1.0"], - ["Mustache", v"0.1.4", "Compat", v"0.7.18"], - ["Mux", v"0.0.0", "Hiccup"], - ["Mux", v"0.0.0", "HttpServer"], - ["Mux", v"0.0.0", "Lazy"], - ["Mux", v"0.0.0", "URIParser"], - ["Mux", v"0.1.1", "Compat"], - ["Mux", v"0.1.1", "Hiccup"], - ["Mux", v"0.1.1", "HttpCommon"], - ["Mux", v"0.1.1", "HttpServer"], - ["Mux", v"0.1.1", "Lazy"], - ["Mux", v"0.1.1", "URIParser"], - ["Mux", v"0.1.1", "WebSockets"], - ["Mux", v"0.2.2", "Hiccup"], - ["Mux", v"0.2.2", "HttpCommon"], - ["Mux", v"0.2.2", "HttpServer"], - ["Mux", v"0.2.2", "Lazy"], - ["Mux", v"0.2.2", "URIParser"], - ["Mux", v"0.2.2", "WebSockets"], - ["Mux", v"0.2.3", "Hiccup"], - ["Mux", v"0.2.3", "HttpCommon"], - ["Mux", v"0.2.3", "Compat", v"0.7.9"], - ["Mux", v"0.2.3", "HttpServer"], - ["Mux", v"0.2.3", "Lazy"], - ["Mux", v"0.2.3", "URIParser"], - ["Mux", v"0.2.3", "WebSockets"], - ["NLSolversBase", v"2.1.1", "Compat", v"0.17.0"], - ["NLsolve", v"0.7.3", "Calculus"], - ["NLsolve", v"0.7.3", "Distances"], - ["NLsolve", v"0.7.3", "Optim"], - ["NLsolve", v"0.7.3", "Compat", v"0.8.0"], - ["NLsolve", v"0.7.3", "ForwardDiff", v"0.2.0"], - ["NLsolve", v"0.7.3", "LineSearches", v"0.0.1", v"1.0.0-"], - ["NLsolve", v"0.8.0", "Calculus"], - ["NLsolve", v"0.8.0", "Distances"], - ["NLsolve", v"0.8.0", "Optim"], - ["NLsolve", v"0.8.0", "Compat", v"0.8.4"], - ["NLsolve", v"0.8.0", "ForwardDiff", v"0.2.0"], - ["NLsolve", v"0.8.0", "LineSearches", v"0.0.1", v"1.0.0-"], - ["NLsolve", v"0.9.0", "Calculus"], - ["NLsolve", v"0.9.0", "DiffBase"], - ["NLsolve", v"0.9.0", "Distances"], - ["NLsolve", v"0.9.0", "Optim"], - ["NLsolve", v"0.9.0", "Compat", v"0.8.4"], - ["NLsolve", v"0.9.0", "ForwardDiff", v"0.3.0"], - ["NLsolve", v"0.9.0", "LineSearches", v"0.1.2", v"1.0.0-"], - ["NLsolve", v"0.9.1", "Calculus"], - ["NLsolve", v"0.9.1", "DiffBase"], - ["NLsolve", v"0.9.1", "Distances"], - ["NLsolve", v"0.9.1", "Optim"], - ["NLsolve", v"0.9.1", "Compat", v"0.8.4"], - ["NLsolve", v"0.9.1", "ForwardDiff", v"0.3.0"], - ["NLsolve", v"0.9.1", "LineSearches", v"0.1.2", v"1.0.0-"], - ["NaNMath", v"0.1.1", "Compat"], - ["NaNMath", v"0.2.0"], - ["NaNMath", v"0.2.1"], - ["NaNMath", v"0.2.3", "Compat", v"0.9.1"], - ["NaNMath", v"0.2.4", "Compat", v"0.9.1"], - ["Nettle", v"0.1.1"], - ["Nettle", v"0.1.7", "BinDeps"], - ["Nettle", v"0.1.10", "BinDeps"], - ["Nettle", v"0.1.10", "Compat"], - ["Nettle", v"0.2.3", "BinDeps"], - ["Nettle", v"0.2.3", "Compat"], - ["Nettle", v"0.3.0", "BinDeps"], - ["Nettle", v"0.3.0", "Compat", v"0.8.0"], - ["NumericExtensions", v"0.3.6"], - ["NumericExtensions", v"0.4.3", "ArrayViews", v"0.2.0-"], - ["NumericExtensions", v"0.5.6", "ArrayViews", v"0.2.0-"], - ["NumericExtensions", v"0.6.2", "ArrayViews", v"0.2.0-"], - ["NumericExtensions", v"0.6.2", "NumericFuns", v"0.2.1-"], - ["NumericFuns", v"0.2.0"], - ["NumericFuns", v"0.2.3"], - ["NumericFuns", v"0.2.4", "Compat"], - ["ObjFileBase", v"0.0.4"], - ["OffsetArrays", v"0.2.13"], - ["OffsetArrays", v"0.3.0", "Compat", v"0.19.0"], - ["Optim", v"0.4.6", "Calculus"], - ["Optim", v"0.4.6", "Compat"], - ["Optim", v"0.4.6", "DualNumbers"], - ["Optim", v"0.4.6", "LineSearches", v"0.0.1", v"1.0.0-"], - ["Optim", v"0.4.7", "Calculus"], - ["Optim", v"0.4.7", "DualNumbers", v"0.2.0"], - ["Optim", v"0.4.7", "PositiveFactorizations"], - ["Optim", v"0.4.7", "LineSearches", v"0.0.1", v"1.0.0-"], - ["Optim", v"0.5.0", "Calculus"], - ["Optim", v"0.5.0", "PositiveFactorizations"], - ["Optim", v"0.5.0", "Compat", v"0.7.16"], - ["Optim", v"0.5.0", "DualNumbers", v"0.2.0"], - ["Optim", v"0.5.0", "LineSearches", v"0.0.1", v"1.0.0-"], - ["Optim", v"0.6.1", "Calculus"], - ["Optim", v"0.6.1", "PositiveFactorizations"], - ["Optim", v"0.6.1", "Compat", v"0.8.4"], - ["Optim", v"0.6.1", "ForwardDiff", v"0.2.0", v"0.3.0"], - ["Optim", v"0.6.1", "LineSearches", v"0.0.1", v"1.0.0-"], - ["Optim", v"0.7.2", "Calculus"], - ["Optim", v"0.7.2", "PositiveFactorizations"], - ["Optim", v"0.7.2", "Compat", v"0.8.4"], - ["Optim", v"0.7.2", "ForwardDiff", v"0.3.0", v"0.4.0"], - ["Optim", v"0.7.2", "LineSearches", v"0.1.0", v"1.0.0-"], - ["Optim", v"0.7.4", "Calculus"], - ["Optim", v"0.7.4", "PositiveFactorizations"], - ["Optim", v"0.7.4", "Compat", v"0.8.4"], - ["Optim", v"0.7.4", "ForwardDiff", v"0.3.0", v"0.4.0"], - ["Optim", v"0.7.4", "LineSearches", v"0.1.2", v"1.0.0-"], - ["Optim", v"0.7.5", "Calculus"], - ["Optim", v"0.7.5", "PositiveFactorizations"], - ["Optim", v"0.7.5", "Compat", v"0.8.4"], - ["Optim", v"0.7.5", "ForwardDiff", v"0.3.0", v"0.4.0"], - ["Optim", v"0.7.5", "LineSearches", v"0.1.2", v"1.0.0-"], - ["Optim", v"0.7.7", "Calculus"], - ["Optim", v"0.7.7", "PositiveFactorizations"], - ["Optim", v"0.7.7", "Compat", v"0.18.0"], - ["Optim", v"0.7.7", "ForwardDiff", v"0.3.0", v"0.4.0"], - ["Optim", v"0.7.7", "LineSearches", v"0.1.2", v"1.0.0-"], - ["Optim", v"0.7.8", "Calculus"], - ["Optim", v"0.7.8", "PositiveFactorizations"], - ["Optim", v"0.7.8", "Compat", v"0.18.0"], - ["Optim", v"0.7.8", "ForwardDiff", v"0.3.0", v"0.5.0"], - ["Optim", v"0.7.8", "LineSearches", v"0.1.2", v"1.0.0-"], - ["Options", v"0.2.6"], - ["OrdinaryDiffEq", v"0.0.1", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.7.0"], - ["OrdinaryDiffEq", v"0.0.1", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"0.0.1", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"0.0.1", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"0.0.1", "NLsolve", v"0.7.3"], - ["OrdinaryDiffEq", v"0.0.1", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"0.0.1", "Ranges", v"0.0.1"], - ["OrdinaryDiffEq", v"0.0.1", "RecipesBase", v"0.1.0"], - ["OrdinaryDiffEq", v"0.0.1", "Sundials", v"0.3.0"], - ["OrdinaryDiffEq", v"0.0.3", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"0.0.3", "DiffEqBase", v"0.0.0", v"0.7.0"], - ["OrdinaryDiffEq", v"0.0.3", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"0.0.3", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"0.0.3", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"0.0.3", "NLsolve", v"0.7.3"], - ["OrdinaryDiffEq", v"0.0.3", "ParameterizedFunctions", v"0.1.0"], - ["OrdinaryDiffEq", v"0.0.3", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"0.0.3", "Ranges", v"0.0.1"], - ["OrdinaryDiffEq", v"0.0.3", "RecipesBase", v"0.1.0"], - ["OrdinaryDiffEq", v"0.0.3", "Sundials", v"0.3.0"], - ["OrdinaryDiffEq", v"0.0.5", "RecursiveArrayTools"], - ["OrdinaryDiffEq", v"0.0.5", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"0.0.5", "DiffEqBase", v"0.0.0", v"0.7.0"], - ["OrdinaryDiffEq", v"0.0.5", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"0.0.5", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"0.0.5", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"0.0.5", "NLsolve", v"0.7.3"], - ["OrdinaryDiffEq", v"0.0.5", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"0.0.5", "Ranges", v"0.0.1"], - ["OrdinaryDiffEq", v"0.0.5", "RecipesBase", v"0.1.0"], - ["OrdinaryDiffEq", v"0.0.5", "Sundials", v"0.3.0"], - ["OrdinaryDiffEq", v"0.1.0", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"0.1.0", "DiffEqBase", v"0.0.0", v"0.7.0"], - ["OrdinaryDiffEq", v"0.1.0", "Juno"], - ["OrdinaryDiffEq", v"0.1.0", "RecursiveArrayTools"], - ["OrdinaryDiffEq", v"0.1.0", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"0.1.0", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"0.1.0", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"0.1.0", "NLsolve", v"0.7.3"], - ["OrdinaryDiffEq", v"0.1.0", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"0.1.0", "Ranges", v"0.0.1"], - ["OrdinaryDiffEq", v"0.1.0", "RecipesBase", v"0.1.0"], - ["OrdinaryDiffEq", v"0.1.1", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"0.1.1", "DiffEqBase", v"0.1.2", v"0.7.0"], - ["OrdinaryDiffEq", v"0.1.1", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"0.1.1", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"0.1.1", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"0.1.1", "Juno", v"0.2.5"], - ["OrdinaryDiffEq", v"0.1.1", "NLsolve", v"0.7.3"], - ["OrdinaryDiffEq", v"0.1.1", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"0.1.1", "Ranges", v"0.0.1"], - ["OrdinaryDiffEq", v"0.1.1", "RecipesBase", v"0.1.0"], - ["OrdinaryDiffEq", v"0.1.1", "RecursiveArrayTools", v"0.0.2"], - ["OrdinaryDiffEq", v"0.5.0", "Calculus", v"0.1.15"], - ["OrdinaryDiffEq", v"0.5.0", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"0.5.0", "DiffEqBase", v"0.2.0", v"0.7.0"], - ["OrdinaryDiffEq", v"0.5.0", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"0.5.0", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"0.5.0", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"0.5.0", "Juno", v"0.2.5"], - ["OrdinaryDiffEq", v"0.5.0", "NLsolve", v"0.7.3"], - ["OrdinaryDiffEq", v"0.5.0", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"0.5.0", "Ranges", v"0.0.1"], - ["OrdinaryDiffEq", v"0.5.0", "RecipesBase", v"0.1.0"], - ["OrdinaryDiffEq", v"0.5.0", "RecursiveArrayTools", v"0.0.2"], - ["OrdinaryDiffEq", v"0.6.0", "Calculus", v"0.1.15"], - ["OrdinaryDiffEq", v"0.6.0", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"0.6.0", "DiffEqBase", v"0.4.0", v"0.7.0"], - ["OrdinaryDiffEq", v"0.6.0", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"0.6.0", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"0.6.0", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"0.6.0", "Juno", v"0.2.5"], - ["OrdinaryDiffEq", v"0.6.0", "NLsolve", v"0.7.3"], - ["OrdinaryDiffEq", v"0.6.0", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"0.6.0", "Ranges", v"0.0.1"], - ["OrdinaryDiffEq", v"0.6.0", "RecipesBase", v"0.1.0"], - ["OrdinaryDiffEq", v"0.6.0", "RecursiveArrayTools", v"0.0.2"], - ["OrdinaryDiffEq", v"1.0.2", "Calculus", v"0.1.15"], - ["OrdinaryDiffEq", v"1.0.2", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"1.0.2", "DataStructures", v"0.4.6"], - ["OrdinaryDiffEq", v"1.0.2", "DiffEqBase", v"0.6.0", v"0.8.0"], - ["OrdinaryDiffEq", v"1.0.2", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"1.0.2", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"1.0.2", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"1.0.2", "Juno", v"0.2.5"], - ["OrdinaryDiffEq", v"1.0.2", "NLsolve", v"0.9.1"], - ["OrdinaryDiffEq", v"1.0.2", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"1.0.2", "RecursiveArrayTools", v"0.1.2"], - ["OrdinaryDiffEq", v"1.0.2", "Roots", v"0.2.1"], - ["OrdinaryDiffEq", v"1.1.0", "Calculus", v"0.1.15"], - ["OrdinaryDiffEq", v"1.1.0", "DiffEqBase", v"0.7.0", v"0.8.0"], - ["OrdinaryDiffEq", v"1.1.0", "Iterators"], - ["OrdinaryDiffEq", v"1.1.0", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"1.1.0", "DataStructures", v"0.4.6"], - ["OrdinaryDiffEq", v"1.1.0", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"1.1.0", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"1.1.0", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"1.1.0", "Juno", v"0.2.5"], - ["OrdinaryDiffEq", v"1.1.0", "NLsolve", v"0.9.1"], - ["OrdinaryDiffEq", v"1.1.0", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"1.1.0", "RecursiveArrayTools", v"0.1.2"], - ["OrdinaryDiffEq", v"1.1.0", "Roots", v"0.2.1"], - ["OrdinaryDiffEq", v"1.3.1", "Calculus", v"0.1.15"], - ["OrdinaryDiffEq", v"1.3.1", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"1.3.1", "DataStructures", v"0.4.6"], - ["OrdinaryDiffEq", v"1.3.1", "DiffEqBase", v"0.8.0", v"0.15.0"], - ["OrdinaryDiffEq", v"1.3.1", "Iterators"], - ["OrdinaryDiffEq", v"1.3.1", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"1.3.1", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"1.3.1", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"1.3.1", "Juno", v"0.2.5"], - ["OrdinaryDiffEq", v"1.3.1", "NLsolve", v"0.9.1"], - ["OrdinaryDiffEq", v"1.3.1", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"1.3.1", "RecursiveArrayTools", v"0.2.0"], - ["OrdinaryDiffEq", v"1.3.1", "Roots", v"0.2.1"], - ["OrdinaryDiffEq", v"1.4.1", "Calculus", v"0.1.15"], - ["OrdinaryDiffEq", v"1.4.1", "Iterators"], - ["OrdinaryDiffEq", v"1.4.1", "Compat", v"0.8.8"], - ["OrdinaryDiffEq", v"1.4.1", "DataStructures", v"0.4.6"], - ["OrdinaryDiffEq", v"1.4.1", "DiffEqBase", v"0.11.0", v"0.15.0"], - ["OrdinaryDiffEq", v"1.4.1", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"1.4.1", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"1.4.1", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"1.4.1", "Juno", v"0.2.5"], - ["OrdinaryDiffEq", v"1.4.1", "NLsolve", v"0.9.1"], - ["OrdinaryDiffEq", v"1.4.1", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"1.4.1", "RecursiveArrayTools", v"0.2.0"], - ["OrdinaryDiffEq", v"1.4.1", "Roots", v"0.2.1"], - ["OrdinaryDiffEq", v"1.5.0", "Calculus", v"0.1.15"], - ["OrdinaryDiffEq", v"1.5.0", "Iterators"], - ["OrdinaryDiffEq", v"1.5.0", "Compat", v"0.17.0"], - ["OrdinaryDiffEq", v"1.5.0", "DataStructures", v"0.4.6"], - ["OrdinaryDiffEq", v"1.5.0", "DiffEqBase", v"0.11.0", v"0.15.0"], - ["OrdinaryDiffEq", v"1.5.0", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"1.5.0", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"1.5.0", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"1.5.0", "Juno", v"0.2.5"], - ["OrdinaryDiffEq", v"1.5.0", "NLsolve", v"0.9.1"], - ["OrdinaryDiffEq", v"1.5.0", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"1.5.0", "RecursiveArrayTools", v"0.2.0"], - ["OrdinaryDiffEq", v"1.5.0", "Roots", v"0.2.1"], - ["OrdinaryDiffEq", v"1.7.0", "Calculus", v"0.1.15"], - ["OrdinaryDiffEq", v"1.7.0", "Iterators"], - ["OrdinaryDiffEq", v"1.7.0", "Compat", v"0.17.0"], - ["OrdinaryDiffEq", v"1.7.0", "DataStructures", v"0.4.6"], - ["OrdinaryDiffEq", v"1.7.0", "DiffEqBase", v"0.13.0", v"0.15.0"], - ["OrdinaryDiffEq", v"1.7.0", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"1.7.0", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"1.7.0", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"1.7.0", "Juno", v"0.2.5"], - ["OrdinaryDiffEq", v"1.7.0", "NLsolve", v"0.9.1"], - ["OrdinaryDiffEq", v"1.7.0", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"1.7.0", "RecursiveArrayTools", v"0.2.0"], - ["OrdinaryDiffEq", v"1.7.0", "Roots", v"0.2.1"], - ["OrdinaryDiffEq", v"1.8.0", "Calculus", v"0.1.15"], - ["OrdinaryDiffEq", v"1.8.0", "DiffEqBase", v"0.15.0"], - ["OrdinaryDiffEq", v"1.8.0", "Iterators"], - ["OrdinaryDiffEq", v"1.8.0", "Compat", v"0.17.0"], - ["OrdinaryDiffEq", v"1.8.0", "DataStructures", v"0.4.6"], - ["OrdinaryDiffEq", v"1.8.0", "ForwardDiff", v"0.2.4"], - ["OrdinaryDiffEq", v"1.8.0", "GenericSVD", v"0.0.2"], - ["OrdinaryDiffEq", v"1.8.0", "InplaceOps", v"0.0.5"], - ["OrdinaryDiffEq", v"1.8.0", "Juno", v"0.2.5"], - ["OrdinaryDiffEq", v"1.8.0", "NLsolve", v"0.9.1"], - ["OrdinaryDiffEq", v"1.8.0", "Parameters", v"0.5.0"], - ["OrdinaryDiffEq", v"1.8.0", "RecursiveArrayTools", v"0.2.0"], - ["OrdinaryDiffEq", v"1.8.0", "Roots", v"0.2.1"], - ["PDMats", v"0.1.2", "NumericExtensions", v"0.5.0-"], - ["PDMats", v"0.2.5", "ArrayViews", v"0.4.0-"], - ["PDMats", v"0.3.0", "ArrayViews", v"0.4.8-"], - ["PDMats", v"0.3.1", "ArrayViews", v"0.4.8-"], - ["PDMats", v"0.3.6", "ArrayViews", v"0.4.8-"], - ["PDMats", v"0.4.0", "Compat", v"0.7.7"], - ["PDMats", v"0.4.1", "Compat", v"0.7.7"], - ["PDMats", v"0.4.2", "Compat", v"0.7.7"], - ["PDMats", v"0.5.3", "Compat", v"0.9.2"], - ["PDMats", v"0.5.4", "Compat", v"0.9.2"], - ["PDMats", v"0.5.5", "Compat", v"0.17.0"], - ["PDMats", v"0.5.6", "Compat", v"0.18.0"], - ["PDMats", v"0.6.0", "Compat", v"0.18.0"], - ["ParameterizedFunctions", v"0.0.1", "DataStructures", v"0.4.6"], - ["ParameterizedFunctions", v"0.0.1", "DiffEqBase", v"0.0.0", v"0.5.0"], - ["ParameterizedFunctions", v"0.0.1", "SymEngine", v"0.1.1"], - ["ParameterizedFunctions", v"0.1.1", "DataStructures", v"0.4.6"], - ["ParameterizedFunctions", v"0.1.1", "DiffEqBase", v"0.0.0", v"0.5.0"], - ["ParameterizedFunctions", v"0.1.1", "SymEngine", v"0.1.1"], - ["ParameterizedFunctions", v"0.2.2", "DataStructures", v"0.4.6"], - ["ParameterizedFunctions", v"0.2.2", "DiffEqBase", v"0.0.0", v"0.5.0"], - ["ParameterizedFunctions", v"0.2.2", "SymEngine", v"0.1.1"], - ["ParameterizedFunctions", v"0.3.1", "DataStructures", v"0.4.6"], - ["ParameterizedFunctions", v"0.3.1", "DiffEqBase", v"0.1.0", v"0.5.0"], - ["ParameterizedFunctions", v"0.3.1", "SymEngine", v"0.1.2"], - ["ParameterizedFunctions", v"0.3.2", "DataStructures", v"0.4.6"], - ["ParameterizedFunctions", v"0.3.2", "DiffEqBase", v"0.1.0", v"0.5.0"], - ["ParameterizedFunctions", v"0.3.2", "SymEngine", v"0.1.2"], - ["ParameterizedFunctions", v"0.3.3", "DataStructures", v"0.4.6"], - ["ParameterizedFunctions", v"0.3.3", "DiffEqBase", v"0.2.0", v"0.5.0"], - ["ParameterizedFunctions", v"0.3.3", "SymEngine", v"0.1.2"], - ["ParameterizedFunctions", v"0.4.2", "DataStructures", v"0.4.6"], - ["ParameterizedFunctions", v"0.4.2", "SimpleTraits", v"0.1.1"], - ["ParameterizedFunctions", v"0.4.2", "DiffEqBase", v"0.2.0", v"0.5.0"], - ["ParameterizedFunctions", v"0.4.2", "SymEngine", v"0.1.2"], - ["ParameterizedFunctions", v"0.5.1", "DataStructures", v"0.4.6"], - ["ParameterizedFunctions", v"0.5.1", "SimpleTraits", v"0.1.1"], - ["ParameterizedFunctions", v"0.5.1", "DiffEqBase", v"0.4.0", v"0.5.0"], - ["ParameterizedFunctions", v"0.5.1", "SymEngine", v"0.1.2"], - ["ParameterizedFunctions", v"1.2.0", "DataStructures", v"0.4.6"], - ["ParameterizedFunctions", v"1.2.0", "SimpleTraits", v"0.1.1"], - ["ParameterizedFunctions", v"1.2.0", "DiffEqBase", v"0.5.0", v"0.14.0"], - ["ParameterizedFunctions", v"1.2.0", "SymEngine", v"0.1.2"], - ["ParameterizedFunctions", v"1.3.0", "DataStructures", v"0.4.6"], - ["ParameterizedFunctions", v"1.3.0", "DiffEqBase", v"0.14.0"], - ["ParameterizedFunctions", v"1.3.0", "SimpleTraits", v"0.1.1"], - ["ParameterizedFunctions", v"1.3.0", "SymEngine", v"0.1.2"], - ["Parameters", v"0.5.0", "Compat", v"0.7.15"], - ["Parameters", v"0.5.0", "DataStructures", v"0.4.3"], - ["Parameters", v"0.6.0", "DataStructures", v"0.4.3"], - ["Parameters", v"0.7.1", "Compat", v"0.17.0"], - ["Parameters", v"0.7.1", "DataStructures", v"0.5.2"], - ["Parameters", v"0.7.2", "DataStructures", v"0.5.2"], - ["PlotThemes", v"0.1.1", "PlotUtils"], - ["PlotUtils", v"0.0.1"], - ["PlotUtils", v"0.3.0", "Colors"], - ["PlotUtils", v"0.3.0", "Reexport"], - ["Plots", v"0.1.0", "Colors"], - ["Plots", v"0.1.0", "FactCheck"], - ["Plots", v"0.1.0", "JSON", v"0.0.0", v"0.9.0"], - ["Plots", v"0.1.3", "Colors"], - ["Plots", v"0.1.3", "JSON", v"0.0.0", v"0.9.0"], - ["Plots", v"0.3.0", "Colors"], - ["Plots", v"0.3.0", "Reexport"], - ["Plots", v"0.3.0", "JSON", v"0.0.0", v"0.9.0"], - ["Plots", v"0.5.1", "Colors"], - ["Plots", v"0.5.1", "Compat"], - ["Plots", v"0.5.1", "Reexport"], - ["Plots", v"0.5.1", "JSON", v"0.0.0", v"0.9.0"], - ["Plots", v"0.5.2", "Colors"], - ["Plots", v"0.5.2", "Compat"], - ["Plots", v"0.5.2", "Reexport"], - ["Plots", v"0.5.2", "Requires"], - ["Plots", v"0.5.2", "JSON", v"0.0.0", v"0.9.0"], - ["Plots", v"0.6.1", "Colors"], - ["Plots", v"0.6.1", "Compat"], - ["Plots", v"0.6.1", "FixedSizeArrays"], - ["Plots", v"0.6.1", "Reexport"], - ["Plots", v"0.6.1", "Requires"], - ["Plots", v"0.6.1", "JSON", v"0.0.0", v"0.9.0"], - ["Plots", v"0.6.2", "Colors"], - ["Plots", v"0.6.2", "Compat"], - ["Plots", v"0.6.2", "FixedSizeArrays"], - ["Plots", v"0.6.2", "Reexport"], - ["Plots", v"0.6.2", "Requires"], - ["Plots", v"0.6.2", "JSON", v"0.0.0", v"0.9.0"], - ["Plots", v"0.6.2", "RecipesBase", v"0.0.1", v"0.0.2"], - ["Plots", v"0.7.5", "Colors"], - ["Plots", v"0.7.5", "Compat"], - ["Plots", v"0.7.5", "FixedSizeArrays"], - ["Plots", v"0.7.5", "Measures"], - ["Plots", v"0.7.5", "JSON", v"0.0.0", v"0.9.0"], - ["Plots", v"0.7.5", "RecipesBase"], - ["Plots", v"0.7.5", "Reexport"], - ["Plots", v"0.8.0", "Compat"], - ["Plots", v"0.8.0", "FixedSizeArrays"], - ["Plots", v"0.8.0", "Measures"], - ["Plots", v"0.8.0", "PlotUtils"], - ["Plots", v"0.8.0", "JSON", v"0.0.0", v"0.9.0"], - ["Plots", v"0.8.0", "RecipesBase"], - ["Plots", v"0.8.0", "Reexport"], - ["Plots", v"0.9.0", "Compat"], - ["Plots", v"0.9.0", "FixedSizeArrays"], - ["Plots", v"0.9.0", "Measures"], - ["Plots", v"0.9.0", "PlotUtils"], - ["Plots", v"0.9.0", "RecipesBase"], - ["Plots", v"0.9.0", "Reexport"], - ["Plots", v"0.9.0", "JSON", v"0.0.0", v"0.9.0"], - ["Plots", v"0.9.0", "Showoff"], - ["Plots", v"0.9.1", "Compat"], - ["Plots", v"0.9.1", "FixedSizeArrays"], - ["Plots", v"0.9.1", "Measures"], - ["Plots", v"0.9.1", "PlotUtils"], - ["Plots", v"0.9.1", "RecipesBase"], - ["Plots", v"0.9.1", "Reexport"], - ["Plots", v"0.9.1", "Showoff"], - ["Plots", v"0.9.3", "Compat"], - ["Plots", v"0.9.3", "FixedSizeArrays"], - ["Plots", v"0.9.3", "Measures"], - ["Plots", v"0.9.3", "PlotUtils"], - ["Plots", v"0.9.3", "RecipesBase"], - ["Plots", v"0.9.3", "Reexport"], - ["Plots", v"0.9.3", "Showoff"], - ["Plots", v"0.9.4", "FixedSizeArrays"], - ["Plots", v"0.9.4", "Measures"], - ["Plots", v"0.9.4", "PlotUtils"], - ["Plots", v"0.9.4", "RecipesBase"], - ["Plots", v"0.9.4", "Reexport"], - ["Plots", v"0.9.4", "Showoff"], - ["Plots", v"0.10.3", "FixedSizeArrays"], - ["Plots", v"0.10.3", "Measures"], - ["Plots", v"0.10.3", "PlotThemes"], - ["Plots", v"0.10.3", "PlotUtils"], - ["Plots", v"0.10.3", "RecipesBase"], - ["Plots", v"0.10.3", "Reexport"], - ["Plots", v"0.10.3", "Showoff"], - ["PolynomialFactors", v"0.0.1", "Combinatorics", v"0.2.1"], - ["PolynomialFactors", v"0.0.1", "Compat", v"0.7.15"], - ["PolynomialFactors", v"0.0.1", "Iterators", v"0.1.0"], - ["PolynomialFactors", v"0.0.1", "Primes", v"0.1.1"], - ["PolynomialFactors", v"0.0.2", "Combinatorics", v"0.2.1"], - ["PolynomialFactors", v"0.0.2", "Compat", v"0.7.15"], - ["PolynomialFactors", v"0.0.2", "Iterators", v"0.1.0"], - ["PolynomialFactors", v"0.0.2", "Polynomials", v"0.1.1"], - ["PolynomialFactors", v"0.0.2", "Primes", v"0.1.1"], - ["PolynomialFactors", v"0.0.4", "Combinatorics", v"0.2.1"], - ["PolynomialFactors", v"0.0.4", "Compat", v"0.7.15"], - ["PolynomialFactors", v"0.0.4", "Iterators", v"0.1.0"], - ["PolynomialFactors", v"0.0.4", "Polynomials", v"0.1.1"], - ["PolynomialFactors", v"0.0.4", "Primes", v"0.1.1"], - ["Polynomials", v"0.0.2"], - ["Polynomials", v"0.0.3"], - ["Polynomials", v"0.0.4", "Compat"], - ["Polynomials", v"0.0.5", "Compat"], - ["Polynomials", v"0.1.0", "Compat", v"0.7.15"], - ["Polynomials", v"0.1.1", "Compat", v"0.8.0"], - ["Polynomials", v"0.1.5", "Compat", v"0.9.4"], - ["PositiveFactorizations", v"0.0.1"], - ["PositiveFactorizations", v"0.0.3", "Compat", v"0.8.4"], - ["PositiveFactorizations", v"0.0.4", "Compat", v"0.12.0"], - ["PowerSeries", v"0.1.10"], - ["PowerSeries", v"0.1.14", "Compat", v"0.4.7"], - ["PowerSeries", v"0.2.0"], - ["Primes", v"0.1.0"], - ["Primes", v"0.1.1"], - ["Primes", v"0.1.3", "Compat", v"0.9.4"], - ["PyCall", v"0.4.10"], - ["PyCall", v"0.6.2", "Compat", v"0.2.0"], - ["PyCall", v"0.7.3", "Compat", v"0.2.0"], - ["PyCall", v"0.7.3", "Dates"], - ["PyCall", v"0.7.4", "Compat", v"0.3.1"], - ["PyCall", v"0.7.4", "Dates"], - ["PyCall", v"0.7.5", "Compat", v"0.3.4"], - ["PyCall", v"0.7.5", "Dates"], - ["PyCall", v"0.8.1", "Compat", v"0.4.0"], - ["PyCall", v"0.8.1", "Dates"], - ["PyCall", v"1.0.1", "Compat", v"0.4.6"], - ["PyCall", v"1.0.1", "Dates"], - ["PyCall", v"1.0.3", "Compat", v"0.7.1"], - ["PyCall", v"1.0.3", "Dates"], - ["PyCall", v"1.4.0", "Compat", v"0.7.1"], - ["PyCall", v"1.4.0", "Conda", v"0.1.6"], - ["PyCall", v"1.4.0", "Dates"], - ["PyCall", v"1.5.0", "Compat", v"0.7.15"], - ["PyCall", v"1.5.0", "Conda", v"0.1.6"], - ["PyCall", v"1.5.0", "MacroTools", v"0.2.0"], - ["PyCall", v"1.6.2", "Compat", v"0.7.15"], - ["PyCall", v"1.6.2", "Conda", v"0.2.0"], - ["PyCall", v"1.6.2", "MacroTools", v"0.2.0"], - ["PyCall", v"1.7.2", "Compat", v"0.8.0"], - ["PyCall", v"1.7.2", "Conda", v"0.2.0"], - ["PyCall", v"1.7.2", "MacroTools", v"0.2.0"], - ["PyCall", v"1.10.0", "Compat", v"0.9.5"], - ["PyCall", v"1.10.0", "Conda", v"0.2.0"], - ["PyCall", v"1.10.0", "MacroTools", v"0.2.0"], - ["PyCall", v"1.12.0", "Compat", v"0.18.0"], - ["PyCall", v"1.12.0", "Conda", v"0.2.0"], - ["PyCall", v"1.12.0", "MacroTools", v"0.2.0"], - ["PyDSTool", v"0.0.1", "DataStructures"], - ["PyDSTool", v"0.0.1", "PyCall"], - ["PyDSTool", v"0.0.2", "Conda"], - ["PyDSTool", v"0.0.2", "DataStructures"], - ["PyDSTool", v"0.0.2", "PyCall"], - ["PyDSTool", v"0.1.1", "Conda"], - ["PyDSTool", v"0.1.1", "DataStructures"], - ["PyDSTool", v"0.1.1", "DiffEqBase", v"0.11.0"], - ["PyDSTool", v"0.1.1", "PyCall"], - ["PyDSTool", v"0.1.1", "RecipesBase"], - ["PyDSTool", v"0.1.2", "DataStructures"], - ["PyDSTool", v"0.1.2", "PyCall"], - ["PyDSTool", v"0.1.2", "RecipesBase"], - ["PyDSTool", v"0.1.2", "Conda", v"0.2.0"], - ["PyDSTool", v"0.1.2", "DiffEqBase", v"0.11.0"], - ["QuadGK", v"0.1.0"], - ["QuadGK", v"0.1.2", "DataStructures", v"0.5.0"], - ["RangeArrays", v"0.1.1"], - ["RangeArrays", v"0.1.2", "Compat", v"0.19.0"], - ["Ranges", v"0.0.1"], - ["Ratios", v"0.0.3"], - ["Ratios", v"0.0.4", "Compat"], - ["Reactive", v"0.2.4", "FactCheck"], - ["Reactive", v"0.2.4", "Compat", v"0.4.0"], - ["Reactive", v"0.3.4", "Compat"], - ["Reactive", v"0.3.5", "Compat", v"0.9.2"], - ["Reactive", v"0.3.6"], - ["Reactive", v"0.3.7", "DataStructures"], - ["RecipesBase", v"0.1.0"], - ["RecursiveArrayTools", v"0.0.1"], - ["RecursiveArrayTools", v"0.1.1"], - ["RecursiveArrayTools", v"0.1.2"], - ["RecursiveArrayTools", v"0.2.0"], - ["Reexport", v"0.0.2"], - ["Reexport", v"0.0.3"], - ["Requires", v"0.2.3", "MacroTools"], - ["Requires", v"0.4.1"], - ["ResettableStacks", v"0.1.0"], - ["Rmath", v"0.1.0", "BinDeps"], - ["Rmath", v"0.1.2", "BinDeps"], - ["Rmath", v"0.1.2", "Compat", v"0.8.4"], - ["Rmath", v"0.1.6", "BinDeps"], - ["Rmath", v"0.1.6", "Compat", v"0.9.1"], - ["Roots", v"0.1.9", "Polynomials", v"0.0.3"], - ["Roots", v"0.1.9", "ForwardDiff", v"0.0.0", v"0.2.0"], - ["Roots", v"0.1.9", "PowerSeries", v"0.1.0"], - ["Roots", v"0.1.13", "Docile", v"0.4.0"], - ["Roots", v"0.1.13", "Polynomials", v"0.0.3"], - ["Roots", v"0.1.13", "ForwardDiff", v"0.0.0", v"0.2.0"], - ["Roots", v"0.1.13", "PowerSeries", v"0.1.11"], - ["Roots", v"0.1.18", "Compat", v"0.4.0"], - ["Roots", v"0.1.18", "Docile", v"0.4.0"], - ["Roots", v"0.1.18", "Polynomials", v"0.0.3"], - ["Roots", v"0.1.18", "ForwardDiff", v"0.0.0", v"0.2.0"], - ["Roots", v"0.1.18", "PowerSeries", v"0.1.11"], - ["Roots", v"0.1.22", "Compat", v"0.4.0"], - ["Roots", v"0.1.22", "Docile", v"0.4.0"], - ["Roots", v"0.1.22", "Polynomials", v"0.0.3"], - ["Roots", v"0.1.22", "ForwardDiff", v"0.0.0", v"0.2.0"], - ["Roots", v"0.1.26", "Compat", v"0.4.0"], - ["Roots", v"0.1.26", "Docile", v"0.4.0"], - ["Roots", v"0.1.26", "Polynomials", v"0.0.5"], - ["Roots", v"0.1.26", "ForwardDiff", v"0.0.0", v"0.2.0"], - ["Roots", v"0.2.0", "Primes"], - ["Roots", v"0.2.0", "Compat", v"0.4.0"], - ["Roots", v"0.2.0", "Docile", v"0.4.0"], - ["Roots", v"0.2.0", "ForwardDiff", v"0.2.0"], - ["Roots", v"0.2.0", "Polynomials", v"0.0.5"], - ["Roots", v"0.2.1", "Primes"], - ["Roots", v"0.2.1", "Compat", v"0.4.0"], - ["Roots", v"0.2.1", "ForwardDiff", v"0.2.0"], - ["Roots", v"0.2.1", "Polynomials", v"0.0.5"], - ["Roots", v"0.3.0", "Compat", v"0.8.0"], - ["Roots", v"0.3.0", "ForwardDiff", v"0.2.0"], - ["Roots", v"0.3.0", "PolynomialFactors", v"0.0.3"], - ["Roots", v"0.3.0", "Polynomials", v"0.0.5"], - ["Rotations", v"0.3.4", "StaticArrays", v"0.0.3", v"0.3.0-"], - ["Rotations", v"0.3.5", "StaticArrays", v"0.3.0", v"0.4.0-"], - ["Rotations", v"0.4.0", "StaticArrays", v"0.4.0", v"0.5.0-"], - ["SHA", v"0.0.2"], - ["SHA", v"0.0.3"], - ["SHA", v"0.2.0", "Compat", v"0.3.5"], - ["SHA", v"0.2.1", "Compat", v"0.7.9"], - ["SHA", v"0.3.1", "Compat", v"0.9.4"], - ["SHA", v"0.3.2", "Compat", v"0.17.0"], - ["SIUnits", v"0.0.5", "TexExtensions"], - ["SIUnits", v"0.0.6", "Compat"], - ["SIUnits", v"0.0.6", "TexExtensions"], - ["SIUnits", v"0.1.0", "TexExtensions"], - ["SIUnits", v"0.1.0", "Compat", v"0.8.0"], - ["ShowItLikeYouBuildIt", v"0.0.1"], - ["Showoff", v"0.0.1"], - ["Showoff", v"0.0.3", "Iterators"], - ["Showoff", v"0.0.7", "Compat"], - ["Showoff", v"0.0.7", "Iterators"], - ["Showoff", v"0.1.0", "Compat", v"0.9.5"], - ["Showoff", v"0.1.1", "Compat", v"0.18.0"], - ["SimpleTraits", v"0.1.0", "Compat"], - ["SimpleTraits", v"0.1.1"], - ["SimpleTraits", v"0.2.0", "MacroTools", v"0.3.2"], - ["SimpleTraits", v"0.4.0", "Compat", v"0.19.0"], - ["SimpleTraits", v"0.4.0", "MacroTools", v"0.3.2"], - ["SortingAlgorithms", v"0.0.3"], - ["SortingAlgorithms", v"0.0.6", "Compat"], - ["SortingAlgorithms", v"0.1.0", "Compat", v"0.8.4"], - ["SortingAlgorithms", v"0.1.1", "Compat", v"0.9.4"], - ["SortingAlgorithms", v"0.1.1", "DataStructures", v"0.5.3"], - ["SpecialFunctions", v"0.0.1", "Compat", v"0.9.1"], - ["SpecialFunctions", v"0.1.0", "Compat", v"0.9.1"], - ["SpecialFunctions", v"0.1.1", "Compat", v"0.18.0"], - ["StaticArrays", v"0.0.2"], - ["StaticArrays", v"0.0.4"], - ["StaticArrays", v"0.2.1"], - ["StaticArrays", v"0.3.0"], - ["StaticArrays", v"0.4.0"], - ["Stats", v"0.0.1", "StatsBase", v"0.3.0-"], - ["Stats", v"0.1.0", "StatsBase"], - ["StatsBase", v"0.2.4", "NumericExtensions"], - ["StatsBase", v"0.2.9"], - ["StatsBase", v"0.3.9"], - ["StatsBase", v"0.4.1"], - ["StatsBase", v"0.6.8", "ArrayViews", v"0.4.6-"], - ["StatsBase", v"0.6.9", "ArrayViews", v"0.4.8-"], - ["StatsBase", v"0.6.10", "ArrayViews", v"0.4.8-"], - ["StatsBase", v"0.6.12", "ArrayViews", v"0.4.8-"], - ["StatsBase", v"0.6.12", "Compat", v"0.2.11-"], - ["StatsBase", v"0.6.13", "ArrayViews", v"0.4.10"], - ["StatsBase", v"0.6.13", "Compat", v"0.3.2"], - ["StatsBase", v"0.6.16", "ArrayViews", v"0.4.12"], - ["StatsBase", v"0.6.16", "Compat", v"0.4.0"], - ["StatsBase", v"0.7.4", "ArrayViews", v"0.4.12"], - ["StatsBase", v"0.7.4", "Compat", v"0.4.0"], - ["StatsBase", v"0.7.4", "StatsFuns", v"0.1.0"], - ["StatsBase", v"0.8.1", "ArrayViews", v"0.4.12"], - ["StatsBase", v"0.8.1", "Compat", v"0.4.0"], - ["StatsBase", v"0.8.1", "StatsFuns", v"0.1.0"], - ["StatsBase", v"0.8.2", "ArrayViews", v"0.4.12"], - ["StatsBase", v"0.8.2", "Compat", v"0.4.0"], - ["StatsBase", v"0.8.2", "StatsFuns", v"0.1.0"], - ["StatsBase", v"0.8.3", "Compat", v"0.8.4"], - ["StatsBase", v"0.8.3", "StatsFuns", v"0.1.0"], - ["StatsBase", v"0.9.0", "Compat", v"0.8.4"], - ["StatsBase", v"0.9.0", "StatsFuns", v"0.3.0"], - ["StatsBase", v"0.10.0", "Compat", v"0.8.4"], - ["StatsBase", v"0.12.0", "Compat", v"0.8.4"], - ["StatsBase", v"0.13.0", "Compat", v"0.13.0"], - ["StatsBase", v"0.13.0", "DataStructures", v"0.5.0"], - ["StatsBase", v"0.13.1", "Compat", v"0.18.0"], - ["StatsBase", v"0.13.1", "DataStructures", v"0.5.0"], - ["StatsBase", v"0.13.1", "SpecialFunctions", v"0.1.0"], - ["StatsFuns", v"0.0.3", "Compat", v"0.4.0"], - ["StatsFuns", v"0.1.0", "Compat", v"0.4.0"], - ["StatsFuns", v"0.2.1", "Compat", v"0.4.0"], - ["StatsFuns", v"0.2.2", "Compat", v"0.7.18"], - ["StatsFuns", v"0.3.0", "Compat", v"0.8.4"], - ["StatsFuns", v"0.3.0", "Rmath", v"0.1.0"], - ["StatsFuns", v"0.4.0", "Compat", v"0.9.1"], - ["StatsFuns", v"0.4.0", "Rmath", v"0.1.0"], - ["StatsFuns", v"0.5.0", "SpecialFunctions"], - ["StatsFuns", v"0.5.0", "Compat", v"0.9.1"], - ["StatsFuns", v"0.5.0", "Rmath", v"0.1.0"], - ["StochasticDiffEq", v"0.0.3", "ChunkedArrays", v"0.1.0"], - ["StochasticDiffEq", v"0.0.3", "DiffEqBase", v"0.0.0", v"0.8.0"], - ["StochasticDiffEq", v"0.0.3", "ParameterizedFunctions", v"0.1.0"], - ["StochasticDiffEq", v"0.0.3", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"0.0.4", "RecursiveArrayTools"], - ["StochasticDiffEq", v"0.0.4", "ChunkedArrays", v"0.1.0"], - ["StochasticDiffEq", v"0.0.4", "DiffEqBase", v"0.0.0", v"0.8.0"], - ["StochasticDiffEq", v"0.0.4", "ParameterizedFunctions", v"0.1.0"], - ["StochasticDiffEq", v"0.0.4", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"0.0.5", "RecursiveArrayTools"], - ["StochasticDiffEq", v"0.0.5", "ChunkedArrays", v"0.1.0"], - ["StochasticDiffEq", v"0.0.5", "DiffEqBase", v"0.0.0", v"0.8.0"], - ["StochasticDiffEq", v"0.0.5", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"0.2.0", "ChunkedArrays", v"0.1.0"], - ["StochasticDiffEq", v"0.2.0", "DiffEqBase", v"0.2.0", v"0.8.0"], - ["StochasticDiffEq", v"0.2.0", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"0.2.0", "RecursiveArrayTools", v"0.0.2"], - ["StochasticDiffEq", v"0.3.0", "ChunkedArrays", v"0.1.0"], - ["StochasticDiffEq", v"0.3.0", "DataStructures"], - ["StochasticDiffEq", v"0.3.0", "DiffEqBase", v"0.2.0", v"0.8.0"], - ["StochasticDiffEq", v"0.3.0", "Juno"], - ["StochasticDiffEq", v"0.3.0", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"0.3.0", "RecursiveArrayTools", v"0.0.2"], - ["StochasticDiffEq", v"0.3.0", "ResettableStacks"], - ["StochasticDiffEq", v"0.5.0", "ChunkedArrays", v"0.1.0"], - ["StochasticDiffEq", v"0.5.0", "DataStructures", v"0.4.6"], - ["StochasticDiffEq", v"0.5.0", "DiffEqBase", v"0.4.0", v"0.8.0"], - ["StochasticDiffEq", v"0.5.0", "Juno", v"0.2.5"], - ["StochasticDiffEq", v"0.5.0", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"0.5.0", "RecursiveArrayTools", v"0.1.2"], - ["StochasticDiffEq", v"0.5.0", "ResettableStacks", v"0.0.1"], - ["StochasticDiffEq", v"1.0.2", "Iterators"], - ["StochasticDiffEq", v"1.0.2", "Roots"], - ["StochasticDiffEq", v"1.0.2", "DataStructures", v"0.4.6"], - ["StochasticDiffEq", v"1.0.2", "DiffEqBase", v"0.8.0", v"0.15.0"], - ["StochasticDiffEq", v"1.0.2", "Juno", v"0.2.5"], - ["StochasticDiffEq", v"1.0.2", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"1.0.2", "RecursiveArrayTools", v"0.2.0"], - ["StochasticDiffEq", v"1.0.2", "ResettableStacks", v"0.0.1"], - ["StochasticDiffEq", v"1.1.0", "Iterators"], - ["StochasticDiffEq", v"1.1.0", "Roots"], - ["StochasticDiffEq", v"1.1.0", "DataStructures", v"0.4.6"], - ["StochasticDiffEq", v"1.1.0", "DiffEqBase", v"0.11.0", v"0.15.0"], - ["StochasticDiffEq", v"1.1.0", "Juno", v"0.2.5"], - ["StochasticDiffEq", v"1.1.0", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"1.1.0", "RecursiveArrayTools", v"0.2.0"], - ["StochasticDiffEq", v"1.1.0", "ResettableStacks", v"0.0.1"], - ["StochasticDiffEq", v"1.2.1", "Compat", v"0.17.0"], - ["StochasticDiffEq", v"1.2.1", "Iterators"], - ["StochasticDiffEq", v"1.2.1", "Roots"], - ["StochasticDiffEq", v"1.2.1", "DataStructures", v"0.4.6"], - ["StochasticDiffEq", v"1.2.1", "DiffEqBase", v"0.11.0", v"0.15.0"], - ["StochasticDiffEq", v"1.2.1", "Juno", v"0.2.5"], - ["StochasticDiffEq", v"1.2.1", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"1.2.1", "RecursiveArrayTools", v"0.2.0"], - ["StochasticDiffEq", v"1.2.1", "ResettableStacks", v"0.0.1"], - ["StochasticDiffEq", v"1.3.0", "Compat", v"0.17.0"], - ["StochasticDiffEq", v"1.3.0", "Iterators"], - ["StochasticDiffEq", v"1.3.0", "Roots"], - ["StochasticDiffEq", v"1.3.0", "DataStructures", v"0.4.6"], - ["StochasticDiffEq", v"1.3.0", "DiffEqBase", v"0.13.0", v"0.15.0"], - ["StochasticDiffEq", v"1.3.0", "Juno", v"0.2.5"], - ["StochasticDiffEq", v"1.3.0", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"1.3.0", "RecursiveArrayTools", v"0.2.0"], - ["StochasticDiffEq", v"1.3.0", "ResettableStacks", v"0.0.1"], - ["StochasticDiffEq", v"1.4.0", "Compat", v"0.17.0"], - ["StochasticDiffEq", v"1.4.0", "DiffEqBase", v"0.15.0"], - ["StochasticDiffEq", v"1.4.0", "Iterators"], - ["StochasticDiffEq", v"1.4.0", "Roots"], - ["StochasticDiffEq", v"1.4.0", "DataStructures", v"0.4.6"], - ["StochasticDiffEq", v"1.4.0", "Juno", v"0.2.5"], - ["StochasticDiffEq", v"1.4.0", "Parameters", v"0.5.0"], - ["StochasticDiffEq", v"1.4.0", "RecursiveArrayTools", v"0.2.0"], - ["StochasticDiffEq", v"1.4.0", "ResettableStacks", v"0.0.1"], - ["StokesDiffEq", v"0.0.1", "DiffEqBase"], - ["StokesDiffEq", v"0.0.1", "Parameters", v"0.5.0"], - ["StokesDiffEq", v"0.0.1", "VectorizedRoutines", v"0.0.1"], - ["StokesDiffEq", v"0.0.2", "DiffEqBase"], - ["StokesDiffEq", v"0.0.2", "Parameters", v"0.5.0"], - ["StokesDiffEq", v"0.0.2", "VectorizedRoutines", v"0.0.1"], - ["StokesDiffEq", v"0.1.0", "DiffEqBase", v"0.4.0"], - ["StokesDiffEq", v"0.1.0", "Parameters", v"0.5.0"], - ["StokesDiffEq", v"0.1.0", "VectorizedRoutines", v"0.0.2"], - ["StrPack", v"0.0.1"], - ["StructIO", v"0.0.2"], - ["Sundials", v"0.0.0"], - ["Sundials", v"0.1.2", "BinDeps"], - ["Sundials", v"0.2.0", "BinDeps", v"0.3.0"], - ["Sundials", v"0.2.2", "Compat"], - ["Sundials", v"0.2.2", "BinDeps", v"0.3.0"], - ["Sundials", v"0.3.0", "BinDeps", v"0.4.3"], - ["Sundials", v"0.3.0", "Compat", v"0.9.0"], - ["Sundials", v"0.4.0", "BinDeps", v"0.4.3"], - ["Sundials", v"0.4.0", "Compat", v"0.9.0"], - ["Sundials", v"0.4.0", "DiffEqBase", v"0.0.0", v"0.2.0"], - ["Sundials", v"0.9.0", "BinDeps", v"0.4.3"], - ["Sundials", v"0.9.0", "Compat", v"0.9.0"], - ["Sundials", v"0.9.0", "DiffEqBase", v"0.2.0", v"0.15.0"], - ["Sundials", v"0.10.0", "BinDeps", v"0.4.3"], - ["Sundials", v"0.10.0", "Compat", v"0.9.0"], - ["Sundials", v"0.10.0", "DiffEqBase", v"0.15.0"], - ["SymEngine", v"0.1.0", "BinDeps"], - ["SymEngine", v"0.1.0", "Conda"], - ["SymEngine", v"0.1.0", "Compat", v"0.8.5"], - ["SymEngine", v"0.1.0", "RecipesBase", v"0.0.6"], - ["SymEngine", v"0.1.1", "BinDeps", v"0.4.0"], - ["SymEngine", v"0.1.1", "Compat", v"0.8.5"], - ["SymEngine", v"0.1.1", "Conda", v"0.3.0"], - ["SymEngine", v"0.1.1", "RecipesBase", v"0.0.6"], - ["SymEngine", v"0.1.2", "BinDeps", v"0.4.0"], - ["SymEngine", v"0.1.2", "Compat", v"0.8.5"], - ["SymEngine", v"0.1.2", "Conda", v"0.4.0"], - ["SymEngine", v"0.1.2", "RecipesBase", v"0.0.6"], - ["SymEngine", v"0.1.5", "BinDeps", v"0.4.0"], - ["SymEngine", v"0.1.5", "Compat", v"0.9.5"], - ["SymEngine", v"0.1.5", "Conda", v"0.4.0"], - ["SymEngine", v"0.1.5", "RecipesBase", v"0.0.6"], - ["TerminalUI", v"0.0.1", "Reactive"], - ["TerminalUI", v"0.0.1", "VT100"], - ["TerminalUI", v"0.0.2", "AbstractTrees"], - ["TerminalUI", v"0.0.2", "Colors"], - ["TerminalUI", v"0.0.2", "Compat"], - ["TerminalUI", v"0.0.2", "FixedPointNumbers"], - ["TerminalUI", v"0.0.2", "Reactive"], - ["TerminalUI", v"0.0.2", "VT100"], - ["TexExtensions", v"0.0.2"], - ["TexExtensions", v"0.0.3", "Compat"], - ["TextWrap", v"0.0.0", "Options"], - ["TextWrap", v"0.1.3"], - ["TextWrap", v"0.1.4"], - ["TextWrap", v"0.1.5", "Compat", v"0.7.3"], - ["TextWrap", v"0.1.6", "Compat", v"0.7.15"], - ["TextWrap", v"0.2.0", "Compat", v"0.9.5"], - ["TiledIteration", v"0.0.2", "OffsetArrays"], - ["URIParser", v"0.0.4", "Compat"], - ["URIParser", v"0.0.5", "Compat", v"0.3.5"], - ["URIParser", v"0.1.0", "HttpCommon"], - ["URIParser", v"0.1.0", "Compat", v"0.3.5"], - ["URIParser", v"0.1.3"], - ["URIParser", v"0.1.6", "Compat", v"0.8.0"], - ["URIParser", v"0.1.8", "Compat", v"0.9.5"], - ["VT100", v"0.0.1", "Colors"], - ["VT100", v"0.0.1", "Compat"], - ["VT100", v"0.0.1", "FixedPointNumbers"], - ["VT100", v"0.0.2", "Colors"], - ["VT100", v"0.0.2", "FixedPointNumbers"], - ["VT100", v"0.0.2", "Compat", v"0.7.15"], - ["VT100", v"0.1.0", "ColorTypes", v"0.3.4"], - ["VT100", v"0.1.0", "Compat", v"0.17.0"], - ["VT100", v"0.1.0", "FixedPointNumbers", v"0.3.0"], - ["VectorizedRoutines", v"0.0.1", "Distributions"], - ["VectorizedRoutines", v"0.0.1", "StatsFuns"], - ["VectorizedRoutines", v"0.0.2", "Distributions"], - ["WebSockets", v"0.0.0", "HttpCommon"], - ["WebSockets", v"0.0.0", "HttpServer"], - ["WebSockets", v"0.0.1"], - ["WebSockets", v"0.0.3", "Codecs"], - ["WebSockets", v"0.0.3", "HttpCommon"], - ["WebSockets", v"0.0.3", "HttpServer"], - ["WebSockets", v"0.0.5", "Codecs"], - ["WebSockets", v"0.0.5", "HttpCommon", v"0.0.3-"], - ["WebSockets", v"0.0.5", "HttpServer", v"0.0.4-"], - ["WebSockets", v"0.0.6", "Codecs"], - ["WebSockets", v"0.0.6", "Nettle"], - ["WebSockets", v"0.0.6", "HttpCommon", v"0.0.3-"], - ["WebSockets", v"0.0.6", "HttpServer", v"0.0.4-"], - ["WebSockets", v"0.1.0", "Codecs"], - ["WebSockets", v"0.1.0", "Compat"], - ["WebSockets", v"0.1.0", "Nettle"], - ["WebSockets", v"0.1.0", "HttpCommon", v"0.0.3"], - ["WebSockets", v"0.1.0", "HttpServer", v"0.0.4"], - ["WebSockets", v"0.1.2", "Codecs"], - ["WebSockets", v"0.1.2", "Compat"], - ["WebSockets", v"0.1.2", "HttpCommon", v"0.0.3"], - ["WebSockets", v"0.1.2", "HttpServer", v"0.0.4"], - ["WebSockets", v"0.1.2", "Nettle", v"0.2.0"], - ["WebSockets", v"0.2.1", "Codecs"], - ["WebSockets", v"0.2.1", "MbedTLS"], - ["WebSockets", v"0.2.1", "Compat", v"0.7.16"], - ["WebSockets", v"0.2.1", "HttpCommon", v"0.0.3"], - ["WebSockets", v"0.2.1", "HttpServer", v"0.0.4"], - ["WoodburyMatrices", v"0.0.2"], - ["WoodburyMatrices", v"0.1.3", "Docile"], - ["WoodburyMatrices", v"0.1.4", "Compat"], - ["WoodburyMatrices", v"0.1.4", "Docile"], - ["WoodburyMatrices", v"0.1.5", "Compat"], - ["WoodburyMatrices", v"0.1.5", "Docile"], - ["WoodburyMatrices", v"0.2.1", "Compat"], - ["WoodburyMatrices", v"0.2.2", "Compat", v"0.7.19"], - ["Zlib", v"0.1.9"], - ["Zlib", v"0.1.12", "Compat"], -] - -problematic_data = Any[ - ("CoordinateTransformations", v"0.2.0"), - ("Plots", v"0.6.2"), - ("Roots", v"0.1.9"), - ("Roots", v"0.1.13"), - ("Roots", v"0.1.18"), - ("Roots", v"0.1.22"), - ("Roots", v"0.1.26"), -] - -reqs_data = Any[ - ["Atom"], - ["DifferentialEquations"], - ["ImageMagick"], - ["Plots"], -] - -want_data = Dict( - "ASTInterpreter"=>v"0.0.4", - "AbstractTrees"=>v"0.0.4", - "AlgebraicDiffEq"=>v"0.1.0", - "ArgParse"=>v"0.4.0", - "Atom"=>v"0.5.10", - "AxisAlgorithms"=>v"0.1.6", - "AxisArrays"=>v"0.1.2", - "BinDeps"=>v"0.4.7", - "Blink"=>v"0.5.1", - "COFF"=>v"0.0.2", - "CRC"=>v"1.2.0", - "Calculus"=>v"0.2.2", - "CatIndices"=>v"0.0.2", - "ChunkedArrays"=>v"0.1.1", - "CodeTools"=>v"0.4.3", - "Codecs"=>v"0.3.0", - "ColorTypes"=>v"0.4.1", - "ColorVectorSpace"=>v"0.4.2", - "Colors"=>v"0.7.3", - "Combinatorics"=>v"0.4.0", - "Compat"=>v"0.24.0", - "ComputationalResources"=>v"0.0.2", - "Conda"=>v"0.5.3", - "CoordinateTransformations"=>v"0.4.1", - "CustomUnitRanges"=>v"0.0.4", - "DWARF"=>v"0.1.0", - "DataStructures"=>v"0.5.3", - "DelayDiffEq"=>v"0.3.0", - "DiffBase"=>v"0.1.0", - "DiffEqBase"=>v"0.15.0", - "DiffEqBiological"=>v"0.0.1", - "DiffEqCallbacks"=>v"0.0.2", - "DiffEqDevTools"=>v"0.7.0", - "DiffEqFinancial"=>v"0.1.0", - "DiffEqJump"=>v"0.3.0", - "DiffEqMonteCarlo"=>v"0.2.0", - "DiffEqPDEBase"=>v"0.2.0", - "DiffEqParamEstim"=>v"0.2.0", - "DiffEqSensitivity"=>v"0.1.0", - "DifferentialEquations"=>v"1.10.1", - "Distances"=>v"0.4.1", - "Distributions"=>v"0.12.5", - "DualNumbers"=>v"0.3.0", - "ELF"=>v"0.1.0", - "EllipsisNotation"=>v"0.1.0", - "FFTViews"=>v"0.0.2", - "FileIO"=>v"0.3.1", - "FiniteElementDiffEq"=>v"0.3.0", - "FixedPointNumbers"=>v"0.3.6", - "FixedSizeArrays"=>v"0.2.5", - "ForwardDiff"=>v"0.4.2", - "Gallium"=>v"0.0.4", - "GenericSVD"=>v"0.0.2", - "Graphics"=>v"0.2.0", - "Hiccup"=>v"0.1.1", - "HttpCommon"=>v"0.2.7", - "HttpParser"=>v"0.2.0", - "HttpServer"=>v"0.2.0", - "ImageAxes"=>v"0.2.1", - "ImageCore"=>v"0.3.0", - "ImageFiltering"=>v"0.1.4", - "ImageMagick"=>v"0.2.4", - "ImageMetadata"=>v"0.2.3", - "ImageTransformations"=>v"0.2.2", - "Images"=>v"0.9.1", - "IndirectArrays"=>v"0.1.1", - "InplaceOps"=>v"0.1.0", - "Interpolations"=>v"0.5.0", - "IntervalSets"=>v"0.0.5", - "IterativeSolvers"=>v"0.2.2", - "Iterators"=>v"0.3.0", - "JSON"=>v"0.9.0", - "JuliaParser"=>v"0.7.4", - "Juno"=>v"0.2.7", - "LNR"=>v"0.0.2", - "Lazy"=>v"0.11.6", - "LearnBase"=>v"0.1.5", - "LineSearches"=>v"0.1.5", - "LossFunctions"=>v"0.1.0", - "LsqFit"=>v"0.2.0", - "MachO"=>v"0.0.4", - "MacroTools"=>v"0.3.6", - "MappedArrays"=>v"0.0.7", - "MbedTLS"=>v"0.4.5", - "Measures"=>v"0.1.0", - "Media"=>v"0.2.7", - "MultiScaleArrays"=>v"0.1.0", - "Mustache"=>v"0.1.4", - "Mux"=>v"0.2.3", - "NLsolve"=>v"0.9.1", - "NaNMath"=>v"0.2.4", - "ObjFileBase"=>v"0.0.4", - "OffsetArrays"=>v"0.3.0", - "Optim"=>v"0.7.8", - "OrdinaryDiffEq"=>v"1.8.0", - "PDMats"=>v"0.6.0", - "ParameterizedFunctions"=>v"1.3.0", - "Parameters"=>v"0.7.2", - "PlotThemes"=>v"0.1.1", - "PlotUtils"=>v"0.3.0", - "Plots"=>v"0.10.3", - "PolynomialFactors"=>v"0.0.4", - "Polynomials"=>v"0.1.5", - "PositiveFactorizations"=>v"0.0.4", - "Primes"=>v"0.1.3", - "QuadGK"=>v"0.1.2", - "RangeArrays"=>v"0.1.2", - "Ranges"=>v"0.0.1", - "Ratios"=>v"0.0.4", - "Reactive"=>v"0.3.7", - "RecipesBase"=>v"0.1.0", - "RecursiveArrayTools"=>v"0.2.0", - "Reexport"=>v"0.0.3", - "ResettableStacks"=>v"0.1.0", - "Rmath"=>v"0.1.6", - "Roots"=>v"0.3.0", - "Rotations"=>v"0.4.0", - "SHA"=>v"0.3.2", - "SIUnits"=>v"0.1.0", - "ShowItLikeYouBuildIt"=>v"0.0.1", - "Showoff"=>v"0.1.1", - "SimpleTraits"=>v"0.4.0", - "SpecialFunctions"=>v"0.1.1", - "StaticArrays"=>v"0.4.0", - "StatsBase"=>v"0.13.1", - "StatsFuns"=>v"0.5.0", - "StochasticDiffEq"=>v"1.4.0", - "StokesDiffEq"=>v"0.1.0", - "StructIO"=>v"0.0.2", - "Sundials"=>v"0.10.0", - "SymEngine"=>v"0.1.5", - "TerminalUI"=>v"0.0.2", - "TexExtensions"=>v"0.0.3", - "TextWrap"=>v"0.2.0", - "TiledIteration"=>v"0.0.2", - "URIParser"=>v"0.1.8", - "VT100"=>v"0.1.0", - "VectorizedRoutines"=>v"0.0.2", - "WebSockets"=>v"0.2.1", - "WoodburyMatrices"=>v"0.2.2", -) diff --git a/stdlib/OldPkg/test/runtests.jl b/stdlib/OldPkg/test/runtests.jl deleted file mode 100644 index 036a76a73bb3f..0000000000000 --- a/stdlib/OldPkg/test/runtests.jl +++ /dev/null @@ -1,4 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -include("pkg.jl") -include("resolve.jl") diff --git a/stdlib/OldPkg/test/testgroups b/stdlib/OldPkg/test/testgroups deleted file mode 100644 index 3d2ccfc5960cb..0000000000000 --- a/stdlib/OldPkg/test/testgroups +++ /dev/null @@ -1,2 +0,0 @@ -pkg -resolve diff --git a/stdlib/Pkg/bin/gitmeta.jl b/stdlib/Pkg/bin/gitmeta.jl index 060b4b360bf05..37f973e43c455 100644 --- a/stdlib/Pkg/bin/gitmeta.jl +++ b/stdlib/Pkg/bin/gitmeta.jl @@ -20,7 +20,6 @@ const STDLIBS = sort!(by = lowercase, [ "Logging" "Markdown" "Mmap" - "OldPkg" "Pkg" "Printf" "Profile" diff --git a/stdlib/Pkg/bin/stdlib.toml b/stdlib/Pkg/bin/stdlib.toml index 20e404585d6ba..b01074807ec8c 100644 --- a/stdlib/Pkg/bin/stdlib.toml +++ b/stdlib/Pkg/bin/stdlib.toml @@ -14,7 +14,6 @@ STDLIBS = [ "Logging", "Markdown", "Mmap", - "OldPkg", "Pkg", "Printf", "Profile", diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl index 8187150114c7a..f8a3b4d0d7101 100644 --- a/stdlib/REPL/test/replcompletions.jl +++ b/stdlib/REPL/test/replcompletions.jl @@ -3,7 +3,6 @@ using REPL.REPLCompletions using Test using Random -import OldPkg let ex = quote module CompletionFoo @@ -86,23 +85,6 @@ let ex = quote Core.eval(Main, ex) end -function temp_pkg_dir_noinit(fn::Function) - # Used in tests below to set up and tear down a sandboxed package directory - # Unlike the version in test/pkg.jl, this does not run OldPkg.init so does not - # clone METADATA (only Pkg and LibGit2 tests should need internet access) - tmpdir = joinpath(tempdir(),randstring()) - withenv("JULIA_PKGDIR" => tmpdir) do - @test !isdir(OldPkg.dir()) - try - mkpath(OldPkg.dir()) - @test isdir(OldPkg.dir()) - fn() - finally - rm(tmpdir, recursive=true) - end - end -end - function map_completion_text(completions) c, r, res = completions return map(completion_text, c), r, res @@ -501,39 +483,6 @@ let s = "#=\nmax" end # Test completion of packages -mkp(p) = ((@assert !isdir(p)); mkpath(p)) -temp_pkg_dir_noinit() do - push!(LOAD_PATH, OldPkg.dir()) - try - # Complete /src/.jl and .jl/src/.jl - # but not / if no corresponding .jl file is found - pkg_dir = OldPkg.dir("CompletionFooPackage", "src") - mkp(pkg_dir) - touch(joinpath(pkg_dir, "CompletionFooPackage.jl")) - - pkg_dir = OldPkg.dir("CompletionFooPackage2.jl", "src") - mkp(pkg_dir) - touch(joinpath(pkg_dir, "CompletionFooPackage2.jl")) - - touch(OldPkg.dir("CompletionFooPackage3.jl")) - - mkp(OldPkg.dir("CompletionFooPackageNone")) - mkp(OldPkg.dir("CompletionFooPackageNone2.jl")) - - s = "using Completion" - c,r = test_complete(s) - @test "CompletionFoo" in c #The module - @test "CompletionFooPackage" in c #The package - @test "CompletionFooPackage2" in c #The package - @test "CompletionFooPackage3" in c #The package - @test !("CompletionFooPackageNone" in c) #The package - @test !("CompletionFooPackageNone2" in c) #The package - @test s[r] == "Completion" - finally - @test pop!(LOAD_PATH) == OldPkg.dir() - end -end - path = joinpath(tempdir(),randstring()) pushfirst!(LOAD_PATH, path) try diff --git a/test/choosetests.jl b/test/choosetests.jl index 65fb53e60c69b..ab69d402ba801 100644 --- a/test/choosetests.jl +++ b/test/choosetests.jl @@ -159,7 +159,6 @@ function choosetests(choices = []) filter!(!in(skip_tests), tests) - explicit_pkg = "OldPkg/pkg" in tests explicit_pkg3 = "Pkg/pkg" in tests explicit_libgit2 = "LibGit2/online" in tests new_tests = String[] @@ -177,7 +176,6 @@ function choosetests(choices = []) end filter!(x -> (x != "stdlib" && !(x in STDLIBS)) , tests) append!(tests, new_tests) - explicit_pkg || filter!(x -> x != "OldPkg/pkg", tests) explicit_pkg3 || filter!(x -> x != "Pkg/pkg", tests) explicit_libgit2 || filter!(x -> x != "LibGit2/online", tests) diff --git a/test/precompile.jl b/test/precompile.jl index fa44c465960aa..df0883dfa5fa6 100644 --- a/test/precompile.jl +++ b/test/precompile.jl @@ -235,7 +235,7 @@ try [:Base64, :CRC32c, :Dates, :DelimitedFiles, :Distributed, :FileWatching, :Markdown, :Future, :Libdl, :LinearAlgebra, :Logging, :Mmap, :Printf, :Profile, :Random, :Serialization, :SharedArrays, :SparseArrays, :SuiteSparse, :Test, - :Unicode, :REPL, :InteractiveUtils, :OldPkg, :Pkg, :LibGit2, :SHA, :UUIDs, :Sockets, + :Unicode, :REPL, :InteractiveUtils, :Pkg, :LibGit2, :SHA, :UUIDs, :Sockets, :Statistics, ]), # Plus precompilation module generated at build time let id = Base.PkgId("__PackagePrecompilationStatementModule")