Merge branch 'master' of ssh://bernie@trinity.codewiz.org/~/public_html/wiki/git...
authorBernie Innocenti <bernie@codewiz.org>
Sat, 11 Apr 2009 15:49:23 +0000 (17:49 +0200)
committerBernie Innocenti <bernie@codewiz.org>
Sat, 11 Apr 2009 15:49:23 +0000 (17:49 +0200)
Conflicts:
geekigeeki.py

1  2 
geekigeeki.py
macros/WordIndex.py

diff --combined geekigeeki.py
index 6e1ba6ea4a5a2c9ddd808ebe717d499d8cb8731e,f6ba26c967419f5c219d98d313bdc19932630883..d208bb723fa672890c99155a6791d93d921c29da
@@@ -1,9 -1,9 +1,9 @@@
 -#!/usr/bin/python
 +#!/usr/bin/python3.0
  # -*- coding: utf-8 -*-
  #
  # Copyright 1999, 2000 Martin Pool <mbp@humbug.org.au>
  # Copyright 2002 Gerardo Poggiali
- # Copyright 2007, 2008 Bernie Innocenti <bernie@codewiz.org>
+ # Copyright 2007, 2008, 2009 Bernie Innocenti <bernie@codewiz.org>
  #
  # This program is free software: you can redistribute it and/or modify
  # it under the terms of the GNU General Public License as published by
@@@ -30,18 -30,25 +30,25 @@@ import cgi, sys, os, re, errno, sta
  word_re = re.compile(r"^\b((([A-Z][a-z0-9]+){2,}/)*([A-Z][a-z0-9]+){2,})\b$")
  # FIXME: we accept stuff like foo/../bar and we shouldn't
  file_re = re.compile(r"^\b([A-Za-z0-9_\-][A-Za-z0-9_\.\-/]*)\b$")
- img_re = re.compile(r"^.*\.(png|gif|jpg|jpeg|bmp|ico)$", re.IGNORECASE)
+ img_re = re.compile(r"^.*\.(png|gif|jpg|jpeg|bmp|ico|ogm|ogg|mkv|mpg|mpeg|mp4|avi|asf|flv|wmv|qt)$", re.IGNORECASE)
+ video_re = re.compile(r"^.*\.(ogm|ogg|mkv|mpg|mpeg|mp4|avi|asf|flv|wmv|qt)$", re.IGNORECASE)
  url_re = re.compile(r"^[a-z]{3,8}://[^\s'\"]+\S$")
- link_re = re.compile("(?:\[\[|{{)([^\s\|]+)(?:\s*\|\s*([^\]]+)|)(?:\]\]|}})")
+ link_re = re.compile(r"(?:\[\[|{{)([^\s\|]+)(?:\s*\|\s*([^\]]+)|)(?:\]\]|}})")
+ ext_re = re.compile(r"\.([^\./]+)$")
  
  title_done = False
  
  # CGI stuff ---------------------------------------------------------
  def script_name():
      return os.environ.get('SCRIPT_NAME', '')
  
+ def query_string():
+     path_info = os.environ.get('PATH_INFO', '')
+     if len(path_info) and path_info[0] == '/':
+         return path_info[1:] or 'FrontPage'
+     else:
+         return os.environ.get('QUERY_STRING', '') or 'FrontPage'
  def privileged_path():
      return privileged_url or script_name()
  
@@@ -61,53 -68,36 +68,35 @@@ def get_hostname(addr)
      except Exception:
          return addr
  
+ def is_external_url(pathname):
+     return (url_re.match(pathname) or pathname.startswith('/'))
  def relative_url(pathname, privileged=False):
-     if not (url_re.match(pathname) or pathname.startswith('/')):
+     if not is_external_url(pathname):
          if privileged:
              url = privileged_path()
          else:
              url = script_name()
          pathname = url + '/' + pathname
-     return pathname
+     return cgi.escape(pathname, quote=True)
  
  def permalink(s):
      return re.sub(' ', '-', re.sub('[^a-z0-9_ ]', '', s.lower()).strip())
  
  # Formatting stuff --------------------------------------------------
  def emit_header(mime_type="text/html"):
 -    print "Content-type: " + mime_type + "; charset=utf-8\n"
 +    print("Content-type: " + mime_type + "; charset=utf-8\n")
  
  def send_guru(msg_text, msg_type):
      if not msg_text: return
 -    print '<pre id="guru" onclick="this.style.display = \'none\'" class="' + msg_type + '">'
 +    print('<pre id="guru" onclick="this.style.display = \'none\'" class="' + msg_type + '">')
      if msg_type == 'error':
 -        print '    Software Failure.  Press left mouse button to continue.\n'
 -    print msg_text
 +        print('    Software Failure.  Press left mouse button to continue.\n')
 +    print(msg_text)
      if msg_type == 'error':
