bug#41572: 28.0.50; [PATCH] Support plain project marked with file .emacs-project

[Dmitry Gutov <dgutov@yandex.ru>]

On 06.10.2021 17:09, Nikolay Kudryavtsev wrote:
>> But when we go up a directory, "./project/". And when asked to list 
>> its files, how do we avoid including "./project/foo/a" in that list? 
>> It would make sense to exclude any nested projects, right?
> Not necessarily. It may be a useful thing to do for some projects, but 
> it does not follow from anything that it should be the only or the 
> default option.

When should we not do it?

> The correct solution here is IMHO implementing some kind 
> of .project-settings.el file in which you can set 
> hide-nested-project-files.

You can already specify ignored files in a project through .dir-locals.el.

But then you will end up specifying the same information twice. Once 
when setting up those new backends -- and the second time when 
configuring the parent project to ignore particular subdirectories. And 
that seems problematic from the usability standpoint. Also, that 
information can easily get out of sync.

>> Setting project-find-functions in a major mode is a questionable thing 
>> to do, because then you end up with Emacs where files in the same 
>> directory belong to different projects.
> I'm not talking about setting it locally in the mode, more about modes 
> providing such functions on load. That's another important question. 
> More backends are more functions to test, so it's reasonable to add 
> backends only when they're needed. I may avoid programming in language X 
> from some months so no reason to keep that backed on, but when I start 
> editing a file in that language, the major mode loads and so should the 
> backend.

If the only piece of information such modes intend to provide is the 
name, or multiple names, of "marker" files which indicate that their 
containing directory is the root, and if this information should be 
applied by the user manually anyway, why not have a single backend for 
that purpose, with a custom var containing the list of files names? The 
major modes can tell the users to modify that variable.

And this backend is in the proposed 'fallback' backend.

>> If there is a next backend which indicates the same root, why do we 
>> need the first one? 
> We don't know what the next backend in line indicates. Nor do we care 
> about it since the current one already gives us something. We just try 
> to find backends until we find one in the order of priority and then stop.

That didn't really answer my question.

>> Suppose I call project-find-file, meaning to jump to another file in 
>> the same Git repository. And instead I am shown only a list of files 
>> in the current subdirectory because it contains, say, a Makefile. Is 
>> that a good idea to enact this kind of behavior automatically? 
> If a user believes that it looks like a duck, it should squeak like one. 
> Sure you personally may want to suppress some possible project backends 
> from firing, but someone may want the opposite.

I'm not sure how I would suppress "possible project backends" from 
firing. That's the rub: the configuration is global, and whatever 
backend ends up being used, should be the most fitting to the total set 
of possible user's needs.

Meaning, it should correspond to the user's view of the project to the 
best possible ability: point out the root, exclude the files that need 
to be excluded, and ideally fetch the list of files quickly as well.

> I want to remind you of this recent-ish thread on HGE:
> 
> https://lists.gnu.org/archive/html/help-gnu-emacs/2021-09/msg00045.html
> 
> Lets take the maven example presented there. We have a project 
> containing modules. The user wants to compile both independently. We can 
> write two different compilation commands, one that works on the project 
> and one that works on the module. Or we can just have a single command, 
> since the compilation process is not different in any way for both. Then 
> we can give that command some prefix that would make it work not on the 
> project itself but on the root project of that project.

Either you have a compilation command that is Maven-aware (and thus can 
find the module root directory on its own), or we add an extension of 
the project API, with generic like project-modules, where modules behave 
like projects themselves (can implement the 'root' and 'files' methods). 
And maybe with a project-current-module generic as well, though it could 
easily be implemented with a linear search across a small list (with 
file-in-directory-p check).

But if the command creates a Maven-specific invocation, it doesn't need 
the above abstraction -- it works with Maven, so it knows Maven, it can 
look for the current module directly. Or just use the project root, if 
the appropriate value of prefix was specified.

I don't see where your approach would make things simpler/more 
predictable/reliable.

> The Makefile example is your strongest argument here, but we can define 
> find functions for it recursively. That is until you find a Makefile 
> that does not have a dominating Makefile of it's own. And if all else 
> fails you can just use the proposed plain project mark.

That's possible, but it's not at all a guarantee that in every big 
project every Makefile will have a "dominating" Makefile of its own.

The above is just a particular GNU convention. But Makefiles are also 
used for quick scripting in projects that are actually built with other 
tools.

>> What user-level commands are going to benefit from this setup?
> It seems that we somewhat differ in our priorities for project 
> treatment. You seem to prioritize the logical grouping of files for 
> editing operations, while I prioritize "actionability".

I'm prioritizing "universality", so to speak. And predictability. So 
that a certain class of commands (or several classes, actually) can use 
"current project" and be reliably certain of what it is.

> If a certain 
> directory has a set of unique actions that can be performed on it, then 
> it's a project for me.

It would seem like your vision of the project could benefit from a 
notion like "facet". E.g. a project lookup would search for not just 
"the current project", but "the current build project" or "current file 
listing project", or... I don't know what else, actually. But I'm sure 
there can be other additions (something test-framework related, maybe).

But unless I'm missing something major, the same goal could be served by 
an addition of a new hook. Like 'buildtool-find-functions'. Which would 
return, for example, new kind of object, and that object could tell the 
parent directory of its build file, and the list of the tasks described 
in it, and... perhaps something about how those tasks should be invoked. 
That new abstraction could be used by commands that want to interact 
with build files in an abstract fashion and to launch build tasks.

It might also have a problem choosing which Makefile to use, out of a 
hierarchy of Makefiles, though. Requiring similar customization capability.

> And while your observation that such emphasis on 
> actionability may result in worse logical grouping is broadly true, it 
> is not necessarily true that a blind reliance on VC backend would result 
> in proper logical grouping. Sure, that would be true for most projects, 
> but oftentimes you have multiple independent, but related projects 
> sharing the same repository.

There are two patches in this bug report. Have you looked at the other one?