Merge lp:~thomir-deactivatedaccount/wikkid/wikkid-improvments into lp:wikkid

[Thomi Richards]

Several small changes:

 * Added wiki text formatters for markdown and textile. To use these, you must have the python-markdown and python-textile packages installed, respectively.

 * User can now specify which wiki text format they want to use by default when running wikkid-serve. The default is still 'rest'.

 * User can now specify which network interface to listen on. Default is still 'localhost'

 * When requesting a directory that does not exist, we now give a nice page, rather than an error.

[lp:~thomir-deactivatedaccount/wikkid/wikkid-improvments]

65. By Thomi Richards on 2010-11-08

Added unit tests for markdown formatter.

66. By Thomi Richards on 2010-11-08

Added unit tests for recently added textile formatter.

67. By Thomi Richards on 2010-11-12

Implemented several changes, as requested by Tim.

Mainly:
 * ExecutionContext is no longer a singleton, and is passed in to all base views.

 * ExecutionContext class is no longer a singleton. It now derives from the dict
   type, and provides attribute-based lookup as well.

 * Fixed indentation, module imports, docstrings and some other things.

68. By Thomi Richards on 2010-11-12

Added simple unicode tests for markdown and textile formatters.

=== modified file 'Hacking.txt'
--- Hacking.txt	2010-07-12 19:02:14 +0000
+++ Hacking.txt	2010-11-12 09:13:57 +0000
@@ -29,7 +29,8 @@
   Currently there is the Bazaar based one, and a simplistic filestore that
   just uses some in-memory dictionaries.
 * **wikkid.formatter**: The different formatters used to render the text files
-  as HTML.  Currently there are formatters for Creold, ReST, and Pygments.
+  as HTML.  Currently there are formatters for Creold, ReST, textile, markdown 
+  and Pygments.
 * **wikkid.interface**: All the zope interface definitions are in this module.
 * **wikkid.model**: The model objects representing the different things that
   you end up hitting through file traversal, like missing pages, directories,

=== modified file 'ToDo.txt'
--- ToDo.txt	2010-07-12 18:34:03 +0000
+++ ToDo.txt	2010-11-12 09:13:57 +0000
@@ -7,8 +7,6 @@
 
 * Add in the ability to move pages
 
-* Add markdown and textile formatters
-
 * Lock pages as read-only (see also merging)
   Is this really locked, or is it a restricted ACL?
 

=== modified file 'bin/wikkid-serve'
--- bin/wikkid-serve	2010-06-13 11:12:22 +0000
+++ bin/wikkid-serve	2010-11-12 09:13:57 +0000
@@ -1,4 +1,5 @@
 #! /usr/bin/python
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2010 Wikkid Developers.
 #
@@ -23,6 +24,7 @@
 from wikkid.app import WikkidApp
 from wikkid.filestore.bzr import FileStore
 from wikkid.user.bzr import LocalBazaarUserMiddleware
+from wikkid.context import ExecutionContext
 
 
 def setup_logging():
@@ -39,11 +41,23 @@
 def main(args):
 
     usage = "Usage: %prog [options] <wiki-branch>"
-    parser = optparse.OptionParser(
-        usage=usage, description="Run a Wikkid Wiki server.", version=version)
+    parser = optparse.OptionParser(usage=usage, 
+                                   description="Run a Wikkid Wiki server.", 
+                                   version=version)
+    parser.add_option('--host', type='string', default='localhost',
+                      help='The interface to listen on. Defaults to \'localhost\'')
     parser.add_option('--port', type='int', default=8080,
                       help='The port to listen on.  Defaults to 8080.')
+    parser.add_option('--default-format', type='string', default='rest', 
+                      dest='default_formatter',
+                      help='Specify the default formatter to use. Defaults to \'rest\'')
     options, args = parser.parse_args(sys.argv[1:])
+    
+    # create execution context object, and add processed command line args to it
+    ec = ExecutionContext()
+    # kinda ugly, but the only way to do it. 
+    ec.add_context(vars(options))
+    
     if len(args) == 0:
         print "No branch location specified.\n"
         parser.print_usage()
@@ -61,11 +75,11 @@
     logger.info('Using: %s', working_tree)
     filestore = FileStore(working_tree)
 
-    app = WikkidApp(filestore)
+    app = WikkidApp(filestore, execution_context=ec)
     app = LocalBazaarUserMiddleware(app, working_tree.branch)
     from wsgiref.simple_server import make_server