-         print('\n      Guru Meditation #DEADBEEF.ABADC0DE')
-     print('</pre>')
-     # FIXME: This little JS snippet is harder to pass than ACID 3.0 
-     print("""
-     <script language="JavaScript" type="text/javascript">
-         var guru = document.getElementById('guru');
-         // Firefox 2.0 doesn't take border-color, but returns border-top-color fine
-         var color = document.defaultView.getComputedStyle(guru,null).getPropertyValue('border-top-color');
-         function guruOn() {
-             guru.style.setProperty('border-color', color, '');
-             setTimeout('guruOff()', 1000);
-         }
-         function guruOff() {
-             guru.style.setProperty('border-color', '#000000', '');
-             setTimeout('guruOn()', 1000);
-         }
-         // Safari 2.0 returns this rgba crap
-         // Konqueror 3.5.6 doesn't seem to support computed properties
-         if (color && color != 'rgba(0, 0, 0, 0)') {
-             //window.alert("enabled! color='" + color + "'");
-             guruOn();
-         }
-     </script>""")
+         print '\n           Guru Meditation #DEADBEEF.ABADC0DE'
 -    print '</pre>'
 -    print '<script language="JavaScript" type="text/javascript" src="%s" defer="defer"></script>' \
 -        % relative_url('sys/GuruMeditation.js')
++    print('</pre><script language="JavaScript" type="text/javascript" src="%s" defer="defer"></script>' \
++        % relative_url('sys/GuruMeditation.js'))
  
  def send_title(name, text="Limbo", msg_text=None, msg_type='error', writable=False):
      global title_done
  
      # Head
      emit_header()
 -    print '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"'
 -    print '  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
 -    print '<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">'
 +    print('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"')
 +    print('  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">')
 +    print('<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">')
  
 -    print "<head><title>%s: %s</title>" % (site_name, text)
 -    print ' <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=utf-8" />'
 +    print("<head><title>%s: %s</title>" % (site_name, text))
 +    print(' <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=utf-8" />')
      if not name:
 -        print ' <meta name="robots" content="noindex,nofollow" />'
 +        print(' <meta name="robots" content="noindex,nofollow" />')
  
      for meta in meta_urls:
          http_equiv, content = meta
 -        print ' <meta http-equiv="%s" content="%s" />' % (http_equiv, relative_url(content))
 +        print(' <meta http-equiv="%s" content="%s" />' % (http_equiv, relative_url(content)))
  
      for link in link_urls:
          rel, href = link
 -        print ' <link rel="%s" href="%s" />' % (rel, relative_url(href))
 +        print(' <link rel="%s" href="%s" />' % (rel, relative_url(href)))
  
      if name and writable and privileged_url is not None:
 -        print ' <link rel="alternate" type="application/x-wiki" title="Edit this page" href="%s" />' \
 -            % (privileged_path() + '?edit=' + name)
 +        print(' <link rel="alternate" type="application/x-wiki" title="Edit this page" href="%s" />' \
 +            % (privileged_path() + '?edit=' + name))
  
      if history_url is not None:
 -        print ' <link rel="alternate" type="application/rss+xml" title="RSS" href="%s" />' \
 -            % relative_url(history_url + '?a=rss')
 +        print(' <link rel="alternate" type="application/rss+xml" title="RSS" href="%s" />' \
 +            % relative_url(history_url + '?a=rss'))
  
 -    print '</head>'
 +    print('</head>')
  
      # Body
      if name and writable and privileged_url is not None:
 -        print '<body ondblclick="location.href=\'' + privileged_path() + '?edit=' + name + '\'">'
 +        print('<body ondblclick="location.href=\'' + privileged_path() + '?edit=' + name + '\'">')
      else:
 -        print '<body>'
 +        print('<body>')
  
      title_done = True
      send_guru(msg_text, msg_type)
  
      # Navbar
 -    print '<div class="nav">'
 +    print('<div class="nav">')
+     print link_tag('FrontPage', site_icon or 'Home', 'navlink')
      if name:
 -        print '  <b>' + link_tag('?fullsearch=' + name, text, 'navlink') + '</b> '
 +        print('  <b>' + link_tag('?fullsearch=' + name, text, 'navlink') + '</b> ')
      else:
 -        print '  <b>' + text + '</b> '
 -    print ' | ' + link_tag('FindPage', 'Find Page', 'navlink')
 +        print('  <b>' + text + '</b> ')
