If Pkg.dir() is deprecated, what is its replacement?

[tkluck]

The function Pkg.dir() gives the following warning:

Warning: Pkg.dir is only kept for legacy CI script reasons

which I think means that it is deprecated. I currently use it to pass the right library environment to a non-julia subprocess (source). What's the best way to get the same result?

I'll be happy to submit a pull request to document the alternative, hopefully in the warning itself.

[tkluck]

FWIW, here's what I used previously:

tkluck/StatProfilerHTML.jl@df697a1

I thought Pkg.dir() was a marked improvement!

[KristofferC]

Use relative paths (with e.g. @__DIR__). Pkg.dir is definitely the wrong thing to use because it assumed that the package is installed in .julia/v0.x which might not be true at all.

[tkluck]

Thanks @KristofferC! I just pushed tkluck/StatProfilerHTML.jl@6eb9335 by your recommendation.

Pkg.dir is definitely the wrong thing to use because it assumed that the package is installed in .julia/v0.x which might not be true at all.

Is that a necessary limitation for this function? Couldn't Pkg.dir theoretically use the same resolution logic as what using and import use? (Looking at the source, I can't really decide whether that isn't what it does.)

[KristofferC]

It was a limitation with the old function, but it could indeed support showing the actual location (and that is actually what the deprecation sneakily uses).

JuliaLang/julia#27592 should be relevant.

[tpapp]

Another use case I had for Pkg.dir is

cd(Pkg.dir("somepkg", "test"))

so that I could step through a runtest.jl with includes interactively.

Is there a suggested replacement for this?

[KristofferC]

Until JuliaLang/julia#27592 is fixed you can use something like

julia> pkgdir(pkg::String) = abspath(joinpath(dirname(Base.find_package(pkg)), ".."))
pkgdir (generic function with 1 method)

julia> pkgdir("Example")
"/Users/kristoffer/.julia/packages/Example/kH44/"

But what package julia will load is completely independent of the package manager which is why I feel this should maybe be a Base API.

[fredrikekre]

For most uses I recommend trying to rewrite the code to use @__DIR__, but we now also have Base.pathof(::Module) if need be.

[tpapp]

Not opening another issue, but I am not sure how to determine where the coverage files ended up after a

Pkg.test("SomePkg"; coverage = true)

using the official API. Base.pathof would assume that I loaded the module, right?

[fredrikekre]

For Coverage submission on CI? You don't need the cd call there anyway, we are already in the root of the package.

[tpapp]

No, for LocalCoverage.jl. I want to know where the files are so I can run genhtml etc on them.

I think this is a reasonable use case. Coverage may be run outside CI, and one may want to know where the output is for processing.

[tpapp]

Also, if there is no immediate fix, please reopen the issue or let me know if I should create another one.

[fredrikekre]

Why can't you load it? You can also use Base.find_package

[fredrikekre]

Another option is to change your API, and make it generate_coverage(::Module) instead. That is what we have done with DocumenterTools.

[tpapp]

Why can't you load it?

My understanding is that it would be a global side-effect, which I would want to avoid in a function.

You can also use Base.find_package

A comment above suggests that it may not be the right solution, did that change?

In any case, I think my issue boils down to the following: Pkg.test(...; coverage = true) generates files as an intended side effect, but it is not possible to find out where they are via the official API.

[KristofferC]

That is pretty much #624. We could have something like activate --target=... that generates the new files and keeps you in that environment (so you can do e.g. include("test/runtests.jl").

[tpapp]

I thought of reworking the API of LocalCoverage.jl to use the active project instead (if any), but I am not sure how to hook into that either. I could proceed from Pkg.Types.Context().env.project_file, but that sounds like an even more horrid hack.

[KristofferC]

JuliaLang/julia#29030

[tpapp]

Thanks. Is there a way to query if the result of Base.active_project() is something I can run pkg"test" on?

[KristofferC]

If it has a name = ... in the TOML file and if test/runtests.jl exists.

Could probably do it like

function can_run_test()
    p = Base.active_project()
    try Pkg.Types.read_package(p)
    catch
        return false
    end
    return isfile(joinpath(dirname(p), "test", "runtests.jl"))
end