TracDev/ContextRefactoring: work_in_progress_snapshot.diff

trac/attachment.py

@@ -27 +27 @@
 
 from trac import perm, util
 from trac.config import BoolOption, IntOption
-from trac.context import IContextProvider, Context, ResourceSystem, \
-                         ResourceNotFound
+from trac.context import IResourceManager, ResourceSystem, ResourceNotFound
 from trac.core import *
 from trac.env import IEnvironmentSetupParticipant
 from trac.perm import PermissionError, PermissionSystem, IPermissionPolicy
@@ -80 +79 @@
         OK."""
 
 
-class AttachmentContext(Context):
-    """Context for attachment resources."""
-
-    realm = 'attachment'
-
-    # methods reimplemented from Context
-
-    def get_resource(self):
-        return Attachment(self.env, self.parent.realm, self.parent.id,
-                          filename=self.id, db=self._db)
-
-    def get_href(self, href, path=None, **kwargs):
-        """Return an URL to the attachment itself.
-
-        A `format` keyword argument equal to `'raw'` will be converted
-        to the raw-attachment prefix.
-        """
-        format = kwargs.get('format')
-        prefix = 'attachment'
-        if format == 'raw':
-            kwargs.pop('format')
-            prefix = 'raw-attachment'
-        path = [unicode(p) for p in [prefix, self.parent.realm, self.parent.id,
-                                     self.id, path] if p]
-        return Context.get_href(self, href, '/' + '/'.join(path), **kwargs)
-
-    def permid(self):
-        return self.parent.permid() + (self.realm, self.id)
-
-    def name(self):
-        if self.id:
-            return _("Attachment '%(id)s' in %(parent)s", id=self.id,
-                     parent=self.parent.name())
-        else:
-            return _("Attachments of %(parent)s", parent=self.parent.name())
-
-    def shortname(self):
-        return '%s:%s' % (self.parent.shortname(), self.filename)
-
-    def summary(self):
-        return self.resource.description
-
 
 class AttachmentList(object):
     """Helper class for template data, representing a list of attachments."""
     
     def __init__(self, parent, attachments):
-        self.req = parent.req
-        self.parent = parent
-        self.attachments = [parent('attachment', a.filename, resource=a)
-                            for a in attachments]
-
-    def attach_href(self):
-        return self.parent('attachment').get_href(self.req.href, action='new')
+        self.attachments = filter(None, [parent.child('attachment', a.filename,
+                                                      model=a)
+                                         for a in attachments])
+        self.new_attachment = parent.child('attachment')
+
+    def attach_href(self, href):
+        return self.new_attachment.url(href, action='new')
 
     def can_create(self):
-        return 'ATTACHMENT_CREATE' in self.req.perm(self.parent('attachment'))
+        return 'ATTACHMENT_CREATE' in self.new_attachment.perm
 
 
 class Attachment(object):
@@ -322 +279 @@
 class AttachmentModule(Component):
 
     implements(IEnvironmentSetupParticipant, IRequestHandler,
-               INavigationContributor, IWikiSyntaxProvider,
-               IContextProvider)
+               INavigationContributor, IWikiSyntaxProvider, IResourceManager)
 
     change_listeners = ExtensionPoint(IAttachmentChangeListener)
     manipulators = ExtensionPoint(IAttachmentManipulator)
@@ -381 +337 @@
             return True
 
     def process_request(self, req):
+        parent_id = None
         parent_realm = req.args.get('realm')
         path = req.args.get('path')
+        filename = None
         
         if not parent_realm or not path:
             raise HTTPBadRequest(_('Bad request'))
 
-        context = Context(self.env, req)
-
+        parent_realm = req.perm(parent_realm)
         action = req.args.get('action', 'view')
         if action == 'new':
-            attachment = Attachment(self.env, parent_realm, path)
+            parent_id = path
         else:
             segments = path.split('/')
             parent_id = '/'.join(segments[:-1])
             filename = len(segments) > 1 and segments[-1]
             if not filename: # if there's a trailing '/', show the list
-                return self._render_list(req, context(parent_realm, parent_id))
-            attachment = Attachment(self.env, parent_realm, parent_id,
-                                    filename)
-
-        ctx = context(attachment.parent_realm, attachment.parent_id) \
-              ('attachment', attachment.filename, resource=attachment)
-        add_link(req, 'up', ctx.parent.resource_href(), ctx.parent.name())
+                return self._render_list(
+                    req, parent_realm.assert_copy(id=parent_id))
+
+        parent = parent_realm.assert_copy(id=parent_id)
+        attachment = parent.child('attachment', filename)
+        
+        add_link(req, 'up', parent.url(req.href), parent.name)
         
         if req.method == 'POST':
             if action == 'new':
-                self._do_save(ctx)
+                self._do_save(req, attachment)
             elif action == 'delete':
-                self._do_delete(ctx)
+                self._do_delete(req, attachment)
         elif action == 'delete':
-            data = self._render_confirm_delete(ctx)
+            data = self._render_confirm_delete(req, attachment)
         elif action == 'new':
-            data = self._render_form(ctx)
-        else:
-            data = self._render_view(ctx)
-
-        data['context'] = ctx
+            data = self._render_form(req, attachment)
+        else:
+            data = self._render_view(req, attachment)
+
+        data['resource'] = attachment
 
         add_stylesheet(req, 'common/css/code.css')
         return 'attachment.html', data, None
@@ -437 +394 @@
         """Return list of attachments allowed in the request."""
         return AttachmentList(parent,
             [a for a in Attachment.select(self.env, parent.realm, parent.id)
-             if 'ATTACHMENT_VIEW' in req.perm(parent('attachment', a.filename))])
+             if parent.child('attachment', a.filename)])
 
     def get_history(self, start, stop, realm):
         """Return an iterable of tuples describing changes to attachments on
