Hello,

I have started on a Hibernate tool. It is a re-write of the hbm2java tool. My version uses ant and velocity and provides the user with a great amount of control of the generation. It is very easy to extend and can be used to generate almost anything (from DAOs to DDL to struts actions to unit tests)

I was wondering how I open-source it?
- Do I just donate it to the Hibernate project?
- Do I set it up on source forge?
- Can I put it on the hibernate wiki?
- Can I use the hibernate package or should I create my own.
- Can I use other open source code (i.e. from Apache)?
- If I use some Apache source code, should I leave their copywrite at the top of the file or do I just need to include their license file?
- Is their any restrictions on the jars I use (i.e do they all need to be open-source)

Thanks

Cool !

If you want to donate it to the Hibernate project the easist thing is to submit it via jira - and we can together take it from there.

Regarding using other open source code it's quite alright - just don't require something like Tomcat, Jboss or something of that size ;)

Secondly, if you are using some apache source code, you are probably using it as an external jar, right ? You can't INCLUDE apache source code into Hibernate - do you need that anyway ?

And you can primarily only use opensource external jars.
If you need any non-opensource we (and you) can't distribute it.

Now to the questions about your new hbm2java:

- have you used the contributed velocity renderer or is it a totally new implementation ? ;)

If yes - does it support the meta tags ?

Have you rewrote the parser ?

Just very curious on this since i'm actually doing the exact same thing ;)

Hello,

I started doing it as a way of getting to know Hibernate. I have done quite a bit of code generation at work (about 2 years worth) and I wanted to try out some new ideas.

Yes, it is a totally new implementation. It is based on Texen (an ant text generation task which uses velocity). I have spent about 16 hrs and have quite a nice generator. It is pretty small and very easy to extend. You have complete control over the templates and I have started putting together a set of tools that can be used in the templates (including java source code formatting).

The architecture is very simple. Use an ant task to run the generator and handle the loading of files, properties, classpath, etc. Use a plug-in parser to parse the hbm file and create a model. Stick the model into a control velocity template which calls other templates to generate the source code. Add a rich set of tools to do things like insert java docs, format code, load files, convert strings, etc.

The features are as follows (many are not yet implemented, but should not take too long):
- Generate text files using a very small, simple wrapper around ant and velocity.

- Powerful execution environment that uses the power of ant to define:
the classpath
scan directories
include / exclude file patterns (see FileSets)
execution arguments and properties

- Have a plug-in parser architecture (so you can write a plug-in that will parse other types of files.) These other parses can be used to parse everything from alternate products config files (switch from ORB to hibernate) to reverse engineering sql and java source to generating struts / web classes.

- Complete control over the files that are generated. Developers should be able to add new templates for things like dao's, unit test, ddl, etc by simply changing a template file.

- Complete control over source format, license text, code standards, etc

For the Hibernate parser (refactored from the existing hbm2java) ...

- A simple model that represents the Hibernate hbm file.

- A rich set of methods (that can be called from velocity) to generate the source.

- The xml as a dom4j model (which can be directly access from velocity.) This allows the generation task to access the very latest config changes without even changing the source code.

- Access to the meta attributes and the ability to easily (no code change to the generator) add your own.

- A rich set of tools in the templates including:
- Files Tools: Read files and write files
- Generator Tool: Load velocity templates, manipulate the context and generate output strings
- MetaAttribute Tool: Manage meta attributes
- String Tools: Format strings, convert strings, etc
- Xml Tools: Access config file elements directly (without any code changes)
- Java Tools: Source code formatting, java element parsing etc

All tools should be easily extendable. Users should be able to add any java class into the context and directly use its methods in the templates.

and finally a set of nice, clean, easy to change templates with features such as:
- Logging

- Regeneration support (Base class which contains 99% of generated code and the actual class which the user can easily extend). We have found it very useful to be able to generate a class over and over without ever effecting the custom code. For example, if you add a new field to the hbm file, you just regenerate over the Base class. Add to this the ability to check which class needs to be generated (date check) and which class has been customised (file attribute check).

- Support for validation and lifecycle interfaces

- xDoclet tags (just because it is so easy and would allow developers to switch from one type of generation to another)

The nice thing with my approach is it is so simple. Almost all my time is spent creating the templates and understanding the hbm file. I hardly have to spend any time working on the generation mechanics. Add to that the fact that it is so easy to extend and there is a large velocity skill base (plus the fact that you can use java classes directly from velocity) makes it a very easy tool to use. The approach is well proven (just check out the number of generation tools on sourcforge that do very similar things)

Hopefully, I will get to alpha stage in the next 2 weeks.

I would love to get your feedback.

Cheers

I would love to see the code.
Have you already somewhere to download ?

I was busy writing the same thing.

Same reason I entered the hibernate project - by improving hbm2java (then called CodeGenerator)

