Sylvain Wallez

i think validation rules should be external to the form. but one should have the ability to also place rules inside the form, because sometimes for certain views you want to have tighter restrictions.

Credit where credit's due: that integration code comes from Christophe Oliver (coliver@apache.org), and not Andy C. Oliver (acoliver@apache.org). As much as Andy's rants amuse me, his only contribution to the Cocoon code base so far has been the HSSF serializer, which he doesn't consider to be a POI issue anymore. About XMLForm vs Woody, I'm pretty sure you know which framework will be the better supported/documented one ;-)

In Woody, validation rules aren't really specified in the form layout. The form definition file doesn't contain any layout information at all. In a sense, it describes the schema of the form.

As for Woody vs XMLForm, just use the best tool for the job. I'm sure you're able to support yourself either way :-)

Bruno, as I explained in my update, I was actually confused by the naming of files ("form definition file" is a actually a schema).

As for the best tool to use, don't be afraid : I know where the community and the good work is. But this also means I will input my requirements there ;-)

Be sure it is different... at least in one major aspect: the abstraction of the the schema. One word - Schematron.

Ivelin and me disunited about the use of Schemtron. IMNSHO Schematron is not very well suited for form validation from the *machine* point of view. And I always wanted to automagically generate client side validation, too. This is almost impossible with Schematron because you basically only have one type of validator: the xpath expression validator. Easy to understand for humans - but not to generate javascript. But this could have been ignored.

Much worse: having the view definitions implicitly inside the Schematron schema (the phases concept) mixes concerns!

ups ...or did you mean compared to woody?

Yes Torsten, the comparison was with Woody ! Both are schema-based, and I really would like to see a single framework for schema-based forms (be it relax, WXS, woody, commons validator, etc).

First of all, Sylvain, I'd sure be interested to take a look at your demo.

For some of your points, I'd prefer to just answer something like "hmmyeahno", but I'll try to translate feelings to rational arguments :-)

* a repeater could indeed accept new items coming from the request. In fact, the current form demos work completely stateless, nothing is stored in the session.

* XPath is an XML-oriented language, and may not make sense for Woody's purposes. I say may, because I didn't put much thought to it yet, I just reused xReporter's query language. I don't know jexl, I'll take a look at it. On the other hand, the expression language is dead simple (which is also important, since form definitions should be easy enough to be created by non-programmers, and it may also help in translating them to javascript equivalents).

* Then about Precept. I think the only point where Precept and Woody resemble is that they both use a tree-like datastructure that is constructed by and validated against some kind of schema. Woody's "schema" is however strong on validation of individual fields, and doesn't really have structural validation (or in fact, the instance always conforms to the schema because the schema leaves no choices). On the other hand, the items in Woody's form instances (the widgets) can hold whatever data they like, such as Long or Date objects, while with XML it's all text.

I think the effort required to make a general XML-based, WXS/RNG-grammar based form solution, just isn't worth it, at least not for many of the common form requirements (you could of course dumb-down XML and WXS or RNG to an easy manageable subset, but please lets not call them by those names anymore then. That's just confusing). WXS/RNG are strong at describing the structure of XML documents, while for forms, the end-user doesn't care about structure, (s)he just fills in individual fields (and because of this, the end-user would often probably not be able to fix any structural validation failures -- let alone understand them).

The form designer would also need to have a fair bit of advanced XML knowledge, while the goal of Woody is to make creating forms really easy.

As a side-remark, it bothers me somewhat how WXS, RNG and even commons-validator are mentioned in one go just as if they are equivalent. Just the difference in power between WXS and RNG is enormous. For example, while I could imagine implementing a partial validator for WXS, I wouldn't know how to do this for RNG.

test