Project detection and configuration (Was: IDE)

[Lluís]

Hi!

As Eric pointed out, most of the user-facing features of an IDE depend on some
underlying support to detect and configure projects.

Now, it is not clear what "detect and configure" really means, but it seems that
EDE (CEDET's project management component) is not fully satisfying or simple
enough to extend/configure at this point in time.

I've formed my own opinions on how this could be improved, but I would like to
hear what others think before discussing how to do it. So, what is required from
"project management"? A few things quickly come into mind:

* Repository
** Detect the root directory that conforms a checked-out repository
** Ignore repository-specific files on other components
** Interact with repo-management tools?

* Project information
** Name, version, homepage, etc

* Build system
** This one seems rather tricky to provide a unified interface
** Detect autotools, hand-made makefiles, ant, maven, linux, etc.
** Build modes of a project (e.g., debug vs release)
** Generate files (targets) of a project
** Create release tarballs?
** Sometimes identifies the root directory of the project

* Source file locations
** Detect the "MIME" of every file on the project
** Information from the build system usually helps identifying files
** Detect changes to files

* Per-source compilation flags
** Necessary for code-analysis tools
** Can be extracted from the build system on some very narrow cases

* Code analysis
** Use CEDET's parsers
*** Needs to know where are the relevant sources, and their interdependence
** Use external tools
*** Need to know how to access their information
*** Need to know how to update their information?

* Auto-detection
** All functionality implementations should support as much auto-configuration
   as possible

* Code navigation, refactoring and other high-level operations
** I'm leaving these out of the "project management" discussion for now, since I
   think they can be implemented on top of the rest

* Let users customize each of the above
** It should be easy to customize existing functionality (e.g., using dir-local
   vars, a simple alist, etc.)
** It should be reasonably easy to compose different implementations of a
   functionality (e.g., use some project auto-detection and on top overlay some
   functionality for a specific external dependency - finding the headers for
   external library dependencies comes into mind -)
** It should be reasonably easy to write new functionality for each of these
   tasks; made easier if composition is easy


What else?

PS: Note that some functionalities are repeated on that list.


Thanks,
  Lluis

-- 
"And it's much the same thing with knowledge, for whenever you learn
something new, the whole world becomes that much richer."
-- The Princess of Pure Reason, as told by Norton Juster in The Phantom
Tollbooth