Hi Jayson,
IDE support has one of the highest priorities for Gradle. You will
get all the help you need from my side for implementing your plugin.
On May 31, 2008, at 1:45 AM, Jayson Minard wrote:
Hello Hans,
I'm looking at developing or having someone at my company develop
an IntelliJ plugin for Gradle for launching builds as well as
keeping the IntelliJ module library set up to date.
So consider the following set of items we most likely need to
accomplish:
- Instantiate and run Gradle directly and want to have it confer
the configured tasks to us
As Gradle builds the tasks graph before it starts the execution this
is basically easy. If you type gradle -t for a particular project
this graph is for example printed to the console. The only problem is
that it might takes a couple of seconds to generate this graph as the
build script has to be evaluated. A structured view of the gradlefile
in form of its task elements would be very cool. The question is how
to update it. Starting the graph generation for every build script
change might be too expensive.
- be able to launch specific tasks
As soon as we have a task view this is easy.
- finally hear the dependencies that are resolved and where we can
access them
Easy for normal dependencies. The problem are multi-project builds as
you want to have project dependencies between them. Gradle needs to
offer a method where you can ask explicitly for external dependencies
or project dependencies. This won't be too hard to implement but is
not available yet.
- configure where we would want the cache to exist locally in case
the user wants them to be cached within the module tree
Easy,
- possibly silently make the Gradle jar available to the project
for gradlefile development
What I have in mind is a feature where you can specifically define a
classpath for the gradlefile. This classpath would be independent of
the classpath for the module. I don't know how difficult this is to
implement with IntelliJ. I have asked Eugene Vigdorchik, the
JetGroovy lead, about this a month ago. He wanted to think about it.
May be he has some good idea now ;). I'm sure he will give advise to
you for developing such a functionality.
What is easily available vs. hard to get at within Gradle? Any big
barriers in the way?
For 0.2 we want to implement a rich plugin system. One plan is to let
the plugins communicate directly with each other. One use case are
IDE plugins. We think about an Interface IdeAware which is
implemented for example by the Java plugin and the War plugin. The
IntelliJPlugin would be able to send request to all IdeAware plugins
(without knowing them) and those plugins would add information to the
IDE domain objects. With this information the IntelliJ plugin can
then build the IDE files. The development for 0.2 will start next week.
One thing we could start with is a test project with a gradlefile.
usePlugin('java')
dependencies {
// some declarations
}
createTask('intelliJ') {
// the logic for creating the intelliJ project files.
}
If this works we can refactor the intelliJ task into a plugin.
What do you think?
- Hans
Thanks for any kick-start help you can provide.
-- Jayson @ MindHeap
---------------------------------------------------------------------
To unsubscribe from this list, please visit:
http://xircles.codehaus.org/manage_email
--
Hans Dockter
Gradle Project lead
http://www.gradle.org
---------------------------------------------------------------------
To unsubscribe from this list, please visit:
http://xircles.codehaus.org/manage_email
