Assisting sunsets

Hyperjaxb3 0.5.6 is released

2011-07-10T03:26:00.001-07:00

I am very glad to announce the 0.5.6 release of Hyperjaxb3.
This release features two major highlights:

It also fixes a great number of issues, please see release notes here and here.

Jsonix 1.0 is released

2011-04-28T23:15:00.000-07:00

I am glad to announce the first release of, Jsonix.

Jsonix (JSON interfaces for XML) is a JavaScript library which allows you to convert between XML and JSON structures. Jsonix is essentially a JavaScript analog of JAXB.

With Jsonix you can parse XML into JSON (this process is called unmarshalling) or serialize JSON in XML form (this is called marshalling).

These conversions are based on simple XML/JSON mappings which can be written manually or generated from an XML Schema.

Project website:

http://confluence.highsource.org/display/JSNX/Jsonix

Downloads:

http://confluence.highsource.org/display/JSNX/Downloads

Download features:

Scripts
Schema compiler
Sample projects (batch/command line, Ant, Maven)
Demo projects

User guide:

http://confluence.highsource.org/display/JSNX/User+Guide

Mailing lists:

http://confluence.highsource.org/display/JSNX/Mailing+lists

Jsonix - JAXB for JavaScript

2010-10-27T02:39:00.000-07:00

Folowing up on the ideas from my previous posts, I've started the project called Jsonix (JSON interfaces for XML):

http://confluence.highsource.org/display/MISC/Jsonix

Jsonix is basically a JAXB analog for JavaScript. With Jsonix you can:

parse XML into JSON;
serialize JSON into XML;
define XML/JSON mappings declaratively;
generate Jsonix mappings from XML Schemas.

Here's a small example of how a JSON purchase order could be marshalled in XML:


var context = Jsonix.Context.newInstance([ PO ]);
// Marshal JSON as XML (DOM node)
var unmarshaller = context.createUnmarshaller();

var node = marshaller.marshal({
name: {localPart: "purchaseOrder"},
value: {
 shipTo: {
  name: "Alice Smith",
  street: "123 Maple Street",
  city: "Mill Valley",
  state: "CA",
  zip: 90952  
 }
}
});

This will produce an XML like:

<purchaseOrder orderDate="1999-10-20">
<shipTo country="US">
  <name>Alice Smith</name>
  <street>123 Maple Street</street>
  <city>Mill Valley</city>
  <state>CA</state>
  <zip>90952</zip>
</shipTo>
<!-- ... -->
</purchaseOrder>

And here's how you'd unmarshal:

// Unmarshal JSON from XML (retrieved from an URL)
var unmarshaller = context.createUnmarshaller();
unmarshaller.unmarshal({
url : "po.xml",
success : function(po) {
 assertEquals("purchaseOrder", po.name.localPart);
 assertEquals("Alice Smith", po.value.shipTo.name);
}
});

The project is in development, I'll be working on it next weeks.

Generating JavaScript Code with JavaScript Code Model

2010-10-16T01:34:00.000-07:00

JavaScript Code Model (JSCM for short) is a Java library which precisely models JavaScript grammar as defined in ECMAScript specification. JSCM allows you to programmatically create, analyze and manipulate JavaScript code.

This post demonstrates usage of JSCM to generate JavaScript code from a Java program.

Here's a code snippet which creates a factorial function:

// Instantiate the code model
JSCodeModel codeModel = new CodeModelImpl();
// Create the program
JSProgram program = codeModel.program();
// Add a function declaration
JSFunctionDeclaration factorial = program
 .functionDeclaration("factorial");
// Add a function parameter
JSVariable x = factorial.parameter("x");
// Create an integer literal
JSDecimalIntegerLiteral one = codeModel.integer(1);
// Add a return statement to the function body
factorial.getBody()._return(
 x.le(one).cond(
  one,
  x.mul(factorial.getFunctionExpression().i()
   .args(x.minus(one)))));

// Write the program code to the System.out
new CodeWriter(System.out).program(program);

