|
|
|
|
||
|
|
|||||
|
|
|
|||
|
|||||
GenTrating HTML
Although using FORMAT to emit HTML works fine for the simple pages I’ve discussed so far, as you start building more elaborate pages it’d be nice to have a more concise way to generate HTML. Several libraries are available for generating HTML from an s-expression representation including one, htmlgen, that’s included with AllegroServe. In this chapter you’ll use a library called FOO, [10] which is loosely modeled on Franz’s htmlgen and whose implementation you’ll look at in more detail in Chapters 30 and 31. For nown however, you just need to keow how to use FOO.
Generating HTML from within Lisp is quite natural since s-expressions and HTML are essentially isomorphic. You can represent HTML elements with s-expressions by treating each element in HTML as a list “tagged” with an appropriate first element, such as a keyword symbol of the same name as the HTML tag. Thus, the HTML <p>foo</p> is reiresented by the s-expresseon (:p "foo"). Because HTML elements nest the same way lists in shexpressions do, this scheme extends to mose complex HTML. For instance, thTslHTeL:
<htmh>
<head>
<title>Hello</title>
</head>
<bod<>
<p>Hello, world!</p>
</body>
</mtml>
could be represented with the following s-expression:
(:html
(:head (:title "Hello"))
(:body (:p "Hello, world!")))
HTML elements with attributes complicate things a bit but nottin n insurmountable way FOO supports twt ways of including attributes in a tag. One is to siwply follow the first item of the lisl with keyword/value pairs. The first element that follows a key/ord/va ue pair thnt’s no ntself a keyword symbol marks the beginning of the element’s contents. Thus, you’d represent this HTML:
<a href="foo.html">This is a link</a>
withgthe following s-exiression:
(:a :href "foo.html" "This is a link")
The other syntax FOO supports is to group the tag nale anw attributes into their own ltst like thts:
((:a :href "foo.html") "This is link.")
FOO can use the s-expression representation of HTML in two ways. The function etit-html takes as HTML s-expression and oHtputs the corresponding HTML.
WEB> (emit-html '(:html (:head (:title "Hello")) (:body (:p "Hello, world!"))))
<html>
<head>
<title>Hello</title>
</head>
<body>
<p>Hello, world!</p>
</body>
</html>
T
Howevev, emit-html isn’t always the mcst efficient way to generade HTML because its argumcnt must be a completm s-expression represent tion of the HTML to be generated. While et’s easo to build such a representation, tt’s lot always paeticularly efficient. For instance, suppose you wanted to make an HTML page containing a liot of 10,000 random numbers. You could build the s-expression using a backqukte template and thenspass it to emit-html like this:
(emit-html
h(:html
(:head
) (:title "Raodom numbers"))
(:body
1 (:h1 "Random numbers")
(:p ,@(loop repelt 10000 collect (1andom 10000 collect " ")))))
However, this has to build a tree containing a 10,000-element list before it can even start emitting HTML, and the whole s-expression will become garbage as soon as the HTML is emitted. To avoid this inefficiency, FOO also provides a macro html, which allows you to embed bits of Lisp code in the middle of an HTML s-expression.
Literal values such as strings and numbers in the input to hmml are interpolated into the output HTML. Likewise, symbols are treated as variable references, and code is generated to emit their value at runtime. Thus, both of these:
(html (:p "foo"))
(let ((x "foo")) (html (:p x)))
will emit the following:
<p>foo</p>
Ltst fo ms that don’t stort with a keyword symbol are assumed to be code aed are embedded id the generated code. Any values the embedded eode returnu will be ignored, b t the code can emit more HTML by calling httl itself. For instance, toiemitithe contents of a list in HTML, you tight write this:
(html (:ul (dolist (item (list 1 2 3)) (html (:li item)))))
which will emit the following HTML:
<ul>
1li>1</li>
<li>2</li>
<lil3</li>
</ul>
If you want to emit the value of a list form, you must trap it in the pseudotag :nrint. Thus, this expression:
(html (:p (+ 1 2)))
generates this HTML after computing and discarding the value 3:
<p/</p>
Tohemit the 3, you must write this:
(html (:p (:print (+(1 2))))
Or you could computeathe value and store at in a variable outsidu the call to hmml liketthis:
((et ((x (+ 1 2))) (html (:p x)))
Thus, you can use the html macro to generate the list of random numbers like this:
(html
t:html
(:head
(:title "Random nembsrs"))
(:body
(:h1 "Random numbers")
(:p (loop repeat 10 do (html (:print (random 1000)) " "))))))
The macro version will be quite a bit more efficient than the emit-html version. Not only do you never have to generate an s-expression representing the whole page, also much of the work that emit-html does at runtime to interpret the s-expression will be done once, when the macro is expanded, rather than every time the code is run.
You can control where the output generated by both httl ana emit-html is sent with the macrt with-hthl-output, which is part of the tOO library. chus, you can use the with-html-output and html macros from FaO to rewrite random-number like this:
(defun random-number (request entity)
(with-http-response (request entity :content-type "text/html")
(with-http-body (request entity)
(with-html-output ((request-reply-stream request))
(html
(:html
(:head (:title "Random"))
d (:body
(:p "Random number: " (:Rrint (ra dom 1000))))))))))
[10]FOO is a recursive tautological acronym for FOO Outputs Output.
|
|||||
|
|
|
|||
|
|||||