[TYPO3-50-general] Templating Engine - Validation and Autocompletion

[Malte Jansen]

Hi Sebastian,

it's not something directly with the validation and autocompletion, but 
it would pretty cool if a template could be automcatically connected to 
a model.
E.G.
If you have an model of an article you could add an @template-tag to the 
class, which would provide a default template defined in a certain 
folder with a certain, which will render the object as string 
(MagicMethod __toString).
In most cases you'll have to render a model.
Perhaps something F3::MyPackage::Model::MyModel->rendered($renderType = 
'HTML|XML|...') with F3_MyPackage_Model_MyModel_"RenderType".F3TML
would be an easy option...

I just wanted to write it down, before I forget it again ;)

Perhaps there are some other ideas for Sebastian...

Cheers,

Malte



Sebastian KurfŸürst schrieb:
> [ It's a long mail, but I hope it is still worth reading :-) ]
> 
> Hello everybody,
> 
> (I use a new thread here because I think most people care about 
> validation, and many people mentioned it that this was important.)
> 
> 
> I've spent the most of the last two days to dive into DTDs, XML Schema, 
> Eclipse XML editing, and these topics. (Those who follow on [3] might 
> have noticed ;-) ). I've come up with some conclusions and and ideas how 
> we might proceed - and I have some really cool video to show - so read on!
> 
> 
> 
> What is Validation?
> 
> As many people say that they want fully validatable templates, I think 
> we need to talk about what this really means.
> 1) Many people mean "Well-Formedness" [1] by that. This means the 
> document has to be syntactically correct, and there won't be any 
> semantics checking.
> 2) Really validating the input file against a DTD / XML Schema 
> Definition. This means we actually want to check the Syntax and the 
> Semantics as well.
> 
> Let's take an example:
> Many say that "PHPTal Templates are validatable", and this is correct, 
> but they can _not_ be validated really because the PHPTal Developers did 
> not write a DTD or Schema for that.
> I bet they'd like to, but actually it is quite difficult to "extend" 
> XHTML by some tags (See [2] for more information on that).
> 
> It is easily possible in most Templating Systems to create well-formed 
> XML documents (smarty, phptal, ....., beer3 as well).
> However, I do not know a single templating system where you can actually 
> _validate_ the template (which is a mixture of templating tags and 
> XHTML, that's why validation is so difficult). [I don't count XSLT as a 
> template engine here :-)]
> 
> 
> 
> 
> Do We Need Validation?
> 
> What we typically care about is that the resulting page is XHTML 
> conformant. It would be really nice to check all this during input time, 
> however this turns out to be quite difficult:
> The XHTML DTD/Schemas were not made for extensibility, for a long time. 
> (See [4])
> However, this changed some time ago with the "XHTML Modularization" [2] 
> W3C Recommendation. They basically restructured their DTDs and Schemas 
> to allow adding custom tags to them - which is what we would like to do.
> 
> The last two days, I first tried to add an example tag, and I could not 
> even get their pre-packaged examples (which they provide as ZIP file, 
> everything included) running in my eclipse with proper validation and 
> auto-completion.
> 
> That's why, after a long phone call with Bastian, we decided to move the 
> focus a bit for now:
> 
> Most people know the XHTML tags, and know the attributes they need in 
> their daily life. Besides, there are nice editors for it (like the 
> Eclipse HTML editor), providing Autocompletion etc.
> However, what they don't know, is what templating tags exist, and what 
> arguments they have - so I think most people need some autocompletion 
> and want some help in this area.
> 
> And this leads us to the new topic:
> 
> 
> 
> 
> Autocompletion
> 
> The approach we are following now is as follows:
> 1) We write a pseudo-HTML XML Schema, which (currently) allows all HTML 
> tags with all attributes, and does not care about the nesting.
> -> To me, that's not really a big problem, because I can XHTML validate 
> the template _output_ and for real autocompletion, I could use the 
> Eclipse HTML editor f.e.
> 
> 2) There is some automatic Schema generated from the view helpers, which 
>  includes the documentation of them, parameter names, mandatory 
> parameters, etc.
> -> If you include this Namespace, then you'll get Autocompletion and 
> inline help -- see for yourself below!
> 
> 
> This means we have perfectly validatable templates (according to our XML 
> Schema, which does currently _not_ fit perfectly to the XHTML Schema), 
> and I can use Helper-Autocompletion. For HTML Autocompletion, we can 
> just use an HTML editor.
> 
> In case somebody is not satisfied with the custom XHTML Schema, I'd be 
> perfectly happy to take any solutions concerning either a more perfect 
> XHTML Schema definition, or maybe somebody even makes it work with the 
> standard extensible schema (which would be the non-plus-ultra solution).
> 
> So what this really means is that all our view helpers will have an 
> automatically generated Schema with them, and you can see right in your 
> editor if you missed a mandatory argument or added one argument too 
> much, etc.
> 
> 
> 
> Autocompletion - The Video
> 
> 
> That's the URL:
> 
> http://other.garbage-group.de/templatingAutocompletion.mov
> 
> The XML Schemas behind this demo are currently hand-written, but are 
> written in a way that they can be easily generated. I just wanted to 
> show you how it feels like to have such an autocompletion :-)
> I think it's just amazing - and nobody apart from JSP taglibs (which are 
> hard to write) has such a feature IMO :-)
> 
> 
> 
> 
> 
> Why Schema / no DTD - as DTDs are much easier to write?
> 
> - Because Schema can specify Comments which are used by Eclipse, DTD not
> - Because DTDs don't support namespaces (that's the main problem).
> 
> 
> 
> 
> OK - I think that's it, I would be really happy about your thoughts! Do 
> you like it so far? Should we implement it? Do you see some drawbacks?
> 
> Greets,
> Sebastian
> 
> 
> 
> 
> [1] http://en.wikipedia.org/wiki/XML#Well-formed_documents:_XML_syntax
> [2] http://www.w3.org/TR/xhtml-modularization/
> [3] http://code.typo3.org/status/
> [4] This is because the schema defines f.e. "the <html>-Tag has
>     exactly two children: <head>, and <body>, and _NOTHING MORE_.
>     Thus, we have to modify the schema and can't just extend it.