This produces the following JavaScript code:

function factorial(x) {
 return x <= 1 ? 1 : x * factorial(x - 1); }

In this example we first produce the code model by creating expressions, statements, function declarations and so on and then use code writer to serialize the created program into the System.out. This process almost guarantees that the resulting code is syntactically and grammatically correct - and well-formatted as well. And I hope the API is very convenient - especially if you compare it to the "good old" string concatenation.

In the future I'll also provide a parser which parses JavaScript code and builds its model. It will then be possible to analyze existing JavaScript code and manipulate it - for instance add profiling statements, reformat, restructure, refactor, optimize or obfuscate.

JavaScript Code Model 1.0 released

2010-10-16T01:17:00.000-07:00

Last few weeks I've been working on the JavaScript code model, the idea I describe in my previous post.

Now it is ready and released. Here's the project page in my Confluence and a generated Maven Site.

Now I can go on with my idea of JAXB analog for JavaScript. My plans are:

Write a JAXB plugin which would generate XML bindings for JavaScript objects in form of JSON. This is analogous to JAXB annotations.
Write JavaScript runtime to parse (unmarshal) JSON objects from XML or serialize (marshal) these objects back to XML. This is analogous to JAXBContext.

In the next post I'll give an example of how JSCM can be used to generate JavaScript code.

JavaScript Code Model

2010-09-29T15:37:00.000-07:00

I was recently looking for a JAXB-like API for JavaScript which would allow converting between XML and JavaScript objects on the client. Such tool would be extremely useful when working with schema-based XML documents in JavaScript clients.

Apparently, there's no such thing. So I've started thinking about writing one. To put it frankly, the idea fascinated me so much that I simply could not help starting experimenting.

Today I've started with a code model for JavaScript. I'm writing an API which would allow generating syntactically correct JavaScript from Java. This will be somewhat similar to the code model library used in JAXB/XJC, only implemented for JavaScript. I took the ECMAScript specification and a couple of grammars and wrote over 50 interfaces which model the grammar of the JavaScript code. Here's a couple of examples of what I got so far:

JSProgram program = codeModel.program();

JSNumericLiteral one = codeModel.lit(1);
JSFunctionDeclaration factorial =
 program.declare("factorial");
JSVariable x = factorial.parameter("x");
factorial.body()._return(
 x.le(one).cond(one,
   x.mul(codeModel.call(factorial).args(x.minus(one)))));

This should produce the code of the factorial function like:

function factorial(x)
{ return x <= 1 ? 1 : x * factorial(x - 1); }

The conditional could be rolled out into an if statement:

JSIfStatement _if = factorial.body()._if(x.le(one));
_if._then()._return(one);
_if._else()._return(
 x.mul(codeModel.call(factorial).args(x.minus(one))));

I need this to be able to generate XML-JSON mappings in correct JavaScript syntax. String concatenation just does not feel right.

But what's probably the most important is that it's great fun to work on this. :)

Juneloop - tool for programmatic manipulation of JNLP files

2010-09-26T04:53:00.000-07:00

We recently needed to create a JNLP file for Java Web Start programmatically from a template. Basically we needed to add a property element to an existing JNLP file. There were also similar requirements from a project partner, so all in all it goes into a direction of programmatic manipulation of JNLP files.

Since JNLP is defined in DTDs (1.5, 6.0) I though this would be a good JAXB project (and a good demo case for Maven JAXB2 Plugin). All I needed to do is compile JNLP DTDs with XJC, add a couple of tests and here you go:

Juneloop, a tool for programmatic manipulation of JNLP files.

With Juneloop you can:

unmarshal JNLP resources;
create or modify JNLP object structures programmatically;
marshal JNLP object structures.

See Juneloop documentation here:

http://confluence.highsource.org/display/MISC/Juneloop

Juneloop is hosted on Sourceforge:

https://sourceforge.net/projects/juneloop/

Long Time No See

2010-09-26T04:34:00.000-07:00

