diff -r 79ea0e2a6cc2 -r 02d4040d5946 sites/irclogs.qmsk.net/urls.py
--- a/sites/irclogs.qmsk.net/urls.py	Sat Feb 07 17:14:01 2009 +0200
+++ b/sites/irclogs.qmsk.net/urls.py	Sat Feb 07 20:05:57 2009 +0200
@@ -3,20 +3,389 @@
     URL mapping for the irclogs.qmsk.net site
 """
 
+import re
+
 # our own handlers
 import handlers
 
-# library stuff
-from lib.map import StaticMapper, map, mapre
+# mapper
+from lib import map
 
-def build_mapper () :
+class URLError (Exception) :
     """
-        Construct and return the Mapping object
+        Error with an URL definition
     """
 
-    return StaticMapper([
-        map(    '/',                                        handlers.index                  ),
-        map(    '/channel/%s',                              handlers.channel_view           ),
-        mapre(  r'^/channel/(\w+)/last/(\d+)(\.\w+)?',      handlers.channel_last           ),
-    ])
+    pass
 
+class Label (object) :
+    """
+        Base class for URL labels (i.e. the segments of the URL between /s)
+    """
+
+    @staticmethod
+    def parse (mask, defaults) :
+        """
+            Parse the given label-segment, and return a *Label instance
+        """
+
+        # empty?
+        if not mask :
+            return EmptyLabel()
+
+        # simple value?
+        match = SimpleValueLabel.EXPR.match(mask)
+
+        if match :
+            # key
+            key = match.group('key')
+
+            # default?
+            default = defaults.get(key)
+
+            # build
+            return SimpleValueLabel(key, default)
+        
+        # static?
+        match = StaticLabel.EXPR.match(mask)
+
+        if match :
+            return StaticLabel(match.group('name'))
+
+        # invalid
+        raise URLError("Invalid label: %r" % (mask, ))
+
+
+class EmptyLabel (Label) :
+    """
+        An empty label, i.e. just a slash in the URL
+    """
+    
+    def __eq__ (self, other) :
+        """
+            Just compares type
+        """
+
+        return isinstance(other, EmptyLabel)
+    
+    def __str__ (self) :
+        return ''
+
+class StaticLabel (Label) :
+    """
+        A simple literal Label, used for fixed terms in the URL
+    """
+
+    EXPR = re.compile(r'^(?P<name>[a-zA-Z_.-]+)$')
+
+    def __init__ (self, name) :
+        """
+            The given name is the literal name of this label
+        """
+
+        self.name = name
+
+    def __eq__ (self, other) :
+        """
+            Compares names
+        """
+
+        return isinstance(other, StaticLabel) and self.name == other.name
+    
+    def __str__ (self) :
+        return self.name
+
+class ValueLabel (Label) :
+    """
+        A label with a key and a value
+    """
+
+    def __init__ (self, key, default) :
+        """
+            Set the key and default value. Default value may be None if there is no default value defined
+        """
+
+        self.key = key
+        self.default = default
+
+    def __eq__ (self, other) :
+        """
+            Compares keys
+        """
+
+        return isinstance(other, ValueLabel) and self.key == other.key
+
+class SimpleValueLabel (ValueLabel) :
+    """
+        A label that has a name and a simple string value
+    """
+
+    EXPR = re.compile(r'^\{(?P<key>[a-zA-Z_][a-zA-Z0-9_]*)\}$')
+
+    def __init__ (self, key, default) :
+        """
+            The given key is the name of this label's value
+        """
+
+        super(SimpleValueLabel, self).__init__(key, default)
+    
+    def __str__ (self) :
+        if self.default :
+            return '{%s=%s}' % (self.key, self.default)
+            
+        else :
+            return '{%s}' % (self.key, )
+
+class URL (object) :
+    """
+        Represents a specific URL
+    """
+
+    def __init__ (self, url_mask, handler, **defaults) :
+        """
+            Create an URL with the given url mask, handler, and default values
+        """
+
+        # store
+        self.url_mask = url_mask
+        self.handler = handler
+        self.defaults = defaults
+
+        # build our labels
+        self.label_path = [Label.parse(mask, defaults) for mask in url_mask.split('/')]
+        
+    def get_label_path (self) :
+        """
+            Returns a list containing the labels in this url
+        """
+        
+        # copy self.label_path
+        return list(self.label_path)
+
+    def execute (self, request, xxx) :
+        """
+            Invoke the handler with the correct parameters
+        """
+
+        xxx
+    
+    def __str__ (self) :
+        return '/'.join(str(label) for label in self.label_path)
+    
+    def __repr__ (self) :
+        return "URL(%r, %r)" % (str(self), self.handler)
+
+class URLNode (object) :
+    """
+        Represents a node in the URLTree
+    """
+
+    def __init__ (self, parent, label) :
+        """
+            Initialize with the given parent and label, empty children dict
+        """
+        
+        # the parent URLNode
+        self.parent = parent
+
+        # this node's Label
+        self.label = label
+
+        # list of child URLNodes
+        self.children = []
+
+        # this node's URL, set by add_url for an empty label_path
+        self.url = None
+
+    def _build_child (self, label) :
+        """
+            Build, insert and return a new child Node
+        """
+        
+        # build new child
+        child = URLNode(self, label)
+        
+        # add to children
+        self.children.append(child)
+
+        # return
+        return child
+
+    def add_url (self, url, label_path) :
+        """
+            Add a URL object to this node under the given path. Uses recursion to process the path.
+
+            The label_path argument is a (partial) label path as returned by URL.get_label_path.
+
+            If label_path is empty (len zero, or begins with EmptyLabel), then the given url is assigned to this node, if no
+            url was assigned before.
+        """
+        
+        # matches this node?
+        if not label_path or isinstance(label_path[0], EmptyLabel) :
+            if self.url :
+                raise URLError(url, "node already defined")
+
+            else :
+                # set
+                self.url = url
+
+        else :
+            # pop child label from label_path
+            child_label = label_path.pop(0)
+
+            # look for the child to recurse into
+            child = None
+
+            # look for an existing child with that label
+            for child in self.children :
+                if child.label == child_label :
+                    # found, use this
+                    break
+
+            else :
+                # build a new child
+                child = self._build_child(child_label)
+
+            # recurse to handle the rest of the label_path
+            child.add_url(url, label_path)
+    
+    def match_label (self, label) :
+        """
+            Match our label mask against the given label value.
+
+            Returns either False (no match), True (matched, no value) or a (key, value) pair.
+        """
+
+        # simple mask
+        if self.label.beginswith('{') and self.label.endswith('}') :
+            value_name = self.label.strip('{}')
+
+            return (value_name, label)
+        
+        # literal mask
+        elif self.label == label :
+            return True
+
+        else :  
+            return False
+
+    def match (self, path, label_path) :
+        """
+            Locate the URL object corresponding to the given label_path value under this node, with the given path
+            containing the previously matched label values
+        """
+
+        # empty label_path?
+        if not label_path or not label_path[0] :
+            # we wanted this node
+            if self.url :
+                # this URL is the best match
+                return [self]
+            
+            elif self.children :
+                # continue testing our children
+                label = None
+            
+            else :
+                # incomplete URL
+                raise URLError(url, "no URL handler defined for this Node")
+        
+        else :
+            # pop our child label from the label path
+            label = label_path.pop(0)
+
+            # build a list of matching children
+            matches = []
+
+            # recurse through our children
+            for child in self.children :
+                matches.append(child.match(label_path))
+
+            # return the list of matching children
+            return matches
+    
+    def dump (self, indent=0) :
+        """
+            Returns a multi-line string representation of this Node
+        """
+
+        return '\n'.join([
+            "%-45s%s" % (
+                ' '*indent + str(self.label) + ('/' if self.children else ''), 
+                (' -> %r' % self.url) if self.url else ''
+            )
+        ] + [
+            child.dump(indent + 4) for child in self.children
+        ])
+
+    def __str__ (self) :
+        return "%s/[%s]" % (self.label, ','.join(str(child) for child in self.children))
+
+class URLTree (map.Mapper) :
+    """
+        Map requests to handlers, using a defined tree of URLs
+    """
+
+    def __init__ (self, url_list) :
+        """
+            Initialize the tree using the given list of URLs
+        """
+
+        # root node
+        self.root = URLNode(None, EmptyLabel())
+        
+        # just add each URL
+        for url in url_list :
+            self.add_url(url)
+
+    def add_url (self, url) :
+        """
+            Adds the given URL to the tree. The URL must begin with a root slash.
+        """
+        # get url's label path
+        path = url.get_label_path()
+
+        # should begin with root
+        root_label = path.pop(0)
+        assert root_label == self.root.label, "URL must begin with root"
+
+        # add to root
+        self.root.add_url(url, path)
+        
+    def match (self, url) :
+        """
+            Returns the URL object best corresponding to the given url
+        """
+
+        # normalize the URL
+        url = os.path.normpath(url)
+
+        # split it into labels
+        label_path = url.split('/')
+
+        # just match starting at root
+        return self.root.match(label_path)
+
+    def handle_request (self, request) :
+        """
+            Looks up the request's URL, and invokes its handler
+        """
+        
+        # get the request's URL path
+        url = self.match(request.get_page_name())
+
+        # XXX: figure out the argument values...
+
+        # let the URL handle it
+        url.execute(request, xxx)
+
+# urls
+index           = URL(  '/',                                            handlers.index                                          )
+channel_view    = URL(  '/channel/{channel}',                           handlers.channel_view                                   )
+channel_last    = URL(  '/channel/{channel}/last/{count}/{format}',     handlers.channel_last,      count=100, format="html"    )
+channel_search  = URL(  '/channel/{channel}/search',                    handlers.channel_search                                 )
+
+# mapper
+mapper = URLTree([index, channel_view, channel_last, channel_search])
+