@@ -458 +415 @@
             time = datetime.fromtimestamp(ts, utc)
             yield ('created', realm, id, filename, time, description, author)
 
-    def get_timeline_events(self, context, start, stop):
-        """Return an iterable of events suitable for ITimelineEventProvider.
-
-        `context` specifies the realm.
+    def get_timeline_events(self, req, resource_realm, start, stop):
+        """Return an event generator suitable for ITimelineEventProvider.
+
+        Events are changes to attachments on resources of the given
+        `resource_realm.realm`.
         """
-        req = context.req
         for change, realm, id, filename, time, descr, author in \
-                self.get_history(start, stop, context.realm):
-            ctx = context(realm=realm, id=id)('attachment', filename)
-            if 'ATTACHMENT_VIEW' not in req.perm(ctx):
-                continue
-            title = tag(tag.em(os.path.basename(filename)), ' attached to ',
-                        tag.em(ctx.parent.name(), title=ctx.parent.summary()))
-            event = TimelineEvent(self, 'attachment')
-            event.set_changeinfo(time, author)
-            event.add_markup(title=title)
-            event.add_wiki(ctx, body=descr)
-            yield event
+                self.get_history(start, stop, resource_realm.realm):
+            parent = resource_realm(id=id)
+            if parent:
+                attachment = parent.child('attachment', filename)
+                if attachment:
+                    title = tag(tag.em(os.path.basename(filename)),
+                                _(" attached to "),
+                                tag.em(parent.name, title=parent.summary))
+                    event = TimelineEvent(self, 'attachment')
+                    event.set_changeinfo(time, author)
+                    event.add_markup(title=title)
+                    event.add_wiki(parent, body=descr)
+                    yield event
 
     def event_formatter(self, event, key):
         return None
     
-    # IContextProvider methods
-
-    def get_context_classes(self):
-        yield AttachmentContext
+    # IResourceManager methods
+    
+    def get_resource_realms(self):
+        yield 'attachment'
+
+    def get_model(self, resource):
+        return Attachment(resource.env, resource.parent.realm,
+                          resource.parent.id, filename=resource.id)
+
+    def get_resource_url(self, resource, href, path=None, **kwargs):
+        """Return an URL to the attachment itself.
+
+        A `format` keyword argument equal to `'raw'` will be converted
+        to the raw-attachment prefix.
+        """
+        format = kwargs.get('format')
+        prefix = 'attachment'
+        if format == 'raw':
+            kwargs.pop('format')
+            prefix = 'raw-attachment'
+        path = [unicode(p) for p in
+                [prefix, resource.parent.realm, resource.parent.id,
+                 resource.id, path] if p]
+        return ResourceSystem(self.env).get_resource_url(
+            resource, href, '/' + '/'.join(path), **kwargs)
+
+    def get_resource_description(self, resource, format=None):
+        if format == 'compact':
+            return '%s:%s' % (resource.parent.shortname, resource.filename)
+        elif format == 'summary':
+            return resource.model.description
+        if resource.id:
+            return _("Attachment '%(id)s' in %(parent)s", id=resource.id,
+                     parent=resource.parent.name)
+        else:
+            return _("Attachments of %(parent)s", parent=resource.parent.name)
 
     # Internal methods
 
-    def _do_save(self, context):
-        req, attachment = context.req, context.resource
-        req.perm.require('ATTACHMENT_CREATE', context)
+    def _do_save(self, req, attachment):
+        attachment.perm.require('ATTACHMENT_CREATE')
 
         if 'cancel' in req.args:
-            req.redirect(context.parent.resource_href())
+            req.redirect(attachment.parent.url(req.href))
 
         upload = req.args['attachment']
         if not hasattr(upload, 'filename') or not upload.filename:
@@ -520 +510 @@
         filename = os.path.basename(filename)
         if not filename:
             raise TracError(_('No file uploaded'))
-        # Now the filename is known, update the attachment context
-        context.id = filename
-
-        attachment.description = req.args.get('description', '')
-        attachment.author = get_reporter_id(req, 'author')
-        attachment.ipnr = req.remote_addr
+        # Now the filename is known, update the attachment resource
+        attachment.id = filename
+
+        model = Attachment(self.env, parent_realm, path) 
+        model.description = req.args.get('description', '')
+        model.author = get_reporter_id(req, 'author')
+        model.ipnr = req.remote_addr
 
         # Validate attachment
         for manipulator in self.manipulators:
-            for field, message in manipulator.validate_attachment(req,
-                                                                  attachment):
+            for field, message in manipulator.validate_attachment(req, model):
                 if field:
                     raise InvalidAttachment(_('Attachment field %(field)s is '
                                               'invalid: %(message)s',
@@ -541 +531 @@
 
         if req.args.get('replace'):
             try:
-                old_attachment = Attachment(self.env, attachment.parent_realm,
-                                            attachment.parent_id, filename)
+                old_attachment = Attachment(self.env, attachment.parent.realm,
+                                            attachment.parent.id, filename)
                 if not (old_attachment.author and req.authname \
                         and old_attachment.author == req.authname):
-                    req.perm.require('ATTACHMENT_DELETE', context)
+                    attachment.perm.require('ATTACHMENT_DELETE')
                 old_attachment.delete()
             except TracError:
                 pass # don't worry if there's nothing to replace
-            attachment.filename = None
-        attachment.insert(filename, upload.file, size)
+            model.filename = None
+        model.insert(filename, upload.file, size)
 
         # Redirect the user to list of attachments (must add a trailing '/')
-        req.redirect(context.resource_href('..') + '/')
-
-    def _do_delete(self, context):
-        req, attachment = context.req, context.resource
-        req.perm.require('ATTACHMENT_DELETE', context)
-
-        parent_href = context.parent.resource_href()
+        req.redirect(attachment.url(req.href, '..') + '/')
+
+    def _do_delete(self, req, attachment):
+        resource.perm.require('ATTACHMENT_DELETE')
+
+        parent_href = attachment.parent.url(req.href)
         if 'cancel' in req.args:
             req.redirect(parent_href)
 
-        context.resource.delete()
-
-        # Redirect the user to the attachment parent page
+        attachment.model.delete()
         req.redirect(parent_href)
 
-    def _render_confirm_delete(self, context):
-        req, attachment = context.req, context.resource
-        req.perm.require('ATTACHMENT_DELETE', context)
-        
-        attachment = context.resource
-        return {'mode': 'delete',
-                'title': _('%(context)s (delete)', context=context.name()),
+    def _render_confirm_delete(self, req, attachment):
+        attachment.perm.require('ATTACHMENT_DELETE')
+        return {'mode': 'delete', 'title': _('%(attachment)s (delete)',
+                                             attachment=attachment.name),
+                'attachment': attachment.model} # FIXME
+
+    def _render_form(self, req, attachment):
+        attachment.perm.require('ATTACHMENT_CREATE')
+        return {'mode': 'new', 'author': get_reporter_id(req),
                 'attachment': attachment}
 
-    def _render_form(self, context):
-        req, attachment = context.req, context.resource
-        req.perm.require('ATTACHMENT_CREATE', context)
-
-        return {'mode': 'new', 'author': get_reporter_id(context.req)}
-
-    def _render_list(self, req, context):
-        context.req.perm.require('ATTACHMENT_VIEW', context('attachment'))
-
+    def _render_list(self, req, parent):
+        attachment = parent.assert_child('attachment')
         data = {
-            'mode': 'list', 'context': None, # no specific attachment
-            'attachments': self.permitted_attachment_list(req, context)}
-
-        add_link(context.req, 'up', context.resource_href(), context.name())
+            'mode': 'list', 'attachment': None, # no specific attachment
+            'attachments': self.permitted_attachment_list(req, parent)}
+
+        add_link(req, 'up', parent.url(req.href), parent.name)
 
         return 'attachment.html', data, None
 
-    def _render_view(self, context):
-        req, attachment = context.req, context.resource
-        req.perm.require('ATTACHMENT_VIEW', context)
-
-        req.check_modified(attachment.date)
-
-        data = {'mode': 'view', 'title': context.name(),
-                'attachment': attachment}
-
-        fd = attachment.open()
+    def _render_view(self, req, attachment):
+        req.check_modified(attachment.model.date)
+
+        data = {'mode': 'view', 'title': attachment.name,
+                'attachment': attachment} 
+
+        fd = attachment.model.open()
         try:
             mimeview = Mimeview(self.env)
 
@@ -611 +590 @@
             str_data = fd.read(1000)
             fd.seek(0)
             
-            mime_type = mimeview.get_mimetype(attachment.filename, str_data)
+            mime_type = mimeview.get_mimetype(attachment.model.filename,
+                                              str_data)
 
             # Eventually send the file directly
             format = req.args.get('format')
@@ -628 +608 @@
                 if 'charset=' not in mime_type:
                     charset = mimeview.get_charset(str_data, mime_type)
                     mime_type = mime_type + '; charset=' + charset
-                req.send_file(attachment.path, mime_type)
+                req.send_file(attachment.model.path, mime_type)
 
             # add ''Plain Text'' alternate link if needed
             if (self.render_unsafe_content and 
                 mime_type and not mime_type.startswith('text/plain')):
-                plaintext_href = context.resource_href(format='txt')
+                plaintext_href = attachment.url(req.href, format='txt')
                 add_link(req, 'alternate', plaintext_href, _('Plain Text'),
                          mime_type)
 
             # add ''Original Format'' alternate link (always)
-            raw_href = context.resource_href(format='raw')
+            raw_href = attachment.url(req.href, format='raw')
             add_link(req, 'alternate', raw_href, _('Original Format'),
                      mime_type)
 
             self.log.debug("Rendering preview of file %s with mime-type %s"
-                           % (attachment.filename, mime_type))
-
+                           % (attachment.model.filename, mime_type))
+
+            context = RenderingContext(req.href, attachment)
             data['preview'] = mimeview.preview_data(
                 context, fd, os.fstat(fd.fileno()).st_size, mime_type,
-                attachment.filename, raw_href, annotations=['lineno'])
+                attachment.model.filename, raw_href, annotations=['lineno'])
             return data
         finally:
             fd.close()
@@ -655 +636 @@
     def _format_link(self, formatter, ns, target, label):
         link, params, fragment = formatter.split_link(target)
         ids = link.split(':', 2)
-        context = None
+        attachment = None
         if len(ids) == 3:
             known_realms = ResourceSystem(self.env).get_known_realms()
             # new-style attachment: TracLinks (filename:realm:id)
             if ids[1] in known_realms:
-                context = formatter.context(ids[1], ids[2]) \
-                          ('attachment', ids[0])
+                parent = formatter.perm(ids[1], ids[2])
+                if parent:
+                    attachment = parent.child('attachment', ids[0])
             else: # try old-style attachment: TracLinks (realm:id:filename)
                 if ids[0] in known_realms:
-                    context = formatter.context(ids[0], ids[1]) \
-                              ('attachment', ids[2])
+                    parent = formatter.perm(ids[0], ids[1])
+                    if parent:
+                        attachment = parent.child('attachment', ids[2])
         else: # local attachment: TracLinks (filename)
-            context = formatter.context('attachment', link)
-        if context:
+            attachment = formatter.resource.child('attachment', link)
+        if attachment:
             try:
-                attachment = context.resource
+                check_existing = attachment.model # TODO: verify
                 format = None
                 if ns.startswith('raw'):
                     format = 'raw'
                 return tag.a(label, class_='attachment',
-                             href=context.resource_href(format=format) + params,
-                             title=context.name())
+                             href=(attachment.url(formatter.href,
+                                                  format=format) + params),
+                             title=attachment.name)
             except TracError, e:
                 pass
         return tag.a(label, class_='missing attachment', rel='nofollow')
@@ -697 +681 @@
                               'milestone': 'MILESTONE_DELETE'},
     }
 
-    def check_permission(self, username, action, context):
+    def check_permission(self, username, action, resource):
         perm_map = self._perm_maps.get(action)
         if perm_map:
-            legacy_action = perm_map.get(context.resource.parent_realm)
+            legacy_action = perm_map.get(resource.parent.realm)
             if legacy_action:
                 decision = PermissionSystem(self.env) \
-                    .check_permission(legacy_action, username, context)
+                    .check_permission(legacy_action, username, resource)
                 if not decision:
                     self.env.log.debug('LegacyAttachmentPolicy denied %s '
                                        'access to %s. User needs %s' %
-                                       (username, context, legacy_action))
+                                       (username, resource, legacy_action))
                 return decision

trac/mimeview/api.py

@@ -71 +71 @@
 
 
 __all__ = ['get_mimetype', 'is_binary', 'detect_unicode', 'Mimeview',
-           'content_to_unicode']
+           'content_to_unicode', 'RenderingContext']
 
 
 # Some common MIME types and their associated keywords and/or file extensions
@@ -215 +215 @@
     return mimeview.to_unicode(content, mimetype)
 
 
+class RenderingContext(object):
+    """Rendering contexts.
+
+    This specifies ''how'' a rendering should be done, with various
+    options that might be relevant to some or all the renderers.
+
+    A context stores the `href` used as a base for building URLs.
+    If not given, this reverts to the value of `env.abs_href`.
+    
+    A resource can also be associated to a rendering context, and that resource
+    will be used as the base content when rendering relative TracLinks.
+
+    Another aspect related to the access context consists of the scope or
+    context trail by which the information belonging to a context is
+    presented. It is quite usual that contexts are embedded in other
+    contexts. This can be known by querying the `parent` context, which
+    is automatically set when creating a subcontext from another context. XXX
+
+    For example, when rendering a ticket description from within a
+    Custom Query rendered by the TicketQuery macro inside a wiki page,
+    the context ''path'' will be:
+
+    context.resource.(realm, id) = ('ticket', '12')
+    context.parent.resource.(realm, id) = ('wiki', 'CurrentStatus')
+
+    Finally, the context could also know about the expected output MIME type
+    which should be used to present the information to the user (TODO)
+    """
+
+    def __init__(self, req, resource, parent=None, href=None, **kwargs):
+        self.req = req
+        self.resource = resource or req.perm.toplevel()
+        self.env = self.resource.env
+        self.perm = self.resource.perm
+        self.parent = parent
+        self.href = href or self.env.abs_href
+        self.properties = kwargs
+
+    def __repr__(self):
+        path = []
+        context = self
+        while context:
+            if context.resource.realm: # skip toplevel resource
+                path.append(unicode(context.resource))
+            context = context.parent
+        return '<RenderingContext %s>' % (' - '.join(reversed(path)))
+
+    def __call__(self, resource, href=None, **kwargs):
+        """Return a sub-`RenderingContext`.
+
+        'href' can be modified on the fly, which is usefull to e.g. turn URL
+        generation to absolute mode.
+
+        'resource' can be modified this way as well.
+        Any remaining keyword argument will be treated as a new property.
+        """
+        return RenderingContext(self.req, resource, self, href or self.href,
+                                **kwargs)
+    
+    def __contains__(self, resource):
+        """Check whether a given resource is in the rendering path.
+
+        This is useful for avoiding to render resources recursively.
+        """
+        context = self
+        while context:
+            if context.resource == resource:
+                return True
+            context = context.parent
+
+
 class IHTMLPreviewRenderer(Interface):
     """Extension point interface for components that add HTML renderers of
     specific content types to the `Mimeview` component.