-     print(' | ' + link_tag('FrontPage', 'Home', 'navlink'))
 +    print(' | ' + link_tag('FindPage', 'Find Page', 'navlink'))
      if 'history_url' in globals():
 -        print ' | <a href="' + relative_url(history_url) + '" class="navlink">Recent Changes</a>'
 +        print(' | <a href="' + relative_url(history_url) + '" class="navlink">Recent Changes</a>')
          if name:
 -            print ' | <a href="' + relative_url(history_url + '?a=history;f=' + name) + '" class="navlink">Page History</a>'
 +            print(' | <a href="' + relative_url(history_url + '?a=history;f=' + name) + '" class="navlink">Page History</a>')
  
      if name:
 -        print ' | ' + link_tag('?raw=' + name, 'Raw Text', 'navlink')
 +        print(' | ' + link_tag('?raw=' + name, 'Raw Text', 'navlink'))
          if privileged_url is not None:
              if writable:
 -                print ' | ' + link_tag('?edit=' + name, 'Edit', 'navlink', privileged=True)
 +                print(' | ' + link_tag('?edit=' + name, 'Edit', 'navlink', privileged=True))
              else:
 -                print ' | ' + link_tag(name, 'Login', 'navlink', privileged=True)
 +                print(' | ' + link_tag(name, 'Login', 'navlink', privileged=True))
  
      else:
 -        print ' | <i>Immutable Page</i>'
 +        print(' | <i>Immutable Page</i>')
  
      user = remote_user()
      if user != 'AnonymousCoward':
-         print(' | <span class="login"><i>logged in as <b>' + cgi.escape(user) + '</b></i></span>')
 -        print ' | <span class="login"><i><b>' + link_tag('User/' + user, user) + '</b></i></span>'
++        print(' | <span class="login"><i><b>' + link_tag('User/' + user, user) + '</b></i></span>')
  
 -    print '<hr /></div>'
 +    print('<hr /></div>')
  
  def send_httperror(status="403 Not Found", query=""):
 -    print "Status: %s" % status
 +    print("Status: %s" % status)
      send_title(None, msg_text=("%s: on query '%s'" % (status, query)))
      send_footer()
  
- def link_tag(params, text=None, ss_class=None, privileged=False):
+ def link_tag(params, text=None, link_class=None, privileged=False):
      if text is None:
          text = params # default
-     classattr = ''
-     if ss_class:
-         classattr += 'class="%s" ' % ss_class
-         # Prevent crawlers from following links potentially added by spammers or to generated pages
-         if ss_class == 'external' or ss_class == 'navlink':
-             classattr += 'rel="nofollow" '
-     elif url_re.match(params):
-         classattr += 'rel="nofollow" '
+     elif img_re.match(text):
+         text = '<img border="0" src="' + relative_url(text) + '" alt="' + text + '" />'
+     if not link_class:
+         if is_external_url(params):
+             link_class = 'external'
+         elif file_re.match(params) and Page(params).exists():
+             link_class = 'wikilink'
+         else:
+             params = nonexist_pfx + params
+             link_class = 'nonexistent'
+     classattr = 'class="%s" ' % link_class
+     # Prevent crawlers from following links potentially added by spammers or to generated pages
+     if link_class == 'external' or link_class == 'navlink':
+         classattr += 'rel="nofollow"'
      return '<a %shref="%s">%s</a>' % (classattr, relative_url(params, privileged=privileged), text)
  
+ def link_inline(name, descr=None, args=''):
+     if not descr: descr = name
+     url = relative_url(name)
+     if video_re.match(name):
+         return '<video src="%s">Your browser does not support the HTML5 video tag</video>' % url
+     elif img_re.match(name):
+         return '<a href="%s"><img border="0" src="%s" alt="%s" /></a>' % (url, url + args, descr)
+     elif file_re.match(name) and not ext_re.search(name): # FIXME: this guesses a wiki page
+         return Page(name).send_naked()
+     else:
+         return '<iframe width="100%%" scrolling="auto" frameborder="0" src="%s"><a href="%s">%s</a></iframe>' \
+             % (url, url, name)
  # Search ---------------------------------------------------
  
  def handle_fullsearch(needle):
      hits.sort()
      hits.reverse()
  
 -    print "<ul>"
 +    print("<ul>")
      for (count, page_name) in hits:
-         print('<li><p>' + Page(page_name).link_to())
-         print(' . . . . ' + str(count))
 -        print '<li><p>' + link_tag(page_name)
 -        print ' . . . . ' + `count`
 -        print ['match', 'matches'][count != 1]
 -        print '</p></li>'
 -    print "</ul>"
++        print('<li><p>' + link_tag(page_name))
++        print(' . . . . ' + `count`)
 +        print(['match', 'matches'][count != 1])
 +        print('</p></li>')
 +    print("</ul>")
  
      print_search_stats(len(hits), len(all_pages))
  
@@@ -234,17 -246,17 +245,17 @@@ def handle_titlesearch(needle)
  
      needle_re = re.compile(needle, re.IGNORECASE)
      all_pages = page_list()
 -    hits = filter(needle_re.search, all_pages)
 +    hits = list(filter(needle_re.search, all_pages))
  
 -    print "<ul>"
 +    print("<ul>")
      for filename in hits:
