Add pkgdir(m::Module)

[IanButterworth]

Edit: function now named pkgdir(m::Module) but was originally proposed as rootof(m::Module)

---

Provides a convenient way to get to the root directory (the parent directory of src) of the package that imported module m.

Closely equivalent to:

dirname(dirname(pathof(Base.moduleroot(m))))

Submodules resolve the same root:

import Foo
import Foo.SubFoo

rootof(Foo) == rootof(SubFoo)

One notable use case would be getting to package examples easily:

import Foo
examplesdir = joinpath(rootof(Foo),"examples")

Discussed in #31638

[IanButterworth]

N.B. the submodule test required adding a submodule to test/project/deps/Foo1. I'm not sure whether that breaks any other tests
Edit: It doesn't seem to

[StefanKarpinski]

Wouldn’t the usual dirname(dirname(path)) be slightly more efficient?

[IanButterworth]

Your judgement is best here.. so I've switched it out

[StefanKarpinski]

Looks good to me. I'm tagging for triage just to discuss the API.

[mschauer]

A minor snag is the discrepancy in meaning of root between moduleroot and rootof(module). Can one derive a name from basedirectory?

[IanButterworth]

That is unfortunate.

basedirectory is good but perhaps basedir given isdir and walkdir etc exist?

Also, not that I’m suggesting changing it, but rootmodule might have been a better name for moduleroot.

[StefanKarpinski]

How about pkgdir(::Module)? After all, it is the replacement for Pkg.dir(::String) and it only returns a path if the module belongs to a package. The other option would be to define it in Pkg and then have it be Pkg.dir(::Module).

[IanButterworth]

pkgdir(::Module) wins for simplicity given no need to Using Pkg. Especially if the main point here is competing with the simplicity of dirname(dirname(pathof(Module)))

But I like the mentality of this being a Pkg function too. Pkg.dir(::Module) makes a lot of sense.

How about both?

[StefanKarpinski]

How about both?

Eh, I'd prefer not to have two gratuitously different ways to spell the same thing.

[IanButterworth]

I’d go for the former then, given convenience

[vtjnash]

only returns a path if the module belongs to a package

Yeah, that's a pretty serious issue that almost makes these functions worse than useless. I've been intending to eventually get around to fixing that. I guess this is good motivation for me to address both at the same time. So, I'm good with merging this now, with the intention that the implementation will be completely redone at some point (so that it'll still typically give this answer, but actually give it correctly in all cases).

[IanButterworth]

Just to check, I’d need to rename the function to pkgdir() before merge, if that’s what the consensus is?

[StefanKarpinski]

I've been intending to eventually get around to fixing that.

How do you propose doing that? This function returns the root directory of the package that a module comes from. It can't, by definition, do that unless the module comes from a package.

So, I'm good with merging this now, with the intention that the implementation will be completely redone at some point (so that it'll still typically give this answer, but actually give it correctly in all cases).

Before you do any of that, please explain what you have in mind.

[KristofferC]

Giving the path to the file where the module was defined (which is what pathof) does now seems good.

One notable use case would be getting to package examples easily:
examplesdir = joinpath(rootof(Foo),"examples")

If you just have the packages added then that will take you to some weird path where the examples are read only which is probably not where you want to be. And if you have the package deved, it is simple to cd there or copy paste the output from Pkg.status.

[IanButterworth]

If you just have the packages added then that will take you to some weird path where the examples are read only which is probably not where you want to be. And if you have the package deved, it is simple to cd there or copy paste the output from Pkg.status.

I think there's a strong case for easy read-only access to dirs like examples, and that's the main purpose of examples. To be quick ways to showcase how to use the package, that can then be copied elsewhere and modified. Being able to just run them with minimal code seems helpful to me.

And dev-ing packages describes another kind of user. I don't think people would be looking to modify the examples generally. Copying the path out of Pkg.status is simple, but it's manual.

I just see a lot of dirname(dirname(pathof(m))) in example docs and it seems like it should be simpler.

[JeffBezanson]

+1 to pkgdir instead of rootof; seems much clearer.

[IanButterworth]

I've switched out the name to pkgdir()

[fredrikekre]

Do we need two functions that do (basically) the same thing?

[JeffBezanson]

pathof could be extended to also work on e.g. methods and types.

[JeffBezanson]

Triage is ok with this.

[IanButterworth]

Could this get into v1.3, or is that window closed?

[fredrikekre]

Feature freeze was August 15.

[IanButterworth]

ok, thanks @fredrikekre

[StefanKarpinski]

Do we need two functions that do (basically) the same thing?

I don't get this comment. @fredrikekre, what's the other function that's the same as this?

[IanButterworth]

It'd be nice to get this into 1.4 🙏🏻

[fredrikekre]

Looks like this is missing from NEWS.md