Clean-up release 1.4 branch

Author: oxinabox

Project.toml

@@ -7,11 +7,15 @@ Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 
 [compat]
 ChainRulesCore = "=1.0.2"
+MCMCDiagnosticTools = "=0.1.0"
+YAXArrays = "0.1.3"
 julia = "~1.4, ~1.5, ~1.6"
 
 [extras]
 ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
+MCMCDiagnosticTools = "be115224-59cd-429b-ad48-344e309966f0"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+YAXArrays = "c21b50f5-aa40-41ea-b809-c0f5e47bfa5c"
 
 [targets]
-test = ["ChainRulesCore", "Test"]
+test = ["ChainRulesCore", "MCMCDiagnosticTools", "Test", "YAXArrays"]

src/TestEnv.jl

@@ -6,33 +6,10 @@ using Pkg.Operations: manifest_info, manifest_resolve!, project_deps_resolve!
 using Pkg.Operations: project_rel_path, project_resolve!
 
 using Pkg.Types: Types, projectfile_path, manifestfile_path
-
-# Version specific imports
-@static if VERSION >= v"1.4.0"
-    using Pkg.Operations: gen_target_project
-else
-    using Pkg.Operations: with_dependencies_loadable_at_toplevel
-end
-@static if isdefined(Pkg.Operations, :update_package_test!)
-    using Pkg.Operations: update_package_test!
-else
-    function update_package_test!(pkg, entry)
-        is_stdlib(pkg.uuid) && return
-        pkg.version = entry.version
-        pkg.tree_hash = entry.tree_hash
-        pkg.repo = entry.repo
-        pkg.path = entry.path
-        pkg.pinned = entry.pinned
-    end
-end
-
-@static if VERSION >= v"1.2.0"
-    using Pkg.Types: is_stdlib
-    using Pkg.Operations: sandbox, source_path, sandbox_preserve, abspath!
-else
-    using Pkg.Operations: find_installed
-    using Pkg.Types: SHA1
-end
+using Pkg.Operations: gen_target_project
+using Pkg.Operations: update_package_test!
+using Pkg.Types: is_stdlib
+using Pkg.Operations: sandbox, source_path, sandbox_preserve, abspath!
 
 
 include("exceptions.jl")

src/activate.jl