-         print('<li><p>' + Page(filename).link_to() + "</p></li>")
 -        print '<li><p>' + link_tag(filename) + "</p></li>"
 -    print "</ul>"
++        print('<li><p>' + link_tag(filename) + "</p></li>")
 +    print("</ul>")
  
      print_search_stats(len(hits), len(all_pages))
  
  def print_search_stats(hits, searched):
 -    print "<p>%d hits out of %d pages searched.</p>" % (hits, searched)
 +    print("<p>%d hits out of %d pages searched.</p>" % (hits, searched))
  
  def handle_raw(pagename):
      if not file_re.match(pagename):
@@@ -275,9 -287,10 +286,10 @@@ def handle_edit(pagename)
              text = form['savetext'].value
          pg.send_editor(text)
  
+ # Used by macros/WordIndex and macros/TitleIndex
  def make_index_key():
 -    links = map(lambda ch: '<a href="#%s">%s</a>' % (ch, ch), 'abcdefghijklmnopqrstuvwxyz')
 -    return '<p style="text-align: center">'+ ' | '.join(links) + '</p>'
 +    links = ['<a href="#%s">%s</a>' % (ch, ch) for ch in 'abcdefghijklmnopqrstuvwxyz']
-     return '<p><center>'+ ' | '.join(links) + '</center></p>'
++    return '<p style="text-align: center">' + ' | '.join(links) + '</p>'
  
  def page_list(dirname = None, re = word_re):
      return sorted(filter(re.match, os.listdir(dirname or data_dir)))
@@@ -287,16 -300,16 +299,16 @@@ def send_footer(mod_string=None)
          cgi.print_arguments()
          cgi.print_form(form)
          cgi.print_environ()
 -    print '''
 +    print('''
  <div id="footer"><hr />
  <p class="copyright">
- <a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/"><img class="license" alt="Creative Commons License" src="http://i.creativecommons.org/l/by-sa/3.0/80x15.png" /></a>
+ <a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/"><img class="license" alt="Creative Commons License" src="%s" /></a>
  <span class="benchmark">generated in %0.3fs</span> by <a href="http://www.codewiz.org/wiki/GeekiGeeki">GeekiGeeki</a> version %s
  </p>
- ''' % (clock() - start_time, __version__))
 -''' % (relative_url('cc-by-sa.png'), clock() - start_time, __version__)
++''' % (relative_url('cc-by-sa.png'), clock() - start_time, __version__))
      if mod_string:
 -        print '<p class="modified">last modified %s</p>' % mod_string
 -    print '</div></body></html>'
 +        print('<p class="modified">last modified %s</p>' % mod_string)
 +    print('</div></body></html>')
  
  class WikiFormatter:
      """Object that turns Wiki markup into HTML.
          self.styles = {
              #wiki   html   enabled?
              "//":  ["em",  False],
-             "''":  ["em",  False],
              "**":  ["b",   False],
-             "'''": ["b",   False],
              "##":  ["tt",  False],
-             "``":  ["tt",  False],
              "__":  ["u",   False],
              "^^":  ["sup", False],
-             ",,":  ["sub", False]
+             ",,":  ["sub", False],
+             "''":  ["em",  False], # LEGACY
+             "'''": ["b",   False], # LEGACY
+             "``":  ["tt",  False], # LEGACY
          }
  
      def _b_repl(self, word):
      def _rule_repl(self, word):
          return self._undent() + '\n<hr size="%d" noshade="noshade" />\n' % (len(word) - 2)
  
-     def _word_repl(self, word):
-         return Page(word).link_to()
-     def _img_repl(self, word):
-         pathname = relative_url(word)
-         return '<a href="%s"><img border="0" src="%s" /></a>' % (pathname, pathname)
-     def _url_repl(self, word):
-         if img_re.match(word):
-             return '<a href="%s"><img border="0" src="%s" /></a>' % (word, word)
-         else:
-             return '<a href="%s" rel="nofollow" class="external">%s</a>' % (word, word)
      def _macro_repl(self, word):
          m = re.compile("\<\<([^\s\|\>]+)(?:\s*\|\s*([^\>]+)|)\>\>").match(word)
          name = m.group(1)
          argv = [name]
          if m.group(2):
              argv.extend(m.group(2).split('|'))
 -        argv = map(str.strip, argv)
 +        argv = list(map(str.strip, argv))
  
          macro = globals().get('_macro_' + name)
          if not macro:
              try:
 -                execfile("macros/" + name + ".py", globals())
 -            except IOError, err:
 +                exec(open("macros/" + name + ".py").read(), globals())
 +            except IOError as err:
                  if err.errno == errno.ENOENT: pass
              macro = globals().get('_macro_' + name)
          if macro:
              return macro(argv)
          else:
-             return '<strong class="error">&lt;&lt;' + '|'.join(argv) + '&gt;&gt;</strong>'
+             msg = '&lt;&lt;' + '|'.join(argv) + '&gt;&gt;'
+             if not self.in_html:
+                 msg = '<strong class="error">' + msg + '</strong>'
+             return msg
  
      def _hurl_repl(self, word):
          m = link_re.match(word)
-         name = m.group(1)
-         descr = m.group(2)
-         if descr is None:
-             descr = name
-         elif img_re.match(m.group(2)):
-             descr = '<img border="0" src="' + descr + '" />'
-         return link_tag(name, descr, 'wikilink')
+         return link_tag(m.group(1), m.group(2))
  
      def _inl_repl(self, word):
-         m = link_re.match(word)
-         name = m.group(1)
-         descr = m.group(2) or name
-         name = relative_url(name)
-         argv = descr.split('|')
-         descr = argv.pop(0)
+         (name, descr) = link_re.match(word).groups()
  
-         if argv:
-             args = '?' + '&amp;'.join(argv)
-         else:
+         if descr:
+             argv = descr.split('|')
+             descr = argv.pop(0)
              args = ''
+             if argv:
+                 args = '?' + '&amp;'.join(argv)
  
-         if descr:
              # The "extthumb" nonsense works around a limitation of the HTML block model
-             return '<div class="extthumb"><div class="thumb"><a href="%s"><img border="0" src="%s" alt="%s" /></a><div class="caption">%s</div></div></div>' \
-                     % (name, name + args, descr, descr)
+             return '<div class="extthumb"><div class="thumb">' \
+                 + link_inline(name, descr, args) \
+                 + '<div class="caption">' + descr + '</div></div></div>'
          else:
-             return '<a href="%s"><img border="0" src="%s" /></a>' % (name, name + args)
-     def _email_repl(self, word):
-         return '<a href="mailto:%s">%s</a>' % (word, word)
+             return link_inline(name, name)
  
      def _html_repl(self, word):
+         if not self.in_html and word.startswith('<div'): word = '</p>' + word
          self.in_html += 1
          return word; # Pass through
  
+     def _htmle_repl(self, word):
+         self.in_html -= 1
+         if not self.in_html and word.startswith('</div'): word += '<p>'
+         return word; # Pass through
      def _ent_repl(self, s):
-         if self.in_html and s == '>':
-             self.in_html -= 1
-             return '>'
+         if self.in_html:
+             return s; # Pass through
          return {'&': '&amp;',
                  '<': '&lt;',
                  '>': '&gt;'}[s]
  
+     def _img_repl(self, word): # LEGACY
+         return self._inl_repl('{{' + word + '}}')
+     def _word_repl(self, word): # LEGACY
+         if self.in_html: return word # pass through
+         return link_tag(word)
+     def _url_repl(self, word): # LEGACY
+         if self.in_html: return word # pass through
+         return link_tag(word)
+     def _email_repl(self, word): # LEGACY
+         if self.in_html: return word # pass through
+         return '<a href="mailto:%s">%s</a>' % (word, word)
      def _li_repl(self, match):
          if self.in_li:
              return '</li><li>'
          return res
  
      def replace(self, match):
 -        for rule, hit in match.groupdict().items():
 +        for rule, hit in list(match.groupdict().items()):
              if hit:
                  return getattr(self, '_' + rule + '_repl')(hit)
          else:
              raise "Can't handle match " + repr(match)
  
      def print_html(self):
 -        print '<div class="wiki"><p>'
 +        print('<div class="wiki"><p>')
  
