diff --git a/wiki-lenny/share/Page.orig.py b/wiki-lenny/share/Page.orig.py
deleted file mode 100644
index 7727cea1..00000000
--- a/wiki-lenny/share/Page.orig.py
+++ /dev/null
@@ -1,1873 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - Page class
-
-    Page is used for read-only access to a wiki page. For r/w access see PageEditor.
-    A Page object is used to access a wiki page (in general) as well as to access
-    some specific revision of a wiki page.
-
-    The RootPage is some virtual page located at / and is mainly used to do namespace
-    operations like getting the page list.
-
-    Currently, this is all a big mixture between high-level page code, intermediate
-    data/underlay layering code, caching code and low-level filesystem storage code.
-    To see the filesystem storage layout we use, best is to look into data/pages/
-    (underlay dir uses the same format).
-
-    TODO:
-    * Cleanly separate the code into packages for:
-      * Page (or rather: Item)
-      * Layering
-      * Cache
-      * Storage
-    * ACLs should be handled on a low layer, raising an Exception when access
-      is denied, so we won't have security issues just because someone forgot to check
-      user.may.read(secretpage).
-    * The distinction between a item and a item revision should be clearer.
-    * Items can be anything, not just wiki pages, but also files of any mimetype.
-      The mimetype hierarchy should be modelled by a MimeTypeItem class hierarchy.
-
-    @copyright: 2000-2004 by Juergen Hermann <jh@web.de>,
-                2005-2008 by MoinMoin:ThomasWaldmann,
-                2006 by MoinMoin:FlorianFesti,
-                2007 by MoinMoin:ReimarBauer
-    @license: GNU GPL, see COPYING for details.
-"""
-
-import os, re, codecs
-
-from MoinMoin import log
-logging = log.getLogger(__name__)
-
-from MoinMoin import config, caching, user, util, wikiutil
-from MoinMoin.logfile import eventlog
-from MoinMoin.util import filesys
-
-def is_cache_exception(e):
-    args = e.args
-    return not (len(args) != 1 or args[0] != 'CacheNeedsUpdate')
-
-
-class ItemCache:
-    """ Cache some page item related data, as meta data or pagelist
-
-        We only cache this to RAM in request.cfg (this is the only kind of
-        server object we have), because it might be too big for pickling it
-        in and out.
-    """
-    def __init__(self, name):
-        """ Initialize ItemCache object.
-            @param name: name of the object, used for display in logging and
-                         influences behaviour of refresh().
-        """
-        self.name = name
-        self.cache = {}
-        self.log_pos = None # TODO: initialize this to EOF pos of log
-                            # to avoid reading in the whole log on first request
-        self.requests = 0
-        self.hits = 0
-        self.loglevel = logging.NOTSET
-
-    def putItem(self, request, name, key, data):
-        """ Remembers some data for item name under a key.
-            @param request: currently unused
-            @param name: name of the item (page), unicode
-            @param key: used as secondary access key after name
-            @param data: the data item that should be remembered
-        """
-        d = self.cache.setdefault(name, {})
-        d[key] = data
-
-    def getItem(self, request, name, key):
-        """ Returns some item stored for item name under key.
-            @param request: the request object
-            @param name: name of the item (page), unicode
-            @param key: used as secondary access key after name
-            @return: the data or None, if there is no such name or key.
-        """
-        self.refresh(request)
-        try:
-            data = self.cache[name][key]
-            self.hits += 1
-            hit_str = 'hit'
-        except KeyError:
-            data = None
-            hit_str = 'miss'
-        self.requests += 1
-        logging.log(self.loglevel, "%s cache %s (h/r %2.1f%%) for %r %r" % (
-            self.name,
-            hit_str,
-            float(self.hits * 100) / self.requests,
-            name,
-            key,
-        ))
-        return data
-
-    def refresh(self, request):
-        """ Refresh the cache - if anything has changed in the wiki, we see it
-            in the edit-log and either delete cached data for the changed items
-            (for 'meta') or the complete cache ('pagelists').
-            @param request: the request object
-        """
-        elog = request.editlog
-        old_pos = self.log_pos
-        new_pos, items = elog.news(old_pos)
-        if items:
-            if self.name == 'meta':
-                for item in items:
-                    logging.log(self.loglevel, "cache: removing %r" % item)
-                    try:
-                        del self.cache[item]
-                    except:
-                        pass
-            elif self.name == 'pagelists':
-                logging.log(self.loglevel, "cache: clearing pagelist cache")
-                self.cache = {}
-        self.log_pos = new_pos # important to do this at the end -
-                               # avoids threading race conditions
-
-
-class Page(object):
-    """ Page - Manage an (immutable) page associated with a WikiName.
-        To change a page's content, use the PageEditor class.
-    """
-    def __init__(self, request, page_name, **kw):
-        """ Create page object.
-
-        Note that this is a 'lean' operation, since the text for the page
-        is loaded on demand. Thus, things like `Page(name).link_to()` are
-        efficient.
-
-        @param page_name: WikiName of the page
-        @keyword rev: number of older revision
-        @keyword formatter: formatter instance or mimetype str,
-                            None or no kw arg will use default formatter
-        @keyword include_self: if 1, include current user (default: 0)
-        """
-        self.request = request
-        self.cfg = request.cfg
-        self.page_name = page_name
-        self.rev = kw.get('rev', 0) # revision of this page
-        self.include_self = kw.get('include_self', 0)
-
-        formatter = kw.get('formatter', None)
-        if isinstance(formatter, (str, unicode)): # mimetype given
-            mimetype = str(formatter)
-            self.formatter = None
-            self.output_mimetype = mimetype
-            self.default_formatter = mimetype == "text/html"
-        elif formatter is not None: # formatter instance given
-            self.formatter = formatter
-            self.default_formatter = 0
-            self.output_mimetype = "text/todo" # TODO where do we get this value from?
-        else:
-            self.formatter = None
-            self.default_formatter = 1
-            self.output_mimetype = "text/html"
-
-        self.output_charset = config.charset # correct for wiki pages
-
-        self._text_filename_force = None
-        self.hilite_re = None
-
-        self.__body = None # unicode page body == metadata + data
-        self.__body_modified = 0 # was __body modified in RAM so it differs from disk?
-        self.__meta = None # list of raw tuples of page metadata (currently: the # stuff at top of the page)
-        self.__pi = None # dict of preprocessed page metadata (processing instructions)
-        self.__data = None # unicode page data = body - metadata
-
-        self.reset()
-
-    def reset(self):
-        """ Reset page state """
-        page_name = self.page_name
-        # page_name quoted for file system usage, needs to be reset to
-        # None when pagename changes
-
-        qpagename = wikiutil.quoteWikinameFS(page_name)
-        self.page_name_fs = qpagename
-
-        # the normal and the underlay path used for this page
-        normalpath = os.path.join(self.cfg.data_dir, "pages", qpagename)
-        if not self.cfg.data_underlay_dir is None:
-            underlaypath = os.path.join(self.cfg.data_underlay_dir, "pages", qpagename)
-        else:
-            underlaypath = None
-
-        # TUNING - remember some essential values
-
-        # does the page come from normal page storage (0) or from
-        # underlay dir (1) (can be used as index into following list)
-        self._underlay = None
-
-        # path to normal / underlay page dir
-        self._pagepath = [normalpath, underlaypath]
-
-    # now we define some properties to lazy load some attributes on first access:
-
-    def get_body(self):
-        if self.__body is None:
-            # try to open file
-            try:
-                f = codecs.open(self._text_filename(), 'rb', config.charset)
-            except IOError, er:
-                import errno
-                if er.errno == errno.ENOENT:
-                    # just doesn't exist, return empty text (note that we
-                    # never store empty pages, so this is detectable and also
-                    # safe when passed to a function expecting a string)
-                    return ""
-                else:
-                    raise
-
-            # read file content and make sure it is closed properly
-            try:
-                text = f.read()
-                text = self.decodeTextMimeType(text)
-                self.__body = text
-            finally:
-                f.close()
-        return self.__body
-
-    def set_body(self, newbody):
-        self.__body = newbody
-        self.__meta = None
-        self.__data = None
-    body = property(fget=get_body, fset=set_body) # complete page text
-
-    def get_meta(self):
-        if self.__meta is None:
-            self.__meta, self.__data = wikiutil.get_processing_instructions(self.body)
-        return self.__meta
-    meta = property(fget=get_meta) # processing instructions, ACLs (upper part of page text)
-
-    def get_data(self):
-        if self.__data is None:
-            self.__meta, self.__data = wikiutil.get_processing_instructions(self.body)
-        return self.__data
-    data = property(fget=get_data) # content (lower part of page text)
-
-    def get_pi(self):
-        if self.__pi is None:
-            self.__pi = self.parse_processing_instructions()
-        return self.__pi
-    pi = property(fget=get_pi) # processed meta stuff
-
-    def getlines(self):
-        """ Return a list of all lines in body.
-
-        @rtype: list
-        @return: list of strs body_lines
-        """
-        return self.body.split('\n')
-
-    def get_raw_body(self):
-        """ Load the raw markup from the page file.
-
-        @rtype: unicode
-        @return: raw page contents of this page, unicode
-        """
-        return self.body
-
-    def get_raw_body_str(self):
-        """ Returns the raw markup from the page file, as a string.
-
-        @rtype: str
-        @return: raw page contents of this page, utf-8-encoded
-        """
-        return self.body.encode("utf-8")
-
-    def set_raw_body(self, body, modified=0):
-        """ Set the raw body text (prevents loading from disk).
-
-        TODO: this should not be a public function, as Page is immutable.
-
-        @param body: raw body text
-        @param modified: 1 means that we internally modified the raw text and
-            that it is not in sync with the page file on disk.  This is
-            used e.g. by PageEditor when previewing the page.
-        """
-        self.body = body
-        self.__body_modified = modified
-
-    def get_current_from_pagedir(self, pagedir):
-        """ Get the current revision number from an arbitrary pagedir.
-            Does not modify page object's state, uncached, direct disk access.
-            @param pagedir: the pagedir with the 'current' file to read
-            @return: int currentrev
-        """
-        revfilename = os.path.join(pagedir, 'current')
-        try:
-            revfile = file(revfilename)
-            revstr = revfile.read().strip()
-            revfile.close()
-            rev = int(revstr)
-        except:
-            rev = 99999999 # XXX do some better error handling
-        return rev
-
-    def get_rev_dir(self, pagedir, rev=0):
-        """ Get a revision of a page from an arbitrary pagedir.
-
-        Does not modify page object's state, uncached, direct disk access.
-
-        @param pagedir: the path to the page storage area
-        @param rev: int revision to get (default is 0 and means the current
-                    revision (in this case, the real revint is returned)
-        @return: (str path to file of the revision,
-                  int realrevint,
-                  bool exists)
-        """
-        if rev == 0:
-            rev = self.get_current_from_pagedir(pagedir)
-
-        revstr = '%08d' % rev
-        pagefile = os.path.join(pagedir, 'revisions', revstr)
-        if rev != 99999999:
-            exists = os.path.exists(pagefile)
-            if exists:
-                self._setRealPageName(pagedir)
-        else:
-            exists = False
-        return pagefile, rev, exists
-
-    def _setRealPageName(self, pagedir):
-        """ Set page_name to the real case of page name
-
-        On case insensitive file system, "pagename" exists even if the
-        real page name is "PageName" or "PAGENAME". This leads to
-        confusion in urls, links and logs.
-        See MoinMoinBugs/MacHfsPlusCaseInsensitive
-
-        Correct the case of the page name. Elements created from the
-        page name in reset() are not updated because it's too messy, and
-        this fix seems to be enough for now.
-
-        Problems to fix later:
-
-         - ["helponnavigation"] link to HelpOnNavigation but not
-           considered as backlink.
-
-        @param pagedir: the storage path to the page directory
-        """
-        if self._text_filename_force is None:
-            # we only do this for normal pages, but not for the MissingPage,
-            # because the code below is wrong in that case
-            realPath = util.filesys.realPathCase(pagedir)
-            if realPath is not None:
-                realPath = wikiutil.unquoteWikiname(realPath)
-                self.page_name = realPath[-len(self.page_name):]
-
-    def get_rev(self, use_underlay=-1, rev=0):
-        """ Get information about a revision.
-
-        filename, number, and (existance test) of this page and revision.
-
-        @param use_underlay: -1 == auto, 0 == normal, 1 == underlay
-        @param rev: int revision to get (default is 0 and means the current
-                    revision (in this case, the real revint is returned)
-        @return: (str path to current revision of page,
-                  int realrevint,
-                  bool exists)
-        """
-        def layername(underlay):
-            if underlay == -1:
-                return 'layer_auto'
-            elif underlay == 0:
-                return 'layer_normal'
-            else: # 1
-                return 'layer_underlay'
-
-        request = self.request
-        cache_name = self.page_name
-        cache_key = layername(use_underlay)
-        if self._text_filename_force is None:
-            cache_data = request.cfg.cache.meta.getItem(request, cache_name, cache_key)
-            if cache_data and (rev == 0 or rev == cache_data[1]):
-                # we got the correct rev data from the cache
-                #logging.debug("got data from cache: %r %r %r" % cache_data)
-                return cache_data
-
-        # Figure out if we should use underlay or not, if needed.
-        if use_underlay == -1:
-            underlay, pagedir = self.getPageStatus(check_create=0)
-        else:
-            underlay, pagedir = use_underlay, self._pagepath[use_underlay]
-
-        # Find current revision, if automatic selection is requested.
-        if rev == 0:
-            realrev = self.get_current_from_pagedir(pagedir)
-        else:
-            realrev = rev
-
-        data = self.get_rev_dir(pagedir, realrev)
-        if rev == 0 and self._text_filename_force is None:
-            # we only save the current rev to the cache
-            request.cfg.cache.meta.putItem(request, cache_name, cache_key, data)
-
-        return data
-
-    def current_rev(self):
-        """ Return number of current revision.
-
-        This is the same as get_rev()[1].
-
-        @return: int revision
-        """
-        pagefile, rev, exists = self.get_rev()
-        return rev
-
-    def get_real_rev(self):
-        """ Returns the real revision number of this page.
-            A rev==0 is translated to the current revision.
-
-        @returns: revision number > 0
-        @rtype: int
-        """
-        if self.rev == 0:
-            return self.current_rev()
-        return self.rev
-
-    def getPageBasePath(self, use_underlay=-1):
-        """ Get full path to a page-specific storage area. `args` can
-            contain additional path components that are added to the base path.
-
-        @param use_underlay: force using a specific pagedir, default -1
-                                -1 = automatically choose page dir
-                                1 = use underlay page dir
-                                0 = use standard page dir
-        @rtype: string
-        @return: int underlay,
-                 str the full path to the storage area
-        """
-        standardpath, underlaypath = self._pagepath
-        if underlaypath is None:
-            use_underlay = 0
-
-        if use_underlay == -1: # automatic
-            if self._underlay is None:
-                underlay, path = 0, standardpath
-                pagefile, rev, exists = self.get_rev(use_underlay=0)
-                if not exists:
-                    pagefile, rev, exists = self.get_rev(use_underlay=1)
-                    if exists:
-                        underlay, path = 1, underlaypath
-                self._underlay = underlay
-            else:
-                underlay = self._underlay
-                path = self._pagepath[underlay]
-        else: # normal or underlay
-            underlay, path = use_underlay, self._pagepath[use_underlay]
-
-        return underlay, path
-
-    def getPageStatus(self, *args, **kw):
-        """ Get full path to a page-specific storage area. `args` can
-            contain additional path components that are added to the base path.
-
-        @param args: additional path components
-        @keyword use_underlay: force using a specific pagedir, default '-1'
-                                -1 = automatically choose page dir
-                                1 = use underlay page dir
-                                0 = use standard page dir
-        @keyword check_create: if true, ensures that the path requested really exists
-                               (if it doesn't, create all directories automatically).
-                               (default true)
-        @keyword isfile: is the last component in args a filename? (default is false)
-        @rtype: string
-        @return: (int underlay (1 if using underlay, 0 otherwise),
-                  str the full path to the storage area )
-        """
-        check_create = kw.get('check_create', 1)
-        isfile = kw.get('isfile', 0)
-        use_underlay = kw.get('use_underlay', -1)
-        underlay, path = self.getPageBasePath(use_underlay)
-        fullpath = os.path.join(*((path, ) + args))
-        if check_create:
-            if isfile:
-                dirname, filename = os.path.split(fullpath)
-            else:
-                dirname = fullpath
-            try:
-                os.makedirs(dirname)
-            except OSError, err:
-                if not os.path.exists(dirname):
-                    raise err
-        return underlay, fullpath
-
-    def getPagePath(self, *args, **kw):
-        """ Return path to the page storage area. """
-        return self.getPageStatus(*args, **kw)[1]
-
-    def _text_filename(self, **kw):
-        """ The name of the page file, possibly of an older page.
-
-        @keyword rev: page revision, overriding self.rev
-        @rtype: string
-        @return: complete filename (including path) to this page
-        """
-        if self._text_filename_force is not None:
-            return self._text_filename_force
-        rev = kw.get('rev', 0)
-        if not rev and self.rev:
-            rev = self.rev
-        fname, rev, exists = self.get_rev(-1, rev)
-        return fname
-
-    def editlog_entry(self):
-        """ Return the edit-log entry for this Page object (can be an old revision).
-        """
-        request = self.request
-        use_cache = self.rev == 0 # use the cache for current rev
-        if use_cache:
-            cache_name, cache_key = self.page_name, 'lastlog'
-            entry = request.cfg.cache.meta.getItem(request, cache_name, cache_key)
-        else:
-            entry = None
-        if entry is None:
-            from MoinMoin.logfile import editlog
-            wanted_rev = "%08d" % self.get_real_rev()
-            edit_log = editlog.EditLog(request, rootpagename=self.page_name)
-            for entry in edit_log.reverse():
-                if entry.rev == wanted_rev:
-                    break
-            else:
-                entry = () # don't use None
-            if use_cache:
-                request.cfg.cache.meta.putItem(request, cache_name, cache_key, entry)
-        return entry
-
-    def edit_info(self):
-        """ Return timestamp/editor info for this Page object (can be an old revision).
-
-            Note: if you ask about a deleted revision, it will report timestamp and editor
-                  for the delete action (in the edit-log, this is just a SAVE).
-
-        This is used by MoinMoin/xmlrpc/__init__.py.
-
-        @rtype: dict
-        @return: timestamp and editor information
-        """
-        line = self.editlog_entry()
-        if line:
-            editordata = line.getInterwikiEditorData(self.request)
-            if editordata[0] == 'interwiki':
-                editor = "%s:%s" % editordata[1]
-            else:
-                editor = editordata[1] # ip or email
-            result = {
-                'timestamp': line.ed_time_usecs,
-                'editor': editor,
-            }
-            del line
-        else:
-            result = {}
-        return result
-
-    def last_edit(self, request):
-        # XXX usage of last_edit is DEPRECATED - use edit_info()
-        if not self.exists(): # XXX doesn't make much sense, but still kept
-            return None       # XXX here until we remove last_edit()
-        return self.edit_info()
-
-    def lastEditInfo(self, request=None):
-        """ Return the last edit info.
-
-            Note: if you ask about a deleted revision, it will report timestamp and editor
-                  for the delete action (in the edit-log, this is just a SAVE).
-
-        @param request: the request object (DEPRECATED, unused)
-        @rtype: dict
-        @return: timestamp and editor information
-        """
-        log = self.editlog_entry()
-        if log:
-            request = self.request
-            editor = log.getEditor(request)
-            time = wikiutil.version2timestamp(log.ed_time_usecs)
-            time = request.user.getFormattedDateTime(time) # Use user time format
-            result = {'editor': editor, 'time': time}
-            del log
-        else:
-            result = {}
-        return result
-
-    def isWritable(self):
-        """ Can this page be changed?
-
-        @rtype: bool
-        @return: true, if this page is writable or does not exist
-        """
-        return os.access(self._text_filename(), os.W_OK) or not self.exists()
-
-    def isUnderlayPage(self, includeDeleted=True):
-        """ Does this page live in the underlay dir?
-
-        Return true even if the data dir has a copy of this page. To
-        check for underlay only page, use ifUnderlayPage() and not
-        isStandardPage()
-
-        @param includeDeleted: include deleted pages
-        @rtype: bool
-        @return: true if page lives in the underlay dir
-        """
-        return self.exists(domain='underlay', includeDeleted=includeDeleted)
-
-    def isStandardPage(self, includeDeleted=True):
-        """ Does this page live in the data dir?
-
-        Return true even if this is a copy of an underlay page. To check
-        for data only page, use isStandardPage() and not isUnderlayPage().
-
-        @param includeDeleted: include deleted pages
-        @rtype: bool
-        @return: true if page lives in the data dir
-        """
-        return self.exists(domain='standard', includeDeleted=includeDeleted)
-
-    def exists(self, rev=0, domain=None, includeDeleted=False):
-        """ Does this page exist?
-
-        This is the lower level method for checking page existence. Use
-        the higher level methods isUnderlayPage and isStandardPage for
-        cleaner code.
-
-        @param rev: revision to look for. Default: check current
-        @param domain: where to look for the page. Default: look in all,
-                       available values: 'underlay', 'standard'
-        @param includeDeleted: ignore page state, just check its pagedir
-        @rtype: bool
-        @return: true, if page exists
-        """
-        # Edge cases
-        if domain == 'underlay' and not self.request.cfg.data_underlay_dir:
-            return False
-
-        if includeDeleted:
-            # Look for page directory, ignore page state
-            if domain is None:
-                checklist = [0, 1]
-            else:
-                checklist = [domain == 'underlay']
-            for use_underlay in checklist:
-                pagedir = self.getPagePath(use_underlay=use_underlay, check_create=0)
-                if os.path.exists(pagedir):
-                    return True
-            return False
-        else:
-            # Look for non-deleted pages only, using get_rev
-            if not rev and self.rev:
-                rev = self.rev
-
-            if domain is None:
-                use_underlay = -1
-            else:
-                use_underlay = domain == 'underlay'
-            d, d, exists = self.get_rev(use_underlay, rev)
-            return exists
-
-    def size(self, rev=0):
-        """ Get Page size.
-
-        @rtype: int
-        @return: page size, 0 for non-existent pages.
-        """
-        if rev == self.rev: # same revision as self
-            if self.__body is not None:
-                return len(self.__body)
-
-        try:
-            return os.path.getsize(self._text_filename(rev=rev))
-        except EnvironmentError, e:
-            import errno
-            if e.errno == errno.ENOENT:
-                return 0
-            raise
-
-    def mtime_usecs(self):
-        """ Get modification timestamp of this page (from edit-log, can be for an old revision).
-
-        @rtype: int
-        @return: mtime of page (or 0 if page / edit-log entry does not exist)
-        """
-        entry = self.editlog_entry()
-        return entry and entry.ed_time_usecs or 0
-
-    def mtime_printable(self, request):
-        """ Get printable (as per user's preferences) modification timestamp of this page.
-
-        @rtype: string
-        @return: formatted string with mtime of page
-        """
-        t = self.mtime_usecs()
-        if not t:
-            result = "0" # TODO: i18n, "Ever", "Beginning of time"...?
-        else:
-            result = request.user.getFormattedDateTime(
-                wikiutil.version2timestamp(t))
-        return result
-
-    def split_title(self, force=0):
-        """ Return a string with the page name split by spaces, if the user wants that.
-
-        @param force: if != 0, then force splitting the page_name
-        @rtype: unicode
-        @return: pagename of this page, splitted into space separated words
-        """
-        request = self.request
-        if not force and not request.user.wikiname_add_spaces:
-            return self.page_name
-
-        # look for the end of words and the start of a new word,
-        # and insert a space there
-        splitted = config.split_regex.sub(r'\1 \2', self.page_name)
-        return splitted
-
-    def url(self, request, querystr=None, anchor=None, relative=False, **kw):
-        """ Return complete URL for this page, including scriptname.
-            The URL is NOT escaped, if you write it to HTML, use wikiutil.escape
-            (at least if you have a querystr, to escape the & chars).
-
-        @param request: the request object
-        @param querystr: the query string to add after a "?" after the url
-            (str or dict, see wikiutil.makeQueryString)
-        @param anchor: if specified, make a link to this anchor
-        @param relative: create a relative link (default: False), note that this
-                         changed in 1.7, in 1.6, the default was True.
-        @rtype: str
-        @return: complete url of this page, including scriptname
-        """
-        assert(isinstance(anchor, (type(None), str, unicode)))
-        # Create url, excluding scriptname
-        url = wikiutil.quoteWikinameURL(self.page_name)
-        if querystr:
-            if isinstance(querystr, dict):
-                action = querystr.get('action', None)
-            else:
-                action = None # we don't support getting the action out of a str
-
-            querystr = wikiutil.makeQueryString(querystr)
-
-            # make action URLs denyable by robots.txt:
-            if action is not None and request.cfg.url_prefix_action is not None:
-                url = "%s/%s/%s" % (request.cfg.url_prefix_action, action, url)
-            url = '%s?%s' % (url, querystr)
-
-        # Add anchor
-        if anchor:
-            url = "%s#%s" % (url, wikiutil.url_quote_plus(anchor))
-
-        if not relative:
-            url = '%s/%s' % (request.getScriptname(), url)
-        return url
-
-    def link_to_raw(self, request, text, querystr=None, anchor=None, **kw):
-        """ core functionality of link_to, without the magic """
-        url = self.url(request, querystr, anchor=anchor, relative=True) # scriptName is added by link_tag
-        # escaping is done by link_tag -> formatter.url -> ._open()
-        link = wikiutil.link_tag(request, url, text,
-                                 formatter=getattr(self, 'formatter', None), **kw)
-        return link
-
-    def link_to(self, request, text=None, querystr=None, anchor=None, **kw):
-        """ Return HTML markup that links to this page.
-
-        See wikiutil.link_tag() for possible keyword parameters.
-
-        @param request: the request object
-        @param text: inner text of the link - it gets automatically escaped
-        @param querystr: the query string to add after a "?" after the url
-        @param anchor: if specified, make a link to this anchor
-        @keyword on: opening/closing tag only
-        @keyword attachment_indicator: if 1, add attachment indicator after link tag
-        @keyword css_class: css class to use
-        @rtype: string
-        @return: formatted link
-        """
-        if not text:
-            text = self.split_title()
-        text = wikiutil.escape(text)
-
-        # Add css class for non existing page
-        if not self.exists():
-            kw['css_class'] = 'nonexistent'
-
-        attachment_indicator = kw.get('attachment_indicator')
-        if attachment_indicator is None:
-            attachment_indicator = 0 # default is off
-        else:
-            del kw['attachment_indicator'] # avoid having this as <a> tag attribute
-
-        link = self.link_to_raw(request, text, querystr, anchor, **kw)
-
-        # Create a link to attachments if any exist
-        if attachment_indicator:
-            from MoinMoin.action import AttachFile
-            link += AttachFile.getIndicator(request, self.page_name)
-
-        return link
-
-    def getSubscribers(self, request, **kw):
-        """ Get all subscribers of this page.
-
-        @param request: the request object
-        @keyword include_self: if 1, include current user (default: 0)
-        @keyword return_users: if 1, return user instances (default: 0)
-        @rtype: dict
-        @return: lists of subscribed email addresses in a dict by language key
-        """
-        include_self = kw.get('include_self', self.include_self)
-        return_users = kw.get('return_users', 0)
-
-        # extract categories of this page
-        pageList = self.getCategories(request)
-
-        # add current page name for list matching
-        pageList.append(self.page_name)
-
-        if self.cfg.SecurityPolicy:
-            UserPerms = self.cfg.SecurityPolicy
-        else:
-            from MoinMoin.security import Default as UserPerms
-
-        # get email addresses of the all wiki user which have a profile stored;
-        # add the address only if the user has subscribed to the page and
-        # the user is not the current editor
-        userlist = user.getUserList(request)
-        subscriber_list = {}
-        for uid in userlist:
-            if uid == request.user.id and not include_self:
-                continue # no self notification
-            subscriber = user.User(request, uid)
-
-            # The following tests should be ordered in order of
-            # decreasing computation complexity, in particular
-            # the permissions check may be expensive; see the bug
-            # MoinMoinBugs/GetSubscribersPerformanceProblem
-
-            # This is a bit wrong if return_users=1 (which implies that the caller will process
-            # user attributes and may, for example choose to send an SMS)
-            # So it _should_ be "not (subscriber.email and return_users)" but that breaks at the moment.
-            if not subscriber.email:
-                continue # skip empty email addresses
-
-            # skip people not subscribed
-            if not subscriber.isSubscribedTo(pageList):
-                continue
-
-            # skip people who can't read the page
-            if not UserPerms(subscriber).read(self.page_name):
-                continue
-
-            # add the user to the list
-            lang = subscriber.language or request.cfg.language_default
-            if not lang in subscriber_list:
-                subscriber_list[lang] = []
-            if return_users:
-                subscriber_list[lang].append(subscriber)
-            else:
-                subscriber_list[lang].append(subscriber.email)
-
-        return subscriber_list
-
-    def parse_processing_instructions(self):
-        """ Parse page text and extract processing instructions,
-            return a dict of PIs and the non-PI rest of the body.
-        """
-        from MoinMoin import i18n
-        from MoinMoin import security
-        request = self.request
-        pi = {} # we collect the processing instructions here
-
-        # default language from cfg
-        pi['language'] = self.cfg.language_default or "en"
-
-        body = self.body
-        # TODO: remove this hack once we have separate metadata and can use mimetype there
-        if body.startswith('<?xml'): # check for XML content
-            pi['lines'] = 0
-            pi['format'] = "xslt"
-            pi['formatargs'] = ''
-            pi['acl'] = security.AccessControlList(request.cfg, []) # avoid KeyError on acl check
-            return pi
-
-        meta = self.meta
-
-        # default is wiki markup
-        pi['format'] = self.cfg.default_markup or "wiki"
-        pi['formatargs'] = ''
-        pi['lines'] = len(meta)
-        acl = []
-
-        for verb, args in meta:
-            if verb == "format": # markup format
-                format, formatargs = (args + ' ').split(' ', 1)
-                pi['format'] = format.lower()
-                pi['formatargs'] = formatargs.strip()
-
-            elif verb == "acl":
-                acl.append(args)
-
-            elif verb == "language":
-                # Page language. Check if args is a known moin language
-                if args in i18n.wikiLanguages():
-                    pi['language'] = args
-
-            elif verb == "refresh":
-                if self.cfg.refresh:
-                    try:
-                        mindelay, targetallowed = self.cfg.refresh
-                        args = args.split()
-                        if len(args) >= 1:
-                            delay = max(int(args[0]), mindelay)
-                        if len(args) >= 2:
-                            target = args[1]
-                        else:
-                            target = self.page_name
-                        if '://' in target:
-                            if targetallowed == 'internal':
-                                raise ValueError
-                            elif targetallowed == 'external':
-                                url = target
-                        else:
-                            url = Page(request, target).url(request)
-                        pi['refresh'] = (delay, url)
-                    except (ValueError, ):
-                        pass
-
-            elif verb == "redirect":
-                pi['redirect'] = args
-
-            elif verb == "deprecated":
-                pi['deprecated'] = True
-
-            elif verb == "openiduser":
-                if request.cfg.openid_server_enable_user:
-                    pi['openid.user'] = args
-
-            elif verb == "pragma":
-                try:
-                    key, val = args.split(' ', 1)
-                except (ValueError, TypeError):
-                    pass
-                else:
-                    request.setPragma(key, val)
-
-        pi['acl'] = security.AccessControlList(request.cfg, acl)
-        return pi
-
-    def send_raw(self, content_disposition=None):
-        """ Output the raw page data (action=raw).
-            With no content_disposition, the browser usually just displays the
-            data on the screen, with content_disposition='attachment', it will
-            offer a dialogue to save it to disk (used by Save action).
-        """
-        request = self.request
-        request.setHttpHeader("Content-type: text/plain; charset=%s" % config.charset)
-        if self.exists():
-            # use the correct last-modified value from the on-disk file
-            # to ensure cacheability where supported. Because we are sending
-            # RAW (file) content, the file mtime is correct as Last-Modified header.
-            request.setHttpHeader("Status: 200 OK")
-            request.setHttpHeader("Last-Modified: %s" % util.timefuncs.formathttpdate(os.path.getmtime(self._text_filename())))
-            text = self.encodeTextMimeType(self.body)
-            #request.setHttpHeader("Content-Length: %d" % len(text))  # XXX WRONG! text is unicode obj, but we send utf-8!
-            if content_disposition:
-                # TODO: fix the encoding here, plain 8 bit is not allowed according to the RFCs
-                # There is no solution that is compatible to IE except stripping non-ascii chars
-                filename_enc = "%s.txt" % self.page_name.encode(config.charset)
-                request.setHttpHeader('Content-Disposition: %s; filename="%s"' % (
-                                      content_disposition, filename_enc))
-        else:
-            request.setHttpHeader('Status: 404 NOTFOUND')
-            text = u"Page %s not found." % self.page_name
-
-        request.emit_http_headers()
-        request.write(text)
-
-    def send_page(self, **keywords):
-        """ Output the formatted page.
-
-        TODO: "kill send_page(), quick" (since 2002 :)
-
-        @keyword content_only: if 1, omit http headers, page header and footer
-        @keyword content_id: set the id of the enclosing div
-        @keyword count_hit: if 1, add an event to the log
-        @keyword send_special: if True, this is a special page send
-        @keyword omit_footnotes: if True, do not send footnotes (used by include macro)
-        """
-        request = self.request
-        _ = request.getText
-        request.clock.start('send_page')
-        emit_headers = keywords.get('emit_headers', 1)
-        content_only = keywords.get('content_only', 0)
-        omit_footnotes = keywords.get('omit_footnotes', 0)
-        content_id = keywords.get('content_id', 'content')
-        do_cache = keywords.get('do_cache', 1)
-        send_special = keywords.get('send_special', False)
-        print_mode = keywords.get('print_mode', 0)
-        if print_mode:
-            media = 'media' in request.form and request.form['media'][0] or 'print'
-        else:
-            media = 'screen'
-        self.hilite_re = (keywords.get('hilite_re') or
-                          request.form.get('highlight', [None])[0])
-
-        # count hit?
-        if keywords.get('count_hit', 0):
-            eventlog.EventLog(request).add(request, 'VIEWPAGE', {'pagename': self.page_name})
-
-        # load the text
-        body = self.data
-        pi = self.pi
-
-        if 'redirect' in pi and not (
-            'action' in request.form or 'redirect' in request.form or content_only):
-            # redirect to another page
-            # note that by including "action=show", we prevent endless looping
-            # (see code in "request") or any cascaded redirection
-            request.http_redirect('%s/%s?action=show&redirect=%s' % (
-                request.getScriptname(),
-                wikiutil.quoteWikinameURL(pi['redirect']),
-                wikiutil.url_quote_plus(self.page_name, ''), ))
-            return
-
-        # if necessary, load the formatter
-        if self.default_formatter:
-            from MoinMoin.formatter.text_html import Formatter
-            self.formatter = Formatter(request, store_pagelinks=1)
-        elif not self.formatter:
-            Formatter = wikiutil.searchAndImportPlugin(request.cfg, "formatter", self.output_mimetype)
-            self.formatter = Formatter(request)
-
-        # save formatter
-        no_formatter = object()
-        old_formatter = getattr(request, "formatter", no_formatter)
-        request.formatter = self.formatter
-
-        self.formatter.setPage(self)
-        if self.hilite_re:
-            try:
-                self.formatter.set_highlight_re(self.hilite_re)
-            except re.error, err:
-                if 'highlight' in request.form:
-                    del request.form['highlight']
-                request.theme.add_msg(_('Invalid highlighting regular expression "%(regex)s": %(error)s') % {
-                                          'regex': self.hilite_re,
-                                          'error': str(err),
-                                      }, "warning")
-                self.hilite_re = None
-
-        if 'deprecated' in pi:
-            # deprecated page, append last backup version to current contents
-            # (which should be a short reason why the page is deprecated)
-            request.theme.add_msg(_('The backed up content of this page is deprecated and will not be included in search results!'), "warning")
-
-            revisions = self.getRevList()
-            if len(revisions) >= 2: # XXX shouldn't that be ever the case!? Looks like not.
-                oldpage = Page(request, self.page_name, rev=revisions[1])
-                body += oldpage.get_raw_body()
-                del oldpage
-
-        lang = self.pi.get('language', request.cfg.language_default)
-        request.setContentLanguage(lang)
-
-        # start document output
-        page_exists = self.exists()
-        if not content_only:
-            if emit_headers:
-                request.setHttpHeader("Content-Type: %s; charset=%s" % (self.output_mimetype, self.output_charset))
-                if page_exists:
-                    if not request.user.may.read(self.page_name):
-                        request.setHttpHeader('Status: 403 Permission Denied')
-                    else:
-                        request.setHttpHeader('Status: 200 OK')
-                    if not request.cacheable:
-                        # use "nocache" headers if we're using a method that is not simply "display"
-                        request.disableHttpCaching(level=2)
-                    elif request.user.valid:
-                        # use nocache headers if a user is logged in (which triggers personalisation features)
-                        request.disableHttpCaching(level=1)
-                    else:
-                        # TODO: we need to know if a page generates dynamic content -
-                        # if it does, we must not use the page file mtime as last modified value
-                        # The following code is commented because it is incorrect for dynamic pages:
-                        #lastmod = os.path.getmtime(self._text_filename())
-                        #request.setHttpHeader("Last-Modified: %s" % util.timefuncs.formathttpdate(lastmod))
-                        pass
-                else:
-                    request.setHttpHeader('Status: 404 NOTFOUND')
-                request.emit_http_headers()
-
-            if not page_exists and self.request.isSpiderAgent:
-                # don't send any 404 content to bots
-                return
-
-            request.write(self.formatter.startDocument(self.page_name))
-
-            # send the page header
-            if self.default_formatter:
-                if self.rev:
-                    request.theme.add_msg("<strong>%s</strong><br>" % (
-                        _('Revision %(rev)d as of %(date)s') % {
-                            'rev': self.rev,
-                            'date': self.mtime_printable(request)
-                        }), "info")
-
-                # This redirect message is very annoying.
-                # Less annoying now without the warning sign.
-                if 'redirect' in request.form:
-                    redir = request.form['redirect'][0]
-                    request.theme.add_msg('<strong>%s</strong><br>' % (
-                        _('Redirected from page "%(page)s"') % {'page':
-                            wikiutil.link_tag(request, wikiutil.quoteWikinameURL(redir) + "?action=show", self.formatter.text(redir))}), "info")
-                if 'redirect' in pi:
-                    request.theme.add_msg('<strong>%s</strong><br>' % (
-                        _('This page redirects to page "%(page)s"') % {'page': wikiutil.escape(pi['redirect'])}), "info")
-
-                # Page trail
-                trail = None
-                if not print_mode:
-                    request.user.addTrail(self)
-                    trail = request.user.getTrail()
-
-                title = self.split_title()
-
-                html_head = ''
-                if request.cfg.openid_server_enabled:
-                    openid_username = self.page_name
-                    userid = user.getUserId(request, openid_username)
-
-                    if userid is None and 'openid.user' in self.pi:
-                        openid_username = self.pi['openid.user']
-                        userid = user.getUserId(request, openid_username)
-
-                    if request.cfg.openid_server_restricted_users_group:
-                        request.dicts.addgroup(request,
-                                               request.cfg.openid_server_restricted_users_group)
-
-                    if userid is not None and not request.cfg.openid_server_restricted_users_group or \
-                      request.dicts.has_member(request.cfg.openid_server_restricted_users_group, openid_username):
-                        html_head = '<link rel="openid2.provider" href="%s">' % \
-                                        wikiutil.escape(request.getQualifiedURL(self.url(request,
-                                                                                querystr={'action': 'serveopenid'})), True)
-                        html_head += '<link rel="openid.server" href="%s">' % \
-                                        wikiutil.escape(request.getQualifiedURL(self.url(request,
-                                                                                querystr={'action': 'serveopenid'})), True)
-                        html_head += '<meta http-equiv="x-xrds-location" content="%s">' % \
-                                        wikiutil.escape(request.getQualifiedURL(self.url(request,
-                                                                                querystr={'action': 'serveopenid', 'yadis': 'ep'})), True)
-                    elif self.page_name == request.cfg.page_front_page:
-                        html_head = '<meta http-equiv="x-xrds-location" content="%s">' % \
-                                        wikiutil.escape(request.getQualifiedURL(self.url(request,
-                                                                                querystr={'action': 'serveopenid', 'yadis': 'idp'})), True)
-
-                request.theme.send_title(title, page=self,
-                                    print_mode=print_mode,
-                                    media=media, pi_refresh=pi.get('refresh'),
-                                    allow_doubleclick=1, trail=trail,
-                                    html_head=html_head,
-                                    )
-
-        # special pages handling, including denying access
-        special = None
-
-        if not send_special:
-            if not page_exists and not body:
-                special = 'missing'
-            elif not request.user.may.read(self.page_name):
-                special = 'denied'
-
-            # if we have a special page, output it, unless
-            #  - we should only output content (this is for say the pagelinks formatter)
-            #  - we have a non-default formatter
-            if special and not content_only and self.default_formatter:
-                self._specialPageText(request, special) # this recursively calls send_page
-
-        # if we didn't short-cut to a special page, output this page
-        if not special:
-            # start wiki content div
-            request.write(self.formatter.startContent(content_id))
-
-            # parse the text and send the page content
-            self.send_page_content(request, body,
-                                   format=pi['format'],
-                                   format_args=pi['formatargs'],
-                                   do_cache=do_cache,
-                                   start_line=pi['lines'])
-
-            # check for pending footnotes
-            if getattr(request, 'footnotes', None) and not omit_footnotes:
-                from MoinMoin.macro.FootNote import emit_footnotes
-                request.write(emit_footnotes(request, self.formatter))
-
-            # end wiki content div
-            request.write(self.formatter.endContent())
-
-        # end document output
-        if not content_only:
-            # send the page footer
-            if self.default_formatter:
-                request.theme.send_footer(self.page_name, print_mode=print_mode)
-
-            request.write(self.formatter.endDocument())
-
-        request.clock.stop('send_page')
-        if not content_only and self.default_formatter:
-            request.theme.send_closing_html()
-
-        # cache the pagelinks
-        if do_cache and self.default_formatter and page_exists:
-            cache = caching.CacheEntry(request, self, 'pagelinks', scope='item', use_pickle=True)
-            if cache.needsUpdate(self._text_filename()):
-                links = self.formatter.pagelinks
-                cache.update(links)
-
-        # restore old formatter (hopefully we dont throw any exception that is catched again)
-        if old_formatter is no_formatter:
-            del request.formatter
-        else:
-            request.formatter = old_formatter
-
-
-    def getFormatterName(self):
-        """ Return a formatter name as used in the caching system
-
-        @rtype: string
-        @return: formatter name as used in caching
-        """
-        if not hasattr(self, 'formatter') or self.formatter is None:
-            return ''
-        module = self.formatter.__module__
-        return module[module.rfind('.') + 1:]
-
-    def canUseCache(self, parser=None):
-        """ Is caching available for this request?
-
-        This make sure we can try to use the caching system for this
-        request, but it does not make sure that this will
-        succeed. Themes can use this to decide if a Refresh action
-        should be displayed.
-
-        @param parser: the parser used to render the page
-        @rtype: bool
-        @return: if this page can use caching
-        """
-        if (not self.rev and
-            not self.hilite_re and
-            not self.__body_modified and
-            self.getFormatterName() in self.cfg.caching_formats):
-            # Everything is fine, now check the parser:
-            if parser is None:
-                parser = wikiutil.searchAndImportPlugin(self.request.cfg, "parser", self.pi['format'])
-            return getattr(parser, 'caching', False)
-        return False
-
-    def send_page_content(self, request, body, format='wiki', format_args='', do_cache=1, **kw):
-        """ Output the formatted wiki page, using caching if possible
-
-        @param request: the request object
-        @param body: text of the wiki page
-        @param format: format of content, default 'wiki'
-        @param format_args: #format arguments, used by some parsers
-        @param do_cache: if True, use cached content
-        """
-        request.clock.start('send_page_content')
-        # Load the parser
-        Parser = wikiutil.searchAndImportPlugin(request.cfg, "parser", format)
-        parser = Parser(body, request, format_args=format_args, **kw)
-
-        if not (do_cache and self.canUseCache(Parser)):
-            self.format(parser)
-        else:
-            try:
-                code = self.loadCache(request)
-                self.execute(request, parser, code)
-            except Exception, e:
-                if not is_cache_exception(e):
-                    raise
-                try:
-                    code = self.makeCache(request, parser)
-                    self.execute(request, parser, code)
-                except Exception, e:
-                    if not is_cache_exception(e):
-                        raise
-                    logging.error('page cache failed after creation')
-                    self.format(parser)
-
-        request.clock.stop('send_page_content')
-
-    def format(self, parser):
-        """ Format and write page content without caching """
-        parser.format(self.formatter)
-
-    def execute(self, request, parser, code):
-        """ Write page content by executing cache code """
-        formatter = self.formatter
-        request.clock.start("Page.execute")
-        try:
-            from MoinMoin.macro import Macro
-            macro_obj = Macro(parser)
-            # Fix __file__ when running from a zip package
-            import MoinMoin
-            if hasattr(MoinMoin, '__loader__'):
-                __file__ = os.path.join(MoinMoin.__loader__.archive, 'dummy')
-            try:
-                exec code
-            except "CacheNeedsUpdate": # convert the exception
-                raise Exception("CacheNeedsUpdate")
-        finally:
-            request.clock.stop("Page.execute")
-
-    def loadCache(self, request):
-        """ Return page content cache or raises 'CacheNeedsUpdate' """
-        cache = caching.CacheEntry(request, self, self.getFormatterName(), scope='item')
-        attachmentsPath = self.getPagePath('attachments', check_create=0)
-        if cache.needsUpdate(self._text_filename(), attachmentsPath):
-            raise Exception('CacheNeedsUpdate')
-
-        import marshal
-        try:
-            return marshal.loads(cache.content())
-        except (EOFError, ValueError, TypeError):
-            # Bad marshal data, must update the cache.
-            # See http://docs.python.org/lib/module-marshal.html
-            raise Exception('CacheNeedsUpdate')
-        except Exception, err:
-            logging.info('failed to load "%s" cache: %s' %
-                        (self.page_name, str(err)))
-            raise Exception('CacheNeedsUpdate')
-
-    def makeCache(self, request, parser):
-        """ Format content into code, update cache and return code """
-        import marshal
-        from MoinMoin.formatter.text_python import Formatter
-        formatter = Formatter(request, ["page"], self.formatter)
-
-        # Save request state while formatting page
-        saved_current_lang = request.current_lang
-        try:
-            text = request.redirectedOutput(parser.format, formatter)
-        finally:
-            request.current_lang = saved_current_lang
-
-        src = formatter.assemble_code(text)
-        code = compile(src.encode(config.charset),
-                       self.page_name.encode(config.charset), 'exec')
-        cache = caching.CacheEntry(request, self, self.getFormatterName(), scope='item')
-        cache.update(marshal.dumps(code))
-        return code
-
-    def _specialPageText(self, request, special_type):
-        """ Output the default page content for new pages.
-
-        @param request: the request object
-        """
-        _ = request.getText
-
-        if special_type == 'missing':
-            if request.user.valid and request.user.name == self.page_name and \
-               request.cfg.user_homewiki in ('Self', request.cfg.interwikiname):
-                page = wikiutil.getLocalizedPage(request, 'MissingHomePage')
-            else:
-                page = wikiutil.getLocalizedPage(request, 'MissingPage')
-
-            alternative_text = u"'''<<Action(action=edit, text=\"%s\")>>'''" % _('Create New Page')
-        elif special_type == 'denied':
-            page = wikiutil.getLocalizedPage(request, 'PermissionDeniedPage')
-            alternative_text = u"'''%s'''" % _('You are not allowed to view this page.')
-        else:
-            assert False
-
-        special_exists = page.exists()
-
-        if special_exists:
-            page._text_filename_force = page._text_filename()
-        else:
-            page.body = alternative_text
-            logging.warn('The page "%s" could not be found. Check your'
-                         ' underlay directory setting.' % page.page_name)
-        page.page_name = self.page_name
-
-        page.send_page(content_only=True, do_cache=not special_exists, send_special=True)
-
-
-    def getRevList(self):
-        """ Get a page revision list of this page, including the current version,
-        sorted by revision number in descending order (current page first).
-
-        @rtype: list of ints
-        @return: page revisions
-        """
-        revisions = []
-        if self.page_name:
-            rev_dir = self.getPagePath('revisions', check_create=0)
-            if os.path.isdir(rev_dir):
-                for rev in filesys.dclistdir(rev_dir):
-                    try:
-                        revint = int(rev)
-                        revisions.append(revint)
-                    except ValueError:
-                        pass
-                revisions.sort()
-                revisions.reverse()
-        return revisions
-
-    def olderrevision(self, rev=0):
-        """ Get revision of the next older page revision than rev.
-        rev == 0 means this page objects revision (that may be an old
-        revision already!)
-        """
-        if rev == 0:
-            rev = self.rev
-        revisions = self.getRevList()
-        for r in revisions:
-            if r < rev:
-                older = r
-                break
-        return older
-
-    def getPageText(self, start=0, length=None):
-        """ Convenience function to get the page text, skipping the header
-
-        @rtype: unicode
-        @return: page text, excluding the header
-        """
-        if length is None:
-            return self.data[start:]
-        else:
-            return self.data[start:start+length]
-
-    def getPageHeader(self, start=0, length=None):
-        """ Convenience function to get the page header
-
-        @rtype: unicode
-        @return: page header
-        """
-        header = ['#%s %s' % t for t in self.meta]
-        header = '\n'.join(header)
-        if header:
-            if length is None:
-                return header[start:]
-            else:
-                return header[start:start+length]
-        return ''
-
-    def getPageLinks(self, request):
-        """ Get a list of the links on this page.
-
-        @param request: the request object
-        @rtype: list
-        @return: page names this page links to
-        """
-        if self.exists():
-            cache = caching.CacheEntry(request, self, 'pagelinks', scope='item', do_locking=False, use_pickle=True)
-            if cache.needsUpdate(self._text_filename()):
-                links = self.parsePageLinks(request)
-                cache.update(links)
-            else:
-                try:
-                    links = cache.content()
-                except caching.CacheError:
-                    links = self.parsePageLinks(request)
-                    cache.update(links)
-        else:
-            links = []
-        return links
-
-    def parsePageLinks(self, request):
-        """ Parse page links by formatting with a pagelinks formatter
-
-        This is a old hack to get the pagelinks by rendering the page
-        with send_page. We can remove this hack after factoring
-        send_page and send_page_content into small reuseable methods.
-
-        More efficient now by using special pagelinks formatter and
-        redirecting possible output into null file.
-        """
-        pagename = self.page_name
-        if request.parsePageLinks_running.get(pagename, False):
-            #logging.debug("avoid recursion for page %r" % pagename)
-            return [] # avoid recursion
-
-        #logging.debug("running parsePageLinks for page %r" % pagename)
-        # remember we are already running this function for this page:
-        request.parsePageLinks_running[pagename] = True
-
-        request.clock.start('parsePageLinks')
-
-        class Null:
-            def write(self, data):
-                pass
-
-        request.redirect(Null())
-        request.mode_getpagelinks += 1
-        #logging.debug("mode_getpagelinks == %r" % request.mode_getpagelinks)
-        try:
-            try:
-                from MoinMoin.formatter.pagelinks import Formatter
-                formatter = Formatter(request, store_pagelinks=1)
-                page = Page(request, pagename, formatter=formatter)
-                page.send_page(content_only=1)
-            except:
-                logging.exception("pagelinks formatter failed, traceback follows")
-        finally:
-            request.mode_getpagelinks -= 1
-            #logging.debug("mode_getpagelinks == %r" % request.mode_getpagelinks)
-            request.redirect()
-            if hasattr(request, '_fmt_hd_counters'):
-                del request._fmt_hd_counters
-            request.clock.stop('parsePageLinks')
-        return formatter.pagelinks
-
-    def getCategories(self, request):
-        """ Get categories this page belongs to.
-
-        @param request: the request object
-        @rtype: list
-        @return: categories this page belongs to
-        """
-        return wikiutil.filterCategoryPages(request, self.getPageLinks(request))
-
-    def getParentPage(self):
-        """ Return parent page or None
-
-        @rtype: Page
-        @return: parent page or None
-        """
-        if self.page_name:
-            pos = self.page_name.rfind('/')
-            if pos > 0:
-                parent = Page(self.request, self.page_name[:pos])
-                if parent.exists():
-                    return parent
-        return None
-
-    def getACL(self, request):
-        """ Get cached ACLs of this page.
-
-        Return cached ACL or invoke parseACL and update the cache.
-
-        @param request: the request object
-        @rtype: MoinMoin.security.AccessControlList
-        @return: ACL of this page
-        """
-        try:
-            return self.__acl # for request.page, this is n-1 times used
-        except AttributeError:
-            # the caching here is still useful for pages != request.page,
-            # when we have multiple page objects for the same page name.
-            request.clock.start('getACL')
-            # Try the cache or parse acl and update the cache
-            currentRevision = self.current_rev()
-            cache_name = self.page_name
-            cache_key = 'acl'
-            cache_data = request.cfg.cache.meta.getItem(request, cache_name, cache_key)
-            if cache_data is None:
-                aclRevision, acl = None, None
-            else:
-                aclRevision, acl = cache_data
-            #logging.debug("currrev: %r, cachedaclrev: %r" % (currentRevision, aclRevision))
-            if aclRevision != currentRevision:
-                acl = self.parseACL()
-                if currentRevision != 99999999:
-                    # don't use cache for non existing pages
-                    # otherwise in the process of creating copies by filesys.copytree (PageEditor.copyPage)
-                    # the first may test will create a cache entry with the default_acls for a non existing page
-                    # At the time the page is created acls on that page would be ignored until the process
-                    # is completed by adding a log entry into edit-log
-                    cache_data = (currentRevision, acl)
-                    request.cfg.cache.meta.putItem(request, cache_name, cache_key, cache_data)
-            self.__acl = acl
-            request.clock.stop('getACL')
-            return acl
-
-    def parseACL(self):
-        """ Return ACLs parsed from the last available revision
-
-        The effective ACL is always from the last revision, even if
-        you access an older revision.
-        """
-        from MoinMoin import security
-        if self.exists() and self.rev == 0:
-            return self.pi['acl']
-        try:
-            lastRevision = self.getRevList()[0]
-        except IndexError:
-            return security.AccessControlList(self.request.cfg)
-        if self.rev == lastRevision:
-            return self.pi['acl']
-
-        return Page(self.request, self.page_name, rev=lastRevision).parseACL()
-
-    def clean_acl_cache(self):
-        """
-        Clean ACL cache entry of this page (used by PageEditor on save)
-        """
-        pass # should not be necessary any more as the new cache watches edit-log for changes
-
-    # Text format -------------------------------------------------------
-
-    def encodeTextMimeType(self, text):
-        """ Encode text from moin internal representation to text/* mime type
-
-        Make sure text uses CRLF line ends, keep trailing newline.
-
-        @param text: text to encode (unicode)
-        @rtype: unicode
-        @return: encoded text
-        """
-        if text:
-            lines = text.splitlines()
-            # Keep trailing newline
-            if text.endswith(u'\n') and not lines[-1] == u'':
-                lines.append(u'')
-            text = u'\r\n'.join(lines)
-        return text
-
-    def decodeTextMimeType(self, text):
-        """ Decode text from text/* mime type to moin internal representation
-
-        @param text: text to decode (unicode). Text must use CRLF!
-        @rtype: unicode
-        @return: text using internal representation
-        """
-        text = text.replace(u'\r', u'')
-        return text
-
-    def isConflict(self):
-        """ Returns true if there is a known editing conflict for that page.
-
-        @return: true if there is a known conflict.
-        """
-
-        cache = caching.CacheEntry(self.request, self, 'conflict', scope='item')
-        return cache.exists()
-
-    def setConflict(self, state):
-        """ Sets the editing conflict flag.
-
-        @param state: bool, true if there is a conflict.
-        """
-        cache = caching.CacheEntry(self.request, self, 'conflict', scope='item')
-        if state:
-            cache.update("") # touch it!
-        else:
-            cache.remove()
-
-
-class RootPage(Page):
-    """ These functions were removed from the Page class to remove hierarchical
-        page storage support until after we have a storage api (and really need it).
-        Currently, there is only 1 instance of this class: request.rootpage
-    """
-    def __init__(self, request):
-        page_name = u''
-        Page.__init__(self, request, page_name)
-
-    def getPageBasePath(self, use_underlay=0):
-        """ Get full path to a page-specific storage area. `args` can
-            contain additional path components that are added to the base path.
-
-        @param use_underlay: force using a specific pagedir, default 0:
-                                1 = use underlay page dir
-                                0 = use standard page dir
-                                Note: we do NOT have special support for -1
-                                      here, that will just behave as 0!
-        @rtype: string
-        @return: int underlay,
-                 str the full path to the storage area
-        """
-        if self.cfg.data_underlay_dir is None:
-            use_underlay = 0
-
-        # 'auto' doesn't make sense here. maybe not even 'underlay':
-        if use_underlay == 1:
-            underlay, path = 1, self.cfg.data_underlay_dir
-        # no need to check 'standard' case, we just use path in that case!
-        else:
-            # this is the location of the virtual root page
-            underlay, path = 0, self.cfg.data_dir
-
-        return underlay, path
-
-    def getPageList(self, user=None, exists=1, filter=None, include_underlay=True, return_objects=False):
-        """ List user readable pages under current page
-
-        Currently only request.rootpage is used to list pages, but if we
-        have true sub pages, any page can list its sub pages.
-
-        The default behavior is listing all the pages readable by the
-        current user. If you want to get a page list for another user,
-        specify the user name.
-
-        If you want to get the full page list, without user filtering,
-        call with user="". Use this only if really needed, and do not
-        display pages the user can not read.
-
-        filter is usually compiled re match or search method, but can be
-        any method that get a unicode argument and return bool. If you
-        want to filter the page list, do it with this filter function,
-        and NOT on the output of this function. page.exists() and
-        user.may.read are very expensive, and should be done on the
-        smallest data set.
-
-        @param user: the user requesting the pages (MoinMoin.user.User)
-        @param filter: filter function
-        @param exists: filter existing pages
-        @param include_underlay: determines if underlay pages are returned as well
-        @param return_objects: lets it return a list of Page objects instead of
-            names
-        @rtype: list of unicode strings
-        @return: user readable wiki page names
-        """
-        request = self.request
-        request.clock.start('getPageList')
-        # Check input
-        if user is None:
-            user = request.user
-
-        # Get pages cache or create it
-        cachedlist = request.cfg.cache.pagelists.getItem(request, 'all', None)
-        if cachedlist is None:
-            cachedlist = {}
-            for name in self._listPages():
-                # Unquote file system names
-                pagename = wikiutil.unquoteWikiname(name)
-
-                # Filter those annoying editor backups - current moin does not create
-                # those pages any more, but users have them already in data/pages
-                # until we remove them by a mig script...
-                if pagename.endswith(u'/MoinEditorBackup'):
-                    continue
-
-                cachedlist[pagename] = None
-            request.cfg.cache.pagelists.putItem(request, 'all', None, cachedlist)
-
-        if user or exists or filter or not include_underlay or return_objects:
-            # Filter names
-            pages = []
-            for name in cachedlist:
-                # First, custom filter - exists and acl check are very
-                # expensive!
-                if filter and not filter(name):
-                    continue
-
-                page = Page(request, name)
-
-                # Filter underlay pages
-                if not include_underlay and page.getPageStatus()[0]: # is an underlay page
-                    continue
-
-                # Filter deleted pages
-                if exists and not page.exists():
-                    continue
-
-                # Filter out page user may not read.
-                if user and not user.may.read(name):
-                    continue
-
-                if return_objects:
-                    pages.append(page)
-                else:
-                    pages.append(name)
-        else:
-            pages = cachedlist.keys()
-
-        request.clock.stop('getPageList')
-        return pages
-
-    def getPageDict(self, user=None, exists=1, filter=None, include_underlay=True):
-        """ Return a dictionary of filtered page objects readable by user
-
-        Invoke getPageList then create a dict from the page list. See
-        getPageList docstring for more details.
-
-        @param user: the user requesting the pages
-        @param filter: filter function
-        @param exists: only existing pages
-        @rtype: dict {unicode: Page}
-        @return: user readable pages
-        """
-        pages = {}
-        for name in self.getPageList(user=user, exists=exists, filter=filter, include_underlay=include_underlay):
-            pages[name] = Page(self.request, name)
-        return pages
-
-    def _listPages(self):
-        """ Return a list of file system page names
-
-        This is the lowest level disk access, don't use it unless you
-        really need it.
-
-        NOTE: names are returned in file system encoding, not in unicode!
-
-        @rtype: dict
-        @return: dict of page names using file system encoding
-        """
-        # Get pages in standard dir
-        path = self.getPagePath('pages')
-        pages = self._listPageInPath(path)
-
-        if self.cfg.data_underlay_dir is not None:
-            # Merge with pages from underlay
-            path = self.getPagePath('pages', use_underlay=1)
-            underlay = self._listPageInPath(path)
-            pages.update(underlay)
-
-        return pages
-
-    def _listPageInPath(self, path):
-        """ List page names in domain, using path
-
-        This is the lowest level disk access, don't use it unless you
-        really need it.
-
-        NOTE: names are returned in file system encoding, not in unicode!
-
-        @param path: directory to list (string)
-        @rtype: dict
-        @return: dict of page names using file system encoding
-        """
-        pages = {}
-        for name in filesys.dclistdir(path):
-            # Filter non-pages in quoted wiki names
-            # List all pages in pages directory - assume flat namespace.
-            # We exclude everything starting with '.' to get rid of . and ..
-            # directory entries. If we ever create pagedirs starting with '.'
-            # it will be with the intention to have them not show up in page
-            # list (like .name won't show up for ls command under UNIX).
-            # Note that a . within a wiki page name will be quoted to (2e).
-            if not name.startswith('.'):
-                pages[name] = None
-
-        if 'CVS' in pages:
-            del pages['CVS'] # XXX DEPRECATED: remove this directory name just in
-                             # case someone has the pages dir under CVS control.
-        return pages
-
-    def getPageCount(self, exists=0):
-        """ Return page count
-
-        The default value does the fastest listing, and return count of
-        all pages, including deleted pages, ignoring acl rights.
-
-        If you want to get a more accurate number, call with
-        exists=1. This will be about 100 times slower though.
-
-        @param exists: filter existing pages
-        @rtype: int
-        @return: number of pages
-        """
-        self.request.clock.start('getPageCount')
-        if exists:
-            # WARNING: SLOW
-            pages = self.getPageList(user='')
-        else:
-            pages = self.request.pages
-            if not pages:
-                pages = self._listPages()
-        count = len(pages)
-        self.request.clock.stop('getPageCount')
-
-        return count
diff --git a/wiki-lenny/share/Page.py b/wiki-lenny/share/Page.py
deleted file mode 100644
index c79440ff..00000000
--- a/wiki-lenny/share/Page.py
+++ /dev/null
@@ -1,1879 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - Page class
-
-    Page is used for read-only access to a wiki page. For r/w access see PageEditor.
-    A Page object is used to access a wiki page (in general) as well as to access
-    some specific revision of a wiki page.
-
-    The RootPage is some virtual page located at / and is mainly used to do namespace
-    operations like getting the page list.
-
-    Currently, this is all a big mixture between high-level page code, intermediate
-    data/underlay layering code, caching code and low-level filesystem storage code.
-    To see the filesystem storage layout we use, best is to look into data/pages/
-    (underlay dir uses the same format).
-
-    TODO:
-    * Cleanly separate the code into packages for:
-      * Page (or rather: Item)
-      * Layering
-      * Cache
-      * Storage
-    * ACLs should be handled on a low layer, raising an Exception when access
-      is denied, so we won't have security issues just because someone forgot to check
-      user.may.read(secretpage).
-    * The distinction between a item and a item revision should be clearer.
-    * Items can be anything, not just wiki pages, but also files of any mimetype.
-      The mimetype hierarchy should be modelled by a MimeTypeItem class hierarchy.
-
-    @copyright: 2000-2004 by Juergen Hermann <jh@web.de>,
-                2005-2008 by MoinMoin:ThomasWaldmann,
-                2006 by MoinMoin:FlorianFesti,
-                2007 by MoinMoin:ReimarBauer
-    @license: GNU GPL, see COPYING for details.
-"""
-
-import os, re, codecs
-
-from MoinMoin import log
-logging = log.getLogger(__name__)
-
-from MoinMoin import config, caching, user, util, wikiutil
-from MoinMoin.logfile import eventlog
-from MoinMoin.util import filesys
-
-def is_cache_exception(e):
-    args = e.args
-    return not (len(args) != 1 or args[0] != 'CacheNeedsUpdate')
-
-
-class ItemCache:
-    """ Cache some page item related data, as meta data or pagelist
-
-        We only cache this to RAM in request.cfg (this is the only kind of
-        server object we have), because it might be too big for pickling it
-        in and out.
-    """
-    def __init__(self, name):
-        """ Initialize ItemCache object.
-            @param name: name of the object, used for display in logging and
-                         influences behaviour of refresh().
-        """
-        self.name = name
-        self.cache = {}
-        self.log_pos = None # TODO: initialize this to EOF pos of log
-                            # to avoid reading in the whole log on first request
-        self.requests = 0
-        self.hits = 0
-        self.loglevel = logging.NOTSET
-
-    def putItem(self, request, name, key, data):
-        """ Remembers some data for item name under a key.
-            @param request: currently unused
-            @param name: name of the item (page), unicode
-            @param key: used as secondary access key after name
-            @param data: the data item that should be remembered
-        """
-        d = self.cache.setdefault(name, {})
-        d[key] = data
-
-    def getItem(self, request, name, key):
-        """ Returns some item stored for item name under key.
-            @param request: the request object
-            @param name: name of the item (page), unicode
-            @param key: used as secondary access key after name
-            @return: the data or None, if there is no such name or key.
-        """
-        self.refresh(request)
-        try:
-            data = self.cache[name][key]
-            self.hits += 1
-            hit_str = 'hit'
-        except KeyError:
-            data = None
-            hit_str = 'miss'
-        self.requests += 1
-        logging.log(self.loglevel, "%s cache %s (h/r %2.1f%%) for %r %r" % (
-            self.name,
-            hit_str,
-            float(self.hits * 100) / self.requests,
-            name,
-            key,
-        ))
-        return data
-
-    def refresh(self, request):
-        """ Refresh the cache - if anything has changed in the wiki, we see it
-            in the edit-log and either delete cached data for the changed items
-            (for 'meta') or the complete cache ('pagelists').
-            @param request: the request object
-        """
-        elog = request.editlog
-        old_pos = self.log_pos
-        new_pos, items = elog.news(old_pos)
-        if items:
-            if self.name == 'meta':
-                for item in items:
-                    logging.log(self.loglevel, "cache: removing %r" % item)
-                    try:
-                        del self.cache[item]
-                    except:
-                        pass
-            elif self.name == 'pagelists':
-                logging.log(self.loglevel, "cache: clearing pagelist cache")
-                self.cache = {}
-        self.log_pos = new_pos # important to do this at the end -
-                               # avoids threading race conditions
-
-
-class Page(object):
-    """ Page - Manage an (immutable) page associated with a WikiName.
-        To change a page's content, use the PageEditor class.
-    """
-    def __init__(self, request, page_name, **kw):
-        """ Create page object.
-
-        Note that this is a 'lean' operation, since the text for the page
-        is loaded on demand. Thus, things like `Page(name).link_to()` are
-        efficient.
-
-        @param page_name: WikiName of the page
-        @keyword rev: number of older revision
-        @keyword formatter: formatter instance or mimetype str,
-                            None or no kw arg will use default formatter
-        @keyword include_self: if 1, include current user (default: 0)
-        """
-        self.request = request
-        self.cfg = request.cfg
-        self.page_name = page_name
-        self.rev = kw.get('rev', 0) # revision of this page
-        self.include_self = kw.get('include_self', 0)
-
-        formatter = kw.get('formatter', None)
-        if isinstance(formatter, (str, unicode)): # mimetype given
-            mimetype = str(formatter)
-            self.formatter = None
-            self.output_mimetype = mimetype
-            self.default_formatter = mimetype == "text/html"
-        elif formatter is not None: # formatter instance given
-            self.formatter = formatter
-            self.default_formatter = 0
-            self.output_mimetype = "text/todo" # TODO where do we get this value from?
-        else:
-            self.formatter = None
-            self.default_formatter = 1
-            self.output_mimetype = "text/html"
-
-        self.output_charset = config.charset # correct for wiki pages
-
-        self._text_filename_force = None
-        self.hilite_re = None
-
-        self.__body = None # unicode page body == metadata + data
-        self.__body_modified = 0 # was __body modified in RAM so it differs from disk?
-        self.__meta = None # list of raw tuples of page metadata (currently: the # stuff at top of the page)
-        self.__pi = None # dict of preprocessed page metadata (processing instructions)
-        self.__data = None # unicode page data = body - metadata
-
-        self.reset()
-
-    def reset(self):
-        """ Reset page state """
-        page_name = self.page_name
-        # page_name quoted for file system usage, needs to be reset to
-        # None when pagename changes
-
-        qpagename = wikiutil.quoteWikinameFS(page_name)
-        self.page_name_fs = qpagename
-
-        # the normal and the underlay path used for this page
-        normalpath = os.path.join(self.cfg.data_dir, "pages", qpagename)
-        if not self.cfg.data_underlay_dir is None:
-            underlaypath = os.path.join(self.cfg.data_underlay_dir, "pages", qpagename)
-        else:
-            underlaypath = None
-
-        # TUNING - remember some essential values
-
-        # does the page come from normal page storage (0) or from
-        # underlay dir (1) (can be used as index into following list)
-        self._underlay = None
-
-        # path to normal / underlay page dir
-        self._pagepath = [normalpath, underlaypath]
-
-    # now we define some properties to lazy load some attributes on first access:
-
-    def get_body(self):
-        if self.__body is None:
-            # try to open file
-            try:
-                f = codecs.open(self._text_filename(), 'rb', config.charset)
-            except IOError, er:
-                import errno
-                if er.errno == errno.ENOENT:
-                    # just doesn't exist, return empty text (note that we
-                    # never store empty pages, so this is detectable and also
-                    # safe when passed to a function expecting a string)
-                    return ""
-                else:
-                    raise
-
-            # read file content and make sure it is closed properly
-            try:
-                text = f.read()
-                text = self.decodeTextMimeType(text)
-                self.__body = text
-            finally:
-                f.close()
-        return self.__body
-
-    def set_body(self, newbody):
-        self.__body = newbody
-        self.__meta = None
-        self.__data = None
-    body = property(fget=get_body, fset=set_body) # complete page text
-
-    def get_meta(self):
-        if self.__meta is None:
-            self.__meta, self.__data = wikiutil.get_processing_instructions(self.body)
-        return self.__meta
-    meta = property(fget=get_meta) # processing instructions, ACLs (upper part of page text)
-
-    def get_data(self):
-        if self.__data is None:
-            self.__meta, self.__data = wikiutil.get_processing_instructions(self.body)
-        return self.__data
-    data = property(fget=get_data) # content (lower part of page text)
-
-    def get_pi(self):
-        if self.__pi is None:
-            self.__pi = self.parse_processing_instructions()
-        return self.__pi
-    pi = property(fget=get_pi) # processed meta stuff
-
-    def getlines(self):
-        """ Return a list of all lines in body.
-
-        @rtype: list
-        @return: list of strs body_lines
-        """
-        return self.body.split('\n')
-
-    def get_raw_body(self):
-        """ Load the raw markup from the page file.
-
-        @rtype: unicode
-        @return: raw page contents of this page, unicode
-        """
-        return self.body
-
-    def get_raw_body_str(self):
-        """ Returns the raw markup from the page file, as a string.
-
-        @rtype: str
-        @return: raw page contents of this page, utf-8-encoded
-        """
-        return self.body.encode("utf-8")
-
-    def set_raw_body(self, body, modified=0):
-        """ Set the raw body text (prevents loading from disk).
-
-        TODO: this should not be a public function, as Page is immutable.
-
-        @param body: raw body text
-        @param modified: 1 means that we internally modified the raw text and
-            that it is not in sync with the page file on disk.  This is
-            used e.g. by PageEditor when previewing the page.
-        """
-        self.body = body
-        self.__body_modified = modified
-
-    def get_current_from_pagedir(self, pagedir):
-        """ Get the current revision number from an arbitrary pagedir.
-            Does not modify page object's state, uncached, direct disk access.
-            @param pagedir: the pagedir with the 'current' file to read
-            @return: int currentrev
-        """
-        revfilename = os.path.join(pagedir, 'current')
-        try:
-            revfile = file(revfilename)
-            revstr = revfile.read().strip()
-            revfile.close()
-            rev = int(revstr)
-        except:
-            rev = 99999999 # XXX do some better error handling
-        return rev
-
-    def get_rev_dir(self, pagedir, rev=0):
-        """ Get a revision of a page from an arbitrary pagedir.
-
-        Does not modify page object's state, uncached, direct disk access.
-
-        @param pagedir: the path to the page storage area
-        @param rev: int revision to get (default is 0 and means the current
-                    revision (in this case, the real revint is returned)
-        @return: (str path to file of the revision,
-                  int realrevint,
-                  bool exists)
-        """
-        if rev == 0:
-            rev = self.get_current_from_pagedir(pagedir)
-
-        revstr = '%08d' % rev
-        pagefile = os.path.join(pagedir, 'revisions', revstr)
-        if rev != 99999999:
-            exists = os.path.exists(pagefile)
-            if exists:
-                self._setRealPageName(pagedir)
-        else:
-            exists = False
-        return pagefile, rev, exists
-
-    def _setRealPageName(self, pagedir):
-        """ Set page_name to the real case of page name
-
-        On case insensitive file system, "pagename" exists even if the
-        real page name is "PageName" or "PAGENAME". This leads to
-        confusion in urls, links and logs.
-        See MoinMoinBugs/MacHfsPlusCaseInsensitive
-
-        Correct the case of the page name. Elements created from the
-        page name in reset() are not updated because it's too messy, and
-        this fix seems to be enough for now.
-
-        Problems to fix later:
-
-         - ["helponnavigation"] link to HelpOnNavigation but not
-           considered as backlink.
-
-        @param pagedir: the storage path to the page directory
-        """
-        if self._text_filename_force is None:
-            # we only do this for normal pages, but not for the MissingPage,
-            # because the code below is wrong in that case
-            realPath = util.filesys.realPathCase(pagedir)
-            if realPath is not None:
-                realPath = wikiutil.unquoteWikiname(realPath)
-                self.page_name = realPath[-len(self.page_name):]
-
-    def get_rev(self, use_underlay=-1, rev=0):
-        """ Get information about a revision.
-
-        filename, number, and (existance test) of this page and revision.
-
-        @param use_underlay: -1 == auto, 0 == normal, 1 == underlay
-        @param rev: int revision to get (default is 0 and means the current
-                    revision (in this case, the real revint is returned)
-        @return: (str path to current revision of page,
-                  int realrevint,
-                  bool exists)
-        """
-        def layername(underlay):
-            if underlay == -1:
-                return 'layer_auto'
-            elif underlay == 0:
-                return 'layer_normal'
-            else: # 1
-                return 'layer_underlay'
-
-        request = self.request
-        cache_name = self.page_name
-        cache_key = layername(use_underlay)
-        if self._text_filename_force is None:
-            cache_data = request.cfg.cache.meta.getItem(request, cache_name, cache_key)
-            if cache_data and (rev == 0 or rev == cache_data[1]):
-                # we got the correct rev data from the cache
-                #logging.debug("got data from cache: %r %r %r" % cache_data)
-                return cache_data
-
-        # Figure out if we should use underlay or not, if needed.
-        if use_underlay == -1:
-            underlay, pagedir = self.getPageStatus(check_create=0)
-        else:
-            underlay, pagedir = use_underlay, self._pagepath[use_underlay]
-
-        # Find current revision, if automatic selection is requested.
-        if rev == 0:
-            realrev = self.get_current_from_pagedir(pagedir)
-        else:
-            realrev = rev
-
-        data = self.get_rev_dir(pagedir, realrev)
-        if rev == 0 and self._text_filename_force is None:
-            # we only save the current rev to the cache
-            request.cfg.cache.meta.putItem(request, cache_name, cache_key, data)
-
-        return data
-
-    def current_rev(self):
-        """ Return number of current revision.
-
-        This is the same as get_rev()[1].
-
-        @return: int revision
-        """
-        pagefile, rev, exists = self.get_rev()
-        return rev
-
-    def get_real_rev(self):
-        """ Returns the real revision number of this page.
-            A rev==0 is translated to the current revision.
-
-        @returns: revision number > 0
-        @rtype: int
-        """
-        if self.rev == 0:
-            return self.current_rev()
-        return self.rev
-
-    def getPageBasePath(self, use_underlay=-1):
-        """ Get full path to a page-specific storage area. `args` can
-            contain additional path components that are added to the base path.
-
-        @param use_underlay: force using a specific pagedir, default -1
-                                -1 = automatically choose page dir
-                                1 = use underlay page dir
-                                0 = use standard page dir
-        @rtype: string
-        @return: int underlay,
-                 str the full path to the storage area
-        """
-        standardpath, underlaypath = self._pagepath
-        if underlaypath is None:
-            use_underlay = 0
-
-        if use_underlay == -1: # automatic
-            if self._underlay is None:
-                underlay, path = 0, standardpath
-                pagefile, rev, exists = self.get_rev(use_underlay=0)
-                if not exists:
-                    pagefile, rev, exists = self.get_rev(use_underlay=1)
-                    if exists:
-                        underlay, path = 1, underlaypath
-                self._underlay = underlay
-            else:
-                underlay = self._underlay
-                path = self._pagepath[underlay]
-        else: # normal or underlay
-            underlay, path = use_underlay, self._pagepath[use_underlay]
-
-        return underlay, path
-
-    def getPageStatus(self, *args, **kw):
-        """ Get full path to a page-specific storage area. `args` can
-            contain additional path components that are added to the base path.
-
-        @param args: additional path components
-        @keyword use_underlay: force using a specific pagedir, default '-1'
-                                -1 = automatically choose page dir
-                                1 = use underlay page dir
-                                0 = use standard page dir
-        @keyword check_create: if true, ensures that the path requested really exists
-                               (if it doesn't, create all directories automatically).
-                               (default true)
-        @keyword isfile: is the last component in args a filename? (default is false)
-        @rtype: string
-        @return: (int underlay (1 if using underlay, 0 otherwise),
-                  str the full path to the storage area )
-        """
-        check_create = kw.get('check_create', 1)
-        isfile = kw.get('isfile', 0)
-        use_underlay = kw.get('use_underlay', -1)
-        underlay, path = self.getPageBasePath(use_underlay)
-        fullpath = os.path.join(*((path, ) + args))
-        if check_create:
-            if isfile:
-                dirname, filename = os.path.split(fullpath)
-            else:
-                dirname = fullpath
-            try:
-                os.makedirs(dirname)
-            except OSError, err:
-                if not os.path.exists(dirname):
-                    raise err
-        return underlay, fullpath
-
-    def getPagePath(self, *args, **kw):
-        """ Return path to the page storage area. """
-        return self.getPageStatus(*args, **kw)[1]
-
-    def _text_filename(self, **kw):
-        """ The name of the page file, possibly of an older page.
-
-        @keyword rev: page revision, overriding self.rev
-        @rtype: string
-        @return: complete filename (including path) to this page
-        """
-        if self._text_filename_force is not None:
-            return self._text_filename_force
-        rev = kw.get('rev', 0)
-        if not rev and self.rev:
-            rev = self.rev
-        fname, rev, exists = self.get_rev(-1, rev)
-        return fname
-
-    def editlog_entry(self):
-        """ Return the edit-log entry for this Page object (can be an old revision).
-        """
-        request = self.request
-        use_cache = self.rev == 0 # use the cache for current rev
-        if use_cache:
-            cache_name, cache_key = self.page_name, 'lastlog'
-            entry = request.cfg.cache.meta.getItem(request, cache_name, cache_key)
-        else:
-            entry = None
-        if entry is None:
-            from MoinMoin.logfile import editlog
-            wanted_rev = "%08d" % self.get_real_rev()
-            edit_log = editlog.EditLog(request, rootpagename=self.page_name)
-            for entry in edit_log.reverse():
-                if entry.rev == wanted_rev:
-                    break
-            else:
-                entry = () # don't use None
-            if use_cache:
-                request.cfg.cache.meta.putItem(request, cache_name, cache_key, entry)
-        return entry
-
-    def edit_info(self):
-        """ Return timestamp/editor info for this Page object (can be an old revision).
-
-            Note: if you ask about a deleted revision, it will report timestamp and editor
-                  for the delete action (in the edit-log, this is just a SAVE).
-
-        This is used by MoinMoin/xmlrpc/__init__.py.
-
-        @rtype: dict
-        @return: timestamp and editor information
-        """
-        line = self.editlog_entry()
-        if line:
-            editordata = line.getInterwikiEditorData(self.request)
-            if editordata[0] == 'interwiki':
-                editor = "%s:%s" % editordata[1]
-            else:
-                editor = editordata[1] # ip or email
-            result = {
-                'timestamp': line.ed_time_usecs,
-                'editor': editor,
-            }
-            del line
-        else:
-            result = {}
-        return result
-
-    def last_edit(self, request):
-        # XXX usage of last_edit is DEPRECATED - use edit_info()
-        if not self.exists(): # XXX doesn't make much sense, but still kept
-            return None       # XXX here until we remove last_edit()
-        return self.edit_info()
-
-    def lastEditInfo(self, request=None):
-        """ Return the last edit info.
-
-            Note: if you ask about a deleted revision, it will report timestamp and editor
-                  for the delete action (in the edit-log, this is just a SAVE).
-
-        @param request: the request object (DEPRECATED, unused)
-        @rtype: dict
-        @return: timestamp and editor information
-        """
-        log = self.editlog_entry()
-        if log:
-            request = self.request
-            editor = log.getEditor(request)
-            time = wikiutil.version2timestamp(log.ed_time_usecs)
-            time = request.user.getFormattedDateTime(time) # Use user time format
-            result = {'editor': editor, 'time': time}
-            del log
-        else:
-            result = {}
-        return result
-
-    def isWritable(self):
-        """ Can this page be changed?
-
-        @rtype: bool
-        @return: true, if this page is writable or does not exist
-        """
-        return os.access(self._text_filename(), os.W_OK) or not self.exists()
-
-    def isUnderlayPage(self, includeDeleted=True):
-        """ Does this page live in the underlay dir?
-
-        Return true even if the data dir has a copy of this page. To
-        check for underlay only page, use ifUnderlayPage() and not
-        isStandardPage()
-
-        @param includeDeleted: include deleted pages
-        @rtype: bool
-        @return: true if page lives in the underlay dir
-        """
-        return self.exists(domain='underlay', includeDeleted=includeDeleted)
-
-    def isStandardPage(self, includeDeleted=True):
-        """ Does this page live in the data dir?
-
-        Return true even if this is a copy of an underlay page. To check
-        for data only page, use isStandardPage() and not isUnderlayPage().
-
-        @param includeDeleted: include deleted pages
-        @rtype: bool
-        @return: true if page lives in the data dir
-        """
-        return self.exists(domain='standard', includeDeleted=includeDeleted)
-
-    def exists(self, rev=0, domain=None, includeDeleted=False):
-        """ Does this page exist?
-
-        This is the lower level method for checking page existence. Use
-        the higher level methods isUnderlayPage and isStandardPage for
-        cleaner code.
-
-        @param rev: revision to look for. Default: check current
-        @param domain: where to look for the page. Default: look in all,
-                       available values: 'underlay', 'standard'
-        @param includeDeleted: ignore page state, just check its pagedir
-        @rtype: bool
-        @return: true, if page exists
-        """
-        # Edge cases
-        if domain == 'underlay' and not self.request.cfg.data_underlay_dir:
-            return False
-
-        if includeDeleted:
-            # Look for page directory, ignore page state
-            if domain is None:
-                checklist = [0, 1]
-            else:
-                checklist = [domain == 'underlay']
-            for use_underlay in checklist:
-                pagedir = self.getPagePath(use_underlay=use_underlay, check_create=0)
-                if os.path.exists(pagedir):
-                    return True
-            return False
-        else:
-            # Look for non-deleted pages only, using get_rev
-            if not rev and self.rev:
-                rev = self.rev
-
-            if domain is None:
-                use_underlay = -1
-            else:
-                use_underlay = domain == 'underlay'
-            d, d, exists = self.get_rev(use_underlay, rev)
-            return exists
-
-    def size(self, rev=0):
-        """ Get Page size.
-
-        @rtype: int
-        @return: page size, 0 for non-existent pages.
-        """
-        if rev == self.rev: # same revision as self
-            if self.__body is not None:
-                return len(self.__body)
-
-        try:
-            return os.path.getsize(self._text_filename(rev=rev))
-        except EnvironmentError, e:
-            import errno
-            if e.errno == errno.ENOENT:
-                return 0
-            raise
-
-    def mtime_usecs(self):
-        """ Get modification timestamp of this page (from edit-log, can be for an old revision).
-
-        @rtype: int
-        @return: mtime of page (or 0 if page / edit-log entry does not exist)
-        """
-        entry = self.editlog_entry()
-        return entry and entry.ed_time_usecs or 0
-
-    def mtime_printable(self, request):
-        """ Get printable (as per user's preferences) modification timestamp of this page.
-
-        @rtype: string
-        @return: formatted string with mtime of page
-        """
-        t = self.mtime_usecs()
-        if not t:
-            result = "0" # TODO: i18n, "Ever", "Beginning of time"...?
-        else:
-            result = request.user.getFormattedDateTime(
-                wikiutil.version2timestamp(t))
-        return result
-
-    def split_title(self, force=0):
-        """ Return a string with the page name split by spaces, if the user wants that.
-
-        @param force: if != 0, then force splitting the page_name
-        @rtype: unicode
-        @return: pagename of this page, splitted into space separated words
-        """
-        request = self.request
-        if not force and not request.user.wikiname_add_spaces:
-            return self.page_name
-
-        # look for the end of words and the start of a new word,
-        # and insert a space there
-        splitted = config.split_regex.sub(r'\1 \2', self.page_name)
-        return splitted
-
-    def url(self, request, querystr=None, anchor=None, relative=False, **kw):
-        """ Return complete URL for this page, including scriptname.
-            The URL is NOT escaped, if you write it to HTML, use wikiutil.escape
-            (at least if you have a querystr, to escape the & chars).
-
-        @param request: the request object
-        @param querystr: the query string to add after a "?" after the url
-            (str or dict, see wikiutil.makeQueryString)
-        @param anchor: if specified, make a link to this anchor
-        @param relative: create a relative link (default: False), note that this
-                         changed in 1.7, in 1.6, the default was True.
-        @rtype: str
-        @return: complete url of this page, including scriptname
-        """
-        assert(isinstance(anchor, (type(None), str, unicode)))
-        # Create url, excluding scriptname
-        url = wikiutil.quoteWikinameURL(self.page_name)
-        if querystr:
-            if isinstance(querystr, dict):
-                action = querystr.get('action', None)
-            else:
-                action = None # we don't support getting the action out of a str
-
-            querystr = wikiutil.makeQueryString(querystr)
-
-            # make action URLs denyable by robots.txt:
-            if action is not None and request.cfg.url_prefix_action is not None:
-                url = "%s/%s/%s" % (request.cfg.url_prefix_action, action, url)
-            url = '%s?%s' % (url, querystr)
-
-        # Add anchor
-        if anchor:
-            url = "%s#%s" % (url, wikiutil.url_quote_plus(anchor))
-
-        if not relative:
-            url = '%s/%s' % (request.getScriptname(), url)
-        return url
-
-    def link_to_raw(self, request, text, querystr=None, anchor=None, **kw):
-        """ core functionality of link_to, without the magic """
-        url = self.url(request, querystr, anchor=anchor, relative=True) # scriptName is added by link_tag
-        # escaping is done by link_tag -> formatter.url -> ._open()
-        link = wikiutil.link_tag(request, url, text,
-                                 formatter=getattr(self, 'formatter', None), **kw)
-        return link
-
-    def link_to(self, request, text=None, querystr=None, anchor=None, **kw):
-        """ Return HTML markup that links to this page.
-
-        See wikiutil.link_tag() for possible keyword parameters.
-
-        @param request: the request object
-        @param text: inner text of the link - it gets automatically escaped
-        @param querystr: the query string to add after a "?" after the url
-        @param anchor: if specified, make a link to this anchor
-        @keyword on: opening/closing tag only
-        @keyword attachment_indicator: if 1, add attachment indicator after link tag
-        @keyword css_class: css class to use
-        @rtype: string
-        @return: formatted link
-        """
-        if not text:
-            text = self.split_title()
-        text = wikiutil.escape(text)
-
-        # Add css class for non existing page
-        if not self.exists():
-            kw['css_class'] = 'nonexistent'
-
-        attachment_indicator = kw.get('attachment_indicator')
-        if attachment_indicator is None:
-            attachment_indicator = 0 # default is off
-        else:
-            del kw['attachment_indicator'] # avoid having this as <a> tag attribute
-
-        link = self.link_to_raw(request, text, querystr, anchor, **kw)
-
-        # Create a link to attachments if any exist
-        if attachment_indicator:
-            from MoinMoin.action import AttachFile
-            link += AttachFile.getIndicator(request, self.page_name)
-
-        return link
-
-    def getSubscribers(self, request, **kw):
-        """ Get all subscribers of this page.
-
-        @param request: the request object
-        @keyword include_self: if 1, include current user (default: 0)
-        @keyword return_users: if 1, return user instances (default: 0)
-        @rtype: dict
-        @return: lists of subscribed email addresses in a dict by language key
-        """
-        include_self = kw.get('include_self', self.include_self)
-        return_users = kw.get('return_users', 0)
-
-        # extract categories of this page
-        pageList = self.getCategories(request)
-
-        # add current page name for list matching
-        pageList.append(self.page_name)
-
-        if self.cfg.SecurityPolicy:
-            UserPerms = self.cfg.SecurityPolicy
-        else:
-            from MoinMoin.security import Default as UserPerms
-
-        # get email addresses of the all wiki user which have a profile stored;
-        # add the address only if the user has subscribed to the page and
-        # the user is not the current editor
-        userlist = user.getUserList(request)
-        subscriber_list = {}
-        for uid in userlist:
-            if uid == request.user.id and not include_self:
-                continue # no self notification
-            subscriber = user.User(request, uid)
-
-            # The following tests should be ordered in order of
-            # decreasing computation complexity, in particular
-            # the permissions check may be expensive; see the bug
-            # MoinMoinBugs/GetSubscribersPerformanceProblem
-
-            # This is a bit wrong if return_users=1 (which implies that the caller will process
-            # user attributes and may, for example choose to send an SMS)
-            # So it _should_ be "not (subscriber.email and return_users)" but that breaks at the moment.
-            if not subscriber.email:
-                continue # skip empty email addresses
-
-            # skip people not subscribed
-            if not subscriber.isSubscribedTo(pageList):
-                continue
-
-            # skip people who can't read the page
-            if not UserPerms(subscriber).read(self.page_name):
-                continue
-
-            # add the user to the list
-            lang = subscriber.language or request.cfg.language_default
-            if not lang in subscriber_list:
-                subscriber_list[lang] = []
-            if return_users:
-                subscriber_list[lang].append(subscriber)
-            else:
-                subscriber_list[lang].append(subscriber.email)
-
-        return subscriber_list
-
-    def parse_processing_instructions(self):
-        """ Parse page text and extract processing instructions,
-            return a dict of PIs and the non-PI rest of the body.
-        """
-        from MoinMoin import i18n
-        from MoinMoin import security
-        request = self.request
-        pi = {} # we collect the processing instructions here
-
-        # default language from cfg
-        pi['language'] = self.cfg.language_default or "en"
-
-        body = self.body
-        # TODO: remove this hack once we have separate metadata and can use mimetype there
-        if body.startswith('<?xml'): # check for XML content
-            pi['lines'] = 0
-            pi['format'] = "xslt"
-            pi['formatargs'] = ''
-            pi['acl'] = security.AccessControlList(request.cfg, []) # avoid KeyError on acl check
-            return pi
-
-        meta = self.meta
-
-        # default is wiki markup
-        pi['format'] = self.cfg.default_markup or "wiki"
-        pi['formatargs'] = ''
-        pi['lines'] = len(meta)
-        acl = []
-
-        for verb, args in meta:
-            if verb == "format": # markup format
-                format, formatargs = (args + ' ').split(' ', 1)
-                pi['format'] = format.lower()
-                pi['formatargs'] = formatargs.strip()
-
-            elif verb == "acl":
-                acl.append(args)
-
-            elif verb == "language":
-                # Page language. Check if args is a known moin language
-                if args in i18n.wikiLanguages():
-                    pi['language'] = args
-
-            elif verb == "refresh":
-                if self.cfg.refresh:
-                    try:
-                        mindelay, targetallowed = self.cfg.refresh
-                        args = args.split()
-                        if len(args) >= 1:
-                            delay = max(int(args[0]), mindelay)
-                        if len(args) >= 2:
-                            target = args[1]
-                        else:
-                            target = self.page_name
-                        if '://' in target:
-                            if targetallowed == 'internal':
-                                raise ValueError
-                            elif targetallowed == 'external':
-                                url = target
-                        else:
-                            url = Page(request, target).url(request)
-                        pi['refresh'] = (delay, url)
-                    except (ValueError, ):
-                        pass
-
-            elif verb == "redirect":
-                pi['redirect'] = args
-
-            elif verb == "deprecated":
-                pi['deprecated'] = True
-
-            elif verb == "openiduser":
-                if request.cfg.openid_server_enable_user:
-                    pi['openid.user'] = args
-
-            elif verb == "pragma":
-                try:
-                    key, val = args.split(' ', 1)
-                except (ValueError, TypeError):
-                    pass
-                else:
-                    request.setPragma(key, val)
-
-        pi['acl'] = security.AccessControlList(request.cfg, acl)
-        return pi
-
-    def send_raw(self, content_disposition=None):
-        """ Output the raw page data (action=raw).
-            With no content_disposition, the browser usually just displays the
-            data on the screen, with content_disposition='attachment', it will
-            offer a dialogue to save it to disk (used by Save action).
-        """
-        request = self.request
-        request.setHttpHeader("Content-type: text/plain; charset=%s" % config.charset)
-        if self.exists():
-            # use the correct last-modified value from the on-disk file
-            # to ensure cacheability where supported. Because we are sending
-            # RAW (file) content, the file mtime is correct as Last-Modified header.
-            request.setHttpHeader("Status: 200 OK")
-            request.setHttpHeader("Last-Modified: %s" % util.timefuncs.formathttpdate(os.path.getmtime(self._text_filename())))
-            text = self.encodeTextMimeType(self.body)
-            #request.setHttpHeader("Content-Length: %d" % len(text))  # XXX WRONG! text is unicode obj, but we send utf-8!
-            if content_disposition:
-                # TODO: fix the encoding here, plain 8 bit is not allowed according to the RFCs
-                # There is no solution that is compatible to IE except stripping non-ascii chars
-                filename_enc = "%s.txt" % self.page_name.encode(config.charset)
-                request.setHttpHeader('Content-Disposition: %s; filename="%s"' % (
-                                      content_disposition, filename_enc))
-        else:
-            request.setHttpHeader('Status: 404 NOTFOUND')
-            text = u"Page %s not found." % self.page_name
-
-        request.emit_http_headers()
-        request.write(text)
-
-    def send_page(self, **keywords):
-        """ Output the formatted page.
-
-        TODO: "kill send_page(), quick" (since 2002 :)
-
-        @keyword content_only: if 1, omit http headers, page header and footer
-        @keyword content_id: set the id of the enclosing div
-        @keyword count_hit: if 1, add an event to the log
-        @keyword send_special: if True, this is a special page send
-        @keyword omit_footnotes: if True, do not send footnotes (used by include macro)
-        """
-        request = self.request
-        _ = request.getText
-        request.clock.start('send_page')
-        emit_headers = keywords.get('emit_headers', 1)
-        content_only = keywords.get('content_only', 0)
-        omit_footnotes = keywords.get('omit_footnotes', 0)
-        content_id = keywords.get('content_id', 'content')
-        do_cache = keywords.get('do_cache', 1)
-        send_special = keywords.get('send_special', False)
-        print_mode = keywords.get('print_mode', 0)
-        if print_mode:
-            media = 'media' in request.form and request.form['media'][0] or 'print'
-        else:
-            media = 'screen'
-        self.hilite_re = (keywords.get('hilite_re') or
-                          request.form.get('highlight', [None])[0])
-
-        # count hit?
-        if keywords.get('count_hit', 0):
-            eventlog.EventLog(request).add(request, 'VIEWPAGE', {'pagename': self.page_name})
-
-        # load the text
-        body = self.data
-        pi = self.pi
-
-        if 'redirect' in pi and not (
-            'action' in request.form or 'redirect' in request.form or content_only):
-            # redirect to another page
-            # note that by including "action=show", we prevent endless looping
-            # (see code in "request") or any cascaded redirection
-            request.http_redirect('%s/%s?action=show&redirect=%s' % (
-                request.getScriptname(),
-                wikiutil.quoteWikinameURL(pi['redirect']),
-                wikiutil.url_quote_plus(self.page_name, ''), ))
-            return
-
-        # if necessary, load the formatter
-        if self.default_formatter:
-            from MoinMoin.formatter.text_html import Formatter
-            self.formatter = Formatter(request, store_pagelinks=1)
-        elif not self.formatter:
-            Formatter = wikiutil.searchAndImportPlugin(request.cfg, "formatter", self.output_mimetype)
-            self.formatter = Formatter(request)
-
-        # save formatter
-        no_formatter = object()
-        old_formatter = getattr(request, "formatter", no_formatter)
-        request.formatter = self.formatter
-
-        self.formatter.setPage(self)
-        if self.hilite_re:
-            try:
-                self.formatter.set_highlight_re(self.hilite_re)
-            except re.error, err:
-                if 'highlight' in request.form:
-                    del request.form['highlight']
-                request.theme.add_msg(_('Invalid highlighting regular expression "%(regex)s": %(error)s') % {
-                                          'regex': self.hilite_re,
-                                          'error': str(err),
-                                      }, "warning")
-                self.hilite_re = None
-
-        if 'deprecated' in pi:
-            # deprecated page, append last backup version to current contents
-            # (which should be a short reason why the page is deprecated)
-            request.theme.add_msg(_('The backed up content of this page is deprecated and will not be included in search results!'), "warning")
-
-            revisions = self.getRevList()
-            if len(revisions) >= 2: # XXX shouldn't that be ever the case!? Looks like not.
-                oldpage = Page(request, self.page_name, rev=revisions[1])
-                body += oldpage.get_raw_body()
-                del oldpage
-
-        lang = self.pi.get('language', request.cfg.language_default)
-        request.setContentLanguage(lang)
-
-        # start document output
-        page_exists = self.exists()
-        if not content_only:
-            if emit_headers:
-                request.setHttpHeader("Content-Type: %s; charset=%s" % (self.output_mimetype, self.output_charset))
-                if page_exists:
-                    ### HACK SAUVAGE 2/3
-                    if not (request.user.may.read(self.page_name) or keywords.get('gc', False)):
-                        request.setHttpHeader('Status: 403 Permission Denied')
-                    ### FIN HACK 2/3
-                    else:
-                        request.setHttpHeader('Status: 200 OK')
-                    if not request.cacheable:
-                        # use "nocache" headers if we're using a method that is not simply "display"
-                        request.disableHttpCaching(level=2)
-                    elif request.user.valid:
-                        # use nocache headers if a user is logged in (which triggers personalisation features)
-                        request.disableHttpCaching(level=1)
-                    else:
-                        # TODO: we need to know if a page generates dynamic content -
-                        # if it does, we must not use the page file mtime as last modified value
-                        # The following code is commented because it is incorrect for dynamic pages:
-                        #lastmod = os.path.getmtime(self._text_filename())
-                        #request.setHttpHeader("Last-Modified: %s" % util.timefuncs.formathttpdate(lastmod))
-                        pass
-                else:
-                    request.setHttpHeader('Status: 404 NOTFOUND')
-                request.emit_http_headers()
-
-            if not page_exists and self.request.isSpiderAgent:
-                # don't send any 404 content to bots
-                return
-
-            request.write(self.formatter.startDocument(self.page_name))
-
-            # send the page header
-            if self.default_formatter:
-                if self.rev:
-                    request.theme.add_msg("<strong>%s</strong><br>" % (
-                        _('Revision %(rev)d as of %(date)s') % {
-                            'rev': self.rev,
-                            'date': self.mtime_printable(request)
-                        }), "info")
-
-                # This redirect message is very annoying.
-                # Less annoying now without the warning sign.
-                if 'redirect' in request.form:
-                    redir = request.form['redirect'][0]
-                    request.theme.add_msg('<strong>%s</strong><br>' % (
-                        _('Redirected from page "%(page)s"') % {'page':
-                            wikiutil.link_tag(request, wikiutil.quoteWikinameURL(redir) + "?action=show", self.formatter.text(redir))}), "info")
-                if 'redirect' in pi:
-                    request.theme.add_msg('<strong>%s</strong><br>' % (
-                        _('This page redirects to page "%(page)s"') % {'page': wikiutil.escape(pi['redirect'])}), "info")
-
-                # Page trail
-                trail = None
-                if not print_mode:
-                    request.user.addTrail(self)
-                    trail = request.user.getTrail()
-
-                title = self.split_title()
-
-                html_head = ''
-                if request.cfg.openid_server_enabled:
-                    openid_username = self.page_name
-                    userid = user.getUserId(request, openid_username)
-
-                    if userid is None and 'openid.user' in self.pi:
-                        openid_username = self.pi['openid.user']
-                        userid = user.getUserId(request, openid_username)
-
-                    if request.cfg.openid_server_restricted_users_group:
-                        request.dicts.addgroup(request,
-                                               request.cfg.openid_server_restricted_users_group)
-
-                    if userid is not None and not request.cfg.openid_server_restricted_users_group or \
-                      request.dicts.has_member(request.cfg.openid_server_restricted_users_group, openid_username):
-                        html_head = '<link rel="openid2.provider" href="%s">' % \
-                                        wikiutil.escape(request.getQualifiedURL(self.url(request,
-                                                                                querystr={'action': 'serveopenid'})), True)
-                        html_head += '<link rel="openid.server" href="%s">' % \
-                                        wikiutil.escape(request.getQualifiedURL(self.url(request,
-                                                                                querystr={'action': 'serveopenid'})), True)
-                        html_head += '<meta http-equiv="x-xrds-location" content="%s">' % \
-                                        wikiutil.escape(request.getQualifiedURL(self.url(request,
-                                                                                querystr={'action': 'serveopenid', 'yadis': 'ep'})), True)
-                    elif self.page_name == request.cfg.page_front_page:
-                        html_head = '<meta http-equiv="x-xrds-location" content="%s">' % \
-                                        wikiutil.escape(request.getQualifiedURL(self.url(request,
-                                                                                querystr={'action': 'serveopenid', 'yadis': 'idp'})), True)
-
-                request.theme.send_title(title, page=self,
-                                    print_mode=print_mode,
-                                    media=media, pi_refresh=pi.get('refresh'),
-                                    allow_doubleclick=1, trail=trail,
-                                    html_head=html_head,
-                                    )
-
-        # special pages handling, including denying access
-        special = None
-
-        if not send_special:
-            if not page_exists and not body:
-                special = 'missing'
-            ### HACK SAUVAGE 3/3
-            elif not (request.user.may.read(self.page_name) or keywords.get('gc', False)):
-                special = 'denied'
-            ### FIN HACK 3/3
-
-            # if we have a special page, output it, unless
-            #  - we should only output content (this is for say the pagelinks formatter)
-            #  - we have a non-default formatter
-            if special and not content_only and self.default_formatter:
-                self._specialPageText(request, special) # this recursively calls send_page
-
-        # if we didn't short-cut to a special page, output this page
-        if not special:
-            # start wiki content div
-            request.write(self.formatter.startContent(content_id))
-
-            # parse the text and send the page content
-            self.send_page_content(request, body,
-                                   format=pi['format'],
-                                   format_args=pi['formatargs'],
-                                   do_cache=do_cache,
-                                   start_line=pi['lines'])
-
-            # check for pending footnotes
-            if getattr(request, 'footnotes', None) and not omit_footnotes:
-                from MoinMoin.macro.FootNote import emit_footnotes
-                request.write(emit_footnotes(request, self.formatter))
-
-            # end wiki content div
-            request.write(self.formatter.endContent())
-
-        # end document output
-        if not content_only:
-            # send the page footer
-            if self.default_formatter:
-                request.theme.send_footer(self.page_name, print_mode=print_mode)
-
-            request.write(self.formatter.endDocument())
-
-        request.clock.stop('send_page')
-        if not content_only and self.default_formatter:
-            request.theme.send_closing_html()
-
-        # cache the pagelinks
-        if do_cache and self.default_formatter and page_exists:
-            cache = caching.CacheEntry(request, self, 'pagelinks', scope='item', use_pickle=True)
-            if cache.needsUpdate(self._text_filename()):
-                links = self.formatter.pagelinks
-                cache.update(links)
-
-        # restore old formatter (hopefully we dont throw any exception that is catched again)
-        if old_formatter is no_formatter:
-            del request.formatter
-        else:
-            request.formatter = old_formatter
-
-
-    def getFormatterName(self):
-        """ Return a formatter name as used in the caching system
-
-        @rtype: string
-        @return: formatter name as used in caching
-        """
-        if not hasattr(self, 'formatter') or self.formatter is None:
-            return ''
-        module = self.formatter.__module__
-        return module[module.rfind('.') + 1:]
-
-    def canUseCache(self, parser=None):
-        """ Is caching available for this request?
-
-        This make sure we can try to use the caching system for this
-        request, but it does not make sure that this will
-        succeed. Themes can use this to decide if a Refresh action
-        should be displayed.
-
-        @param parser: the parser used to render the page
-        @rtype: bool
-        @return: if this page can use caching
-        """
-        if (not self.rev and
-            not self.hilite_re and
-            not self.__body_modified and
-            self.getFormatterName() in self.cfg.caching_formats):
-            # Everything is fine, now check the parser:
-            if parser is None:
-                parser = wikiutil.searchAndImportPlugin(self.request.cfg, "parser", self.pi['format'])
-            return getattr(parser, 'caching', False)
-        return False
-
-    def send_page_content(self, request, body, format='wiki', format_args='', do_cache=1, **kw):
-        """ Output the formatted wiki page, using caching if possible
-
-        @param request: the request object
-        @param body: text of the wiki page
-        @param format: format of content, default 'wiki'
-        @param format_args: #format arguments, used by some parsers
-        @param do_cache: if True, use cached content
-        """
-        request.clock.start('send_page_content')
-        # Load the parser
-        Parser = wikiutil.searchAndImportPlugin(request.cfg, "parser", format)
-        parser = Parser(body, request, format_args=format_args, **kw)
-
-        if not (do_cache and self.canUseCache(Parser)):
-            self.format(parser)
-        else:
-            try:
-                code = self.loadCache(request)
-                self.execute(request, parser, code)
-            except Exception, e:
-                if not is_cache_exception(e):
-                    raise
-                try:
-                    code = self.makeCache(request, parser)
-                    self.execute(request, parser, code)
-                except Exception, e:
-                    if not is_cache_exception(e):
-                        raise
-                    logging.error('page cache failed after creation')
-                    self.format(parser)
-
-        request.clock.stop('send_page_content')
-
-    def format(self, parser):
-        """ Format and write page content without caching """
-        parser.format(self.formatter)
-
-    def execute(self, request, parser, code):
-        """ Write page content by executing cache code """
-        formatter = self.formatter
-        request.clock.start("Page.execute")
-        try:
-            from MoinMoin.macro import Macro
-            macro_obj = Macro(parser)
-            # Fix __file__ when running from a zip package
-            import MoinMoin
-            if hasattr(MoinMoin, '__loader__'):
-                __file__ = os.path.join(MoinMoin.__loader__.archive, 'dummy')
-            try:
-                exec code
-            except "CacheNeedsUpdate": # convert the exception
-                raise Exception("CacheNeedsUpdate")
-        finally:
-            request.clock.stop("Page.execute")
-
-    def loadCache(self, request):
-        """ Return page content cache or raises 'CacheNeedsUpdate' """
-        cache = caching.CacheEntry(request, self, self.getFormatterName(), scope='item')
-        attachmentsPath = self.getPagePath('attachments', check_create=0)
-        if cache.needsUpdate(self._text_filename(), attachmentsPath):
-            raise Exception('CacheNeedsUpdate')
-
-        import marshal
-        try:
-            return marshal.loads(cache.content())
-        except (EOFError, ValueError, TypeError):
-            # Bad marshal data, must update the cache.
-            # See http://docs.python.org/lib/module-marshal.html
-            raise Exception('CacheNeedsUpdate')
-        except Exception, err:
-            logging.info('failed to load "%s" cache: %s' %
-                        (self.page_name, str(err)))
-            raise Exception('CacheNeedsUpdate')
-
-    def makeCache(self, request, parser):
-        """ Format content into code, update cache and return code """
-        import marshal
-        from MoinMoin.formatter.text_python import Formatter
-        formatter = Formatter(request, ["page"], self.formatter)
-
-        # Save request state while formatting page
-        saved_current_lang = request.current_lang
-        try:
-            text = request.redirectedOutput(parser.format, formatter)
-        finally:
-            request.current_lang = saved_current_lang
-
-        src = formatter.assemble_code(text)
-        code = compile(src.encode(config.charset),
-                       self.page_name.encode(config.charset), 'exec')
-        cache = caching.CacheEntry(request, self, self.getFormatterName(), scope='item')
-        cache.update(marshal.dumps(code))
-        return code
-
-    def _specialPageText(self, request, special_type):
-        """ Output the default page content for new pages.
-
-        @param request: the request object
-        """
-        _ = request.getText
-
-        if special_type == 'missing':
-            if request.user.valid and request.user.name == self.page_name and \
-               request.cfg.user_homewiki in ('Self', request.cfg.interwikiname):
-                page = wikiutil.getLocalizedPage(request, 'MissingHomePage')
-            else:
-                page = wikiutil.getLocalizedPage(request, 'MissingPage')
-
-            alternative_text = u"'''<<Action(action=edit, text=\"%s\")>>'''" % _('Create New Page')
-        elif special_type == 'denied':
-            page = wikiutil.getLocalizedPage(request, 'PermissionDeniedPage')
-            alternative_text = u"'''%s'''" % _('You are not allowed to view this page.')
-        else:
-            assert False
-
-        special_exists = page.exists()
-
-        if special_exists:
-            page._text_filename_force = page._text_filename()
-        else:
-            page.body = alternative_text
-            logging.warn('The page "%s" could not be found. Check your'
-                         ' underlay directory setting.' % page.page_name)
-        page.page_name = self.page_name
-
-        page.send_page(content_only=True, do_cache=not special_exists, send_special=True)
-
-
-    def getRevList(self):
-        """ Get a page revision list of this page, including the current version,
-        sorted by revision number in descending order (current page first).
-
-        @rtype: list of ints
-        @return: page revisions
-        """
-        revisions = []
-        if self.page_name:
-            rev_dir = self.getPagePath('revisions', check_create=0)
-            if os.path.isdir(rev_dir):
-                for rev in filesys.dclistdir(rev_dir):
-                    try:
-                        revint = int(rev)
-                        revisions.append(revint)
-                    except ValueError:
-                        pass
-                revisions.sort()
-                revisions.reverse()
-        return revisions
-
-    def olderrevision(self, rev=0):
-        """ Get revision of the next older page revision than rev.
-        rev == 0 means this page objects revision (that may be an old
-        revision already!)
-        """
-        if rev == 0:
-            rev = self.rev
-        revisions = self.getRevList()
-        for r in revisions:
-            if r < rev:
-                older = r
-                break
-        return older
-
-    def getPageText(self, start=0, length=None):
-        """ Convenience function to get the page text, skipping the header
-
-        @rtype: unicode
-        @return: page text, excluding the header
-        """
-        if length is None:
-            return self.data[start:]
-        else:
-            return self.data[start:start+length]
-
-    def getPageHeader(self, start=0, length=None):
-        """ Convenience function to get the page header
-
-        @rtype: unicode
-        @return: page header
-        """
-        header = ['#%s %s' % t for t in self.meta]
-        header = '\n'.join(header)
-        if header:
-            if length is None:
-                return header[start:]
-            else:
-                return header[start:start+length]
-        return ''
-
-    def getPageLinks(self, request):
-        """ Get a list of the links on this page.
-
-        @param request: the request object
-        @rtype: list
-        @return: page names this page links to
-        """
-        if self.exists():
-            cache = caching.CacheEntry(request, self, 'pagelinks', scope='item', do_locking=False, use_pickle=True)
-            if cache.needsUpdate(self._text_filename()):
-                links = self.parsePageLinks(request)
-                cache.update(links)
-            else:
-                try:
-                    links = cache.content()
-                except caching.CacheError:
-                    links = self.parsePageLinks(request)
-                    cache.update(links)
-        else:
-            links = []
-        return links
-
-    def parsePageLinks(self, request):
-        """ Parse page links by formatting with a pagelinks formatter
-
-        This is a old hack to get the pagelinks by rendering the page
-        with send_page. We can remove this hack after factoring
-        send_page and send_page_content into small reuseable methods.
-
-        More efficient now by using special pagelinks formatter and
-        redirecting possible output into null file.
-        """
-        pagename = self.page_name
-        if request.parsePageLinks_running.get(pagename, False):
-            #logging.debug("avoid recursion for page %r" % pagename)
-            return [] # avoid recursion
-
-        #logging.debug("running parsePageLinks for page %r" % pagename)
-        # remember we are already running this function for this page:
-        request.parsePageLinks_running[pagename] = True
-
-        request.clock.start('parsePageLinks')
-
-        class Null:
-            def write(self, data):
-                pass
-
-        request.redirect(Null())
-        request.mode_getpagelinks += 1
-        #logging.debug("mode_getpagelinks == %r" % request.mode_getpagelinks)
-        try:
-            try:
-                from MoinMoin.formatter.pagelinks import Formatter
-                formatter = Formatter(request, store_pagelinks=1)
-                page = Page(request, pagename, formatter=formatter)
-                ### HACK SAUVAGE 1/3
-                page.send_page(content_only=1, gc=True)
-                ### FIN HACK 1/3
-            except:
-                logging.exception("pagelinks formatter failed, traceback follows")
-        finally:
-            request.mode_getpagelinks -= 1
-            #logging.debug("mode_getpagelinks == %r" % request.mode_getpagelinks)
-            request.redirect()
-            if hasattr(request, '_fmt_hd_counters'):
-                del request._fmt_hd_counters
-            request.clock.stop('parsePageLinks')
-        return formatter.pagelinks
-
-    def getCategories(self, request):
-        """ Get categories this page belongs to.
-
-        @param request: the request object
-        @rtype: list
-        @return: categories this page belongs to
-        """
-        return wikiutil.filterCategoryPages(request, self.getPageLinks(request))
-
-    def getParentPage(self):
-        """ Return parent page or None
-
-        @rtype: Page
-        @return: parent page or None
-        """
-        if self.page_name:
-            pos = self.page_name.rfind('/')
-            if pos > 0:
-                parent = Page(self.request, self.page_name[:pos])
-                if parent.exists():
-                    return parent
-        return None
-
-    def getACL(self, request):
-        """ Get cached ACLs of this page.
-
-        Return cached ACL or invoke parseACL and update the cache.
-
-        @param request: the request object
-        @rtype: MoinMoin.security.AccessControlList
-        @return: ACL of this page
-        """
-        try:
-            return self.__acl # for request.page, this is n-1 times used
-        except AttributeError:
-            # the caching here is still useful for pages != request.page,
-            # when we have multiple page objects for the same page name.
-            request.clock.start('getACL')
-            # Try the cache or parse acl and update the cache
-            currentRevision = self.current_rev()
-            cache_name = self.page_name
-            cache_key = 'acl'
-            cache_data = request.cfg.cache.meta.getItem(request, cache_name, cache_key)
-            if cache_data is None:
-                aclRevision, acl = None, None
-            else:
-                aclRevision, acl = cache_data
-            #logging.debug("currrev: %r, cachedaclrev: %r" % (currentRevision, aclRevision))
-            if aclRevision != currentRevision:
-                acl = self.parseACL()
-                if currentRevision != 99999999:
-                    # don't use cache for non existing pages
-                    # otherwise in the process of creating copies by filesys.copytree (PageEditor.copyPage)
-                    # the first may test will create a cache entry with the default_acls for a non existing page
-                    # At the time the page is created acls on that page would be ignored until the process
-                    # is completed by adding a log entry into edit-log
-                    cache_data = (currentRevision, acl)
-                    request.cfg.cache.meta.putItem(request, cache_name, cache_key, cache_data)
-            self.__acl = acl
-            request.clock.stop('getACL')
-            return acl
-
-    def parseACL(self):
-        """ Return ACLs parsed from the last available revision
-
-        The effective ACL is always from the last revision, even if
-        you access an older revision.
-        """
-        from MoinMoin import security
-        if self.exists() and self.rev == 0:
-            return self.pi['acl']
-        try:
-            lastRevision = self.getRevList()[0]
-        except IndexError:
-            return security.AccessControlList(self.request.cfg)
-        if self.rev == lastRevision:
-            return self.pi['acl']
-
-        return Page(self.request, self.page_name, rev=lastRevision).parseACL()
-
-    def clean_acl_cache(self):
-        """
-        Clean ACL cache entry of this page (used by PageEditor on save)
-        """
-        pass # should not be necessary any more as the new cache watches edit-log for changes
-
-    # Text format -------------------------------------------------------
-
-    def encodeTextMimeType(self, text):
-        """ Encode text from moin internal representation to text/* mime type
-
-        Make sure text uses CRLF line ends, keep trailing newline.
-
-        @param text: text to encode (unicode)
-        @rtype: unicode
-        @return: encoded text
-        """
-        if text:
-            lines = text.splitlines()
-            # Keep trailing newline
-            if text.endswith(u'\n') and not lines[-1] == u'':
-                lines.append(u'')
-            text = u'\r\n'.join(lines)
-        return text
-
-    def decodeTextMimeType(self, text):
-        """ Decode text from text/* mime type to moin internal representation
-
-        @param text: text to decode (unicode). Text must use CRLF!
-        @rtype: unicode
-        @return: text using internal representation
-        """
-        text = text.replace(u'\r', u'')
-        return text
-
-    def isConflict(self):
-        """ Returns true if there is a known editing conflict for that page.
-
-        @return: true if there is a known conflict.
-        """
-
-        cache = caching.CacheEntry(self.request, self, 'conflict', scope='item')
-        return cache.exists()
-
-    def setConflict(self, state):
-        """ Sets the editing conflict flag.
-
-        @param state: bool, true if there is a conflict.
-        """
-        cache = caching.CacheEntry(self.request, self, 'conflict', scope='item')
-        if state:
-            cache.update("") # touch it!
-        else:
-            cache.remove()
-
-
-class RootPage(Page):
-    """ These functions were removed from the Page class to remove hierarchical
-        page storage support until after we have a storage api (and really need it).
-        Currently, there is only 1 instance of this class: request.rootpage
-    """
-    def __init__(self, request):
-        page_name = u''
-        Page.__init__(self, request, page_name)
-
-    def getPageBasePath(self, use_underlay=0):
-        """ Get full path to a page-specific storage area. `args` can
-            contain additional path components that are added to the base path.
-
-        @param use_underlay: force using a specific pagedir, default 0:
-                                1 = use underlay page dir
-                                0 = use standard page dir
-                                Note: we do NOT have special support for -1
-                                      here, that will just behave as 0!
-        @rtype: string
-        @return: int underlay,
-                 str the full path to the storage area
-        """
-        if self.cfg.data_underlay_dir is None:
-            use_underlay = 0
-
-        # 'auto' doesn't make sense here. maybe not even 'underlay':
-        if use_underlay == 1:
-            underlay, path = 1, self.cfg.data_underlay_dir
-        # no need to check 'standard' case, we just use path in that case!
-        else:
-            # this is the location of the virtual root page
-            underlay, path = 0, self.cfg.data_dir
-
-        return underlay, path
-
-    def getPageList(self, user=None, exists=1, filter=None, include_underlay=True, return_objects=False):
-        """ List user readable pages under current page
-
-        Currently only request.rootpage is used to list pages, but if we
-        have true sub pages, any page can list its sub pages.
-
-        The default behavior is listing all the pages readable by the
-        current user. If you want to get a page list for another user,
-        specify the user name.
-
-        If you want to get the full page list, without user filtering,
-        call with user="". Use this only if really needed, and do not
-        display pages the user can not read.
-
-        filter is usually compiled re match or search method, but can be
-        any method that get a unicode argument and return bool. If you
-        want to filter the page list, do it with this filter function,
-        and NOT on the output of this function. page.exists() and
-        user.may.read are very expensive, and should be done on the
-        smallest data set.
-
-        @param user: the user requesting the pages (MoinMoin.user.User)
-        @param filter: filter function
-        @param exists: filter existing pages
-        @param include_underlay: determines if underlay pages are returned as well
-        @param return_objects: lets it return a list of Page objects instead of
-            names
-        @rtype: list of unicode strings
-        @return: user readable wiki page names
-        """
-        request = self.request
-        request.clock.start('getPageList')
-        # Check input
-        if user is None:
-            user = request.user
-
-        # Get pages cache or create it
-        cachedlist = request.cfg.cache.pagelists.getItem(request, 'all', None)
-        if cachedlist is None:
-            cachedlist = {}
-            for name in self._listPages():
-                # Unquote file system names
-                pagename = wikiutil.unquoteWikiname(name)
-
-                # Filter those annoying editor backups - current moin does not create
-                # those pages any more, but users have them already in data/pages
-                # until we remove them by a mig script...
-                if pagename.endswith(u'/MoinEditorBackup'):
-                    continue
-
-                cachedlist[pagename] = None
-            request.cfg.cache.pagelists.putItem(request, 'all', None, cachedlist)
-
-        if user or exists or filter or not include_underlay or return_objects:
-            # Filter names
-            pages = []
-            for name in cachedlist:
-                # First, custom filter - exists and acl check are very
-                # expensive!
-                if filter and not filter(name):
-                    continue
-
-                page = Page(request, name)
-
-                # Filter underlay pages
-                if not include_underlay and page.getPageStatus()[0]: # is an underlay page
-                    continue
-
-                # Filter deleted pages
-                if exists and not page.exists():
-                    continue
-
-                # Filter out page user may not read.
-                if user and not user.may.read(name):
-                    continue
-
-                if return_objects:
-                    pages.append(page)
-                else:
-                    pages.append(name)
-        else:
-            pages = cachedlist.keys()
-
-        request.clock.stop('getPageList')
-        return pages
-
-    def getPageDict(self, user=None, exists=1, filter=None, include_underlay=True):
-        """ Return a dictionary of filtered page objects readable by user
-
-        Invoke getPageList then create a dict from the page list. See
-        getPageList docstring for more details.
-
-        @param user: the user requesting the pages
-        @param filter: filter function
-        @param exists: only existing pages
-        @rtype: dict {unicode: Page}
-        @return: user readable pages
-        """
-        pages = {}
-        for name in self.getPageList(user=user, exists=exists, filter=filter, include_underlay=include_underlay):
-            pages[name] = Page(self.request, name)
-        return pages
-
-    def _listPages(self):
-        """ Return a list of file system page names
-
-        This is the lowest level disk access, don't use it unless you
-        really need it.
-
-        NOTE: names are returned in file system encoding, not in unicode!
-
-        @rtype: dict
-        @return: dict of page names using file system encoding
-        """
-        # Get pages in standard dir
-        path = self.getPagePath('pages')
-        pages = self._listPageInPath(path)
-
-        if self.cfg.data_underlay_dir is not None:
-            # Merge with pages from underlay
-            path = self.getPagePath('pages', use_underlay=1)
-            underlay = self._listPageInPath(path)
-            pages.update(underlay)
-
-        return pages
-
-    def _listPageInPath(self, path):
-        """ List page names in domain, using path
-
-        This is the lowest level disk access, don't use it unless you
-        really need it.
-
-        NOTE: names are returned in file system encoding, not in unicode!
-
-        @param path: directory to list (string)
-        @rtype: dict
-        @return: dict of page names using file system encoding
-        """
-        pages = {}
-        for name in filesys.dclistdir(path):
-            # Filter non-pages in quoted wiki names
-            # List all pages in pages directory - assume flat namespace.
-            # We exclude everything starting with '.' to get rid of . and ..
-            # directory entries. If we ever create pagedirs starting with '.'
-            # it will be with the intention to have them not show up in page
-            # list (like .name won't show up for ls command under UNIX).
-            # Note that a . within a wiki page name will be quoted to (2e).
-            if not name.startswith('.'):
-                pages[name] = None
-
-        if 'CVS' in pages:
-            del pages['CVS'] # XXX DEPRECATED: remove this directory name just in
-                             # case someone has the pages dir under CVS control.
-        return pages
-
-    def getPageCount(self, exists=0):
-        """ Return page count
-
-        The default value does the fastest listing, and return count of
-        all pages, including deleted pages, ignoring acl rights.
-
-        If you want to get a more accurate number, call with
-        exists=1. This will be about 100 times slower though.
-
-        @param exists: filter existing pages
-        @rtype: int
-        @return: number of pages
-        """
-        self.request.clock.start('getPageCount')
-        if exists:
-            # WARNING: SLOW
-            pages = self.getPageList(user='')
-        else:
-            pages = self.request.pages
-            if not pages:
-                pages = self._listPages()
-        count = len(pages)
-        self.request.clock.stop('getPageCount')
-
-        return count
diff --git a/wiki-lenny/share/formatter.__init__.orig.py b/wiki-lenny/share/formatter.__init__.orig.py
deleted file mode 100644
index 595c61d3..00000000
--- a/wiki-lenny/share/formatter.__init__.orig.py
+++ /dev/null
@@ -1,432 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - Formatter Package and FormatterBase
-
-    See "base.py" for the formatter interface.
-
-    @copyright: 2000-2004 by Juergen Hermann <jh@web.de>
-    @license: GNU GPL, see COPYING for details.
-"""
-import re
-
-from MoinMoin import log
-logging = log.getLogger(__name__)
-
-from MoinMoin.util import pysupport
-from MoinMoin import wikiutil
-from MoinMoin.support.python_compatibility import rsplit
-
-modules = pysupport.getPackageModules(__file__)
-
-
-class FormatterBase:
-    """ This defines the output interface used all over the rest of the code.
-
-        Note that no other means should be used to generate _content_ output,
-        while navigational elements (HTML page header/footer) and the like
-        can be printed directly without violating output abstraction.
-    """
-
-    hardspace = ' '
-
-    def __init__(self, request, **kw):
-        self.request = request
-        self._ = request.getText
-
-        self._store_pagelinks = kw.get('store_pagelinks', 0)
-        self._terse = kw.get('terse', 0)
-        self.pagelinks = []
-        self.in_p = 0
-        self.in_pre = 0
-        self._highlight_re = None
-        self._base_depth = 0
-
-    def set_highlight_re(self, hi_re=None):
-        """ set the highlighting regular expression (e.g. for search terms)
-
-        @param hi_re: either a valid re as str/unicode (you may want to use
-                      re.escape before passing generic strings!) or a compiled
-                      re object. raises re.error for invalid re.
-        """
-        if isinstance(hi_re, (str, unicode)):
-            hi_re = re.compile(hi_re, re.U + re.IGNORECASE)
-        self._highlight_re = hi_re
-
-    def lang(self, on, lang_name):
-        return ""
-
-    def setPage(self, page):
-        self.page = page
-
-    def sysmsg(self, on, **kw):
-        """ Emit a system message (embed it into the page).
-
-            Normally used to indicate disabled options, or invalid markup.
-        """
-        return ""
-
-    # Document Level #####################################################
-
-    def startDocument(self, pagename):
-        return ""
-
-    def endDocument(self):
-        return ""
-
-    def startContent(self, content_id="content", **kw):
-        if self.page:
-            self.request.begin_include(self.page.page_name)
-        return ""
-
-    def endContent(self):
-        if self.page:
-            self.request.end_include()
-        return ""
-
-    # Links ##############################################################
-
-    def pagelink(self, on, pagename='', page=None, **kw):
-        """ make a link to page <pagename>. Instead of supplying a pagename,
-            it is also possible to give a live Page object, then page.page_name
-            will be used.
-        """
-        if not self._store_pagelinks or not on or kw.get('generated'):
-            return ''
-        if not pagename and page:
-            pagename = page.page_name
-        pagename = self.request.normalizePagename(pagename)
-        if pagename and pagename not in self.pagelinks:
-            self.pagelinks.append(pagename)
-
-    def interwikilink(self, on, interwiki='', pagename='', **kw):
-        """ calls pagelink() for internal interwikilinks
-            to make sure they get counted for self.pagelinks.
-            IMPORTANT: on and off must be called with same parameters, see
-                       also the text_html formatter.
-        """
-        wikitag, wikiurl, wikitail, wikitag_bad = wikiutil.resolve_interwiki(self.request, interwiki, pagename)
-        if wikitag == 'Self' or wikitag == self.request.cfg.interwikiname:
-            if '#' in wikitail:
-                wikitail, kw['anchor'] = rsplit(wikitail, '#', 1)
-                wikitail = wikiutil.url_unquote(wikitail)
-            return self.pagelink(on, wikitail, **kw)
-        return ''
-
-    def url(self, on, url=None, css=None, **kw):
-        raise NotImplementedError
-
-    # Attachments ######################################################
-
-    def attachment_link(self, on, url=None, **kw):
-        raise NotImplementedError
-    def attachment_image(self, url, **kw):
-        raise NotImplementedError
-    def attachment_drawing(self, url, text, **kw):
-        raise NotImplementedError
-
-    def attachment_inlined(self, url, text, **kw):
-        from MoinMoin.action import AttachFile
-        import os
-        _ = self.request.getText
-        pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
-        fname = wikiutil.taintfilename(filename)
-        fpath = AttachFile.getFilename(self.request, pagename, fname)
-        ext = os.path.splitext(filename)[1]
-        Parser = wikiutil.getParserForExtension(self.request.cfg, ext)
-        if Parser is not None:
-            try:
-                content = file(fpath, 'r').read()
-                # Try to decode text. It might return junk, but we don't
-                # have enough information with attachments.
-                content = wikiutil.decodeUnknownInput(content)
-                colorizer = Parser(content, self.request, filename=filename)
-                colorizer.format(self)
-            except IOError:
-                pass
-
-        return (self.attachment_link(1, url) +
-                self.text(text) +
-                self.attachment_link(0))
-
-    def anchordef(self, name):
-        return ""
-
-    def line_anchordef(self, lineno):
-        return ""
-
-    def anchorlink(self, on, name='', **kw):
-        return ""
-
-    def line_anchorlink(self, on, lineno=0):
-        return ""
-
-    def image(self, src=None, **kw):
-        """An inline image.
-
-        Extra keyword arguments are according to the HTML <img> tag attributes.
-        In particular an 'alt' or 'title' argument should give a description
-        of the image.
-        """
-        title = src
-        for titleattr in ('title', 'html__title', 'alt', 'html__alt'):
-            if titleattr in kw:
-                title = kw[titleattr]
-                break
-        if title:
-            return '[Image:%s]' % title
-        return '[Image]'
-
-    # generic transclude/include:
-    def transclusion(self, on, **kw):
-        raise NotImplementedError
-    def transclusion_param(self, **kw):
-        raise NotImplementedError
-
-    def smiley(self, text):
-        return text
-
-    def nowikiword(self, text):
-        return self.text(text)
-
-    # Text and Text Attributes ###########################################
-
-    def text(self, text, **kw):
-        if not self._highlight_re:
-            return self._text(text)
-
-        result = []
-        lastpos = 0
-        match = self._highlight_re.search(text)
-        while match and lastpos < len(text):
-            # add the match we found
-            result.append(self._text(text[lastpos:match.start()]))
-            result.append(self.highlight(1))
-            result.append(self._text(match.group(0)))
-            result.append(self.highlight(0))
-
-            # search for the next one
-            lastpos = match.end() + (match.end() == lastpos)
-            match = self._highlight_re.search(text, lastpos)
-
-        result.append(self._text(text[lastpos:]))
-        return ''.join(result)
-
-    def _text(self, text):
-        raise NotImplementedError
-
-    def strong(self, on, **kw):
-        raise NotImplementedError
-
-    def emphasis(self, on, **kw):
-        raise NotImplementedError
-
-    def underline(self, on, **kw):
-        raise NotImplementedError
-
-    def highlight(self, on, **kw):
-        raise NotImplementedError
-
-    def sup(self, on, **kw):
-        raise NotImplementedError
-
-    def sub(self, on, **kw):
-        raise NotImplementedError
-
-    def strike(self, on, **kw):
-        raise NotImplementedError
-
-    def code(self, on, **kw):
-        raise NotImplementedError
-
-    def preformatted(self, on, **kw):
-        self.in_pre = on != 0
-
-    def small(self, on, **kw):
-        raise NotImplementedError
-
-    def big(self, on, **kw):
-        raise NotImplementedError
-
-    # special markup for syntax highlighting #############################
-
-    def code_area(self, on, code_id, **kw):
-        raise NotImplementedError
-
-    def code_line(self, on):
-        raise NotImplementedError
-
-    def code_token(self, tok_text, tok_type):
-        raise NotImplementedError
-
-    # Paragraphs, Lines, Rules ###########################################
-
-    def linebreak(self, preformatted=1):
-        raise NotImplementedError
-
-    def paragraph(self, on, **kw):
-        self.in_p = on != 0
-
-    def rule(self, size=0, **kw):
-        raise NotImplementedError
-
-    def icon(self, type):
-        return type
-
-    # Lists ##############################################################
-
-    def number_list(self, on, type=None, start=None, **kw):
-        raise NotImplementedError
-
-    def bullet_list(self, on, **kw):
-        raise NotImplementedError
-
-    def listitem(self, on, **kw):
-        raise NotImplementedError
-
-    def definition_list(self, on, **kw):
-        raise NotImplementedError
-
-    def definition_term(self, on, compact=0, **kw):
-        raise NotImplementedError
-
-    def definition_desc(self, on, **kw):
-        raise NotImplementedError
-
-    def heading(self, on, depth, **kw):
-        raise NotImplementedError
-
-    # Tables #############################################################
-
-    def table(self, on, attrs={}, **kw):
-        raise NotImplementedError
-
-    def table_row(self, on, attrs={}, **kw):
-        raise NotImplementedError
-
-    def table_cell(self, on, attrs={}, **kw):
-        raise NotImplementedError
-
-    # Dynamic stuff / Plugins ############################################
-
-    def macro(self, macro_obj, name, args, markup=None):
-        # call the macro
-        try:
-            return macro_obj.execute(name, args)
-        except ImportError, err:
-            errmsg = unicode(err)
-            if not name in errmsg:
-                raise
-            if markup:
-                return (self.span(1, title=errmsg) +
-                        self.text(markup) +
-                        self.span(0))
-            else:
-                return self.text(errmsg)
-    def _get_bang_args(self, line):
-        if line.startswith('#!'):
-            try:
-                name, args = line[2:].split(None, 1)
-            except ValueError:
-                return ''
-            else:
-                return args
-        return None
-
-    def parser(self, parser_name, lines):
-        """ parser_name MUST be valid!
-            writes out the result instead of returning it!
-        """
-        # attention: this is copied into text_python!
-        parser = wikiutil.searchAndImportPlugin(self.request.cfg, "parser", parser_name)
-        args = None
-        if lines:
-            args = self._get_bang_args(lines[0])
-            logging.debug("formatter.parser: parser args %r" % args)
-            if args is not None:
-                lines = lines[1:]
-        if lines and not lines[0]:
-            lines = lines[1:]
-        if lines and not lines[-1].strip():
-            lines = lines[:-1]
-        p = parser('\n'.join(lines), self.request, format_args=args)
-        p.format(self)
-        del p
-        return ''
-
-    # Other ##############################################################
-
-    def div(self, on, **kw):
-        """ open/close a blocklevel division """
-        return ""
-
-    def span(self, on, **kw):
-        """ open/close a inline span """
-        return ""
-
-    def rawHTML(self, markup):
-        """ This allows emitting pre-formatted HTML markup, and should be
-            used wisely (i.e. very seldom).
-
-            Using this event while generating content results in unwanted
-            effects, like loss of markup or insertion of CDATA sections
-            when output goes to XML formats.
-        """
-
-        import formatter, htmllib
-        from MoinMoin.util import simpleIO
-
-        # Regenerate plain text
-        f = simpleIO()
-        h = htmllib.HTMLParser(formatter.AbstractFormatter(formatter.DumbWriter(f)))
-        h.feed(markup)
-        h.close()
-
-        return self.text(f.getvalue())
-
-    def escapedText(self, on, **kw):
-        """ This allows emitting text as-is, anything special will
-            be escaped (at least in HTML, some text output format
-            would possibly do nothing here)
-        """
-        return ""
-
-    def comment(self, text, **kw):
-        return ""
-
-    # ID handling #################################################
-
-    def sanitize_to_id(self, text):
-        '''
-        Take 'text' and return something that is a valid ID
-        for this formatter.
-        The default returns the first non-space character of the string.
-
-        Because of the way this is used, it must be idempotent,
-        i.e. calling it on an already sanitized id must yield the
-        original id.
-        '''
-        return text.strip()[:1]
-
-    def make_id_unique(self, id):
-        '''
-        Take an ID and make it unique in the current namespace.
-        '''
-        ns = self.request.include_id
-        if not ns is None:
-            ns = self.sanitize_to_id(ns)
-        id = self.sanitize_to_id(id)
-        id = self.request.make_unique_id(id, ns)
-        return id
-
-    def qualify_id(self, id):
-        '''
-        Take an ID and return a string that is qualified by
-        the current namespace; this default implementation
-        is suitable if the dot ('.') is valid in IDs for your
-        formatter.
-        '''
-        ns = self.request.include_id
-        if not ns is None:
-            ns = self.sanitize_to_id(ns)
-            return '%s.%s' % (ns, id)
-        return id
diff --git a/wiki-lenny/share/formatter.__init__.py b/wiki-lenny/share/formatter.__init__.py
deleted file mode 100644
index aa06ebe4..00000000
--- a/wiki-lenny/share/formatter.__init__.py
+++ /dev/null
@@ -1,438 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - Formatter Package and FormatterBase
-
-    See "base.py" for the formatter interface.
-
-    @copyright: 2000-2004 by Juergen Hermann <jh@web.de>
-    @license: GNU GPL, see COPYING for details.
-"""
-import re
-
-from MoinMoin import log
-logging = log.getLogger(__name__)
-
-from MoinMoin.util import pysupport
-from MoinMoin import wikiutil
-from MoinMoin.support.python_compatibility import rsplit
-
-modules = pysupport.getPackageModules(__file__)
-
-
-class FormatterBase:
-    """ This defines the output interface used all over the rest of the code.
-
-        Note that no other means should be used to generate _content_ output,
-        while navigational elements (HTML page header/footer) and the like
-        can be printed directly without violating output abstraction.
-    """
-
-    hardspace = ' '
-
-    def __init__(self, request, **kw):
-        self.request = request
-        self._ = request.getText
-
-        self._store_pagelinks = kw.get('store_pagelinks', 0)
-        self._terse = kw.get('terse', 0)
-        self.pagelinks = []
-        self.in_p = 0
-        self.in_pre = 0
-        self._highlight_re = None
-        self._base_depth = 0
-
-    def set_highlight_re(self, hi_re=None):
-        """ set the highlighting regular expression (e.g. for search terms)
-
-        @param hi_re: either a valid re as str/unicode (you may want to use
-                      re.escape before passing generic strings!) or a compiled
-                      re object. raises re.error for invalid re.
-        """
-        if isinstance(hi_re, (str, unicode)):
-            hi_re = re.compile(hi_re, re.U + re.IGNORECASE)
-        self._highlight_re = hi_re
-
-    def lang(self, on, lang_name):
-        return ""
-
-    def setPage(self, page):
-        self.page = page
-
-    def sysmsg(self, on, **kw):
-        """ Emit a system message (embed it into the page).
-
-            Normally used to indicate disabled options, or invalid markup.
-        """
-        return ""
-
-    # Document Level #####################################################
-
-    def startDocument(self, pagename):
-        return ""
-
-    def endDocument(self):
-        return ""
-
-    def startContent(self, content_id="content", **kw):
-        if self.page:
-            self.request.begin_include(self.page.page_name)
-        return ""
-
-    def endContent(self):
-        if self.page:
-            self.request.end_include()
-        return ""
-
-    # Links ##############################################################
-
-    def pagelink(self, on, pagename='', page=None, **kw):
-        """ make a link to page <pagename>. Instead of supplying a pagename,
-            it is also possible to give a live Page object, then page.page_name
-            will be used.
-        """
-        if not self._store_pagelinks or not on or kw.get('generated'):
-            return ''
-        if not pagename and page:
-            pagename = page.page_name
-        pagename = self.request.normalizePagename(pagename)
-        if pagename and pagename not in self.pagelinks:
-            self.pagelinks.append(pagename)
-
-    def interwikilink(self, on, interwiki='', pagename='', **kw):
-        """ calls pagelink() for internal interwikilinks
-            to make sure they get counted for self.pagelinks.
-            IMPORTANT: on and off must be called with same parameters, see
-                       also the text_html formatter.
-        """
-        wikitag, wikiurl, wikitail, wikitag_bad = wikiutil.resolve_interwiki(self.request, interwiki, pagename)
-        if wikitag == 'Self' or wikitag == self.request.cfg.interwikiname:
-            if '#' in wikitail:
-                wikitail, kw['anchor'] = rsplit(wikitail, '#', 1)
-                wikitail = wikiutil.url_unquote(wikitail)
-            return self.pagelink(on, wikitail, **kw)
-        return ''
-
-    def url(self, on, url=None, css=None, **kw):
-        raise NotImplementedError
-
-    # Attachments ######################################################
-
-    def attachment_link(self, on, url=None, **kw):
-        raise NotImplementedError
-    def attachment_image(self, url, **kw):
-        raise NotImplementedError
-    def attachment_drawing(self, url, text, **kw):
-        raise NotImplementedError
-
-    def attachment_inlined(self, url, text, **kw):
-        from MoinMoin.action import AttachFile
-        import os
-        _ = self.request.getText
-        pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
-        fname = wikiutil.taintfilename(filename)
-        fpath = AttachFile.getFilename(self.request, pagename, fname)
-        ext = os.path.splitext(filename)[1]
-        Parser = wikiutil.getParserForExtension(self.request.cfg, ext)
-        if Parser is not None:
-            try:
-                content = file(fpath, 'r').read()
-                # Try to decode text. It might return junk, but we don't
-                # have enough information with attachments.
-                content = wikiutil.decodeUnknownInput(content)
-                colorizer = Parser(content, self.request, filename=filename)
-                colorizer.format(self)
-            except IOError:
-                pass
-
-        return (self.attachment_link(1, url) +
-                self.text(text) +
-                self.attachment_link(0))
-
-    def anchordef(self, name):
-        return ""
-
-    def line_anchordef(self, lineno):
-        return ""
-
-    def anchorlink(self, on, name='', **kw):
-        return ""
-
-    def line_anchorlink(self, on, lineno=0):
-        return ""
-
-    def image(self, src=None, **kw):
-        """An inline image.
-
-        Extra keyword arguments are according to the HTML <img> tag attributes.
-        In particular an 'alt' or 'title' argument should give a description
-        of the image.
-        """
-        title = src
-        for titleattr in ('title', 'html__title', 'alt', 'html__alt'):
-            if titleattr in kw:
-                title = kw[titleattr]
-                break
-        if title:
-            return '[Image:%s]' % title
-        return '[Image]'
-
-    # generic transclude/include:
-    def transclusion(self, on, **kw):
-        raise NotImplementedError
-    def transclusion_param(self, **kw):
-        raise NotImplementedError
-
-    def smiley(self, text):
-        return text
-
-    def nowikiword(self, text):
-        return self.text(text)
-
-    # Text and Text Attributes ###########################################
-
-    def text(self, text, **kw):
-        if not self._highlight_re:
-            return self._text(text)
-
-        result = []
-        lastpos = 0
-        match = self._highlight_re.search(text)
-        while match and lastpos < len(text):
-            # add the match we found
-            result.append(self._text(text[lastpos:match.start()]))
-            result.append(self.highlight(1))
-            result.append(self._text(match.group(0)))
-            result.append(self.highlight(0))
-
-            # search for the next one
-            lastpos = match.end() + (match.end() == lastpos)
-            match = self._highlight_re.search(text, lastpos)
-
-        result.append(self._text(text[lastpos:]))
-        return ''.join(result)
-
-    def _text(self, text):
-        raise NotImplementedError
-
-    def strong(self, on, **kw):
-        raise NotImplementedError
-
-    def emphasis(self, on, **kw):
-        raise NotImplementedError
-
-    def underline(self, on, **kw):
-        raise NotImplementedError
-
-    def highlight(self, on, **kw):
-        raise NotImplementedError
-
-    def sup(self, on, **kw):
-        raise NotImplementedError
-
-    def sub(self, on, **kw):
-        raise NotImplementedError
-
-    def strike(self, on, **kw):
-        raise NotImplementedError
-
-    def code(self, on, **kw):
-        raise NotImplementedError
-
-    def preformatted(self, on, **kw):
-        self.in_pre = on != 0
-
-    def small(self, on, **kw):
-        raise NotImplementedError
-
-    def big(self, on, **kw):
-        raise NotImplementedError
-
-    # special markup for syntax highlighting #############################
-
-    def code_area(self, on, code_id, **kw):
-        raise NotImplementedError
-
-    def code_line(self, on):
-        raise NotImplementedError
-
-    def code_token(self, tok_text, tok_type):
-        raise NotImplementedError
-
-    def crans_box(self, title, content, color=None):
-        raise NotImplementedError
-
-    def crans_portal(self, entries):
-        raise NotImplementedError
-
-    # Paragraphs, Lines, Rules ###########################################
-
-    def linebreak(self, preformatted=1):
-        raise NotImplementedError
-
-    def paragraph(self, on, **kw):
-        self.in_p = on != 0
-
-    def rule(self, size=0, **kw):
-        raise NotImplementedError
-
-    def icon(self, type):
-        return type
-
-    # Lists ##############################################################
-
-    def number_list(self, on, type=None, start=None, **kw):
-        raise NotImplementedError
-
-    def bullet_list(self, on, **kw):
-        raise NotImplementedError
-
-    def listitem(self, on, **kw):
-        raise NotImplementedError
-
-    def definition_list(self, on, **kw):
-        raise NotImplementedError
-
-    def definition_term(self, on, compact=0, **kw):
-        raise NotImplementedError
-
-    def definition_desc(self, on, **kw):
-        raise NotImplementedError
-
-    def heading(self, on, depth, **kw):
-        raise NotImplementedError
-
-    # Tables #############################################################
-
-    def table(self, on, attrs={}, **kw):
-        raise NotImplementedError
-
-    def table_row(self, on, attrs={}, **kw):
-        raise NotImplementedError
-
-    def table_cell(self, on, attrs={}, **kw):
-        raise NotImplementedError
-
-    # Dynamic stuff / Plugins ############################################
-
-    def macro(self, macro_obj, name, args, markup=None):
-        # call the macro
-        try:
-            return macro_obj.execute(name, args)
-        except ImportError, err:
-            errmsg = unicode(err)
-            if not name in errmsg:
-                raise
-            if markup:
-                return (self.span(1, title=errmsg) +
-                        self.text(markup) +
-                        self.span(0))
-            else:
-                return self.text(errmsg)
-    def _get_bang_args(self, line):
-        if line.startswith('#!'):
-            try:
-                name, args = line[2:].split(None, 1)
-            except ValueError:
-                return ''
-            else:
-                return args
-        return None
-
-    def parser(self, parser_name, lines):
-        """ parser_name MUST be valid!
-            writes out the result instead of returning it!
-        """
-        # attention: this is copied into text_python!
-        parser = wikiutil.searchAndImportPlugin(self.request.cfg, "parser", parser_name)
-        args = None
-        if lines:
-            args = self._get_bang_args(lines[0])
-            logging.debug("formatter.parser: parser args %r" % args)
-            if args is not None:
-                lines = lines[1:]
-        if lines and not lines[0]:
-            lines = lines[1:]
-        if lines and not lines[-1].strip():
-            lines = lines[:-1]
-        p = parser('\n'.join(lines), self.request, format_args=args)
-        p.format(self)
-        del p
-        return ''
-
-    # Other ##############################################################
-
-    def div(self, on, **kw):
-        """ open/close a blocklevel division """
-        return ""
-
-    def span(self, on, **kw):
-        """ open/close a inline span """
-        return ""
-
-    def rawHTML(self, markup):
-        """ This allows emitting pre-formatted HTML markup, and should be
-            used wisely (i.e. very seldom).
-
-            Using this event while generating content results in unwanted
-            effects, like loss of markup or insertion of CDATA sections
-            when output goes to XML formats.
-        """
-
-        import formatter, htmllib
-        from MoinMoin.util import simpleIO
-
-        # Regenerate plain text
-        f = simpleIO()
-        h = htmllib.HTMLParser(formatter.AbstractFormatter(formatter.DumbWriter(f)))
-        h.feed(markup)
-        h.close()
-
-        return self.text(f.getvalue())
-
-    def escapedText(self, on, **kw):
-        """ This allows emitting text as-is, anything special will
-            be escaped (at least in HTML, some text output format
-            would possibly do nothing here)
-        """
-        return ""
-
-    def comment(self, text, **kw):
-        return ""
-
-    # ID handling #################################################
-
-    def sanitize_to_id(self, text):
-        '''
-        Take 'text' and return something that is a valid ID
-        for this formatter.
-        The default returns the first non-space character of the string.
-
-        Because of the way this is used, it must be idempotent,
-        i.e. calling it on an already sanitized id must yield the
-        original id.
-        '''
-        return text.strip()[:1]
-
-    def make_id_unique(self, id):
-        '''
-        Take an ID and make it unique in the current namespace.
-        '''
-        ns = self.request.include_id
-        if not ns is None:
-            ns = self.sanitize_to_id(ns)
-        id = self.sanitize_to_id(id)
-        id = self.request.make_unique_id(id, ns)
-        return id
-
-    def qualify_id(self, id):
-        '''
-        Take an ID and return a string that is qualified by
-        the current namespace; this default implementation
-        is suitable if the dot ('.') is valid in IDs for your
-        formatter.
-        '''
-        ns = self.request.include_id
-        if not ns is None:
-            ns = self.sanitize_to_id(ns)
-            return '%s.%s' % (ns, id)
-        return id
diff --git a/wiki-lenny/share/formatter.pagelinks.orig.py b/wiki-lenny/share/formatter.pagelinks.orig.py
deleted file mode 100644
index 8819b7bc..00000000
--- a/wiki-lenny/share/formatter.pagelinks.orig.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - pagelinks Formatter
-
-    @copyright: 2005 Nir Soffer <nirs@freeshell.org>
-    @license: GNU GPL, see COPYING for details.
-"""
-
-from MoinMoin.formatter import FormatterBase
-
-class Formatter(FormatterBase):
-    """ Collect pagelinks and format nothing :-) """
-
-    def pagelink(self, on, pagename='', page=None, **kw):
-        FormatterBase.pagelink(self, on, pagename, page, **kw)
-        return self.null()
-
-    def null(self, *args, **kw):
-        return ''
-
-    # All these must be overriden here because they raise
-    # NotImplementedError!@#! or return html?! in the base class.
-    set_highlight_re = rawHTML = url = image = smiley = text = null
-    strong = emphasis = underline = highlight = sup = sub = strike = null
-    code = preformatted = small = big = code_area = code_line = null
-    code_token = linebreak = paragraph = rule = icon = null
-    number_list = bullet_list = listitem = definition_list = null
-    definition_term = definition_desc = heading = table = null
-    table_row = table_cell = attachment_link = attachment_image = attachment_drawing = null
-    transclusion = transclusion_param = null
-
diff --git a/wiki-lenny/share/formatter.pagelinks.py b/wiki-lenny/share/formatter.pagelinks.py
deleted file mode 100644
index ebe03272..00000000
--- a/wiki-lenny/share/formatter.pagelinks.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - pagelinks Formatter
-
-    @copyright: 2005 Nir Soffer <nirs@freeshell.org>
-    @license: GNU GPL, see COPYING for details.
-"""
-
-from MoinMoin.formatter import FormatterBase
-
-class Formatter(FormatterBase):
-    """ Collect pagelinks and format nothing :-) """
-
-    def pagelink(self, on, pagename='', page=None, **kw):
-        FormatterBase.pagelink(self, on, pagename, page, **kw)
-        return self.null()
-
-    def null(self, *args, **kw):
-        return ''
-
-    # All these must be overriden here because they raise
-    # NotImplementedError!@#! or return html?! in the base class.
-    set_highlight_re = rawHTML = url = image = smiley = text = null
-    strong = emphasis = underline = highlight = sup = sub = strike = null
-    code = preformatted = small = big = code_area = code_line = null
-    code_token = linebreak = paragraph = rule = icon = null
-    number_list = bullet_list = listitem = definition_list = null
-    definition_term = definition_desc = heading = table = null
-    table_row = table_cell = attachment_link = attachment_image = attachment_drawing = null
-    transclusion = transclusion_param = null
-    ### HACK SAUVAGE 1/1
-    crans_box = crans_portal = null
-    ### FIN HACK 1/1
diff --git a/wiki-lenny/share/formatter.text_html.orig.py b/wiki-lenny/share/formatter.text_html.orig.py
deleted file mode 100644
index d2d879e7..00000000
--- a/wiki-lenny/share/formatter.text_html.orig.py
+++ /dev/null
@@ -1,1383 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - "text/html+css" Formatter
-
-    @copyright: 2000-2004 by Juergen Hermann <jh@web.de>
-    @license: GNU GPL, see COPYING for details.
-"""
-import os.path, re
-
-from MoinMoin import log
-logging = log.getLogger(__name__)
-
-from MoinMoin.formatter import FormatterBase
-from MoinMoin import wikiutil, i18n
-from MoinMoin.Page import Page
-from MoinMoin.action import AttachFile
-from MoinMoin.support.python_compatibility import set, rsplit
-
-# insert IDs into output wherever they occur
-# warning: breaks toggle line numbers javascript
-_id_debug = False
-
-line_anchors = True
-prettyprint = False
-
-# These are the HTML elements that we treat as block elements.
-_blocks = set(['dd', 'div', 'dl', 'dt', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
-               'hr', 'li', 'ol', 'p', 'pre', 'table', 'tbody', 'td', 'tfoot', 'th',
-               'thead', 'tr', 'ul', 'blockquote', ])
-
-# These are the HTML elements which are typically only used with
-# an opening tag without a separate closing tag.  We do not
-# include 'script' or 'style' because sometimes they do have
-# content, and also IE has a parsing bug with those two elements (only)
-# when they don't have a closing tag even if valid XHTML.
-
-_self_closing_tags = set(['area', 'base', 'br', 'col', 'frame', 'hr', 'img',
-                          'input', 'isindex', 'link', 'meta', 'param'])
-
-# We only open those tags and let the browser auto-close them:
-_auto_closing_tags = set(['p'])
-
-# These are the elements which generally should cause an increase in the
-# indention level in the html souce code.
-_indenting_tags = set(['ol', 'ul', 'dl', 'li', 'dt', 'dd', 'tr', 'td'])
-
-# These are the elements that discard any whitespace they contain as
-# immediate child nodes.
-_space_eating_tags = set(['colgroup', 'dl', 'frameset', 'head', 'map' 'menu',
-                          'ol', 'optgroup', 'select', 'table', 'tbody', 'tfoot',
-                          'thead', 'tr', 'ul'])
-
-# These are standard HTML attributes which are typically used without any
-# value; e.g., as boolean flags indicated by their presence.
-_html_attribute_boolflags = set(['compact', 'disabled', 'ismap', 'nohref',
-                                 'noresize', 'noshade', 'nowrap', 'readonly',
-                                 'selected', 'wrap'])
-
-# These are all the standard HTML attributes that are allowed on any element.
-_common_attributes = set(['accesskey', 'class', 'dir', 'disabled', 'id', 'lang',
-                          'style', 'tabindex', 'title'])
-
-
-def rewrite_attribute_name(name, default_namespace='html'):
-    """
-    Takes an attribute name and tries to make it HTML correct.
-
-    This function takes an attribute name as a string, as it may be
-    passed in to a formatting method using a keyword-argument syntax,
-    and tries to convert it into a real attribute name.  This is
-    necessary because some attributes may conflict with Python
-    reserved words or variable syntax (such as 'for', 'class', or
-    'z-index'); and also to help with backwards compatibility with
-    older versions of MoinMoin where different names may have been
-    used (such as 'content_id' or 'css').
-
-    Returns a tuple of strings: (namespace, attribute).
-
-    Namespaces: The default namespace is always assumed to be 'html',
-    unless the input string contains a colon or a double-underscore;
-    in which case the first such occurance is assumed to separate the
-    namespace prefix from name.  So, for example, to get the HTML
-    attribute 'for' (as on a <label> element), you can pass in the
-    string 'html__for' or even '__for'.
-
-    Hyphens:  To better support hyphens (which are not allowed in Python
-    variable names), all occurances of two underscores will be replaced
-    with a hyphen.  If you use this, then you must also provide a
-    namespace since the first occurance of '__' separates a namespace
-    from the name.
-
-    Special cases: Within the 'html' namespace, mainly to preserve
-    backwards compatibility, these exceptions ars recognized:
-    'content_type', 'content_id', 'css_class', and 'css'.
-    Additionally all html attributes starting with 'on' are forced to
-    lower-case.  Also the string 'xmlns' is recognized as having
-    no namespace.
-
-    Examples:
-        'id' -> ('html', 'id')
-        'css_class' -> ('html', 'class')
-        'content_id' -> ('html', 'id')
-        'content_type' -> ('html', 'type')
-        'html__for' -> ('html', 'for)
-        'xml__space' -> ('xml', 'space')
-        '__z__index' -> ('html', 'z-index')
-        '__http__equiv' -> ('html', 'http-equiv')
-        'onChange' -> ('html', 'onchange')
-        'xmlns' -> ('', 'xmlns')
-        'xmlns__abc' -> ('xmlns', 'abc')
-
-    (In actuality we only deal with namespace prefixes, not any real
-    namespace URI...we only care about the syntax not the meanings.)
-    """
-
-    # Handle any namespaces (just in case someday we support XHTML)
-    if ':' in name:
-        ns, name = name.split(':', 1)
-    elif '__' in name:
-        ns, name = name.split('__', 1)
-    elif name == 'xmlns':
-        ns = ''
-    else:
-        ns = default_namespace
-
-    name.replace('__', '-')
-    if ns == 'html':
-        # We have an HTML attribute, fix according to DTD
-        if name == 'content_type': # MIME type such as in <a> and <link> elements
-            name = 'type'
-        elif name == 'content_id': # moin historical convention
-            name = 'id'
-        elif name in ('css_class', 'css'): # to avoid python word 'class'
-            name = 'class'
-        elif name.startswith('on'): # event handler hook
-            name = name.lower()
-    return ns, name
-
-
-def extend_attribute_dictionary(attributedict, ns, name, value):
-    """Add a new attribute to an attribute dictionary, merging values where possible.
-
-    The attributedict must be a dictionary with tuple-keys of the form:
-    (namespace, attrname).
-
-    The given ns, name, and value will be added to the dictionary.  It
-    will replace the old value if it existed, except for a few special
-    cases where the values are logically merged instead (CSS class
-    names and style rules).
-
-    As a special case, if value is None (not just ''), then the
-    attribute is actually deleted from the dictionary.
-    """
-
-    key = ns, name
-    if value is None:
-        if key in attributedict:
-            del attributedict[key]
-    else:
-        if ns == 'html' and key in attributedict:
-            if name == 'class':
-                # CSS classes are appended by space-separated list
-                value = attributedict[key] + ' ' + value
-            elif name == 'style':
-                # CSS styles are appended by semicolon-separated rules list
-                value = attributedict[key] + '; ' + value
-            elif name in _html_attribute_boolflags:
-                # All attributes must have a value. According to XHTML those
-                # traditionally used as flags should have their value set to
-                # the same as the attribute name.
-                value = name
-        attributedict[key] = value
-
-
-class Formatter(FormatterBase):
-    """
-        Send HTML data.
-    """
-
-    hardspace = '&nbsp;'
-    indentspace = ' '
-
-    def __init__(self, request, **kw):
-        FormatterBase.__init__(self, request, **kw)
-        self._indent_level = 0
-
-        self._in_code = 0 # used by text_gedit
-        self._in_code_area = 0
-        self._in_code_line = 0
-        self._code_area_js = 0
-        self._code_area_state = ['', 0, -1, -1, 0]
-        self._show_section_numbers = None
-        self.pagelink_preclosed = False
-        self._is_included = kw.get('is_included', False)
-        self.request = request
-        self.cfg = request.cfg
-        self.no_magic = kw.get('no_magic', False) # disabled tag auto closing
-
-        if not hasattr(request, '_fmt_hd_counters'):
-            request._fmt_hd_counters = []
-
-    # Primitive formatter functions #####################################
-
-    # all other methods should use these to format tags. This keeps the
-    # code clean and handle pathological cases like unclosed p and
-    # inline tags.
-
-    def _langAttr(self, lang=None):
-        """ Return lang and dir attribute
-        (INTERNAL USE BY HTML FORMATTER ONLY!)
-
-        Must be used on all block elements - div, p, table, etc.
-        @param lang: if defined, will return attributes for lang. if not
-            defined, will return attributes only if the current lang is
-            different from the content lang.
-        @rtype: dict
-        @return: language attributes
-        """
-        if not lang:
-            lang = self.request.current_lang
-            # Actions that generate content in user language should change
-            # the content lang from the default defined in cfg.
-            if lang == self.request.content_lang:
-                # lang is inherited from content div
-                return {}
-
-        #attr = {'xml:lang': lang, 'lang': lang, 'dir': i18n.getDirection(lang),}
-        attr = {'lang': lang, 'dir': i18n.getDirection(lang), }
-        return attr
-
-    def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):
-        """ Return HTML attributes formatted as a single string. (INTERNAL USE BY HTML FORMATTER ONLY!)
-
-        @param attr: dict containing keys and values
-        @param allowed_attrs: A list of allowable attribute names
-        @param kw: other arbitrary attributes expressed as keyword arguments.
-        @rtype: string
-        @return: formated attributes or empty string
-
-        The attributes and their values can either be given in the
-        'attr' dictionary, or as extra keyword arguments.  They are
-        both merged together.  See the function
-        rewrite_attribute_name() for special notes on how to name
-        attributes.
-
-        Setting a value to None rather than a string (or string
-        coercible) will remove that attribute from the list.
-
-        If the list of allowed_attrs is provided, then an error is
-        raised if an HTML attribute is encountered that is not in that
-        list (or is not a common attribute which is always allowed or
-        is not in another XML namespace using the double-underscore
-        syntax).
-        """
-
-        # Merge the attr dict and kw dict into a single attributes
-        # dictionary (rewriting any attribute names, extracting
-        # namespaces, and merging some values like css classes).
-        attributes = {} # dict of key=(namespace,name): value=attribute_value
-        if attr:
-            for a, v in attr.items():
-                a_ns, a_name = rewrite_attribute_name(a)
-                extend_attribute_dictionary(attributes, a_ns, a_name, v)
-        if kw:
-            for a, v in kw.items():
-                a_ns, a_name = rewrite_attribute_name(a)
-                extend_attribute_dictionary(attributes, a_ns, a_name, v)
-
-        # Add title attribute if missing, but it has an alt.
-        if ('html', 'alt') in attributes and ('html', 'title') not in attributes:
-            attributes[('html', 'title')] = attributes[('html', 'alt')]
-
-        # Force both lang and xml:lang to be present and identical if
-        # either exists.  The lang takes precedence over xml:lang if
-        # both exist.
-        #if ('html', 'lang') in attributes:
-        #    attributes[('xml', 'lang')] = attributes[('html', 'lang')]
-        #elif ('xml', 'lang') in attributes:
-        #    attributes[('html', 'lang')] = attributes[('xml', 'lang')]
-
-        # Check all the HTML attributes to see if they are known and
-        # allowed.  Ignore attributes if in non-HTML namespaces.
-        if allowed_attrs:
-            for name in [key[1] for key in attributes if key[0] == 'html']:
-                if name in _common_attributes or name in allowed_attrs:
-                    pass
-                elif name.startswith('on'):
-                    pass  # Too many event handlers to enumerate, just let them all pass.
-                else:
-                    # Unknown or unallowed attribute.
-                    err = 'Illegal HTML attribute "%s" passed to formatter' % name
-                    raise ValueError(err)
-
-        # Finally, format them all as a single string.
-        if attributes:
-            # Construct a formatted string containing all attributes
-            # with their values escaped.  Any html:* namespace
-            # attributes drop the namespace prefix.  We build this by
-            # separating the attributes into three categories:
-            #
-            #  * Those without any namespace (should only be xmlns attributes)
-            #  * Those in the HTML namespace (we drop the html: prefix for these)
-            #  * Those in any other non-HTML namespace, including xml:
-
-            xmlnslist = ['%s="%s"' % (k[1], wikiutil.escape(v, 1))
-                         for k, v in attributes.items() if not k[0]]
-            htmllist = ['%s="%s"' % (k[1], wikiutil.escape(v, 1))
-                        for k, v in attributes.items() if k[0] == 'html']
-            otherlist = ['%s:%s="%s"' % (k[0], k[1], wikiutil.escape(v, 1))
-                         for k, v in attributes.items() if k[0] and k[0] != 'html']
-
-            # Join all these lists together in a space-separated string.  Also
-            # prefix the whole thing with a space too.
-            htmllist.sort()
-            otherlist.sort()
-            all = [''] + xmlnslist + htmllist + otherlist
-            return ' '.join(all)
-        return ''
-
-    def _open(self, tag, newline=False, attr=None, allowed_attrs=None,
-              is_unique=False, **kw):
-        """ Open a tag with optional attributes (INTERNAL USE BY HTML FORMATTER ONLY!)
-
-        @param tag: html tag, string
-        @param newline: render tag so following data is on a separate line
-        @param attr: dict with tag attributes
-        @param allowed_attrs: list of allowed attributes for this element
-        @param is_unique: ID is already unique
-        @param kw: arbitrary attributes and values
-        @rtype: string ?
-        @return: open tag with attributes as a string
-        """
-        # If it is self-closing, then don't expect a closing tag later on.
-        is_self_closing = (tag in _self_closing_tags) and ' /' or ''
-
-        # make ID unique
-        id = None
-        if not is_unique:
-            if attr and 'id' in attr:
-                id = self.make_id_unique(attr['id'])
-                id = self.qualify_id(id)
-                attr['id'] = id
-            if 'id' in kw:
-                id = self.make_id_unique(kw['id'])
-                id = self.qualify_id(id)
-                kw['id'] = id
-        else:
-            if attr and 'id' in attr:
-                id = attr['id']
-            if 'id' in kw:
-                id = kw['id']
-
-        if tag in _blocks:
-            # Block elements
-            result = []
-
-            # Add language attributes, but let caller overide the default
-            attributes = self._langAttr()
-            if attr:
-                attributes.update(attr)
-
-            # Format
-            attributes = self._formatAttributes(attributes, allowed_attrs=allowed_attrs, **kw)
-            result.append('<%s%s%s>' % (tag, attributes, is_self_closing))
-            if newline:
-                result.append(self._newline())
-            if _id_debug and id:
-                result.append('(%s) ' % id)
-            tagstr = ''.join(result)
-        else:
-            # Inline elements
-            tagstr = '<%s%s%s>' % (tag,
-                                      self._formatAttributes(attr, allowed_attrs, **kw),
-                                      is_self_closing)
-        return tagstr
-
-    def _close(self, tag, newline=False):
-        """ Close tag (INTERNAL USE BY HTML FORMATTER ONLY!)
-
-        @param tag: html tag, string
-        @param newline: render tag so following data is on a separate line
-        @rtype: string
-        @return: closing tag as a string
-        """
-        if tag in _self_closing_tags or (tag in _auto_closing_tags and not self.no_magic):
-            # This tag was already closed
-            tagstr = ''
-        elif tag in _blocks:
-            # Block elements
-            result = []
-            if newline:
-                result.append(self._newline())
-            result.append('</%s>' % (tag))
-            tagstr = ''.join(result)
-        else:
-            # Inline elements
-            tagstr = '</%s>' % tag
-
-        if newline:
-            tagstr += self._newline()
-        return tagstr
-
-    # Public methods ###################################################
-
-    def startContent(self, content_id='content', newline=True, **kw):
-        """ Start page content div.
-
-        A link anchor is provided at the beginning of the div, with
-        an id of 'top' (modified by the request ID cache).
-        """
-
-        if hasattr(self, 'page'):
-            self.request.begin_include(self.page.page_name)
-
-        result = []
-        # Use the content language
-        attr = self._langAttr(self.request.content_lang)
-        attr['id'] = content_id
-        result.append(self._open('div', newline=False, attr=attr,
-                                 allowed_attrs=['align'], **kw))
-        result.append(self.anchordef('top'))
-        if newline:
-            result.append('\n')
-        return ''.join(result)
-
-    def endContent(self, newline=True):
-        """ Close page content div.
-
-        A link anchor is provided at the end of the div, with
-        an id of 'bottom' (modified by the request ID cache).
-        """
-
-        result = []
-        result.append(self.anchordef('bottom'))
-        result.append(self._close('div', newline=newline))
-        if hasattr(self, 'page'):
-            self.request.end_include()
-        return ''.join(result)
-
-    def lang(self, on, lang_name):
-        """ Insert text with specific lang and direction.
-
-            Enclose within span tag if lang_name is different from
-            the current lang
-        """
-        tag = 'span'
-        if lang_name != self.request.current_lang:
-            # Enclose text in span using lang attributes
-            if on:
-                attr = self._langAttr(lang=lang_name)
-                return self._open(tag, attr=attr)
-            return self._close(tag)
-
-        # Direction did not change, no need for span
-        return ''
-
-    # Links ##############################################################
-
-    def pagelink(self, on, pagename='', page=None, **kw):
-        """ Link to a page.
-
-            formatter.text_python will use an optimized call with a page!=None
-            parameter. DO NOT USE THIS YOURSELF OR IT WILL BREAK.
-
-            See wikiutil.link_tag() for possible keyword parameters.
-        """
-        FormatterBase.pagelink(self, on, pagename, page, **kw)
-        if 'generated' in kw:
-            del kw['generated']
-        if page is None:
-            page = Page(self.request, pagename, formatter=self)
-        if self.request.user.show_nonexist_qm and on and not page.exists():
-            self.pagelink_preclosed = True
-            return (page.link_to(self.request, on=1, **kw) +
-                    self.text("?") +
-                    page.link_to(self.request, on=0, **kw))
-        elif not on and self.pagelink_preclosed:
-            self.pagelink_preclosed = False
-            return ""
-        else:
-            return page.link_to(self.request, on=on, **kw)
-
-    def interwikilink(self, on, interwiki='', pagename='', **kw):
-        """
-        @keyword title: override using the interwiki wikiname as title
-        """
-        querystr = kw.get('querystr', {})
-        wikitag, wikiurl, wikitail, wikitag_bad = wikiutil.resolve_interwiki(self.request, interwiki, pagename)
-        wikiurl = wikiutil.mapURL(self.request, wikiurl)
-        if wikitag == 'Self': # for own wiki, do simple links
-            if '#' in wikitail:
-                wikitail, kw['anchor'] = rsplit(wikitail, '#', 1)
-            wikitail = wikiutil.url_unquote(wikitail)
-            try: # XXX this is the only place where we access self.page - do we need it? Crashes silently on actions!
-                pagename = wikiutil.AbsPageName(self.page.page_name, wikitail)
-            except:
-                pagename = wikitail
-            return self.pagelink(on, pagename, **kw)
-        else: # return InterWiki hyperlink
-            if on:
-                href = wikiutil.join_wiki(wikiurl, wikitail)
-                if querystr:
-                    separator = ('?', '&')['?' in href]
-                    href = '%s%s%s' % (href, separator, wikiutil.makeQueryString(querystr))
-                if wikitag_bad:
-                    html_class = 'badinterwiki'
-                else:
-                    html_class = 'interwiki'
-                title = kw.get('title', wikitag)
-                return self.url(1, href, title=title, css=html_class) # interwiki links with umlauts
-            else:
-                return self.url(0)
-
-    def url(self, on, url=None, css=None, do_escape=None, **kw):
-        """
-        Inserts an <a> element (you can give any A tag attributes as kw args).
-
-        @param on: 1 to start the link, 0 to end the link (no other arguments are needed when on==0).
-        @param url: the URL to link to; will go through Wiki URL mapping.
-        @param css: a space-separated list of CSS classes
-        @param do_escape: DEPRECATED and not used any more, please remove it from your code!
-                          We will remove this parameter in moin 1.8 (it used to filter url
-                          param through wikiutil.escape, but text_html formatter's _open
-                          will do it again, so this just leads to double escaping now).
-        """
-        if do_escape is not None:
-            if do_escape:
-                logging.warning("Deprecation warning: MoinMoin.formatter.text_html.url being called with do_escape=1/True parameter, please review caller.")
-            else:
-                logging.warning("Deprecation warning: MoinMoin.formatter.text_html.url being called with do_escape=0/False parameter, please remove it from the caller.")
-        if on:
-            attrs = self._langAttr()
-
-            # Handle the URL mapping
-            if url is None and 'href' in kw:
-                url = kw['href']
-                del kw['href']
-            if url is not None:
-                url = wikiutil.mapURL(self.request, url)
-                attrs['href'] = url
-
-            if css:
-                attrs['class'] = css
-
-            markup = self._open('a', attr=attrs, **kw)
-        else:
-            markup = self._close('a')
-        return markup
-
-    def anchordef(self, id):
-        """Inserts an invisible element used as a link target.
-
-        Inserts an empty <span> element with an id attribute, used as an anchor
-        for link references.  We use <span></span> rather than <span/>
-        for browser portability.
-        """
-        # Don't add newlines, \n, as it will break pre and
-        # line-numbered code sections (from line_achordef() method).
-        #return '<a id="%s"></a>' % (id, ) # do not use - this breaks PRE sections for IE
-        id = self.make_id_unique(id)
-        id = self.qualify_id(id)
-        return '<span class="anchor" id="%s"></span>' % id
-
-    def line_anchordef(self, lineno):
-        if line_anchors:
-            return self.anchordef("line-%d" % lineno)
-        else:
-            return ''
-
-    def anchorlink(self, on, name='', **kw):
-        """Insert an <a> link pointing to an anchor on the same page.
-
-        Call once with on=1 to start the link, and a second time with
-        on=0 to end it.  No other arguments are needed on the second
-        call.
-
-        The name argument should be the same as the id provided to the
-        anchordef() method, or some other elment.  It should NOT start
-        with '#' as that will be added automatically.
-
-        The id argument, if provided, is instead the id of this link
-        itself and not of the target element the link references.
-        """
-        attrs = self._langAttr()
-        if name:
-            name = self.sanitize_to_id(name)
-            attrs['href'] = '#' + self.qualify_id(name)
-        if 'href' in kw:
-            del kw['href']
-        if on:
-            str = self._open('a', attr=attrs, **kw)
-        else:
-            str = self._close('a')
-        return str
-
-    def line_anchorlink(self, on, lineno=0):
-        if line_anchors:
-            return self.anchorlink(on, name="line-%d" % lineno)
-        else:
-            return ''
-
-    # Attachments ######################################################
-
-    def attachment_link(self, on, url=None, **kw):
-        """ Link to an attachment.
-
-            @param on: 1/True=start link, 0/False=end link
-            @param url: filename.ext or PageName/filename.ext
-        """
-        assert on in (0, 1, False, True) # make sure we get called the new way, not like the 1.5 api was
-        _ = self.request.getText
-        querystr = kw.get('querystr', {})
-        assert isinstance(querystr, dict) # new in 1.6, only support dicts
-        if 'do' not in querystr:
-            querystr['do'] = 'view'
-        if on:
-            pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
-            #logging.debug("attachment_link: url %s pagename %s filename %s" % (url, pagename, filename))
-            fname = wikiutil.taintfilename(filename)
-            if AttachFile.exists(self.request, pagename, fname):
-                target = AttachFile.getAttachUrl(pagename, fname, self.request, do=querystr['do'])
-                title = "attachment:%s" % url
-                css = 'attachment'
-            else:
-                target = AttachFile.getAttachUrl(pagename, fname, self.request, upload=True)
-                title = _('Upload new attachment "%(filename)s"') % {'filename': fname}
-                css = 'attachment nonexistent'
-            return self.url(on, target, css=css, title=title)
-        else:
-            return self.url(on)
-
-    def attachment_image(self, url, **kw):
-        _ = self.request.getText
-        pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
-        fname = wikiutil.taintfilename(filename)
-        exists = AttachFile.exists(self.request, pagename, fname)
-        if exists:
-            kw['css'] = 'attachment'
-            kw['src'] = AttachFile.getAttachUrl(pagename, filename, self.request, addts=1)
-            title = _('Inlined image: %(url)s') % {'url': self.text(url)}
-            if not 'title' in kw:
-                kw['title'] = title
-            # alt is required for images:
-            if not 'alt' in kw:
-                kw['alt'] = kw['title']
-            return self.image(**kw)
-        else:
-            title = _('Upload new attachment "%(filename)s"') % {'filename': fname}
-            img = self.icon('attachimg')
-            css = 'nonexistent'
-            target = AttachFile.getAttachUrl(pagename, fname, self.request, upload=True)
-            return self.url(1, target, css=css, title=title) + img + self.url(0)
-
-    def attachment_drawing(self, url, text, **kw):
-        _ = self.request.getText
-        pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
-        fname = wikiutil.taintfilename(filename)
-        drawing = fname
-        fname = fname + u".png"
-        filename = filename + u".png"
-        # fallback for old gif drawings (1.1 -> 1.2)
-        exists = AttachFile.exists(self.request, pagename, fname)
-        if not exists:
-            gfname = fname[:-4] + u".gif"
-            gfilename = filename[:-4] + u".gif"
-            exists = AttachFile.exists(self.request, pagename, gfname)
-            if exists:
-                fname, filename = gfname, gfilename
-
-        # check whether attachment exists, possibly point to upload form
-        drawing_url = AttachFile.getAttachUrl(pagename, fname, self.request, drawing=drawing, upload=True)
-        if not exists:
-            linktext = _('Create new drawing "%(filename)s (opens in new window)"')
-            return (self.url(1, drawing_url) +
-                    self.text(linktext % {'filename': fname}) +
-                    self.url(0))
-
-        mappath = AttachFile.getFilename(self.request, pagename, drawing + u'.map')
-
-        # check for map file
-        if os.path.exists(mappath):
-            # we have a image map. inline it and add a map ref to the img tag
-            try:
-                map = file(mappath, 'r').read()
-            except IOError:
-                pass
-            except OSError:
-                pass
-            else:
-                mapid = 'ImageMapOf' + drawing
-                # replace MAPNAME
-                map = map.replace('%MAPNAME%', mapid)
-                # add alt and title tags to areas
-                map = re.sub('href\s*=\s*"((?!%TWIKIDRAW%).+?)"', r'href="\1" alt="\1" title="\1"', map)
-                # add in edit links plus alt and title attributes
-                alt = title = _('Edit drawing %(filename)s (opens in new window)') % {'filename': self.text(fname)}
-                map = map.replace('%TWIKIDRAW%"', '%s" alt="%s" title="%s"' % (drawing_url, alt, title))
-                # unxml, because 4.01 concrete will not validate />
-                map = map.replace('/>', '>')
-                alt = title = _('Clickable drawing: %(filename)s') % {'filename': self.text(fname)}
-                src = AttachFile.getAttachUrl(pagename, filename, self.request, addts=1)
-                return (map + self.image(alt=alt, title=title, src=src, usemap='#'+mapid, css="drawing"))
-        else:
-            alt = title = _('Edit drawing %(filename)s (opens in new window)') % {'filename': self.text(fname)}
-            src = AttachFile.getAttachUrl(pagename, filename, self.request, addts=1)
-            return (self.url(1, drawing_url) +
-                    self.image(alt=alt, title=title, src=src, css="drawing") +
-                    self.url(0))
-
-
-    # Text ##############################################################
-
-    def _text(self, text):
-        text = wikiutil.escape(text)
-        if self._in_code:
-            text = text.replace(' ', self.hardspace)
-        return text
-
-    # Inline ###########################################################
-
-    def strong(self, on, **kw):
-        """Creates an HTML <strong> element.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'strong'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def emphasis(self, on, **kw):
-        """Creates an HTML <em> element.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'em'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def underline(self, on, **kw):
-        """Creates a text span for underlining (css class "u").
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'span'
-        if on:
-            return self._open(tag, attr={'class': 'u'}, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def highlight(self, on, **kw):
-        """Creates a text span for highlighting (css class "highlight").
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'strong'
-        if on:
-            return self._open(tag, attr={'class': 'highlight'}, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def sup(self, on, **kw):
-        """Creates a <sup> element for superscript text.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'sup'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def sub(self, on, **kw):
-        """Creates a <sub> element for subscript text.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'sub'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def strike(self, on, **kw):
-        """Creates a text span for line-through (strikeout) text (css class 'strike').
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        # This does not use <strike> because has been deprecated in standard HTML.
-        tag = 'span'
-        if on:
-            return self._open(tag, attr={'class': 'strike'},
-                              allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def code(self, on, **kw):
-        """Creates a <tt> element for inline code or monospaced text.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-
-        Any text within this section will have spaces converted to
-        non-break spaces.
-        """
-        tag = 'tt'
-        self._in_code = on
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def small(self, on, **kw):
-        """Creates a <small> element for smaller font.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'small'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def big(self, on, **kw):
-        """Creates a <big> element for larger font.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'big'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-
-    # Block elements ####################################################
-
-    def preformatted(self, on, **kw):
-        """Creates a preformatted text region, with a <pre> element.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        FormatterBase.preformatted(self, on)
-        tag = 'pre'
-        if on:
-            return self._open(tag, newline=1, **kw)
-        return self._close(tag)
-
-    # Use by code area
-    _toggleLineNumbersScript = """
-<script type="text/javascript">
-function isnumbered(obj) {
-  return obj.childNodes.length && obj.firstChild.childNodes.length && obj.firstChild.firstChild.className == 'LineNumber';
-}
-function nformat(num,chrs,add) {
-  var nlen = Math.max(0,chrs-(''+num).length), res = '';
-  while (nlen>0) { res += ' '; nlen-- }
-  return res+num+add;
-}
-function addnumber(did, nstart, nstep) {
-  var c = document.getElementById(did), l = c.firstChild, n = 1;
-  if (!isnumbered(c))
-    if (typeof nstart == 'undefined') nstart = 1;
-    if (typeof nstep  == 'undefined') nstep = 1;
-    n = nstart;
-    while (l != null) {
-      if (l.tagName == 'SPAN') {
-        var s = document.createElement('SPAN');
-        s.className = 'LineNumber'
-        s.appendChild(document.createTextNode(nformat(n,4,' ')));
-        n += nstep;
-        if (l.childNodes.length)
-          l.insertBefore(s, l.firstChild)
-        else
-          l.appendChild(s)
-      }
-      l = l.nextSibling;
-    }
-  return false;
-}
-function remnumber(did) {
-  var c = document.getElementById(did), l = c.firstChild;
-  if (isnumbered(c))
-    while (l != null) {
-      if (l.tagName == 'SPAN' && l.firstChild.className == 'LineNumber') l.removeChild(l.firstChild);
-      l = l.nextSibling;
-    }
-  return false;
-}
-function togglenumber(did, nstart, nstep) {
-  var c = document.getElementById(did);
-  if (isnumbered(c)) {
-    remnumber(did);
-  } else {
-    addnumber(did,nstart,nstep);
-  }
-  return false;
-}
-</script>
-"""
-
-    def code_area(self, on, code_id, code_type='code', show=0, start=-1, step=-1):
-        """Creates a formatted code region, with line numbering.
-
-        This region is formatted as a <div> with a <pre> inside it.  The
-        code_id argument is assigned to the 'id' of the div element, and
-        must be unique within the document.  The show, start, and step are
-        used for line numbering.
-
-        Note this is not like most formatter methods, it can not take any
-        extra keyword arguments.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        _ = self.request.getText
-        res = []
-        if on:
-            code_id = self.sanitize_to_id('CA-%s' % code_id)
-            ci = self.qualify_id(self.make_id_unique(code_id))
-
-            # Open a code area
-            self._in_code_area = 1
-            self._in_code_line = 0
-            # id in here no longer used
-            self._code_area_state = [None, show, start, step, start]
-
-            # Open the code div - using left to right always!
-            attr = {'class': 'codearea', 'lang': 'en', 'dir': 'ltr'}
-            res.append(self._open('div', attr=attr))
-
-            # Add the script only in the first code area on the page
-            if self._code_area_js == 0 and self._code_area_state[1] >= 0:
-                res.append(self._toggleLineNumbersScript)
-                self._code_area_js = 1
-
-            # Add line number link, but only for JavaScript enabled browsers.
-            if self._code_area_state[1] >= 0:
-                toggleLineNumbersLink = r'''
-<script type="text/javascript">
-document.write('<a href="#" onclick="return togglenumber(\'%s\', %d, %d);" \
-                class="codenumbers">%s<\/a>');
-</script>
-''' % (ci, self._code_area_state[2], self._code_area_state[3],
-       _("Toggle line numbers"))
-                res.append(toggleLineNumbersLink)
-
-            # Open pre - using left to right always!
-            attr = {'id': ci, 'lang': 'en', 'dir': 'ltr'}
-            res.append(self._open('pre', newline=True, attr=attr, is_unique=True))
-        else:
-            # Close code area
-            res = []
-            if self._in_code_line:
-                res.append(self.code_line(0))
-            res.append(self._close('pre'))
-            res.append(self._close('div'))
-
-            # Update state
-            self._in_code_area = 0
-
-        return ''.join(res)
-
-    def code_line(self, on):
-        res = ''
-        if not on or (on and self._in_code_line):
-            res += '</span>\n'
-        if on:
-            res += '<span class="line">'
-            if self._code_area_state[1] > 0:
-                res += '<span class="LineNumber">%4d </span>' % (self._code_area_state[4], )
-                self._code_area_state[4] += self._code_area_state[3]
-        self._in_code_line = on != 0
-        return res
-
-    def code_token(self, on, tok_type):
-        return ['<span class="%s">' % tok_type, '</span>'][not on]
-
-    # Paragraphs, Lines, Rules ###########################################
-
-    def _indent_spaces(self):
-        """Returns space(s) for indenting the html source so list nesting is easy to read.
-
-        Note that this mostly works, but because of caching may not always be accurate."""
-        if prettyprint:
-            return self.indentspace * self._indent_level
-        else:
-            return ''
-
-    def _newline(self):
-        """Returns the whitespace for starting a new html source line, properly indented."""
-        if prettyprint:
-            return '\n' + self._indent_spaces()
-        else:
-            return ''
-
-    def linebreak(self, preformatted=1):
-        """Creates a line break in the HTML output.
-
-        If preformatted is true a <br> element is inserted, otherwise
-        the linebreak will only be visible in the HTML source.
-        """
-        if self._in_code_area:
-            preformatted = 1
-        return ['\n', '<br>\n'][not preformatted] + self._indent_spaces()
-
-    def paragraph(self, on, **kw):
-        """Creates a paragraph with a <p> element.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        if self._terse:
-            return ''
-        FormatterBase.paragraph(self, on)
-        tag = 'p'
-        if on:
-            tagstr = self._open(tag, **kw)
-        else:
-            tagstr = self._close(tag)
-        return tagstr
-
-    def rule(self, size=None, **kw):
-        """Creates a horizontal rule with an <hr> element.
-
-        If size is a number in the range [1..6], the CSS class of the rule
-        is set to 'hr1' through 'hr6'.  The intent is that the larger the
-        size number the thicker or bolder the rule will be.
-        """
-        if size and 1 <= size <= 6:
-            # Add hr class: hr1 - hr6
-            return self._open('hr', newline=1, attr={'class': 'hr%d' % size}, **kw)
-        return self._open('hr', newline=1, **kw)
-
-    # Images / Transclusion ##############################################
-
-    def icon(self, type):
-        return self.request.theme.make_icon(type)
-
-    smiley = icon
-
-    def image(self, src=None, **kw):
-        """Creates an inline image with an <img> element.
-
-        The src argument must be the URL to the image file.
-        """
-        if src:
-            kw['src'] = src
-        return self._open('img', **kw)
-
-    def transclusion(self, on, **kw):
-        """Transcludes (includes/embeds) another object."""
-        if on:
-            return self._open('object',
-                              allowed_attrs=['archive', 'classid', 'codebase',
-                                             'codetype', 'data', 'declare',
-                                             'height', 'name', 'standby',
-                                             'type', 'width', ],
-                              **kw)
-        else:
-            return self._close('object')
-
-    def transclusion_param(self, **kw):
-        """Give a parameter to a transcluded object."""
-        return self._open('param',
-                          allowed_attrs=['name', 'type', 'value', 'valuetype', ],
-                          **kw)
-
-    # Lists ##############################################################
-
-    def number_list(self, on, type=None, start=None, **kw):
-        """Creates an HTML ordered list, <ol> element.
-
-        The 'type' if specified can be any legal numbered
-        list-style-type, such as 'decimal','lower-roman', etc.
-
-        The 'start' argument if specified gives the numeric value of
-        the first list item (default is 1).
-
-        Call once with on=1 to start the list, and a second time
-        with on=0 to end it.
-        """
-        tag = 'ol'
-        if on:
-            attr = {}
-            if type is not None:
-                attr['type'] = type
-            if start is not None:
-                attr['start'] = start
-            tagstr = self._open(tag, newline=1, attr=attr, **kw)
-        else:
-            tagstr = self._close(tag, newline=1)
-        return tagstr
-
-    def bullet_list(self, on, **kw):
-        """Creates an HTML ordered list, <ul> element.
-
-        The 'type' if specified can be any legal unnumbered
-        list-style-type, such as 'disc','square', etc.
-
-        Call once with on=1 to start the list, and a second time
-        with on=0 to end it.
-        """
-        tag = 'ul'
-        if on:
-            tagstr = self._open(tag, newline=1, **kw)
-        else:
-            tagstr = self._close(tag, newline=1)
-        return tagstr
-
-    def listitem(self, on, **kw):
-        """Adds a list item, <li> element, to a previously opened
-        bullet or number list.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'li'
-        if on:
-            tagstr = self._open(tag, newline=1, **kw)
-        else:
-            tagstr = self._close(tag, newline=1)
-        return tagstr
-
-    def definition_list(self, on, **kw):
-        """Creates an HTML definition list, <dl> element.
-
-        Call once with on=1 to start the list, and a second time
-        with on=0 to end it.
-        """
-        tag = 'dl'
-        if on:
-            tagstr = self._open(tag, newline=1, **kw)
-        else:
-            tagstr = self._close(tag, newline=1)
-        return tagstr
-
-    def definition_term(self, on, **kw):
-        """Adds a new term to a definition list, HTML element <dt>.
-
-        Call once with on=1 to start the term, and a second time
-        with on=0 to end it.
-        """
-        tag = 'dt'
-        if on:
-            tagstr = self._open(tag, newline=1, **kw)
-        else:
-            tagstr = self._close(tag, newline=0)
-        return tagstr
-
-    def definition_desc(self, on, **kw):
-        """Gives the definition to a definition item, HTML element <dd>.
-
-        Call once with on=1 to start the definition, and a second time
-        with on=0 to end it.
-        """
-        tag = 'dd'
-        if on:
-            tagstr = self._open(tag, newline=1, **kw)
-        else:
-            tagstr = self._close(tag, newline=0)
-        return tagstr
-
-    def heading(self, on, depth, **kw):
-        # remember depth of first heading, and adapt counting depth accordingly
-        if not self._base_depth:
-            self._base_depth = depth
-
-        count_depth = max(depth - (self._base_depth - 1), 1)
-
-        # check numbering, possibly changing the default
-        if self._show_section_numbers is None:
-            self._show_section_numbers = self.cfg.show_section_numbers
-            numbering = self.request.getPragma('section-numbers', '').lower()
-            if numbering in ['0', 'off']:
-                self._show_section_numbers = 0
-            elif numbering in ['1', 'on']:
-                self._show_section_numbers = 1
-            elif numbering in ['2', '3', '4', '5', '6']:
-                # explicit base level for section number display
-                self._show_section_numbers = int(numbering)
-
-        heading_depth = depth
-
-        # closing tag, with empty line after, to make source more readable
-        if not on:
-            return self._close('h%d' % heading_depth) + '\n'
-
-        # create section number
-        number = ''
-        if self._show_section_numbers:
-            # count headings on all levels
-            self.request._fmt_hd_counters = self.request._fmt_hd_counters[:count_depth]
-            while len(self.request._fmt_hd_counters) < count_depth:
-                self.request._fmt_hd_counters.append(0)
-            self.request._fmt_hd_counters[-1] = self.request._fmt_hd_counters[-1] + 1
-            number = '.'.join([str(x) for x in self.request._fmt_hd_counters[self._show_section_numbers-1:]])
-            if number: number += ". "
-
-        # Add space before heading, easier to check source code
-        result = '\n' + self._open('h%d' % heading_depth, **kw)
-
-        if self.request.user.show_topbottom:
-            result += "%s%s%s%s%s%s" % (
-                       self.anchorlink(1, "bottom"), self.icon('bottom'), self.anchorlink(0),
-                       self.anchorlink(1, "top"), self.icon('top'), self.anchorlink(0))
-
-        return "%s%s" % (result, number)
-
-
-    # Tables #############################################################
-
-    _allowed_table_attrs = {
-        'table': ['class', 'id', 'style'],
-        'row': ['class', 'id', 'style'],
-        '': ['colspan', 'rowspan', 'class', 'id', 'style', 'abbr'],
-    }
-
-    def _checkTableAttr(self, attrs, prefix):
-        """ Check table attributes
-
-        Convert from wikitable attributes to html 4 attributes.
-
-        @param attrs: attribute dict
-        @param prefix: used in wiki table attributes
-        @rtype: dict
-        @return: valid table attributes
-        """
-        if not attrs:
-            return {}
-
-        result = {}
-        s = [] # we collect synthesized style in s
-        for key, val in attrs.items():
-            # Ignore keys that don't start with prefix
-            if prefix and key[:len(prefix)] != prefix:
-                continue
-            key = key[len(prefix):]
-            val = val.strip('"')
-            # remove invalid attrs from dict and synthesize style
-            if key == 'width':
-                s.append("width: %s" % val)
-            elif key == 'height':
-                s.append("height: %s" % val)
-            elif key == 'bgcolor':
-                s.append("background-color: %s" % val)
-            elif key == 'align':
-                s.append("text-align: %s" % val)
-            elif key == 'valign':
-                s.append("vertical-align: %s" % val)
-            # Ignore unknown keys
-            if key not in self._allowed_table_attrs[prefix]:
-                continue
-            result[key] = val
-        st = result.get('style', '').split(';')
-        st = '; '.join(st + s)
-        st = st.strip(';')
-        st = st.strip()
-        if not st:
-            try:
-                del result['style'] # avoid empty style attr
-            except:
-                pass
-        else:
-            result['style'] = st
-        #logging.debug("_checkTableAttr returns %r" % result)
-        return result
-
-
-    def table(self, on, attrs=None, **kw):
-        """ Create table
-
-        @param on: start table
-        @param attrs: table attributes
-        @rtype: string
-        @return start or end tag of a table
-        """
-        result = []
-        if on:
-            # Open div to get correct alignment with table width smaller
-            # than 100%
-            result.append(self._open('div', newline=1))
-
-            # Open table
-            if not attrs:
-                attrs = {}
-            else:
-                attrs = self._checkTableAttr(attrs, 'table')
-            result.append(self._open('table', newline=1, attr=attrs,
-                                     allowed_attrs=self._allowed_table_attrs['table'],
-                                     **kw))
-            result.append(self._open('tbody', newline=1))
-        else:
-            # Close tbody, table, and then div
-            result.append(self._close('tbody'))
-            result.append(self._close('table'))
-            result.append(self._close('div'))
-
-        return ''.join(result)
-
-    def table_row(self, on, attrs=None, **kw):
-        tag = 'tr'
-        if on:
-            if not attrs:
-                attrs = {}
-            else:
-                attrs = self._checkTableAttr(attrs, 'row')
-            return self._open(tag, newline=1, attr=attrs,
-                             allowed_attrs=self._allowed_table_attrs['row'],
-                             **kw)
-        return self._close(tag) + '\n'
-
-    def table_cell(self, on, attrs=None, **kw):
-        tag = 'td'
-        if on:
-            if not attrs:
-                attrs = {}
-            else:
-                attrs = self._checkTableAttr(attrs, '')
-            return '  ' + self._open(tag, attr=attrs,
-                             allowed_attrs=self._allowed_table_attrs[''],
-                             **kw)
-        return self._close(tag) + '\n'
-
-    def text(self, text, **kw):
-        txt = FormatterBase.text(self, text, **kw)
-        if kw:
-            return self._open('span', **kw) + txt + self._close('span')
-        return txt
-
-    def escapedText(self, text, **kw):
-        txt = wikiutil.escape(text)
-        if kw:
-            return self._open('span', **kw) + txt + self._close('span')
-        return txt
-
-    def rawHTML(self, markup):
-        return markup
-
-    def sysmsg(self, on, **kw):
-        tag = 'div'
-        if on:
-            return self._open(tag, attr={'class': 'message'}, **kw)
-        return self._close(tag)
-
-    def div(self, on, **kw):
-        css_class = kw.get('css_class')
-        # the display of comment class divs depends on a user setting:
-        if css_class and 'comment' in css_class.split():
-            style = kw.get('style')
-            display = self.request.user.show_comments and "display:''" or "display:none"
-            if not style:
-                style = display
-            else:
-                style += "; %s" % display
-            kw['style'] = style
-        tag = 'div'
-        if on:
-            return self._open(tag, **kw)
-        return self._close(tag)
-
-    def span(self, on, **kw):
-        css_class = kw.get('css_class')
-        # the display of comment class spans depends on a user setting:
-        if css_class and 'comment' in css_class.split():
-            style = kw.get('style')
-            display = self.request.user.show_comments and "display:''" or "display:none"
-            if not style:
-                style = display
-            else:
-                style += "; %s" % display
-            kw['style'] = style
-        tag = 'span'
-        if on:
-            return self._open(tag, **kw)
-        return self._close(tag)
-
-    def sanitize_to_id(self, text):
-        return wikiutil.anchor_name_from_text(text)
-
diff --git a/wiki-lenny/share/formatter.text_html.py b/wiki-lenny/share/formatter.text_html.py
deleted file mode 100644
index 8fe6c0aa..00000000
--- a/wiki-lenny/share/formatter.text_html.py
+++ /dev/null
@@ -1,1469 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - "text/html+css" Formatter
-
-    @copyright: 2000-2004 by Juergen Hermann <jh@web.de>
-    @license: GNU GPL, see COPYING for details.
-"""
-import os.path, re
-
-from MoinMoin import log
-logging = log.getLogger(__name__)
-
-from MoinMoin.formatter import FormatterBase
-from MoinMoin import wikiutil, i18n
-from MoinMoin.Page import Page
-from MoinMoin.action import AttachFile
-from MoinMoin.support.python_compatibility import set, rsplit
-### HACK SAUVAGE
-import urllib
-### FIN HACK
-
-
-# insert IDs into output wherever they occur
-# warning: breaks toggle line numbers javascript
-_id_debug = False
-
-line_anchors = True
-prettyprint = False
-
-# These are the HTML elements that we treat as block elements.
-_blocks = set(['dd', 'div', 'dl', 'dt', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
-               'hr', 'li', 'ol', 'p', 'pre', 'table', 'tbody', 'td', 'tfoot', 'th',
-               'thead', 'tr', 'ul', 'blockquote', ])
-
-# These are the HTML elements which are typically only used with
-# an opening tag without a separate closing tag.  We do not
-# include 'script' or 'style' because sometimes they do have
-# content, and also IE has a parsing bug with those two elements (only)
-# when they don't have a closing tag even if valid XHTML.
-
-_self_closing_tags = set(['area', 'base', 'br', 'col', 'frame', 'hr', 'img',
-                          'input', 'isindex', 'link', 'meta', 'param'])
-
-# We only open those tags and let the browser auto-close them:
-_auto_closing_tags = set(['p'])
-
-# These are the elements which generally should cause an increase in the
-# indention level in the html souce code.
-_indenting_tags = set(['ol', 'ul', 'dl', 'li', 'dt', 'dd', 'tr', 'td'])
-
-# These are the elements that discard any whitespace they contain as
-# immediate child nodes.
-_space_eating_tags = set(['colgroup', 'dl', 'frameset', 'head', 'map' 'menu',
-                          'ol', 'optgroup', 'select', 'table', 'tbody', 'tfoot',
-                          'thead', 'tr', 'ul'])
-
-# These are standard HTML attributes which are typically used without any
-# value; e.g., as boolean flags indicated by their presence.
-_html_attribute_boolflags = set(['compact', 'disabled', 'ismap', 'nohref',
-                                 'noresize', 'noshade', 'nowrap', 'readonly',
-                                 'selected', 'wrap'])
-
-# These are all the standard HTML attributes that are allowed on any element.
-_common_attributes = set(['accesskey', 'class', 'dir', 'disabled', 'id', 'lang',
-                          'style', 'tabindex', 'title'])
-
-
-def rewrite_attribute_name(name, default_namespace='html'):
-    """
-    Takes an attribute name and tries to make it HTML correct.
-
-    This function takes an attribute name as a string, as it may be
-    passed in to a formatting method using a keyword-argument syntax,
-    and tries to convert it into a real attribute name.  This is
-    necessary because some attributes may conflict with Python
-    reserved words or variable syntax (such as 'for', 'class', or
-    'z-index'); and also to help with backwards compatibility with
-    older versions of MoinMoin where different names may have been
-    used (such as 'content_id' or 'css').
-
-    Returns a tuple of strings: (namespace, attribute).
-
-    Namespaces: The default namespace is always assumed to be 'html',
-    unless the input string contains a colon or a double-underscore;
-    in which case the first such occurance is assumed to separate the
-    namespace prefix from name.  So, for example, to get the HTML
-    attribute 'for' (as on a <label> element), you can pass in the
-    string 'html__for' or even '__for'.
-
-    Hyphens:  To better support hyphens (which are not allowed in Python
-    variable names), all occurances of two underscores will be replaced
-    with a hyphen.  If you use this, then you must also provide a
-    namespace since the first occurance of '__' separates a namespace
-    from the name.
-
-    Special cases: Within the 'html' namespace, mainly to preserve
-    backwards compatibility, these exceptions ars recognized:
-    'content_type', 'content_id', 'css_class', and 'css'.
-    Additionally all html attributes starting with 'on' are forced to
-    lower-case.  Also the string 'xmlns' is recognized as having
-    no namespace.
-
-    Examples:
-        'id' -> ('html', 'id')
-        'css_class' -> ('html', 'class')
-        'content_id' -> ('html', 'id')
-        'content_type' -> ('html', 'type')
-        'html__for' -> ('html', 'for)
-        'xml__space' -> ('xml', 'space')
-        '__z__index' -> ('html', 'z-index')
-        '__http__equiv' -> ('html', 'http-equiv')
-        'onChange' -> ('html', 'onchange')
-        'xmlns' -> ('', 'xmlns')
-        'xmlns__abc' -> ('xmlns', 'abc')
-
-    (In actuality we only deal with namespace prefixes, not any real
-    namespace URI...we only care about the syntax not the meanings.)
-    """
-
-    # Handle any namespaces (just in case someday we support XHTML)
-    if ':' in name:
-        ns, name = name.split(':', 1)
-    elif '__' in name:
-        ns, name = name.split('__', 1)
-    elif name == 'xmlns':
-        ns = ''
-    else:
-        ns = default_namespace
-
-    name.replace('__', '-')
-    if ns == 'html':
-        # We have an HTML attribute, fix according to DTD
-        if name == 'content_type': # MIME type such as in <a> and <link> elements
-            name = 'type'
-        elif name == 'content_id': # moin historical convention
-            name = 'id'
-        elif name in ('css_class', 'css'): # to avoid python word 'class'
-            name = 'class'
-        elif name.startswith('on'): # event handler hook
-            name = name.lower()
-    return ns, name
-
-
-def extend_attribute_dictionary(attributedict, ns, name, value):
-    """Add a new attribute to an attribute dictionary, merging values where possible.
-
-    The attributedict must be a dictionary with tuple-keys of the form:
-    (namespace, attrname).
-
-    The given ns, name, and value will be added to the dictionary.  It
-    will replace the old value if it existed, except for a few special
-    cases where the values are logically merged instead (CSS class
-    names and style rules).
-
-    As a special case, if value is None (not just ''), then the
-    attribute is actually deleted from the dictionary.
-    """
-
-    key = ns, name
-    if value is None:
-        if key in attributedict:
-            del attributedict[key]
-    else:
-        if ns == 'html' and key in attributedict:
-            if name == 'class':
-                # CSS classes are appended by space-separated list
-                value = attributedict[key] + ' ' + value
-            elif name == 'style':
-                # CSS styles are appended by semicolon-separated rules list
-                value = attributedict[key] + '; ' + value
-            elif name in _html_attribute_boolflags:
-                # All attributes must have a value. According to XHTML those
-                # traditionally used as flags should have their value set to
-                # the same as the attribute name.
-                value = name
-        attributedict[key] = value
-
-
-class Formatter(FormatterBase):
-    """
-        Send HTML data.
-    """
-
-    hardspace = '&nbsp;'
-    indentspace = ' '
-
-    def __init__(self, request, **kw):
-        FormatterBase.__init__(self, request, **kw)
-        self._indent_level = 0
-
-        self._in_code = 0 # used by text_gedit
-        self._in_code_area = 0
-        self._in_code_line = 0
-        self._code_area_js = 0
-        self._code_area_state = ['', 0, -1, -1, 0]
-        self._show_section_numbers = None
-        self.pagelink_preclosed = False
-        self._is_included = kw.get('is_included', False)
-        self.request = request
-        self.cfg = request.cfg
-        self.no_magic = kw.get('no_magic', False) # disabled tag auto closing
-
-        if not hasattr(request, '_fmt_hd_counters'):
-            request._fmt_hd_counters = []
-
-    # Primitive formatter functions #####################################
-
-    # all other methods should use these to format tags. This keeps the
-    # code clean and handle pathological cases like unclosed p and
-    # inline tags.
-
-    def _langAttr(self, lang=None):
-        """ Return lang and dir attribute
-        (INTERNAL USE BY HTML FORMATTER ONLY!)
-
-        Must be used on all block elements - div, p, table, etc.
-        @param lang: if defined, will return attributes for lang. if not
-            defined, will return attributes only if the current lang is
-            different from the content lang.
-        @rtype: dict
-        @return: language attributes
-        """
-        if not lang:
-            lang = self.request.current_lang
-            # Actions that generate content in user language should change
-            # the content lang from the default defined in cfg.
-            if lang == self.request.content_lang:
-                # lang is inherited from content div
-                return {}
-
-        #attr = {'xml:lang': lang, 'lang': lang, 'dir': i18n.getDirection(lang),}
-        attr = {'lang': lang, 'dir': i18n.getDirection(lang), }
-        return attr
-
-    def _formatAttributes(self, attr=None, allowed_attrs=None, **kw):
-        """ Return HTML attributes formatted as a single string. (INTERNAL USE BY HTML FORMATTER ONLY!)
-
-        @param attr: dict containing keys and values
-        @param allowed_attrs: A list of allowable attribute names
-        @param kw: other arbitrary attributes expressed as keyword arguments.
-        @rtype: string
-        @return: formated attributes or empty string
-
-        The attributes and their values can either be given in the
-        'attr' dictionary, or as extra keyword arguments.  They are
-        both merged together.  See the function
-        rewrite_attribute_name() for special notes on how to name
-        attributes.
-
-        Setting a value to None rather than a string (or string
-        coercible) will remove that attribute from the list.
-
-        If the list of allowed_attrs is provided, then an error is
-        raised if an HTML attribute is encountered that is not in that
-        list (or is not a common attribute which is always allowed or
-        is not in another XML namespace using the double-underscore
-        syntax).
-        """
-
-        # Merge the attr dict and kw dict into a single attributes
-        # dictionary (rewriting any attribute names, extracting
-        # namespaces, and merging some values like css classes).
-        attributes = {} # dict of key=(namespace,name): value=attribute_value
-        if attr:
-            for a, v in attr.items():
-                a_ns, a_name = rewrite_attribute_name(a)
-                extend_attribute_dictionary(attributes, a_ns, a_name, v)
-        if kw:
-            for a, v in kw.items():
-                a_ns, a_name = rewrite_attribute_name(a)
-                extend_attribute_dictionary(attributes, a_ns, a_name, v)
-
-        # Add title attribute if missing, but it has an alt.
-        if ('html', 'alt') in attributes and ('html', 'title') not in attributes:
-            attributes[('html', 'title')] = attributes[('html', 'alt')]
-
-        # Force both lang and xml:lang to be present and identical if
-        # either exists.  The lang takes precedence over xml:lang if
-        # both exist.
-        #if ('html', 'lang') in attributes:
-        #    attributes[('xml', 'lang')] = attributes[('html', 'lang')]
-        #elif ('xml', 'lang') in attributes:
-        #    attributes[('html', 'lang')] = attributes[('xml', 'lang')]
-
-        # Check all the HTML attributes to see if they are known and
-        # allowed.  Ignore attributes if in non-HTML namespaces.
-        if allowed_attrs:
-            for name in [key[1] for key in attributes if key[0] == 'html']:
-                if name in _common_attributes or name in allowed_attrs:
-                    pass
-                elif name.startswith('on'):
-                    pass  # Too many event handlers to enumerate, just let them all pass.
-                else:
-                    # Unknown or unallowed attribute.
-                    err = 'Illegal HTML attribute "%s" passed to formatter' % name
-                    raise ValueError(err)
-
-        # Finally, format them all as a single string.
-        if attributes:
-            # Construct a formatted string containing all attributes
-            # with their values escaped.  Any html:* namespace
-            # attributes drop the namespace prefix.  We build this by
-            # separating the attributes into three categories:
-            #
-            #  * Those without any namespace (should only be xmlns attributes)
-            #  * Those in the HTML namespace (we drop the html: prefix for these)
-            #  * Those in any other non-HTML namespace, including xml:
-
-            xmlnslist = ['%s="%s"' % (k[1], wikiutil.escape(v, 1))
-                         for k, v in attributes.items() if not k[0]]
-            htmllist = ['%s="%s"' % (k[1], wikiutil.escape(v, 1))
-                        for k, v in attributes.items() if k[0] == 'html']
-            otherlist = ['%s:%s="%s"' % (k[0], k[1], wikiutil.escape(v, 1))
-                         for k, v in attributes.items() if k[0] and k[0] != 'html']
-
-            # Join all these lists together in a space-separated string.  Also
-            # prefix the whole thing with a space too.
-            htmllist.sort()
-            otherlist.sort()
-            all = [''] + xmlnslist + htmllist + otherlist
-            return ' '.join(all)
-        return ''
-
-    def _open(self, tag, newline=False, attr=None, allowed_attrs=None,
-              is_unique=False, **kw):
-        """ Open a tag with optional attributes (INTERNAL USE BY HTML FORMATTER ONLY!)
-
-        @param tag: html tag, string
-        @param newline: render tag so following data is on a separate line
-        @param attr: dict with tag attributes
-        @param allowed_attrs: list of allowed attributes for this element
-        @param is_unique: ID is already unique
-        @param kw: arbitrary attributes and values
-        @rtype: string ?
-        @return: open tag with attributes as a string
-        """
-        # If it is self-closing, then don't expect a closing tag later on.
-        is_self_closing = (tag in _self_closing_tags) and ' /' or ''
-
-        # make ID unique
-        id = None
-        if not is_unique:
-            if attr and 'id' in attr:
-                id = self.make_id_unique(attr['id'])
-                id = self.qualify_id(id)
-                attr['id'] = id
-            if 'id' in kw:
-                id = self.make_id_unique(kw['id'])
-                id = self.qualify_id(id)
-                kw['id'] = id
-        else:
-            if attr and 'id' in attr:
-                id = attr['id']
-            if 'id' in kw:
-                id = kw['id']
-
-        if tag in _blocks:
-            # Block elements
-            result = []
-
-            # Add language attributes, but let caller overide the default
-            attributes = self._langAttr()
-            if attr:
-                attributes.update(attr)
-
-            # Format
-            attributes = self._formatAttributes(attributes, allowed_attrs=allowed_attrs, **kw)
-            result.append('<%s%s%s>' % (tag, attributes, is_self_closing))
-            if newline:
-                result.append(self._newline())
-            if _id_debug and id:
-                result.append('(%s) ' % id)
-            tagstr = ''.join(result)
-        else:
-            # Inline elements
-            tagstr = '<%s%s%s>' % (tag,
-                                      self._formatAttributes(attr, allowed_attrs, **kw),
-                                      is_self_closing)
-        return tagstr
-
-    def _close(self, tag, newline=False):
-        """ Close tag (INTERNAL USE BY HTML FORMATTER ONLY!)
-
-        @param tag: html tag, string
-        @param newline: render tag so following data is on a separate line
-        @rtype: string
-        @return: closing tag as a string
-        """
-        if tag in _self_closing_tags or (tag in _auto_closing_tags and not self.no_magic):
-            # This tag was already closed
-            tagstr = ''
-        elif tag in _blocks:
-            # Block elements
-            result = []
-            if newline:
-                result.append(self._newline())
-            result.append('</%s>' % (tag))
-            tagstr = ''.join(result)
-        else:
-            # Inline elements
-            tagstr = '</%s>' % tag
-
-        if newline:
-            tagstr += self._newline()
-        return tagstr
-
-    # Public methods ###################################################
-
-    def startContent(self, content_id='content', newline=True, **kw):
-        """ Start page content div.
-
-        A link anchor is provided at the beginning of the div, with
-        an id of 'top' (modified by the request ID cache).
-        """
-
-        if hasattr(self, 'page'):
-            self.request.begin_include(self.page.page_name)
-
-        result = []
-        # Use the content language
-        attr = self._langAttr(self.request.content_lang)
-        attr['id'] = content_id
-        result.append(self._open('div', newline=False, attr=attr,
-                                 allowed_attrs=['align'], **kw))
-        result.append(self.anchordef('top'))
-        if newline:
-            result.append('\n')
-        return ''.join(result)
-
-    def endContent(self, newline=True):
-        """ Close page content div.
-
-        A link anchor is provided at the end of the div, with
-        an id of 'bottom' (modified by the request ID cache).
-        """
-
-        result = []
-        result.append(self.anchordef('bottom'))
-        result.append(self._close('div', newline=newline))
-        if hasattr(self, 'page'):
-            self.request.end_include()
-        return ''.join(result)
-
-    def lang(self, on, lang_name):
-        """ Insert text with specific lang and direction.
-
-            Enclose within span tag if lang_name is different from
-            the current lang
-        """
-        tag = 'span'
-        if lang_name != self.request.current_lang:
-            # Enclose text in span using lang attributes
-            if on:
-                attr = self._langAttr(lang=lang_name)
-                return self._open(tag, attr=attr)
-            return self._close(tag)
-
-        # Direction did not change, no need for span
-        return ''
-
-    # Links ##############################################################
-
-    def pagelink(self, on, pagename='', page=None, **kw):
-        """ Link to a page.
-
-            formatter.text_python will use an optimized call with a page!=None
-            parameter. DO NOT USE THIS YOURSELF OR IT WILL BREAK.
-
-            See wikiutil.link_tag() for possible keyword parameters.
-        """
-        FormatterBase.pagelink(self, on, pagename, page, **kw)
-        if 'generated' in kw:
-            del kw['generated']
-        if page is None:
-            page = Page(self.request, pagename, formatter=self)
-        if self.request.user.show_nonexist_qm and on and not page.exists():
-            self.pagelink_preclosed = True
-            return (page.link_to(self.request, on=1, **kw) +
-                    self.text("?") +
-                    page.link_to(self.request, on=0, **kw))
-        elif not on and self.pagelink_preclosed:
-            self.pagelink_preclosed = False
-            return ""
-        else:
-            return page.link_to(self.request, on=on, **kw)
-
-    def interwikilink(self, on, interwiki='', pagename='', **kw):
-        """
-        @keyword title: override using the interwiki wikiname as title
-        """
-        querystr = kw.get('querystr', {})
-        wikitag, wikiurl, wikitail, wikitag_bad = wikiutil.resolve_interwiki(self.request, interwiki, pagename)
-        wikiurl = wikiutil.mapURL(self.request, wikiurl)
-        if wikitag == 'Self': # for own wiki, do simple links
-            if '#' in wikitail:
-                wikitail, kw['anchor'] = rsplit(wikitail, '#', 1)
-            wikitail = wikiutil.url_unquote(wikitail)
-            try: # XXX this is the only place where we access self.page - do we need it? Crashes silently on actions!
-                pagename = wikiutil.AbsPageName(self.page.page_name, wikitail)
-            except:
-                pagename = wikitail
-            return self.pagelink(on, pagename, **kw)
-        else: # return InterWiki hyperlink
-            if on:
-                href = wikiutil.join_wiki(wikiurl, wikitail)
-                if querystr:
-                    separator = ('?', '&')['?' in href]
-                    href = '%s%s%s' % (href, separator, wikiutil.makeQueryString(querystr))
-                if wikitag_bad:
-                    html_class = 'badinterwiki'
-                else:
-                    html_class = 'interwiki'
-                title = kw.get('title', wikitag)
-                return self.url(1, href, title=title, css=html_class) # interwiki links with umlauts
-            else:
-                return self.url(0)
-
-    def url(self, on, url=None, css=None, do_escape=None, **kw):
-        """
-        Inserts an <a> element (you can give any A tag attributes as kw args).
-
-        @param on: 1 to start the link, 0 to end the link (no other arguments are needed when on==0).
-        @param url: the URL to link to; will go through Wiki URL mapping.
-        @param css: a space-separated list of CSS classes
-        @param do_escape: DEPRECATED and not used any more, please remove it from your code!
-                          We will remove this parameter in moin 1.8 (it used to filter url
-                          param through wikiutil.escape, but text_html formatter's _open
-                          will do it again, so this just leads to double escaping now).
-        """
-        if do_escape is not None:
-            if do_escape:
-                logging.warning("Deprecation warning: MoinMoin.formatter.text_html.url being called with do_escape=1/True parameter, please review caller.")
-            else:
-                logging.warning("Deprecation warning: MoinMoin.formatter.text_html.url being called with do_escape=0/False parameter, please remove it from the caller.")
-        if on:
-            attrs = self._langAttr()
-
-            # Handle the URL mapping
-            if url is None and 'href' in kw:
-                url = kw['href']
-                del kw['href']
-            if url is not None:
-                url = wikiutil.mapURL(self.request, url)
-                attrs['href'] = url
-
-            if css:
-                attrs['class'] = css
-
-            markup = self._open('a', attr=attrs, **kw)
-        else:
-            markup = self._close('a')
-        return markup
-
-    def anchordef(self, id):
-        """Inserts an invisible element used as a link target.
-
-        Inserts an empty <span> element with an id attribute, used as an anchor
-        for link references.  We use <span></span> rather than <span/>
-        for browser portability.
-        """
-        # Don't add newlines, \n, as it will break pre and
-        # line-numbered code sections (from line_achordef() method).
-        #return '<a id="%s"></a>' % (id, ) # do not use - this breaks PRE sections for IE
-        id = self.make_id_unique(id)
-        id = self.qualify_id(id)
-        return '<span class="anchor" id="%s"></span>' % id
-
-    def line_anchordef(self, lineno):
-        if line_anchors:
-            return self.anchordef("line-%d" % lineno)
-        else:
-            return ''
-
-    def anchorlink(self, on, name='', **kw):
-        """Insert an <a> link pointing to an anchor on the same page.
-
-        Call once with on=1 to start the link, and a second time with
-        on=0 to end it.  No other arguments are needed on the second
-        call.
-
-        The name argument should be the same as the id provided to the
-        anchordef() method, or some other elment.  It should NOT start
-        with '#' as that will be added automatically.
-
-        The id argument, if provided, is instead the id of this link
-        itself and not of the target element the link references.
-        """
-        attrs = self._langAttr()
-        if name:
-            name = self.sanitize_to_id(name)
-            attrs['href'] = '#' + self.qualify_id(name)
-        if 'href' in kw:
-            del kw['href']
-        if on:
-            str = self._open('a', attr=attrs, **kw)
-        else:
-            str = self._close('a')
-        return str
-
-    def line_anchorlink(self, on, lineno=0):
-        if line_anchors:
-            return self.anchorlink(on, name="line-%d" % lineno)
-        else:
-            return ''
-
-    # Attachments ######################################################
-
-    def attachment_link(self, on, url=None, **kw):
-        """ Link to an attachment.
-
-            @param on: 1/True=start link, 0/False=end link
-            @param url: filename.ext or PageName/filename.ext
-        """
-        assert on in (0, 1, False, True) # make sure we get called the new way, not like the 1.5 api was
-        _ = self.request.getText
-        querystr = kw.get('querystr', {})
-        assert isinstance(querystr, dict) # new in 1.6, only support dicts
-        if 'do' not in querystr:
-            querystr['do'] = 'view'
-        if on:
-            pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
-            #logging.debug("attachment_link: url %s pagename %s filename %s" % (url, pagename, filename))
-            fname = wikiutil.taintfilename(filename)
-            if AttachFile.exists(self.request, pagename, fname):
-                target = AttachFile.getAttachUrl(pagename, fname, self.request, do=querystr['do'])
-                title = "attachment:%s" % url
-                css = 'attachment'
-            else:
-                target = AttachFile.getAttachUrl(pagename, fname, self.request, upload=True)
-                title = _('Upload new attachment "%(filename)s"') % {'filename': fname}
-                css = 'attachment nonexistent'
-            return self.url(on, target, css=css, title=title)
-        else:
-            return self.url(on)
-
-    def attachment_image(self, url, **kw):
-        _ = self.request.getText
-        pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
-        fname = wikiutil.taintfilename(filename)
-        exists = AttachFile.exists(self.request, pagename, fname)
-        if exists:
-            kw['css'] = 'attachment'
-            kw['src'] = AttachFile.getAttachUrl(pagename, filename, self.request, addts=1)
-            title = _('Inlined image: %(url)s') % {'url': self.text(url)}
-            if not 'title' in kw:
-                kw['title'] = title
-            # alt is required for images:
-            if not 'alt' in kw:
-                kw['alt'] = kw['title']
-            return self.image(**kw)
-        else:
-            title = _('Upload new attachment "%(filename)s"') % {'filename': fname}
-            img = self.icon('attachimg')
-            css = 'nonexistent'
-            target = AttachFile.getAttachUrl(pagename, fname, self.request, upload=True)
-            return self.url(1, target, css=css, title=title) + img + self.url(0)
-
-    def attachment_drawing(self, url, text, **kw):
-        _ = self.request.getText
-        pagename, filename = AttachFile.absoluteName(url, self.page.page_name)
-        fname = wikiutil.taintfilename(filename)
-        drawing = fname
-        fname = fname + u".png"
-        filename = filename + u".png"
-        # fallback for old gif drawings (1.1 -> 1.2)
-        exists = AttachFile.exists(self.request, pagename, fname)
-        if not exists:
-            gfname = fname[:-4] + u".gif"
-            gfilename = filename[:-4] + u".gif"
-            exists = AttachFile.exists(self.request, pagename, gfname)
-            if exists:
-                fname, filename = gfname, gfilename
-
-        # check whether attachment exists, possibly point to upload form
-        drawing_url = AttachFile.getAttachUrl(pagename, fname, self.request, drawing=drawing, upload=True)
-        if not exists:
-            linktext = _('Create new drawing "%(filename)s (opens in new window)"')
-            return (self.url(1, drawing_url) +
-                    self.text(linktext % {'filename': fname}) +
-                    self.url(0))
-
-        mappath = AttachFile.getFilename(self.request, pagename, drawing + u'.map')
-
-        # check for map file
-        if os.path.exists(mappath):
-            # we have a image map. inline it and add a map ref to the img tag
-            try:
-                map = file(mappath, 'r').read()
-            except IOError:
-                pass
-            except OSError:
-                pass
-            else:
-                mapid = 'ImageMapOf' + drawing
-                # replace MAPNAME
-                map = map.replace('%MAPNAME%', mapid)
-                # add alt and title tags to areas
-                map = re.sub('href\s*=\s*"((?!%TWIKIDRAW%).+?)"', r'href="\1" alt="\1" title="\1"', map)
-                # add in edit links plus alt and title attributes
-                alt = title = _('Edit drawing %(filename)s (opens in new window)') % {'filename': self.text(fname)}
-                map = map.replace('%TWIKIDRAW%"', '%s" alt="%s" title="%s"' % (drawing_url, alt, title))
-                # unxml, because 4.01 concrete will not validate />
-                map = map.replace('/>', '>')
-                alt = title = _('Clickable drawing: %(filename)s') % {'filename': self.text(fname)}
-                src = AttachFile.getAttachUrl(pagename, filename, self.request, addts=1)
-                return (map + self.image(alt=alt, title=title, src=src, usemap='#'+mapid, css="drawing"))
-        else:
-            alt = title = _('Edit drawing %(filename)s (opens in new window)') % {'filename': self.text(fname)}
-            src = AttachFile.getAttachUrl(pagename, filename, self.request, addts=1)
-            return (self.url(1, drawing_url) +
-                    self.image(alt=alt, title=title, src=src, css="drawing") +
-                    self.url(0))
-
-
-    # Text ##############################################################
-
-    def _text(self, text):
-        text = wikiutil.escape(text)
-        if self._in_code:
-            text = text.replace(' ', self.hardspace)
-        return text
-
-    # Inline ###########################################################
-
-    def strong(self, on, **kw):
-        """Creates an HTML <strong> element.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'strong'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def emphasis(self, on, **kw):
-        """Creates an HTML <em> element.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'em'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def underline(self, on, **kw):
-        """Creates a text span for underlining (css class "u").
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'span'
-        if on:
-            return self._open(tag, attr={'class': 'u'}, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def highlight(self, on, **kw):
-        """Creates a text span for highlighting (css class "highlight").
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'strong'
-        if on:
-            return self._open(tag, attr={'class': 'highlight'}, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def sup(self, on, **kw):
-        """Creates a <sup> element for superscript text.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'sup'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def sub(self, on, **kw):
-        """Creates a <sub> element for subscript text.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'sub'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def strike(self, on, **kw):
-        """Creates a text span for line-through (strikeout) text (css class 'strike').
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        # This does not use <strike> because has been deprecated in standard HTML.
-        tag = 'span'
-        if on:
-            return self._open(tag, attr={'class': 'strike'},
-                              allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def code(self, on, **kw):
-        """Creates a <tt> element for inline code or monospaced text.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-
-        Any text within this section will have spaces converted to
-        non-break spaces.
-        """
-        tag = 'tt'
-        self._in_code = on
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def small(self, on, **kw):
-        """Creates a <small> element for smaller font.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'small'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-    def big(self, on, **kw):
-        """Creates a <big> element for larger font.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'big'
-        if on:
-            return self._open(tag, allowed_attrs=[], **kw)
-        return self._close(tag)
-
-
-    # Block elements ####################################################
-
-    def preformatted(self, on, **kw):
-        """Creates a preformatted text region, with a <pre> element.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        FormatterBase.preformatted(self, on)
-        tag = 'pre'
-        if on:
-            return self._open(tag, newline=1, **kw)
-        return self._close(tag)
-
-    # Use by code area
-    _toggleLineNumbersScript = """
-<script type="text/javascript">
-function isnumbered(obj) {
-  return obj.childNodes.length && obj.firstChild.childNodes.length && obj.firstChild.firstChild.className == 'LineNumber';
-}
-function nformat(num,chrs,add) {
-  var nlen = Math.max(0,chrs-(''+num).length), res = '';
-  while (nlen>0) { res += ' '; nlen-- }
-  return res+num+add;
-}
-function addnumber(did, nstart, nstep) {
-  var c = document.getElementById(did), l = c.firstChild, n = 1;
-  if (!isnumbered(c))
-    if (typeof nstart == 'undefined') nstart = 1;
-    if (typeof nstep  == 'undefined') nstep = 1;
-    n = nstart;
-    while (l != null) {
-      if (l.tagName == 'SPAN') {
-        var s = document.createElement('SPAN');
-        s.className = 'LineNumber'
-        s.appendChild(document.createTextNode(nformat(n,4,' ')));
-        n += nstep;
-        if (l.childNodes.length)
-          l.insertBefore(s, l.firstChild)
-        else
-          l.appendChild(s)
-      }
-      l = l.nextSibling;
-    }
-  return false;
-}
-function remnumber(did) {
-  var c = document.getElementById(did), l = c.firstChild;
-  if (isnumbered(c))
-    while (l != null) {
-      if (l.tagName == 'SPAN' && l.firstChild.className == 'LineNumber') l.removeChild(l.firstChild);
-      l = l.nextSibling;
-    }
-  return false;
-}
-function togglenumber(did, nstart, nstep) {
-  var c = document.getElementById(did);
-  if (isnumbered(c)) {
-    remnumber(did);
-  } else {
-    addnumber(did,nstart,nstep);
-  }
-  return false;
-}
-</script>
-"""
-
-    def code_area(self, on, code_id, code_type='code', show=0, start=-1, step=-1):
-        """Creates a formatted code region, with line numbering.
-
-        This region is formatted as a <div> with a <pre> inside it.  The
-        code_id argument is assigned to the 'id' of the div element, and
-        must be unique within the document.  The show, start, and step are
-        used for line numbering.
-
-        Note this is not like most formatter methods, it can not take any
-        extra keyword arguments.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        _ = self.request.getText
-        res = []
-        if on:
-            code_id = self.sanitize_to_id('CA-%s' % code_id)
-            ci = self.qualify_id(self.make_id_unique(code_id))
-
-            # Open a code area
-            self._in_code_area = 1
-            self._in_code_line = 0
-            # id in here no longer used
-            self._code_area_state = [None, show, start, step, start]
-
-            # Open the code div - using left to right always!
-            attr = {'class': 'codearea', 'lang': 'en', 'dir': 'ltr'}
-            res.append(self._open('div', attr=attr))
-
-            # Add the script only in the first code area on the page
-            if self._code_area_js == 0 and self._code_area_state[1] >= 0:
-                res.append(self._toggleLineNumbersScript)
-                self._code_area_js = 1
-
-            # Add line number link, but only for JavaScript enabled browsers.
-            if self._code_area_state[1] >= 0:
-                toggleLineNumbersLink = r'''
-<script type="text/javascript">
-document.write('<a href="#" onclick="return togglenumber(\'%s\', %d, %d);" \
-                class="codenumbers">%s<\/a>');
-</script>
-''' % (ci, self._code_area_state[2], self._code_area_state[3],
-       _("Toggle line numbers"))
-                res.append(toggleLineNumbersLink)
-
-            # Open pre - using left to right always!
-            attr = {'id': ci, 'lang': 'en', 'dir': 'ltr'}
-            res.append(self._open('pre', newline=True, attr=attr, is_unique=True))
-        else:
-            # Close code area
-            res = []
-            if self._in_code_line:
-                res.append(self.code_line(0))
-            res.append(self._close('pre'))
-            res.append(self._close('div'))
-
-            # Update state
-            self._in_code_area = 0
-
-        return ''.join(res)
-
-    def code_line(self, on):
-        res = ''
-        if not on or (on and self._in_code_line):
-            res += '</span>\n'
-        if on:
-            res += '<span class="line">'
-            if self._code_area_state[1] > 0:
-                res += '<span class="LineNumber">%4d </span>' % (self._code_area_state[4], )
-                self._code_area_state[4] += self._code_area_state[3]
-        self._in_code_line = on != 0
-        return res
-
-    def code_token(self, on, tok_type):
-        return ['<span class="%s">' % tok_type, '</span>'][not on]
-
-
-    #### HACK SAUVAGE 1/1 ####
-    def crans_box(self, title, body_html, color=None):
-        if color==None: css_color_class=u""
-        else: css_color_class = u" %s_box" % color
-        html = [
-                    '<div class="sidebox%s">' % css_color_class,
-                    '<div class="boxhead">',
-                    self.heading(1,3),
-                    title,
-                    self.heading(0,3),
-                    '</div>',
-                    '<div class="boxbody1">',
-                    '<div class="boxbody2">',
-                    body_html,
-                    '</div>',
-                    '</div>',
-                    '</div>',
-                ]
-        return('\n'.join(html))
-
-    def crans_portal(self, entries):
-        html = [ '\n\n<div class="portal" style="padding: 0 0 2em 0;">' ]
-
-        format_pe = '''
-  <div style="background:transparent url('%s') center left no-repeat;
-              width: 38%%; height: 5em; padding: 1.5em 20px 0 60px; float:left;">
-    <ul style="list-style: none;">
-      <li>%s</li>
-      <li>%s</li>
-    </ul>
-  </div>'''
-
-        format_pne = '''
-  <div style="width: 38%%; height: 5em; padding: 10px 20px 0 0px; float:left;">
-    <div style="float: left; padding-top: 1.5em; width: 20%%;">
-      <a href="%s" style="font-size: 5pt" alt="envoyer l'image">envoyer<br>%s</a>
-    </div>
-    <div style="float: left; width: 75%%; padding: 0; margin: 0;">
-      <ul style="list-style: none;">
-        <li>%s</li>
-        <li>%s</li>
-      </ul>
-    </div>
-  </div>'''
-
-        pn = self.page.page_name
-
-        while len(entries) != 0:
-            pic0, tit0, bod0 = entries[0]
-
-            fname = urllib.url2pathname(pic0)
-            if AttachFile.exists(self.request, pn, fname):
-                pic0 = AttachFile.getAttachUrl(pn, pic0, self.request)
-                pic0 = pic0.replace('& ','&amp;')
-                html += [ format_pe % (pic0, tit0, bod0) ]
-            else:
-                pic0 = AttachFile.getAttachUrl(pn, pic0, self.request, upload=True)
-                pic0 = pic0.replace('& ','&amp;')
-                html += [ format_pne % (pic0, fname, tit0, bod0) ]
-
-            if len(entries) >= 2:
-                pic1, tit1, bod1 = entries[1]
-                entries = entries[2:]
-
-                fname = urllib.url2pathname(pic1)
-                if AttachFile.exists(self.request, self.page.page_name, fname):
-                    pic1 = AttachFile.getAttachUrl(pn, pic1, self.request)
-#                    pic1 = pic1.replace('& ','&amp;')
-                    html += [ format_pe % (pic1, tit1, bod1) ]
-                else:
-                    pic1 = AttachFile.getAttachUrl(pn, pic1, self.request, upload=True)
-#                    pic1 = pic.replace('& ','&amp;')
-                    html += [ format_pne % (pic1, fname, tit1, bod1) ]
-
-            else:
-                entries = [] # plus propre que {{{ break() }}}
-
-        html += [ '\n</div>\n<hr style="visibility:hidden">\n\n' ]
-        return('\n'.join(html))
-    #### FIN HACK 1/1 ####
-
-    # Paragraphs, Lines, Rules ###########################################
-
-    def _indent_spaces(self):
-        """Returns space(s) for indenting the html source so list nesting is easy to read.
-
-        Note that this mostly works, but because of caching may not always be accurate."""
-        if prettyprint:
-            return self.indentspace * self._indent_level
-        else:
-            return ''
-
-    def _newline(self):
-        """Returns the whitespace for starting a new html source line, properly indented."""
-        if prettyprint:
-            return '\n' + self._indent_spaces()
-        else:
-            return ''
-
-    def linebreak(self, preformatted=1):
-        """Creates a line break in the HTML output.
-
-        If preformatted is true a <br> element is inserted, otherwise
-        the linebreak will only be visible in the HTML source.
-        """
-        if self._in_code_area:
-            preformatted = 1
-        return ['\n', '<br>\n'][not preformatted] + self._indent_spaces()
-
-    def paragraph(self, on, **kw):
-        """Creates a paragraph with a <p> element.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        if self._terse:
-            return ''
-        FormatterBase.paragraph(self, on)
-        tag = 'p'
-        if on:
-            tagstr = self._open(tag, **kw)
-        else:
-            tagstr = self._close(tag)
-        return tagstr
-
-    def rule(self, size=None, **kw):
-        """Creates a horizontal rule with an <hr> element.
-
-        If size is a number in the range [1..6], the CSS class of the rule
-        is set to 'hr1' through 'hr6'.  The intent is that the larger the
-        size number the thicker or bolder the rule will be.
-        """
-        if size and 1 <= size <= 6:
-            # Add hr class: hr1 - hr6
-            return self._open('hr', newline=1, attr={'class': 'hr%d' % size}, **kw)
-        return self._open('hr', newline=1, **kw)
-
-    # Images / Transclusion ##############################################
-
-    def icon(self, type):
-        return self.request.theme.make_icon(type)
-
-    smiley = icon
-
-    def image(self, src=None, **kw):
-        """Creates an inline image with an <img> element.
-
-        The src argument must be the URL to the image file.
-        """
-        if src:
-            kw['src'] = src
-        return self._open('img', **kw)
-
-    def transclusion(self, on, **kw):
-        """Transcludes (includes/embeds) another object."""
-        if on:
-            return self._open('object',
-                              allowed_attrs=['archive', 'classid', 'codebase',
-                                             'codetype', 'data', 'declare',
-                                             'height', 'name', 'standby',
-                                             'type', 'width', ],
-                              **kw)
-        else:
-            return self._close('object')
-
-    def transclusion_param(self, **kw):
-        """Give a parameter to a transcluded object."""
-        return self._open('param',
-                          allowed_attrs=['name', 'type', 'value', 'valuetype', ],
-                          **kw)
-
-    # Lists ##############################################################
-
-    def number_list(self, on, type=None, start=None, **kw):
-        """Creates an HTML ordered list, <ol> element.
-
-        The 'type' if specified can be any legal numbered
-        list-style-type, such as 'decimal','lower-roman', etc.
-
-        The 'start' argument if specified gives the numeric value of
-        the first list item (default is 1).
-
-        Call once with on=1 to start the list, and a second time
-        with on=0 to end it.
-        """
-        tag = 'ol'
-        if on:
-            attr = {}
-            if type is not None:
-                attr['type'] = type
-            if start is not None:
-                attr['start'] = start
-            tagstr = self._open(tag, newline=1, attr=attr, **kw)
-        else:
-            tagstr = self._close(tag, newline=1)
-        return tagstr
-
-    def bullet_list(self, on, **kw):
-        """Creates an HTML ordered list, <ul> element.
-
-        The 'type' if specified can be any legal unnumbered
-        list-style-type, such as 'disc','square', etc.
-
-        Call once with on=1 to start the list, and a second time
-        with on=0 to end it.
-        """
-        tag = 'ul'
-        if on:
-            tagstr = self._open(tag, newline=1, **kw)
-        else:
-            tagstr = self._close(tag, newline=1)
-        return tagstr
-
-    def listitem(self, on, **kw):
-        """Adds a list item, <li> element, to a previously opened
-        bullet or number list.
-
-        Call once with on=1 to start the region, and a second time
-        with on=0 to end it.
-        """
-        tag = 'li'
-        if on:
-            tagstr = self._open(tag, newline=1, **kw)
-        else:
-            tagstr = self._close(tag, newline=1)
-        return tagstr
-
-    def definition_list(self, on, **kw):
-        """Creates an HTML definition list, <dl> element.
-
-        Call once with on=1 to start the list, and a second time
-        with on=0 to end it.
-        """
-        tag = 'dl'
-        if on:
-            tagstr = self._open(tag, newline=1, **kw)
-        else:
-            tagstr = self._close(tag, newline=1)
-        return tagstr
-
-    def definition_term(self, on, **kw):
-        """Adds a new term to a definition list, HTML element <dt>.
-
-        Call once with on=1 to start the term, and a second time
-        with on=0 to end it.
-        """
-        tag = 'dt'
-        if on:
-            tagstr = self._open(tag, newline=1, **kw)
-        else:
-            tagstr = self._close(tag, newline=0)
-        return tagstr
-
-    def definition_desc(self, on, **kw):
-        """Gives the definition to a definition item, HTML element <dd>.
-
-        Call once with on=1 to start the definition, and a second time
-        with on=0 to end it.
-        """
-        tag = 'dd'
-        if on:
-            tagstr = self._open(tag, newline=1, **kw)
-        else:
-            tagstr = self._close(tag, newline=0)
-        return tagstr
-
-    def heading(self, on, depth, **kw):
-        # remember depth of first heading, and adapt counting depth accordingly
-        if not self._base_depth:
-            self._base_depth = depth
-
-        count_depth = max(depth - (self._base_depth - 1), 1)
-
-        # check numbering, possibly changing the default
-        if self._show_section_numbers is None:
-            self._show_section_numbers = self.cfg.show_section_numbers
-            numbering = self.request.getPragma('section-numbers', '').lower()
-            if numbering in ['0', 'off']:
-                self._show_section_numbers = 0
-            elif numbering in ['1', 'on']:
-                self._show_section_numbers = 1
-            elif numbering in ['2', '3', '4', '5', '6']:
-                # explicit base level for section number display
-                self._show_section_numbers = int(numbering)
-
-        heading_depth = depth
-
-        # closing tag, with empty line after, to make source more readable
-        if not on:
-            return self._close('h%d' % heading_depth) + '\n'
-
-        # create section number
-        number = ''
-        if self._show_section_numbers:
-            # count headings on all levels
-            self.request._fmt_hd_counters = self.request._fmt_hd_counters[:count_depth]
-            while len(self.request._fmt_hd_counters) < count_depth:
-                self.request._fmt_hd_counters.append(0)
-            self.request._fmt_hd_counters[-1] = self.request._fmt_hd_counters[-1] + 1
-            number = '.'.join([str(x) for x in self.request._fmt_hd_counters[self._show_section_numbers-1:]])
-            if number: number += ". "
-
-        # Add space before heading, easier to check source code
-        result = '\n' + self._open('h%d' % heading_depth, **kw)
-
-        if self.request.user.show_topbottom:
-            result += "%s%s%s%s%s%s" % (
-                       self.anchorlink(1, "bottom"), self.icon('bottom'), self.anchorlink(0),
-                       self.anchorlink(1, "top"), self.icon('top'), self.anchorlink(0))
-
-        return "%s%s" % (result, number)
-
-
-    # Tables #############################################################
-
-    _allowed_table_attrs = {
-        'table': ['class', 'id', 'style'],
-        'row': ['class', 'id', 'style'],
-        '': ['colspan', 'rowspan', 'class', 'id', 'style', 'abbr'],
-    }
-
-    def _checkTableAttr(self, attrs, prefix):
-        """ Check table attributes
-
-        Convert from wikitable attributes to html 4 attributes.
-
-        @param attrs: attribute dict
-        @param prefix: used in wiki table attributes
-        @rtype: dict
-        @return: valid table attributes
-        """
-        if not attrs:
-            return {}
-
-        result = {}
-        s = [] # we collect synthesized style in s
-        for key, val in attrs.items():
-            # Ignore keys that don't start with prefix
-            if prefix and key[:len(prefix)] != prefix:
-                continue
-            key = key[len(prefix):]
-            val = val.strip('"')
-            # remove invalid attrs from dict and synthesize style
-            if key == 'width':
-                s.append("width: %s" % val)
-            elif key == 'height':
-                s.append("height: %s" % val)
-            elif key == 'bgcolor':
-                s.append("background-color: %s" % val)
-            elif key == 'align':
-                s.append("text-align: %s" % val)
-            elif key == 'valign':
-                s.append("vertical-align: %s" % val)
-            # Ignore unknown keys
-            if key not in self._allowed_table_attrs[prefix]:
-                continue
-            result[key] = val
-        st = result.get('style', '').split(';')
-        st = '; '.join(st + s)
-        st = st.strip(';')
-        st = st.strip()
-        if not st:
-            try:
-                del result['style'] # avoid empty style attr
-            except:
-                pass
-        else:
-            result['style'] = st
-        #logging.debug("_checkTableAttr returns %r" % result)
-        return result
-
-
-    def table(self, on, attrs=None, **kw):
-        """ Create table
-
-        @param on: start table
-        @param attrs: table attributes
-        @rtype: string
-        @return start or end tag of a table
-        """
-        result = []
-        if on:
-            # Open div to get correct alignment with table width smaller
-            # than 100%
-            result.append(self._open('div', newline=1))
-
-            # Open table
-            if not attrs:
-                attrs = {}
-            else:
-                attrs = self._checkTableAttr(attrs, 'table')
-            result.append(self._open('table', newline=1, attr=attrs,
-                                     allowed_attrs=self._allowed_table_attrs['table'],
-                                     **kw))
-            result.append(self._open('tbody', newline=1))
-        else:
-            # Close tbody, table, and then div
-            result.append(self._close('tbody'))
-            result.append(self._close('table'))
-            result.append(self._close('div'))
-
-        return ''.join(result)
-
-    def table_row(self, on, attrs=None, **kw):
-        tag = 'tr'
-        if on:
-            if not attrs:
-                attrs = {}
-            else:
-                attrs = self._checkTableAttr(attrs, 'row')
-            return self._open(tag, newline=1, attr=attrs,
-                             allowed_attrs=self._allowed_table_attrs['row'],
-                             **kw)
-        return self._close(tag) + '\n'
-
-    def table_cell(self, on, attrs=None, **kw):
-        tag = 'td'
-        if on:
-            if not attrs:
-                attrs = {}
-            else:
-                attrs = self._checkTableAttr(attrs, '')
-            return '  ' + self._open(tag, attr=attrs,
-                             allowed_attrs=self._allowed_table_attrs[''],
-                             **kw)
-        return self._close(tag) + '\n'
-
-    def text(self, text, **kw):
-        txt = FormatterBase.text(self, text, **kw)
-        if kw:
-            return self._open('span', **kw) + txt + self._close('span')
-        return txt
-
-    def escapedText(self, text, **kw):
-        txt = wikiutil.escape(text)
-        if kw:
-            return self._open('span', **kw) + txt + self._close('span')
-        return txt
-
-    def rawHTML(self, markup):
-        return markup
-
-    def sysmsg(self, on, **kw):
-        tag = 'div'
-        if on:
-            return self._open(tag, attr={'class': 'message'}, **kw)
-        return self._close(tag)
-
-    def div(self, on, **kw):
-        css_class = kw.get('css_class')
-        # the display of comment class divs depends on a user setting:
-        if css_class and 'comment' in css_class.split():
-            style = kw.get('style')
-            display = self.request.user.show_comments and "display:''" or "display:none"
-            if not style:
-                style = display
-            else:
-                style += "; %s" % display
-            kw['style'] = style
-        tag = 'div'
-        if on:
-            return self._open(tag, **kw)
-        return self._close(tag)
-
-    def span(self, on, **kw):
-        css_class = kw.get('css_class')
-        # the display of comment class spans depends on a user setting:
-        if css_class and 'comment' in css_class.split():
-            style = kw.get('style')
-            display = self.request.user.show_comments and "display:''" or "display:none"
-            if not style:
-                style = display
-            else:
-                style += "; %s" % display
-            kw['style'] = style
-        tag = 'span'
-        if on:
-            return self._open(tag, **kw)
-        return self._close(tag)
-
-    def sanitize_to_id(self, text):
-        return wikiutil.anchor_name_from_text(text)
-
diff --git a/wiki-lenny/share/request.__init__.orig.py b/wiki-lenny/share/request.__init__.orig.py
deleted file mode 100644
index bcaf90a5..00000000
--- a/wiki-lenny/share/request.__init__.orig.py
+++ /dev/null
@@ -1,1680 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - RequestBase Implementation
-
-    @copyright: 2001-2003 Juergen Hermann <jh@web.de>,
-                2003-2008 MoinMoin:ThomasWaldmann
-    @license: GNU GPL, see COPYING for details.
-"""
-
-# Support for remote IP address detection when using (reverse) proxy (or even proxies).
-# If you exactly KNOW which (reverse) proxies you can trust, put them into the list
-# below, so we can determine the "outside" IP as your trusted proxies see it.
-
-proxies_trusted = [] # trust noone!
-#proxies_trusted = ['127.0.0.1', ] # can be a list of multiple IPs
-
-from MoinMoin import log
-logging = log.getLogger(__name__)
-
-def find_remote_addr(addrs):
-    """ Find the last remote IP address before it hits our reverse proxies.
-        The LAST address in the <addrs> list is the remote IP as detected by the server
-        (not taken from some x-forwarded-for header).
-        The FIRST address in the <addrs> list might be the client's IP - if noone cheats
-        and everyone supports x-f-f header.
-
-        See http://bob.pythonmac.org/archives/2005/09/23/apache-x-forwarded-for-caveat/
-
-        For debug loglevel, we log all <addrs>.
-
-        TODO: refactor request code to first do some basic IP init, then load configuration,
-        TODO: then do proxy processing.
-        TODO: add wikiconfig configurability for proxies_trusted
-        TODO: later, make it possible to put multipe remote IP addrs into edit-log
-    """
-    logging.debug("request.find_remote_addr: addrs == %r" % addrs)
-    if proxies_trusted:
-        result = [addr for addr in addrs if addr not in proxies_trusted]
-        if result:
-            return result[-1] # last IP before it hit our trusted (reverse) proxies
-    return addrs[-1] # this is a safe remote_addr, not taken from x-f-f header
-
-
-import os, re, time, sys, cgi, StringIO
-import Cookie
-import traceback
-
-from MoinMoin.Page import Page
-from MoinMoin import config, wikiutil, user, caching, error
-from MoinMoin.config import multiconfig
-from MoinMoin.support.python_compatibility import set
-from MoinMoin.util import IsWin9x
-from MoinMoin.util.clock import Clock
-from MoinMoin import auth
-from urllib import quote, quote_plus
-
-# umask setting --------------------------------------------------------
-def set_umask(new_mask=0777^config.umask):
-    """ Set the OS umask value (and ignore potential failures on OSes where
-        this is not supported).
-        Default: the bitwise inverted value of config.umask
-    """
-    try:
-        old_mask = os.umask(new_mask)
-    except:
-        # maybe we are on win32?
-        pass
-
-# We do this at least once per Python process, when request is imported.
-# If other software parts (like twistd's daemonize() function) set an
-# unwanted umask, we have to call this again to set the correct one:
-set_umask()
-
-# Exceptions -----------------------------------------------------------
-
-class MoinMoinFinish(Exception):
-    """ Raised to jump directly to end of run() function, where finish is called """
-
-
-class HeadersAlreadySentException(Exception):
-    """ Is raised if the headers were already sent when emit_http_headers is called."""
-
-
-class RemoteClosedConnection(Exception):
-    """ Remote end closed connection during request """
-
-# Utilities
-
-def cgiMetaVariable(header, scheme='http'):
-    """ Return CGI meta variable for header name
-
-    e.g 'User-Agent' -> 'HTTP_USER_AGENT'
-    See http://www.faqs.org/rfcs/rfc3875.html section 4.1.18
-    """
-    var = '%s_%s' % (scheme, header)
-    return var.upper().replace('-', '_')
-
-
-# Request Base ----------------------------------------------------------
-
-class RequestBase(object):
-    """ A collection for all data associated with ONE request. """
-
-    # Defaults (used by sub classes)
-    http_accept_language = 'en'
-    server_name = 'localhost'
-    server_port = '80'
-
-    # Extra headers we support. Both standalone and twisted store
-    # headers as lowercase.
-    moin_location = 'x-moin-location'
-    proxy_host = 'x-forwarded-host' # original host: header as seen by the proxy (e.g. wiki.example.org)
-    proxy_xff = 'x-forwarded-for' # list of original remote_addrs as seen by the proxies (e.g. <clientip>,<proxy1>,<proxy2>,...)
-
-    def __init__(self, properties={}):
-
-        # twistd's daemonize() overrides our umask, so we reset it here every
-        # request. we do it for all request types to avoid similar problems.
-        set_umask()
-
-        self._finishers = []
-
-        self._auth_redirected = False
-
-        # Decode values collected by sub classes
-        self.path_info = self.decodePagename(self.path_info)
-
-        self.failed = 0
-        self._available_actions = None
-        self._known_actions = None
-
-        # Pages meta data that we collect in one request
-        self.pages = {}
-
-        self.sent_headers = None
-        self.user_headers = []
-        self.cacheable = 0 # may this output get cached by http proxies/caches?
-        self.http_caching_disabled = 0 # see disableHttpCaching()
-        self.page = None
-        self._dicts = None
-
-        # session handling. users cannot rely on a session being
-        # created, but we should always set request.session
-        self.session = {}
-
-        # setuid handling requires an attribute in the request
-        # that stores the real user
-        self._setuid_real_user = None
-
-        # Check for dumb proxy requests
-        # TODO relying on request_uri will not work on all servers, especially
-        # not on external non-Apache servers
-        self.forbidden = False
-        if self.request_uri.startswith('http://'):
-            self.makeForbidden403()
-
-        # Init
-        else:
-            self.writestack = []
-            self.clock = Clock()
-            self.clock.start('total')
-            self.clock.start('base__init__')
-            # order is important here!
-            self.__dict__.update(properties)
-            try:
-                self._load_multi_cfg()
-            except error.NoConfigMatchedError:
-                self.makeForbidden(404, 'No wiki configuration matching the URL found!\r\n')
-                return
-
-            self.isSpiderAgent = self.check_spider()
-
-            # Set decode charsets.  Input from the user is always in
-            # config.charset, which is the page charsets. Except
-            # path_info, which may use utf-8, and handled by decodePagename.
-            self.decode_charsets = [config.charset]
-
-            if self.query_string.startswith('action=xmlrpc'):
-                self.args = {}
-                self.form = {}
-                self.action = 'xmlrpc'
-                self.rev = None
-            else:
-                try:
-                    self.args = self.form = self.setup_args()
-                except UnicodeError:
-                    self.makeForbidden(403, "The input you sent could not be understood.")
-                    return
-                self.action = self.form.get('action', ['show'])[0]
-                try:
-                    self.rev = int(self.form['rev'][0])
-                except:
-                    self.rev = None
-
-            from MoinMoin.Page import RootPage
-            self.rootpage = RootPage(self)
-
-            from MoinMoin.logfile import editlog
-            self.editlog = editlog.EditLog(self)
-
-            from MoinMoin import i18n
-            self.i18n = i18n
-            i18n.i18n_init(self)
-
-            # authentication might require translated forms, so
-            # have a try at guessing the language from the browser
-            lang = i18n.requestLanguage(self, try_user=False)
-            self.getText = lambda text, i18n=self.i18n, request=self, lang=lang, **kw: i18n.getText(text, request, lang, **kw)
-
-            # session handler start, auth
-            self.parse_cookie()
-            user_obj = self.cfg.session_handler.start(self, self.cfg.session_id_handler)
-            shfinisher = lambda request: self.cfg.session_handler.finish(request, request.user,
-                                                                         self.cfg.session_id_handler)
-            self.add_finisher(shfinisher)
-            # set self.user even if _handle_auth_form raises an Exception
-            self.user = None
-            self.user = self._handle_auth_form(user_obj)
-            del user_obj
-            self.cfg.session_handler.after_auth(self, self.cfg.session_id_handler, self.user)
-            if not self.user:
-                self.user = user.User(self, auth_method='request:invalid')
-
-            # setuid handling, check isSuperUser() because the user
-            # might have lost the permission between requests
-            if 'setuid' in self.session and self.user.isSuperUser():
-                self._setuid_real_user = self.user
-                uid = self.session['setuid']
-                self.user = user.User(self, uid, auth_method='setuid')
-                # set valid to True so superusers can even switch
-                # to disable accounts
-                self.user.valid = True
-
-            if self.action != 'xmlrpc':
-                if not self.forbidden and self.isForbidden():
-                    self.makeForbidden403()
-                if not self.forbidden and self.surge_protect():
-                    self.makeUnavailable503()
-
-            self.pragma = {}
-            self.mode_getpagelinks = 0 # is > 0 as long as we are in a getPageLinks call
-            self.parsePageLinks_running = {} # avoid infinite recursion by remembering what we are already running
-
-            self.lang = i18n.requestLanguage(self)
-            # Language for content. Page content should use the wiki default lang,
-            # but generated content like search results should use the user language.
-            self.content_lang = self.cfg.language_default
-            self.getText = lambda text, i18n=self.i18n, request=self, lang=self.lang, **kv: i18n.getText(text, request, lang, **kv)
-
-            self.reset()
-
-            from MoinMoin.formatter.text_html import Formatter
-            self.html_formatter = Formatter(self)
-            self.formatter = self.html_formatter
-
-            self.clock.stop('base__init__')
-
-    def surge_protect(self, kick_him=False):
-        """ check if someone requesting too much from us,
-            if kick_him is True, we unconditionally blacklist the current user/ip
-        """
-        limits = self.cfg.surge_action_limits
-        if not limits:
-            return False
-
-        if self.remote_addr.startswith('127.'): # localnet
-            return False
-
-        validuser = self.user.valid
-        current_id = validuser and self.user.name or self.remote_addr
-        current_action = self.action
-
-        default_limit = limits.get('default', (30, 60))
-
-        now = int(time.time())
-        surgedict = {}
-        surge_detected = False
-
-        try:
-            # if we have common farm users, we could also use scope='farm':
-            cache = caching.CacheEntry(self, 'surgeprotect', 'surge-log', scope='wiki', use_encode=True)
-            if cache.exists():
-                data = cache.content()
-                data = data.split("\n")
-                for line in data:
-                    try:
-                        id, t, action, surge_indicator = line.split("\t")
-                        t = int(t)
-                        maxnum, dt = limits.get(action, default_limit)
-                        if t >= now - dt:
-                            events = surgedict.setdefault(id, {})
-                            timestamps = events.setdefault(action, [])
-                            timestamps.append((t, surge_indicator))
-                    except StandardError:
-                        pass
-
-            maxnum, dt = limits.get(current_action, default_limit)
-            events = surgedict.setdefault(current_id, {})
-            timestamps = events.setdefault(current_action, [])
-            surge_detected = len(timestamps) > maxnum
-
-            surge_indicator = surge_detected and "!" or ""
-            timestamps.append((now, surge_indicator))
-            if surge_detected:
-                if len(timestamps) < maxnum * 2:
-                    timestamps.append((now + self.cfg.surge_lockout_time, surge_indicator)) # continue like that and get locked out
-
-            if current_action not in ('cache', 'AttachFile', ): # don't add cache/AttachFile accesses to all or picture galleries will trigger SP
-                current_action = 'all' # put a total limit on user's requests
-                maxnum, dt = limits.get(current_action, default_limit)
-                events = surgedict.setdefault(current_id, {})
-                timestamps = events.setdefault(current_action, [])
-
-                if kick_him: # ban this guy, NOW
-                    timestamps.extend([(now + self.cfg.surge_lockout_time, "!")] * (2 * maxnum))
-
-                surge_detected = surge_detected or len(timestamps) > maxnum
-
-                surge_indicator = surge_detected and "!" or ""
-                timestamps.append((now, surge_indicator))
-                if surge_detected:
-                    if len(timestamps) < maxnum * 2:
-                        timestamps.append((now + self.cfg.surge_lockout_time, surge_indicator)) # continue like that and get locked out
-
-            data = []
-            for id, events in surgedict.items():
-                for action, timestamps in events.items():
-                    for t, surge_indicator in timestamps:
-                        data.append("%s\t%d\t%s\t%s" % (id, t, action, surge_indicator))
-            data = "\n".join(data)
-            cache.update(data)
-        except StandardError:
-            pass
-
-        if surge_detected and validuser and self.user.auth_method in self.cfg.auth_methods_trusted:
-            logging.info("Trusted user %s would have triggered surge protection if not trusted." % self.user.name)
-            return False  # do not subject trusted users to surge protection
-
-        return surge_detected
-
-    def getDicts(self):
-        """ Lazy initialize the dicts on the first access """
-        if self._dicts is None:
-            from MoinMoin import wikidicts
-            dicts = wikidicts.GroupDict(self)
-            dicts.load_dicts()
-            self._dicts = dicts
-        return self._dicts
-
-    def delDicts(self):
-        """ Delete the dicts, used by some tests """
-        del self._dicts
-        self._dicts = None
-
-    dicts = property(getDicts, None, delDicts)
-
-    def _load_multi_cfg(self):
-        # protect against calling multiple times
-        if not hasattr(self, 'cfg'):
-            self.clock.start('load_multi_cfg')
-            self.cfg = multiconfig.getConfig(self.url)
-            self.clock.stop('load_multi_cfg')
-
-    def setAcceptedCharsets(self, accept_charset):
-        """ Set accepted_charsets by parsing accept-charset header
-
-        Set self.accepted_charsets to an ordered list based on http_accept_charset.
-
-        Reference: http://www.w3.org/Protocols/rfc2616/rfc2616.txt
-
-        TODO: currently no code use this value.
-
-        @param accept_charset: accept-charset header
-        """
-        charsets = []
-        if accept_charset:
-            accept_charset = accept_charset.lower()
-            # Add iso-8859-1 if needed
-            if (not '*' in accept_charset and
-                'iso-8859-1' not in accept_charset):
-                accept_charset += ',iso-8859-1'
-
-            # Make a list, sorted by quality value, using Schwartzian Transform
-            # Create list of tuples (value, name) , sort, extract names
-            for item in accept_charset.split(','):
-                if ';' in item:
-                    name, qval = item.split(';')
-                    qval = 1.0 - float(qval.split('=')[1])
-                else:
-                    name, qval = item, 0
-                charsets.append((qval, name))
-            charsets.sort()
-            # Remove *, its not clear what we should do with it later
-            charsets = [name for qval, name in charsets if name != '*']
-
-        self.accepted_charsets = charsets
-
-    def _setup_vars_from_std_env(self, env):
-        """ Set common request variables from CGI environment
-
-        Parse a standard CGI environment as created by common web servers.
-        Reference: http://www.faqs.org/rfcs/rfc3875.html
-
-        @param env: dict like object containing cgi meta variables
-        """
-        # Values we can just copy
-        self.env = env
-        self.http_accept_language = env.get('HTTP_ACCEPT_LANGUAGE', self.http_accept_language)
-        self.server_name = env.get('SERVER_NAME', self.server_name)
-        self.server_port = env.get('SERVER_PORT', self.server_port)
-        self.saved_cookie = env.get('HTTP_COOKIE', '')
-        self.script_name = env.get('SCRIPT_NAME', '')
-        self.path_info = env.get('PATH_INFO', '')
-        self.query_string = env.get('QUERY_STRING', '')
-        self.request_method = env.get('REQUEST_METHOD', None)
-        self.remote_addr = env.get('REMOTE_ADDR', '')
-        self.http_user_agent = env.get('HTTP_USER_AGENT', '')
-        try:
-            self.content_length = int(env.get('CONTENT_LENGTH'))
-        except (TypeError, ValueError):
-            self.content_length = None
-        self.if_modified_since = env.get('If-modified-since') or env.get(cgiMetaVariable('If-modified-since'))
-        self.if_none_match = env.get('If-none-match') or env.get(cgiMetaVariable('If-none-match'))
-
-        # REQUEST_URI is not part of CGI spec, but an addition of Apache.
-        self.request_uri = env.get('REQUEST_URI', '')
-
-        # Values that need more work
-        self.setHttpReferer(env.get('HTTP_REFERER'))
-        self.setIsSSL(env)
-        self.setHost(env.get('HTTP_HOST'))
-        self.fixURI(env)
-
-        self.setURL(env)
-        #self.debugEnvironment(env)
-
-    def setHttpReferer(self, referer):
-        """ Set http_referer, making sure its ascii
-
-        IE might send non-ascii value.
-        """
-        value = ''
-        if referer:
-            value = unicode(referer, 'ascii', 'replace')
-            value = value.encode('ascii', 'replace')
-        self.http_referer = value
-
-    def setIsSSL(self, env):
-        """ Set is_ssl
-
-        @param env: dict like object containing cgi meta variables
-        """
-        self.is_ssl = bool(env.get('SSL_PROTOCOL') or
-                           env.get('SSL_PROTOCOL_VERSION') or
-                           env.get('HTTPS') == 'on')
-
-    def setHost(self, host=None):
-        """ Set http_host
-
-        Create from server name and port if missing. Previous code
-        default to localhost.
-        """
-        if not host:
-            port = ''
-            standardPort = ('80', '443')[self.is_ssl]
-            if self.server_port != standardPort:
-                port = ':' + self.server_port
-            host = self.server_name + port
-        self.http_host = host
-
-    def fixURI(self, env):
-        """ Fix problems with script_name and path_info
-
-        Handle the strange charset semantics on Windows and other non
-        posix systems. path_info is transformed into the system code
-        page by the web server. Additionally, paths containing dots let
-        most webservers choke.
-
-        Broken environment variables in different environments:
-                path_info script_name
-        Apache1     X          X      PI does not contain dots
-        Apache2     X          X      PI is not encoded correctly
-        IIS         X          X      path_info include script_name
-        Other       ?          -      ? := Possible and even RFC-compatible.
-                                      - := Hopefully not.
-
-        @param env: dict like object containing cgi meta variables
-        """
-        # Fix the script_name when using Apache on Windows.
-        server_software = env.get('SERVER_SOFTWARE', '')
-        if os.name == 'nt' and 'Apache/' in server_software:
-            # Removes elements ending in '.' from the path.
-            self.script_name = '/'.join([x for x in self.script_name.split('/')
-                                         if not x.endswith('.')])
-
-        # Fix path_info
-        if os.name != 'posix' and self.request_uri != '':
-            # Try to recreate path_info from request_uri.
-            import urlparse
-            scriptAndPath = urlparse.urlparse(self.request_uri)[2]
-            path = scriptAndPath.replace(self.script_name, '', 1)
-            self.path_info = wikiutil.url_unquote(path, want_unicode=False)
-        elif os.name == 'nt':
-            # Recode path_info to utf-8
-            path = wikiutil.decodeWindowsPath(self.path_info)
-            self.path_info = path.encode("utf-8")
-
-            # Fix bug in IIS/4.0 when path_info contain script_name
-            if self.path_info.startswith(self.script_name):
-                self.path_info = self.path_info[len(self.script_name):]
-
-    def setURL(self, env):
-        """ Set url, used to locate wiki config
-
-        This is the place to manipulate url parts as needed.
-
-        @param env: dict like object containing cgi meta variables or http headers.
-        """
-        # proxy support
-        self.rewriteRemoteAddr(env)
-        self.rewriteHost(env)
-
-        self.rewriteURI(env)
-
-        if not self.request_uri:
-            self.request_uri = self.makeURI()
-        self.url = self.http_host + self.request_uri
-
-    def rewriteHost(self, env):
-        """ Rewrite http_host transparently
-
-        Get the proxy host using 'X-Forwarded-Host' header, added by
-        Apache 2 and other proxy software.
-
-        TODO: Will not work for Apache 1 or others that don't add this header.
-
-        TODO: If we want to add an option to disable this feature it
-        should be in the server script, because the config is not
-        loaded at this point, and must be loaded after url is set.
-
-        @param env: dict like object containing cgi meta variables or http headers.
-        """
-        proxy_host = (env.get(self.proxy_host) or
-                      env.get(cgiMetaVariable(self.proxy_host)))
-        if proxy_host:
-            self.http_host = proxy_host
-
-    def rewriteRemoteAddr(self, env):
-        """ Rewrite remote_addr transparently
-
-        Get the proxy remote addr using 'X-Forwarded-For' header, added by
-        Apache 2 and other proxy software.
-
-        TODO: Will not work for Apache 1 or others that don't add this header.
-
-        TODO: If we want to add an option to disable this feature it
-        should be in the server script, because the config is not
-        loaded at this point, and must be loaded after url is set.
-
-        @param env: dict like object containing cgi meta variables or http headers.
-        """
-        xff = (env.get(self.proxy_xff) or
-               env.get(cgiMetaVariable(self.proxy_xff)))
-        if xff:
-            xff = [addr.strip() for addr in xff.split(',')]
-            xff.append(self.remote_addr)
-            self.remote_addr = find_remote_addr(xff)
-
-    def rewriteURI(self, env):
-        """ Rewrite request_uri, script_name and path_info transparently
-
-        Useful when running mod python or when running behind a proxy,
-        e.g run on localhost:8000/ and serve as example.com/wiki/.
-
-        Uses private 'X-Moin-Location' header to set the script name.
-        This allow setting the script name when using Apache 2
-        <location> directive::
-
-            <Location /my/wiki/>
-                RequestHeader set X-Moin-Location /my/wiki/
-            </location>
-
-        TODO: does not work for Apache 1 and others that do not allow
-        setting custom headers per request.
-
-        @param env: dict like object containing cgi meta variables or http headers.
-        """
-        location = (env.get(self.moin_location) or
-                    env.get(cgiMetaVariable(self.moin_location)))
-        if location is None:
-            return
-
-        scriptAndPath = self.script_name + self.path_info
-        location = location.rstrip('/')
-        self.script_name = location
-
-        # This may happen when using mod_python
-        if scriptAndPath.startswith(location):
-            self.path_info = scriptAndPath[len(location):]
-
-        # Recreate the URI from the modified parts
-        if self.request_uri:
-            self.request_uri = self.makeURI()
-
-    def makeURI(self):
-        """ Return uri created from uri parts """
-        uri = self.script_name + wikiutil.url_quote(self.path_info)
-        if self.query_string:
-            uri += '?' + self.query_string
-        return uri
-
-    def splitURI(self, uri):
-        """ Return path and query splited from uri
-
-        Just like CGI environment, the path is unquoted, the query is not.
-        """
-        if '?' in uri:
-            path, query = uri.split('?', 1)
-        else:
-            path, query = uri, ''
-        return wikiutil.url_unquote(path, want_unicode=False), query
-
-    def _handle_auth_form(self, user_obj):
-        username = self.form.get('name', [None])[0]
-        password = self.form.get('password', [None])[0]
-        oid = self.form.get('openid_identifier', [None])[0]
-        login = 'login' in self.form
-        logout = 'logout' in self.form
-        stage = self.form.get('stage', [None])[0]
-        return self.handle_auth(user_obj, attended=True, username=username,
-                                password=password, login=login, logout=logout,
-                                stage=stage, openid_identifier=oid)
-
-    def handle_auth(self, user_obj, attended=False, **kw):
-        username = kw.get('username')
-        password = kw.get('password')
-        oid = kw.get('openid_identifier')
-        login = kw.get('login')
-        logout = kw.get('logout')
-        stage = kw.get('stage')
-        extra = {
-            'cookie': self.cookie,
-        }
-        if login:
-            extra['attended'] = attended
-            extra['username'] = username
-            extra['password'] = password
-            extra['openid_identifier'] = oid
-            if stage:
-                extra['multistage'] = True
-        login_msgs = []
-        self._login_multistage = None
-
-        if logout and 'setuid' in self.session:
-            del self.session['setuid']
-            return user_obj
-
-        for authmethod in self.cfg.auth:
-            if logout:
-                user_obj, cont = authmethod.logout(self, user_obj, **extra)
-            elif login:
-                if stage and authmethod.name != stage:
-                    continue
-                ret = authmethod.login(self, user_obj, **extra)
-                user_obj = ret.user_obj
-                cont = ret.continue_flag
-                if stage:
-                    stage = None
-                    del extra['multistage']
-                if ret.multistage:
-                    self._login_multistage = ret.multistage
-                    self._login_multistage_name = authmethod.name
-                    return user_obj
-                if ret.redirect_to:
-                    nextstage = auth.get_multistage_continuation_url(self, authmethod.name)
-                    url = ret.redirect_to
-                    url = url.replace('%return_form', quote_plus(nextstage))
-                    url = url.replace('%return', quote(nextstage))
-                    self._auth_redirected = True
-                    self.http_redirect(url)
-                    return user_obj
-                msg = ret.message
-                if msg and not msg in login_msgs:
-                    login_msgs.append(msg)
-            else:
-                user_obj, cont = authmethod.request(self, user_obj, **extra)
-            if not cont:
-                break
-
-        self._login_messages = login_msgs
-        return user_obj
-
-    def handle_jid_auth(self, jid):
-        return user.get_by_jabber_id(self, jid)
-
-    def parse_cookie(self):
-        try:
-            self.cookie = Cookie.SimpleCookie(self.saved_cookie)
-        except Cookie.CookieError:
-            self.cookie = None
-
-    def reset(self):
-        """ Reset request state.
-
-        Called after saving a page, before serving the updated
-        page. Solves some practical problems with request state
-        modified during saving.
-
-        """
-        # This is the content language and has nothing to do with
-        # The user interface language. The content language can change
-        # during the rendering of a page by lang macros
-        self.current_lang = self.cfg.language_default
-
-        # caches unique ids
-        self.init_unique_ids()
-
-        if hasattr(self, "_fmt_hd_counters"):
-            del self._fmt_hd_counters
-
-    def loadTheme(self, theme_name):
-        """ Load the Theme to use for this request.
-
-        @param theme_name: the name of the theme
-        @type theme_name: str
-        @rtype: int
-        @return: success code
-                 0 on success
-                 1 if user theme could not be loaded,
-                 2 if a hard fallback to modern theme was required.
-        """
-        fallback = 0
-        if theme_name == "<default>":
-            theme_name = self.cfg.theme_default
-
-        try:
-            Theme = wikiutil.importPlugin(self.cfg, 'theme', theme_name, 'Theme')
-        except wikiutil.PluginMissingError:
-            fallback = 1
-            try:
-                Theme = wikiutil.importPlugin(self.cfg, 'theme', self.cfg.theme_default, 'Theme')
-            except wikiutil.PluginMissingError:
-                fallback = 2
-                from MoinMoin.theme.modern import Theme
-
-        self.theme = Theme(self)
-        return fallback
-
-    def setContentLanguage(self, lang):
-        """ Set the content language, used for the content div
-
-        Actions that generate content in the user language, like search,
-        should set the content direction to the user language before they
-        call send_title!
-        """
-        self.content_lang = lang
-        self.current_lang = lang
-
-    def getPragma(self, key, defval=None):
-        """ Query a pragma value (#pragma processing instruction)
-
-            Keys are not case-sensitive.
-        """
-        return self.pragma.get(key.lower(), defval)
-
-    def setPragma(self, key, value):
-        """ Set a pragma value (#pragma processing instruction)
-
-            Keys are not case-sensitive.
-        """
-        self.pragma[key.lower()] = value
-
-    def getPathinfo(self):
-        """ Return the remaining part of the URL. """
-        return self.path_info
-
-    def getScriptname(self):
-        """ Return the scriptname part of the URL ('/path/to/my.cgi'). """
-        if self.script_name == '/':
-            return ''
-        return self.script_name
-
-    def getKnownActions(self):
-        """ Create a dict of avaiable actions
-
-        Return cached version if avaiable.
-
-        @rtype: dict
-        @return: dict of all known actions
-        """
-        try:
-            self.cfg.cache.known_actions # check
-        except AttributeError:
-            from MoinMoin import action
-            self.cfg.cache.known_actions = set(action.getNames(self.cfg))
-
-        # Return a copy, so clients will not change the set.
-        return self.cfg.cache.known_actions.copy()
-
-    def getAvailableActions(self, page):
-        """ Get list of avaiable actions for this request
-
-        The dict does not contain actions that starts with lower case.
-        Themes use this dict to display the actions to the user.
-
-        @param page: current page, Page object
-        @rtype: dict
-        @return: dict of avaiable actions
-        """
-        if self._available_actions is None:
-            # some actions might make sense for non-existing pages, so we just
-            # require read access here. Can be later refined to some action
-            # specific check:
-            if not self.user.may.read(page.page_name):
-                return []
-
-            # Filter non ui actions (starts with lower case letter)
-            actions = self.getKnownActions()
-            actions = [action for action in actions if not action[0].islower()]
-
-            # Filter wiki excluded actions
-            actions = [action for action in actions if not action in self.cfg.actions_excluded]
-
-            # Filter actions by page type, acl and user state
-            excluded = []
-            if ((page.isUnderlayPage() and not page.isStandardPage()) or
-                not self.user.may.write(page.page_name) or
-                not self.user.may.delete(page.page_name)):
-                # Prevent modification of underlay only pages, or pages
-                # the user can't write and can't delete
-                excluded = [u'RenamePage', u'DeletePage', ] # AttachFile must NOT be here!
-            actions = [action for action in actions if not action in excluded]
-
-            self._available_actions = set(actions)
-
-        # Return a copy, so clients will not change the dict.
-        return self._available_actions.copy()
-
-    def redirectedOutput(self, function, *args, **kw):
-        """ Redirect output during function, return redirected output """
-        buf = StringIO.StringIO()
-        self.redirect(buf)
-        try:
-            function(*args, **kw)
-        finally:
-            self.redirect()
-        text = buf.getvalue()
-        buf.close()
-        return text
-
-    def redirect(self, file=None):
-        """ Redirect output to file, or restore saved output """
-        if file:
-            self.writestack.append(self.write)
-            self.write = file.write
-        else:
-            self.write = self.writestack.pop()
-
-    def log(self, msg):
-        """ DEPRECATED - Log msg to logging framework
-            Please call logging.info(...) directly!
-        """
-        msg = msg.strip()
-        # Encode unicode msg
-        if isinstance(msg, unicode):
-            msg = msg.encode(config.charset)
-        logging.info(msg)
-
-    def timing_log(self, start, action):
-        """ Log to timing log (for performance analysis) """
-        indicator = ''
-        if start:
-            total = "vvv"
-        else:
-            self.clock.stop('total') # make sure it is stopped
-            total_secs = self.clock.timings['total']
-            # we add some stuff that is easy to grep when searching for peformance problems:
-            if total_secs > 50:
-                indicator += '!4!'
-            elif total_secs > 20:
-                indicator += '!3!'
-            elif total_secs > 10:
-                indicator += '!2!'
-            elif total_secs > 2:
-                indicator += '!1!'
-            total = self.clock.value('total')
-            # use + for existing pages, - for non-existing pages
-            if self.page is not None:
-                indicator += self.page.exists() and '+' or '-'
-            if self.isSpiderAgent:
-                indicator += "B"
-
-        pid = os.getpid()
-        msg = 'Timing %5d %-6s %4s %-10s %s\n' % (pid, total, indicator, action, self.url)
-        logging.info(msg)
-
-    def send_file(self, fileobj, bufsize=8192, do_flush=False):
-        """ Send a file to the output stream.
-
-        @param fileobj: a file-like object (supporting read, close)
-        @param bufsize: size of chunks to read/write
-        @param do_flush: call flush after writing?
-        """
-        while True:
-            buf = fileobj.read(bufsize)
-            if not buf:
-                break
-            self.write(buf)
-            if do_flush:
-                self.flush()
-
-    def write(self, *data):
-        """ Write to output stream. """
-        raise NotImplementedError
-
-    def encode(self, data):
-        """ encode data (can be both unicode strings and strings),
-            preparing for a single write()
-        """
-        wd = []
-        for d in data:
-            try:
-                if isinstance(d, unicode):
-                    # if we are REALLY sure, we can use "strict"
-                    d = d.encode(config.charset, 'replace')
-                elif d is None:
-                    continue
-                wd.append(d)
-            except UnicodeError:
-                logging.error("Unicode error on: %s" % repr(d))
-        return ''.join(wd)
-
-    def decodePagename(self, name):
-        """ Decode path, possibly using non ascii characters
-
-        Does not change the name, only decode to Unicode.
-
-        First split the path to pages, then decode each one. This enables
-        us to decode one page using config.charset and another using
-        utf-8. This situation happens when you try to add to a name of
-        an existing page.
-
-        See http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.2.1
-
-        @param name: page name, string
-        @rtype: unicode
-        @return decoded page name
-        """
-        # Split to pages and decode each one
-        pages = name.split('/')
-        decoded = []
-        for page in pages:
-            # Recode from utf-8 into config charset. If the path
-            # contains user typed parts, they are encoded using 'utf-8'.
-            if config.charset != 'utf-8':
-                try:
-                    page = unicode(page, 'utf-8', 'strict')
-                    # Fit data into config.charset, replacing what won't
-                    # fit. Better have few "?" in the name than crash.
-                    page = page.encode(config.charset, 'replace')
-                except UnicodeError:
-                    pass
-
-            # Decode from config.charset, replacing what can't be decoded.
-            page = unicode(page, config.charset, 'replace')
-            decoded.append(page)
-
-        # Assemble decoded parts
-        name = u'/'.join(decoded)
-        return name
-
-    def normalizePagename(self, name):
-        """ Normalize page name
-
-        Prevent creating page names with invisible characters or funny
-        whitespace that might confuse the users or abuse the wiki, or
-        just does not make sense.
-
-        Restrict even more group pages, so they can be used inside acl lines.
-
-        @param name: page name, unicode
-        @rtype: unicode
-        @return: decoded and sanitized page name
-        """
-        # Strip invalid characters
-        name = config.page_invalid_chars_regex.sub(u'', name)
-
-        # Split to pages and normalize each one
-        pages = name.split(u'/')
-        normalized = []
-        for page in pages:
-            # Ignore empty or whitespace only pages
-            if not page or page.isspace():
-                continue
-
-            # Cleanup group pages.
-            # Strip non alpha numeric characters, keep white space
-            if wikiutil.isGroupPage(self, page):
-                page = u''.join([c for c in page
-                                 if c.isalnum() or c.isspace()])
-
-            # Normalize white space. Each name can contain multiple
-            # words separated with only one space. Split handle all
-            # 30 unicode spaces (isspace() == True)
-            page = u' '.join(page.split())
-
-            normalized.append(page)
-
-        # Assemble components into full pagename
-        name = u'/'.join(normalized)
-        return name
-
-    def read(self, n):
-        """ Read n bytes from input stream. """
-        raise NotImplementedError
-
-    def flush(self):
-        """ Flush output stream. """
-        pass
-
-    def check_spider(self):
-        """ check if the user agent for current request is a spider/bot """
-        isSpider = False
-        ua = self.getUserAgent()
-        if ua and self.cfg.cache.ua_spiders:
-            isSpider = self.cfg.cache.ua_spiders.search(ua) is not None
-        return isSpider
-
-    def isForbidden(self):
-        """ check for web spiders and refuse anything except viewing """
-        forbidden = 0
-        # we do not have a parsed query string here, so we can just do simple matching
-        qs = self.query_string
-        action = self.action
-        if ((qs != '' or self.request_method != 'GET') and
-            action != 'rss_rc' and
-            # allow spiders to get attachments and do 'show'
-            not (action == 'AttachFile' and 'do=get' in qs) and
-            action != 'show' and
-            action != 'sitemap'
-            ):
-            forbidden = self.isSpiderAgent
-
-        if not forbidden and self.cfg.hosts_deny:
-            ip = self.remote_addr
-            for host in self.cfg.hosts_deny:
-                if host[-1] == '.' and ip.startswith(host):
-                    forbidden = 1
-                    logging.debug("hosts_deny (net): %s" % str(forbidden))
-                    break
-                if ip == host:
-                    forbidden = 1
-                    logging.debug("hosts_deny (ip): %s" % str(forbidden))
-                    break
-        return forbidden
-
-    def setup_args(self):
-        """ Return args dict
-        First, we parse the query string (usually this is used in GET methods,
-        but TwikiDraw uses ?action=AttachFile&do=savedrawing plus posted stuff).
-        Second, we update what we got in first step by the stuff we get from
-        the form (or by a POST). We invoke _setup_args_from_cgi_form to handle
-        possible file uploads.
-        """
-        args = cgi.parse_qs(self.query_string, keep_blank_values=1)
-        args = self.decodeArgs(args)
-        # if we have form data (in a POST), those override the stuff we already have:
-        if self.request_method == 'POST':
-            postargs = self._setup_args_from_cgi_form()
-            args.update(postargs)
-        return args
-
-    def _setup_args_from_cgi_form(self, form=None):
-        """ Return args dict from a FieldStorage
-
-        Create the args from a given form. Each key contain a list of values.
-        This method usually gets overridden in classes derived from this - it
-        is their task to call this method with an appropriate form parameter.
-
-        @param form: a cgi.FieldStorage
-        @rtype: dict
-        @return: dict with form keys, each contains a list of values
-        """
-        args = {}
-        for key in form:
-            values = form[key]
-            if not isinstance(values, list):
-                values = [values]
-            fixedResult = []
-            for item in values:
-                if isinstance(item, cgi.FieldStorage) and item.filename:
-                    fixedResult.append(item.file) # open data tempfile
-                    # Save upload file name in a separate key
-                    args[key + '__filename__'] = item.filename
-                else:
-                    fixedResult.append(item.value)
-            args[key] = fixedResult
-
-        return self.decodeArgs(args)
-
-    def decodeArgs(self, args):
-        """ Decode args dict
-
-        Decoding is done in a separate path because it is reused by
-        other methods and sub classes.
-        """
-        decode = wikiutil.decodeUserInput
-        result = {}
-        for key in args:
-            if key + '__filename__' in args:
-                # Copy file data as is
-                result[key] = args[key]
-            elif key.endswith('__filename__'):
-                result[key] = decode(args[key], self.decode_charsets)
-            else:
-                result[key] = [decode(value, self.decode_charsets) for value in args[key]]
-        return result
-
-    def getBaseURL(self):
-        """ Return a fully qualified URL to this script. """
-        return self.getQualifiedURL(self.getScriptname())
-
-    def getQualifiedURL(self, uri=''):
-        """ Return an absolute URL starting with schema and host.
-
-        Already qualified urls are returned unchanged.
-
-        @param uri: server rooted uri e.g /scriptname/pagename.
-                    It must start with a slash. Must be ascii and url encoded.
-        """
-        import urlparse
-        scheme = urlparse.urlparse(uri)[0]
-        if scheme:
-            return uri
-
-        scheme = ('http', 'https')[self.is_ssl]
-        result = "%s://%s%s" % (scheme, self.http_host, uri)
-
-        # This might break qualified urls in redirects!
-        # e.g. mapping 'http://netloc' -> '/'
-        return wikiutil.mapURL(self, result)
-
-    def getUserAgent(self):
-        """ Get the user agent. """
-        return self.http_user_agent
-
-    def makeForbidden(self, resultcode, msg):
-        statusmsg = {
-            401: 'Authorization required',
-            403: 'FORBIDDEN',
-            404: 'Not found',
-            503: 'Service unavailable',
-        }
-        headers = [
-            'Status: %d %s' % (resultcode, statusmsg[resultcode]),
-            'Content-Type: text/plain; charset=utf-8'
-        ]
-        # when surge protection triggered, tell bots to come back later...
-        if resultcode == 503:
-            headers.append('Retry-After: %d' % self.cfg.surge_lockout_time)
-        self.emit_http_headers(headers)
-        self.write(msg)
-        self.forbidden = True
-
-    def makeForbidden403(self):
-        self.makeForbidden(403, 'You are not allowed to access this!\r\n')
-
-    def makeUnavailable503(self):
-        self.makeForbidden(503, "Warning:\r\n"
-                   "You triggered the wiki's surge protection by doing too many requests in a short time.\r\n"
-                   "Please make a short break reading the stuff you already got.\r\n"
-                   "When you restart doing requests AFTER that, slow down or you might get locked out for a longer time!\r\n")
-
-    def initTheme(self):
-        """ Set theme - forced theme, user theme or wiki default """
-        if self.cfg.theme_force:
-            theme_name = self.cfg.theme_default
-        else:
-            theme_name = self.user.theme_name
-        self.loadTheme(theme_name)
-
-    def _try_redirect_spaces_page(self, pagename):
-        if '_' in pagename and not self.page.exists():
-            pname = pagename.replace('_', ' ')
-            pg = Page(self, pname)
-            if pg.exists():
-                url = pg.url(self)
-                self.http_redirect(url)
-                return True
-        return False
-
-    def run(self):
-        # Exit now if __init__ failed or request is forbidden
-        if self.failed or self.forbidden or self._auth_redirected:
-            # Don't sleep() here, it binds too much of our resources!
-            return self.finish()
-
-        _ = self.getText
-        self.clock.start('run')
-
-        self.initTheme()
-
-        action_name = self.action
-        if self.cfg.log_timing:
-            self.timing_log(True, action_name)
-
-        if action_name == 'xmlrpc':
-            from MoinMoin import xmlrpc
-            if self.query_string == 'action=xmlrpc':
-                xmlrpc.xmlrpc(self)
-            elif self.query_string == 'action=xmlrpc2':
-                xmlrpc.xmlrpc2(self)
-            if self.cfg.log_timing:
-                self.timing_log(False, action_name)
-            return self.finish()
-
-        # parse request data
-        try:
-            # The last component in path_info is the page name, if any
-            path = self.getPathinfo()
-
-            # we can have all action URLs like this: /action/ActionName/PageName?action=ActionName&...
-            # this is just for robots.txt being able to forbid them for crawlers
-            prefix = self.cfg.url_prefix_action
-            if prefix is not None:
-                prefix = '/%s/' % prefix # e.g. '/action/'
-                if path.startswith(prefix):
-                    # remove prefix and action name
-                    path = path[len(prefix):]
-                    action, path = (path.split('/', 1) + ['', ''])[:2]
-                    path = '/' + path
-
-            if path.startswith('/'):
-                pagename = self.normalizePagename(path)
-            else:
-                pagename = None
-
-            # need to inform caches that content changes based on:
-            # * cookie (even if we aren't sending one now)
-            # * User-Agent (because a bot might be denied and get no content)
-            # * Accept-Language (except if moin is told to ignore browser language)
-            if self.cfg.language_ignore_browser:
-                self.setHttpHeader("Vary: Cookie,User-Agent")
-            else:
-                self.setHttpHeader("Vary: Cookie,User-Agent,Accept-Language")
-
-            # Handle request. We have these options:
-            # 1. jump to page where user left off
-            if not pagename and self.user.remember_last_visit and action_name == 'show':
-                pagetrail = self.user.getTrail()
-                if pagetrail:
-                    # Redirect to last page visited
-                    last_visited = pagetrail[-1]
-                    wikiname, pagename = wikiutil.split_interwiki(last_visited)
-                    if wikiname != 'Self':
-                        wikitag, wikiurl, wikitail, error = wikiutil.resolve_interwiki(self, wikiname, pagename)
-                        url = wikiurl + wikiutil.quoteWikinameURL(wikitail)
-                    else:
-                        url = Page(self, pagename).url(self)
-                else:
-                    # Or to localized FrontPage
-                    url = wikiutil.getFrontPage(self).url(self)
-                self.http_redirect(url)
-                return self.finish()
-
-            # 2. handle action
-            else:
-                # pagename could be empty after normalization e.g. '///' -> ''
-                # Use localized FrontPage if pagename is empty
-                if not pagename:
-                    self.page = wikiutil.getFrontPage(self)
-                else:
-                    self.page = Page(self, pagename)
-                    if self._try_redirect_spaces_page(pagename):
-                        return self.finish()
-
-                msg = None
-                # Complain about unknown actions
-                if not action_name in self.getKnownActions():
-                    msg = _("Unknown action %(action_name)s.") % {
-                            'action_name': wikiutil.escape(action_name), }
-
-                # Disallow non available actions
-                elif action_name[0].isupper() and not action_name in self.getAvailableActions(self.page):
-                    msg = _("You are not allowed to do %(action_name)s on this page.") % {
-                            'action_name': wikiutil.escape(action_name), }
-                    if not self.user.valid:
-                        # Suggest non valid user to login
-                        msg += " " + _("Login and try again.")
-
-                if msg:
-                    self.theme.add_msg(msg, "error")
-                    self.page.send_page()
-                # Try action
-                else:
-                    from MoinMoin import action
-                    handler = action.getHandler(self, action_name)
-                    if handler is None:
-                        msg = _("You are not allowed to do %(action_name)s on this page.") % {
-                                'action_name': wikiutil.escape(action_name), }
-                        if not self.user.valid:
-                            # Suggest non valid user to login
-                            msg += " " + _("Login and try again.")
-                        self.theme.add_msg(msg, "error")
-                        self.page.send_page()
-                    else:
-                        handler(self.page.page_name, self)
-
-            # every action that didn't use to raise MoinMoinFinish must call this now:
-            # self.theme.send_closing_html()
-
-        except MoinMoinFinish:
-            pass
-        except RemoteClosedConnection:
-            # at least clean up
-            pass
-        except SystemExit:
-            raise # fcgi uses this to terminate a thread
-        except Exception, err:
-            try:
-                # nothing we can do about further failures!
-                self.fail(err)
-            except:
-                pass
-
-        if self.cfg.log_timing:
-            self.timing_log(False, action_name)
-
-        return self.finish()
-
-    def http_redirect(self, url):
-        """ Redirect to a fully qualified, or server-rooted URL
-
-        @param url: relative or absolute url, ascii using url encoding.
-        """
-        url = self.getQualifiedURL(url)
-        self.emit_http_headers(["Status: 302 Found", "Location: %s" % url])
-
-    def emit_http_headers(self, more_headers=[], testing=False):
-        """ emit http headers after some preprocessing / checking
-
-            Makes sure we only emit headers once.
-            Encodes to ASCII if it gets unicode headers.
-            Make sure we have exactly one Content-Type and one Status header.
-            Make sure Status header string begins with a integer number.
-
-            For emitting (testing == False), it calls the server specific
-            _emit_http_headers method. For testing, it returns the result.
-
-            @param more_headers: list of additional header strings
-            @param testing: set to True by test code
-        """
-        user_headers = self.user_headers
-        self.user_headers = []
-        tracehere = ''.join(traceback.format_stack()[:-1])
-        all_headers = [(hdr, tracehere) for hdr in more_headers] + user_headers
-
-        if self.sent_headers:
-            # Send headers only once
-            logging.error("Attempt to send headers twice!")
-            logging.error("First attempt:\n%s" % self.sent_headers)
-            logging.error("Second attempt:\n%s" % tracehere)
-            raise HeadersAlreadySentException("emit_http_headers has already been called before!")
-        else:
-            self.sent_headers = tracehere
-
-        # assemble dict of http headers
-        headers = {}
-        traces = {}
-        for header, trace in all_headers:
-            if isinstance(header, unicode):
-                header = header.encode('ascii')
-            key, value = header.split(':', 1)
-            lkey = key.lower()
-            value = value.lstrip()
-            if lkey in headers:
-                if lkey in ['vary', 'cache-control', 'content-language', ]:
-                    # these headers (list might be incomplete) allow multiple values
-                    # that can be merged into a comma separated list
-                    headers[lkey] = headers[lkey][0], '%s, %s' % (headers[lkey][1], value)
-                    traces[lkey] = trace
-                else:
-                    logging.warning("Duplicate http header: %r (ignored)" % header)
-                    logging.warning("Header added first at:\n%s" % traces[lkey])
-                    logging.warning("Header added again at:\n%s" % trace)
-            else:
-                headers[lkey] = (key, value)
-                traces[lkey] = trace
-
-        if 'content-type' not in headers:
-            headers['content-type'] = ('Content-type', 'text/html; charset=%s' % config.charset)
-
-        if 'status' not in headers:
-            headers['status'] = ('Status', '200 OK')
-        else:
-            # check if we got a valid status
-            try:
-                status = headers['status'][1]
-                int(status.split(' ', 1)[0])
-            except:
-                logging.error("emit_http_headers called with invalid header Status: %r" % status)
-                headers['status'] = ('Status', '500 Server Error - invalid status header')
-
-        header_format = '%s: %s'
-        st_header = header_format % headers['status']
-        del headers['status']
-        ct_header = header_format % headers['content-type']
-        del headers['content-type']
-
-        headers = [header_format % kv_tuple for kv_tuple in headers.values()] # make a list of strings
-        headers = [st_header, ct_header] + headers # do NOT change order!
-        if not testing:
-            self._emit_http_headers(headers)
-        else:
-            return headers
-
-    def _emit_http_headers(self, headers):
-        """ server specific method to emit http headers.
-
-            @param headers: a list of http header strings in this FIXED order:
-                1. status header (always present and valid, e.g. "200 OK")
-                2. content type header (always present)
-                3. other headers (optional)
-        """
-        raise NotImplementedError
-
-    def setHttpHeader(self, header):
-        """ Save header for later send.
-
-            Attention: although we use a list here, some implementations use a dict,
-            thus multiple calls with the same header type do NOT work in the end!
-        """
-        # save a traceback with the header for duplicate bug reporting
-        self.user_headers.append((header, ''.join(traceback.format_stack()[:-1])))
-
-    def fail(self, err):
-        """ Fail when we can't continue
-
-        Send 500 status code with the error name. Reference:
-        http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html#sec6.1.1
-
-        Log the error, then let failure module handle it.
-
-        @param err: Exception instance or subclass.
-        """
-        self.failed = 1 # save state for self.run()
-        # we should not generate the headers two times
-        if not self.sent_headers:
-            self.emit_http_headers(['Status: 500 MoinMoin Internal Error'])
-        from MoinMoin import failure
-        failure.handle(self, err)
-
-    def make_unique_id(self, base, namespace=None):
-        """
-        Generates a unique ID using a given base name. Appends a running count to the base.
-
-        Needs to stay deterministic!
-
-        @param base: the base of the id
-        @type base: unicode
-        @param namespace: the namespace for the ID, used when including pages
-
-        @returns: a unique (relatively to the namespace) ID
-        @rtype: unicode
-        """
-        if not isinstance(base, unicode):
-            base = unicode(str(base), 'ascii', 'ignore')
-        if not namespace in self._page_ids:
-            self._page_ids[namespace] = {}
-        count = self._page_ids[namespace].get(base, -1) + 1
-        self._page_ids[namespace][base] = count
-        if not count:
-            return base
-        return u'%s-%d' % (base, count)
-
-    def init_unique_ids(self):
-        '''Initialise everything needed for unique IDs'''
-        self._unique_id_stack = []
-        self._page_ids = {None: {}}
-        self.include_id = None
-        self._include_stack = []
-
-    def push_unique_ids(self):
-        '''
-        Used by the TOC macro, this ensures that the ID namespaces
-        are reset to the status when the current include started.
-        This guarantees that doing the ID enumeration twice results
-        in the same results, on any level.
-        '''
-        self._unique_id_stack.append((self._page_ids, self.include_id))
-        self.include_id, pids = self._include_stack[-1]
-        # make a copy of the containing ID namespaces, that is to say
-        # go back to the level we had at the previous include
-        self._page_ids = {}
-        for namespace in pids:
-            self._page_ids[namespace] = pids[namespace].copy()
-
-    def pop_unique_ids(self):
-        '''
-        Used by the TOC macro to reset the ID namespaces after
-        having parsed the page for TOC generation and after
-        printing the TOC.
-        '''
-        self._page_ids, self.include_id = self._unique_id_stack.pop()
-
-    def begin_include(self, base):
-        '''
-        Called by the formatter when a document begins, which means
-        that include causing nested documents gives us an include
-        stack in self._include_id_stack.
-        '''
-        pids = {}
-        for namespace in self._page_ids:
-            pids[namespace] = self._page_ids[namespace].copy()
-        self._include_stack.append((self.include_id, pids))
-        self.include_id = self.make_unique_id(base)
-        # if it's the page name then set it to None so we don't
-        # prepend anything to IDs, but otherwise keep it.
-        if self.page and self.page.page_name == self.include_id:
-            self.include_id = None
-
-    def end_include(self):
-        '''
-        Called by the formatter when a document ends, restores
-        the current include ID to the previous one and discards
-        the page IDs state we kept around for push_unique_ids().
-        '''
-        self.include_id, pids = self._include_stack.pop()
-
-    def httpDate(self, when=None, rfc='1123'):
-        """ Returns http date string, according to rfc2068
-
-        See http://www.cse.ohio-state.edu/cgi-bin/rfc/rfc2068.html#sec-3.3
-
-        A http 1.1 server should use only rfc1123 date, but cookie's
-        "expires" field should use the older obsolete rfc850 date.
-
-        Note: we can not use strftime() because that honors the locale
-        and rfc2822 requires english day and month names.
-
-        We can not use email.Utils.formatdate because it formats the
-        zone as '-0000' instead of 'GMT', and creates only rfc1123
-        dates. This is a modified version of email.Utils.formatdate
-        from Python 2.4.
-
-        @param when: seconds from epoch, as returned by time.time()
-        @param rfc: conform to rfc ('1123' or '850')
-        @rtype: string
-        @return: http date conforming to rfc1123 or rfc850
-        """
-        if when is None:
-            when = time.time()
-        now = time.gmtime(when)
-        month = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',
-                 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][now.tm_mon - 1]
-        if rfc == '1123':
-            day = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'][now.tm_wday]
-            date = '%02d %s %04d' % (now.tm_mday, month, now.tm_year)
-        elif rfc == '850':
-            day = ["Monday", "Tuesday", "Wednesday", "Thursday",
-                    "Friday", "Saturday", "Sunday"][now.tm_wday]
-            date = '%02d-%s-%s' % (now.tm_mday, month, str(now.tm_year)[-2:])
-        else:
-            raise ValueError("Invalid rfc value: %s" % rfc)
-
-        return '%s, %s %02d:%02d:%02d GMT' % (day, date, now.tm_hour,
-                                              now.tm_min, now.tm_sec)
-
-    def disableHttpCaching(self, level=1):
-        """ Prevent caching of pages that should not be cached.
-
-        level == 1 means disabling caching when we have a cookie set
-        level == 2 means completely disabling caching (used by Page*Editor)
-
-        This is important to prevent caches break acl by providing one
-        user pages meant to be seen only by another user, when both users
-        share the same caching proxy.
-
-        AVOID using no-cache and no-store for attachments as it is completely broken on IE!
-
-        Details: http://support.microsoft.com/support/kb/articles/Q234/0/67.ASP
-        """
-        if level <= self.http_caching_disabled:
-            return # only make caching stricter
-
-        if level == 1:
-            # Set Cache control header for http 1.1 caches
-            # See http://www.cse.ohio-state.edu/cgi-bin/rfc/rfc2109.html#sec-4.2.3
-            # and http://www.cse.ohio-state.edu/cgi-bin/rfc/rfc2068.html#sec-14.9
-            #self.setHttpHeader('Cache-Control: no-cache="set-cookie", private, max-age=0')
-            self.setHttpHeader('Cache-Control: private, must-revalidate, max-age=10')
-        elif level == 2:
-            self.setHttpHeader('Cache-Control: no-cache')
-
-        # only do this once to avoid 'duplicate header' warnings
-        # (in case the caching disabling is being made stricter)
-        if not self.http_caching_disabled:
-            # Set Expires for http 1.0 caches (does not support Cache-Control)
-            when = time.time() - (3600 * 24 * 365)
-            self.setHttpHeader('Expires: %s' % self.httpDate(when=when))
-
-        # Set Pragma for http 1.0 caches
-        # See http://www.cse.ohio-state.edu/cgi-bin/rfc/rfc2068.html#sec-14.32
-        # DISABLED for level == 1 to fix IE https file attachment downloading trouble.
-        if level == 2:
-            self.setHttpHeader('Pragma: no-cache')
-
-        self.http_caching_disabled = level
-
-    def finish(self):
-        """ General cleanup on end of request
-
-        Delete circular references - all object that we create using self.name = class(self).
-        This helps Python to collect these objects and keep our memory footprint lower.
-        """
-        for method in self._finishers:
-            method(self)
-        # only execute finishers once
-        self._finishers = []
-
-        for attr_name in [
-            'editlog', # avoid leaking file handles for open edit-log
-            'theme',
-            'dicts',
-            'user',
-            'rootpage',
-            'page',
-            'html_formatter',
-            'formatter',
-            #'cfg', -- do NOT delattr cfg - it causes problems in the xapian indexing thread
-            ]:
-            try:
-                delattr(self, attr_name)
-            except:
-                pass
-
-    def add_finisher(self, method):
-        self._finishers.append(method)
-
-    # Debug ------------------------------------------------------------
-
-    def debugEnvironment(self, env):
-        """ Environment debugging aid """
-        # Keep this one name per line so its easy to comment stuff
-        names = [
-#             'http_accept_language',
-#             'http_host',
-#             'http_referer',
-#             'http_user_agent',
-#             'is_ssl',
-            'path_info',
-            'query_string',
-#             'remote_addr',
-            'request_method',
-#             'request_uri',
-#             'saved_cookie',
-            'script_name',
-#             'server_name',
-#             'server_port',
-            ]
-        names.sort()
-        attributes = []
-        for name in names:
-            attributes.append('  %s = %r\n' % (name, getattr(self, name, None)))
-        attributes = ''.join(attributes)
-
-        environment = []
-        names = env.keys()
-        names.sort()
-        for key in names:
-            environment.append('  %s = %r\n' % (key, env[key]))
-        environment = ''.join(environment)
-
-        data = '\nRequest Attributes\n%s\nEnvironment\n%s' % (attributes, environment)
-        f = open('/tmp/env.log', 'a')
-        try:
-            f.write(data)
-        finally:
-            f.close()
-
diff --git a/wiki-lenny/share/request.__init__.py b/wiki-lenny/share/request.__init__.py
deleted file mode 100644
index 46198855..00000000
--- a/wiki-lenny/share/request.__init__.py
+++ /dev/null
@@ -1,1684 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - RequestBase Implementation
-
-    @copyright: 2001-2003 Juergen Hermann <jh@web.de>,
-                2003-2008 MoinMoin:ThomasWaldmann
-    @license: GNU GPL, see COPYING for details.
-"""
-
-# Support for remote IP address detection when using (reverse) proxy (or even proxies).
-# If you exactly KNOW which (reverse) proxies you can trust, put them into the list
-# below, so we can determine the "outside" IP as your trusted proxies see it.
-
-proxies_trusted = [] # trust noone!
-#proxies_trusted = ['127.0.0.1', ] # can be a list of multiple IPs
-
-from MoinMoin import log
-logging = log.getLogger(__name__)
-
-def find_remote_addr(addrs):
-    """ Find the last remote IP address before it hits our reverse proxies.
-        The LAST address in the <addrs> list is the remote IP as detected by the server
-        (not taken from some x-forwarded-for header).
-        The FIRST address in the <addrs> list might be the client's IP - if noone cheats
-        and everyone supports x-f-f header.
-
-        See http://bob.pythonmac.org/archives/2005/09/23/apache-x-forwarded-for-caveat/
-
-        For debug loglevel, we log all <addrs>.
-
-        TODO: refactor request code to first do some basic IP init, then load configuration,
-        TODO: then do proxy processing.
-        TODO: add wikiconfig configurability for proxies_trusted
-        TODO: later, make it possible to put multipe remote IP addrs into edit-log
-    """
-    logging.debug("request.find_remote_addr: addrs == %r" % addrs)
-    if proxies_trusted:
-        result = [addr for addr in addrs if addr not in proxies_trusted]
-        if result:
-            return result[-1] # last IP before it hit our trusted (reverse) proxies
-    return addrs[-1] # this is a safe remote_addr, not taken from x-f-f header
-
-
-import os, re, time, sys, cgi, StringIO
-import Cookie
-import traceback
-
-from MoinMoin.Page import Page
-from MoinMoin import config, wikiutil, user, caching, error
-from MoinMoin.config import multiconfig
-from MoinMoin.support.python_compatibility import set
-from MoinMoin.util import IsWin9x
-from MoinMoin.util.clock import Clock
-from MoinMoin import auth
-from urllib import quote, quote_plus
-
-# umask setting --------------------------------------------------------
-def set_umask(new_mask=0777^config.umask):
-    """ Set the OS umask value (and ignore potential failures on OSes where
-        this is not supported).
-        Default: the bitwise inverted value of config.umask
-    """
-    try:
-        old_mask = os.umask(new_mask)
-    except:
-        # maybe we are on win32?
-        pass
-
-# We do this at least once per Python process, when request is imported.
-# If other software parts (like twistd's daemonize() function) set an
-# unwanted umask, we have to call this again to set the correct one:
-set_umask()
-
-# Exceptions -----------------------------------------------------------
-
-class MoinMoinFinish(Exception):
-    """ Raised to jump directly to end of run() function, where finish is called """
-
-
-class HeadersAlreadySentException(Exception):
-    """ Is raised if the headers were already sent when emit_http_headers is called."""
-
-
-class RemoteClosedConnection(Exception):
-    """ Remote end closed connection during request """
-
-# Utilities
-
-def cgiMetaVariable(header, scheme='http'):
-    """ Return CGI meta variable for header name
-
-    e.g 'User-Agent' -> 'HTTP_USER_AGENT'
-    See http://www.faqs.org/rfcs/rfc3875.html section 4.1.18
-    """
-    var = '%s_%s' % (scheme, header)
-    return var.upper().replace('-', '_')
-
-
-# Request Base ----------------------------------------------------------
-
-class RequestBase(object):
-    """ A collection for all data associated with ONE request. """
-
-    # Defaults (used by sub classes)
-    http_accept_language = 'en'
-    server_name = 'localhost'
-    server_port = '80'
-
-    # Extra headers we support. Both standalone and twisted store
-    # headers as lowercase.
-    moin_location = 'x-moin-location'
-    proxy_host = 'x-forwarded-host' # original host: header as seen by the proxy (e.g. wiki.example.org)
-    proxy_xff = 'x-forwarded-for' # list of original remote_addrs as seen by the proxies (e.g. <clientip>,<proxy1>,<proxy2>,...)
-
-    def __init__(self, properties={}):
-
-        # twistd's daemonize() overrides our umask, so we reset it here every
-        # request. we do it for all request types to avoid similar problems.
-        set_umask()
-
-        self._finishers = []
-
-        self._auth_redirected = False
-
-        # Decode values collected by sub classes
-        self.path_info = self.decodePagename(self.path_info)
-
-        self.failed = 0
-        self._available_actions = None
-        self._known_actions = None
-
-        # Pages meta data that we collect in one request
-        self.pages = {}
-
-        self.sent_headers = None
-        self.user_headers = []
-        self.cacheable = 0 # may this output get cached by http proxies/caches?
-        self.http_caching_disabled = 0 # see disableHttpCaching()
-        self.page = None
-        self._dicts = None
-
-        # session handling. users cannot rely on a session being
-        # created, but we should always set request.session
-        self.session = {}
-
-        # setuid handling requires an attribute in the request
-        # that stores the real user
-        self._setuid_real_user = None
-
-        # Check for dumb proxy requests
-        # TODO relying on request_uri will not work on all servers, especially
-        # not on external non-Apache servers
-        self.forbidden = False
-        if self.request_uri.startswith('http://'):
-            self.makeForbidden403()
-
-        # Init
-        else:
-            self.writestack = []
-            self.clock = Clock()
-            self.clock.start('total')
-            self.clock.start('base__init__')
-            # order is important here!
-            self.__dict__.update(properties)
-            try:
-                self._load_multi_cfg()
-            except error.NoConfigMatchedError:
-                self.makeForbidden(404, 'No wiki configuration matching the URL found!\r\n')
-                return
-
-            self.isSpiderAgent = self.check_spider()
-
-            # Set decode charsets.  Input from the user is always in
-            # config.charset, which is the page charsets. Except
-            # path_info, which may use utf-8, and handled by decodePagename.
-            self.decode_charsets = [config.charset]
-
-            if self.query_string.startswith('action=xmlrpc'):
-                self.args = {}
-                self.form = {}
-                self.action = 'xmlrpc'
-                self.rev = None
-            else:
-                try:
-                    self.args = self.form = self.setup_args()
-                except UnicodeError:
-                    self.makeForbidden(403, "The input you sent could not be understood.")
-                    return
-                self.action = self.form.get('action', ['show'])[0]
-                try:
-                    self.rev = int(self.form['rev'][0])
-                except:
-                    self.rev = None
-
-            from MoinMoin.Page import RootPage
-            self.rootpage = RootPage(self)
-
-            from MoinMoin.logfile import editlog
-            self.editlog = editlog.EditLog(self)
-
-            from MoinMoin import i18n
-            self.i18n = i18n
-            i18n.i18n_init(self)
-
-            # authentication might require translated forms, so
-            # have a try at guessing the language from the browser
-            lang = i18n.requestLanguage(self, try_user=False)
-            self.getText = lambda text, i18n=self.i18n, request=self, lang=lang, **kw: i18n.getText(text, request, lang, **kw)
-
-            # session handler start, auth
-            self.parse_cookie()
-            user_obj = self.cfg.session_handler.start(self, self.cfg.session_id_handler)
-            shfinisher = lambda request: self.cfg.session_handler.finish(request, request.user,
-                                                                         self.cfg.session_id_handler)
-            self.add_finisher(shfinisher)
-            # set self.user even if _handle_auth_form raises an Exception
-            self.user = None
-            self.user = self._handle_auth_form(user_obj)
-            del user_obj
-            self.cfg.session_handler.after_auth(self, self.cfg.session_id_handler, self.user)
-            if not self.user:
-                self.user = user.User(self, auth_method='request:invalid')
-
-            # setuid handling, check isSuperUser() because the user
-            # might have lost the permission between requests
-            if 'setuid' in self.session and self.user.isSuperUser():
-                self._setuid_real_user = self.user
-                uid = self.session['setuid']
-                self.user = user.User(self, uid, auth_method='setuid')
-                # set valid to True so superusers can even switch
-                # to disable accounts
-                self.user.valid = True
-
-            if self.action != 'xmlrpc':
-                if not self.forbidden and self.isForbidden():
-                    self.makeForbidden403()
-                if not self.forbidden and self.surge_protect():
-                    self.makeUnavailable503()
-
-            self.pragma = {}
-            self.mode_getpagelinks = 0 # is > 0 as long as we are in a getPageLinks call
-            self.parsePageLinks_running = {} # avoid infinite recursion by remembering what we are already running
-
-            self.lang = i18n.requestLanguage(self)
-            # Language for content. Page content should use the wiki default lang,
-            # but generated content like search results should use the user language.
-            self.content_lang = self.cfg.language_default
-            self.getText = lambda text, i18n=self.i18n, request=self, lang=self.lang, **kv: i18n.getText(text, request, lang, **kv)
-
-            self.reset()
-
-            from MoinMoin.formatter.text_html import Formatter
-            self.html_formatter = Formatter(self)
-            self.formatter = self.html_formatter
-
-            self.clock.stop('base__init__')
-
-    def surge_protect(self, kick_him=False):
-        """ check if someone requesting too much from us,
-            if kick_him is True, we unconditionally blacklist the current user/ip
-        """
-        limits = self.cfg.surge_action_limits
-        if not limits:
-            return False
-
-        if self.remote_addr.startswith('127.'): # localnet
-            return False
-
-        validuser = self.user.valid
-        current_id = validuser and self.user.name or self.remote_addr
-        current_action = self.action
-
-        default_limit = limits.get('default', (30, 60))
-
-        now = int(time.time())
-        surgedict = {}
-        surge_detected = False
-
-        try:
-            # if we have common farm users, we could also use scope='farm':
-            cache = caching.CacheEntry(self, 'surgeprotect', 'surge-log', scope='wiki', use_encode=True)
-            if cache.exists():
-                data = cache.content()
-                data = data.split("\n")
-                for line in data:
-                    try:
-                        id, t, action, surge_indicator = line.split("\t")
-                        t = int(t)
-                        maxnum, dt = limits.get(action, default_limit)
-                        if t >= now - dt:
-                            events = surgedict.setdefault(id, {})
-                            timestamps = events.setdefault(action, [])
-                            timestamps.append((t, surge_indicator))
-                    except StandardError:
-                        pass
-
-            maxnum, dt = limits.get(current_action, default_limit)
-            events = surgedict.setdefault(current_id, {})
-            timestamps = events.setdefault(current_action, [])
-            surge_detected = len(timestamps) > maxnum
-
-            surge_indicator = surge_detected and "!" or ""
-            timestamps.append((now, surge_indicator))
-            if surge_detected:
-                if len(timestamps) < maxnum * 2:
-                    timestamps.append((now + self.cfg.surge_lockout_time, surge_indicator)) # continue like that and get locked out
-
-            if current_action not in ('cache', 'AttachFile', ): # don't add cache/AttachFile accesses to all or picture galleries will trigger SP
-                current_action = 'all' # put a total limit on user's requests
-                maxnum, dt = limits.get(current_action, default_limit)
-                events = surgedict.setdefault(current_id, {})
-                timestamps = events.setdefault(current_action, [])
-
-                if kick_him: # ban this guy, NOW
-                    timestamps.extend([(now + self.cfg.surge_lockout_time, "!")] * (2 * maxnum))
-
-                surge_detected = surge_detected or len(timestamps) > maxnum
-
-                surge_indicator = surge_detected and "!" or ""
-                timestamps.append((now, surge_indicator))
-                if surge_detected:
-                    if len(timestamps) < maxnum * 2:
-                        timestamps.append((now + self.cfg.surge_lockout_time, surge_indicator)) # continue like that and get locked out
-
-            data = []
-            for id, events in surgedict.items():
-                for action, timestamps in events.items():
-                    for t, surge_indicator in timestamps:
-                        data.append("%s\t%d\t%s\t%s" % (id, t, action, surge_indicator))
-            data = "\n".join(data)
-            cache.update(data)
-        except StandardError:
-            pass
-
-        if surge_detected and validuser and self.user.auth_method in self.cfg.auth_methods_trusted:
-            logging.info("Trusted user %s would have triggered surge protection if not trusted." % self.user.name)
-            return False  # do not subject trusted users to surge protection
-
-        return surge_detected
-
-    def getDicts(self):
-        """ Lazy initialize the dicts on the first access """
-        if self._dicts is None:
-            from MoinMoin import wikidicts
-            dicts = wikidicts.GroupDict(self)
-            dicts.load_dicts()
-            self._dicts = dicts
-        return self._dicts
-
-    def delDicts(self):
-        """ Delete the dicts, used by some tests """
-        del self._dicts
-        self._dicts = None
-
-    dicts = property(getDicts, None, delDicts)
-
-    def _load_multi_cfg(self):
-        # protect against calling multiple times
-        if not hasattr(self, 'cfg'):
-            self.clock.start('load_multi_cfg')
-            self.cfg = multiconfig.getConfig(self.url)
-            self.clock.stop('load_multi_cfg')
-
-    def setAcceptedCharsets(self, accept_charset):
-        """ Set accepted_charsets by parsing accept-charset header
-
-        Set self.accepted_charsets to an ordered list based on http_accept_charset.
-
-        Reference: http://www.w3.org/Protocols/rfc2616/rfc2616.txt
-
-        TODO: currently no code use this value.
-
-        @param accept_charset: accept-charset header
-        """
-        charsets = []
-        if accept_charset:
-            accept_charset = accept_charset.lower()
-            # Add iso-8859-1 if needed
-            if (not '*' in accept_charset and
-                'iso-8859-1' not in accept_charset):
-                accept_charset += ',iso-8859-1'
-
-            # Make a list, sorted by quality value, using Schwartzian Transform
-            # Create list of tuples (value, name) , sort, extract names
-            for item in accept_charset.split(','):
-                if ';' in item:
-                    name, qval = item.split(';')
-                    qval = 1.0 - float(qval.split('=')[1])
-                else:
-                    name, qval = item, 0
-                charsets.append((qval, name))
-            charsets.sort()
-            # Remove *, its not clear what we should do with it later
-            charsets = [name for qval, name in charsets if name != '*']
-
-        self.accepted_charsets = charsets
-
-    def _setup_vars_from_std_env(self, env):
-        """ Set common request variables from CGI environment
-
-        Parse a standard CGI environment as created by common web servers.
-        Reference: http://www.faqs.org/rfcs/rfc3875.html
-
-        @param env: dict like object containing cgi meta variables
-        """
-        # Values we can just copy
-        self.env = env
-        self.http_accept_language = env.get('HTTP_ACCEPT_LANGUAGE', self.http_accept_language)
-        self.server_name = env.get('SERVER_NAME', self.server_name)
-        self.server_port = env.get('SERVER_PORT', self.server_port)
-        self.saved_cookie = env.get('HTTP_COOKIE', '')
-        self.script_name = env.get('SCRIPT_NAME', '')
-        self.path_info = env.get('PATH_INFO', '')
-        self.query_string = env.get('QUERY_STRING', '')
-        self.request_method = env.get('REQUEST_METHOD', None)
-        self.remote_addr = env.get('REMOTE_ADDR', '')
-        self.http_user_agent = env.get('HTTP_USER_AGENT', '')
-        try:
-            self.content_length = int(env.get('CONTENT_LENGTH'))
-        except (TypeError, ValueError):
-            self.content_length = None
-        self.if_modified_since = env.get('If-modified-since') or env.get(cgiMetaVariable('If-modified-since'))
-        self.if_none_match = env.get('If-none-match') or env.get(cgiMetaVariable('If-none-match'))
-
-        # REQUEST_URI is not part of CGI spec, but an addition of Apache.
-        self.request_uri = env.get('REQUEST_URI', '')
-
-        # Values that need more work
-        self.setHttpReferer(env.get('HTTP_REFERER'))
-        self.setIsSSL(env)
-        self.setHost(env.get('HTTP_HOST'))
-        self.fixURI(env)
-
-        self.setURL(env)
-        #self.debugEnvironment(env)
-
-    def setHttpReferer(self, referer):
-        """ Set http_referer, making sure its ascii
-
-        IE might send non-ascii value.
-        """
-        value = ''
-        if referer:
-            value = unicode(referer, 'ascii', 'replace')
-            value = value.encode('ascii', 'replace')
-        self.http_referer = value
-
-    def setIsSSL(self, env):
-        """ Set is_ssl
-
-        @param env: dict like object containing cgi meta variables
-        """
-        self.is_ssl = bool(env.get('SSL_PROTOCOL') or
-                           env.get('SSL_PROTOCOL_VERSION') or
-                           env.get('HTTPS') == 'on')
-
-    def setHost(self, host=None):
-        """ Set http_host
-
-        Create from server name and port if missing. Previous code
-        default to localhost.
-        """
-        if not host:
-            port = ''
-            standardPort = ('80', '443')[self.is_ssl]
-            if self.server_port != standardPort:
-                port = ':' + self.server_port
-            host = self.server_name + port
-        self.http_host = host
-
-    def fixURI(self, env):
-        """ Fix problems with script_name and path_info
-
-        Handle the strange charset semantics on Windows and other non
-        posix systems. path_info is transformed into the system code
-        page by the web server. Additionally, paths containing dots let
-        most webservers choke.
-
-        Broken environment variables in different environments:
-                path_info script_name
-        Apache1     X          X      PI does not contain dots
-        Apache2     X          X      PI is not encoded correctly
-        IIS         X          X      path_info include script_name
-        Other       ?          -      ? := Possible and even RFC-compatible.
-                                      - := Hopefully not.
-
-        @param env: dict like object containing cgi meta variables
-        """
-        # Fix the script_name when using Apache on Windows.
-        server_software = env.get('SERVER_SOFTWARE', '')
-        if os.name == 'nt' and 'Apache/' in server_software:
-            # Removes elements ending in '.' from the path.
-            self.script_name = '/'.join([x for x in self.script_name.split('/')
-                                         if not x.endswith('.')])
-
-        # Fix path_info
-        if os.name != 'posix' and self.request_uri != '':
-            # Try to recreate path_info from request_uri.
-            import urlparse
-            scriptAndPath = urlparse.urlparse(self.request_uri)[2]
-            path = scriptAndPath.replace(self.script_name, '', 1)
-            self.path_info = wikiutil.url_unquote(path, want_unicode=False)
-        elif os.name == 'nt':
-            # Recode path_info to utf-8
-            path = wikiutil.decodeWindowsPath(self.path_info)
-            self.path_info = path.encode("utf-8")
-
-            # Fix bug in IIS/4.0 when path_info contain script_name
-            if self.path_info.startswith(self.script_name):
-                self.path_info = self.path_info[len(self.script_name):]
-
-    def setURL(self, env):
-        """ Set url, used to locate wiki config
-
-        This is the place to manipulate url parts as needed.
-
-        @param env: dict like object containing cgi meta variables or http headers.
-        """
-        # proxy support
-        self.rewriteRemoteAddr(env)
-        self.rewriteHost(env)
-
-        self.rewriteURI(env)
-
-        if not self.request_uri:
-            self.request_uri = self.makeURI()
-        self.url = self.http_host + self.request_uri
-
-    def rewriteHost(self, env):
-        """ Rewrite http_host transparently
-
-        Get the proxy host using 'X-Forwarded-Host' header, added by
-        Apache 2 and other proxy software.
-
-        TODO: Will not work for Apache 1 or others that don't add this header.
-
-        TODO: If we want to add an option to disable this feature it
-        should be in the server script, because the config is not
-        loaded at this point, and must be loaded after url is set.
-
-        @param env: dict like object containing cgi meta variables or http headers.
-        """
-        proxy_host = (env.get(self.proxy_host) or
-                      env.get(cgiMetaVariable(self.proxy_host)))
-        if proxy_host:
-            self.http_host = proxy_host
-
-    def rewriteRemoteAddr(self, env):
-        """ Rewrite remote_addr transparently
-
-        Get the proxy remote addr using 'X-Forwarded-For' header, added by
-        Apache 2 and other proxy software.
-
-        TODO: Will not work for Apache 1 or others that don't add this header.
-
-        TODO: If we want to add an option to disable this feature it
-        should be in the server script, because the config is not
-        loaded at this point, and must be loaded after url is set.
-
-        @param env: dict like object containing cgi meta variables or http headers.
-        """
-        xff = (env.get(self.proxy_xff) or
-               env.get(cgiMetaVariable(self.proxy_xff)))
-        if xff:
-            xff = [addr.strip() for addr in xff.split(',')]
-            xff.append(self.remote_addr)
-            self.remote_addr = find_remote_addr(xff)
-
-    def rewriteURI(self, env):
-        """ Rewrite request_uri, script_name and path_info transparently
-
-        Useful when running mod python or when running behind a proxy,
-        e.g run on localhost:8000/ and serve as example.com/wiki/.
-
-        Uses private 'X-Moin-Location' header to set the script name.
-        This allow setting the script name when using Apache 2
-        <location> directive::
-
-            <Location /my/wiki/>
-                RequestHeader set X-Moin-Location /my/wiki/
-            </location>
-
-        TODO: does not work for Apache 1 and others that do not allow
-        setting custom headers per request.
-
-        @param env: dict like object containing cgi meta variables or http headers.
-        """
-        location = (env.get(self.moin_location) or
-                    env.get(cgiMetaVariable(self.moin_location)))
-        if location is None:
-            return
-
-        scriptAndPath = self.script_name + self.path_info
-        location = location.rstrip('/')
-        self.script_name = location
-
-        # This may happen when using mod_python
-        if scriptAndPath.startswith(location):
-            self.path_info = scriptAndPath[len(location):]
-
-        # Recreate the URI from the modified parts
-        if self.request_uri:
-            self.request_uri = self.makeURI()
-
-    def makeURI(self):
-        """ Return uri created from uri parts """
-        uri = self.script_name + wikiutil.url_quote(self.path_info)
-        if self.query_string:
-            uri += '?' + self.query_string
-        return uri
-
-    def splitURI(self, uri):
-        """ Return path and query splited from uri
-
-        Just like CGI environment, the path is unquoted, the query is not.
-        """
-        if '?' in uri:
-            path, query = uri.split('?', 1)
-        else:
-            path, query = uri, ''
-        return wikiutil.url_unquote(path, want_unicode=False), query
-
-    def _handle_auth_form(self, user_obj):
-        username = self.form.get('name', [None])[0]
-        password = self.form.get('password', [None])[0]
-        oid = self.form.get('openid_identifier', [None])[0]
-        login = 'login' in self.form
-        logout = 'logout' in self.form
-        stage = self.form.get('stage', [None])[0]
-        return self.handle_auth(user_obj, attended=True, username=username,
-                                password=password, login=login, logout=logout,
-                                stage=stage, openid_identifier=oid)
-
-    def handle_auth(self, user_obj, attended=False, **kw):
-        username = kw.get('username')
-        password = kw.get('password')
-        oid = kw.get('openid_identifier')
-        login = kw.get('login')
-        logout = kw.get('logout')
-        stage = kw.get('stage')
-        extra = {
-            'cookie': self.cookie,
-        }
-        if login:
-            extra['attended'] = attended
-            extra['username'] = username
-            extra['password'] = password
-            extra['openid_identifier'] = oid
-            if stage:
-                extra['multistage'] = True
-        login_msgs = []
-        self._login_multistage = None
-
-        if logout and 'setuid' in self.session:
-            del self.session['setuid']
-            return user_obj
-
-        for authmethod in self.cfg.auth:
-            if logout:
-                user_obj, cont = authmethod.logout(self, user_obj, **extra)
-            elif login:
-                if stage and authmethod.name != stage:
-                    continue
-                ret = authmethod.login(self, user_obj, **extra)
-                user_obj = ret.user_obj
-                cont = ret.continue_flag
-                if stage:
-                    stage = None
-                    del extra['multistage']
-                if ret.multistage:
-                    self._login_multistage = ret.multistage
-                    self._login_multistage_name = authmethod.name
-                    return user_obj
-                if ret.redirect_to:
-                    nextstage = auth.get_multistage_continuation_url(self, authmethod.name)
-                    url = ret.redirect_to
-                    url = url.replace('%return_form', quote_plus(nextstage))
-                    url = url.replace('%return', quote(nextstage))
-                    self._auth_redirected = True
-                    self.http_redirect(url)
-                    return user_obj
-                msg = ret.message
-                if msg and not msg in login_msgs:
-                    login_msgs.append(msg)
-            else:
-                user_obj, cont = authmethod.request(self, user_obj, **extra)
-            if not cont:
-                break
-
-        self._login_messages = login_msgs
-        return user_obj
-
-    def handle_jid_auth(self, jid):
-        return user.get_by_jabber_id(self, jid)
-
-    def parse_cookie(self):
-        try:
-            self.cookie = Cookie.SimpleCookie(self.saved_cookie)
-        except Cookie.CookieError:
-            self.cookie = None
-
-    def reset(self):
-        """ Reset request state.
-
-        Called after saving a page, before serving the updated
-        page. Solves some practical problems with request state
-        modified during saving.
-
-        """
-        # This is the content language and has nothing to do with
-        # The user interface language. The content language can change
-        # during the rendering of a page by lang macros
-        self.current_lang = self.cfg.language_default
-
-        # caches unique ids
-        self.init_unique_ids()
-
-        if hasattr(self, "_fmt_hd_counters"):
-            del self._fmt_hd_counters
-
-    def loadTheme(self, theme_name):
-        """ Load the Theme to use for this request.
-
-        @param theme_name: the name of the theme
-        @type theme_name: str
-        @rtype: int
-        @return: success code
-                 0 on success
-                 1 if user theme could not be loaded,
-                 2 if a hard fallback to modern theme was required.
-        """
-        fallback = 0
-        if theme_name == "<default>":
-            theme_name = self.cfg.theme_default
-
-        try:
-            Theme = wikiutil.importPlugin(self.cfg, 'theme', theme_name, 'Theme')
-        except wikiutil.PluginMissingError:
-            fallback = 1
-            try:
-                Theme = wikiutil.importPlugin(self.cfg, 'theme', self.cfg.theme_default, 'Theme')
-            except wikiutil.PluginMissingError:
-                fallback = 2
-                from MoinMoin.theme.modern import Theme
-
-        self.theme = Theme(self)
-        return fallback
-
-    def setContentLanguage(self, lang):
-        """ Set the content language, used for the content div
-
-        Actions that generate content in the user language, like search,
-        should set the content direction to the user language before they
-        call send_title!
-        """
-        self.content_lang = lang
-        self.current_lang = lang
-
-    def getPragma(self, key, defval=None):
-        """ Query a pragma value (#pragma processing instruction)
-
-            Keys are not case-sensitive.
-        """
-        return self.pragma.get(key.lower(), defval)
-
-    def setPragma(self, key, value):
-        """ Set a pragma value (#pragma processing instruction)
-
-            Keys are not case-sensitive.
-        """
-        self.pragma[key.lower()] = value
-
-    def getPathinfo(self):
-        """ Return the remaining part of the URL. """
-        return self.path_info
-
-    def getScriptname(self):
-        """ Return the scriptname part of the URL ('/path/to/my.cgi'). """
-        if self.script_name == '/':
-            return ''
-        return self.script_name
-
-    def getKnownActions(self):
-        """ Create a dict of avaiable actions
-
-        Return cached version if avaiable.
-
-        @rtype: dict
-        @return: dict of all known actions
-        """
-        try:
-            self.cfg.cache.known_actions # check
-        except AttributeError:
-            from MoinMoin import action
-            self.cfg.cache.known_actions = set(action.getNames(self.cfg))
-
-        # Return a copy, so clients will not change the set.
-        return self.cfg.cache.known_actions.copy()
-
-    def getAvailableActions(self, page):
-        """ Get list of avaiable actions for this request
-
-        The dict does not contain actions that starts with lower case.
-        Themes use this dict to display the actions to the user.
-
-        @param page: current page, Page object
-        @rtype: dict
-        @return: dict of avaiable actions
-        """
-        if self._available_actions is None:
-            # some actions might make sense for non-existing pages, so we just
-            # require read access here. Can be later refined to some action
-            # specific check:
-            if not self.user.may.read(page.page_name):
-                return []
-
-            # Filter non ui actions (starts with lower case letter)
-            actions = self.getKnownActions()
-            actions = [action for action in actions if not action[0].islower()]
-
-            # Filter wiki excluded actions
-            actions = [action for action in actions if not action in self.cfg.actions_excluded]
-
-            # Filter actions by page type, acl and user state
-            excluded = []
-            if ((page.isUnderlayPage() and not page.isStandardPage()) or
-                not self.user.may.write(page.page_name) or
-                not self.user.may.delete(page.page_name)):
-                # Prevent modification of underlay only pages, or pages
-                # the user can't write and can't delete
-                excluded = [u'RenamePage', u'DeletePage', ] # AttachFile must NOT be here!
-            actions = [action for action in actions if not action in excluded]
-
-            self._available_actions = set(actions)
-
-        # Return a copy, so clients will not change the dict.
-        return self._available_actions.copy()
-
-    def redirectedOutput(self, function, *args, **kw):
-        """ Redirect output during function, return redirected output """
-        buf = StringIO.StringIO()
-        self.redirect(buf)
-        try:
-            function(*args, **kw)
-        finally:
-            self.redirect()
-        text = buf.getvalue()
-        buf.close()
-        return text
-
-    def redirect(self, file=None):
-        """ Redirect output to file, or restore saved output """
-        if file:
-            self.writestack.append(self.write)
-            self.write = file.write
-        else:
-            self.write = self.writestack.pop()
-
-    def log(self, msg):
-        """ DEPRECATED - Log msg to logging framework
-            Please call logging.info(...) directly!
-        """
-        msg = msg.strip()
-        # Encode unicode msg
-        if isinstance(msg, unicode):
-            msg = msg.encode(config.charset)
-        logging.info(msg)
-
-    def timing_log(self, start, action):
-        """ Log to timing log (for performance analysis) """
-        indicator = ''
-        if start:
-            total = "vvv"
-        else:
-            self.clock.stop('total') # make sure it is stopped
-            total_secs = self.clock.timings['total']
-            # we add some stuff that is easy to grep when searching for peformance problems:
-            if total_secs > 50:
-                indicator += '!4!'
-            elif total_secs > 20:
-                indicator += '!3!'
-            elif total_secs > 10:
-                indicator += '!2!'
-            elif total_secs > 2:
-                indicator += '!1!'
-            total = self.clock.value('total')
-            # use + for existing pages, - for non-existing pages
-            if self.page is not None:
-                indicator += self.page.exists() and '+' or '-'
-            if self.isSpiderAgent:
-                indicator += "B"
-
-        pid = os.getpid()
-        msg = 'Timing %5d %-6s %4s %-10s %s\n' % (pid, total, indicator, action, self.url)
-        logging.info(msg)
-
-    def send_file(self, fileobj, bufsize=8192, do_flush=False):
-        """ Send a file to the output stream.
-
-        @param fileobj: a file-like object (supporting read, close)
-        @param bufsize: size of chunks to read/write
-        @param do_flush: call flush after writing?
-        """
-        while True:
-            buf = fileobj.read(bufsize)
-            if not buf:
-                break
-            self.write(buf)
-            if do_flush:
-                self.flush()
-
-    def write(self, *data):
-        """ Write to output stream. """
-        raise NotImplementedError
-
-    def encode(self, data):
-        """ encode data (can be both unicode strings and strings),
-            preparing for a single write()
-        """
-        wd = []
-        for d in data:
-            try:
-                if isinstance(d, unicode):
-                    # if we are REALLY sure, we can use "strict"
-                    d = d.encode(config.charset, 'replace')
-                elif d is None:
-                    continue
-                wd.append(d)
-            except UnicodeError:
-                logging.error("Unicode error on: %s" % repr(d))
-        return ''.join(wd)
-
-    def decodePagename(self, name):
-        """ Decode path, possibly using non ascii characters
-
-        Does not change the name, only decode to Unicode.
-
-        First split the path to pages, then decode each one. This enables
-        us to decode one page using config.charset and another using
-        utf-8. This situation happens when you try to add to a name of
-        an existing page.
-
-        See http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.2.1
-
-        @param name: page name, string
-        @rtype: unicode
-        @return decoded page name
-        """
-        # Split to pages and decode each one
-        pages = name.split('/')
-        decoded = []
-        for page in pages:
-            # Recode from utf-8 into config charset. If the path
-            # contains user typed parts, they are encoded using 'utf-8'.
-            if config.charset != 'utf-8':
-                try:
-                    page = unicode(page, 'utf-8', 'strict')
-                    # Fit data into config.charset, replacing what won't
-                    # fit. Better have few "?" in the name than crash.
-                    page = page.encode(config.charset, 'replace')
-                except UnicodeError:
-                    pass
-
-            # Decode from config.charset, replacing what can't be decoded.
-            page = unicode(page, config.charset, 'replace')
-            decoded.append(page)
-
-        # Assemble decoded parts
-        name = u'/'.join(decoded)
-        return name
-
-    def normalizePagename(self, name):
-        """ Normalize page name
-
-        Prevent creating page names with invisible characters or funny
-        whitespace that might confuse the users or abuse the wiki, or
-        just does not make sense.
-
-        Restrict even more group pages, so they can be used inside acl lines.
-
-        @param name: page name, unicode
-        @rtype: unicode
-        @return: decoded and sanitized page name
-        """
-        # Strip invalid characters
-        name = config.page_invalid_chars_regex.sub(u'', name)
-
-        # Split to pages and normalize each one
-        pages = name.split(u'/')
-        normalized = []
-        for page in pages:
-            # Ignore empty or whitespace only pages
-            if not page or page.isspace():
-                continue
-
-            # Cleanup group pages.
-            # Strip non alpha numeric characters, keep white space
-            if wikiutil.isGroupPage(self, page):
-                page = u''.join([c for c in page
-                                 if c.isalnum() or c.isspace()])
-
-            # Normalize white space. Each name can contain multiple
-            # words separated with only one space. Split handle all
-            # 30 unicode spaces (isspace() == True)
-            page = u' '.join(page.split())
-
-            normalized.append(page)
-
-        # Assemble components into full pagename
-        name = u'/'.join(normalized)
-        return name
-
-    def read(self, n):
-        """ Read n bytes from input stream. """
-        raise NotImplementedError
-
-    def flush(self):
-        """ Flush output stream. """
-        pass
-
-    def check_spider(self):
-        """ check if the user agent for current request is a spider/bot """
-        isSpider = False
-        ua = self.getUserAgent()
-        if ua and self.cfg.cache.ua_spiders:
-            isSpider = self.cfg.cache.ua_spiders.search(ua) is not None
-        return isSpider
-
-    def isForbidden(self):
-        """ check for web spiders and refuse anything except viewing """
-        forbidden = 0
-        # we do not have a parsed query string here, so we can just do simple matching
-        qs = self.query_string
-        action = self.action
-        if ((qs != '' or self.request_method != 'GET') and
-            action != 'rss_rc' and
-            # allow spiders to get attachments and do 'show'
-            not (action == 'AttachFile' and 'do=get' in qs) and
-            action != 'show' and
-            action != 'sitemap'
-            ):
-            forbidden = self.isSpiderAgent
-
-        if not forbidden and self.cfg.hosts_deny:
-            ip = self.remote_addr
-            for host in self.cfg.hosts_deny:
-                if host[-1] == '.' and ip.startswith(host):
-                    forbidden = 1
-                    logging.debug("hosts_deny (net): %s" % str(forbidden))
-                    break
-                if ip == host:
-                    forbidden = 1
-                    logging.debug("hosts_deny (ip): %s" % str(forbidden))
-                    break
-        return forbidden
-
-    def setup_args(self):
-        """ Return args dict
-        First, we parse the query string (usually this is used in GET methods,
-        but TwikiDraw uses ?action=AttachFile&do=savedrawing plus posted stuff).
-        Second, we update what we got in first step by the stuff we get from
-        the form (or by a POST). We invoke _setup_args_from_cgi_form to handle
-        possible file uploads.
-        """
-        args = cgi.parse_qs(self.query_string, keep_blank_values=1)
-        args = self.decodeArgs(args)
-        # if we have form data (in a POST), those override the stuff we already have:
-        if self.request_method == 'POST':
-            postargs = self._setup_args_from_cgi_form()
-            args.update(postargs)
-        return args
-
-    def _setup_args_from_cgi_form(self, form=None):
-        """ Return args dict from a FieldStorage
-
-        Create the args from a given form. Each key contain a list of values.
-        This method usually gets overridden in classes derived from this - it
-        is their task to call this method with an appropriate form parameter.
-
-        @param form: a cgi.FieldStorage
-        @rtype: dict
-        @return: dict with form keys, each contains a list of values
-        """
-        args = {}
-        for key in form:
-            values = form[key]
-            if not isinstance(values, list):
-                values = [values]
-            fixedResult = []
-            for item in values:
-                if isinstance(item, cgi.FieldStorage) and item.filename:
-                    fixedResult.append(item.file) # open data tempfile
-                    # Save upload file name in a separate key
-                    args[key + '__filename__'] = item.filename
-                else:
-                    fixedResult.append(item.value)
-            args[key] = fixedResult
-
-        return self.decodeArgs(args)
-
-    def decodeArgs(self, args):
-        """ Decode args dict
-
-        Decoding is done in a separate path because it is reused by
-        other methods and sub classes.
-        """
-        decode = wikiutil.decodeUserInput
-        result = {}
-        for key in args:
-            if key + '__filename__' in args:
-                # Copy file data as is
-                result[key] = args[key]
-            elif key.endswith('__filename__'):
-                result[key] = decode(args[key], self.decode_charsets)
-            else:
-                result[key] = [decode(value, self.decode_charsets) for value in args[key]]
-        return result
-
-    def getBaseURL(self):
-        """ Return a fully qualified URL to this script. """
-        return self.getQualifiedURL(self.getScriptname())
-
-    def getQualifiedURL(self, uri=''):
-        """ Return an absolute URL starting with schema and host.
-
-        Already qualified urls are returned unchanged.
-
-        @param uri: server rooted uri e.g /scriptname/pagename.
-                    It must start with a slash. Must be ascii and url encoded.
-        """
-        import urlparse
-        scheme = urlparse.urlparse(uri)[0]
-        if scheme:
-            return uri
-
-        scheme = ('http', 'https')[self.is_ssl]
-        result = "%s://%s%s" % (scheme, self.http_host, uri)
-
-        # This might break qualified urls in redirects!
-        # e.g. mapping 'http://netloc' -> '/'
-        return wikiutil.mapURL(self, result)
-
-    def getUserAgent(self):
-        """ Get the user agent. """
-        return self.http_user_agent
-
-    def makeForbidden(self, resultcode, msg):
-        statusmsg = {
-            401: 'Authorization required',
-            403: 'FORBIDDEN',
-            404: 'Not found',
-            503: 'Service unavailable',
-        }
-        headers = [
-            'Status: %d %s' % (resultcode, statusmsg[resultcode]),
-            'Content-Type: text/plain; charset=utf-8'
-        ]
-        # when surge protection triggered, tell bots to come back later...
-        if resultcode == 503:
-            headers.append('Retry-After: %d' % self.cfg.surge_lockout_time)
-        self.emit_http_headers(headers)
-        self.write(msg)
-        self.forbidden = True
-
-    def makeForbidden403(self):
-        self.makeForbidden(403, 'You are not allowed to access this!\r\n')
-
-    def makeUnavailable503(self):
-        self.makeForbidden(503, "Warning:\r\n"
-                   "You triggered the wiki's surge protection by doing too many requests in a short time.\r\n"
-                   "Please make a short break reading the stuff you already got.\r\n"
-                   "When you restart doing requests AFTER that, slow down or you might get locked out for a longer time!\r\n")
-
-    def initTheme(self):
-        """ Set theme - forced theme, user theme or wiki default """
-        ### HACK SAUVAGE 1/1
-        if self.http_host == 'www.crans.org':
-            theme_name = 'crans-www'
-        elif self.cfg.theme_force:
-        ### FIN HACK 1/1
-            theme_name = self.cfg.theme_default
-        else:
-            theme_name = self.user.theme_name
-        self.loadTheme(theme_name)
-
-    def _try_redirect_spaces_page(self, pagename):
-        if '_' in pagename and not self.page.exists():
-            pname = pagename.replace('_', ' ')
-            pg = Page(self, pname)
-            if pg.exists():
-                url = pg.url(self)
-                self.http_redirect(url)
-                return True
-        return False
-
-    def run(self):
-        # Exit now if __init__ failed or request is forbidden
-        if self.failed or self.forbidden or self._auth_redirected:
-            # Don't sleep() here, it binds too much of our resources!
-            return self.finish()
-
-        _ = self.getText
-        self.clock.start('run')
-
-        self.initTheme()
-
-        action_name = self.action
-        if self.cfg.log_timing:
-            self.timing_log(True, action_name)
-
-        if action_name == 'xmlrpc':
-            from MoinMoin import xmlrpc
-            if self.query_string == 'action=xmlrpc':
-                xmlrpc.xmlrpc(self)
-            elif self.query_string == 'action=xmlrpc2':
-                xmlrpc.xmlrpc2(self)
-            if self.cfg.log_timing:
-                self.timing_log(False, action_name)
-            return self.finish()
-
-        # parse request data
-        try:
-            # The last component in path_info is the page name, if any
-            path = self.getPathinfo()
-
-            # we can have all action URLs like this: /action/ActionName/PageName?action=ActionName&...
-            # this is just for robots.txt being able to forbid them for crawlers
-            prefix = self.cfg.url_prefix_action
-            if prefix is not None:
-                prefix = '/%s/' % prefix # e.g. '/action/'
-                if path.startswith(prefix):
-                    # remove prefix and action name
-                    path = path[len(prefix):]
-                    action, path = (path.split('/', 1) + ['', ''])[:2]
-                    path = '/' + path
-
-            if path.startswith('/'):
-                pagename = self.normalizePagename(path)
-            else:
-                pagename = None
-
-            # need to inform caches that content changes based on:
-            # * cookie (even if we aren't sending one now)
-            # * User-Agent (because a bot might be denied and get no content)
-            # * Accept-Language (except if moin is told to ignore browser language)
-            if self.cfg.language_ignore_browser:
-                self.setHttpHeader("Vary: Cookie,User-Agent")
-            else:
-                self.setHttpHeader("Vary: Cookie,User-Agent,Accept-Language")
-
-            # Handle request. We have these options:
-            # 1. jump to page where user left off
-            if not pagename and self.user.remember_last_visit and action_name == 'show':
-                pagetrail = self.user.getTrail()
-                if pagetrail:
-                    # Redirect to last page visited
-                    last_visited = pagetrail[-1]
-                    wikiname, pagename = wikiutil.split_interwiki(last_visited)
-                    if wikiname != 'Self':
-                        wikitag, wikiurl, wikitail, error = wikiutil.resolve_interwiki(self, wikiname, pagename)
-                        url = wikiurl + wikiutil.quoteWikinameURL(wikitail)
-                    else:
-                        url = Page(self, pagename).url(self)
-                else:
-                    # Or to localized FrontPage
-                    url = wikiutil.getFrontPage(self).url(self)
-                self.http_redirect(url)
-                return self.finish()
-
-            # 2. handle action
-            else:
-                # pagename could be empty after normalization e.g. '///' -> ''
-                # Use localized FrontPage if pagename is empty
-                if not pagename:
-                    self.page = wikiutil.getFrontPage(self)
-                else:
-                    self.page = Page(self, pagename)
-                    if self._try_redirect_spaces_page(pagename):
-                        return self.finish()
-
-                msg = None
-                # Complain about unknown actions
-                if not action_name in self.getKnownActions():
-                    msg = _("Unknown action %(action_name)s.") % {
-                            'action_name': wikiutil.escape(action_name), }
-
-                # Disallow non available actions
-                elif action_name[0].isupper() and not action_name in self.getAvailableActions(self.page):
-                    msg = _("You are not allowed to do %(action_name)s on this page.") % {
-                            'action_name': wikiutil.escape(action_name), }
-                    if not self.user.valid:
-                        # Suggest non valid user to login
-                        msg += " " + _("Login and try again.")
-
-                if msg:
-                    self.theme.add_msg(msg, "error")
-                    self.page.send_page()
-                # Try action
-                else:
-                    from MoinMoin import action
-                    handler = action.getHandler(self, action_name)
-                    if handler is None:
-                        msg = _("You are not allowed to do %(action_name)s on this page.") % {
-                                'action_name': wikiutil.escape(action_name), }
-                        if not self.user.valid:
-                            # Suggest non valid user to login
-                            msg += " " + _("Login and try again.")
-                        self.theme.add_msg(msg, "error")
-                        self.page.send_page()
-                    else:
-                        handler(self.page.page_name, self)
-
-            # every action that didn't use to raise MoinMoinFinish must call this now:
-            # self.theme.send_closing_html()
-
-        except MoinMoinFinish:
-            pass
-        except RemoteClosedConnection:
-            # at least clean up
-            pass
-        except SystemExit:
-            raise # fcgi uses this to terminate a thread
-        except Exception, err:
-            try:
-                # nothing we can do about further failures!
-                self.fail(err)
-            except:
-                pass
-
-        if self.cfg.log_timing:
-            self.timing_log(False, action_name)
-
-        return self.finish()
-
-    def http_redirect(self, url):
-        """ Redirect to a fully qualified, or server-rooted URL
-
-        @param url: relative or absolute url, ascii using url encoding.
-        """
-        url = self.getQualifiedURL(url)
-        self.emit_http_headers(["Status: 302 Found", "Location: %s" % url])
-
-    def emit_http_headers(self, more_headers=[], testing=False):
-        """ emit http headers after some preprocessing / checking
-
-            Makes sure we only emit headers once.
-            Encodes to ASCII if it gets unicode headers.
-            Make sure we have exactly one Content-Type and one Status header.
-            Make sure Status header string begins with a integer number.
-
-            For emitting (testing == False), it calls the server specific
-            _emit_http_headers method. For testing, it returns the result.
-
-            @param more_headers: list of additional header strings
-            @param testing: set to True by test code
-        """
-        user_headers = self.user_headers
-        self.user_headers = []
-        tracehere = ''.join(traceback.format_stack()[:-1])
-        all_headers = [(hdr, tracehere) for hdr in more_headers] + user_headers
-
-        if self.sent_headers:
-            # Send headers only once
-            logging.error("Attempt to send headers twice!")
-            logging.error("First attempt:\n%s" % self.sent_headers)
-            logging.error("Second attempt:\n%s" % tracehere)
-            raise HeadersAlreadySentException("emit_http_headers has already been called before!")
-        else:
-            self.sent_headers = tracehere
-
-        # assemble dict of http headers
-        headers = {}
-        traces = {}
-        for header, trace in all_headers:
-            if isinstance(header, unicode):
-                header = header.encode('ascii')
-            key, value = header.split(':', 1)
-            lkey = key.lower()
-            value = value.lstrip()
-            if lkey in headers:
-                if lkey in ['vary', 'cache-control', 'content-language', ]:
-                    # these headers (list might be incomplete) allow multiple values
-                    # that can be merged into a comma separated list
-                    headers[lkey] = headers[lkey][0], '%s, %s' % (headers[lkey][1], value)
-                    traces[lkey] = trace
-                else:
-                    logging.warning("Duplicate http header: %r (ignored)" % header)
-                    logging.warning("Header added first at:\n%s" % traces[lkey])
-                    logging.warning("Header added again at:\n%s" % trace)
-            else:
-                headers[lkey] = (key, value)
-                traces[lkey] = trace
-
-        if 'content-type' not in headers:
-            headers['content-type'] = ('Content-type', 'text/html; charset=%s' % config.charset)
-
-        if 'status' not in headers:
-            headers['status'] = ('Status', '200 OK')
-        else:
-            # check if we got a valid status
-            try:
-                status = headers['status'][1]
-                int(status.split(' ', 1)[0])
-            except:
-                logging.error("emit_http_headers called with invalid header Status: %r" % status)
-                headers['status'] = ('Status', '500 Server Error - invalid status header')
-
-        header_format = '%s: %s'
-        st_header = header_format % headers['status']
-        del headers['status']
-        ct_header = header_format % headers['content-type']
-        del headers['content-type']
-
-        headers = [header_format % kv_tuple for kv_tuple in headers.values()] # make a list of strings
-        headers = [st_header, ct_header] + headers # do NOT change order!
-        if not testing:
-            self._emit_http_headers(headers)
-        else:
-            return headers
-
-    def _emit_http_headers(self, headers):
-        """ server specific method to emit http headers.
-
-            @param headers: a list of http header strings in this FIXED order:
-                1. status header (always present and valid, e.g. "200 OK")
-                2. content type header (always present)
-                3. other headers (optional)
-        """
-        raise NotImplementedError
-
-    def setHttpHeader(self, header):
-        """ Save header for later send.
-
-            Attention: although we use a list here, some implementations use a dict,
-            thus multiple calls with the same header type do NOT work in the end!
-        """
-        # save a traceback with the header for duplicate bug reporting
-        self.user_headers.append((header, ''.join(traceback.format_stack()[:-1])))
-
-    def fail(self, err):
-        """ Fail when we can't continue
-
-        Send 500 status code with the error name. Reference:
-        http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html#sec6.1.1
-
-        Log the error, then let failure module handle it.
-
-        @param err: Exception instance or subclass.
-        """
-        self.failed = 1 # save state for self.run()
-        # we should not generate the headers two times
-        if not self.sent_headers:
-            self.emit_http_headers(['Status: 500 MoinMoin Internal Error'])
-        from MoinMoin import failure
-        failure.handle(self, err)
-
-    def make_unique_id(self, base, namespace=None):
-        """
-        Generates a unique ID using a given base name. Appends a running count to the base.
-
-        Needs to stay deterministic!
-
-        @param base: the base of the id
-        @type base: unicode
-        @param namespace: the namespace for the ID, used when including pages
-
-        @returns: a unique (relatively to the namespace) ID
-        @rtype: unicode
-        """
-        if not isinstance(base, unicode):
-            base = unicode(str(base), 'ascii', 'ignore')
-        if not namespace in self._page_ids:
-            self._page_ids[namespace] = {}
-        count = self._page_ids[namespace].get(base, -1) + 1
-        self._page_ids[namespace][base] = count
-        if not count:
-            return base
-        return u'%s-%d' % (base, count)
-
-    def init_unique_ids(self):
-        '''Initialise everything needed for unique IDs'''
-        self._unique_id_stack = []
-        self._page_ids = {None: {}}
-        self.include_id = None
-        self._include_stack = []
-
-    def push_unique_ids(self):
-        '''
-        Used by the TOC macro, this ensures that the ID namespaces
-        are reset to the status when the current include started.
-        This guarantees that doing the ID enumeration twice results
-        in the same results, on any level.
-        '''
-        self._unique_id_stack.append((self._page_ids, self.include_id))
-        self.include_id, pids = self._include_stack[-1]
-        # make a copy of the containing ID namespaces, that is to say
-        # go back to the level we had at the previous include
-        self._page_ids = {}
-        for namespace in pids:
-            self._page_ids[namespace] = pids[namespace].copy()
-
-    def pop_unique_ids(self):
-        '''
-        Used by the TOC macro to reset the ID namespaces after
-        having parsed the page for TOC generation and after
-        printing the TOC.
-        '''
-        self._page_ids, self.include_id = self._unique_id_stack.pop()
-
-    def begin_include(self, base):
-        '''
-        Called by the formatter when a document begins, which means
-        that include causing nested documents gives us an include
-        stack in self._include_id_stack.
-        '''
-        pids = {}
-        for namespace in self._page_ids:
-            pids[namespace] = self._page_ids[namespace].copy()
-        self._include_stack.append((self.include_id, pids))
-        self.include_id = self.make_unique_id(base)
-        # if it's the page name then set it to None so we don't
-        # prepend anything to IDs, but otherwise keep it.
-        if self.page and self.page.page_name == self.include_id:
-            self.include_id = None
-
-    def end_include(self):
-        '''
-        Called by the formatter when a document ends, restores
-        the current include ID to the previous one and discards
-        the page IDs state we kept around for push_unique_ids().
-        '''
-        self.include_id, pids = self._include_stack.pop()
-
-    def httpDate(self, when=None, rfc='1123'):
-        """ Returns http date string, according to rfc2068
-
-        See http://www.cse.ohio-state.edu/cgi-bin/rfc/rfc2068.html#sec-3.3
-
-        A http 1.1 server should use only rfc1123 date, but cookie's
-        "expires" field should use the older obsolete rfc850 date.
-
-        Note: we can not use strftime() because that honors the locale
-        and rfc2822 requires english day and month names.
-
-        We can not use email.Utils.formatdate because it formats the
-        zone as '-0000' instead of 'GMT', and creates only rfc1123
-        dates. This is a modified version of email.Utils.formatdate
-        from Python 2.4.
-
-        @param when: seconds from epoch, as returned by time.time()
-        @param rfc: conform to rfc ('1123' or '850')
-        @rtype: string
-        @return: http date conforming to rfc1123 or rfc850
-        """
-        if when is None:
-            when = time.time()
-        now = time.gmtime(when)
-        month = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',
-                 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][now.tm_mon - 1]
-        if rfc == '1123':
-            day = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'][now.tm_wday]
-            date = '%02d %s %04d' % (now.tm_mday, month, now.tm_year)
-        elif rfc == '850':
-            day = ["Monday", "Tuesday", "Wednesday", "Thursday",
-                    "Friday", "Saturday", "Sunday"][now.tm_wday]
-            date = '%02d-%s-%s' % (now.tm_mday, month, str(now.tm_year)[-2:])
-        else:
-            raise ValueError("Invalid rfc value: %s" % rfc)
-
-        return '%s, %s %02d:%02d:%02d GMT' % (day, date, now.tm_hour,
-                                              now.tm_min, now.tm_sec)
-
-    def disableHttpCaching(self, level=1):
-        """ Prevent caching of pages that should not be cached.
-
-        level == 1 means disabling caching when we have a cookie set
-        level == 2 means completely disabling caching (used by Page*Editor)
-
-        This is important to prevent caches break acl by providing one
-        user pages meant to be seen only by another user, when both users
-        share the same caching proxy.
-
-        AVOID using no-cache and no-store for attachments as it is completely broken on IE!
-
-        Details: http://support.microsoft.com/support/kb/articles/Q234/0/67.ASP
-        """
-        if level <= self.http_caching_disabled:
-            return # only make caching stricter
-
-        if level == 1:
-            # Set Cache control header for http 1.1 caches
-            # See http://www.cse.ohio-state.edu/cgi-bin/rfc/rfc2109.html#sec-4.2.3
-            # and http://www.cse.ohio-state.edu/cgi-bin/rfc/rfc2068.html#sec-14.9
-            #self.setHttpHeader('Cache-Control: no-cache="set-cookie", private, max-age=0')
-            self.setHttpHeader('Cache-Control: private, must-revalidate, max-age=10')
-        elif level == 2:
-            self.setHttpHeader('Cache-Control: no-cache')
-
-        # only do this once to avoid 'duplicate header' warnings
-        # (in case the caching disabling is being made stricter)
-        if not self.http_caching_disabled:
-            # Set Expires for http 1.0 caches (does not support Cache-Control)
-            when = time.time() - (3600 * 24 * 365)
-            self.setHttpHeader('Expires: %s' % self.httpDate(when=when))
-
-        # Set Pragma for http 1.0 caches
-        # See http://www.cse.ohio-state.edu/cgi-bin/rfc/rfc2068.html#sec-14.32
-        # DISABLED for level == 1 to fix IE https file attachment downloading trouble.
-        if level == 2:
-            self.setHttpHeader('Pragma: no-cache')
-
-        self.http_caching_disabled = level
-
-    def finish(self):
-        """ General cleanup on end of request
-
-        Delete circular references - all object that we create using self.name = class(self).
-        This helps Python to collect these objects and keep our memory footprint lower.
-        """
-        for method in self._finishers:
-            method(self)
-        # only execute finishers once
-        self._finishers = []
-
-        for attr_name in [
-            'editlog', # avoid leaking file handles for open edit-log
-            'theme',
-            'dicts',
-            'user',
-            'rootpage',
-            'page',
-            'html_formatter',
-            'formatter',
-            #'cfg', -- do NOT delattr cfg - it causes problems in the xapian indexing thread
-            ]:
-            try:
-                delattr(self, attr_name)
-            except:
-                pass
-
-    def add_finisher(self, method):
-        self._finishers.append(method)
-
-    # Debug ------------------------------------------------------------
-
-    def debugEnvironment(self, env):
-        """ Environment debugging aid """
-        # Keep this one name per line so its easy to comment stuff
-        names = [
-#             'http_accept_language',
-#             'http_host',
-#             'http_referer',
-#             'http_user_agent',
-#             'is_ssl',
-            'path_info',
-            'query_string',
-#             'remote_addr',
-            'request_method',
-#             'request_uri',
-#             'saved_cookie',
-            'script_name',
-#             'server_name',
-#             'server_port',
-            ]
-        names.sort()
-        attributes = []
-        for name in names:
-            attributes.append('  %s = %r\n' % (name, getattr(self, name, None)))
-        attributes = ''.join(attributes)
-
-        environment = []
-        names = env.keys()
-        names.sort()
-        for key in names:
-            environment.append('  %s = %r\n' % (key, env[key]))
-        environment = ''.join(environment)
-
-        data = '\nRequest Attributes\n%s\nEnvironment\n%s' % (attributes, environment)
-        f = open('/tmp/env.log', 'a')
-        try:
-            f.write(data)
-        finally:
-            f.close()
-
diff --git a/wiki-lenny/share/scripts.export.dump.orig.py b/wiki-lenny/share/scripts.export.dump.orig.py
deleted file mode 100644
index c4b84ae5..00000000
--- a/wiki-lenny/share/scripts.export.dump.orig.py
+++ /dev/null
@@ -1,234 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-MoinMoin - Dump a MoinMoin wiki to static pages
-
-@copyright: 2002-2004 Juergen Hermann <jh@web.de>,
-            2005-2006 MoinMoin:ThomasWaldmann
-@license: GNU GPL, see COPYING for details.
-"""
-
-import sys, os, time, codecs, shutil, re, errno
-
-from MoinMoin import config, wikiutil, Page, user
-from MoinMoin import script
-from MoinMoin.action import AttachFile
-
-url_prefix_static = "."
-logo_html = '<img src="logo.png">'
-HTML_SUFFIX = ".html"
-
-page_template = u'''<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
-<html>
-<head>
-<meta http-equiv="content-type" content="text/html; charset=%(charset)s">
-<title>%(pagename)s</title>
-<link rel="stylesheet" type="text/css" media="all" charset="utf-8" href="%(theme)s/css/common.css">
-<link rel="stylesheet" type="text/css" media="screen" charset="utf-8" href="%(theme)s/css/screen.css">
-<link rel="stylesheet" type="text/css" media="print" charset="utf-8" href="%(theme)s/css/print.css">
-<style type="text/css">
-ul.pagetitle{
-  display: inline;
-  margin: 0;
-  padding: 0;
-  font-size: 1.5em;
-}
-li.pagetitle{
-  display: inline;
-  margin: 0;
-}
-td.noborder {
-  border: 0;
-}
-</style>
-</head>
-<body>
-<table>
-<tr>
-<td class="noborder">
-%(logo_html)s
-</td>
-<td class="noborder">
-<ul class="pagetitle">
-<li class="pagetitle"><a class="backlink">%(pagename)s</a>
-</ul>
-<br><br>
-%(navibar_html)s
-</td>
-</tr>
-</table>
-<hr>
-<div id="page">
-%(pagehtml)s
-</div>
-<hr>
-%(timestamp)s
-</body>
-</html>
-'''
-
-
-def _attachment(request, pagename, filename, outputdir, **kw):
-    filename = filename.encode(config.charset)
-    source_dir = AttachFile.getAttachDir(request, pagename)
-    source_file = os.path.join(source_dir, filename)
-    dest_dir = os.path.join(outputdir, "attachments", wikiutil.quoteWikinameFS(pagename))
-    dest_file = os.path.join(dest_dir, filename)
-    dest_url = "attachments/%s/%s" % (wikiutil.quoteWikinameFS(pagename), wikiutil.url_quote(filename))
-    if os.access(source_file, os.R_OK):
-        if not os.access(dest_dir, os.F_OK):
-            try:
-                os.makedirs(dest_dir)
-            except:
-                script.fatal("Cannot create attachment directory '%s'" % dest_dir)
-        elif not os.path.isdir(dest_dir):
-            script.fatal("'%s' is not a directory" % dest_dir)
-
-        shutil.copyfile(source_file, dest_file)
-        script.log('Writing "%s"...' % dest_url)
-        return dest_url
-    else:
-        return ""
-
-
-class PluginScript(script.MoinScript):
-    """\
-Purpose:
-========
-This tool allows you to dump MoinMoin wiki pages to static HTML files.
-
-Detailed Instructions:
-======================
-General syntax: moin [options] export dump [dump-options]
-
-[options] usually should be:
-    --config-dir=/path/to/my/cfg/ --wiki-url=wiki.example.org/
-
-[dump-options] see below:
-    0. You must run this script as owner of the wiki files, usually this is the
-       web server user.
-
-    1. To dump all the pages on the wiki to the directory '/mywiki'
-       moin ... export dump --target-dir=/mywiki
-
-    2. To dump all the pages readable by 'JohnSmith' on the wiki to the directory
-       '/mywiki'
-       moin ... export dump --target-dir=/mywiki --username JohnSmith
-"""
-
-    def __init__(self, argv=None, def_values=None):
-        script.MoinScript.__init__(self, argv, def_values)
-        self.parser.add_option(
-            "-t", "--target-dir", dest = "target_dir",
-            help = "Write html dump to DIRECTORY"
-        )
-        self.parser.add_option(
-            "-u", "--username", dest = "dump_user",
-            help = "User the dump will be performed as (for ACL checks, etc)"
-        )
-
-    def mainloop(self):
-        """ moin-dump's main code. """
-
-        # Prepare output directory
-        if not self.options.target_dir:
-            script.fatal("you must use --target-dir=/your/output/path to specify the directory we write the html files to")
-        outputdir = os.path.abspath(self.options.target_dir)
-        try:
-            os.mkdir(outputdir)
-            script.log("Created output directory '%s'!" % outputdir)
-        except OSError, err:
-            if err.errno != errno.EEXIST:
-                script.fatal("Cannot create output directory '%s'!" % outputdir)
-
-        # Insert config dir or the current directory to the start of the path.
-        config_dir = self.options.config_dir
-        if config_dir and os.path.isfile(config_dir):
-            config_dir = os.path.dirname(config_dir)
-        if config_dir and not os.path.isdir(config_dir):
-            script.fatal("bad path given to --config-dir option")
-        sys.path.insert(0, os.path.abspath(config_dir or os.curdir))
-
-        self.init_request()
-        request = self.request
-
-        # fix url_prefix_static so we get relative paths in output html
-        request.cfg.url_prefix_static = url_prefix_static
-
-        # use this user for permissions checks
-        request.user = user.User(request, name=self.options.dump_user)
-
-        pages = request.rootpage.getPageList(user='') # get list of all pages in wiki
-        pages.sort()
-        if self.options.page: # did user request a particular page or group of pages?
-            try:
-                namematch = re.compile(self.options.page)
-                pages = [page for page in pages if namematch.match(page)]
-                if not pages:
-                    pages = [self.options.page]
-            except:
-                pages = [self.options.page]
-
-        wikiutil.quoteWikinameURL = lambda pagename, qfn=wikiutil.quoteWikinameFS: (qfn(pagename) + HTML_SUFFIX)
-
-        AttachFile.getAttachUrl = lambda pagename, filename, request, **kw: _attachment(request, pagename, filename, outputdir, **kw)
-
-        errfile = os.path.join(outputdir, 'error.log')
-        errlog = open(errfile, 'w')
-        errcnt = 0
-
-        page_front_page = wikiutil.getLocalizedPage(request, request.cfg.page_front_page).page_name
-        page_title_index = wikiutil.getLocalizedPage(request, 'TitleIndex').page_name
-        page_word_index = wikiutil.getLocalizedPage(request, 'WordIndex').page_name
-
-        navibar_html = ''
-        for p in [page_front_page, page_title_index, page_word_index]:
-            navibar_html += '[<a href="%s">%s</a>]&nbsp;' % (wikiutil.quoteWikinameURL(p), wikiutil.escape(p))
-
-        urlbase = request.url # save wiki base url
-        for pagename in pages:
-            # we have the same name in URL and FS
-            file = wikiutil.quoteWikinameURL(pagename)
-            script.log('Writing "%s"...' % file)
-            try:
-                pagehtml = ''
-                request.url = urlbase + pagename # add current pagename to url base
-                page = Page.Page(request, pagename)
-                request.page = page
-                try:
-                    request.reset()
-                    pagehtml = request.redirectedOutput(page.send_page, count_hit=0, content_only=1)
-                except:
-                    errcnt = errcnt + 1
-                    print >> sys.stderr, "*** Caught exception while writing page!"
-                    print >> errlog, "~" * 78
-                    print >> errlog, file # page filename
-                    import traceback
-                    traceback.print_exc(None, errlog)
-            finally:
-                timestamp = time.strftime("%Y-%m-%d %H:%M")
-                filepath = os.path.join(outputdir, file)
-                fileout = codecs.open(filepath, 'w', config.charset)
-                fileout.write(page_template % {
-                    'charset': config.charset,
-                    'pagename': pagename,
-                    'pagehtml': pagehtml,
-                    'logo_html': logo_html,
-                    'navibar_html': navibar_html,
-                    'timestamp': timestamp,
-                    'theme': request.cfg.theme_default,
-                })
-                fileout.close()
-
-        # copy FrontPage to "index.html"
-        indexpage = page_front_page
-        if self.options.page:
-            indexpage = pages[0] # index page has limited use when dumping specific pages, but create one anyway
-        shutil.copyfile(
-            os.path.join(outputdir, wikiutil.quoteWikinameFS(indexpage) + HTML_SUFFIX),
-            os.path.join(outputdir, 'index' + HTML_SUFFIX)
-        )
-
-        errlog.close()
-        if errcnt:
-            print >> sys.stderr, "*** %d error(s) occurred, see '%s'!" % (errcnt, errfile)
-
diff --git a/wiki-lenny/share/scripts.export.dump.py b/wiki-lenny/share/scripts.export.dump.py
deleted file mode 100644
index 323416b5..00000000
--- a/wiki-lenny/share/scripts.export.dump.py
+++ /dev/null
@@ -1,215 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-MoinMoin - Dump a MoinMoin wiki to static pages
-
-@copyright: 2002-2004 Juergen Hermann <jh@web.de>,
-            2005-2006 MoinMoin:ThomasWaldmann
-@license: GNU GPL, see COPYING for details.
-"""
-
-import sys, os, time, codecs, shutil, re, errno
-
-from MoinMoin import config, wikiutil, Page, user
-from MoinMoin import script
-from MoinMoin.action import AttachFile
-
-url_prefix_static = "."
-logo_html = '<img src="logo.png">'
-HTML_SUFFIX = ".html"
-
-### TEMPLATE MODIFIÉ
-page_template = u'''<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
-<html>
-<head>
-<meta http-equiv="content-type" content="text/html; charset=%(charset)s">
-<title>%(pagename)s</title>
-<link rel="stylesheet" type="text/css" media="all" charset="utf-8" href="/style.css">
-<link rel="stylesheet" type="text/css" media="all" charset="utf-8" href="%(theme)s/css/common.css">
-<link rel="stylesheet" type="text/css" media="screen" charset="utf-8" href="%(theme)s/css/screen.css">
-<link rel="stylesheet" type="text/css" media="print" charset="utf-8" href="%(theme)s/css/print.css">
-</head>
-<body>
-<p class="avertissement">
-Ce site est une copie statique et partielle de ce que l'on peut trouver
-sur le <a href="http://wiki.crans.org">wiki</a> de l'association. Si
-vous êtes ici, alors que vous avez demandé un autre site, c'est sans
-doute que vous êtes connecté au réseau wifi de l'association mais que
-vous n'avez pas encore complété toutes les étapes nécessaires pour avoir
-une connexion pleinement fonctionnelle. Ce site contient donc les infos
-pour configurer correctement votre connexion.
-</p>
-<div id="title"><h1>%(pagename)s</h1></div>
-%(pagehtml)s
-<p class="creation">
-Cette page a été extraite du wiki le %(timestamp)s. Vous pouvez l'<a href="http://wiki.crans.org/%(pagename)s?action=edit">éditer</a> ou <a href="http://www.crans.org/%(pagename)s">voir</a> la page originale.
-</p>
-</body>
-</html>
-'''
-
-
-def _attachment(request, pagename, filename, outputdir, **kw):
-    filename = filename.encode(config.charset)
-    source_dir = AttachFile.getAttachDir(request, pagename)
-    source_file = os.path.join(source_dir, filename)
-    dest_dir = os.path.join(outputdir, "attachments", wikiutil.quoteWikinameFS(pagename))
-    dest_file = os.path.join(dest_dir, filename)
-    dest_url = "attachments/%s/%s" % (wikiutil.quoteWikinameFS(pagename), wikiutil.url_quote(filename))
-    if os.access(source_file, os.R_OK):
-        if not os.access(dest_dir, os.F_OK):
-            try:
-                os.makedirs(dest_dir)
-            except:
-                script.fatal("Cannot create attachment directory '%s'" % dest_dir)
-        elif not os.path.isdir(dest_dir):
-            script.fatal("'%s' is not a directory" % dest_dir)
-
-        shutil.copyfile(source_file, dest_file)
-        script.log('Writing "%s"...' % dest_url)
-        return dest_url
-    else:
-        return ""
-
-
-class PluginScript(script.MoinScript):
-    """\
-Purpose:
-========
-This tool allows you to dump MoinMoin wiki pages to static HTML files.
-
-Detailed Instructions:
-======================
-General syntax: moin [options] export dump [dump-options]
-
-[options] usually should be:
-    --config-dir=/path/to/my/cfg/ --wiki-url=wiki.example.org/
-
-[dump-options] see below:
-    0. You must run this script as owner of the wiki files, usually this is the
-       web server user.
-
-    1. To dump all the pages on the wiki to the directory '/mywiki'
-       moin ... export dump --target-dir=/mywiki
-
-    2. To dump all the pages readable by 'JohnSmith' on the wiki to the directory
-       '/mywiki'
-       moin ... export dump --target-dir=/mywiki --username JohnSmith
-"""
-
-    def __init__(self, argv=None, def_values=None):
-        script.MoinScript.__init__(self, argv, def_values)
-        self.parser.add_option(
-            "-t", "--target-dir", dest = "target_dir",
-            help = "Write html dump to DIRECTORY"
-        )
-        self.parser.add_option(
-            "-u", "--username", dest = "dump_user",
-            help = "User the dump will be performed as (for ACL checks, etc)"
-        )
-
-    def mainloop(self):
-        """ moin-dump's main code. """
-
-        # Prepare output directory
-        if not self.options.target_dir:
-            script.fatal("you must use --target-dir=/your/output/path to specify the directory we write the html files to")
-        outputdir = os.path.abspath(self.options.target_dir)
-        try:
-            os.mkdir(outputdir)
-            script.log("Created output directory '%s'!" % outputdir)
-        except OSError, err:
-            if err.errno != errno.EEXIST:
-                script.fatal("Cannot create output directory '%s'!" % outputdir)
-
-        # Insert config dir or the current directory to the start of the path.
-        config_dir = self.options.config_dir
-        if config_dir and os.path.isfile(config_dir):
-            config_dir = os.path.dirname(config_dir)
-        if config_dir and not os.path.isdir(config_dir):
-            script.fatal("bad path given to --config-dir option")
-        sys.path.insert(0, os.path.abspath(config_dir or os.curdir))
-
-        self.init_request()
-        request = self.request
-
-        # fix url_prefix_static so we get relative paths in output html
-        request.cfg.url_prefix_static = url_prefix_static
-
-        # use this user for permissions checks
-        request.user = user.User(request, name=self.options.dump_user)
-
-        pages = request.rootpage.getPageList(user='') # get list of all pages in wiki
-        pages.sort()
-        if self.options.page: # did user request a particular page or group of pages?
-            try:
-                namematch = re.compile(self.options.page)
-                pages = [page for page in pages if namematch.match(page)]
-                if not pages:
-                    pages = [self.options.page]
-            except:
-                pages = [self.options.page]
-
-        wikiutil.quoteWikinameURL = lambda pagename, qfn=wikiutil.quoteWikinameFS: (qfn(pagename) + HTML_SUFFIX)
-
-        AttachFile.getAttachUrl = lambda pagename, filename, request, **kw: _attachment(request, pagename, filename, outputdir, **kw)
-
-        errfile = os.path.join(outputdir, 'error.log')
-        errlog = open(errfile, 'w')
-        errcnt = 0
-
-        page_front_page = wikiutil.getLocalizedPage(request, request.cfg.page_front_page).page_name
-        page_title_index = wikiutil.getLocalizedPage(request, 'TitleIndex').page_name
-        page_word_index = wikiutil.getLocalizedPage(request, 'WordIndex').page_name
-
-        navibar_html = ''
-        for p in [page_front_page, page_title_index, page_word_index]:
-            navibar_html += '[<a href="%s">%s</a>]&nbsp;' % (wikiutil.quoteWikinameURL(p), wikiutil.escape(p))
-
-        urlbase = request.url # save wiki base url
-        for pagename in pages:
-            # we have the same name in URL and FS
-            file = wikiutil.quoteWikinameURL(pagename)
-            script.log('Writing "%s"...' % file)
-            try:
-                pagehtml = ''
-                request.url = urlbase + pagename # add current pagename to url base
-                page = Page.Page(request, pagename)
-                request.page = page
-                try:
-                    request.reset()
-                    pagehtml = request.redirectedOutput(page.send_page, count_hit=0, content_only=1)
-                except:
-                    errcnt = errcnt + 1
-                    print >> sys.stderr, "*** Caught exception while writing page!"
-                    print >> errlog, "~" * 78
-                    print >> errlog, file # page filename
-                    import traceback
-                    traceback.print_exc(None, errlog)
-            finally:
-                timestamp = time.strftime("%Y-%m-%d %H:%M")
-                filepath = os.path.join(outputdir, file)
-                fileout = codecs.open(filepath, 'w', config.charset)
-                fileout.write(page_template % {
-                    'charset': config.charset,
-                    'pagename': pagename,
-                    'pagehtml': pagehtml,
-                    'logo_html': logo_html,
-                    'navibar_html': navibar_html,
-                    'timestamp': timestamp,
-                    'theme': request.cfg.theme_default,
-                })
-                fileout.close()
-
-        # copy FrontPage to "index.html"
-        indexpage = page_front_page
-        if self.options.page:
-            indexpage = pages[0] # index page has limited use when dumping specific pages, but create one anyway
-        shutil.copyfile(
-            os.path.join(outputdir, wikiutil.quoteWikinameFS(indexpage) + HTML_SUFFIX),
-            os.path.join(outputdir, 'index' + HTML_SUFFIX)
-        )
-
-        errlog.close()
-        if errcnt:
-            print >> sys.stderr, "*** %d error(s) occurred, see '%s'!" % (errcnt, errfile)
-
diff --git a/wiki-lenny/share/security.__init__.orig.py b/wiki-lenny/share/security.__init__.orig.py
deleted file mode 100644
index dd2e0b04..00000000
--- a/wiki-lenny/share/security.__init__.orig.py
+++ /dev/null
@@ -1,454 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - Wiki Security Interface and Access Control Lists
-
-
-    This implements the basic interface for user permissions and
-    system policy. If you want to define your own policy, inherit
-    from the base class 'Permissions', so that when new permissions
-    are defined, you get the defaults.
-
-    Then assign your new class to "SecurityPolicy" in wikiconfig;
-    and I mean the class, not an instance of it!
-
-    @copyright: 2000-2004 Juergen Hermann <jh@web.de>,
-                2003-2008 MoinMoin:ThomasWaldmann,
-                2003 Gustavo Niemeyer,
-                2005 Oliver Graf,
-                2007 Alexander Schremmer
-    @license: GNU GPL, see COPYING for details.
-"""
-
-import re
-
-from MoinMoin import wikiutil, user
-from MoinMoin.Page import Page
-
-#############################################################################
-### Basic Permissions Interface -- most features enabled by default
-#############################################################################
-
-def _check(request, pagename, username, right):
-    """ Check <right> access permission for user <username> on page <pagename>
-
-    For cfg.acl_hierarchic=False we just check the page in question.
-
-    For cfg.acl_hierarchic=True we, we check each page in the hierarchy. We
-    start with the deepest page and recurse to the top of the tree.
-    If one of those permits, True is returned.
-
-    For both configurations, we check acl_rights_before before the page/default
-    acl and acl_rights_after after the page/default acl, of course.
-
-    This method should not be called by users, use __getattr__ instead.
-
-    @param request: the current request object
-    @param pagename: pagename to get permissions from
-    @param username: the user name
-    @param right: the right to check
-
-    @rtype: bool
-    @return: True if you have permission or False
-    """
-    cache = request.cfg.cache
-    allowed = cache.acl_rights_before.may(request, username, right)
-    if allowed is not None:
-        return allowed
-
-    if request.cfg.acl_hierarchic:
-        pages = pagename.split('/') # create page hierarchy list
-        some_acl = False
-        for i in range(len(pages), 0, -1):
-            # Create the next pagename in the hierarchy
-            # starting at the leaf, going to the root
-            name = '/'.join(pages[:i])
-            # Get page acl and ask for permission
-            acl = Page(request, name).getACL(request)
-            if acl.acl:
-                some_acl = True
-                allowed = acl.may(request, username, right)
-                if allowed is not None:
-                    return allowed
-        if not some_acl:
-            allowed = cache.acl_rights_default.may(request, username, right)
-            if allowed is not None:
-                return allowed
-    else:
-        if request.page is not None and pagename == request.page.page_name:
-            p = request.page # reuse is good
-        else:
-            p = Page(request, pagename)
-        acl = p.getACL(request) # this will be fast in a reused page obj
-        allowed = acl.may(request, username, right)
-        if allowed is not None:
-            return allowed
-
-    allowed = cache.acl_rights_after.may(request, username, right)
-    if allowed is not None:
-        return allowed
-
-    return False
-
-
-class Permissions:
-    """ Basic interface for user permissions and system policy.
-
-    Note that you still need to allow some of the related actions, this
-    just controls their behavior, not their activation.
-
-    When sub classing this class, you must extend the class methods, not
-    replace them, or you might break the acl in the wiki. Correct sub
-    classing looks like this:
-
-    def read(self, pagename):
-        # Your special security rule
-        if something:
-            return false
-
-        # Do not return True or you break acl!
-        # This call will use the default acl rules
-        return Permissions.read(pagename)
-    """
-
-    def __init__(self, user):
-        self.name = user.name
-        self.request = user._request
-
-    def save(self, editor, newtext, rev, **kw):
-        """ Check whether user may save a page.
-
-        `editor` is the PageEditor instance, the other arguments are
-        those of the `PageEditor.saveText` method.
-
-        @param editor: PageEditor instance.
-        @param newtext: new page text, you can enable of disable saving according
-            to the content of the text, e.g. prevent link spam.
-        @param rev: new revision number? XXX
-        @param kw: XXX
-        @rtype: bool
-        @return: True if you can save or False
-        """
-        return self.write(editor.page_name)
-
-    def __getattr__(self, attr):
-        """ Shortcut to export getPermission function for all known ACL rights
-
-        if attr is one of the rights in acl_rights_valid, then return a
-        checking function for it. Else raise an AttributeError.
-
-        @param attr: one of ACL rights as defined in acl_rights_valid
-        @rtype: function
-        @return: checking function for that right, accepting a pagename
-        """
-        request = self.request
-        if attr not in request.cfg.acl_rights_valid:
-            raise AttributeError, attr
-        return lambda pagename: _check(self.request, pagename, self.name, attr)
-
-
-# make an alias for the default policy
-Default = Permissions
-
-
-class AccessControlList:
-    ''' Access Control List
-
-    Control who may do what on or with a wiki page.
-
-    Syntax of an ACL string:
-
-        [+|-]User[,User,...]:[right[,right,...]] [[+|-]SomeGroup:...] ...
-        ... [[+|-]Known:...] [[+|-]All:...]
-
-        "User" is a user name and triggers only if the user matches. Up
-        to version 1.2 only WikiNames were supported, as of version 1.3,
-        any name can be used in acl lines, including name with spaces
-        using esoteric languages.
-
-        "SomeGroup" is a page name matching cfg.page_group_regex with
-         some lines in the form " * Member", defining the group members.
-
-        "Known" is a group containing all valid / known users.
-
-        "All" is a group containing all users (Known and Anonymous users).
-
-        "right" may be an arbitrary word like read, write, delete, admin.
-        Only words in cfg.acl_validrights are accepted, others are
-        ignored. It is allowed to specify no rights, which means that no
-        rights are given.
-
-    How ACL is processed
-
-        When some user is trying to access some ACL-protected resource,
-        the ACLs will be processed in the order they are found. The first
-        matching ACL will tell if the user has access to that resource
-        or not.
-
-        For example, the following ACL tells that SomeUser is able to
-        read and write the resources protected by that ACL, while any
-        member of SomeGroup (besides SomeUser, if part of that group)
-        may also admin that, and every other user is able to read it.
-
-            SomeUser:read,write SomeGroup:read,write,admin All:read
-
-        In this example, SomeUser can read and write but can not admin,
-        revert or delete pages. Rights that are NOT specified on the
-        right list are automatically set to NO.
-
-    Using Prefixes
-
-        To make the system more flexible, there are also two modifiers:
-        the prefixes "+" and "-".
-
-            +SomeUser:read -OtherUser:write
-
-        The acl line above will grant SomeUser read right, and OtherUser
-        write right, but will NOT block automatically all other rights
-        for these users. For example, if SomeUser ask to write, the
-        above acl line does not define if he can or can not write. He
-        will be able to write if acl_rights_before or acl_rights_after
-        allow this (see configuration options).
-
-        Using prefixes, this acl line:
-
-            SomeUser:read,write SomeGroup:read,write,admin All:read
-
-        Can be written as:
-
-            -SomeUser:admin SomeGroup:read,write,admin All:read
-
-        Or even:
-
-            +All:read -SomeUser:admin SomeGroup:read,write,admin
-
-        Notice that you probably will not want to use the second and
-        third examples in ACL entries of some page. They are very
-        useful on the moin configuration entries though.
-
-   Configuration options
-
-       cfg.acl_rights_default
-           It is is ONLY used when no other ACLs are given.
-           Default: "Known:read,write,delete All:read,write",
-
-       cfg.acl_rights_before
-           When the page has ACL entries, this will be inserted BEFORE
-           any page entries.
-           Default: ""
-
-       cfg.acl_rights_after
-           When the page has ACL entries, this will be inserted AFTER
-           any page entries.
-           Default: ""
-
-       cfg.acl_rights_valid
-           These are the acceptable (known) rights (and the place to
-           extend, if necessary).
-           Default: ["read", "write", "delete", "admin"]
-    '''
-
-    special_users = ["All", "Known", "Trusted"] # order is important
-
-    def __init__(self, cfg, lines=[]):
-        """Initialize an ACL, starting from <nothing>.
-        """
-        if lines:
-            self.acl = [] # [ ('User', {"read": 0, ...}), ... ]
-            self.acl_lines = []
-            for line in lines:
-                self._addLine(cfg, line)
-        else:
-            self.acl = None
-            self.acl_lines = None
-
-    def _addLine(self, cfg, aclstring, remember=1):
-        """ Add another ACL line
-
-        This can be used in multiple subsequent calls to process longer lists.
-
-        @param cfg: current config
-        @param aclstring: acl string from page or cfg
-        @param remember: should add the line to self.acl_lines
-        """
-
-        # Remember lines
-        if remember:
-            self.acl_lines.append(aclstring)
-
-        # Iterate over entries and rights, parsed by acl string iterator
-        acliter = ACLStringIterator(cfg.acl_rights_valid, aclstring)
-        for modifier, entries, rights in acliter:
-            if entries == ['Default']:
-                self._addLine(cfg, cfg.acl_rights_default, remember=0)
-            else:
-                for entry in entries:
-                    rightsdict = {}
-                    if modifier:
-                        # Only user rights are added to the right dict.
-                        # + add rights with value of 1
-                        # - add right with value of 0
-                        for right in rights:
-                            rightsdict[right] = (modifier == '+')
-                    else:
-                        # All rights from acl_rights_valid are added to the
-                        # dict, user rights with value of 1, and other with
-                        # value of 0
-                        for right in cfg.acl_rights_valid:
-                            rightsdict[right] = (right in rights)
-                    self.acl.append((entry, rightsdict))
-
-    def may(self, request, name, dowhat):
-        """ May <name> <dowhat>? Returns boolean answer.
-
-            Note: this check does NOT include the acl_rights_before / _after ACL,
-                  but it WILL use acl_rights_default if there is no (page) ACL.
-        """
-        if self.acl is None: # no #acl used on Page
-            acl = request.cfg.cache.acl_rights_default.acl
-        else: # we have a #acl on the page (self.acl can be [] if #acl is empty!)
-            acl = self.acl
-        is_group_member = request.dicts.has_member
-        group_re = request.cfg.cache.page_group_regexact
-        allowed = None
-        for entry, rightsdict in acl:
-            if entry in self.special_users:
-                handler = getattr(self, "_special_"+entry, None)
-                allowed = handler(request, name, dowhat, rightsdict)
-            elif group_re.search(entry):
-                if is_group_member(entry, name):
-                    allowed = rightsdict.get(dowhat)
-                else:
-                    for special in self.special_users:
-                        if is_group_member(entry, special):
-                            handler = getattr(self, "_special_" + special, None)
-                            allowed = handler(request, name, dowhat, rightsdict)
-                            break # order of self.special_users is important
-            elif entry == name:
-                allowed = rightsdict.get(dowhat)
-            if allowed is not None:
-                return allowed
-        return allowed # should be None
-
-    def getString(self, b='#acl ', e='\n'):
-        """print the acl strings we were fed with"""
-        if self.acl_lines:
-            acl_lines = ''.join(["%s%s%s" % (b, l, e) for l in self.acl_lines])
-        else:
-            acl_lines = ''
-        return acl_lines
-
-    def _special_All(self, request, name, dowhat, rightsdict):
-        return rightsdict.get(dowhat)
-
-    def _special_Known(self, request, name, dowhat, rightsdict):
-        """ check if user <name> is known to us,
-            that means that there is a valid user account present.
-            works for subscription emails.
-        """
-        if user.getUserId(request, name): # is a user with this name known?
-            return rightsdict.get(dowhat)
-        return None
-
-    def _special_Trusted(self, request, name, dowhat, rightsdict):
-        """ check if user <name> is known AND has logged in using a trusted
-            authentication method.
-            Does not work for subsription emails that should be sent to <user>,
-            as he is not logged in in that case.
-        """
-        if (request.user.name == name and
-            request.user.auth_method in request.cfg.auth_methods_trusted):
-            return rightsdict.get(dowhat)
-        return None
-
-    def __eq__(self, other):
-        return self.acl_lines == other.acl_lines
-
-    def __ne__(self, other):
-        return self.acl_lines != other.acl_lines
-
-
-class ACLStringIterator:
-    """ Iterator for acl string
-
-    Parse acl string and return the next entry on each call to
-    next. Implement the Iterator protocol.
-
-    Usage:
-        iter = ACLStringIterator(cfg.acl_rights_valid, 'user name:right')
-        for modifier, entries, rights in iter:
-            # process data
-    """
-
-    def __init__(self, rights, aclstring):
-        """ Initialize acl iterator
-
-        @param rights: the acl rights to consider when parsing
-        @param aclstring: string to parse
-        """
-        self.rights = rights
-        self.rest = aclstring.strip()
-        self.finished = 0
-
-    def __iter__(self):
-        """ Required by the Iterator protocol """
-        return self
-
-    def next(self):
-        """ Return the next values from the acl string
-
-        When the iterator is finished and you try to call next, it
-        raises a StopIteration. The iterator finish as soon as the
-        string is fully parsed or can not be parsed any more.
-
-        @rtype: 3 tuple - (modifier, [entry, ...], [right, ...])
-        @return: values for one item in an acl string
-        """
-        # Handle finished state, required by iterator protocol
-        if self.rest == '':
-            self.finished = 1
-        if self.finished:
-            raise StopIteration
-
-        # Get optional modifier [+|-]entries:rights
-        modifier = ''
-        if self.rest[0] in ('+', '-'):
-            modifier, self.rest = self.rest[0], self.rest[1:]
-
-        # Handle the Default meta acl
-        if self.rest.startswith('Default ') or self.rest == 'Default':
-            self.rest = self.rest[8:]
-            entries, rights = ['Default'], []
-
-        # Handle entries:rights pairs
-        else:
-            # Get entries
-            try:
-                entries, self.rest = self.rest.split(':', 1)
-            except ValueError:
-                self.finished = 1
-                raise StopIteration("Can't parse rest of string")
-            if entries == '':
-                entries = []
-            else:
-                # TODO strip each entry from blanks?
-                entries = entries.split(',')
-
-            # Get rights
-            try:
-                rights, self.rest = self.rest.split(' ', 1)
-                # Remove extra white space after rights fragment,
-                # allowing using multiple spaces between items.
-                self.rest = self.rest.lstrip()
-            except ValueError:
-                rights, self.rest = self.rest, ''
-            rights = [r for r in rights.split(',') if r in self.rights]
-
-        return modifier, entries, rights
-
-
-def parseACL(request, text):
-    """ Parse acl lines from text and return ACL object """
-    pi, dummy = wikiutil.get_processing_instructions(text)
-    acl_lines = [args for verb, args in pi if verb == 'acl']
-    return AccessControlList(request.cfg, acl_lines)
-
diff --git a/wiki-lenny/share/security.__init__.py b/wiki-lenny/share/security.__init__.py
deleted file mode 100644
index 38882c79..00000000
--- a/wiki-lenny/share/security.__init__.py
+++ /dev/null
@@ -1,501 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - Wiki Security Interface and Access Control Lists
-
-
-    This implements the basic interface for user permissions and
-    system policy. If you want to define your own policy, inherit
-    from the base class 'Permissions', so that when new permissions
-    are defined, you get the defaults.
-
-    Then assign your new class to "SecurityPolicy" in wikiconfig;
-    and I mean the class, not an instance of it!
-
-    @copyright: 2000-2004 Juergen Hermann <jh@web.de>,
-                2003-2008 MoinMoin:ThomasWaldmann,
-                2003 Gustavo Niemeyer,
-                2005 Oliver Graf,
-                2007 Alexander Schremmer
-    @license: GNU GPL, see COPYING for details.
-"""
-
-import re
-
-from MoinMoin import wikiutil, user
-from MoinMoin.Page import Page
-
-### HACK SAUVAGE 1/5
-import sys
-sys.path.append('/usr/scripts/gestion/')
-from iptools import is_crans
-### FIN HACK 1/5
-
-#############################################################################
-### Basic Permissions Interface -- most features enabled by default
-#############################################################################
-
-def _check(request, pagename, username, right):
-    """ Check <right> access permission for user <username> on page <pagename>
-
-    For cfg.acl_hierarchic=False we just check the page in question.
-
-    For cfg.acl_hierarchic=True we, we check each page in the hierarchy. We
-    start with the deepest page and recurse to the top of the tree.
-    If one of those permits, True is returned.
-
-    For both configurations, we check acl_rights_before before the page/default
-    acl and acl_rights_after after the page/default acl, of course.
-
-    This method should not be called by users, use __getattr__ instead.
-
-    @param request: the current request object
-    @param pagename: pagename to get permissions from
-    @param username: the user name
-    @param right: the right to check
-
-    @rtype: bool
-    @return: True if you have permission or False
-    """
-    cache = request.cfg.cache
-    allowed = cache.acl_rights_before.may(request, username, right)
-    if allowed is not None:
-        return allowed
-
-    if request.cfg.acl_hierarchic:
-        pages = pagename.split('/') # create page hierarchy list
-        some_acl = False
-        for i in range(len(pages), 0, -1):
-            # Create the next pagename in the hierarchy
-            # starting at the leaf, going to the root
-            name = '/'.join(pages[:i])
-            # Get page acl and ask for permission
-            acl = Page(request, name).getACL(request)
-            if acl.acl:
-                some_acl = True
-                allowed = acl.may(request, username, right)
-                if allowed is not None:
-                    return allowed
-        if not some_acl:
-            allowed = cache.acl_rights_default.may(request, username, right)
-            if allowed is not None:
-                return allowed
-    else:
-        if request.page is not None and pagename == request.page.page_name:
-            p = request.page # reuse is good
-        else:
-            p = Page(request, pagename)
-        acl = p.getACL(request) # this will be fast in a reused page obj
-        allowed = acl.may(request, username, right)
-        if allowed is not None:
-            return allowed
-
-    allowed = cache.acl_rights_after.may(request, username, right)
-    if allowed is not None:
-        return allowed
-
-    return False
-
-
-class Permissions:
-    """ Basic interface for user permissions and system policy.
-
-    Note that you still need to allow some of the related actions, this
-    just controls their behavior, not their activation.
-
-    When sub classing this class, you must extend the class methods, not
-    replace them, or you might break the acl in the wiki. Correct sub
-    classing looks like this:
-
-    def read(self, pagename):
-        # Your special security rule
-        if something:
-            return false
-
-        # Do not return True or you break acl!
-        # This call will use the default acl rules
-        return Permissions.read(pagename)
-    """
-
-    def __init__(self, user):
-        self.name = user.name
-        self.request = user._request
-
-    def save(self, editor, newtext, rev, **kw):
-        """ Check whether user may save a page.
-
-        `editor` is the PageEditor instance, the other arguments are
-        those of the `PageEditor.saveText` method.
-
-        @param editor: PageEditor instance.
-        @param newtext: new page text, you can enable of disable saving according
-            to the content of the text, e.g. prevent link spam.
-        @param rev: new revision number? XXX
-        @param kw: XXX
-        @rtype: bool
-        @return: True if you can save or False
-        """
-        return self.write(editor.page_name)
-
-    def __getattr__(self, attr):
-        """ Shortcut to export getPermission function for all known ACL rights
-
-        if attr is one of the rights in acl_rights_valid, then return a
-        checking function for it. Else raise an AttributeError.
-
-        @param attr: one of ACL rights as defined in acl_rights_valid
-        @rtype: function
-        @return: checking function for that right, accepting a pagename
-        """
-        request = self.request
-        if attr not in request.cfg.acl_rights_valid:
-            raise AttributeError, attr
-        return lambda pagename: _check(self.request, pagename, self.name, attr)
-
-
-# make an alias for the default policy
-Default = Permissions
-
-
-class AccessControlList:
-    ''' Access Control List
-
-    Control who may do what on or with a wiki page.
-
-    Syntax of an ACL string:
-
-        [+|-]User[,User,...]:[right[,right,...]] [[+|-]SomeGroup:...] ...
-        ... [[+|-]Known:...] [[+|-]All:...]
-
-        "User" is a user name and triggers only if the user matches. Up
-        to version 1.2 only WikiNames were supported, as of version 1.3,
-        any name can be used in acl lines, including name with spaces
-        using esoteric languages.
-
-        "SomeGroup" is a page name matching cfg.page_group_regex with
-         some lines in the form " * Member", defining the group members.
-
-        "Known" is a group containing all valid / known users.
-
-        "All" is a group containing all users (Known and Anonymous users).
-
-        "right" may be an arbitrary word like read, write, delete, admin.
-        Only words in cfg.acl_validrights are accepted, others are
-        ignored. It is allowed to specify no rights, which means that no
-        rights are given.
-
-    How ACL is processed
-
-        When some user is trying to access some ACL-protected resource,
-        the ACLs will be processed in the order they are found. The first
-        matching ACL will tell if the user has access to that resource
-        or not.
-
-        For example, the following ACL tells that SomeUser is able to
-        read and write the resources protected by that ACL, while any
-        member of SomeGroup (besides SomeUser, if part of that group)
-        may also admin that, and every other user is able to read it.
-
-            SomeUser:read,write SomeGroup:read,write,admin All:read
-
-        In this example, SomeUser can read and write but can not admin,
-        revert or delete pages. Rights that are NOT specified on the
-        right list are automatically set to NO.
-
-    Using Prefixes
-
-        To make the system more flexible, there are also two modifiers:
-        the prefixes "+" and "-".
-
-            +SomeUser:read -OtherUser:write
-
-        The acl line above will grant SomeUser read right, and OtherUser
-        write right, but will NOT block automatically all other rights
-        for these users. For example, if SomeUser ask to write, the
-        above acl line does not define if he can or can not write. He
-        will be able to write if acl_rights_before or acl_rights_after
-        allow this (see configuration options).
-
-        Using prefixes, this acl line:
-
-            SomeUser:read,write SomeGroup:read,write,admin All:read
-
-        Can be written as:
-
-            -SomeUser:admin SomeGroup:read,write,admin All:read
-
-        Or even:
-
-            +All:read -SomeUser:admin SomeGroup:read,write,admin
-
-        Notice that you probably will not want to use the second and
-        third examples in ACL entries of some page. They are very
-        useful on the moin configuration entries though.
-
-   Configuration options
-
-       cfg.acl_rights_default
-           It is is ONLY used when no other ACLs are given.
-           Default: "Known:read,write,delete All:read,write",
-
-       cfg.acl_rights_before
-           When the page has ACL entries, this will be inserted BEFORE
-           any page entries.
-           Default: ""
-
-       cfg.acl_rights_after
-           When the page has ACL entries, this will be inserted AFTER
-           any page entries.
-           Default: ""
-
-       cfg.acl_rights_valid
-           These are the acceptable (known) rights (and the place to
-           extend, if necessary).
-           Default: ["read", "write", "delete", "admin"]
-    '''
-
-    #special_users = ["All", "Known", "Trusted"] # order is important
-    ### HACK SAUVAGE 2/5
-    special_users = ["All", "Known", "Trusted", "Crans", "NoCrans"] # order is important
-    ### FIN HACK 2/5
-
-    def __init__(self, cfg, lines=[]):
-        """Initialize an ACL, starting from <nothing>.
-        """
-        if lines:
-            self.acl = [] # [ ('User', {"read": 0, ...}), ... ]
-            self.acl_lines = []
-            for line in lines:
-                self._addLine(cfg, line)
-        else:
-            self.acl = None
-            self.acl_lines = None
-
-    def _addLine(self, cfg, aclstring, remember=1):
-        """ Add another ACL line
-
-        This can be used in multiple subsequent calls to process longer lists.
-
-        @param cfg: current config
-        @param aclstring: acl string from page or cfg
-        @param remember: should add the line to self.acl_lines
-        """
-
-        # Remember lines
-        if remember:
-            self.acl_lines.append(aclstring)
-
-        # Iterate over entries and rights, parsed by acl string iterator
-        acliter = ACLStringIterator(cfg.acl_rights_valid, aclstring)
-        for modifier, entries, rights in acliter:
-            if entries == ['Default']:
-                self._addLine(cfg, cfg.acl_rights_default, remember=0)
-            else:
-                for entry in entries:
-                    rightsdict = {}
-                    if modifier:
-                        # Only user rights are added to the right dict.
-                        # + add rights with value of 1
-                        # - add right with value of 0
-                        for right in rights:
-                            rightsdict[right] = (modifier == '+')
-                    else:
-                        # All rights from acl_rights_valid are added to the
-                        # dict, user rights with value of 1, and other with
-                        # value of 0
-                        for right in cfg.acl_rights_valid:
-                            rightsdict[right] = (right in rights)
-                    self.acl.append((entry, rightsdict))
-
-    def may(self, request, name, dowhat):
-        """ May <name> <dowhat>? Returns boolean answer.
-
-            Note: this check does NOT include the acl_rights_before / _after ACL,
-                  but it WILL use acl_rights_default if there is no (page) ACL.
-        """
-        if self.acl is None: # no #acl used on Page
-            acl = request.cfg.cache.acl_rights_default.acl
-        else: # we have a #acl on the page (self.acl can be [] if #acl is empty!)
-            acl = self.acl
-        is_group_member = request.dicts.has_member
-        group_re = request.cfg.cache.page_group_regexact
-        allowed = None
-        for entry, rightsdict in acl:
-            if entry in self.special_users:
-                handler = getattr(self, "_special_"+entry, None)
-                allowed = handler(request, name, dowhat, rightsdict)
-            elif group_re.search(entry):
-                if is_group_member(entry, name):
-                    allowed = rightsdict.get(dowhat)
-                else:
-                    for special in self.special_users:
-                        if is_group_member(entry, special):
-                            handler = getattr(self, "_special_" + special, None)
-                            allowed = handler(request, name, dowhat, rightsdict)
-                            break # order of self.special_users is important
-            elif entry == name:
-                allowed = rightsdict.get(dowhat)
-            if allowed is not None:
-                return allowed
-        return allowed # should be None
-
-    def getString(self, b='#acl ', e='\n'):
-        """print the acl strings we were fed with"""
-        if self.acl_lines:
-            acl_lines = ''.join(["%s%s%s" % (b, l, e) for l in self.acl_lines])
-        else:
-            acl_lines = ''
-        return acl_lines
-
-    def _special_All(self, request, name, dowhat, rightsdict):
-        ### HACK SAUVAGE 3/5
-        if dowhat == "read" and is_page_public(request):
-            return True
-        ### FIN HACK 3/5
-        return rightsdict.get(dowhat)
-
-    def _special_Known(self, request, name, dowhat, rightsdict):
-        """ check if user <name> is known to us,
-            that means that there is a valid user account present.
-            works for subscription emails.
-        """
-        if user.getUserId(request, name): # is a user with this name known?
-            return rightsdict.get(dowhat)
-        return None
-
-    def _special_Trusted(self, request, name, dowhat, rightsdict):
-        """ check if user <name> is known AND has logged in using a trusted
-            authentication method.
-            Does not work for subsription emails that should be sent to <user>,
-            as he is not logged in in that case.
-        """
-        if (request.user.name == name and
-            request.user.auth_method in request.cfg.auth_methods_trusted):
-            return rightsdict.get(dowhat)
-        return None
-
-    ### HACK SAUVAGE 4/5
-    def _requete_interne(self, request):
-        try:
-            if is_crans(request.remote_addr):
-                return True
-        except:
-            pass
-
-        return False
-
-    def _special_Crans(self, request, name, dowhat, rightsdict):
-        if self._requete_interne(request):
-            return rightsdict.get(dowhat)
-        return None
-
-    def _special_NoCrans(self, request, name, dowhat, rightsdict):
-        if dowhat == "read" and is_page_public(request):
-            return True
-        if not self._requete_interne(request):
-            return rightsdict.get(dowhat)
-        return None
-    ### FIN HACK 4/5
-
-    def __eq__(self, other):
-        return self.acl_lines == other.acl_lines
-
-    def __ne__(self, other):
-        return self.acl_lines != other.acl_lines
-
-
-class ACLStringIterator:
-    """ Iterator for acl string
-
-    Parse acl string and return the next entry on each call to
-    next. Implement the Iterator protocol.
-
-    Usage:
-        iter = ACLStringIterator(cfg.acl_rights_valid, 'user name:right')
-        for modifier, entries, rights in iter:
-            # process data
-    """
-
-    def __init__(self, rights, aclstring):
-        """ Initialize acl iterator
-
-        @param rights: the acl rights to consider when parsing
-        @param aclstring: string to parse
-        """
-        self.rights = rights
-        self.rest = aclstring.strip()
-        self.finished = 0
-
-    def __iter__(self):
-        """ Required by the Iterator protocol """
-        return self
-
-    def next(self):
-        """ Return the next values from the acl string
-
-        When the iterator is finished and you try to call next, it
-        raises a StopIteration. The iterator finish as soon as the
-        string is fully parsed or can not be parsed any more.
-
-        @rtype: 3 tuple - (modifier, [entry, ...], [right, ...])
-        @return: values for one item in an acl string
-        """
-        # Handle finished state, required by iterator protocol
-        if self.rest == '':
-            self.finished = 1
-        if self.finished:
-            raise StopIteration
-
-        # Get optional modifier [+|-]entries:rights
-        modifier = ''
-        if self.rest[0] in ('+', '-'):
-            modifier, self.rest = self.rest[0], self.rest[1:]
-
-        # Handle the Default meta acl
-        if self.rest.startswith('Default ') or self.rest == 'Default':
-            self.rest = self.rest[8:]
-            entries, rights = ['Default'], []
-
-        # Handle entries:rights pairs
-        else:
-            # Get entries
-            try:
-                entries, self.rest = self.rest.split(':', 1)
-            except ValueError:
-                self.finished = 1
-                raise StopIteration("Can't parse rest of string")
-            if entries == '':
-                entries = []
-            else:
-                # TODO strip each entry from blanks?
-                entries = entries.split(',')
-
-            # Get rights
-            try:
-                rights, self.rest = self.rest.split(' ', 1)
-                # Remove extra white space after rights fragment,
-                # allowing using multiple spaces between items.
-                self.rest = self.rest.lstrip()
-            except ValueError:
-                rights, self.rest = self.rest, ''
-            rights = [r for r in rights.split(',') if r in self.rights]
-
-        return modifier, entries, rights
-
-
-def parseACL(request, text):
-    """ Parse acl lines from text and return ACL object """
-    pi, dummy = wikiutil.get_processing_instructions(text)
-    acl_lines = [args for verb, args in pi if verb == 'acl']
-    return AccessControlList(request.cfg, acl_lines)
-
-### HACK SAUVAGE 5/5
-def is_page_public(request):
-    #return True
-    ## On recherche si la page est publique
-    this_page = request.page.page_name
-    categories = request.page.getCategories(request)
-    if u'CatégoriePagePublique' in categories:
-        return True
-    else:
-        return None
-### FIN HACK 5/5
diff --git a/wiki-lenny/share/user.orig.py b/wiki-lenny/share/user.orig.py
deleted file mode 100644
index 8d9918b2..00000000
--- a/wiki-lenny/share/user.orig.py
+++ /dev/null
@@ -1,1094 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - User Accounts
-
-    This module contains functions to access user accounts (list all users, get
-    some specific user). User instances are used to access the user profile of
-    some specific user (name, password, email, bookmark, trail, settings, ...).
-
-    Some related code is in the userform and userprefs modules.
-
-    TODO:
-    * code is a mixture of highlevel user stuff and lowlevel storage functions,
-      this has to get separated into:
-      * user object highlevel stuff
-      * storage code
-
-    @copyright: 2000-2004 Juergen Hermann <jh@web.de>,
-                2003-2007 MoinMoin:ThomasWaldmann
-    @license: GNU GPL, see COPYING for details.
-"""
-
-# add names here to hide them in the cgitb traceback
-unsafe_names = ("id", "key", "val", "user_data", "enc_password", "recoverpass_key")
-
-import os, time, sha, codecs, hmac
-
-from MoinMoin import config, caching, wikiutil, i18n, events
-from MoinMoin.util import timefuncs, filesys, random_string
-from MoinMoin.wikiutil import url_quote_plus
-
-
-def getUserList(request):
-    """ Get a list of all (numerical) user IDs.
-
-    @param request: current request
-    @rtype: list
-    @return: all user IDs
-    """
-    import re
-    user_re = re.compile(r'^\d+\.\d+(\.\d+)?$')
-    files = filesys.dclistdir(request.cfg.user_dir)
-    userlist = [f for f in files if user_re.match(f)]
-    return userlist
-
-def get_by_filter(request, filter_func):
-    """ Searches for an user with a given filter function """
-    for uid in getUserList(request):
-        theuser = User(request, uid)
-        if filter_func(theuser):
-            return theuser
-
-def get_by_email_address(request, email_address):
-    """ Searches for an user with a particular e-mail address and returns it. """
-    filter_func = lambda user: user.valid and user.email.lower() == email_address.lower()
-    return get_by_filter(request, filter_func)
-
-def get_by_jabber_id(request, jabber_id):
-    """ Searches for an user with a perticular jabber id and returns it. """
-    filter_func = lambda user: user.valid and user.jid.lower() == jabber_id.lower()
-    return get_by_filter(request, filter_func)
-
-def _getUserIdByKey(request, key, search):
-    """ Get the user ID for a specified key/value pair.
-
-    This method must only be called for keys that are
-    guaranteed to be unique.
-
-    @param key: the key to look in
-    @param search: the value to look for
-    @return the corresponding user ID or None
-    """
-    if not search or not key:
-        return None
-    cfg = request.cfg
-    cachekey = '%s2id' % key
-    try:
-        _key2id = getattr(cfg.cache, cachekey)
-    except AttributeError:
-        arena = 'user'
-        cache = caching.CacheEntry(request, arena, cachekey, scope='wiki', use_pickle=True)
-        try:
-            _key2id = cache.content()
-        except caching.CacheError:
-            _key2id = {}
-        setattr(cfg.cache, cachekey, _key2id)
-    uid = _key2id.get(search, None)
-    if uid is None:
-        for userid in getUserList(request):
-            u = User(request, id=userid)
-            if hasattr(u, key):
-                value = getattr(u, key)
-                if isinstance(value, list):
-                    for val in value:
-                        _key2id[val] = userid
-                else:
-                    _key2id[value] = userid
-        arena = 'user'
-        cache = caching.CacheEntry(request, arena, cachekey, scope='wiki', use_pickle=True)
-        try:
-            cache.update(_key2id)
-        except caching.CacheError:
-            pass
-        uid = _key2id.get(search, None)
-    return uid
-
-
-def getUserId(request, searchName):
-    """ Get the user ID for a specific user NAME.
-
-    @param searchName: the user name to look up
-    @rtype: string
-    @return: the corresponding user ID or None
-    """
-    return _getUserIdByKey(request, 'name', searchName)
-
-
-def getUserIdByOpenId(request, openid):
-    """ Get the user ID for a specific OpenID.
-
-    @param openid: the openid to look up
-    @rtype: string
-    @return: the corresponding user ID or None
-    """
-    return _getUserIdByKey(request, 'openids', openid)
-
-
-def getUserIdentification(request, username=None):
-    """ Return user name or IP or '<unknown>' indicator.
-
-    @param request: the request object
-    @param username: (optional) user name
-    @rtype: string
-    @return: user name or IP or unknown indicator
-    """
-    _ = request.getText
-
-    if username is None:
-        username = request.user.name
-
-    return username or (request.cfg.show_hosts and request.remote_addr) or _("<unknown>")
-
-
-def encodePassword(pwd, charset='utf-8'):
-    """ Encode a cleartext password
-
-    Compatible to Apache htpasswd SHA encoding.
-
-    When using different encoding than 'utf-8', the encoding might fail
-    and raise UnicodeError.
-
-    @param pwd: the cleartext password, (unicode)
-    @param charset: charset used to encode password, used only for
-        compatibility with old passwords generated on moin-1.2.
-    @rtype: string
-    @return: the password in apache htpasswd compatible SHA-encoding,
-        or None
-    """
-    import base64
-
-    # Might raise UnicodeError, but we can't do anything about it here,
-    # so let the caller handle it.
-    pwd = pwd.encode(charset)
-
-    pwd = sha.new(pwd).digest()
-    pwd = '{SHA}' + base64.encodestring(pwd).rstrip()
-    return pwd
-
-
-def normalizeName(name):
-    """ Make normalized user name
-
-    Prevent impersonating another user with names containing leading,
-    trailing or multiple whitespace, or using invisible unicode
-    characters.
-
-    Prevent creating user page as sub page, because '/' is not allowed
-    in user names.
-
-    Prevent using ':' and ',' which are reserved by acl.
-
-    @param name: user name, unicode
-    @rtype: unicode
-    @return: user name that can be used in acl lines
-    """
-    username_allowedchars = "'@.-_" # ' for names like O'Brian or email addresses.
-                                    # "," and ":" must not be allowed (ACL delimiters).
-                                    # We also allow _ in usernames for nicer URLs.
-    # Strip non alpha numeric characters (except username_allowedchars), keep white space
-    name = ''.join([c for c in name if c.isalnum() or c.isspace() or c in username_allowedchars])
-
-    # Normalize white space. Each name can contain multiple
-    # words separated with only one space.
-    name = ' '.join(name.split())
-
-    return name
-
-
-def isValidName(request, name):
-    """ Validate user name
-
-    @param name: user name, unicode
-    """
-    normalized = normalizeName(name)
-    return (name == normalized) and not wikiutil.isGroupPage(request, name)
-
-
-def encodeList(items):
-    """ Encode list of items in user data file
-
-    Items are separated by '\t' characters.
-
-    @param items: list unicode strings
-    @rtype: unicode
-    @return: list encoded as unicode
-    """
-    line = []
-    for item in items:
-        item = item.strip()
-        if not item:
-            continue
-        line.append(item)
-
-    line = '\t'.join(line)
-    return line
-
-def decodeList(line):
-    """ Decode list of items from user data file
-
-    @param line: line containing list of items, encoded with encodeList
-    @rtype: list of unicode strings
-    @return: list of items in encoded in line
-    """
-    items = []
-    for item in line.split('\t'):
-        item = item.strip()
-        if not item:
-            continue
-        items.append(item)
-    return items
-
-def encodeDict(items):
-    """ Encode dict of items in user data file
-
-    Items are separated by '\t' characters.
-    Each item is key:value.
-
-    @param items: dict of unicode:unicode
-    @rtype: unicode
-    @return: dict encoded as unicode
-    """
-    line = []
-    for key, value in items.items():
-        item = u'%s:%s' % (key, value)
-        line.append(item)
-    line = '\t'.join(line)
-    return line
-
-def decodeDict(line):
-    """ Decode dict of key:value pairs from user data file
-
-    @param line: line containing a dict, encoded with encodeDict
-    @rtype: dict
-    @return: dict  unicode:unicode items
-    """
-    items = {}
-    for item in line.split('\t'):
-        item = item.strip()
-        if not item:
-            continue
-        key, value = item.split(':', 1)
-        items[key] = value
-    return items
-
-
-class User:
-    """ A MoinMoin User """
-
-    def __init__(self, request, id=None, name="", password=None, auth_username="", **kw):
-        """ Initialize User object
-
-        TODO: when this gets refactored, use "uid" not builtin "id"
-
-        @param request: the request object
-        @param id: (optional) user ID
-        @param name: (optional) user name
-        @param password: (optional) user password (unicode)
-        @param auth_username: (optional) already authenticated user name
-                              (e.g. when using http basic auth) (unicode)
-        @keyword auth_method: method that was used for authentication,
-                              default: 'internal'
-        @keyword auth_attribs: tuple of user object attribute names that are
-                               determined by auth method and should not be
-                               changeable by preferences, default: ().
-                               First tuple element was used for authentication.
-        """
-        self._cfg = request.cfg
-        self.valid = 0
-        self.id = id
-        self.auth_username = auth_username
-        self.auth_method = kw.get('auth_method', 'internal')
-        self.auth_attribs = kw.get('auth_attribs', ())
-        self.bookmarks = {} # interwikiname: bookmark
-
-        # create some vars automatically
-        self.__dict__.update(self._cfg.user_form_defaults)
-
-        if name:
-            self.name = name
-        elif auth_username: # this is needed for user_autocreate
-            self.name = auth_username
-
-        # create checkbox fields (with default 0)
-        for key, label in self._cfg.user_checkbox_fields:
-            setattr(self, key, self._cfg.user_checkbox_defaults.get(key, 0))
-
-        self.recoverpass_key = ""
-
-        self.enc_password = ""
-        if password:
-            try:
-                self.enc_password = encodePassword(password)
-            except UnicodeError:
-                pass # Should never happen
-
-        #self.edit_cols = 80
-        self.tz_offset = int(float(self._cfg.tz_offset) * 3600)
-        self.language = ""
-        self.real_language = "" # In case user uses "Browser setting". For language-statistics
-        self._stored = False
-        self.date_fmt = ""
-        self.datetime_fmt = ""
-        self.quicklinks = self._cfg.quicklinks_default
-        self.subscribed_pages = self._cfg.subscribed_pages_default
-        self.email_subscribed_events = self._cfg.email_subscribed_events_default
-        self.jabber_subscribed_events = self._cfg.jabber_subscribed_events_default
-        self.theme_name = self._cfg.theme_default
-        self.editor_default = self._cfg.editor_default
-        self.editor_ui = self._cfg.editor_ui
-        self.last_saved = str(time.time())
-
-        # attrs not saved to profile
-        self._request = request
-        self._trail = []
-
-        # we got an already authenticated username:
-        check_pass = 0
-        if not self.id and self.auth_username:
-            self.id = getUserId(request, self.auth_username)
-            if not password is None:
-                check_pass = 1
-        if self.id:
-            self.load_from_id(check_pass)
-        elif self.name:
-            self.id = getUserId(self._request, self.name)
-            if self.id:
-                self.load_from_id(1)
-            else:
-                self.id = self.make_id()
-        else:
-            self.id = self.make_id()
-
-        # "may" so we can say "if user.may.read(pagename):"
-        if self._cfg.SecurityPolicy:
-            self.may = self._cfg.SecurityPolicy(self)
-        else:
-            from MoinMoin.security import Default
-            self.may = Default(self)
-
-        if self.language and not self.language in i18n.wikiLanguages():
-            self.language = 'en'
-
-    def __repr__(self):
-        return "<%s.%s at 0x%x name:%r valid:%r>" % (
-            self.__class__.__module__, self.__class__.__name__,
-            id(self), self.name, self.valid)
-
-    def make_id(self):
-        """ make a new unique user id """
-        #!!! this should probably be a hash of REMOTE_ADDR, HTTP_USER_AGENT
-        # and some other things identifying remote users, then we could also
-        # use it reliably in edit locking
-        from random import randint
-        return "%s.%d" % (str(time.time()), randint(0, 65535))
-
-    def create_or_update(self, changed=False):
-        """ Create or update a user profile
-
-        @param changed: bool, set this to True if you updated the user profile values
-        """
-        if self._cfg.user_autocreate:
-            if not self.valid and not self.disabled or changed: # do we need to save/update?
-                self.save() # yes, create/update user profile
-
-    def __filename(self):
-        """ Get filename of the user's file on disk
-
-        @rtype: string
-        @return: full path and filename of user account file
-        """
-        return os.path.join(self._cfg.user_dir, self.id or "...NONE...")
-
-    def exists(self):
-        """ Do we have a user account for this user?
-
-        @rtype: bool
-        @return: true, if we have a user account
-        """
-        return os.path.exists(self.__filename())
-
-    def load_from_id(self, check_pass=0):
-        """ Load user account data from disk.
-
-        Can only load user data if the id number is already known.
-
-        This loads all member variables, except "id" and "valid" and
-        those starting with an underscore.
-
-        @param check_pass: If 1, then self.enc_password must match the
-                           password in the user account file.
-        """
-        if not self.exists():
-            return
-
-        data = codecs.open(self.__filename(), "r", config.charset).readlines()
-        user_data = {'enc_password': ''}
-        for line in data:
-            if line[0] == '#':
-                continue
-
-            try:
-                key, val = line.strip().split('=', 1)
-                if key not in self._cfg.user_transient_fields and key[0] != '_':
-                    # Decode list values
-                    if key.endswith('[]'):
-                        key = key[:-2]
-                        val = decodeList(val)
-                    # Decode dict values
-                    elif key.endswith('{}'):
-                        key = key[:-2]
-                        val = decodeDict(val)
-                    # for compatibility reading old files, keep these explicit
-                    # we will store them with [] appended
-                    elif key in ['quicklinks', 'subscribed_pages', 'subscribed_events']:
-                        val = decodeList(val)
-                    user_data[key] = val
-            except ValueError:
-                pass
-
-        # Validate data from user file. In case we need to change some
-        # values, we set 'changed' flag, and later save the user data.
-        changed = 0
-
-        if check_pass:
-            # If we have no password set, we don't accept login with username
-            if not user_data['enc_password']:
-                return
-            # Check for a valid password, possibly changing encoding
-            valid, changed = self._validatePassword(user_data)
-            if not valid:
-                return
-
-        # Remove ignored checkbox values from user data
-        for key, label in self._cfg.user_checkbox_fields:
-            if key in user_data and key in self._cfg.user_checkbox_disable:
-                del user_data[key]
-
-        # Copy user data into user object
-        for key, val in user_data.items():
-            vars(self)[key] = val
-
-        self.tz_offset = int(self.tz_offset)
-
-        # Remove old unsupported attributes from user data file.
-        remove_attributes = ['passwd', 'show_emoticons']
-        for attr in remove_attributes:
-            if hasattr(self, attr):
-                delattr(self, attr)
-                changed = 1
-
-        # make sure checkboxes are boolean
-        for key, label in self._cfg.user_checkbox_fields:
-            try:
-                setattr(self, key, int(getattr(self, key)))
-            except ValueError:
-                setattr(self, key, 0)
-
-        # convert (old) hourly format to seconds
-        if -24 <= self.tz_offset and self.tz_offset <= 24:
-            self.tz_offset = self.tz_offset * 3600
-
-        # clear trail
-        self._trail = []
-
-        if not self.disabled:
-            self.valid = 1
-
-        # Mark this user as stored so saves don't send
-        # the "user created" event
-        self._stored = True
-
-        # If user data has been changed, save fixed user data.
-        if changed:
-            self.save()
-
-    def _validatePassword(self, data):
-        """ Try to validate user password
-
-        This is a private method and should not be used by clients.
-
-        In pre 1.3, the wiki used some 8 bit charset. The user password
-        was entered in this 8 bit password and passed to
-        encodePassword. So old passwords can use any of the charset
-        used.
-
-        In 1.3, we use unicode internally, so we encode the password in
-        encodePassword using utf-8.
-
-        When we compare passwords we must compare with same encoding, or
-        the passwords will not match. We don't know what encoding the
-        password on the user file uses. We may ask the wiki admin to put
-        this into the config, but he may be wrong.
-
-        The way chosen is to try to encode and compare passwords using
-        all the encoding that were available on 1.2, until we get a
-        match, which means that the user is valid.
-
-        If we get a match, we replace the user password hash with the
-        utf-8 encoded version, and next time it will match on first try
-        as before. The user password did not change, this change is
-        completely transparent for the user. Only the sha digest will
-        change.
-
-        @param data: dict with user data
-        @rtype: 2 tuple (bool, bool)
-        @return: password is valid, password did change
-        """
-        # First try with default encoded password. Match only non empty
-        # passwords. (require non empty enc_password)
-        if self.enc_password and self.enc_password == data['enc_password']:
-            return True, False
-
-        # Try to match using one of pre 1.3 8 bit charsets
-
-        # Get the clear text password from the form (require non empty
-        # password)
-        password = self._request.form.get('password', [None])[0]
-        if not password:
-            return False, False
-
-        # First get all available pre13 charsets on this system
-        pre13 = ['iso-8859-1', 'iso-8859-2', 'euc-jp', 'gb2312', 'big5', ]
-        available = []
-        for charset in pre13:
-            try:
-                encoder = codecs.getencoder(charset)
-                available.append(charset)
-            except LookupError:
-                pass # missing on this system
-
-        # Now try to match the password
-        for charset in available:
-            # Try to encode, failure is expected
-            try:
-                enc_password = encodePassword(password, charset=charset)
-            except UnicodeError:
-                continue
-
-            # And match (require non empty enc_password)
-            if enc_password and enc_password == data['enc_password']:
-                # User password match - replace the user password in the
-                # file with self.password
-                data['enc_password'] = self.enc_password
-                return True, True
-
-        # No encoded password match, this must be wrong password
-        return False, False
-
-    def persistent_items(self):
-        """ items we want to store into the user profile """
-        return [(key, value) for key, value in vars(self).items()
-                    if key not in self._cfg.user_transient_fields and key[0] != '_']
-
-    def save(self):
-        """ Save user account data to user account file on disk.
-
-        This saves all member variables, except "id" and "valid" and
-        those starting with an underscore.
-        """
-        if not self.id:
-            return
-
-        user_dir = self._cfg.user_dir
-        if not os.path.exists(user_dir):
-            os.makedirs(user_dir)
-
-        self.last_saved = str(time.time())
-
-        # !!! should write to a temp file here to avoid race conditions,
-        # or even better, use locking
-
-        data = codecs.open(self.__filename(), "w", config.charset)
-        data.write("# Data saved '%s' for id '%s'\n" % (
-            time.strftime(self._cfg.datetime_fmt, time.localtime(time.time())),
-            self.id))
-        attrs = self.persistent_items()
-        attrs.sort()
-        for key, value in attrs:
-            # Encode list values
-            if isinstance(value, list):
-                key += '[]'
-                value = encodeList(value)
-            # Encode dict values
-            elif isinstance(value, dict):
-                key += '{}'
-                value = encodeDict(value)
-            line = u"%s=%s\n" % (key, unicode(value))
-            data.write(line)
-        data.close()
-
-        arena = 'user'
-        key = 'name2id'
-        caching.CacheEntry(self._request, arena, key, scope='wiki').remove()
-        try:
-            del self._request.cfg.cache.name2id
-        except:
-            pass
-        key = 'openid2id'
-        caching.CacheEntry(self._request, arena, key, scope='wiki').remove()
-        try:
-            del self._request.cfg.cache.openid2id
-        except:
-            pass
-
-        if not self.disabled:
-            self.valid = 1
-
-        if not self._stored:
-            self._stored = True
-            event = events.UserCreatedEvent(self._request, self)
-            events.send_event(event)
-
-    # -----------------------------------------------------------------
-    # Time and date formatting
-
-    def getTime(self, tm):
-        """ Get time in user's timezone.
-
-        @param tm: time (UTC UNIX timestamp)
-        @rtype: int
-        @return: tm tuple adjusted for user's timezone
-        """
-        return timefuncs.tmtuple(tm + self.tz_offset)
-
-
-    def getFormattedDate(self, tm):
-        """ Get formatted date adjusted for user's timezone.
-
-        @param tm: time (UTC UNIX timestamp)
-        @rtype: string
-        @return: formatted date, see cfg.date_fmt
-        """
-        date_fmt = self.date_fmt or self._cfg.date_fmt
-        return time.strftime(date_fmt, self.getTime(tm))
-
-
-    def getFormattedDateTime(self, tm):
-        """ Get formatted date and time adjusted for user's timezone.
-
-        @param tm: time (UTC UNIX timestamp)
-        @rtype: string
-        @return: formatted date and time, see cfg.datetime_fmt
-        """
-        datetime_fmt = self.datetime_fmt or self._cfg.datetime_fmt
-        return time.strftime(datetime_fmt, self.getTime(tm))
-
-    # -----------------------------------------------------------------
-    # Bookmark
-
-    def setBookmark(self, tm):
-        """ Set bookmark timestamp.
-
-        @param tm: timestamp
-        """
-        if self.valid:
-            interwikiname = unicode(self._cfg.interwikiname or '')
-            bookmark = unicode(tm)
-            self.bookmarks[interwikiname] = bookmark
-            self.save()
-
-    def getBookmark(self):
-        """ Get bookmark timestamp.
-
-        @rtype: int
-        @return: bookmark timestamp or None
-        """
-        bm = None
-        interwikiname = unicode(self._cfg.interwikiname or '')
-        if self.valid:
-            try:
-                bm = int(self.bookmarks[interwikiname])
-            except (ValueError, KeyError):
-                pass
-        return bm
-
-    def delBookmark(self):
-        """ Removes bookmark timestamp.
-
-        @rtype: int
-        @return: 0 on success, 1 on failure
-        """
-        interwikiname = unicode(self._cfg.interwikiname or '')
-        if self.valid:
-            try:
-                del self.bookmarks[interwikiname]
-            except KeyError:
-                return 1
-            self.save()
-            return 0
-        return 1
-
-    # -----------------------------------------------------------------
-    # Subscribe
-
-    def getSubscriptionList(self):
-        """ Get list of pages this user has subscribed to
-
-        @rtype: list
-        @return: pages this user has subscribed to
-        """
-        return self.subscribed_pages
-
-    def isSubscribedTo(self, pagelist):
-        """ Check if user subscription matches any page in pagelist.
-
-        The subscription list may contain page names or interwiki page
-        names. e.g 'Page Name' or 'WikiName:Page_Name'
-
-        TODO: check if it's fast enough when getting called for many
-              users from page.getSubscribersList()
-
-        @param pagelist: list of pages to check for subscription
-        @rtype: bool
-        @return: if user is subscribed any page in pagelist
-        """
-        if not self.valid:
-            return False
-
-        import re
-        # Create a new list with both names and interwiki names.
-        pages = pagelist[:]
-        if self._cfg.interwikiname:
-            pages += [self._interWikiName(pagename) for pagename in pagelist]
-        # Create text for regular expression search
-        text = '\n'.join(pages)
-
-        for pattern in self.getSubscriptionList():
-            # Try simple match first
-            if pattern in pages:
-                return True
-            # Try regular expression search, skipping bad patterns
-            try:
-                pattern = re.compile(r'^%s$' % pattern, re.M)
-            except re.error:
-                continue
-            if pattern.search(text):
-                return True
-
-        return False
-
-    def subscribe(self, pagename):
-        """ Subscribe to a wiki page.
-
-        To enable shared farm users, if the wiki has an interwiki name,
-        page names are saved as interwiki names.
-
-        @param pagename: name of the page to subscribe
-        @type pagename: unicode
-        @rtype: bool
-        @return: if page was subscribed
-        """
-        if self._cfg.interwikiname:
-            pagename = self._interWikiName(pagename)
-
-        if pagename not in self.subscribed_pages:
-            self.subscribed_pages.append(pagename)
-            self.save()
-
-            # Send a notification
-            from MoinMoin.events import SubscribedToPageEvent, send_event
-            e = SubscribedToPageEvent(self._request, pagename, self.name)
-            send_event(e)
-            return True
-
-        return False
-
-    def unsubscribe(self, pagename):
-        """ Unsubscribe a wiki page.
-
-        Try to unsubscribe by removing non-interwiki name (leftover
-        from old use files) and interwiki name from the subscription
-        list.
-
-        Its possible that the user will be subscribed to a page by more
-        then one pattern. It can be both pagename and interwiki name,
-        or few patterns that all of them match the page. Therefore, we
-        must check if the user is still subscribed to the page after we
-        try to remove names from the list.
-
-        @param pagename: name of the page to subscribe
-        @type pagename: unicode
-        @rtype: bool
-        @return: if unsubscrieb was successful. If the user has a
-            regular expression that match, it will always fail.
-        """
-        changed = False
-        if pagename in self.subscribed_pages:
-            self.subscribed_pages.remove(pagename)
-            changed = True
-
-        interWikiName = self._interWikiName(pagename)
-        if interWikiName and interWikiName in self.subscribed_pages:
-            self.subscribed_pages.remove(interWikiName)
-            changed = True
-
-        if changed:
-            self.save()
-        return not self.isSubscribedTo([pagename])
-
-    # -----------------------------------------------------------------
-    # Quicklinks
-
-    def getQuickLinks(self):
-        """ Get list of pages this user wants in the navibar
-
-        @rtype: list
-        @return: quicklinks from user account
-        """
-        return self.quicklinks
-
-    def isQuickLinkedTo(self, pagelist):
-        """ Check if user quicklink matches any page in pagelist.
-
-        @param pagelist: list of pages to check for quicklinks
-        @rtype: bool
-        @return: if user has quicklinked any page in pagelist
-        """
-        if not self.valid:
-            return False
-
-        for pagename in pagelist:
-            if pagename in self.quicklinks:
-                return True
-            interWikiName = self._interWikiName(pagename)
-            if interWikiName and interWikiName in self.quicklinks:
-                return True
-
-        return False
-
-    def addQuicklink(self, pagename):
-        """ Adds a page to the user quicklinks
-
-        If the wiki has an interwiki name, all links are saved as
-        interwiki names. If not, as simple page name.
-
-        @param pagename: page name
-        @type pagename: unicode
-        @rtype: bool
-        @return: if pagename was added
-        """
-        changed = False
-        interWikiName = self._interWikiName(pagename)
-        if interWikiName:
-            if pagename in self.quicklinks:
-                self.quicklinks.remove(pagename)
-                changed = True
-            if interWikiName not in self.quicklinks:
-                self.quicklinks.append(interWikiName)
-                changed = True
-        else:
-            if pagename not in self.quicklinks:
-                self.quicklinks.append(pagename)
-                changed = True
-
-        if changed:
-            self.save()
-        return changed
-
-    def removeQuicklink(self, pagename):
-        """ Remove a page from user quicklinks
-
-        Remove both interwiki and simple name from quicklinks.
-
-        @param pagename: page name
-        @type pagename: unicode
-        @rtype: bool
-        @return: if pagename was removed
-        """
-        changed = False
-        interWikiName = self._interWikiName(pagename)
-        if interWikiName and interWikiName in self.quicklinks:
-            self.quicklinks.remove(interWikiName)
-            changed = True
-        if pagename in self.quicklinks:
-            self.quicklinks.remove(pagename)
-            changed = True
-
-        if changed:
-            self.save()
-        return changed
-
-    def _interWikiName(self, pagename):
-        """ Return the inter wiki name of a page name
-
-        @param pagename: page name
-        @type pagename: unicode
-        """
-        if not self._cfg.interwikiname:
-            return None
-
-        return "%s:%s" % (self._cfg.interwikiname, pagename)
-
-    # -----------------------------------------------------------------
-    # Trail
-
-    def _wantTrail(self):
-        return (not self.valid and self._request.session.is_stored  # anon session
-                or self.valid and (self.show_page_trail or self.remember_last_visit))  # logged-in session
-
-    def addTrail(self, page):
-        """ Add page to trail.
-
-        @param page: the page (object) to add to the trail
-        """
-        if self._wantTrail():
-            # load trail if not known
-            self.getTrail()
-
-            pagename = page.page_name
-            # Add only existing pages that the user may read
-            if not (page.exists() and self._request.user.may.read(pagename)):
-                return
-
-            # Save interwiki links internally
-            if self._cfg.interwikiname:
-                pagename = self._interWikiName(pagename)
-
-            # Don't append tail to trail ;)
-            if self._trail and self._trail[-1] == pagename:
-                return
-
-            # Append new page, limiting the length
-            self._trail = [p for p in self._trail if p != pagename]
-            self._trail = self._trail[-(self._cfg.trail_size-1):]
-            self._trail.append(pagename)
-            self.saveTrail()
-
-    def saveTrail(self):
-        """ Save trail into session """
-        if not self._request.session.is_new:
-            self._request.session['trail'] = self._trail
-
-    def getTrail(self):
-        """ Return list of recently visited pages.
-
-        @rtype: list
-        @return: pages in trail
-        """
-        if not self._trail and self._wantTrail():
-            trail = self._request.session.get('trail', [])
-            trail = [t.strip() for t in trail]
-            trail = [t for t in trail if t]
-            self._trail = trail[-self._cfg.trail_size:]
-
-        return self._trail
-
-    # -----------------------------------------------------------------
-    # Other
-
-    def isCurrentUser(self):
-        """ Check if this user object is the user doing the current request """
-        return self._request.user.name == self.name
-
-    def isSuperUser(self):
-        """ Check if this user is superuser """
-        request = self._request
-        if request.cfg.DesktopEdition and request.remote_addr == '127.0.0.1' and request.user and request.user.valid:
-            # the DesktopEdition gives any local user superuser powers
-            return True
-        superusers = request.cfg.superuser
-        assert isinstance(superusers, (list, tuple))
-        return self.valid and self.name and self.name in superusers
-
-    def host(self):
-        """ Return user host """
-        _ = self._request.getText
-        host = self.isCurrentUser() and self._cfg.show_hosts and self._request.remote_addr
-        return host or _("<unknown>")
-
-    def wikiHomeLink(self):
-        """ Return wiki markup usable as a link to the user homepage,
-            it doesn't matter whether it already exists or not.
-        """
-        wikiname, pagename = wikiutil.getInterwikiHomePage(self._request, self.name)
-        if wikiname == 'Self':
-            if wikiutil.isStrictWikiname(self.name):
-                markup = pagename
-            else:
-                markup = '[[%s]]' % pagename
-        else:
-            markup = '[[%s:%s]]' % (wikiname, pagename)
-        return markup
-
-    def signature(self):
-        """ Return user signature using wiki markup
-
-        Users sign with a link to their homepage.
-        Visitors return their host address.
-
-        TODO: The signature use wiki format only, for example, it will
-        not create a link when using rst format. It will also break if
-        we change wiki syntax.
-        """
-        if self.name:
-            return self.wikiHomeLink()
-        else:
-            return self.host()
-
-    def generate_recovery_token(self):
-        key = random_string(64, "abcdefghijklmnopqrstuvwxyz0123456789")
-        msg = str(int(time.time()))
-        h = hmac.new(key, msg, sha).hexdigest()
-        self.recoverpass_key = key
-        self.save()
-        return msg + '-' + h
-
-    def apply_recovery_token(self, tok, newpass):
-        key = self.recoverpass_key
-        parts = tok.split('-')
-        if len(parts) != 2:
-            return False
-        try:
-            stamp = int(parts[0])
-        except ValueError:
-            return False
-        # only allow it to be valid for twelve hours
-        if stamp + 12*60*60 < time.time():
-            return False
-        # check hmac
-        h = hmac.new(self.recoverpass_key, str(stamp), sha).hexdigest()
-        if h != parts[1]:
-            return False
-        self.recoverpass_key = ""
-        self.enc_password = encodePassword(newpass)
-        self.save()
-        return True
-
-    def mailAccountData(self, cleartext_passwd=None):
-        """ Mail a user who forgot his password a message enabling
-            him to login again.
-        """
-        from MoinMoin.mail import sendmail
-        from MoinMoin.wikiutil import getLocalizedPage
-        _ = self._request.getText
-
-        tok = self.generate_recovery_token()
-
-        text = '\n' + _("""\
-Login Name: %s
-
-Password recovery token: %s
-
-Password reset URL: %s/?action=recoverpass&name=%s&token=%s
-""") % (
-                        self.name,
-                        tok,
-                        self._request.getBaseURL(),
-                        url_quote_plus(self.name),
-                        tok, )
-
-        text = _("""\
-Somebody has requested to email you a password recovery token.
-
-If you lost your password, please go to the password reset URL below or
-go to the password recovery page again and enter your username and the
-recovery token.
-""") + text
-
-
-        subject = _('[%(sitename)s] Your wiki account data',
-                ) % {'sitename': self._cfg.sitename or "Wiki"}
-        mailok, msg = sendmail.sendmail(self._request, [self.email], subject,
-                                    text, mail_from=self._cfg.mail_from)
-        return mailok, msg
-
diff --git a/wiki-lenny/share/user.py b/wiki-lenny/share/user.py
deleted file mode 100644
index 9a28caef..00000000
--- a/wiki-lenny/share/user.py
+++ /dev/null
@@ -1,1105 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-"""
-    MoinMoin - User Accounts
-
-    This module contains functions to access user accounts (list all users, get
-    some specific user). User instances are used to access the user profile of
-    some specific user (name, password, email, bookmark, trail, settings, ...).
-
-    Some related code is in the userform and userprefs modules.
-
-    TODO:
-    * code is a mixture of highlevel user stuff and lowlevel storage functions,
-      this has to get separated into:
-      * user object highlevel stuff
-      * storage code
-
-    @copyright: 2000-2004 Juergen Hermann <jh@web.de>,
-                2003-2007 MoinMoin:ThomasWaldmann
-    @license: GNU GPL, see COPYING for details.
-"""
-
-# add names here to hide them in the cgitb traceback
-unsafe_names = ("id", "key", "val", "user_data", "enc_password", "recoverpass_key")
-
-import os, time, sha, codecs, hmac
-
-from MoinMoin import config, caching, wikiutil, i18n, events
-from MoinMoin.util import timefuncs, filesys, random_string
-from MoinMoin.wikiutil import url_quote_plus
-### HACK SAUVAGE 1/2
-import socket
-### FIN HACK 1/2
-
-def getUserList(request):
-    """ Get a list of all (numerical) user IDs.
-
-    @param request: current request
-    @rtype: list
-    @return: all user IDs
-    """
-    import re
-    user_re = re.compile(r'^\d+\.\d+(\.\d+)?$')
-    files = filesys.dclistdir(request.cfg.user_dir)
-    userlist = [f for f in files if user_re.match(f)]
-    return userlist
-
-def get_by_filter(request, filter_func):
-    """ Searches for an user with a given filter function """
-    for uid in getUserList(request):
-        theuser = User(request, uid)
-        if filter_func(theuser):
-            return theuser
-
-def get_by_email_address(request, email_address):
-    """ Searches for an user with a particular e-mail address and returns it. """
-    filter_func = lambda user: user.valid and user.email.lower() == email_address.lower()
-    return get_by_filter(request, filter_func)
-
-def get_by_jabber_id(request, jabber_id):
-    """ Searches for an user with a perticular jabber id and returns it. """
-    filter_func = lambda user: user.valid and user.jid.lower() == jabber_id.lower()
-    return get_by_filter(request, filter_func)
-
-def _getUserIdByKey(request, key, search):
-    """ Get the user ID for a specified key/value pair.
-
-    This method must only be called for keys that are
-    guaranteed to be unique.
-
-    @param key: the key to look in
-    @param search: the value to look for
-    @return the corresponding user ID or None
-    """
-    if not search or not key:
-        return None
-    cfg = request.cfg
-    cachekey = '%s2id' % key
-    try:
-        _key2id = getattr(cfg.cache, cachekey)
-    except AttributeError:
-        arena = 'user'
-        cache = caching.CacheEntry(request, arena, cachekey, scope='wiki', use_pickle=True)
-        try:
-            _key2id = cache.content()
-        except caching.CacheError:
-            _key2id = {}
-        setattr(cfg.cache, cachekey, _key2id)
-    uid = _key2id.get(search, None)
-    if uid is None:
-        for userid in getUserList(request):
-            u = User(request, id=userid)
-            if hasattr(u, key):
-                value = getattr(u, key)
-                if isinstance(value, list):
-                    for val in value:
-                        _key2id[val] = userid
-                else:
-                    _key2id[value] = userid
-        arena = 'user'
-        cache = caching.CacheEntry(request, arena, cachekey, scope='wiki', use_pickle=True)
-        try:
-            cache.update(_key2id)
-        except caching.CacheError:
-            pass
-        uid = _key2id.get(search, None)
-    return uid
-
-
-def getUserId(request, searchName):
-    """ Get the user ID for a specific user NAME.
-
-    @param searchName: the user name to look up
-    @rtype: string
-    @return: the corresponding user ID or None
-    """
-    return _getUserIdByKey(request, 'name', searchName)
-
-
-def getUserIdByOpenId(request, openid):
-    """ Get the user ID for a specific OpenID.
-
-    @param openid: the openid to look up
-    @rtype: string
-    @return: the corresponding user ID or None
-    """
-    return _getUserIdByKey(request, 'openids', openid)
-
-
-def getUserIdentification(request, username=None):
-    """ Return user name or IP or '<unknown>' indicator.
-
-    @param request: the request object
-    @param username: (optional) user name
-    @rtype: string
-    @return: user name or IP or unknown indicator
-    """
-    _ = request.getText
-
-    if username is None:
-        username = request.user.name
-
-    return username or (request.cfg.show_hosts and request.remote_addr) or _("<unknown>")
-
-
-def encodePassword(pwd, charset='utf-8'):
-    """ Encode a cleartext password
-
-    Compatible to Apache htpasswd SHA encoding.
-
-    When using different encoding than 'utf-8', the encoding might fail
-    and raise UnicodeError.
-
-    @param pwd: the cleartext password, (unicode)
-    @param charset: charset used to encode password, used only for
-        compatibility with old passwords generated on moin-1.2.
-    @rtype: string
-    @return: the password in apache htpasswd compatible SHA-encoding,
-        or None
-    """
-    import base64
-
-    # Might raise UnicodeError, but we can't do anything about it here,
-    # so let the caller handle it.
-    pwd = pwd.encode(charset)
-
-    pwd = sha.new(pwd).digest()
-    pwd = '{SHA}' + base64.encodestring(pwd).rstrip()
-    return pwd
-
-
-def normalizeName(name):
-    """ Make normalized user name
-
-    Prevent impersonating another user with names containing leading,
-    trailing or multiple whitespace, or using invisible unicode
-    characters.
-
-    Prevent creating user page as sub page, because '/' is not allowed
-    in user names.
-
-    Prevent using ':' and ',' which are reserved by acl.
-
-    @param name: user name, unicode
-    @rtype: unicode
-    @return: user name that can be used in acl lines
-    """
-    username_allowedchars = "'@.-_" # ' for names like O'Brian or email addresses.
-                                    # "," and ":" must not be allowed (ACL delimiters).
-                                    # We also allow _ in usernames for nicer URLs.
-    # Strip non alpha numeric characters (except username_allowedchars), keep white space
-    name = ''.join([c for c in name if c.isalnum() or c.isspace() or c in username_allowedchars])
-
-    # Normalize white space. Each name can contain multiple
-    # words separated with only one space.
-    name = ' '.join(name.split())
-
-    return name
-
-
-def isValidName(request, name):
-    """ Validate user name
-
-    @param name: user name, unicode
-    """
-    normalized = normalizeName(name)
-    return (name == normalized) and not wikiutil.isGroupPage(request, name)
-
-
-def encodeList(items):
-    """ Encode list of items in user data file
-
-    Items are separated by '\t' characters.
-
-    @param items: list unicode strings
-    @rtype: unicode
-    @return: list encoded as unicode
-    """
-    line = []
-    for item in items:
-        item = item.strip()
-        if not item:
-            continue
-        line.append(item)
-
-    line = '\t'.join(line)
-    return line
-
-def decodeList(line):
-    """ Decode list of items from user data file
-
-    @param line: line containing list of items, encoded with encodeList
-    @rtype: list of unicode strings
-    @return: list of items in encoded in line
-    """
-    items = []
-    for item in line.split('\t'):
-        item = item.strip()
-        if not item:
-            continue
-        items.append(item)
-    return items
-
-def encodeDict(items):
-    """ Encode dict of items in user data file
-
-    Items are separated by '\t' characters.
-    Each item is key:value.
-
-    @param items: dict of unicode:unicode
-    @rtype: unicode
-    @return: dict encoded as unicode
-    """
-    line = []
-    for key, value in items.items():
-        item = u'%s:%s' % (key, value)
-        line.append(item)
-    line = '\t'.join(line)
-    return line
-
-def decodeDict(line):
-    """ Decode dict of key:value pairs from user data file
-
-    @param line: line containing a dict, encoded with encodeDict
-    @rtype: dict
-    @return: dict  unicode:unicode items
-    """
-    items = {}
-    for item in line.split('\t'):
-        item = item.strip()
-        if not item:
-            continue
-        key, value = item.split(':', 1)
-        items[key] = value
-    return items
-
-
-class User:
-    """ A MoinMoin User """
-
-    def __init__(self, request, id=None, name="", password=None, auth_username="", **kw):
-        """ Initialize User object
-
-        TODO: when this gets refactored, use "uid" not builtin "id"
-
-        @param request: the request object
-        @param id: (optional) user ID
-        @param name: (optional) user name
-        @param password: (optional) user password (unicode)
-        @param auth_username: (optional) already authenticated user name
-                              (e.g. when using http basic auth) (unicode)
-        @keyword auth_method: method that was used for authentication,
-                              default: 'internal'
-        @keyword auth_attribs: tuple of user object attribute names that are
-                               determined by auth method and should not be
-                               changeable by preferences, default: ().
-                               First tuple element was used for authentication.
-        """
-        self._cfg = request.cfg
-        self.valid = 0
-        self.id = id
-        self.auth_username = auth_username
-        self.auth_method = kw.get('auth_method', 'internal')
-        self.auth_attribs = kw.get('auth_attribs', ())
-        self.bookmarks = {} # interwikiname: bookmark
-
-        # create some vars automatically
-        self.__dict__.update(self._cfg.user_form_defaults)
-
-        if name:
-            self.name = name
-        elif auth_username: # this is needed for user_autocreate
-            self.name = auth_username
-
-        # create checkbox fields (with default 0)
-        for key, label in self._cfg.user_checkbox_fields:
-            setattr(self, key, self._cfg.user_checkbox_defaults.get(key, 0))
-
-        self.recoverpass_key = ""
-
-        self.enc_password = ""
-        if password:
-            try:
-                self.enc_password = encodePassword(password)
-            except UnicodeError:
-                pass # Should never happen
-
-        #self.edit_cols = 80
-        self.tz_offset = int(float(self._cfg.tz_offset) * 3600)
-        self.language = ""
-        self.real_language = "" # In case user uses "Browser setting". For language-statistics
-        self._stored = False
-        self.date_fmt = ""
-        self.datetime_fmt = ""
-        self.quicklinks = self._cfg.quicklinks_default
-        self.subscribed_pages = self._cfg.subscribed_pages_default
-        self.email_subscribed_events = self._cfg.email_subscribed_events_default
-        self.jabber_subscribed_events = self._cfg.jabber_subscribed_events_default
-        self.theme_name = self._cfg.theme_default
-        self.editor_default = self._cfg.editor_default
-        self.editor_ui = self._cfg.editor_ui
-        self.last_saved = str(time.time())
-
-        # attrs not saved to profile
-        self._request = request
-        self._trail = []
-
-        # we got an already authenticated username:
-        check_pass = 0
-        if not self.id and self.auth_username:
-            self.id = getUserId(request, self.auth_username)
-            if not password is None:
-                check_pass = 1
-        if self.id:
-            self.load_from_id(check_pass)
-        elif self.name:
-            self.id = getUserId(self._request, self.name)
-            if self.id:
-                self.load_from_id(1)
-            else:
-                self.id = self.make_id()
-        else:
-            self.id = self.make_id()
-
-        # "may" so we can say "if user.may.read(pagename):"
-        if self._cfg.SecurityPolicy:
-            self.may = self._cfg.SecurityPolicy(self)
-        else:
-            from MoinMoin.security import Default
-            self.may = Default(self)
-
-        if self.language and not self.language in i18n.wikiLanguages():
-            self.language = 'en'
-
-    def __repr__(self):
-        return "<%s.%s at 0x%x name:%r valid:%r>" % (
-            self.__class__.__module__, self.__class__.__name__,
-            id(self), self.name, self.valid)
-
-    def make_id(self):
-        """ make a new unique user id """
-        #!!! this should probably be a hash of REMOTE_ADDR, HTTP_USER_AGENT
-        # and some other things identifying remote users, then we could also
-        # use it reliably in edit locking
-        from random import randint
-        return "%s.%d" % (str(time.time()), randint(0, 65535))
-
-    def create_or_update(self, changed=False):
-        """ Create or update a user profile
-
-        @param changed: bool, set this to True if you updated the user profile values
-        """
-        if self._cfg.user_autocreate:
-            if not self.valid and not self.disabled or changed: # do we need to save/update?
-                self.save() # yes, create/update user profile
-
-    def __filename(self):
-        """ Get filename of the user's file on disk
-
-        @rtype: string
-        @return: full path and filename of user account file
-        """
-        return os.path.join(self._cfg.user_dir, self.id or "...NONE...")
-
-    def exists(self):
-        """ Do we have a user account for this user?
-
-        @rtype: bool
-        @return: true, if we have a user account
-        """
-        return os.path.exists(self.__filename())
-
-    def load_from_id(self, check_pass=0):
-        """ Load user account data from disk.
-
-        Can only load user data if the id number is already known.
-
-        This loads all member variables, except "id" and "valid" and
-        those starting with an underscore.
-
-        @param check_pass: If 1, then self.enc_password must match the
-                           password in the user account file.
-        """
-        if not self.exists():
-            return
-
-        data = codecs.open(self.__filename(), "r", config.charset).readlines()
-        user_data = {'enc_password': ''}
-        for line in data:
-            if line[0] == '#':
-                continue
-
-            try:
-                key, val = line.strip().split('=', 1)
-                if key not in self._cfg.user_transient_fields and key[0] != '_':
-                    # Decode list values
-                    if key.endswith('[]'):
-                        key = key[:-2]
-                        val = decodeList(val)
-                    # Decode dict values
-                    elif key.endswith('{}'):
-                        key = key[:-2]
-                        val = decodeDict(val)
-                    # for compatibility reading old files, keep these explicit
-                    # we will store them with [] appended
-                    elif key in ['quicklinks', 'subscribed_pages', 'subscribed_events']:
-                        val = decodeList(val)
-                    user_data[key] = val
-            except ValueError:
-                pass
-
-        # Validate data from user file. In case we need to change some
-        # values, we set 'changed' flag, and later save the user data.
-        changed = 0
-
-        if check_pass:
-            # If we have no password set, we don't accept login with username
-            if not user_data['enc_password']:
-                return
-            # Check for a valid password, possibly changing encoding
-            valid, changed = self._validatePassword(user_data)
-            if not valid:
-                return
-
-        # Remove ignored checkbox values from user data
-        for key, label in self._cfg.user_checkbox_fields:
-            if key in user_data and key in self._cfg.user_checkbox_disable:
-                del user_data[key]
-
-        # Copy user data into user object
-        for key, val in user_data.items():
-            vars(self)[key] = val
-
-        self.tz_offset = int(self.tz_offset)
-
-        # Remove old unsupported attributes from user data file.
-        remove_attributes = ['passwd', 'show_emoticons']
-        for attr in remove_attributes:
-            if hasattr(self, attr):
-                delattr(self, attr)
-                changed = 1
-
-        # make sure checkboxes are boolean
-        for key, label in self._cfg.user_checkbox_fields:
-            try:
-                setattr(self, key, int(getattr(self, key)))
-            except ValueError:
-                setattr(self, key, 0)
-
-        # convert (old) hourly format to seconds
-        if -24 <= self.tz_offset and self.tz_offset <= 24:
-            self.tz_offset = self.tz_offset * 3600
-
-        # clear trail
-        self._trail = []
-
-        if not self.disabled:
-            self.valid = 1
-
-        # Mark this user as stored so saves don't send
-        # the "user created" event
-        self._stored = True
-
-        # If user data has been changed, save fixed user data.
-        if changed:
-            self.save()
-
-    def _validatePassword(self, data):
-        """ Try to validate user password
-
-        This is a private method and should not be used by clients.
-
-        In pre 1.3, the wiki used some 8 bit charset. The user password
-        was entered in this 8 bit password and passed to
-        encodePassword. So old passwords can use any of the charset
-        used.
-
-        In 1.3, we use unicode internally, so we encode the password in
-        encodePassword using utf-8.
-
-        When we compare passwords we must compare with same encoding, or
-        the passwords will not match. We don't know what encoding the
-        password on the user file uses. We may ask the wiki admin to put
-        this into the config, but he may be wrong.
-
-        The way chosen is to try to encode and compare passwords using
-        all the encoding that were available on 1.2, until we get a
-        match, which means that the user is valid.
-
-        If we get a match, we replace the user password hash with the
-        utf-8 encoded version, and next time it will match on first try
-        as before. The user password did not change, this change is
-        completely transparent for the user. Only the sha digest will
-        change.
-
-        @param data: dict with user data
-        @rtype: 2 tuple (bool, bool)
-        @return: password is valid, password did change
-        """
-        # First try with default encoded password. Match only non empty
-        # passwords. (require non empty enc_password)
-        if self.enc_password and self.enc_password == data['enc_password']:
-            return True, False
-
-        # Try to match using one of pre 1.3 8 bit charsets
-
-        # Get the clear text password from the form (require non empty
-        # password)
-        password = self._request.form.get('password', [None])[0]
-        if not password:
-            return False, False
-
-        # First get all available pre13 charsets on this system
-        pre13 = ['iso-8859-1', 'iso-8859-2', 'euc-jp', 'gb2312', 'big5', ]
-        available = []
-        for charset in pre13:
-            try:
-                encoder = codecs.getencoder(charset)
-                available.append(charset)
-            except LookupError:
-                pass # missing on this system
-
-        # Now try to match the password
-        for charset in available:
-            # Try to encode, failure is expected
-            try:
-                enc_password = encodePassword(password, charset=charset)
-            except UnicodeError:
-                continue
-
-            # And match (require non empty enc_password)
-            if enc_password and enc_password == data['enc_password']:
-                # User password match - replace the user password in the
-                # file with self.password
-                data['enc_password'] = self.enc_password
-                return True, True
-
-        # No encoded password match, this must be wrong password
-        return False, False
-
-    def persistent_items(self):
-        """ items we want to store into the user profile """
-        return [(key, value) for key, value in vars(self).items()
-                    if key not in self._cfg.user_transient_fields and key[0] != '_']
-
-    def save(self):
-        """ Save user account data to user account file on disk.
-
-        This saves all member variables, except "id" and "valid" and
-        those starting with an underscore.
-        """
-        if not self.id:
-            return
-
-        user_dir = self._cfg.user_dir
-        if not os.path.exists(user_dir):
-            os.makedirs(user_dir)
-
-        self.last_saved = str(time.time())
-
-        # !!! should write to a temp file here to avoid race conditions,
-        # or even better, use locking
-
-        data = codecs.open(self.__filename(), "w", config.charset)
-        data.write("# Data saved '%s' for id '%s'\n" % (
-            time.strftime(self._cfg.datetime_fmt, time.localtime(time.time())),
-            self.id))
-        attrs = self.persistent_items()
-        attrs.sort()
-        for key, value in attrs:
-            # Encode list values
-            if isinstance(value, list):
-                key += '[]'
-                value = encodeList(value)
-            # Encode dict values
-            elif isinstance(value, dict):
-                key += '{}'
-                value = encodeDict(value)
-            line = u"%s=%s\n" % (key, unicode(value))
-            data.write(line)
-        data.close()
-
-        arena = 'user'
-        key = 'name2id'
-        caching.CacheEntry(self._request, arena, key, scope='wiki').remove()
-        try:
-            del self._request.cfg.cache.name2id
-        except:
-            pass
-        key = 'openid2id'
-        caching.CacheEntry(self._request, arena, key, scope='wiki').remove()
-        try:
-            del self._request.cfg.cache.openid2id
-        except:
-            pass
-
-        if not self.disabled:
-            self.valid = 1
-
-        if not self._stored:
-            self._stored = True
-            event = events.UserCreatedEvent(self._request, self)
-            events.send_event(event)
-
-    # -----------------------------------------------------------------
-    # Time and date formatting
-
-    def getTime(self, tm):
-        """ Get time in user's timezone.
-
-        @param tm: time (UTC UNIX timestamp)
-        @rtype: int
-        @return: tm tuple adjusted for user's timezone
-        """
-        return timefuncs.tmtuple(tm + self.tz_offset)
-
-
-    def getFormattedDate(self, tm):
-        """ Get formatted date adjusted for user's timezone.
-
-        @param tm: time (UTC UNIX timestamp)
-        @rtype: string
-        @return: formatted date, see cfg.date_fmt
-        """
-        date_fmt = self.date_fmt or self._cfg.date_fmt
-        return time.strftime(date_fmt, self.getTime(tm))
-
-
-    def getFormattedDateTime(self, tm):
-        """ Get formatted date and time adjusted for user's timezone.
-
-        @param tm: time (UTC UNIX timestamp)
-        @rtype: string
-        @return: formatted date and time, see cfg.datetime_fmt
-        """
-        datetime_fmt = self.datetime_fmt or self._cfg.datetime_fmt
-        return time.strftime(datetime_fmt, self.getTime(tm))
-
-    # -----------------------------------------------------------------
-    # Bookmark
-
-    def setBookmark(self, tm):
-        """ Set bookmark timestamp.
-
-        @param tm: timestamp
-        """
-        if self.valid:
-            interwikiname = unicode(self._cfg.interwikiname or '')
-            bookmark = unicode(tm)
-            self.bookmarks[interwikiname] = bookmark
-            self.save()
-
-    def getBookmark(self):
-        """ Get bookmark timestamp.
-
-        @rtype: int
-        @return: bookmark timestamp or None
-        """
-        bm = None
-        interwikiname = unicode(self._cfg.interwikiname or '')
-        if self.valid:
-            try:
-                bm = int(self.bookmarks[interwikiname])
-            except (ValueError, KeyError):
-                pass
-        return bm
-
-    def delBookmark(self):
-        """ Removes bookmark timestamp.
-
-        @rtype: int
-        @return: 0 on success, 1 on failure
-        """
-        interwikiname = unicode(self._cfg.interwikiname or '')
-        if self.valid:
-            try:
-                del self.bookmarks[interwikiname]
-            except KeyError:
-                return 1
-            self.save()
-            return 0
-        return 1
-
-    # -----------------------------------------------------------------
-    # Subscribe
-
-    def getSubscriptionList(self):
-        """ Get list of pages this user has subscribed to
-
-        @rtype: list
-        @return: pages this user has subscribed to
-        """
-        return self.subscribed_pages
-
-    def isSubscribedTo(self, pagelist):
-        """ Check if user subscription matches any page in pagelist.
-
-        The subscription list may contain page names or interwiki page
-        names. e.g 'Page Name' or 'WikiName:Page_Name'
-
-        TODO: check if it's fast enough when getting called for many
-              users from page.getSubscribersList()
-
-        @param pagelist: list of pages to check for subscription
-        @rtype: bool
-        @return: if user is subscribed any page in pagelist
-        """
-        if not self.valid:
-            return False
-
-        import re
-        # Create a new list with both names and interwiki names.
-        pages = pagelist[:]
-        if self._cfg.interwikiname:
-            pages += [self._interWikiName(pagename) for pagename in pagelist]
-        # Create text for regular expression search
-        text = '\n'.join(pages)
-
-        for pattern in self.getSubscriptionList():
-            # Try simple match first
-            if pattern in pages:
-                return True
-            # Try regular expression search, skipping bad patterns
-            try:
-                pattern = re.compile(r'^%s$' % pattern, re.M)
-            except re.error:
-                continue
-            if pattern.search(text):
-                return True
-
-        return False
-
-    def subscribe(self, pagename):
-        """ Subscribe to a wiki page.
-
-        To enable shared farm users, if the wiki has an interwiki name,
-        page names are saved as interwiki names.
-
-        @param pagename: name of the page to subscribe
-        @type pagename: unicode
-        @rtype: bool
-        @return: if page was subscribed
-        """
-        if self._cfg.interwikiname:
-            pagename = self._interWikiName(pagename)
-
-        if pagename not in self.subscribed_pages:
-            self.subscribed_pages.append(pagename)
-            self.save()
-
-            # Send a notification
-            from MoinMoin.events import SubscribedToPageEvent, send_event
-            e = SubscribedToPageEvent(self._request, pagename, self.name)
-            send_event(e)
-            return True
-
-        return False
-
-    def unsubscribe(self, pagename):
-        """ Unsubscribe a wiki page.
-
-        Try to unsubscribe by removing non-interwiki name (leftover
-        from old use files) and interwiki name from the subscription
-        list.
-
-        Its possible that the user will be subscribed to a page by more
-        then one pattern. It can be both pagename and interwiki name,
-        or few patterns that all of them match the page. Therefore, we
-        must check if the user is still subscribed to the page after we
-        try to remove names from the list.
-
-        @param pagename: name of the page to subscribe
-        @type pagename: unicode
-        @rtype: bool
-        @return: if unsubscrieb was successful. If the user has a
-            regular expression that match, it will always fail.
-        """
-        changed = False
-        if pagename in self.subscribed_pages:
-            self.subscribed_pages.remove(pagename)
-            changed = True
-
-        interWikiName = self._interWikiName(pagename)
-        if interWikiName and interWikiName in self.subscribed_pages:
-            self.subscribed_pages.remove(interWikiName)
-            changed = True
-
-        if changed:
-            self.save()
-        return not self.isSubscribedTo([pagename])
-
-    # -----------------------------------------------------------------
-    # Quicklinks
-
-    def getQuickLinks(self):
-        """ Get list of pages this user wants in the navibar
-
-        @rtype: list
-        @return: quicklinks from user account
-        """
-        return self.quicklinks
-
-    def isQuickLinkedTo(self, pagelist):
-        """ Check if user quicklink matches any page in pagelist.
-
-        @param pagelist: list of pages to check for quicklinks
-        @rtype: bool
-        @return: if user has quicklinked any page in pagelist
-        """
-        if not self.valid:
-            return False
-
-        for pagename in pagelist:
-            if pagename in self.quicklinks:
-                return True
-            interWikiName = self._interWikiName(pagename)
-            if interWikiName and interWikiName in self.quicklinks:
-                return True
-
-        return False
-
-    def addQuicklink(self, pagename):
-        """ Adds a page to the user quicklinks
-
-        If the wiki has an interwiki name, all links are saved as
-        interwiki names. If not, as simple page name.
-
-        @param pagename: page name
-        @type pagename: unicode
-        @rtype: bool
-        @return: if pagename was added
-        """
-        changed = False
-        interWikiName = self._interWikiName(pagename)
-        if interWikiName:
-            if pagename in self.quicklinks:
-                self.quicklinks.remove(pagename)
-                changed = True
-            if interWikiName not in self.quicklinks:
-                self.quicklinks.append(interWikiName)
-                changed = True
-        else:
-            if pagename not in self.quicklinks:
-                self.quicklinks.append(pagename)
-                changed = True
-
-        if changed:
-            self.save()
-        return changed
-
-    def removeQuicklink(self, pagename):
-        """ Remove a page from user quicklinks
-
-        Remove both interwiki and simple name from quicklinks.
-
-        @param pagename: page name
-        @type pagename: unicode
-        @rtype: bool
-        @return: if pagename was removed
-        """
-        changed = False
-        interWikiName = self._interWikiName(pagename)
-        if interWikiName and interWikiName in self.quicklinks:
-            self.quicklinks.remove(interWikiName)
-            changed = True
-        if pagename in self.quicklinks:
-            self.quicklinks.remove(pagename)
-            changed = True
-
-        if changed:
-            self.save()
-        return changed
-
-    def _interWikiName(self, pagename):
-        """ Return the inter wiki name of a page name
-
-        @param pagename: page name
-        @type pagename: unicode
-        """
-        if not self._cfg.interwikiname:
-            return None
-
-        return "%s:%s" % (self._cfg.interwikiname, pagename)
-
-    # -----------------------------------------------------------------
-    # Trail
-
-    def _wantTrail(self):
-        return (not self.valid and self._request.session.is_stored  # anon session
-                or self.valid and (self.show_page_trail or self.remember_last_visit))  # logged-in session
-
-    def addTrail(self, page):
-        """ Add page to trail.
-
-        @param page: the page (object) to add to the trail
-        """
-        if self._wantTrail():
-            # load trail if not known
-            self.getTrail()
-
-            pagename = page.page_name
-            # Add only existing pages that the user may read
-            if not (page.exists() and self._request.user.may.read(pagename)):
-                return
-
-            # Save interwiki links internally
-            if self._cfg.interwikiname:
-                pagename = self._interWikiName(pagename)
-
-            # Don't append tail to trail ;)
-            if self._trail and self._trail[-1] == pagename:
-                return
-
-            # Append new page, limiting the length
-            self._trail = [p for p in self._trail if p != pagename]
-            self._trail = self._trail[-(self._cfg.trail_size-1):]
-            self._trail.append(pagename)
-            self.saveTrail()
-
-    def saveTrail(self):
-        """ Save trail into session """
-        if not self._request.session.is_new:
-            self._request.session['trail'] = self._trail
-
-    def getTrail(self):
-        """ Return list of recently visited pages.
-
-        @rtype: list
-        @return: pages in trail
-        """
-        if not self._trail and self._wantTrail():
-            trail = self._request.session.get('trail', [])
-            trail = [t.strip() for t in trail]
-            trail = [t for t in trail if t]
-            self._trail = trail[-self._cfg.trail_size:]
-
-        return self._trail
-
-    # -----------------------------------------------------------------
-    # Other
-
-    def isCurrentUser(self):
-        """ Check if this user object is the user doing the current request """
-        return self._request.user.name == self.name
-
-    def isSuperUser(self):
-        """ Check if this user is superuser """
-        request = self._request
-        if request.cfg.DesktopEdition and request.remote_addr == '127.0.0.1' and request.user and request.user.valid:
-            # the DesktopEdition gives any local user superuser powers
-            return True
-        superusers = request.cfg.superuser
-        assert isinstance(superusers, (list, tuple))
-        return self.valid and self.name and self.name in superusers
-
-    def host(self):
-        """ Return user host """
-        _ = self._request.getText
-        host = self.isCurrentUser() and self._cfg.show_hosts and self._request.remote_addr
-        return host or _("<unknown>")
-
-    def wikiHomeLink(self):
-        """ Return wiki markup usable as a link to the user homepage,
-            it doesn't matter whether it already exists or not.
-        """
-        wikiname, pagename = wikiutil.getInterwikiHomePage(self._request, self.name)
-        if wikiname == 'Self':
-            if wikiutil.isStrictWikiname(self.name):
-                markup = pagename
-            else:
-                markup = '[[%s]]' % pagename
-        else:
-            markup = '[[%s:%s]]' % (wikiname, pagename)
-        return markup
-
-    def signature(self):
-        """ Return user signature using wiki markup
-
-        Users sign with a link to their homepage.
-        Visitors return their host address.
-
-        TODO: The signature use wiki format only, for example, it will
-        not create a link when using rst format. It will also break if
-        we change wiki syntax.
-        """
-        if self.name:
-            return self.wikiHomeLink()
-        else:
-        ### HACK SAUVAGE 2/2
-        #    return self.host()
-            try:
-                hostname = socket.gethostbyaddr(self.host())[0]
-            except socket.herror:
-                hostname = self.host()
-            if (hostname+'.').split('.', 1)[1] in ['crans.org.', 'wifi.crans.org.']:
-                hostname = hostname.split('.',1)[0]
-            return hostname
-        ### FIN HACK 2/2
-
-    def generate_recovery_token(self):
-        key = random_string(64, "abcdefghijklmnopqrstuvwxyz0123456789")
-        msg = str(int(time.time()))
-        h = hmac.new(key, msg, sha).hexdigest()
-        self.recoverpass_key = key
-        self.save()
-        return msg + '-' + h
-
-    def apply_recovery_token(self, tok, newpass):
-        key = self.recoverpass_key
-        parts = tok.split('-')
-        if len(parts) != 2:
-            return False
-        try:
-            stamp = int(parts[0])
-        except ValueError:
-            return False
-        # only allow it to be valid for twelve hours
-        if stamp + 12*60*60 < time.time():
-            return False
-        # check hmac
-        h = hmac.new(self.recoverpass_key, str(stamp), sha).hexdigest()
-        if h != parts[1]:
-            return False
-        self.recoverpass_key = ""
-        self.enc_password = encodePassword(newpass)
-        self.save()
-        return True
-
-    def mailAccountData(self, cleartext_passwd=None):
-        """ Mail a user who forgot his password a message enabling
-            him to login again.
-        """
-        from MoinMoin.mail import sendmail
-        from MoinMoin.wikiutil import getLocalizedPage
-        _ = self._request.getText
-
-        tok = self.generate_recovery_token()
-
-        text = '\n' + _("""\
-Login Name: %s
-
-Password recovery token: %s
-
-Password reset URL: %s/?action=recoverpass&name=%s&token=%s
-""") % (
-                        self.name,
-                        tok,
-                        self._request.getBaseURL(),
-                        url_quote_plus(self.name),
-                        tok, )
-
-        text = _("""\
-Somebody has requested to email you a password recovery token.
-
-If you lost your password, please go to the password reset URL below or
-go to the password recovery page again and enter your username and the
-recovery token.
-""") + text
-
-
-        subject = _('[%(sitename)s] Your wiki account data',
-                ) % {'sitename': self._cfg.sitename or "Wiki"}
-        mailok, msg = sendmail.sendmail(self._request, [self.email], subject,
-                                    text, mail_from=self._cfg.mail_from)
-        return mailok, msg
-