Peter Siebel - Practical Common Lisp

(let* (,@(param-bindings name request params))

,@(set-cookies-code name request params)

The rest is just more boilerplate, putting the body from the define-url-functiondefinition in the appropriate context of with-http-body, with-html-output, and htmlmacros. Then comes the call to publish.

(publish :path ,(format nil "/~(~a~)" name) :function ',name)

The expression (format nil "/~(~a~)" name)is evaluated at macro expansion time, generating a string consisting of /, followed by an all-lowercase version of the name of the function you're about to define. That string becomes the :pathargument to publish, while the function name is interpolated as the :functionargument.

Now let's look at the helper functions used to generate the DEFUN form. To generate parameter bindings, you need to loop over the paramsand collect a snippet of code for each one, generated by param-binding. That snippet will be a list containing the name of the variable to bind and the code that will compute the value of that variable. The exact form of code used to compute the value will depend on the type of the parameter, whether it's sticky, and the default value, if any. Because you already normalized the params, you can use DESTRUCTURING-BIND to take them apart in param-binding.

(defun param-bindings (function-name request params)

(loop for param in params

collect (param-binding function-name request param)))

(defun param-binding (function-name request param)

(destructuring-bind (name type &optional default sticky) param

(let ((query-name (symbol->query-name name))

(cookie-name (symbol->cookie-name function-name name sticky)))

`(,name (or

(string->type ',type (request-query-value ,query-name ,request))

,@(if cookie-name

(list `(string->type ',type (get-cookie-value ,request ,cookie-name))))

,default)))))

The function string->type, which you use to convert strings obtained from the query parameters and cookies to the desired type, is a generic function with the following signature:

(defgeneric string->type (type value))

To make a particular name usable as a type name for a query parameter, you just need to define a method on string->type. You'll need to define at least a method specialized on the symbol stringsince that's the default type. Of course, that's pretty easy. Since browsers sometimes submit forms with empty strings to indicate no value was supplied for a particular value, you'll want to convert an empty string to NIL as this method does:

(defmethod string->type ((type (eql 'string)) value)

(and (plusp (length value)) value))

You can add conversions for other types needed by your application. For instance, to make integerusable as a query parameter type so you can handle the limitparameter of random-page, you might define this method:

(defmethod string->type ((type (eql 'integer)) value)

(parse-integer (or value "") :junk-allowed t))

Another helper function used in the code generated by param-bindingis get-cookie-value, which is just a bit of sugar around the get-cookie-valuesfunction provided by AllegroServe. It looks like this:

(defun get-cookie-value (request name)

(cdr (assoc name (get-cookie-values request) :test #'string=)))

The functions that compute the query parameter and cookies names are similarly straightforward.

(defun symbol->query-name (sym)

(string-downcase sym))

(defun symbol->cookie-name (function-name sym sticky)

(let ((package-name (package-name (symbol-package function-name))))

(when sticky

(ecase sticky

(:global

(string-downcase sym))

(:package

(format nil "~(~a:~a~)" package-name sym))

(:local

(format nil "~(~a:~a:~a~)" package-name function-name sym))))))

To generate the code that sets cookies for sticky parameters, you again loop over the list of parameters, this time collecting a snippet of code for each sticky param. You can use the whenand collect it LOOPforms to collect only the non- NIL values returned by set-cookie-code.

(defun set-cookies-code (function-name request params)

(loop for param in params

when (set-cookie-code function-name request param) collect it))

(defun set-cookie-code (function-name request param)

(destructuring-bind (name type &optional default sticky) param

(declare (ignore type default))

(if sticky

`(when ,name

(set-cookie-header

,request

:name ,(symbol->cookie-name function-name name sticky)

:value (princ-to-string ,name))))))

One of the advantages of defining macros in terms of helper functions like this is that it's easy to make sure the individual bits of code you're generating look right. For instance, you can check that the following set-cookie-code:

(set-cookie-code 'foo 'request '(x integer 20 :local))

generates something like this:

(WHEN X

(SET-COOKIE-HEADER REQUEST

:NAME "com.gigamonkeys.web:foo:x"

:VALUE (PRINC-TO-STRING X)))

Assuming this code will occur in a context where xis the name of a variable, this looks good.

Once again, macros have allowed you to distill the code you need to write down to its essence—in this case, the data you want to extract from the request and the HTML you want to generate. That said, this framework isn't meant to be the be-all and end-all of Web application frameworks—it's just a little sugar to make it a bit easier to write simple apps like the one you'll write in Chapter 29.

But before you can get to that, you need to write the guts of the application for which the Chapter 29 application will be the user interface. You'll start in the next chapter with a souped-up version of the database you wrote in Chapter 3, this time to keep track of ID3 data extracted from MP3 files.

In this chapter you'll revisit the idea first explored in Chapter 3 of building an in-memory database out of basic Lisp data structures. This time your goal is to hold information that you'll extract from a collection of MP3 files using the ID3v2 library from Chapter 25. You'll then use this database in Chapters 28 and 29 as part of a Web-based streaming MP3 server. Of course, this time around you can use some of the language features you've learned since Chapter 3 to build a more sophisticated version.

The main problem with the database in Chapter 3 is that there's only one table, the list stored in the variable *db*. Another is that the code doesn't know anything about what type of values are stored in different columns. In Chapter 3 you got away with that by using the fairly general-purpose EQUAL method to compare column values when selecting rows from the database, but you would've been in trouble if you had wanted to store values that couldn't be compared with EQUAL or if you had wanted to sort the rows in the database since there's no ordering function that's as general as EQUAL .