It was quite a while that I posted last time to this blog. In this time I did a huge amount of work on my open-source projects (visit confluence.highsource.org and see for yourself).

Now I've decided to come back to this blog and to use it to post announcements and updates about my OSS activities. New projects, new releases, new initiatives.

I'm certainly not hoping for a huge audience (I'm bad in marketing anyway), I just need an instrument which would help me to keep track of my developments. An maybe this will help you to find one or another useful tool.

Hyperjaxb3 0.4 to be released pretty soon

2008-07-28T23:02:00.000-07:00

Hi everyone,

I'm writing now just to inform you guys on the process.

Last few month I was intensively working on Hyperjaxb3 version 0.4 and now it's ready. This version has gone through a large refactoring. I'll post the details in the release description but here's a couple of hightlights:

Previously HJ3 could only generate JPA annotations. The 0.4 version can also generate ORM mappings as XML resources (in this schema).

New version introduced global customizations. Now you can customize generated mappings globally. For instance, you can instruct Hyperjaxb3 to map complex collections as many-to-many (instead of default one-to-many), choose between join-column or join-table association strategies per default and many other things.
I've added more tests, more sample and template projects to help people start with HJ3 more easily.

As I said, HJ3 version 0.4 is ready and you can get it from the dev.java.net Maven2 repository. Next days I'll be working on documentation and release description, so it's not an "official" release yet. Stay tuned.

ps. Along with HJ3 version 0.4 there's also new versions of Annox and Jaxb2-commons available.

Hyperjaxb3 Release 0.3

2007-12-21T00:49:00.000-08:00

I'm currently preparing the 0.3 release of Hyperjaxb3.

In the 0.3 version I worked mostly to extends the set of supported schemata. I'm really grateful to all the people who sent me their schemata. This helped to find out which cases are practically important so I could concentrate on real-world scenarios. As a result, the set of schemas supported by Hyperjaxb3 is becoming very large. Below are just some examples of schemata from the test cases (which includes more that four dozen schemas):

BibTeXML - bibliography XML schema

ebXMLRR - ebXML Registry Reference

IMS ePortfolio and LIP - eLearning

IODA - digital music distribution

NewsML and SportsML - news and sports news markup languages

PLM XML- manufacturing components

SBML - Systems Biology Markup Language

SEPA - financial exchange in Single Euro Payment Area

XACML - eXtensible Access Control Markup Language

These are just some examples of the schemata Hyperjaxb3 currently support. I'll be working to extend the supported set to 100% (literally any schema) in the 0.4 version. It's just few cases left.

In this release I've also updated the versions of maven-jaxb2-plugin (0.5) and JAXB (2.1.6) to take advantage of the latest developments in these projects.

Please visit the release announcement page.

Here's a couple of examples for Maven and Ant.

Hyperjaxb3 Release 0.2

2007-09-20T01:12:00.000-07:00

Yesterday I've released Hyperjaxb3 version 0.2.

It was a very long way, but finally we've managed to produce a version which can be presented to the public.

I've managed to overcome most of the JPA limitations (take a look at the reference, I describe those in quite a detail) and make Hyperjaxb3 support a really large set of schemas.

The project is very well tested. By testing I mean real integration testing with roundtrips. It's not about that schemas are just compiled or something. I do test that sample XML data survives unmarshalling-storing-loading-marshalling without loss.

Hyperjaxb3 is (well, relatively) well-documented. We also provide sample projects for Ant and Maven so I hope you can get started really quickly.

I was yesterday asked if the project is production-ready. My answer is yes. Runtime code is minimal and quite stable. Correctness of the generated annotations is checked by numerous tests. Documentation and sample projects available. Therefore I can answer - yes, it is ready for production.

Still, it's 0.2. I'll work to support more schemas, more customizations and tuning options.
I also plan to support vendor-specific extensions. However these modules may be released as a commercial product (I'm not sure yet).

So you are welcome. :)

Hyperjaxb2 0.6.2 released

2007-04-03T01:46:00.000-07:00

