refactor on apps/frontend/views.py and items/__init__.py

MoinMoin/apps/frontend/views.py

+# Copyright: 2012 MoinMoin:CheerXiao
 # Copyright: 2003-2010 MoinMoin:ThomasWaldmann
 # Copyright: 2011 MoinMoin:AkashSinha
 # Copyright: 2011 MoinMoin:ReimarBauer
 # Copyright: 2008 MoinMoin:FlorianKrupicka
 # Copyright: 2010 MoinMoin:DiogenesAugusto
 # Copyright: 2001 Richard Jones <richard@bizarsoftware.com.au>
 # Copyright: 2001 Juergen Hermann <jh@web.de>
 # License: GNU GPL v2 (or any later version), see LICENSE.txt for details.
 
 """
     MoinMoin - frontend views
 
     This shows the usual things users see when using the wiki.
 """
 
 
 import re
 import difflib
 import time
 from datetime import datetime
 from itertools import chain
 from collections import namedtuple
+from functools import wraps
+
 try:
     import json
 except ImportError:
     import simplejson as json
 
 from flask import request, url_for, flash, Response, redirect, session, abort, jsonify
 from flask import current_app as app
 from flask import g as flaskg
 from flaskext.babel import format_date
 from flaskext.themes import get_themes_list
@@ skipping 223 matching lines @@
             flaskg.clock.stop('search render')
     else:
         html = render_template('search.html',
                                query=query,
                                medium_search_form=search_form,
                                title_name=title_name,
                               )
     return html
 
 
+def presenter(view, add_trail=False, abort404=True):
+    """
+    Decorator to create new "presenter" views.
+
+    Presenter views handle GET requests to locations like
+    +{view}/+<rev>/<item_name> and +{view}/<item_name>, and always try to
+    look up the item before processing.
+
+    :param view: name of view
+    :param add_trail: whether to call flaskg.user.add_trail

[waldi, 2012/06/14 14:26:34]

This is only used once.

[xiaq, 2012/06/14 14:28:32]

yes, and same for abort404 too. but i didn't work out a better way. what do you
suggest?

+    :param abort404: whether to abort(404) for nonexistent items
+    """
+    def decorator(wrapped):
+        @frontend.route('/+{view}/+<rev>/<itemname:item_name>'.format(view=view))
+        @frontend.route('/+{view}/<itemname:item_name>'.format(view=view), defaults=dict(rev=CURRENT))
+        @wraps(wrapped)
+        def wrapper(item_name, rev):
+            if add_trail:
+                flaskg.user.add_trail(item_name)
+            try:
+                item = Item.create(item_name, rev_id=rev)
+            except AccessDenied:
+                abort(403)
+            if abort404 and isinstance(item, NonExistent):
+                abort(404, item_name)
+            return wrapped(item)
+        return wrapper
+    return decorator
+
+
 @frontend.route('/<itemname:item_name>', defaults=dict(rev=CURRENT), methods=['GET'])
 @frontend.route('/+show/+<rev>/<itemname:item_name>', methods=['GET'])
 def show_item(item_name, rev):
     flaskg.user.add_trail(item_name)
     item_displayed.send(app._get_current_object(),
                         item_name=item_name)
     try:
         item = Item.create(item_name, rev_id=rev)
     except AccessDenied:
         abort(403)
@@ skipping 15 matching lines @@
                               show_navigation=show_navigation,
                              )
     return Response(content, status)
 
 
 @frontend.route('/+show/<itemname:item_name>')
 def redirect_show_item(item_name):
     return redirect(url_for_item(item_name))
 
 