-    httpd = make_server('localhost', options.port, app)
-    logger.info('Serving on http://localhost:%s', options.port)
+    httpd = make_server(options.host, options.port, app)
+    logger.info('Serving on http://%s:%s', options.host, options.port)
     try:
         httpd.serve_forever()
     except KeyboardInterrupt:

=== modified file 'wikkid/app.py'
--- wikkid/app.py	2010-07-12 18:21:42 +0000
+++ wikkid/app.py	2010-11-12 09:13:57 +0000
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2010 Wikkid Developers.
 #
@@ -19,18 +20,26 @@
 from wikkid.model.factory import ResourceFactory
 from wikkid.skin.loader import Skin
 from wikkid.view.urls import parse_url
+from wikkid.fileutils import FileIterable
+from wikkid.context import ExecutionContext
 
 
 def serve_file(filename):
     if os.path.exists(filename):
         basename = urlutils.basename(filename)
         content_type = mimetypes.guess_type(basename)[0]
-        f = open(filename, 'rb')
-        try:
-            return Response(
-                f.read(), content_type=content_type)
-        finally:
-            f.close()
+
+        res = Response(content_type=content_type, conditional_response=True)
+        res.app_iter = FileIterable(filename)
+        res.content_length = os.path.getsize(filename)
+        res.last_modified = os.path.getmtime(filename)
+        # Todo: is this the best value for the etag? 
+        # perhaps md5 would be a better alternative
+        res.etag = '%s-%s-%s' % (os.path.getmtime(filename),
+            os.path.getsize(filename),
+            hash(filename))
+        return res
+
     else:
         return HTTPNotFound()
 
@@ -38,7 +47,9 @@
 class WikkidApp(object):
     """The main wikkid application."""
 
-    def __init__(self, filestore, skin_name=None):
+    def __init__(self, filestore, skin_name=None, 
+                 execution_context = ExecutionContext()):
+        self.execution_context = execution_context
         self.filestore = filestore
         self.resource_factory = ResourceFactory(self.filestore)
         # Need to load the initial templates for the skin.
@@ -73,7 +84,7 @@
             resource_path, action = parse_url(path)
             model = self.resource_factory.get_resource_at_path(resource_path)
             try:
-                view = get_view(model, action, request)
+                view = get_view(model, action, request, self.execution_context)
                 response = view.render(self.skin)
             except HTTPException, e:
                 response = e

=== added file 'wikkid/context.py'
--- wikkid/context.py	1970-01-01 00:00:00 +0000
+++ wikkid/context.py	2010-11-12 09:13:57 +0000
@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2010 Wikkid Developers.
+#
+# This software is licensed under the GNU Affero General Public License
+# version 3 (see the file LICENSE).
+
+"""A means of storing execution context."""
+
+
+class ExecutionContext(dict):
+    """Store run-time execution context data.
+     
+    To use this class, create an instance of it, and either set key,value
+    pairs just like you would a dictionary, or call add_context(dict), 
+    passing in a dictionary of name,value pairs that you want to _append_
+    to the execution context.
+    
+    To retrieve values, you can either use the classic dictionary methods, 
+    or access options as attribute. So, this:
+    
+    ec['someOption']
+    
+    is equivilent to this:
+    
+    ec.someOption
+    """
+        
+    def add_context(self, contextDict):
+        if type(contextDict) is not dict:
+            raise TypeError, "Context must be a dictionary type."
+        self.update(contextDict)
+        
+    def __getattr__(self, name):
+        if self.has_key(name):
+            return self[name]
+        else:
+            raise AttributeError, "ExecutionContext instance has no attribute '%s'" % (name)
+        
+    def __setattr__(self, name, value):
+        self[name] = value
+        
+        

=== modified file 'wikkid/dispatcher.py'
--- wikkid/dispatcher.py	2010-06-13 11:41:41 +0000
+++ wikkid/dispatcher.py	2010-11-12 09:13:57 +0000
@@ -17,12 +17,13 @@
 
 from zope.interface import providedBy
 
+from wikkid.context import ExecutionContext
 
 # The view registry needs to map an Interface and a name to a class.
 _VIEW_REGISTRY = {}
 
 
