|
1. Gordon's Lawn Happenings
|
Our examples will be based on a fictional web site that has a single page:
<html> <head><title>Gordon's Lawn Happenings</title></head> <body> <h1>Gordon's Lawn Happenings</h1> <h3>Sunday</h3> <p>We've got a groundhog. I will have to stay alert.</p> <p>I lost half a tomato plant to that furry guy.</p> <h3>Monday</h3> <p>The grass grew - I saw it.</p> </body> </html>
We've got a groundhog. I will have to stay alert.
I lost half a tomato plant to that furry guy.
The grass grew - I saw it.
All the example source code may be extracted from the docgen_tutorial.py script that is included with Templayer by running:
python docgen_tutorial.py -s
The first thing we need to do to use this page as a Templayer template file is to add a contents layer to it. This is done by adding the strings "{contents}" and "{/contents}" to the file:
<html>
<head><title>Gordon's Lawn Happenings</title></head>
<body>
<h1>Gordon's Lawn Happenings</h1>
{contents}
{/contents}
<h3>Sunday</h3>
<p>We've got a groundhog. I will have to stay alert.</p>
<p>I lost half a tomato plant to that furry guy.</p>
<h3>Monday</h3>
<p>The grass grew - I saw it.</p>
</body>
</html>
Templayer searches the template file for the first occurrence of "{contents}" and the last occurrence of "{/contents}". This splits the file into three parts: the header, the content and the footer.
The header and footer will appear in Templayer's output. The content is described in sections below.
import templayer
import sys
sys.stdout.write("Content-type: text/html\r\n\r\n")
tmpl = templayer.HTMLTemplate("lawn2.html")
file_layer = tmpl.start_file()
file_layer.open()
file_layer.close()
This is a minimal CGI script that uses Templayer to display the web site. The result of running this script will be the same as if we just used the static page above.
We first create an HTMLTemplate object to handle parsing of the template above.
The start_file function creates a FileLayer object that will use the our HTMLTemplate object. The FileLayer object handles a single output run for our template. The start_file function allows you to pass in a file-like object to use instead of the standard output. For a CGI script we use the default.
The FileLayer object's open function will be explained below.
No output is written until the close function is called at the end of the script. If you don't get any output from your script it might be because you forgot to call the close function on your FileLayer object.
The next step is to add slots to the header and footer of the template. Slots are like variables that can be filled in by the application. In the template file slot names are wrapped in "%" characters:
<html>
<head><title>%title%</title></head>
<body>
<h1>%title%</h1>
{contents}
{/contents}
<h3>Sunday</h3>
<p>We've got a groundhog. I will have to stay alert.</p>
<p>I lost half a tomato plant to that furry guy.</p>
<h3>Monday</h3>
<p>The grass grew - I saw it.</p>
<hr>
<p>Generated on %date%.</p>
</body>
</html>
We have added two %title% slots to the header and one %date% slot to the footer of this template.
Please note: "%" is not a special character in Templayer templates. You do not need to escape "%" characters that aren't part of a slot. When filling slots Templayer has a list of slot names and it only replaces those slots, leaving all the other "%" characters in the template intact.
import templayer
import time
import sys
sys.stdout.write("Content-type: text/html\r\n\r\n")
tmpl = templayer.HTMLTemplate("lawn3.html")
file_layer = tmpl.start_file()
file_layer.open(title="Gordon's Lawn Happenings",
date=time.asctime())
file_layer.close()
Essentially only one line has changed in the code. The open function takes keyword parameters where the names of the parameters correspond to slots in the header and footer. Here both %title% slots will be filled with "Gordon's Lawn Happenings", and the %date% slot will be filled with the current date and time.
The values passed in to fill slots are interpreted by our HTMLTemplate object. The HTMLTemplate object expects HTML Markup described by the expand_html_markup function. Plain strings are treated as unsafe in HTML Markup and any characters that might be interpreted as HTML are escaped by this function. This means that Templayer's default behaviour is to escape values being filled into HTML templates.
We've got a groundhog. I will have to stay alert.
I lost half a tomato plant to that furry guy.
The grass grew - I saw it.
Generated on Thu Jun 14 09:04:15 2007.
Now we look at what we can do with the content of a template file. You will recall that this refers to everything between the first occurrence of "{contents}" and the last occurrence of "{/contents}" in the template file.
<html>
<head><title>%title%</title></head>
<body>
<h1>%title%</h1>
{contents}
{report}
<h3>%day%</h3>
%happenings%
{/report}
{/contents}
<hr>
<p>Generated on %date%.</p>
</body>
</html>
We have now added a {report} layer to the template, and we have removed the "Lawn Happenings" from the template so that the application can fill them in. Layers are placed one after the next in the template content. The {report} layer extends from the first occurrence of "{report}" to the last occurrence of "{/report}" in the template content. Layers have slots just like the template header and footer.
Splitting HTML into separate layers lets us reuse the layers throughout the generated HTML, consolidating duplicated layout information. This template format can also be loaded in a web browser to test changes without running the application. Most templates can also be validated for compliance with HTML and CSS specs.
import templayer
import time
import sys
sys.stdout.write("Content-type: text/html\r\n\r\n")
tmpl = templayer.HTMLTemplate("lawn4.html")
file_layer = tmpl.start_file()
main_layer = file_layer.open(title="Gordon's Lawn Happenings",
date=time.asctime())
main_layer.write_layer('report', day="Sunday", happenings=[
"We've got a groundhog. I will have to stay alert.",
"I lost half a tomato plant to that furry guy."])
main_layer.write_layer('report', day="Monday", happenings=[
"The grass grew - I saw it."])
file_layer.close()
We are now storing the return value of our FileLayer object's open function. The return value is a Layer object that represents the whole file. It knows the value of the header and footer which were filled in the FileLayer object's open function, but it can still have text filled into its content between the header and footer.
Layer objects have a write_layer function that is passed a layer name followed by keyword parameters that correspond to slots in that layer. Here we are adding two instances of our {report} layer to the content of the template's main Layer object. Recall that values passed in to fill slots are interpreted as HTML Markup by the expand_html_markup function. The "happenings" lists are escaped, then concatenated by this function.
Of course, we can separate the "Lawn Happenings" data from the code by creating a structure for it:
import templayer
import time
import sys
sys.stdout.write("Content-type: text/html\r\n\r\n")
reports = [
('Sunday', ["We've got a groundhog. I will have to stay alert.",
"I lost half a tomato plant to that furry guy."]),
('Monday', ["The grass grew - I saw it."]),
]
tmpl = templayer.HTMLTemplate("lawn4.html")
file_layer = tmpl.start_file()
main_layer = file_layer.open(title="Gordon's Lawn Happenings",
date=time.asctime())
for d, h in reports:
main_layer.write_layer('report', day=d, happenings=h)
file_layer.close()
This structure is a list of (day, happenings) tuples that is iterated through in the script. The day and happenings values are treated as HTML Markup
Generated on Thu Jun 14 09:04:15 2007.
Unfortunately, the HTML code that this generates is different than before we added the {report} layer — the "Happenings" are no longer in separate paragraphs. One way to fix this is to use HTML Markup and avoid mixing actual HTML into the code:
import templayer
import time
import sys
sys.stdout.write("Content-type: text/html\r\n\r\n")
reports = [
('Sunday', [('p',"We've got a groundhog. I will have to stay alert."),
('p',"I lost half a tomato plant to that furry guy.")]),
('Monday', [('p',"The grass grew - I saw it.")]),
]
tmpl = templayer.HTMLTemplate("lawn4.html")
file_layer = tmpl.start_file()
main_layer = file_layer.open(title="Gordon's Lawn Happenings",
date=time.asctime())
for d, h in reports:
main_layer.write_layer('report', day=d, happenings=h)
file_layer.close()
The expand_html_markup function will take the ('p', text) tuples, escape the text, wrap them in HTML paragraph tags then concatenate them.
We've got a groundhog. I will have to stay alert.
I lost half a tomato plant to that furry guy.
The grass grew - I saw it.
Generated on Thu Jun 14 09:04:15 2007.
HTML Markup is not intended for anything beyond very simple formatting. A more flexible solution is to create another layer to nest within the first.
<html>
<head><title>%title%</title></head>
<body>
<h1>%title%</h1>
{contents}
{report}
<h3>%day%</h3>
%happenings%
{/report}
{happening}<p>%what%</p>
{/happening}
{/contents}
<hr>
<p>Generated on %date%.</p>
</body>
</html>
Now the decision to format individual "Happenings" as paragraphs has been moved to the template in a {happening} layer.
import templayer
import time
import sys
sys.stdout.write("Content-type: text/html\r\n\r\n")
reports = [
('Sunday', ["We've got a groundhog. I will have to stay alert.",
"I lost half a tomato plant to that furry guy."]),
('Monday', ["The grass grew - I saw it."]),
]
tmpl = templayer.HTMLTemplate("lawn5.html")
file_layer = tmpl.start_file()
main_layer = file_layer.open(title="Gordon's Lawn Happenings",
date=time.asctime())
for d, h in reports:
happening_list = []
for w in h:
formatted = tmpl.format('happening', what=w)
happening_list.append(formatted)
main_layer.write_layer('report', day=d, happenings=happening_list)
file_layer.close()
Within the new inner loop we are calling our HTMLTemplate object's format function. This function is similar to the write_layer function except that it returns a RawHTML object instead of adding it to the content of a Layer object. The expand_html_markup function will leave the contents of the RawHTML object intact, so we can use this object within HTML Markup.
Since it is common to nest layers in Templayer another method is provided that is similar to FileLayer's open function. First we need to rename a slot in the {report} to %contents%:
<html>
<head><title>%title%</title></head>
<body>
<h1>%title%</h1>
{contents}
{report}
<h3>%day%</h3>
%contents%
{/report}
{happening}<p>%contents%</p>
{/happening}
{/contents}
<hr>
<p>Generated on %date%.</p>
</body>
</html>
Now that we have a %contents% slot we can "open" this layer and write into it:
import templayer
import time
import sys
sys.stdout.write("Content-type: text/html\r\n\r\n")
reports = [
('Sunday', ["We've got a groundhog. I will have to stay alert.",
"I lost half a tomato plant to that furry guy."]),
('Monday', ["The grass grew - I saw it."]),
]
tmpl = templayer.HTMLTemplate("lawn6.html")
file_layer = tmpl.start_file()
main_layer = file_layer.open(title="Gordon's Lawn Happenings",
date=time.asctime())
for d, h in reports:
report_layer = main_layer.open_layer('report', day=d)
for happening in h:
report_layer.write_layer('happening', contents=happening)
file_layer.close()
The Layer object has an open_layer function that returns a new layer object. In this case the new Layer object represents a {report} layer that is being written. The Layer object stores everything above the %contents% slot as its header and everything below as its footer. It can have text filled into its content in the same way as our main Layer object. Here we are now using write_layer to fill {happening} layers into {report} layers.
We also renamed the slot in {happening} to %contents%, so we can use the open_layer function on that as well:
import templayer
import time
import sys
sys.stdout.write("Content-type: text/html\r\n\r\n")
reports = [
('Sunday', ["We've got a groundhog. I will have to stay alert.",
"I lost half a tomato plant to that furry guy."]),
('Monday', ["The grass grew - I saw it."]),
]
tmpl = templayer.HTMLTemplate("lawn6.html")
file_layer = tmpl.start_file()
main_layer = file_layer.open(title="Gordon's Lawn Happenings",
date=time.asctime())
for d, h in reports:
report_layer = main_layer.open_layer('report', day=d)
for happening in h:
happening_layer = report_layer.open_layer('happening')
happening_layer.write(happening)
file_layer.close()
We want to send text into this new Layer object, so instead of calling write_layer we call the write function. It takes a single parameter that is interpreted as HTML Markup.
When using Templayer to produce very large files, or when parts of an HTML page take longer to complete, you might want to flush your output part of the way through:
import templayer
import time
import sys
sys.stdout.write("Content-type: text/html\r\n\r\n")
reports = [
('Sunday', ["We've got a groundhog. I will have to stay alert.",
"I lost half a tomato plant to that furry guy."]),
('Monday', ["The grass grew - I saw it."]),
]
tmpl = templayer.HTMLTemplate("lawn6.html")
file_layer = tmpl.start_file()
main_layer = file_layer.open(title="Gordon's Lawn Happenings",
date=time.asctime())
for d, h in reports:
report_layer = main_layer.open_layer('report', day=d)
for happening in h:
happening_layer = report_layer.open_layer('happening')
happening_layer.write(happening)
main_layer.close_child()
file_layer.flush()
file_layer.close()
Layer objects have a close_child function that forces any open "child" layers to finalize their output. In this code we are closing the {report} layer. FileLayer objects have a flush function that will send all the output possible. We are first closing our {report} layer so that when we flush the output the whole report will appear.