ant-ivy-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Gilles Scokart" <>
Subject RE: Working parallel on different modules without building and publishing jar files
Date Tue, 23 Jan 2007 07:59:34 GMT
I'm currently working on an alternative to ivyIDE : ivymakeclipse.

The idea is to generates .classpath from an ant task.

When it will be finished, the task will 
 - update the .classpath when changes are detected
 - reference libraries from the cache
 - support containers definition
 - support link to other project contained in the workspace
 - accept a type attributes allowing to link source jars, and javadoc jars
 - accept src subelement to specifiy where are the sources

The benefits compared to ivyIDE is that you are not forced to install a
plugin, and you control more things into you ant script.

It is not yet finished, there is still bugs, and the documentation is not
uptodate (I changed my mind during the implementation), but you can have a
look at it there :


> -----Original Message-----
> From: SELG Alexander [] 
> Sent: Monday, January 22, 2007 4:17 PM
> To:
> Subject: Working parallel on different modules without 
> building and publishing jar files
> Hi,
> I'm trying to setup our projects with ivy 1.4.1 in eclipse 
> 3.2 using the IvyDE 1.2 .
> I declared the module dependencies in the ivy.xmls and use 
> our cvs-repository to retrieve the artifacts.
> So far so good.
> Say we have a module "core" and a module "extension" which 
> depends on "core"
> ("extension" -> "core").
> I find a bug in a class of module "extension" and during 
> debugging I want to step into class C of the "core" module. I 
> find a bug in C and want to fix this bug and retest it, fix 
> it again and retest it again and so on ...
> I want to do this work in a very quick way (that means 
> without building any
> libraries) because there are many "extension"-modules and 
> many projects with projects-modules depending on the "core"- 
> and "extension"-modules (about 30 modules of our own and 
> about 60 thirdparty modules) - and I have to do this very often.
> We have done this so far in eclipse by changing the "Java 
> Build Path" in the properties of the eclipse "core"-module 
> (remove the core.jar in the Libraries-Tab and add the source 
> folder of the "core" module in the
> Source-Tab) - quite simple and you have the source available 
> in every module referencing classes of module "core".
> Pressing <F3> or stepping into a method of class C opens .
> Now I want to declare the dependencies between the modules 
> with ivy and I'm searching for an easy way to switch to a 
> "source-mode" of the modules I depend on.
> I know it is possible to attach sources and it's even 
> possible to do this automatically with ivy.
> But I don't want to attach the sources of the module "core" 
> to the core.jar because
> - I would have to build the "core" library to see the changes 
> a made (too much time for turn around)
> - during debugging I would open a core/C.class file and lose 
> the Hot Code Replace feature of the eclipse debugger (not 
> acceptable for our developers).
> I know it would be possible to remove the "extension" -> 
> "core" dependency in the ivy.xml and declare it again with 
> eclipse (.classpath, .project
> files) - a way for two modules but no way for 90 modules.
> I want that there is one particular point for the developer 
> to say, this module now in source please.
> Are there any possibilities to accomplish this with ivy; or 
> are there any other possibilities to handle this?
> Thanks,
> Alex

View raw message