-def get_view(obj, view_name, request):
+def get_view(obj, view_name, request, ec=ExecutionContext()):
     """Get the most relevant view for the object for the specified name.
 
     Iterate through the provided interfaces of the object and look in the view
@@ -32,7 +33,7 @@
     for interface in interfaces:
         try:
             klass = _VIEW_REGISTRY[(interface, view_name)]
-            instance = klass(obj, request)
+            instance = klass(obj, request, ec)
             instance.initialize()
             return instance
         except KeyError:

=== added file 'wikkid/fileutils.py'
--- wikkid/fileutils.py	1970-01-01 00:00:00 +0000
+++ wikkid/fileutils.py	2010-11-12 09:13:57 +0000
@@ -0,0 +1,58 @@
+  #
+# Copyright (C) 2010 Wikkid Developers.
+#
+# This software is licensed under the GNU Affero General Public License
+# version 3 (see the file LICENSE).
+
+"""A method of iterating over file contents
+
+This stops us reading the entire file into memory when we serve it.
+"""
+
+
+class FileIterable(object):
+    """An iterable file-like object."""
+    def __init__(self, filename, start=None, stop=None):
+        self.filename = filename
+        self.start = start
+        self.stop = stop
+        
+    def __iter__(self):
+        return FileIterator(self.filename, self.start, self.stop)
+        
+    def app_iter_range(self, start, stop):
+        return self.__class__(self.filename, start, stop)
+
+class FileIterator(object):
+    """Iterate over a file.
+    
+    FileIterable provides a simple file iterator, optionally allowing the
+    user to specify start and end ranges for the file.
+    """
+    chunk_size = 4096
+    def __init__(self, filename, start, stop):
+        self.filename = filename
+        self.fileobj = open(self.filename, 'rb')
+        if start:
+            self.fileobj.seek(start)
+        if stop is not None:
+            self.length = stop - start
+        else:
+            self.length = None
+            
+    def __iter__(self):
+        return self
+        
+    def next(self):
+        if self.length is not None and self.length <= 0:
+            raise StopIteration
+        chunk = self.fileobj.read(self.chunk_size)
+        if not chunk:
+            raise StopIteration
+        if self.length is not None:
+            self.length -= len(chunk)
+            if self.length < 0:
+                # Chop off the extra:
+                chunk = chunk[:self.length]
+        return chunk
+

=== added file 'wikkid/formatter/markdownformatter.py'
--- wikkid/formatter/markdownformatter.py	1970-01-01 00:00:00 +0000
+++ wikkid/formatter/markdownformatter.py	2010-11-12 09:13:57 +0000
@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2010 Wikkid Developers.
+#
+# This software is licensed under the GNU Affero General Public License
+# version 3 (see the file LICENSE).
+
+"""A text to html formatter using markdown."""
+
+import cgi
+import markdown
+from zope.interface import implements
+
+from wikkid.interface.formatter import ITextFormatter
+
+
+class MarkdownFormatter(object):
+    """Format source files as HTML using markdown."""
+
+    implements(ITextFormatter)
+
+    def format(self, filename, text):
+        """Format the text.
+        """
+        md = markdown.Markdown(safe_mode='replace')
+        return md.convert(text)
+

=== modified file 'wikkid/formatter/registry.py'
--- wikkid/formatter/registry.py	2010-06-09 11:29:38 +0000
+++ wikkid/formatter/registry.py	2010-11-12 09:13:57 +0000
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2010 Wikkid Developers
 #
@@ -11,6 +12,8 @@
 from wikkid.formatter.creoleformatter import CreoleFormatter
 from wikkid.formatter.pygmentsformatter import PygmentsFormatter
 from wikkid.formatter.restformatter import RestructuredTextFormatter
+from wikkid.formatter.markdownformatter import MarkdownFormatter
+from wikkid.formatter.textileformatter import TextileFormatter
 
 
 class FormatterRegistry(object):
@@ -18,9 +21,11 @@
 
     def __init__(self):
         self._formatters = {
+            'creole': CreoleFormatter(),
+            'markdown': MarkdownFormatter(),
+            'pygments': PygmentsFormatter(),
             'rest': RestructuredTextFormatter(),
-            'creole': CreoleFormatter(),
-            'pygments': PygmentsFormatter()
+            'textile': TextileFormatter(),
             }
 
     def __getitem__(self, formatter):

=== added file 'wikkid/formatter/textileformatter.py'
--- wikkid/formatter/textileformatter.py	1970-01-01 00:00:00 +0000
+++ wikkid/formatter/textileformatter.py	2010-11-12 09:13:57 +0000
@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2010 Wikkid Developers.
+#
+# This software is licensed under the GNU Affero General Public License
+# version 3 (see the file LICENSE).
+
+"""A text to html formatter using textile."""
+
+
+from textile import textile
+from zope.interface import implements
+
+from wikkid.interface.formatter import ITextFormatter
+
+
+class TextileFormatter(object):
+    """Format source files as HTML using textile."""
+
+    implements(ITextFormatter)
+
+    def format(self, filename, text):
+        """Format the text.
+        """
+        return textile(text)
+

=== added file 'wikkid/skin/default/missing-directory.html'
--- wikkid/skin/default/missing-directory.html	1970-01-01 00:00:00 +0000
+++ wikkid/skin/default/missing-directory.html	2010-11-12 09:13:57 +0000
@@ -0,0 +1,19 @@
+{% extends "base.html" %}
+{% block title %}{{ view.title }}{% endblock %}
+{% block content %}
+
+<p>The directory you are looking for does not exist.<p>
+
+<p><a href="{{ canonical_url(context.root_resource, 'listing') }}">
+  Browse the wiki content
+</a></p>
+
+{% endblock %}
+{% block commands %}
+{% if view.user %}
+<a href="{{ canonical_url(context, 'edit') }}">Edit</a>
+{% endif %}
+{% if context.get_dir_name %}
+<a class="command" href="{{ canonical_url(context.root_resource, 'listing') }}">Browse</a>
+{% endif %}
+{% endblock %}

=== modified file 'wikkid/skin/loader.py'
--- wikkid/skin/loader.py	2010-05-12 10:39:13 +0000
+++ wikkid/skin/loader.py	2010-11-12 09:13:57 +0000
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2010 Wikkid Developers.
 #
@@ -36,6 +37,7 @@
             'edit_page': self.env.get_template('edit.html'),
             'view_directory': self.env.get_template('directory_listing.html'),
             'missing': self.env.get_template('missing-page.html'),
+            'missing-dir' : self.env.get_template('missing-directory.html')
             }
         module_location = urlutils.dirname(__file__)
         self.dir_name = urlutils.joinpath(module_location, skin_name)

=== modified file 'wikkid/tests/formatters/__init__.py'
--- wikkid/tests/formatters/__init__.py	2010-05-16 02:40:12 +0000
+++ wikkid/tests/formatters/__init__.py	2010-11-12 09:13:57 +0000
@@ -15,6 +15,8 @@
         'registry',
         'rest',
         'creole',
+        'markdown',
+        'textile',
         ]
     module_names = ['wikkid.tests.formatters.test_' + name for name in names]
     loader = unittest.TestLoader()

=== added file 'wikkid/tests/formatters/test_markdown.py'
--- wikkid/tests/formatters/test_markdown.py	1970-01-01 00:00:00 +0000
+++ wikkid/tests/formatters/test_markdown.py	2010-11-12 09:13:57 +0000
@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Wikkid Developers.
+#
+# This software is licensed under the GNU Affero General Public License
+# version 3 (see the file LICENSE).
+
+"""Tests for the wikkid.formatter.markdownformatter module."""
+
+from textwrap import dedent
+from BeautifulSoup import BeautifulSoup
+
+from wikkid.formatter.markdownformatter import MarkdownFormatter
+from wikkid.tests import TestCase
+
+
+class TestCreoleFormatter(TestCase):
+    """Tests for the creole formatter."""
+
+    def setUp(self):
+        TestCase.setUp(self)
+        self.formatter = MarkdownFormatter()
+
+    def test_simple_headings(self):
+        # A simple heading and a paragraph.
+        text = dedent("""\
+            Heading 1
+            =========
+            
+            Heading 2
+            ---------
+            
+            Simple sentence.""")
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual('Heading 1', soup.h1.string)
+        self.assertEqual('Heading 2', soup.h2.string)
+        # we don't care about whitespace on <p> tags, and markdown inserts 
+        # newlines.
+        self.assertEqual('Simple sentence.', soup.p.string.strip()) 
+
+    def test_detailed_headings(self):
+        text = dedent("""\
+        # Heading 1
+
+        ## Heading 2
+
+        ### Heading 3
+
+        #### Heading 4
+        
+        ##### Heading 5
+
+        ###### Heading 6""")
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual('Heading 1', soup.h1.string)
+        self.assertEqual('Heading 2', soup.h2.string)
+        self.assertEqual('Heading 3', soup.h3.string)
+        self.assertEqual('Heading 4', soup.h4.string)
+        self.assertEqual('Heading 5', soup.h5.string)
+        self.assertEqual('Heading 6', soup.h6.string)
+
+
+    def test_inline_link(self):
+        # A paragraph containing a wiki word.
+        text = "A link to the [FrontPage](http://127.0.0.1) helps."
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual('http://127.0.0.1', soup.a['href'])
+
+    def test_reference_link(self):
+        # A paragraph containing a wiki word.
+        text = dedent("""\
+                        This is [an example][id] reference-style link.
+
+                        [id]: http://127.0.0.1
+                        """)
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual('http://127.0.0.1', soup.a['href'])
+
+    def test_emphasis(self):
+        texts = ('We can have *emphasis* and **strong** as well!',
+                 'We can have _emphasis_ and __strong__ as well!')
+        for text in texts:
+            result = self.formatter.format('filename', text)
+            soup = BeautifulSoup(result)
+            self.assertEqual('emphasis', soup.em.string)
+            self.assertEqual('strong', soup.strong.string)
+
+    def test_blockquote(self):
+        text = dedent('''\
+                        > This is a block quoted paragraph
+                        > that spans multiple lines.
+                        ''')
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertTrue(soup.blockquote is not None)
+
+    def test_lists(self):
+        text = dedent('''\
+                        Some Text.
+
+                         * UL 1
+                         * UL 2
+                         * UL 3
+
+                       Some More Text! 
+
+                         1. OL 1
+                         2. OL 2
+                         7. OL 3
+                         ''')
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        
+        self.assertTrue(soup.ul)
+        ulNodes = soup.ul.findAll('li')
+        for i in range(3):
+            self.assertEqual('UL %d' % (i+1), ulNodes[i].string.strip())
+        
+        self.assertTrue(soup.ol)
+        olNodes = soup.ol.findAll('li')
+        for i in range(3):
+            self.assertEqual('OL %d' % (i+1), olNodes[i].string.strip())
+
+    def test_code_blocks(self):
+        text = dedent('''\
+                        Some Normal Text.
+
+                            Some Code inside pre tags
+
+                        More Normal text.
+                        ''')
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual(soup.pre.code.string.strip(), 'Some Code inside pre tags')
+
+    def test_hr(self):
+        # test different HR types:
+        texts = ('* * *',
+                 '***',
+                 '*********',
+                 '- - - -',
+                 '------------------')
+        for text in texts:
+            result = self.formatter.format('filename', text)
+            soup = BeautifulSoup(result)
+            self.assertTrue(soup.hr is not None)
+
+    def test_code(self):
+        text = 'use the `printf()` function'
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual('printf()', soup.code.string)
+        
+    def test_unicode(self):
+        # I have no idea what this says. Taken from:
+        # http://www.humancomp.org/unichtm/calblur8.htm
+        # It's simplified chinese, in utf-8, apparently
+        text = u'个专为语文教学而设计的电脑软件'
+        result = self.formatter.format('format', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual(soup.p.string.strip(), text)
+
+    

=== added file 'wikkid/tests/formatters/test_textile.py'
--- wikkid/tests/formatters/test_textile.py	1970-01-01 00:00:00 +0000
+++ wikkid/tests/formatters/test_textile.py	2010-11-12 09:13:57 +0000
@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Wikkid Developers.
+#
+# This software is licensed under the GNU Affero General Public License
+# version 3 (see the file LICENSE).
+
+"""Tests for the wikkid.formatter.markdownformatter module."""
+
+from textwrap import dedent
+from BeautifulSoup import BeautifulSoup
+
+from wikkid.formatter.textileformatter import TextileFormatter
+from wikkid.tests import TestCase
+
+
+class TestTextileFormatter(TestCase):
+    """Tests for the creole formatter."""
+
+    def setUp(self):
+        TestCase.setUp(self)
+        self.formatter = TextileFormatter()
+
+    def test_detailed_headings(self):
+        text = dedent("""\
+        h1. Heading 1
+
+        h2. Heading 2
+
+        h3. Heading 3
+
+        h4. Heading 4
+        
+        h5. Heading 5
+
+        h6. Heading 6""")
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual('Heading 1', soup.h1.string)
+        self.assertEqual('Heading 2', soup.h2.string)
+        self.assertEqual('Heading 3', soup.h3.string)
+        self.assertEqual('Heading 4', soup.h4.string)
+        self.assertEqual('Heading 5', soup.h5.string)
+        self.assertEqual('Heading 6', soup.h6.string)
+
+
+    def test_inline_link(self):
+        # A paragraph containing a wiki word.
+        text = 'A link to the "FrontPage":http://127.0.0.1 helps.'
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual('http://127.0.0.1', soup.a['href'])
+
+    def test_emphasis(self):
+        text = 'We can have _emphasis_ and *strong* as well!'
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual('emphasis', soup.em.string)
+        self.assertEqual('strong', soup.strong.string)
+
+    def test_blockquote(self):
+        text = dedent('''\
+                        Some Text
+
+                        bq. This is a block quoted paragraph
+                        that spans multiple lines.
+
+                        Some more text
+                        ''')
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertTrue(soup.blockquote is not None)
+
+    def test_lists(self):
+        text = dedent('''\
+                       Some Text.
+
+                       * UL 1
+                       * UL 2
+                       * UL 3
+
+                       Some More Text! 
+
+                       # OL 1
+                       # OL 2
+                       # OL 3
+                         ''')
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        
+        self.assertTrue(soup.ul)
+        ulNodes = soup.ul.findAll('li')
+        for i in range(3):
+            self.assertEqual('UL %d' % (i+1), ulNodes[i].string.strip())
+        
+        self.assertTrue(soup.ol)
+        olNodes = soup.ol.findAll('li')
+        for i in range(3):
+            self.assertEqual('OL %d' % (i+1), olNodes[i].string.strip())
+
+    def test_code_blocks(self):
+        text = dedent('''\
+                        Some Normal Text.
+
+                        @Some Code inside pre tags@
+
+                        More Normal text.
+                        ''')
+        result = self.formatter.format('filename', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual(soup.code.string.strip(), 'Some Code inside pre tags')
+        
+    def test_unicode(self):
+        # I have no idea what this says. Taken from:
+        # http://www.humancomp.org/unichtm/calblur8.htm
+        # It's simplified chinese, in utf-8, apparently
+        text = u'个专为语文教学而设计的电脑软件'
+        result = self.formatter.format('format', text)
+        soup = BeautifulSoup(result)
+        self.assertEqual(soup.p.string.strip(), text)
+
+    

=== modified file 'wikkid/view/base.py'
--- wikkid/view/base.py	2010-06-23 10:57:14 +0000
+++ wikkid/view/base.py	2010-11-12 09:13:57 +0000
@@ -45,7 +45,8 @@
 
     __metaclass__ = BaseViewMetaClass
 
-    def __init__(self, context, request):
+    def __init__(self, context, request, execution_context):
+        self.execution_context = execution_context
         self.context = context
         self.request = request
         if request is not None:

=== modified file 'wikkid/view/missing.py'
--- wikkid/view/missing.py	2010-05-19 10:00:43 +0000
+++ wikkid/view/missing.py	2010-11-12 09:13:57 +0000
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2010 Wikkid Developers
 #
@@ -24,6 +25,16 @@
     def content(self):
         '%s Not found' % self.path
 
+class MissingDirectory(BaseView):
+    #"""A wiki Directory that does not exist."""
+    
+    for_interface = IMissingResource
+    name = 'listing'
+    template = 'missing-dir'
+    
+    @property
+    def content(self):
+        '%s Not found' % self.path
 
 class NewWikiPage(BaseEditView):
     """Show the edit page with no existing content."""

=== modified file 'wikkid/view/wiki.py'
--- wikkid/view/wiki.py	2010-06-17 10:12:31 +0000
+++ wikkid/view/wiki.py	2010-11-12 09:13:57 +0000
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2010 Wikkid Developers
 #
@@ -11,6 +12,7 @@
 from wikkid.formatter.registry import get_wiki_formatter
 from wikkid.interface.resource import IWikiTextFile
 from wikkid.view.base import BaseView
+from wikkid.context import ExecutionContext
 
 
 class WikiPage(BaseView):
@@ -25,9 +27,9 @@
     def content(self):
         bytes = self.context.get_bytes()
         # Check the first line of the content to see if it specifies a
-        # formatter. The default is currently ReST, but we should have it
-        # configurable shortly.
-        content, formatter = get_wiki_formatter(bytes, 'rest')
+        # formatter. We get the default formatter from the execution context:
+        content, formatter = get_wiki_formatter(bytes, 
+                        self.execution_context.get('default_formatter','rest'))
         return formatter.format(self.context.base_name, content)
 
     def _render(self, skin):