@@ -44,23 +44,12 @@ is of type `Pkg.Types.Context`. For earlier versions, they are of type
 `Pkg.Types.EnvCache`.
 """
 function isinstalled!(ctx::Context, pkgspec::Pkg.Types.PackageSpec)
-    var = @static if v"1.4.0" <= VERSION < v"1.7.0-"
-        ctx
-    else
-        ctx.env
-    end
-    project_resolve!(var, [pkgspec])
-    project_deps_resolve!(var, [pkgspec])
-
-    manifest = @static if VERSION < v"1.7.0-"
-        var
-    else
-        var.manifest
-    end
-    manifest_resolve!(manifest, [pkgspec])
+    project_resolve!(ctx, [pkgspec])
+    project_deps_resolve!(ctx, [pkgspec])
+    manifest_resolve!(ctx, [pkgspec])
 
     try
-        ensure_resolved(manifest, [pkgspec])
+        ensure_resolved(ctx, [pkgspec])
     catch err
         err isa MethodError && rethrow()
         return false

src/make_test_env.jl

@@ -1,108 +1,85 @@
 
 # Originally from Pkg.Operations.sandbox
-@static if VERSION <= v"1.1"  # 1.0 or 1.1
-    # For now will just abuse that we solved sandbox
-    function make_test_env(ctx::Context, pkgspec)
-        safe_dir = mktempdir()
-        _sandbox(ctx, pkgspec) do
-            cp(Base.active_project(), joinpath(safe_dir, "Project.toml"))
-        end
-        Pkg.activate(safe_dir)
-        Pkg.resolve()
-        return nothing
+function make_test_env(ctx::Context, target)
+    # This needs to be first as `gen_target_project` fixes `target.path` if it is nothing
+    sandbox_project_override = if !test_dir_has_project_file(ctx, target)
+        sandbox_project_override = gen_target_project(ctx, target, target.path, "test")
+    else
+        nothing
     end
-else
-    function make_test_env(ctx::Context, target)
-        # This needs to be first as `gen_target_project` fixes `target.path` if it is nothing
-        sandbox_project_override = if !test_dir_has_project_file(ctx, target)
-            sandbox_project_override = @static if VERSION < v"1.7-a"
-                gen_target_project(ctx, target, target.path, "test")
-            else
-                gen_target_project(ctx.env, ctx.registries, target, target.path, "test")
-            end
-        else
-            nothing
-        end
 
-        sandbox_path = joinpath(target.path, "test")
-        sandbox_project = projectfile_path(sandbox_path)
+    sandbox_path = joinpath(target.path, "test")
+    sandbox_project = projectfile_path(sandbox_path)
 
-        tmp = mktempdir()
-        tmp_project = projectfile_path(tmp)
-        tmp_manifest = manifestfile_path(tmp)
+    tmp = mktempdir()
+    tmp_project = projectfile_path(tmp)
+    tmp_manifest = manifestfile_path(tmp)
 
-        # Copy env info over to temp env
-        if sandbox_project_override !== nothing 
-            Types.write_project(sandbox_project_override, tmp_project)
-        elseif isfile(sandbox_project)
-            cp(sandbox_project, tmp_project)
-            chmod(tmp_project, 0o600)
-        end
-        # create merged manifest
-        # - copy over active subgraph
-        # - abspath! to maintain location of all deved nodes
-        working_manifest = if VERSION <= v"1.7-a"
-            abspath!(ctx, sandbox_preserve(ctx, target, tmp_project))
-        else
-            abspath!(ctx.env, sandbox_preserve(ctx.env, target, tmp_project))
-        end
-        # - copy over fixed subgraphs from test subgraph
-        # really only need to copy over "special" nodes
-        sandbox_env = Types.EnvCache(projectfile_path(sandbox_path))
-        sandbox_manifest = if VERSION <= v"1.7-a"
-            abspath!(sandbox_path, sandbox_env.manifest)
-        else
-            abspath!(sandbox_env, sandbox_env.manifest)
-        end
-        for (name, uuid) in sandbox_env.project.deps
-            entry = get(sandbox_manifest, uuid, nothing)
-            if entry !== nothing && isfixed(entry)
-                subgraph = prune_manifest(sandbox_manifest, [uuid])
-                for (uuid, entry) in subgraph
-                    if haskey(working_manifest, uuid)
-                        pkgerror("can not merge projects")
-                    end
-                    working_manifest[uuid] = entry
+    # Copy env info over to temp env
+    if sandbox_project_override !== nothing 
+        Types.write_project(sandbox_project_override, tmp_project)
+    elseif isfile(sandbox_project)
+        cp(sandbox_project, tmp_project)
+        chmod(tmp_project, 0o600)
+    end
+    # create merged manifest
+    # - copy over active subgraph
+    # - abspath! to maintain location of all deved nodes
+    working_manifest = abspath!(ctx, sandbox_preserve(ctx, target, tmp_project))
+
+    # - copy over fixed subgraphs from test subgraph
+    # really only need to copy over "special" nodes
+    sandbox_env = Types.EnvCache(projectfile_path(sandbox_path))
+    sandbox_manifest = abspath!(sandbox_path, sandbox_env.manifest)
+
+    for (name, uuid) in sandbox_env.project.deps
+        entry = get(sandbox_manifest, uuid, nothing)
+        if entry !== nothing && isfixed(entry)
+            subgraph = prune_manifest(sandbox_manifest, [uuid])
+            for (uuid, entry) in subgraph
+                if haskey(working_manifest, uuid)
+                    pkgerror("can not merge projects")
                 end
+                working_manifest[uuid] = entry
             end
         end
+    end
 
-        Types.write_manifest(working_manifest, tmp_manifest)
+    Types.write_manifest(working_manifest, tmp_manifest)
 
-        # sandbox
-        push!(empty!(LOAD_PATH), "@", tmp)
-        Base.ACTIVE_PROJECT[] = nothing
+    # sandbox
+    push!(empty!(LOAD_PATH), "@", tmp)
+    Base.ACTIVE_PROJECT[] = nothing
 
-        temp_ctx = Context()
-        temp_ctx.env.project.deps[target.name] = target.uuid
+    temp_ctx = Context()
+    temp_ctx.env.project.deps[target.name] = target.uuid
 
-        try
-            Pkg.resolve(temp_ctx; io=devnull)
-            @debug "Using _parent_ dep graph"
-        catch err# TODO
-            @debug err
-            @warn "Could not use exact versions of packages in manifest, re-resolving"
-            temp_ctx.env.manifest.deps = Dict(
-                uuid => entry for
-                (uuid, entry) in temp_ctx.env.manifest.deps if isfixed(entry)
-            )
-            Pkg.resolve(temp_ctx; io=devnull)
-            @debug "Using _clean_ dep graph"
-        end
+    try
+        Pkg.resolve(temp_ctx; io=devnull)
+        @debug "Using _parent_ dep graph"
+    catch err# TODO
+        @debug err
+        @warn "Could not use exact versions of packages in manifest, re-resolving"
+        temp_ctx.env.manifest.deps = Dict(
+            uuid => entry for
+            (uuid, entry) in temp_ctx.env.manifest.deps if isfixed(entry)
+        )
+        Pkg.resolve(temp_ctx; io=devnull)
+        @debug "Using _clean_ dep graph"
+    end
 
-        # Absolutify stdlibs paths
-        for (uuid, entry) in temp_ctx.env.manifest
-            if is_stdlib(uuid)
-                entry.path = Types.stdlib_path(entry.name)
-            end
+    # Absolutify stdlibs paths
+    for (uuid, entry) in temp_ctx.env.manifest
+        if is_stdlib(uuid)
+            entry.path = Types.stdlib_path(entry.name)
         end
-        write_env(temp_ctx.env; update_undo=false)
-
-        # update enviroment variables
-        path_sep = Sys.iswindows() ? ';' : ':'
-        ENV["JULIA_LOAD_PATH"] = "@$(path_sep)$(tmp)"
-        delete!(ENV, "JULIA_PROJECT")
-        
-        return Base.active_project()
     end
+    write_env(temp_ctx.env; update_undo=false)
+
+    # update enviroment variables
+    path_sep = Sys.iswindows() ? ';' : ':'
+    ENV["JULIA_LOAD_PATH"] = "@$(path_sep)$(tmp)"
+    delete!(ENV, "JULIA_PROJECT")
+    
+    return Base.active_project()
 end

src/sandbox.jl

@@ -1,50 +1,11 @@
-
-
-if VERSION <= v"1.1"  # 1.0 or 1.1
-    _sandbox(f, ctx, pkgspec) = _manual_sandbox(f, ctx, pkgspec)
-elseif VERSION <= v"1.3" # 1.2 or 1.3
-    function _sandbox(f, ctx, pkgspec)
-        test_dir_has_project_file(ctx, pkgspec) || return _manual_sandbox(f, ctx, pkgspec)
-        return sandbox(ctx, pkgspec, pkgspec.path, joinpath(pkgspec.path, "test")) do
-            flush(stdout)
-            f()
-        end
+function _sandbox(f, ctx, pkgspec)
+    test_project_override = if !test_dir_has_project_file(ctx, pkgspec)
+        gen_target_project(ctx, pkgspec, pkgspec.path, "test")
+    else
+        nothing
     end
-elseif VERSION >= v"1.7-a"
-    function _sandbox(f, ctx, pkgspec)
-        test_project_override = if !test_dir_has_project_file(ctx, pkgspec)
-            gen_target_project(ctx.env, ctx.registries, pkgspec, pkgspec.path, "test")
-        else
-            nothing
-        end
-        return sandbox(ctx, pkgspec, pkgspec.path, joinpath(pkgspec.path, "test"), test_project_override) do
-            flush(stdout)
-            f()
-        end
-    end
-else
-    @assert VERSION >= v"1.3"
-    function _sandbox(f, ctx, pkgspec)
-        test_project_override = if !test_dir_has_project_file(ctx, pkgspec)
-            gen_target_project(ctx, pkgspec, pkgspec.path, "test")
-        else
-            nothing
-        end
-        return sandbox(ctx, pkgspec, pkgspec.path, joinpath(pkgspec.path, "test"), test_project_override) do
-            flush(stdout)
-            f()
-        end
+    return sandbox(ctx, pkgspec, pkgspec.path, joinpath(pkgspec.path, "test"), test_project_override) do
+        flush(stdout)
+        f()
     end
 end
-#sandbox(ctx::Context, target::PackageSpec, target_path::String,sandbox_path::String, sandbox_project_override)
-
-function _manual_sandbox(f, ctx, pkgspec)
-    with_dependencies_loadable_at_toplevel(ctx, pkgspec; might_need_to_resolve=true) do localctx
-        Pkg.activate(localctx.env.project_file)
-        try
-            f()
-        finally
-            Pkg.activate(ctx.env.project_file)
-        end
-    end
-end