--- a/sites/irclogs.qmsk.net/handlers.py Sat Feb 07 17:14:01 2009 +0200
+++ b/sites/irclogs.qmsk.net/handlers.py Sat Feb 07 20:05:57 2009 +0200
@@ -16,10 +16,17 @@
pass
-def channel_last (request, channel, lines, type='html') :
+def channel_last (request, channel, lines, type) :
"""
Display the last x lines of channel messages in various formats
"""
pass
+def channel_search (request, channel) :
+ """
+ Display the search form for the channel for GET, or do the search for POST
+ """
+
+ pass
+
--- 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])
+