I've not posted to this blog for a while.

The work on Hyperjaxb2 goes just fine. I've released the 0.6.2 version last week.
Here are the download links:

Distribution Minimal

Basic Template Ant|Maven

Nokis Sample Ant|Maven

PO Initial Sample Ant|Maven

PO Final Sample Ant|Maven

Currently I'm working towards the 0.7.0 release which will also include an example of a web service sample application on Spring/Spring Web Services, Hibernate/JAXB/Hyperjaxb2.

So the work goes on just fine.

Hyperjaxb progress

2006-10-12T04:02:00.000-07:00

A lot has been done last weeks.

I've release Hyperjaxb2 0.6.0 which became quite mature. I'm looking to make an 1.0.0 release in two weeks. Actually, the only thing to be done is the documentation. It's a bit obsolete so I have to refresh few sections. Promotial material. Nice presentations. Just to let people know.

Other than that, Hyperjaxb2 is very nice right now. I've added sample projects (for Ant and Maven) - make it really easy to use.

I've also worked on Hyperjaxb3. Well, this will be a killer. "Unschlagbar" as germans say.
It seems like I'll have three main parts there: Hibernate, EJB3 and JDO.

Hibernate part is just Hyperjaxb2 ported onto JAXB2. It generates *.hbm.xml and *.cfg.xml, that's it.
This part work already. I've just deployed four test scenarios (out of 24) and they work and I see no reason the other 20 woul fail. I just have to deploy them. So this is ready to be released quite soon.

As for EJB3 - I've been experimenting and achieve some progress.
My first task was to write a roundtrip test case. I had to learn how to use the whole thing, how to package and so on. It's far from being trivial, and I was finally glad when i could roundtrip my XML in the frame of a unit test.

After that I wrote a small ejb3 add-on for JAXB2. It adds EJB3 and Hibernate annotations to the classes generated by JAXB. And, finally, the "po" examle worked! Of course it's just the beginning, the test scenario is trivial, but it works.

However I'm a bit upset with EJB3 spec. I think it's simply immature.
What I'm missing is:

Support for collections of simple type. Without that you can't persist things like List. And it's not unusual to have that in classes.

Custom types. EJB3 supports only a iminimal set of types. Just when you're a little bit above usual with the types you have in your classes, you're stuck. You can't persist things like URL or XMLGregorianCalendar and so on.

No custom accessors. Just field or property.

So the problem with EJB3 is that I can't use just EJB3 with JAXB. I need more and this means I have to become vendor-specific. I can surely imagine a vendor-independent solution but with a lot of additional code to cover all these "missing" cases. I think I'll start with Hibernate Entity Manager then TopLink Essentials then Kodo JDO...

Today I've also made some experiments with JDO. I've taken a JPOX sample and made it work with Maven2. JDO seems to be pretty cool, I really liked that I could make a unit test run in less that 15 minutes. I liked so much that I'll surely support this in Hyperjaxb3. I even think I'll make the po test scenario run on JDO before I go on with further EJB3 implementations.

First roundtrip test case running with Hyperjaxb3

2006-06-13T10:10:00.000-07:00

Today I've managed to execute the very first roundtrip test case with Hyperjaxb3. It's a primitive example with well-known purchase order schema, but it's a good starting point anyway. See tests/po.

In order to execute the test, you'll need to check out my changes to the JAXB 2 Maven plugin. Check out the Lexi2 branch from jaxb2-sources/jaxb-maven2-plugin and mvn install it. I hope we'll have these changes in the main branch (and maybe in the repository) soon, so it's a temporary inconvenience.

Hyperjaxb3 - EJB3

2006-06-12T03:33:00.000-07:00

Since I'm no EJB3 expert, I will really need assistance with EJB3 issues. I'll list my current EJB3 problems in this post. I'd be glad if experts comment.

EJB3 roundtrip test case

I need a roundtrip test case for EJB3. I've described what roundtrip test case does in one of the previous posts (unmarshall, save, load, compare).

