I'm still not sure that I understand the motivation to change from using
createTask to the keyword style syntax. I think this looks less like normal
groovy code (which makes it harder to initially understand). Perhaps I'm just
ranting about DSLs in general, which are always a balance between convenience
and ease of learning.
That said, if you are going to use a keyword style syntax, I would prefer a
keyword to create a new task that looked more like a verb - perhaps createTask
or newTask. I think the keyword task is confusingly close to the Project.task
methods and Project.getTasks. If I was going to the javadoc to try to
understand what methods in project were available to me, I would find this
confusing.
There is already a method to add actions to a task. Why is the "<<" syntax
needed? It just seems like more non-obvious magic. Could you not just use:
task hello.doLast { stuff to do }
I do like the idea of making more of a distinction between action closures and
configuration closures. The 0.5.2 syntax was confusing initially.
Hans Dockter wrote:
We plan to make another change to the Task DSL before we release 0.6.
At the moment the behavior that if you pass a closure to an existing
task, the closure is used for configuring the task object. If you pass a
closure to a task when creating a task, this closure is used as an
action. The reason for this behavior is that we wanted to make Gradle
behave as convenient as possible for the major use cases. If you create
a simple task like HelloWorld, you usually don't want to configure it
but want to add an action. And if you are accessing a task provided for
example by the Java plugin, you usually want to configure it. The
pay-off for this behavior, is that it can be a bit confusing at the
beginning. And it is different from the normal Gradle behavior, which
always uses closure assigned to objects for configuring them. The use
case that made us change our mind about what is the best behavior, is
when you don't create simple tasks but tasks of a custom type (e.g.
Jar). In such a case you often want to configure the tasks when you
create it (in contrast to simple tasks).
We plan therefore to change the DSL in the following way:
task hello << { <action> }
task hello { <configure> }
task myJar(type: Jar) { <configure> }
existingTask << { <action>} // equivalent to existingTask.doLast
existingTask { <configure> }
We were also thinking about using the work 'do' instead of <<. That
would be nice to read. But this is not trivial to implement in Groovy.
And the << operator is already used in Groovy for adding elements to a
list, which is something similar to adding an action to a task.
Feedback is very welcome
- Hans
--
Hans Dockter
Gradle Project lead
http://www.gradle.org
--
Steve Appling
Automated Logic Research Team
---------------------------------------------------------------------
To unsubscribe from this list, please visit:
http://xircles.codehaus.org/manage_email
