Beginning Python - From Novice to Professional

CHAPTER 20 ■ PROJECT 1: INSTANT MARKUP 399
as its only argument). Confusing? Let’s consider an example (and don’t worry about the default
part yet—I’ll get to that).
Let’s say HTMLRenderer is a subclass of Handler and it implements the method sub_emphasis
as described in the previous section (see Listing 20-4 for the actual code of handlers.py). Let’s
say you have an HTMLRenderer instance in the variable handler:
>>> from handlers import HTMLRenderer
>>> handler = HTMLRenderer()
What then will handler.sub('emphasis') do?
>>> handler.sub('emphasis')
It returns a function (substitution) that basically calls the handler.sub_emphasis method
when you call it. That means that you can use this function in a re.sub statement:
>>> import re
>>> re.sub(r'\*(.+?)\*', handler.sub('emphasis'), 'This *is* a test')
'This is a test'
Magic! (The regular expression matches occurrences of text bracketed by asterisks, which
I’ll discuss shortly.) But why go to such lengths? Why not just use r'\1' as I did in the
simple version? Because then you’d be committed to using the em tag—and you want the handler
to be able to decide what markup to use. If your handler were a (hypothetical) LaTeXRenderer,
for example, you might get another result altogether:
>> re.sub(r'\*(.+?)\*', handler.sub('emphasis'), 'This *is* a test')
'This \emph{is} a test'
The markup has changed, but the code has not.
Now, what about that default part of the replacement function? What’s that all about? It’s
a backup, in case no substitution is implemented. The callback method tries to find a suitable
sub_something method, but if it doesn’t find one, it returns None. Because your function is a
re.sub replacement function, you don’t want it to return None. Instead, if you find no substitution
method, you just return the original match without any modifications. Due to short-circuit
logic (see Chapter 5), if the callback returns None, the lambda (in sub) returns default (which is
match.group(0)) instead, which is the original matched text.
Rules
Now that I’ve made the handlers quite extensible and flexible, it’s time to turn to the parsing (interpretation
of the original text). Instead of making one big if statement with various conditions and
actions such as in my simple markup program, I’ll make the rules a separate kind of object.
The rules are used by the main program (the parser), which must determine which rules
are applicable for a given block, and then make each rule do what is needed to transform the
block. In other words, a rule must
• Be able to recognize blocks where it applies (the condition)
• Be able to transform blocks (the action)