-@frontend.route('/+dom/+<rev>/<itemname:item_name>')
-@frontend.route('/+dom/<itemname:item_name>', defaults=dict(rev=CURRENT))
-def show_dom(item_name, rev):
-    try:
-        item = Item.create(item_name, rev_id=rev)
-    except AccessDenied:
-        abort(403)
+@presenter('dom', abort404=False)
+def show_dom(item):
     if isinstance(item, NonExistent):
         status = 404
     else:
         status = 200
     content = render_template('dom.xml',
                               data_xml=Markup(item._render_data_xml()),
                              )
     return Response(content, status, mimetype='text/xml')
 
 
 # XXX this is just a temporary view to test the indexing converter
 @frontend.route('/+indexable/+<rev>/<itemname:item_name>')
 @frontend.route('/+indexable/<itemname:item_name>', defaults=dict(rev=CURRENT))
 def indexable(item_name, rev):
     from MoinMoin.storage.middleware.indexing import convert_to_indexable
     try:
         item = flaskg.storage[item_name]
         rev = item[rev]
     except KeyError:
         abort(404, item_name)
     content = convert_to_indexable(rev.meta, rev.data)
     return Response(content, 200, mimetype='text/plain')
 
 
-@frontend.route('/+highlight/+<rev>/<itemname:item_name>')
-@frontend.route('/+highlight/<itemname:item_name>', defaults=dict(rev=CURRENT))
-def highlight_item(item_name, rev):
-    try:
-        item = Item.create(item_name, rev_id=rev)
-    except AccessDenied:
-        abort(403)
-    if isinstance(item, NonExistent):
-        abort(404, item_name)
+@presenter('highlight')
+def highlight_item(item):
     return render_template('highlight.html',
                            item=item, item_name=item.name,
                            data_text=Markup(item._render_data_highlight()),
                           )
 
 
-@frontend.route('/+meta/<itemname:item_name>', defaults=dict(rev=CURRENT))
-@frontend.route('/+meta/+<rev>/<itemname:item_name>')
-def show_item_meta(item_name, rev):
-    flaskg.user.add_trail(item_name)
-    try:
-        item = Item.create(item_name, rev_id=rev)
-    except AccessDenied:
-        abort(403)
-    if isinstance(item, NonExistent):
-        abort(404, item_name)
-    show_revision = rev != CURRENT
+@presenter('meta', add_trail=True)
+def show_item_meta(item):
+    show_revision = request.view_args['rev'] != CURRENT
     show_navigation = False # TODO
     first_rev = None
     last_rev = None
     if show_navigation:
         rev_ids = list(item.rev.item.iter_revs())
         if rev_ids:
             first_rev = rev_ids[0]
             last_rev = rev_ids[-1]
     return render_template('meta.html',
                            item=item, item_name=item.name,
@@ skipping 21 matching lines @@
         item = Item.create(item_name, rev_id=rev)
     except AccessDenied:
         abort(403)
     if isinstance(item, NonExistent):
         abort(404, item_name)
     return render_template('content.html',
                            item_name=item.name,
                            data_rendered=Markup(item._render_data()),
                            )
 
-@frontend.route('/+get/+<rev>/<itemname:item_name>')
-@frontend.route('/+get/<itemname:item_name>', defaults=dict(rev=CURRENT))
-def get_item(item_name, rev):
-    try:
-        item = Item.create(item_name, rev_id=rev)
-    except AccessDenied:
-        abort(403)
+@presenter('get')
+def get_item(item):
     return item.do_get()
 
-@frontend.route('/+download/+<rev>/<itemname:item_name>')
-@frontend.route('/+download/<itemname:item_name>', defaults=dict(rev=CURRENT))
-def download_item(item_name, rev):
-    try:
-        item = Item.create(item_name, rev_id=rev)
-        mimetype = request.values.get("mimetype")
-    except AccessDenied:
-        abort(403)
+@presenter('download')
+def download_item(item):
+    mimetype = request.values.get("mimetype")
     return item.do_get(force_attachment=True, mimetype=mimetype)
 
 @frontend.route('/+convert/<itemname:item_name>')
 def convert_item(item_name):
     """
     return a converted item.
 
     We create two items : the original one, and an empty
     one with the expected mimetype for the converted item.
 
@@ skipping 1455 matching lines @@
     return render_template("item_link_list.html",
                            headline=_("Items tagged with %(tag)s", tag=tag),
                            item_name=tag,
                            item_names=item_names)
 
 @frontend.errorhandler(404)
 def page_not_found(e):
     return render_template('404.html',
                            item_name=e.description), 404