[qoute]
Yes, it is a totally new implementation. It is based on Texen (an ant text generation task which uses velocity). I have spent about 16 hrs and have quite a nice generator. It is pretty small and very easy to extend. You have complete control over the templates and I have started putting together a set of tools that can be used in the templates (including java source code formatting).

The architecture is very simple. Use an ant task to run the generator and handle the loading of files, properties, classpath, etc. Use a plug-in parser to parse the hbm file and create a model. Stick the model into a control velocity template which calls other templates to generate the source code. Add a rich set of tools to do things like insert java docs, format code, load files, convert strings, etc.
[/quote]

This sounds great!



If you got any chance of submitting this stuff to the JIRA immediatly it would be GREAT! Large parts of The Hibernate team will be together in real life (for the first time ever) at JAOO in Denmark and it would be great to talk about this new and improved hbm2java contribution.

I can handle any state of the code ;) I would just love to see it.

Hello,

I would love to share the code with the Hibernate team (and anyone else who is interested). I will spend a day or two cleaning / documenting it and then send it to you.

Yes, it is based on Texen, but I have extended it and cleaned up the code. (OK, developers can never leave anything alone)



At the moment I have a simple hbm parser. But there is nothing to stop you writing a simple parser that chains / invokes other parsers or even parses different types of xml files



The nice thing is the templates look almost like the final java files.



Not sure if it is in the version of hbm2java I have seen Hibernate 2.1 b1.
I will try use the existing way. I am note sure if hbm2java generates all files or only the ones for the xml that has changed. I normally mark all generated files as "read-only". That way the user (1) is reminded that the java is generated and should not be altered lightly (2) if changed to write-able, the generator does not overwrite it (a bit backwards, but works like a charm with IDEs and CVS)



If you look at hbm2java, the renderers are quite large classes. With velocity, these disappear and you can spend the time on other (more interesting) parts of the system.



As I said at the start, give me a day or two to clean it up. I will then send it to you. Maybe we could even pair on the development. Particularly as I am very new to Hibernate and it takes me a long time to figure out how to parse the hbm file and what the resulting template should look like. However, the velocity / ant / code generation part I can do in my sleep.

Cheers






[/quote]

great - but it would really be nice if could just get a glimpse of it - after tomorrow it's going to happen a 1000's things the next 5-6 days and here i probably can't find much time to look at it......but then again, it is also fully ok if you don't feel like sharing it yet ;)



cool



yes - it's one of the good wins.



It is - it was the first tag for <meta> ;)
Look at meta attribute "generated-class"



Currently it generates for all the .xml files you give it.



It's cool - and one should not add complety automatically generated files to cvs - one should just add the hbm.xml files, right ?



Yes - and it's why I was about to add the contributed velocity renderer, so we would not require people to code/compile stuff to make changes to the generated code.





Sounds great - looking forward to it.

Hello,

My re-implementation of hbm2java is all zipped up and ready to send. It is in the very, very early stages of development but I think it will give you an idea of its direction. I have taken out all the jars (and just left a list of them in the directory instead). It is about 250k. How should I send it to you? I would prefer sending it directly (as I do not want to release the code just yet).

Cheers

I'm just beginning to write some tools that can be used in Eclipse or some other IDE like that.

Waiting for download!

Just send it to me directly - max AT hibernate.org

I would love to know more about/see this thing. It is exactly what I had in mind to replace our homegrown O/R generation-from-db-solution (done before middlegen was around). hbm2java is great, but I sometimes need more flexibility in the code generation. I assume it would be fairly easy to extend to generate basic DAO wrappers for the persistables, or is there a way to do that today?

Anxiously awaiting a look-see, Max.

Mike

it is possible to day - just make your own Renderer ;)

...that said, hbm2java will be extended so it supports/is velocity driven.

I've got a look at the "new" hbm2java stuff and I like the ideas, but it does not handle all the special cases that the current hbm2java does.

So, what I see is that the new ideas will be integrated into the current hbm2java in the nearest future - so we will get the best from both worlds.

Yeah - I am looking at doing my own renderer. I will wait for Velocity version to become available, and will create (contribute if anyone is interested) a DAO template.

Nice work, all.

Mike

I have seen a number of references to hbm2java generating XDoclet tags. But based on the source and trying it out, can I assume the feature is not yet implemented?

I was curious when we might see GavinLas's source or a merged version. Our team is about to start coding with Hibernate. I have put together a How-To process for using Hibernate on our project, taken primarily from, and with links to, the wonderful doc on the Hibernate web site. The XDoclet enhanced hbm2java tool would make it easy for our developers who are not familiar with Hibernate.

In terms of background, we are doing bottom up: database -> hbm -> java/xdoclet. Throw away the intermediate hbm.xml. We plan on refactoring the ugly DB2 names to nice class and property names in our IDE of choice. In our Ant build script, XDoclet will then generate the hbm.xml files.

Please let us know. The whole Velocity template approach sounds great.

Fred.

XDoclet from hbm2java is high on the TODO list. Max is rather busy at the moment though be assured it is important. The new velocity backend option could well make this easier to provide.