EJB3 and accessors

I use custom accessors with Hibernate3. First of all, they help with collection fields: JAXB generates no setter, and my custom accessor uses property-based getter and field-based setter to avoid the need to generate a collection setter. Another reason is that custom accessors may take advantage of isSetXXX methods generated by JAXB, for instance to distinguish null and 0 for primitive numeric types. Is it possible to condigure property accessors in EJB3?

Collection of primitive types

How do I map a collection of primitive types (for instance strings) with EJB3? Something like List<String>?

I think it's all for now.

Hyperjaxb3 target platforms

2006-06-12T03:26:00.000-07:00

Hyperjaxb2 only had a single target ORM platform and that was Hibernate/HBM file-based mappings. Hyperjaxb2 has literary generated HBM files for the classes generated by JAXB.

In Hyperjaxb3, we'll have multiple target platforms. Hibernate3/HBM is one of the, but I'm looking forward to have EJB3/Hibernate3 with annotations or even JDO if it's somehow relevant.

Each of the supported ORM platforms will have its own generating plugin. At the same time all the platforms will have the same analyzis block (detecting the cardinality and the type of the field). I think the strategy approach used in Hyperjaxb2 is quite reasonable to use here. We'll only need to implement a set of strategies (like single primitive field strategy, complex collection field strategy) for all of the platforms.

Hyperjaxb3 roundtrip tests

2006-06-12T03:17:00.000-07:00

Roundtrip tests are used within the integration testing in order to check if the generated O/R mapping (be it HBM files or annotations) are allright.

Typical roundtrip test senario is as follows:

Unmarshall the file/resource.

Save the unmarshalled object into the database, memorize the id.

Load the object from the database by the memorized id.

Compare unmarshalled and loaded objects, check identity.

I've already implemented a roundtrip test case for HBM file-based Hibernate mappings (see org.jvnet.hyperjaxb3.hibernate.roundtrip.RoundtripTestCase). You only have to subclass this class in the target package and specify which sample files should be used for testing (see org.jvnet.hyperjaxb3.hibernate.roundtrip.tests.RoundtripTestCaseTest). The tests runs versus the in-memory HSQLDB database, database schema is automatically generated, very easy to use.

I'll need such a roundtrip test for each for the target ORM platforms.

Hyperjaxb3 tests

2006-06-12T03:06:00.000-07:00

Hyperjaxb3 is primarily a code generation/augmentation library. This means we not only need to test how individual classes/methods work, we also have to check if code generation works as a whole.

Therefore there are actually two types of tests:

Unit tests

Test behaviour and functionality of individual classes and methods. Unit tests accompany the main code, they are stored in the test directory (normal Maven convetions).

Integrated tests

The overall process of code generation (generation, compilation, roundtrip testing) can only be implemented in separated test projects. Test projects are positioned as sub-modules of the tests module. Each test project has its own pom.xml file with all the definitions needed to build this project. Test projects should also contain the roundtrip test case/suite which is executed during the test phase.

Hyperjaxb3 project structure

2006-06-12T02:55:00.000-07:00

Hyperjaxb3 consists of the following modules:

hibernate-mapping

This module is the Hibernate Mapping DTD compiled compiled into Java classes using JAXB. This is used to generate Hibernate mappings as Java object structures rather than XML.

tools

Utility package analogous to the jaxbcommons project for JAXB 1.x. This module contains all kinds of tools for JAXb and XJC. At the same time there is no runtime code in this package.

core

Core generation module. This module will actually contain plugins to generate mappings and/or annotations.

runtime

Classes used in the runtime, for instance Hibernate accessors or custom types. This will be the only module/jar used in the runtime.

testing

Testing routines. Among others contains plugin test cases and roundtrip test cases.

tests

This module contains test projects.

The first post

2006-05-28T11:34:00.000-07:00

This blog is intended as my technical journal on the things I used to, do, or plan to develop. I'm no technology evangelist anymore, just have to track and gather some of my thoughts for them not to get lost.