Add initial implementation of Comment itemtype.

MoinMoin/items/__init__.py

+# Copyright: 2012-2013 MoinMoin:PavelSviderski
 # Copyright: 2012 MoinMoin:CheerXiao
 # Copyright: 2009 MoinMoin:ThomasWaldmann
 # Copyright: 2009-2011 MoinMoin:ReimarBauer
 # Copyright: 2009 MoinMoin:ChristopherDenter
 # Copyright: 2008,2009 MoinMoin:BastianBlank
 # Copyright: 2010 MoinMoin:ValentinJaniaut
 # Copyright: 2010 MoinMoin:DiogenesAugusto
 # License: GNU GPL v2 (or any later version), see LICENSE.txt for details.
 
 """
     MoinMoin - high-level (frontend) items
 
     While MoinMoin.storage cares for backend storage of items,
     this module cares for more high-level, frontend items,
     e.g. showing, editing, etc. of wiki items.
 
     Each class in this module corresponds to an itemtype.
 """
 
 import json
 from StringIO import StringIO
 from collections import namedtuple
 from operator import attrgetter
 
 from flask import current_app as app
 from flask import g as flaskg
 from flask import request, Response, redirect, abort, escape
 
-from flatland import Form
+from flatland import Form, Unset
 
 from jinja2 import Markup
 
 from whoosh.query import Term, Prefix, And, Or, Not
 
 from MoinMoin import log
 logging = log.getLogger(__name__)
 
 from MoinMoin.security.textcha import TextCha, TextChaizedForm
 from MoinMoin.signalling import item_modified
@@ skipping 348 matching lines @@
 
     def destroy(self, comment=u'', destroy_item=False):
         # called from destroy UI/POST
         if destroy_item:
             # destroy complete item with all revisions, metadata, etc.
             self.rev.item.destroy_all_revisions()
         else:
             # just destroy this revision
             self.rev.item.destroy_revision(self.rev.revid)
 
-    def modify(self, meta, data, comment=u'', contenttype_guessed=None, contenttype_qs=None):
-        if contenttype_qs:
-            # we use querystring param to FORCE content type
-            meta[CONTENTTYPE] = contenttype_qs
-
+    def modify(self, meta, data, comment=u'', contenttype_guessed=None, **update_meta):
+        meta = dict(meta)  # we may get a read-only dict-like, copy it
+        # get rid of None values
+        update_meta = {key:value for key, value in update_meta.items() if value is not None}

[Thomas.J.Waldmann, 2013/07/29 22:48:59]

key: value

pep8

+        meta.update(update_meta)
         return self._save(meta, data, contenttype_guessed=contenttype_guessed, comment=comment)
 
     class _ModifyForm(BaseModifyForm):
         """
         ModifyForm (the form used on +modify view), sans the content part.
         Combined dynamically with the ModifyForm of the Content subclass in
         Contentful.ModifyForm.
 
         Subclasses of Contentful should generally override this instead of
         ModifyForm.
@@ skipping 22 matching lines @@
             """
             Dump useful data out of :self. :item contains the old item and
             should not be the primary data source; but it can be useful in case
             the data in :self is not sufficient.
 
             :returns: a tuple (meta, data, contenttype_guessed, comment),
                       suitable as arguments of the same names to pass to
                       item.modify
             """
             meta = self['meta_form'].value.copy()
-            meta.update(item.meta_text_to_dict(self['extra_meta_text'].value))
+            if self['extra_meta_text'].raw is not Unset:  # it's an optional field
+                meta.update(item.meta_text_to_dict(self['extra_meta_text'].value))
             data, contenttype_guessed = self['content_form']._dump(item.content)
             comment = self['comment'].value
             return meta, data, contenttype_guessed, comment
 
     def do_modify(self):
         """
         Handle +modify requests, both GET and POST.
 
         This method should be overridden in subclasses, providing polymorphic
         behavior for the +modify view.
@@ skipping 218 matching lines @@
                                itemtype=self.itemtype,
                                rev=self.rev,
                                contenttype=self.contenttype,
                                templates=item_templates,
                                first_rev_id=rev_ids and rev_ids[0],
                                last_rev_id=rev_ids and rev_ids[-1],
                                meta_rendered='',
                                data_rendered='',
                                )
 
-    def get_comment_items(self):
+    def get_comment_item_ids(self):
         terms = [Term(WIKINAME, app.cfg.interwikiname),
                  # Only comment items
                  Term(ITEMTYPE, ITEMTYPE_COMMENT),
                  # Only comments for this item
                  Term(COMMENT_FOR, self.meta[ITEMID]),
                  ]
         query = And(terms)
         revs = flaskg.storage.search(query, sortedby=PTIME, limit=None)
-        comment_items = [Item.create(rev.name) for rev in revs]

[Thomas.J.Waldmann, 2013/06/28 22:45:30]

as a general hint: be careful with creating potentially lots of item object in
parallel. think about whether this is really needed.

-        return comment_items
+        comment_item_ids = [rev.item.itemid for rev in revs]
+        return comment_item_ids
 
     def do_show(self, revid):
         show_revision = revid != CURRENT
         show_navigation = False  # TODO
         first_rev = last_rev = None  # TODO
-        comments=self.get_comment_items()
+        # TODO: comments should be a list of ITEMIDs, but currently we use a list
+        # of ITEMNAMEs because we are not able to create an Item object by ITEMID yet.
+        # TODO: filter out protected comments
+        comments = [flaskg.storage.document(itemid=itemid).name
+                    for itemid in self.get_comment_item_ids()]
         return render_template(self.show_template,
                                item=self, item_name=self.name,
                                rev=self.rev,
                                contenttype=self.contenttype,
                                first_rev_id=first_rev,
                                last_rev_id=last_rev,
                                data_rendered=Markup(self.content._render_data()),
                                show_revision=show_revision,
                                show_navigation=show_navigation,
                                comments=comments,

[Thomas.J.Waldmann, 2013/06/28 22:45:30]

maybe this could be more dynamic later, so that comments are only loaded on
request and/or via ajax.

                                )
 
     def do_modify(self):
         method = request.method
         if method in ['GET', 'HEAD']:
             if isinstance(self.content, NonExistentContent):
                 return render_template('modify_select_contenttype.html',
                                        item_name=self.name,
                                        itemtype=self.itemtype,
                                        group_names=content_registry.group_names,
@@ skipping 17 matching lines @@
                 else:
                     # *Draw Applets POSTs more than once, redirecting would
                     # break them
                     return "OK"
             form = self.ModifyForm.from_request(request)
             state = dict(name=self.name, itemid=self.meta.get(ITEMID))
             if form.validate(state):
                 meta, data, contenttype_guessed, comment = form._dump(self)
                 contenttype_qs = request.values.get('contenttype')
                 try:
-                    self.modify(meta, data, comment, contenttype_guessed, contenttype_qs)
+                    self.modify(meta, data, comment, contenttype_guessed, **{CONTENTTYPE: contenttype_qs})
                 except AccessDenied:
                     abort(403)
                 else:
                     return redirect(url_for_item(self.name))
         return render_template(self.modify_template,
                                item_name=self.name,
                                rows_meta=str(ROWS_META), cols=str(COLS),
                                form=form,
                                search_form=None,
                               )
@@ skipping 59 matching lines @@
         # pointless for non-existing items
         pass
 
     def destroy(self, comment=u'', destroy_item=False):
         # pointless for non-existing items
         pass
 
 
 from ..util.pysupport import load_package_modules
 load_package_modules(__name__, __path__)