@@ -248 +319 @@
         """
 
     def render(context, mimetype, content, filename=None, url=None):
-        """Render an XHTML preview of the raw `content` within a Context.
+        """Render an XHTML preview of the raw `content` in context.
+
+        `context` is a `RenderingContext`.
 
         The `content` might be:
          * a `str` object
@@ -292 +365 @@
         """Return the XHTML markup for the table cell that contains the
         annotation data.
 
-        `context` is the context corresponding to the content being annotated,
+        `context` is the `RenderingContext` corresponding to the content being
+        annotated,
         `row` is the tr Element being built, `number` is the line number being
         processed and `line` is the line's actual content.
         `annotations` is whatever additional data the `get_annotation_data`

trac/perm.py

@@ -19 +19 @@
 """Management of permissions."""
 
 from trac.config import ExtensionOption, OrderedExtensionsOption
+from trac.context import Resource
 from trac.core import *
 from trac.util.compat import set
 from trac.util.translation import _
@@ -30 +31 @@
 class PermissionError(StandardError):
     """Insufficient permissions to complete the operation"""
 
-    def __init__ (self, action=None):
+    def __init__ (self, action=None, resource=None):
         StandardError.__init__(self)
         self.action = action
+        self.resource = resource
 
     def __str__ (self):
         if self.action:
-            return _('%(perm)s privileges are required to perform this operation.',
-                     perm=self.action)