Merge #1337

1337: [release-1.3] Backports for 1.3 r=fredrikekre a=fredrikekre



Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
Co-authored-by: Jonas Schulze <jonas.schulze@st.ovgu.de>
Co-authored-by: Fredrik Ekre <ekrefredrik@gmail.com>
Co-authored-by: David Varela <00.varela.david@gmail.com>
Co-authored-by: Lyndon White <oxinabox@ucc.asn.au>

Author: 6 people

Project.toml

@@ -3,7 +3,7 @@ uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 keywords = ["package", "management"]
 license = "MIT"
 desc = "The next-generation Julia package manager."
-version = "1.2.0"
+version = "1.3.0"
 
 [deps]
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"

docs/Project.toml

@@ -3,4 +3,4 @@ Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 DocumenterLaTeX = "cd674d7a-5f81-5cf3-af33-235ef1834b99"
 
 [compat]
-Documenter = "~0.22"
+Documenter = "~0.23"

docs/make.jl

@@ -16,6 +16,9 @@ if "pdf" in ARGS
     push!(formats, LaTeX(platform = "docker"))
 end
 
+# setup for doctesting
+DocMeta.setdocmeta!(Pkg.BinaryPlatforms, :DocTestSetup, :(using Pkg.BinaryPlatforms); recursive=true)
+
 makedocs(
     format = formats,
     modules = [Pkg],

docs/src/artifacts.md

@@ -8,7 +8,13 @@ This mechanism is also used to provide the binary dependencies for packages buil
 
 `Pkg` provides an API for working with artifacts, as well as a TOML file format for recording artifact usage in your packages, and to automate downloading of artifacts at package install time.
 Artifacts can always be referred to by content hash, but are typically accessed by a name that is bound to a content hash in an `Artifacts.toml` file that lives in a project's source tree.
-An example `Artifacts.toml` file is shown here as an example:
+
+!!! note
+    It is possible to use the alternate name `JuliaArtifacts.toml`, similar
+    to how it is possible to use `JuliaProject.toml` and `JuliaManifest.toml`
+    instead of `Project.toml` and `Manifest.toml`, respectively.
+
+An example `Artifacts.toml` file is shown here:
 
 ```TOML
 # Example Artifacts.toml file

src/Artifacts.jl

@@ -13,6 +13,9 @@ export create_artifact, artifact_exists, artifact_path, remove_artifact, verify_
        artifact_meta, artifact_hash, bind_artifact!, unbind_artifact!, download_artifact,
        find_artifacts_toml, ensure_artifact_installed, @artifact_str, archive_artifact
 
+# keep in sync with Base.project_names and Base.manifest_names
+const artifact_names = ("JuliaArtifacts.toml", "Artifacts.toml")
+
 const ARTIFACTS_DIR_OVERRIDE = Ref{Union{String,Nothing}}(nothing)
 """
     with_artifacts_directory(f::Function, artifacts_dir::String)
@@ -370,12 +373,12 @@ returns the `Platform` object that this entry specifies.  Returns `nothing` on e
 """
 function unpack_platform(entry::Dict, name::String, artifacts_toml::String)
     if !haskey(entry, "os")
-        @error("Invalid Artifacts.toml at '$(artifacts_toml)': platform-specific artifact entry '$name' missing 'os' key")
+        @error("Invalid artifacts file at '$(artifacts_toml)': platform-specific artifact entry '$name' missing 'os' key")
         return nothing
     end
 
     if !haskey(entry, "arch")
-        @error("Invalid Artifacts.toml at '$(artifacts_toml)': platform-specific artifact entrty '$name' missing 'arch' key")
+        @error("Invalid artifacts file at '$(artifacts_toml)': platform-specific artifact entrty '$name' missing 'arch' key")
         return nothing
     end
 
@@ -439,7 +442,7 @@ end
     load_artifacts_toml(artifacts_toml::String;
                         pkg_uuid::Union{UUID,Nothing}=nothing)
 
-Loads an `Artifacts.toml` file from disk.  If `pkg_uuid` is set to the `UUID` of the
+Loads an `(Julia)Artifacts.toml` file from disk.  If `pkg_uuid` is set to the `UUID` of the
 owning package, UUID/name overrides stored in a depot `Overrides.toml` will be resolved.
 """
 function load_artifacts_toml(artifacts_toml::String;
@@ -480,7 +483,7 @@ end
                   pkg_uuid::Union{Base.UUID,Nothing}=nothing)
 
 Get metadata about a given artifact (identified by name) stored within the given
-`Artifacts.toml` file.  If the artifact is platform-specific, use `platform` to choose the
+`(Julia)Artifacts.toml` file.  If the artifact is platform-specific, use `platform` to choose the
 most appropriate mapping.  If none is found, return `nothing`.
 """
 function artifact_meta(name::String, artifacts_toml::String;
@@ -508,13 +511,13 @@ function artifact_meta(name::String, artifact_dict::Dict, artifacts_toml::String
         meta = select_platform(dl_dict, platform)
     # If it's NOT a dict, complain
     elseif !isa(meta, Dict)
-        @error("Invalid Artifacts.toml at $(artifacts_toml): artifact '$name' malformed, must be array or dict!")
+        @error("Invalid artifacts file at $(artifacts_toml): artifact '$name' malformed, must be array or dict!")
         return nothing
     end
 
     # This is such a no-no, we are going to call it out right here, right now.
     if meta != nothing && !haskey(meta, "git-tree-sha1")
-        @error("Invalid Artifacts.toml at $(artifacts_toml): artifact '$name' contains no `git-tree-sha1`!")
+        @error("Invalid artifacts file at $(artifacts_toml): artifact '$name' contains no `git-tree-sha1`!")
         return nothing
     end
 
@@ -546,7 +549,7 @@ end
                    lazy::Bool = false,
                    force::Bool = false)
 
-Writes a mapping of `name` -> `hash` within the given `Artifacts.toml` file.  If
+Writes a mapping of `name` -> `hash` within the given `(Julia)Artifacts.toml` file. If
 `platform` is not `nothing`, this artifact is marked as platform-specific, and will be
 a multi-mapping.  It is valid to bind multiple artifacts with the same name, but
 different `platform`s and `hash`'es within the same `artifacts_toml`.  If `force` is set
@@ -566,7 +569,7 @@ function bind_artifact!(artifacts_toml::String, name::String, hash::SHA1;
     # First, check to see if this artifact is already bound:
     if isfile(artifacts_toml)
         artifact_dict = parse_toml(artifacts_toml)
-    
+
         if !force && haskey(artifact_dict, name)
             meta = artifact_dict[name]
             if !isa(meta, Array)
@@ -633,8 +636,8 @@ end
 """
     unbind_artifact!(artifacts_toml::String, name::String; platform = nothing)
 
-Unbind the given `name` from an `Artifacts.toml` file.  Silently fails if no such binding
-exists within the file.
+Unbind the given `name` from an `(Julia)Artifacts.toml` file.
+Silently fails if no such binding exists within the file.
 """
 function unbind_artifact!(artifacts_toml::String, name::String;
                          platform::Union{Platform,Nothing} = nothing)
@@ -730,7 +733,7 @@ end
     find_artifacts_toml(path::String)
 
 Given the path to a `.jl` file, (such as the one returned by `__source__.file` in a macro
-context), find the `Artifacts.toml` that is contained within the containing project (if it
+context), find the `(Julia)Artifacts.toml` that is contained within the containing project (if it
 exists), otherwise return `nothing`.
 """
 function find_artifacts_toml(path::String)
@@ -740,25 +743,22 @@ function find_artifacts_toml(path::String)
 
     # Run until we hit the root directory.
     while dirname(path) != path
-        # Also check for `JuliaArtifacts.toml`, preferring that as it's more specific
-        artifacts_toml_path = joinpath(path, "JuliaArtifacts.toml")
-        if isfile(artifacts_toml_path)
-            return abspath(artifacts_toml_path)
-        end
-
-        # Does this `Artifacts.toml` exist?
-        artifacts_toml_path = joinpath(path, "Artifacts.toml")
-        if isfile(artifacts_toml_path)
-            return abspath(artifacts_toml_path)
+        for f in artifact_names
+            artifacts_toml_path = joinpath(path, f)
+            if isfile(artifacts_toml_path)
+                return abspath(artifacts_toml_path)
+            end
         end
 
-        # Does a `Project.toml` file exist here, in the absence of an Artifacts.toml?
+        # Does a `(Julia)Project.toml` file exist here, in the absence of an Artifacts.toml?
         # If so, stop the search as we've probably hit the top-level of this package,
         # and we don't want to escape out into the larger filesystem.
-        if isfile(joinpath(path, "Project.toml"))
-            return nothing
+        for f in Base.project_names
+            if isfile(joinpath(path, f))
+                return nothing
+            end
         end
-        
+
         # Move up a directory
         path = dirname(path)
     end
@@ -796,7 +796,7 @@ function ensure_artifact_installed(name::String, meta::Dict, artifacts_toml::Str
         if !haskey(meta, "download")
             error("Cannot automatically install '$(name)'; no download section in '$(artifacts_toml)'")
         end
-    
+
         # Attempt to download from all sources
         for entry in meta["download"]
             url = entry["url"]
@@ -818,7 +818,7 @@ end
                                    pkg_uuid = nothing,
                                    include_lazy = false)
 
-Installs all non-lazy artifacts from a given `Artifacts.toml` file.  `package_uuid` must
+Installs all non-lazy artifacts from a given `(Julia)Artifacts.toml` file. `package_uuid` must
 be provided to properly support overrides from `Overrides.toml` entries in depots.
 
 If `include_lazy` is set to `true`, then lazy packages will be installed as well.
@@ -855,14 +855,14 @@ end
 
 Macro that is used to automatically ensure an artifact is installed, and return its
 location on-disk.  Automatically looks the artifact up by name in the project's
-`Artifacts.toml` file.  Throws an error on inability to install the requested artifact.
+`(Julia)Artifacts.toml` file.  Throws an error on inability to install the requested artifact.
 """
 macro artifact_str(name)
     return quote
         local artifacts_toml = $(find_artifacts_toml)($(string(__source__.file)))
         if artifacts_toml === nothing
             error(string(
-                "Cannot locate 'Artifacts.toml' file when attempting to use artifact '",
+                "Cannot locate '(Julia)Artifacts.toml' file when attempting to use artifact '",
                 $(esc(name)),
                 "' in '",
                 $(esc(__module__)),

src/Operations.jl

@@ -10,7 +10,7 @@ import REPL
 using REPL.TerminalMenus
 using ..Types, ..GraphType, ..Resolve, ..Pkg2, ..PlatformEngines, ..GitTools, ..Display
 import ..depots, ..depots1, ..devdir, ..Types.uuid_julia, ..Types.PackageEntry
-import ..Artifacts: ensure_all_artifacts_installed
+import ..Artifacts: ensure_all_artifacts_installed, artifact_names
 using ..BinaryPlatforms
 import ..Pkg
 
@@ -424,7 +424,9 @@ function deps_graph(ctx::Context, uuid_to_name::Dict{UUID,String}, reqs::Require
     for uuid in uuids
         uuid == uuid_julia && continue
         if !haskey(uuid_to_name, uuid)
-            uuid_to_name[uuid] = registered_name(ctx.env, uuid)
+            name = registered_name(ctx.env, uuid)
+            name === nothing && pkgerror("cannot find name corresponding to UUID $(uuid) in a registry")
+            uuid_to_name[uuid] = name
             entry = manifest_info(ctx.env, uuid)
             entry ≡ nothing && continue
             uuid_to_name[uuid] = entry.name
@@ -560,11 +562,14 @@ function download_artifacts(ctx::Context, pkgs::Vector{PackageSpec};
                             platform::Platform=platform_key_abi())
     for pkg in pkgs
         path = source_path(pkg)
-        # Check to see if this package has an Artifacts.toml
-        artifacts_toml = joinpath(path, "Artifacts.toml")
-        if isfile(artifacts_toml)
-            ensure_all_artifacts_installed(artifacts_toml; platform=platform)
-            write_env_usage(artifacts_toml, "artifact_usage.toml")
+        # Check to see if this package has an (Julia)Artifacts.toml
+        for f in artifact_names
+            artifacts_toml = joinpath(path, f)
+            if isfile(artifacts_toml)
+                ensure_all_artifacts_installed(artifacts_toml; platform=platform)
+                write_env_usage(artifacts_toml, "artifact_usage.toml")
+                break
+            end
         end
     end
 end
@@ -871,11 +876,10 @@ function rm(ctx::Context, pkgs::Vector{PackageSpec})
         pkg.mode == PKGMODE_PROJECT || continue
         found = false
         for (name::String, uuid::UUID) in ctx.env.project.deps
-            has_name(pkg) && pkg.name == name ||
-            has_uuid(pkg) && pkg.uuid == uuid || continue
-            !has_name(pkg) || pkg.name == name ||
+            pkg.name == name || pkg.uuid == uuid || continue
+            pkg.name == name ||
                 error("project file name mismatch for `$uuid`: $(pkg.name) ≠ $name")
-            !has_uuid(pkg) || pkg.uuid == uuid ||
+            pkg.uuid == uuid ||
                 error("project file UUID mismatch for `$name`: $(pkg.uuid) ≠ $uuid")
             uuid in drop || push!(drop, uuid)
             found = true
@@ -894,6 +898,9 @@ function rm(ctx::Context, pkgs::Vector{PackageSpec})
         @info "No changes"
         return
     end
+    filter!(ctx.env.project.compat) do (name, _)
+        name in keys(ctx.env.project.deps)
+    end
     deps_names = append!(collect(keys(ctx.env.project.deps)),
                          collect(keys(ctx.env.project.extras)))
     filter!(ctx.env.project.targets) do (target, deps)
@@ -978,7 +985,7 @@ function add(ctx::Context, pkgs::Vector{PackageSpec}, new_git=UUID[];
     # TODO is it still necessary to prune? I don't think so..
     new_apply = download_source(ctx, pkgs)
 
-    # After downloading resolutionary packages, search for Artifacts.toml files
+    # After downloading resolutionary packages, search for (Julia)Artifacts.toml files
     # and ensure they are all downloaded and unpacked as well:
     download_artifacts(ctx, pkgs; platform=platform)
 

src/PlatformEngines.jl

@@ -603,15 +603,15 @@ if `force` is not set and the already-existent file fails verification, or if
 `force` is set, verification fails, and then verification fails again after
 redownloading the file.
 
-If `quiet_download` is set to `false` (the default), this method will print to
-stdout when downloading a new file.  If it is set to `true` (and `verbose` is
+If `quiet_download` is set to `false`, this method will print to
+stdout when downloading a new file.  If it is set to `true` (default, and `verbose` is
 set to `false`) the downloading process will be completely silent.  If
 `verbose` is set to `true`, messages about integrity verification will be
 printed in addition to messages regarding downloading.
 """
 function download_verify(url::AbstractString, hash::AbstractString,
                          dest::AbstractString; verbose::Bool = false,
-                         force::Bool = false, quiet_download::Bool = false)
+                         force::Bool = false, quiet_download::Bool = true)
     # Whether the file existed in the first place
     file_existed = false
 

src/Types.jl

@@ -215,7 +215,14 @@ function manifestfile_path(env_path::String; strict=false)
         maybe_file = joinpath(env_path, name)
         isfile(maybe_file) && return maybe_file
     end
-    return strict ? nothing : joinpath(env_path, "Manifest.toml")
+    if strict
+        return nothing
+    else
+        project = basename(projectfile_path(env_path))
+        idx = findfirst(x -> x == project, Base.project_names)
+        @assert idx !== nothing
+        return joinpath(env_path, Base.manifest_names[idx])
+    end
 end
 
 function find_project_file(env::Union{Nothing,String}=nothing)
@@ -1136,7 +1143,7 @@ function update_registries(ctx::Context, regs::Vector{RegistrySpec} = collect_re
             # Using LibGit2.with here crashes julia when running the
             # tests for PkgDev wiht "Unreachable reached".
             # This seems to work around it.
-            local repo
+            repo = nothing
             try
                 repo = LibGit2.GitRepo(reg.path)
                 if LibGit2.isdirty(repo)
@@ -1177,7 +1184,9 @@ function update_registries(ctx::Context, regs::Vector{RegistrySpec} = collect_re
                 end
                 @label done
             finally
-                close(repo)
+                if repo isa LibGit2.GitRepo
+                    close(repo)
+                end
             end
         end
     end

src/backwards_compatible_isolation.jl

@@ -558,7 +558,7 @@ function with_dependencies_loadable_at_toplevel(f, mainctx::Context, pkg::Packag
         # a trivial modification of the project file only.
         # See issue https://github.com/JuliaLang/Pkg.jl/issues/1144
         not_loadable = setdiff(should_be_in_manifest, should_be_in_project)
-        Operations.rm(localctx, [PackageSpec(uuid = uuid) for uuid in not_loadable])
+        Pkg.API.rm(localctx, [PackageSpec(uuid = uuid) for uuid in not_loadable])
 
         write_env(localctx, display_diff = false)
         will_resolve && build_versions(localctx, new)

test/api.jl

@@ -16,6 +16,17 @@ include("utils.jl")
     end
 end
 
+@testset "Pkg.rm" begin
+    # rm should remove compat entries
+    temp_pkg_dir() do tmp
+        copy_test_package(tmp, "BasicCompat")
+        Pkg.activate(joinpath(tmp, "BasicCompat"))
+        @test haskey(Pkg.Types.Context().env.project.compat, "Example")
+        Pkg.rm("Example")
+        @test !haskey(Pkg.Types.Context().env.project.compat, "Example")
+    end
+end
+
 @testset "Pkg.activate" begin
     temp_pkg_dir() do project_path
         cd_tempdir() do tmp