Ticket #3332: mimeview_api_refactoring-r3612.diff

trac/attachment.py

@@ -26 +26 @@
 from trac.config import BoolOption, IntOption
 from trac.core import *
 from trac.env import IEnvironmentSetupParticipant
-from trac.mimeview import *
+from trac.mimeview.api import Mimeview, MimeType, FileMimeContent, TEXT_PLAIN
 from trac.util import get_reporter_id, create_unique_file
 from trac.util.datefmt import format_datetime, pretty_timedelta
 from trac.util.html import Markup, html
@@ -124 +124 @@
     def parent_href(self, req):
         return req.href(self.parent_type, self.parent_id)
 
-    def _get_title(self):
+    def _get_title(self): # TODO: should extend to other `parent_type`s
         return '%s%s: %s' % (self.parent_type == 'ticket' and '#' or '',
                              self.parent_id, self.filename)
     title = property(_get_title)
@@ -245 +245 @@
     select = classmethod(select)
     delete_all = classmethod(delete_all)
 
-    def open(self):
+    def open(self): # deprecate?
         self.env.log.debug('Trying to open attachment at %s', self.path)
         try:
             fd = open(self.path, 'rb')
@@ -523 +523 @@
                                  'author': get_reporter_id(req)}
 
     def _render_view(self, req, attachment):
+        # FIXME: perm_map should extend to other `parent_type`s
         perm_map = {'ticket': 'TICKET_VIEW', 'wiki': 'WIKI_VIEW'}
         req.perm.assert_permission(perm_map[attachment.parent_type])
 
@@ -533 +534 @@
         req.hdf['attachment'] = attachment_to_hdf(self.env, req, None,
                                                   attachment)
         # Override the 'oneliner'
-        req.hdf['attachment.description'] = wiki_to_html(attachment.description,
-                                                         self.env, req)
+        req.hdf['attachment.description'] = wiki_to_html(
+            attachment.description, self.env, req)
 
         perm_map = {'ticket': 'TICKET_ADMIN', 'wiki': 'WIKI_DELETE'}
         if req.perm.has_permission(perm_map[attachment.parent_type]):
             req.hdf['attachment.can_delete'] = 1
 
-        fd = attachment.open()
-        try:
-            mimeview = Mimeview(self.env)
+        content = FileMimeContent(self.env, attachment.path,
+                                  url=attachment.href(req, format='raw'),
+                                  kind='Attachment')
 
-            # MIME type detection
-            str_data = fd.read(1000)
-            fd.seek(0)
-            
-            binary = is_binary(str_data)
-            mime_type = mimeview.get_mimetype(attachment.filename, str_data)
+        # Eventually send the file directly
+        format = req.args.get('format')
+        if format in ('raw', 'txt'):
+            disposition = 'inline'
+            if self.render_unsafe_content:
+                if content.type.is_unknown or \
+                       (format == 'txt' and not content.is_binary):
+                    # Force the content to be displayed as text
+                    content.type = TEXT_PLAIN ### SHOULD BE ENOUGH
+                    content.type = MimeType('text/plain', content.encoding)
+            elif not content.is_binary:
+                # Force browser to download HTML/SVG/etc pages that may
+                # contain malicious code enabling XSS aattacks
+                disposition = 'attachment'
+            content.send(req, disposition)
 
-            # Eventually send the file directly
-            format = req.args.get('format')
-            if format in ('raw', 'txt'):
-                if not self.render_unsafe_content and not binary:
-                    # Force browser to download HTML/SVG/etc pages that may
-                    # contain malicious code enabling XSS attacks
-                    req.send_header('Content-Disposition', 'attachment;' +
-                                    'filename=' + attachment.filename)
-                if not mime_type or (self.render_unsafe_content and \
-                                     not binary and format == 'txt'):
-                    mime_type = 'text/plain'
-                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)
+        # add ''Plain Text'' alternate link if needed
+        if self.render_unsafe_content and not \
+               (content.is_binary or
+                content.type.is_unknown or 
+                TEXT_PLAIN.match(content.type)):
+            add_link(req, 'alternate', attachment.href(req, format='txt'),
+                     TEXT_PLAIN.name, TEXT_PLAIN.mimetype)
 