-         # For each line, we scan through looking for magic
-         # strings, outputting verbatim any intervening text
-         # TODO: highlight search words (look at referrer)
-         scan_re = re.compile(
-             r"(?:"
-             # Formatting
-             + r"(?P<b>\*\*|'''|//|''|##|``|__|\^\^|,,)"
-             + r"|(?P<tit>\={2,6})"
-             + r"|(?P<br>\\\\)"
-             + r"|(?P<rule>^-{3,})"
-             + r"|(?P<hi>\b(FIXME|TODO|DONE)\b)"
+         scan_re = re.compile(r"""(?:
+             # Styles and formatting
+               (?P<b>     \*\*|'''|//|''|\#\#|``|__|\^\^|,,)
+             | (?P<tit>   \={2,6})
+             | (?P<br>    \\\\)
+             | (?P<rule>  ^-{3,})
+             | (?P<hi>    \b( FIXME | TODO | DONE )\b )
  
              # Links
-             + r"|(?P<macro>\<\<([^\s\|\>]+)(?:\s*\|\s*([^\>]+)|)\>\>)"
-             + r"|(?P<hurl>\[\[([^\s\|]+)(?:\s*\|\s*([^\]]+)|)\]\])"
+             | (?P<macro> \<\<([^\s\|\>]+)(?:\s*\|\s*([^\>]+)|)\>\>)
+             | (?P<hurl>  \[\[([^\s\|]+)(?:\s*\|\s*([^\]]+)|)\]\])
  
              # Inline HTML
-             + r"|(?P<html><(/|)(br|hr|div|span|form|iframe|input|textarea|a|img|h[1-5])[^>]*>)"
-             + r"|(?P<ent>[<>&])"
+             | (?P<html>  <(br|hr|div|span|form|iframe|input|textarea|a|img|h[1-5])\b )
+             | (?P<htmle> ( /\s*> | </(br|hr|div|span|form|iframe|input|textarea|a|img|h[1-5])> ) )
+             | (?P<ent>   [<>&] )
  
              # Auto links (LEGACY)
-             + r"|(?P<img>\b[a-zA-Z0-9_/-]+\.(png|gif|jpg|jpeg|bmp|ico))"
-             + r"|(?P<word>\b(?:[A-Z][a-z]+){2,}\b)"
-             + r"|(?P<url>(http|https|ftp|mailto)\:[^\s'\"]+\S)"
-             + r"|(?P<email>[-\w._+]+\@[\w.-]+)"
+             | (?P<img>   \b[a-zA-Z0-9_/-]+\.(png|gif|jpg|jpeg|bmp|ico|ogm|ogg|mkv|mpg|mpeg|mp4|avi|asf|flv|wmv|qt))
+             | (?P<word>  \b(?:[A-Z][a-z]+){2,}\b)
+             | (?P<url>   (http|https|ftp|mailto)\:[^\s'\"]+\S)
+             | (?P<email> [-\w._+]+\@[\w.-]+)
  
              # Lists, divs, spans
-             + r"|(?P<li>^\s+[\*#] +)"
-             + r"|(?P<pre>\{\{\{|\s*\}\}\})"
-             + r"|(?P<inl>\{\{([^\s\|]+)(?:\s*\|\s*([^\]]+)|)\}\})"
+             | (?P<li>    ^\s+[\*\#]\s+)
+             | (?P<pre>   \{\{\{|\s*\}\}\})
+             | (?P<inl>   \{\{([^\s\|]+)(?:\s*\|\s*([^\]]+)|)\}\})
  
              # Tables
-             + r"|(?P<tr>^\s*\|\|(=|)\s*)"
-             + r"|(?P<tre>\s*\|\|(=|)\s*$)"
-             + r"|(?P<td>\s*\|\|(=|)\s*)"
-             + r")")
-         pre_re = re.compile(
-             r"(?:"
-             + r"(?P<pre>\s*\}\}\})"
-             + r"|(?P<ent>[<>&])"
-             + r")")
+             | (?P<tr>    ^\s*\|\|(=|)\s*)
+             | (?P<tre>   \s*\|\|(=|)\s*$)
+             | (?P<td>    \s*\|\|(=|)\s*)
+             # TODO: highlight search words (look at referrer)
+           )""", re.VERBOSE)
+         pre_re = re.compile("""(?:
+               (?P<pre>\s*\}\}\})
+             | (?P<ent>[<>&])"
+             )""", re.VERBOSE)
          blank_re = re.compile(r"^\s*$")
          indent_re = re.compile(r"^\s*")
          tr_re = re.compile(r"^\s*\|\|")
          eol_re = re.compile(r"\r?\n")
 -
+         # For each line, we scan through looking for magic strings, outputting verbatim any intervening text
 -        for self.line in eol_re.split(self.raw.expandtabs()):
 +        for self.line in eol_re.split(str(self.raw.expandtabs(), 'utf-8')):
              # Skip pragmas
              if self.in_header:
                  if self.line.startswith('#'):
                  self.in_header = False
  
              if self.in_pre:
 -                print re.sub(pre_re, self.replace, self.line)
 +                print(re.sub(pre_re, self.replace, self.line))
              else:
                  if self.in_table and not tr_re.match(self.line):
                      self.in_table = False
 -                    print '</tbody></table><p>'
 +                    print('</tbody></table><p>')
  
                  if blank_re.match(self.line):
 -                    print '</p><p>'
 +                    print('</p><p>')
                  else:
                      indent = indent_re.match(self.line)
 -                    print self._indent_to(len(indent.group(0))) ,
 -                    print re.sub(scan_re, self.replace, self.line)
 +                    print(self._indent_to(len(indent.group(0))), end=' ')
 +                    print(re.sub(scan_re, self.replace, self.line))
  
 -        if self.in_pre: print '</pre>'
 -        if self.in_table: print '</tbody></table><p>'
 -        print self._undent()
 -        print '</p></div>'
 +        if self.in_pre: print('</pre>')
 +        if self.in_table: print('</tbody></table><p>')
 +        print(self._undent())
 +        print('</p></div>')
  
  class Page:
      def __init__(self, page_name):
          return os.path.join(data_dir, self.page_name)
  
      def _tmp_filename(self):
 -        return os.path.join(data_dir, ('#' + self.page_name.replace('/','_') + '.' + `os.getpid()` + '#'))
 +        return os.path.join(data_dir, ('#' + self.page_name.replace('/','_') + '.' + str(os.getpid()) + '#'))
  
      def exists(self):
          try:
              os.stat(self._filename())
              return True
 -        except OSError, err:
 +        except OSError as err:
              if err.errno == errno.ENOENT:
                  return False
              raise err
  
-     def link_to(self):
-         word = self.page_name
-         if self.exists():
-             return link_tag(word, word, 'wikilink')
-         else:
-             return link_tag(word, nonexist_pfx + word, 'nonexistent')
-     def get_raw_body(self):
+     def get_raw_body(self, default=None):
          try:
              return open(self._filename(), 'rb').read()
 -        except IOError, err:
 +        except IOError as err:
              if err.errno == errno.ENOENT:
-                 return '' # just doesn't exist, use default
+                 if default is None:
+                     default = '//[[?edit=%s|Describe %s]]//' % (self.page_name, self.page_name)
+                 return default
              if err.errno == errno.EISDIR:
                  return self.format_dir()
              raise err
          if not '_pragmas' in self.__dict__:
              self._pragmas = {}
              try:
 -                f = open(self._filename(), 'rt')
 +                file = open(self._filename(), 'rt')
                  attr_re = re.compile(r"^#(\S*)(.*)$")
 -                for line in f:
 +                for line in file:
                      m = attr_re.match(line)
                      if not m:
                          break
                      self._pragmas[m.group(1)] = m.group(2).strip()
 -                    #print "bernie: _pragmas[" + m.group(1) + "] = " + m.group(2) + "<br>\n"
 -            except IOError, err:
 +                    #print "bernie: pragmas[" + m.group(1) + "] = " + m.group(2) + "<br>\n"
 +            except IOError as err:
                  if err.errno != errno.ENOENT and err.errno != errno.EISDIR:
 -                    raise err
 +                    raise er
          return self._pragmas
  
      def pragma(self, name, default):
          try:
              from time import localtime, strftime
              modtime = localtime(os.stat(self._filename())[stat.ST_MTIME])
 -        except OSError, err:
 +        except OSError as err:
              if err.errno != errno.ENOENT:
                  raise err
              return None
          if 'file' in form:
              filename = form['file'].value
  
 -        print ('<p><b>Editing ' + self.page_name
 +        print(('<p><b>Editing ' + self.page_name
              + ' for ' + cgi.escape(remote_user())
              + ' from ' + cgi.escape(get_hostname(remote_host()))
 -            + '</b></p>')
 -        print '<div class="editor"><form name="editform" method="post" enctype="multipart/form-data" action="%s">' % relative_url(self.page_name)
 -        print '<input type="hidden" name="edit" value="%s">' % (self.page_name)
 -        print '<input type="input" id="editor" name="changelog" value="Edit page %s" accesskey="c" /><br />' % (self.page_name)
 -        print '<textarea wrap="off" spellcheck="true" id="editor" name="savetext" rows="17" cols="100" accesskey="e">%s</textarea>' \
 -            % cgi.escape(preview or self.get_raw_body(default=''))
 -        print '<label for="file" accesskey="u">Or Upload a file:</label> <input type="file" name="file" value="%s" />' % filename
 -        print """
 +            + '</b></p>'))
 +        print('<div class="editor"><form name="editform" method="post" enctype="multipart/form-data" action="%s">' % relative_url(self.page_name))
 +        print('<input type="hidden" name="edit" value="%s">' % (self.page_name))
 +        print('<input type="input" id="editor" name="changelog" value="Edit page %s" accesskey="c" /><br />' % (self.page_name))
-         print('<textarea wrap="off" spellcheck="true" id="editor" name="savetext" rows="17" cols="100" accesskey="e">%s</textarea>' % cgi.escape(preview or self.get_raw_body()))
++        print('<textarea wrap="off" spellcheck="true" id="editor" name="savetext" rows="17" cols="100" accesskey="e">%s</textarea>' \
++            % cgi.escape(preview or self.get_raw_body(default='')))
 +        print('<label for="file" accesskey="u">Or Upload a file:</label> <input type="file" name="file" value="%s" />' % filename)
 +        print("""
              <br />
              <input type="submit" name="save" value="Save" accesskey="s">
              <input type="submit" name="preview" value="Preview" accesskey="p" />
              document.editform.savetext.focus()
              //-->
              </script>
 -            """
 -        print "<p>" + link_tag('EditingTips') + "</p>"
 +            """)
-         print("<p>" + Page('EditingTips').link_to() + "</p>")
++        print("<p>" + link_tag('EditingTips') + "</p>")
          if preview:
 -            print "<div class='preview'>"
 +            print("<div class='preview'>")
              WikiFormatter(preview).print_html()
 -            print "</div>"
 +            print("</div>")
          send_footer()
  
-     def send_raw(self, mimetype='text/plain'):
-         if self.can_read():
-             body = self.get_raw_body()
-             emit_header(mimetype)
-             print(body)
-         else:
+     def send_raw(self, mimetype='text/plain', args=[]):
+         if not self.can_read():
              send_title(None, msg_text='Read access denied by ACLs', msg_type='notice')
+             return
  
-     def send_image(self, mimetype, args=[]):
          if 'maxwidth' in args:
              import subprocess
              emit_header(mimetype)
              subprocess.check_call(['gm', 'convert', self._filename(),
                  '-scale', args['maxwidth'].value + ' >', '-'])
          else:
-             self.send_raw(mimetype)
+             body = self.get_raw_body()
+             emit_header(mimetype)
 -            print body
++            print(body)
  
      def _write_file(self, data):
          tmp_filename = self._tmp_filename()
              # Bad Bill!  POSIX rename ought to replace. :-(
              try:
                  os.remove(name)
 -            except OSError, err:
 +            except OSError as err:
                  if err.errno != errno.ENOENT: raise err
          os.rename(tmp_filename, name)
  
          self._write_file(newdata)
          rc = 0
          if post_edit_hook:
-             # FIXME: what's the std way to perform shell quoting in python?
-             cmd = ( post_edit_hook
-                 + " '" + data_dir + '/' + self.page_name
-                 + "' '" + remote_user()
-                 + "' '" + remote_host()
-               + "' '" + changelog + "'"
-             )
-             out = os.popen(cmd)
-             output = out.read()
-             rc = out.close()
+             import subprocess
+             cmd = [ post_edit_hook, data_dir + '/' + self.page_name, remote_user(), remote_host(), changelog]
+             child = subprocess.Popen(cmd, stdout=subprocess.PIPE, close_fds=True)
+             output = child.stdout.read()
+             rc = child.wait()
          if rc:
-             self.msg_text += "Post-editing hook returned %d.\n" % rc
-             self.msg_text += 'Command was: ' + cmd + '\n'
+             self.msg_text += "Post-editing hook returned %d. Command was:\n'%s'\n" % (rc, "' '".join(cmd))
              if output:
                  self.msg_text += 'Output follows:\n' + output
          else:
@@@ -803,30 -801,20 +799,20 @@@ def main()
              handler(form[cmd].value)
              break
      else:
-         path_info = os.environ.get('PATH_INFO', '')
-         if len(path_info) and path_info[0] == '/':
-             query = path_info[1:] or 'FrontPage'
-         else:
-             query = os.environ.get('QUERY_STRING', '') or 'FrontPage'
+         query = query_string()
          if file_re.match(query):
-             if word_re.match(query):
-                 Page(query).format()
+             # FIMXE: this is all bullshit, MimeTypes bases its guess on the extension!
+             from mimetypes import MimeTypes
+             mimetype, encoding = MimeTypes().guess_type(query)
+             if mimetype:
+                 Page(query).send_raw(mimetype=mimetype, args=form)
              else:
-                 from mimetypes import MimeTypes
-                 mimetype, encoding = MimeTypes().guess_type(query)
-                 if mimetype:
-                     if mimetype.startswith('image/'):
-                         Page(query).send_image(mimetype=mimetype, args=form)
-                     else:
-                         Page(query).send_raw(mimetype=mimetype)
-                 else:
-                     Page(query).format()
+                 Page(query).format()
          else:
              send_httperror("403 Forbidden", query)
  
  try:
 -    execfile("geekigeeki.conf.py")
 +    exec(open("geekigeeki.conf.py").read())
      form = cgi.FieldStorage()
      main()
  except Exception:
diff --combined macros/WordIndex.py
index 613efb5c2627989f940a4e60ec2ae685deefdbb1,818a8842b9d72fc45c5fc2918090038834068dda..6438d0b932d6bb8dc4794bd6ca82527a44e865a9
mode 100644,100755..100644
@@@ -10,22 -10,22 +10,22 @@@ def _macro_WordIndex(argv)
              except KeyError:
                  map[word] = [name]
  
 -    all_words = map.keys()
 +    all_words = list(map.keys())
      all_words.sort()
      last_letter = None
      # set title
      for word in all_words:
          letter = word[0].lower()
          if letter != last_letter:
-             s = s + '; <a name="%s"><h3>%s</h3></a>' % (letter, letter)
+             s += '<a name="%s"><h3>%s</h3></a>' % (letter, letter)
              last_letter = letter
  
-         s = s + '<b>%s</b><ul>' % word
+         s += '<b>%s</b><ul>' % word
          links = map[word]
          links.sort()
          last_page = None
          for name in links:
              if name == last_page: continue
-             s = s + '<li>' + Page(name).link_to()
-         s = s + '</ul>'
+             s += '<li>' + link_tag(name) + '</li>'
+         s += '</ul>'
      return s