YPage dynamic pages

The Ypage language is as follows: HTML with embedded control structures. You can create these files in any character encoding that:

• is not multi-byte such as MBCS or UTF-16 (where every character takes more than 1 byte)
• has the normal ASCII characters in the lower 127 chars.

ISO-8859-1, ISO-8859-15 and UTF-8 are excellent examples. (also see the inputencoding declaration below).

<%for i ...:%>
    <%for j ...:%>
        in j loop
    <%end%>
    still in i loop
<%end%>

<%if a:
    if b:%>
        Text here
<%end%>

Recognised page declarations

(must be at the top of your Ypage file): (case-insensitive)

Recognised processing instructions:

YPage Templates

You can assign a template to your Ypages. Templates may contain page content that is used on multiple pages to define common elements such as a menu. Using a template, you only have to define the menu once. Templating doesn't work for snakelets: if you want to use page templates for snakelet output, you have to write an Ypage instead and redirect to that ypage from within your snakelet.

When you use the pagetemplate declaration you tell Snakelets to use that template Ypage instead of just running the current Ypage. Instead, the current Ypage will be embedded in the template page. Using the insertpagebody processing instruction you tell the engine where exactly to put the actual page inside the template. If you're using a default page template (webapp config), every Ypage that has no explicit pagetemplate declaration will be templated with the specified default template. To disable a default template, use a pagetemplate declaration with an empty value or 'none'.

Output encodings: the output encoding of the template page is ignored. The output encoding specified by the actual page is used instead! (input encodings work normally ofcourse: your template can be written as UTF-8 file while the pages itself can be ASCII).

Template page parameters: You can add url-escaped parameters to the template page declaration, like: ?arg1=foo&arg2=bar (or use the separate pagetemplatearg declaration, which might be much easier because the values don't have to be url-escaped). These parameters will be available from inside your template page code as self.PageArgs (a dict, like: {'arg1':'foo', 'arg2':'bar'}).

Dynamic template page parameters using special page method: There is a special reserved page method name, templateArgs, that is used to dynamically determine the values in the PageArgs dict. When you define it, like this:

<%@method=templateArgs(self, request):
    return { .... }
%>

it will be called for each page load (with the current Request object as a parameter, so that you can use that info too if you need it, for instance the session object, the user, etc) and the dict that it creates returns is added to PageArgs. If you need this, you must define this method in the templated page, not in the template itself (it's no use there...)

YPage class methods

A compiled Ypage inherits from Snakelet, so you have access to all methods from a snakelet. Also, some additional methods and attributes are defined:

Using self in Ypages to store data

Short: you shouldn't. Long: just like Snakelets, your Ypage code has no single, local, 'personal', environment it is running in. Your Ypage may be accessed concurrently by multiple threads (though in the current implementation, this is not so-- but don't count on this!) Only use local objects to store temporary data in, never create new properties on self! What you probably want to do is to use the request context object (self.RequestCtx) to put values on - that is safe and only lasts for the duration of the request.

Deleting the Session

If you want to delete the session, use: self.Request.deleteSession() From within the Ypage, you have no access to the Response object. Every sensible action with the response can be done with page declarations.