-            # add ''Plain Text'' alternate link if needed
-            if self.render_unsafe_content and not binary and \
-               mime_type and not mime_type.startswith('text/plain'):
-                plaintext_href = attachment.href(req, format='txt')
-                add_link(req, 'alternate', plaintext_href, 'Plain Text',
-                         mime_type)
+        # add ''Original Format'' alternate link (always)
+        add_link(req, 'alternate', content.url,
+                 'Original Format', content.type.mimetype)
 
-            # add ''Original Format'' alternate link (always)
-            raw_href = attachment.href(req, format='raw')
-            add_link(req, 'alternate', raw_href, 'Original Format', mime_type)
+        req.hdf['attachment'] = Mimeview(self.env).preview_to_hdf(
+            req, content, annotations=['lineno'])
 
-            self.log.debug("Rendering preview of file %s with mime-type %s"
-                           % (attachment.filename, mime_type))
-
-            req.hdf['attachment'] = mimeview.preview_to_hdf(
-                req, fd, os.fstat(fd.fileno()).st_size, mime_type,
-                attachment.filename, raw_href, annotations=['lineno'])
-        finally:
-            fd.close()
-
     def _render_list(self, req, p_type, p_id):
         self._parent_to_hdf(req, p_type, p_id)
         req.hdf['attachment'] = {

trac/mimeview/rst.py

@@ -28 +28 @@
 import re
 
 from trac.core import *
-from trac.mimeview.api import IHTMLPreviewRenderer, content_to_unicode
+from trac.mimeview.api import IHTMLPreviewRenderer
 from trac.util.html import Element
 from trac.web.href import Href
 from trac.wiki.formatter import WikiProcessor
@@ -180 +180 @@
 
         _inliner = rst.states.Inliner()
         _parser = rst.Parser(inliner=_inliner)
-        content = content_to_unicode(self.env, content, mimetype)
+        content = unicode(content)
         parts = publish_parts(content, writer_name='html', parser=_parser,
                               settings_overrides={'halt_level': 6, 
                                                   'file_insertion_enabled': 0, 

trac/mimeview/api.py

@@ -19 +19 @@
 #         Christian Boos <cboos@neuf.fr>
 
 """
-The `trac.mimeview` module centralize the intelligence related to
-file metadata, principally concerning the `type` (MIME type) of the content
-and, if relevant, concerning the text encoding (charset) used by the content.
+The `trac.mimeview` module centralizes the intelligence about typed content.
 
-There are primarily two approaches for getting the MIME type of a given file:
- * taking advantage of existing conventions for the file name
- * examining the file content and applying various heuristics
+Originally, this was about file metadata, principally  its MIME type and
+eventually the text encoding (charset) used by that content.
 
-The module also knows how to convert the file content from one type
-to another type.
+Now, this has evolved into managing any kind of typed content,
+and deals also with converting a content from one type to another.
+A common situation which is now handled part of the general case
+is the conversion of any kind of content to a text/html representation.
 
-In some cases, only the `url` pointing to the file's content is actually
-needed, that's why we avoid to read the file's content when it's not needed.
+In order to keep the API of conversion interface IContentConverter simple,
+we introduced a few classes, each encapsulating a part of the knowledge
+related to the content and the conversion:
 
-The actual `content` to be converted might be a `unicode` object,
-but it can also be the raw byte string (`str`) object, or simply
-an object that can be `read()`.
+ * the `ContentType` is used to describe the type of a content.
+   This is an abstract superclass for:
+
+   - `MimeType`, used for storing the mime type string, the charset,
+     and eventually the name and the commonly used file extension
+     for that type
+
+   - `ObjectType`, used when wrapping an arbitrary Python object
+
+ * the `AbstractContent`, which wraps access to the actual content,
+   and provides a few generic methods, among which `convert()` is
+   the most important.
+
+   - the `ObjectContent`, when the content is an arbitrary Python object
+
+   - the `MimeContent` abstract class, which offers an uniform API to
+     access the data over a wide range of containers:
+      * the `StringMimeContent`, for handling string content
+        (like `str`, `unicode` or `Markup` objects)
+      * the `StructuredMimeContent`, for handling structured content
+        (like `Element` objects)
+      * the `LineIteratorMimeContent`, for handling line-oriented string
+        content (like string iterators or string arrays)
+      * the `FileMimeContent`, for handling file content
+      * etc. (as an example, the repository layer defines a `NodeMimeContent`)
+
+     That API provides different ways to get access to the data:
+      * chunks(), an iterator for reading chunks of raw content
+      * lines(), an iterator for reading lines from text content
+      * markup(), when it makes sense to interpret the content as markup
+      * `__unicode()__`, for converting the content to an `unicode` object
+      * encode(), for converting the content to a `str` object. Note that
+        we don't use `__str__` for that on purpose, as we need to be able
+        to specify the charset.
+      * size(), for getting a hint about the content size without actually
+        reading it.
+
+ * the `Conversion` class, which is used to specify how a given
+   `IContentConverter` component will perform a content conversion.
 """
 
+import os
 import re
 from StringIO import StringIO
 
 from trac.config import IntOption, ListOption, Option
 from trac.core import *
 from trac.util import sorted
-from trac.util.text import to_utf8, to_unicode
+from trac.util.datefmt import http_date
+from trac.util.text import to_utf8, to_unicode, IDENTITY_CHARSET
 from trac.util.html import escape, Markup, Fragment, html
 
 
-__all__ = ['get_mimetype', 'is_binary', 'detect_unicode', 'Mimeview',
-           'content_to_unicode']
+__all__ = ['get_mimetype', 'is_binary', 'detect_unicode',
+           'IContentConverter', 'IHTMLPreviewAnnotator',
+           'IHTMLPreviewRenderer', # deprecated
+           'ObjectType', 'MimeType',
+           'ObjectContent',
+           'MimeContent', 'FileMimeContent', 'StringMimeContent',
+           'StructuredMimeContent', 'LineIteratorMimeContent',
+           'Mimeview', 'Conversion',
+           'TEXT_PLAIN', 'TEXT_HTML', 'TEXT_CSV', 'TEXT_TSV',
+           'APPLICATION_RSS_XML', 'APPLICATION_OCTET_STREAM']
 
 
 # Some common MIME types and their associated keywords and/or file extensions
 
+APPLICATION_OCTET_STREAM_STR = 'application/octet-stream'
+
 KNOWN_MIME_TYPES = {
     'application/pdf':        ['pdf'],
     'application/postscript': ['ps'],
@@ -114 +162 @@
     for e in exts:
         MIME_MAP[e] = t
 
-# Simple builtin autodetection from the content using a regexp
-MODE_RE = re.compile(
-    r"#!(?:[/\w.-_]+/)?(\w+)|"               # look for shebang
-    r"-\*-\s*(?:mode:\s*)?([\w+-]+)\s*-\*-|" # look for Emacs' -*- mode -*-
-    r"vim:.*?syntax=(\w+)"                   # look for VIM's syntax=<n>
-    )
 
-def get_mimetype(filename, content=None, mime_map=MIME_MAP):
-    """Guess the most probable MIME type of a file with the given name.
+# -- get_mimetype, is_binary, detect_unicode: a few functions for dealing
+#    with MIME types, binary and text content in a simple way
 
+def get_mimetype_from_filename(filename, mime_map=MIME_MAP):
+    """Guess the most probable MIME type of file with the given `filename`.
+
     `filename` is either a filename (the lookup will then use the suffix)
     or some arbitrary keyword.
-    
-    `content` is either a `str` or an `unicode` string.
+    `mime_map` maps keywords to MIME types.
+
+    Return the MIME type as a string, or `None` if nothing was detected.
     """
     suffix = filename.split('.')[-1]
     if suffix in mime_map:
@@ -141 +187 @@
             mimetype = mimetypes.guess_type(filename)[0]
         except:
             pass
-        if not mimetype and content:
-            match = re.search(MODE_RE, content[:1000])
-            if match:
-                mode = match.group(1) or match.group(3) or \
-                    match.group(2).lower()
-                if mode in mime_map:
-                    # 3) mimetype from the content, using the `MODE_RE`
-                    return mime_map[mode]
-            else:
-                if is_binary(content):
-                    # 4) mimetype from the content, using`is_binary`
-                    return 'application/octet-stream'
         return mimetype
 
+# Simple builtin autodetection from the content using a regexp
+MODE_RE = re.compile(
+    # look for /usr/bin/prog1 or /usr/bin/env prog2
+    r"#!(?:[/\w.-_]+/)?(?P<prog1>\w+)(?:\s+(?P<prog2>\w+))?|"
+    # look for Emacs' -*- mode -*-
+    r"-\*-\s*(?:mode:\s*)?(?P<emacsmode>[\w+-]+)\s*-\*-|"
+    # look for VIM's syntax=<n>
+    r"vim:.*?syntax=(?P<vimsyntax>\w+)"
+    )
+
+def get_mimetype_from_content(content, mime_map=MIME_MAP):
+    """Guess the most probable MIME type of file with the given `filename`.
+
+    `content` is either a `str` or an `unicode` string 
+
+    Return the MIME type as a string, or `None` if not detected.
+    """
+    match = re.search(MODE_RE, content[:1000])
+    if match:
+        mode = match.group('prog1')
+        if mode and mode == 'env':
+            mode = match.group('prog2')
+        if not mode:
+            mode = match.group('vimsyntax') or \
+                   match.group('emacsmode').lower()
+        if mode in mime_map:
+            # 3) mimetype from the content, using the `MODE_RE`
+            return mime_map[mode]
+    else:
+        if is_binary(content):
+            # 4) mimetype from the content, using `is_binary`
+            return APPLICATION_OCTET_STREAM_STR
+
+def get_mimetype(filename, content=None, mime_map=MIME_MAP):
+    """Auto-detect MIME type either from the `filename` or from the `content`.
+    """
+    mimetype = get_mimetype_from_filename(filename, mime_map)
+    if not mimetype and content:
+        mimetype = get_mimetype_from_content(content, mime_map)
+    return mimetype
+
 def is_binary(data):
     """Detect binary content by checking the first thousand bytes for zeroes.
 
@@ -165 +240 @@
     return '\0' in data[:1000]
 
 def detect_unicode(data):
-    """Detect different unicode charsets by looking for BOMs (Byte Order Marks).
+    """Detect different unicode charsets by looking for Byte Order Marks.
 
     Operate obviously only on `str` objects.
     """
@@ -178 +253 @@
     else:
         return None
 
-def content_to_unicode(env, content, mimetype):
-    """Retrieve an `unicode` object from a `content` to be previewed"""
-    mimeview = Mimeview(env)
-    if hasattr(content, 'read'):
-        content = content.read(mimeview.max_preview_size)
-    return mimeview.to_unicode(content, mimetype)
 
+# -- ContentType and subclasses 
 
-class IHTMLPreviewRenderer(Interface):
-    """Extension point interface for components that add HTML renderers of
-    specific content types to the `Mimeview` component.
+class ContentType(object):
+    """Abstract representation of the "type" of some content."""
 
-    (Deprecated)
+    def match(self, other):
+        """Compare this instance with another `ContentType` instance.
+
+        Return True if `other` can be say to ''match'' our type.
+        """
+        raise NotImplementedError
+
+    is_binary = property(lambda x: x._is_binary())
+
+    mimetype = property(lambda x: x._get_mimetype(),
+                        doc="MIME Type string (without charset information)")
+
+    name = 'unknown'
+
+
+class ObjectType(ContentType):
+    """Represent the "type" of a content by using a Python class.
+
+    The corresponding content is then expected to be an `ObjectContent`,
+    wrapping a Python instance of that class.
     """
 
-    # implementing classes should set this property to True if they
-    # support text content where Trac should expand tabs into spaces
-    expand_tabs = False
+    def __init__(self, obj):
+        self._class = isinstance(obj, type) and obj or obj.__class__
+        self._mimetype = self._charset = None
+        self.name = self._class.__name__
 
-    def get_quality_ratio(mimetype):
-        """Return the level of support this renderer provides for the `content`
-        of the specified MIME type. The return value must be a number between
-        0 and 9, where 0 means no support and 9 means "perfect" support.
+    def __repr__(self):
+        return "<ObjectType %s>" % self.name
+
+    # Reimplemented methods
+    
+    def _is_binary(self): return True
+    def _get_mimetype(self): return None
+    # or return 'application/x-python-'+self.name ?
+
+    def match(self, other, regexp=False):
+        other_class = isinstance(other, type) and other or \
+                      isinstance(other, ObjectType) and other._class or \
+                      other.__class__
+        return other_class == self._class
+
+
+class MimeType(ContentType):
+    """Represent the "type" of a content by using a MIME type string.
+
+    If the type is not binary (i.e. is some kind of text), the `charset`
+    information can also be given, when creating the instance.
+
+    A MIME type has a `name` and has an `extension` that can be used
+    for storing the converted data in a file.
+
+    All the properties of this class are read-only.
+    """
+    
+    def __init__(self, mimetype, charset=None, name=None, extension=None,
+                 env=None):
+        """Create a MimeType based on a `mimetype` string.
+
+        That string can eventually contain a `charset=...`, which will be
+        retained as the charset for this instance, unless there's an
+        explicit `charset` parameter given.
+
+        Another possibility is to give a pattern object for the `mimetype`
+        argument, in which case this instance can be used to do pattern
+        matching when using `match()`.
+
+        When optional `env` parameter is given, additional knowledge is
+        used for determining whether this type is binary or not.
         """
+        self.env = env
+        self._mimetype = mimetype
+        # determine charset
+        self._charset = charset
+        if not self._charset and isinstance(self._mimetype, basestring):
+            sep_idx = mimetype.find(';')
+            if sep_idx >= 0:
+                self._mimetype = mimetype[:sep_idx].strip()
+                charset_idx = mimetype.find('charset=', sep_idx)
+                if charset_idx >= 0:
+                    self._charset = mimetype[charset_idx+8:].strip()
+        if extension and not extension.startswith('.'):
+            extension = '.' + extension
+        self._extension = extension
+        self._name = name
 
-    def render(req, mimetype, content, filename=None, url=None):
-        """Render an XHTML preview of the raw `content`.
+    def __repr__(self):
+        return '<MimeType "%s">' % self.mimetype_charset
 
-        The `content` might be:
-         * a `str` object
-         * an `unicode` string
-         * any object with a `read` method, returning one of the above
+    def _get_extension(self):
+        if self._extension is None:
+            self._extension = KNOWN_MIME_TYPES.get(self.mimetype) ### use env
+            if not self._extension:
+                detail = self.mimetype.split('/', 1)[1]
+                if detail.startswith('x-'):
+                    detail = detail[2:]
+                self._extension = '.' + detail
+        return self._extension
 
-        It is assumed that the content will correspond to the given `mimetype`.
+    def _get_mimetype_charset(self):
+        """Combine in a single string the MIME type and charset information."""
+        if self._mimetype and self._charset:
+            return '%s; charset=%s' % (self.mimetype, self.charset)
+        else:
+            return self.mimetype ### or default to utf-8 if not binary? 
+    
+    charset = property(lambda x: x._charset,
+                       doc="Charset information if available")
 
-        Besides the `content` value, the same content may eventually
-        be available through the `filename` or `url` parameters.
-        This is useful for renderers that embed objects, using <object> or
-        <img> instead of including the content inline.
+    name = property(lambda x: x._name or x._get_extension())
+    extension = property(lambda x: x._get_extension())
+    mimetype_charset = property(lambda x: x._get_mimetype_charset(),
+                                doc="MIME Type plus charset information")
+
+    is_unknown = property(lambda x: x._mimetype is None)
+    
+    # Reimplemented methods
+    
+    def _is_binary(self):
+        return (self._mimetype == APPLICATION_OCTET_STREAM_STR or 
+                (self.env and self.mimetype in
+                 Mimeview(self.env).treat_as_binary) or 
+                self.is_unknown)
+
+    def _get_mimetype(self):
+        return self._mimetype or APPLICATION_OCTET_STREAM_STR
+
+    def match(self, other):
+        if isinstance(other, MimeType):
+            other = other.mimetype
+        if not isinstance(other, basestring):
+            return False
+        if hasattr(self.mimetype, 'match'):
+            return self.mimetype.match(other)
+        else:
+            return self.mimetype == other
+
+
+# A few commonly used MIME types:
+
+TEXT_PLAIN = MimeType('text/plain', 'utf-8', 'Plain Text', 'txt')
+TEXT_HTML = MimeType('text/html', 'utf-8', 'HTML', 'html')
+TEXT_CSV = MimeType('text/csv', 'utf-8', 'Comma-delimited Text', 'csv')
+TEXT_TSV = MimeType('text/tab-separated-values', 'utf-8',
+                    'Tab-delimited Text', 'tsv')
+
+APPLICATION_RSS_XML = MimeType('application/rss+xml', 'utf-8',
+                               'RSS Feed', 'xml')
+APPLICATION_OCTET_STREAM = MimeType(APPLICATION_OCTET_STREAM_STR,
+                                    IDENTITY_CHARSET,
+                                    'Undefined (binary)', 'bin') 
+
+
+# -- AbstractContent and subclasses
+
+class AbstractContent(object):
+    """An abstract content, with an associated content type.
+
+    There can also be a `filename` eventually associated to this content.
+    """
+
+    def __init__(self, env, content, type, filename=None):
+        self.env = env
+        self.content = content
+        self._type = type
+        self.filename = filename
+
+    def _is_binary(self): raise NotImplementedError
+
+    def _get_type(self): return self._type
+    def _set_type(self, type): self._type = type
+
+    # Properties
+    
+    type = property(fget=lambda x: x._get_type(),
+                    fset=lambda x, y: x._set_type(y), doc=
+                    """The corresponding `ContentType` for this content.""")
+
+    is_binary = property(lambda x: x._is_binary(), doc=
+                         "True if content should be considered to be binary")
+    
+    # Methods
+    
+    def basename(self):
+        """Return a possible file basename for this content."""
+        return self.filename and os.path.splitext(self.filename)[0] or ''
+
+    def convert(self, req, format=None, typespec=None, context=None):
+        """Convert this content to a `MimeContent`.
+
+        The converter can be selected by either:
         
-        Can return the generated XHTML text as a single string or as an
-        iterable that yields strings. In the latter case, the list will
-        be considered to correspond to lines of text in the original content.
+         - specifying the desired output `format`, which must match the
+           `format` of one of the `Conversion` object returned by
+           `Mimeview.get_conversions(self.type)`.
+           There's usually only one such converter.
+           
+         - giving a `typespec`, which is a `MimeType` object.
+           All matching converters are tried in turn, until one succeeds.
+           This is quite flexible, as one can use a regexp match ### FIXME
+
+        Either succeeds or raise `NoConversion` error.
         """
+        if not typespec and not format:
+            self.env.log.error("Convert called but no conversion specified.")
+            return self
+        if isinstance(format, MimeType): # or signal a programming error?
+            typespec = format
+            format = None
 
+        # Get all available conversions for our `type`, and keep those
+        # which are matching either the `format` or the `typespec`.
+        mimeview = Mimeview(self.env)
+        candidates = []
+        for conversion, converter in mimeview.get_converters(self.type):
+            if conversion.format == format or \
+                   (typespec and typespec.match(conversion.output)):
+                candidates.append((conversion, converter))
+        if not candidates:
+            raise NoConversion('No available MIME conversions',
+                               self.type, typespec, format)
+
+        tab_expanded = None # we don't want to expand tabs more than once.
+
+        # First candidate which converts successfully wins.
+        self.env.log.debug('Converting %s' % repr(self))
+        if not context:
+            class ToplevelContext(object):
+                def __init__(self, req):
+                    self.req = req
+            context = ToplevelContext(req)
+        content = self
+        for conversion, converter in candidates:
+            self.env.log.debug('Trying converter %s using %s' %
+                               (repr(converter), repr(conversion)))
+            if conversion.expand_tabs and not tab_expanded:
+                expanded = unicode(content).expandtabs(mimeview.tab_width)
+                content = StringMimeContent(self.env, expanded, content.type,
+                                            filename=content.filename)
+                self.env.log.debug('(tab expansion performed)')
+            try:
+                result = converter.convert_content(context, conversion, content)
+                if result is not None:
+                    # Check if the conversion is really valid, by trying to
+                    # access an excerpt of the result. This might trigger
+                    # errors with legacy renderers returning an iterator...
+                    check_result = result.excerpt 
+                    return result
+            except Exception, e:
+                self.env.log.warning('MIME conversion using %s failed (%s)'
+                                      % (repr(converter), e), exc_info=True)
+        raise NoConversion('No MIME conversions succeeded',
+                           content.type, typespec, format)
+
+
+class ObjectContent(AbstractContent):
+    """Content is a Python a object, and its type is an `ObjectType`.
+
+    Only supports the bare minimum of the `AbstractContent` methods.
+    `filename` in this case will be the suggested base name to be used
+    when creating a filename for a converted content.
+    """
+
+    def __init__(self, env, obj, filename=None):
+        AbstractContent.__init__(self, env, obj, ObjectType(obj),
+                                 filename=filename)
+
+    # Reimplemented property readers
+
+    def _is_binary(self):
+        return True
+
+    def basename(self):
+        return AbstractContent.basename(self) or self.type.name
+
+
+c