Hi Hans,
hdockter wrote:
>
>
> It might be also a good use case for implementing rules or synthetic
> dependencies as offered by Rake. http://docs.rubyrake.org/user_guide/
> chapter03.html
>
> What do you think?
>
I think it is tricky for C++. There are several reasons:
1. it is hard to code such rules without being dependent on the OS. e.g.,
invoking gcc and cl (visual studio's compiler) are very different. I want a
plugin that will be able to compile on all platforms, so the plugin will
need to provide the compilation command, not the user. so the user can only
supply the dependency.
2. modern compilers can usually create dependencies for you. what there is
left is mapping of source paths to output paths, which is better done
through using the convention object.
The only selling point here (for me) is that creating such rules allows to
incorporate file generation, but this can easily be replaced with a
'gen-sources' target.
hdockter wrote:
>
> Groovy, although an dynamic language, offers a kind of static typing
> which Gradle usually uses. So how to do IoC then? What you can do is
> to say:
>
> dependencies. moduleDescriptorConverter = [convert:
> {DefaultDependencyManager dependencyManager ->
> myLogic
> myReturnValue
> } as ModuleDescriptorConverter
>
>
Thank you for the explanation. I agree that with the examples you gave IOC
is not required.
I think I can make some progress now. Thanks for the help.
Ittay
--
View this message in context:
http://www.nabble.com/design-question-tp17848015p17859893.html
Sent from the gradle-dev mailing list archive at Nabble.com.
---------------------------------------------------------------------
To unsubscribe from this list, please visit:
http://xircles.codehaus.org/manage_email
