ext/rest.py
author Rémi Cardona <remi.cardona@free.fr>
Wed, 20 Aug 2014 20:46:17 +0200
changeset 10212 dccce2be3101
parent 10023 c3ab46842b2d
child 10588 fdaa0e4b7eaf
child 10957 2fdf67ef3341
permissions -rw-r--r--
[ext] Remove use of cStringIO We create a StringIO never to read anything from it. Docutils seems to support setting the 'warning_stream' to False to ignore warnings. So let's just do that.

# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
#
# This file is part of CubicWeb.
#
# CubicWeb is free software: you can redistribute it and/or modify it under the
# terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 2.1 of the License, or (at your option)
# any later version.
#
# CubicWeb is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License along
# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.
"""rest publishing functions

contains some functions and setup of docutils for cubicweb. Provides the
following ReST directives:

* `eid`, create link to entity in the repository by their eid

* `card`, create link to card entity in the repository by their wikiid
  (proposing to create it when the refered card doesn't exist yet)

* `winclude`, reference to a web documentation file (in wdoc/ directories)

* `sourcecode` (if pygments is installed), source code colorization

* `rql-table`, create a table from a RQL query

"""
__docformat__ = "restructuredtext en"

from itertools import chain
from logging import getLogger
from os.path import join
from urlparse import urlsplit

from docutils import statemachine, nodes, utils, io
from docutils.core import Publisher
from docutils.parsers.rst import Parser, states, directives, Directive
from docutils.parsers.rst.roles import register_canonical_role, set_classes

from logilab.mtconverter import ESC_UCAR_TABLE, ESC_CAR_TABLE, xml_escape

from cubicweb import UnknownEid
from cubicweb.ext.html4zope import Writer

from cubicweb.web.views import vid_from_rset # XXX better not to import c.w.views here...

# We provide our own parser as an attempt to get rid of
# state machine reinstanciation

import re
# compile states.Body patterns
for k, v in states.Body.patterns.items():
    if isinstance(v, str):
        states.Body.patterns[k] = re.compile(v)

# register ReStructured Text mimetype / extensions
import mimetypes
mimetypes.add_type('text/rest', '.rest')
mimetypes.add_type('text/rest', '.rst')


LOGGER = getLogger('cubicweb.rest')

def eid_reference_role(role, rawtext, text, lineno, inliner,
                       options={}, content=[]):
    try:
        try:
            eid_num, rest = text.split(u':', 1)
        except ValueError:
            eid_num, rest = text, '#'+text
        eid_num = int(eid_num)
        if eid_num < 0:
            raise ValueError
    except ValueError:
        msg = inliner.reporter.error(
            'EID number must be a positive number; "%s" is invalid.'
            % text, line=lineno)
        prb = inliner.problematic(rawtext, rawtext, msg)
        return [prb], [msg]
    # Base URL mainly used by inliner.pep_reference; so this is correct:
    context = inliner.document.settings.context
    try:
        refedentity = context._cw.entity_from_eid(eid_num)
    except UnknownEid:
        ref = '#'
        rest += u' ' + context._cw._('(UNEXISTANT EID)')
    else:
        ref = refedentity.absolute_url()
    set_classes(options)
    return [nodes.reference(rawtext, utils.unescape(rest), refuri=ref,
                            **options)], []

def rql_role(role, rawtext, text, lineno, inliner, options={}, content=[]):
    """``:rql:`<rql-expr>``` or ``:rql:`<rql-expr>:<vid>```

    Example: ``:rql:`Any X,Y WHERE X is CWUser, X login Y:table```

    Replace the directive with the output of applying the view to the resultset
    returned by the query.

    "X eid %(userid)s" can be used in the RQL query for this query will be
    executed with the argument {'userid': _cw.user.eid}.
    """
    _cw = inliner.document.settings.context._cw
    text = text.strip()
    if ':' in text:
        rql, vid = text.rsplit(u':', 1)
        rql = rql.strip()
    else:
        rql, vid = text, None
    _cw.ensure_ro_rql(rql)
    try:
        rset = _cw.execute(rql, {'userid': _cw.user.eid})
        if rset:
            if vid is None:
                vid = vid_from_rset(_cw, rset, _cw.vreg.schema)
        else:
            vid = 'noresult'
        view = _cw.vreg['views'].select(vid, _cw, rset=rset)
        content = view.render()
    except Exception as exc:
        content = 'an error occurred while interpreting this rql directive: %r' % exc
    set_classes(options)
    return [nodes.raw('', content, format='html')], []

def bookmark_role(role, rawtext, text, lineno, inliner, options={}, content=[]):
    """``:bookmark:`<bookmark-eid>``` or ``:bookmark:`<eid>:<vid>```

    Example: ``:bookmark:`1234:table```

    Replace the directive with the output of applying the view to the resultset
    returned by the query stored in the bookmark. By default, the view is the one
    stored in the bookmark, but it can be overridden by the directive as in the
    example above.

    "X eid %(userid)s" can be used in the RQL query stored in the Bookmark, for
    this query will be executed with the argument {'userid': _cw.user.eid}.
    """
    _cw = inliner.document.settings.context._cw
    text = text.strip()
    try:
        if ':' in text:
            eid, vid = text.rsplit(u':', 1)
            eid = int(eid)
        else:
            eid, vid = int(text), None
    except ValueError:
        msg = inliner.reporter.error(
            'EID number must be a positive number; "%s" is invalid.'
            % text, line=lineno)
        prb = inliner.problematic(rawtext, rawtext, msg)
        return [prb], [msg]
    try:
        bookmark = _cw.entity_from_eid(eid)
    except UnknownEid:
        msg = inliner.reporter.error('Unknown EID %s.' % text, line=lineno)
        prb = inliner.problematic(rawtext, rawtext, msg)
        return [prb], [msg]
    try:
        params = dict(_cw.url_parse_qsl(urlsplit(bookmark.path).query))
        rql = params['rql']
        if vid is None:
            vid = params.get('vid')
    except (ValueError, KeyError), exc:
        msg = inliner.reporter.error('Could not parse bookmark path %s [%s].'
                                     % (bookmark.path, exc), line=lineno)
        prb = inliner.problematic(rawtext, rawtext, msg)
        return [prb], [msg]
    try:
        rset = _cw.execute(rql, {'userid': _cw.user.eid})
        if rset:
            if vid is None:
                vid = vid_from_rset(_cw, rset, _cw.vreg.schema)
        else:
            vid = 'noresult'
        view = _cw.vreg['views'].select(vid, _cw, rset=rset)
        content = view.render()
    except Exception, exc:
        content = 'An error occurred while interpreting directive bookmark: %r' % exc
    set_classes(options)
    return [nodes.raw('', content, format='html')], []

def winclude_directive(name, arguments, options, content, lineno,
                       content_offset, block_text, state, state_machine):
    """Include a reST file as part of the content of this reST file.

    same as standard include directive but using config.locate_doc_resource to
    get actual file to include.

    Most part of this implementation is copied from `include` directive defined
    in `docutils.parsers.rst.directives.misc`
    """
    context = state.document.settings.context
    cw = context._cw
    source = state_machine.input_lines.source(
        lineno - state_machine.input_offset - 1)
    #source_dir = os.path.dirname(os.path.abspath(source))
    fid = arguments[0]
    for lang in chain((cw.lang, cw.vreg.property_value('ui.language')),
                      cw.vreg.config.available_languages()):
        rid = '%s_%s.rst' % (fid, lang)
        resourcedir = cw.vreg.config.locate_doc_file(rid)
        if resourcedir:
            break
    else:
        severe = state_machine.reporter.severe(
              'Problems with "%s" directive path:\nno resource matching %s.'
              % (name, fid),
              nodes.literal_block(block_text, block_text), line=lineno)
        return [severe]
    path = join(resourcedir, rid)
    encoding = options.get('encoding', state.document.settings.input_encoding)
    try:
        state.document.settings.record_dependencies.add(path)
        include_file = io.FileInput(
            source_path=path, encoding=encoding,
            error_handler=state.document.settings.input_encoding_error_handler,
            handle_io_errors=None)
    except IOError as error:
        severe = state_machine.reporter.severe(
              'Problems with "%s" directive path:\n%s: %s.'
              % (name, error.__class__.__name__, error),
              nodes.literal_block(block_text, block_text), line=lineno)
        return [severe]
    try:
        include_text = include_file.read()
    except UnicodeError as error:
        severe = state_machine.reporter.severe(
              'Problem with "%s" directive:\n%s: %s'
              % (name, error.__class__.__name__, error),
              nodes.literal_block(block_text, block_text), line=lineno)
        return [severe]
    if 'literal' in options:
        literal_block = nodes.literal_block(include_text, include_text,
                                            source=path)
        literal_block.line = 1
        return literal_block
    else:
        include_lines = statemachine.string2lines(include_text,
                                                  convert_whitespace=1)
        state_machine.insert_input(include_lines, path)
        return []

winclude_directive.arguments = (1, 0, 1)
winclude_directive.options = {'literal': directives.flag,
                              'encoding': directives.encoding}

class RQLTableDirective(Directive):
    """rql-table directive

    Example:

        .. rql-table::
           :vid: mytable
           :headers: , , progress
           :colvids: 2=progress

            Any X,U,X WHERE X is Project, X url U

    All fields but the RQL string are optionnal. The ``:headers:`` option can
    contain empty column names.
    """

    required_arguments = 0
    optional_arguments = 0
    has_content= True
    final_argument_whitespace = True
    option_spec = {'vid': directives.unchanged,
                   'headers': directives.unchanged,
                   'colvids': directives.unchanged}

    def run(self):
        errid = "rql-table directive"
        self.assert_has_content()
        if self.arguments:
            raise self.warning('%s does not accept arguments' % errid)
        rql = ' '.join([l.strip() for l in self.content])
        _cw = self.state.document.settings.context._cw
        _cw.ensure_ro_rql(rql)
        try:
            rset = _cw.execute(rql)
        except Exception as exc:
            raise self.error("fail to execute RQL query in %s: %r" %
                             (errid, exc))
        if not rset:
            raise self.warning("empty result set")
        vid = self.options.get('vid', 'table')
        try:
            view = _cw.vreg['views'].select(vid, _cw, rset=rset)
        except Exception as exc:
            raise self.error("fail to select '%s' view in %s: %r" %
                             (vid, errid, exc))
        headers = None
        if 'headers' in self.options:
            headers = [h.strip() for h in self.options['headers'].split(',')]
            while headers.count(''):
                headers[headers.index('')] = None
            if len(headers) != len(rset[0]):
                raise self.error("the number of 'headers' does not match the "
                                 "number of columns in %s" % errid)
        cellvids = None
        if 'colvids' in self.options:
            cellvids = {}
            for f in self.options['colvids'].split(','):
                try:
                    idx, vid = f.strip().split('=')
                except ValueError:
                    raise self.error("malformatted 'colvids' option in %s" %
                                     errid)
                cellvids[int(idx.strip())] = vid.strip()
        try:
            content = view.render(headers=headers, cellvids=cellvids)
        except Exception as exc:
            raise self.error("Error rendering %s (%s)" % (errid, exc))
        return [nodes.raw('', content, format='html')]


try:
    from pygments import highlight
    from pygments.lexers import get_lexer_by_name
    from pygments.formatters.html import HtmlFormatter
except ImportError:
    pygments_directive = None
else:
    _PYGMENTS_FORMATTER = HtmlFormatter()

    def pygments_directive(name, arguments, options, content, lineno,
                           content_offset, block_text, state, state_machine):
        try:
            lexer = get_lexer_by_name(arguments[0])
        except ValueError:
            # no lexer found
            lexer = get_lexer_by_name('text')
        parsed = highlight(u'\n'.join(content), lexer, _PYGMENTS_FORMATTER)
        # don't fail if no context set on the sourcecode directive
        try:
            context = state.document.settings.context
            context._cw.add_css('pygments.css')
        except AttributeError:
            # used outside cubicweb XXX use hasattr instead
            pass
        return [nodes.raw('', parsed, format='html')]

    pygments_directive.arguments = (1, 0, 1)
    pygments_directive.content = 1


class CubicWebReSTParser(Parser):
    """The (customized) reStructuredText parser."""

    def __init__(self):
        self.initial_state = 'Body'
        self.state_classes = states.state_classes
        self.inliner = states.Inliner()
        self.statemachine = states.RSTStateMachine(
              state_classes=self.state_classes,
              initial_state=self.initial_state,
              debug=0)

    def parse(self, inputstring, document):
        """Parse `inputstring` and populate `document`, a document tree."""
        self.setup_parse(inputstring, document)
        inputlines = statemachine.string2lines(inputstring,
                                               convert_whitespace=1)
        self.statemachine.run(inputlines, document, inliner=self.inliner)
        self.finish_parse()


# XXX docutils keep a ref on context, can't find a correct way to remove it
class CWReSTPublisher(Publisher):
    def __init__(self, context, settings, **kwargs):
        Publisher.__init__(self, **kwargs)
        self.set_components('standalone', 'restructuredtext', 'pseudoxml')
        self.process_programmatic_settings(None, settings, None)
        self.settings.context = context


def rest_publish(context, data):
    """publish a string formatted as ReStructured Text to HTML

    :type context: a cubicweb application object

    :type data: str
    :param data: some ReST text

    :rtype: unicode
    :return:
      the data formatted as HTML or the original data if an error occurred
    """
    req = context._cw
    if isinstance(data, unicode):
        encoding = 'unicode'
        # remove unprintable characters unauthorized in xml
        data = data.translate(ESC_UCAR_TABLE)
    else:
        encoding = req.encoding
        # remove unprintable characters unauthorized in xml
        data = data.translate(ESC_CAR_TABLE)
    settings = {'input_encoding': encoding, 'output_encoding': 'unicode',
                'warning_stream': False,
                'traceback': True, # don't sys.exit
                'stylesheet': None, # don't try to embed stylesheet (may cause
                                    # obscure bug due to docutils computing
                                    # relative path according to the directory
                                    # used *at import time*
                # dunno what's the max, severe is 4, and we never want a crash
                # (though try/except may be a better option...). May be the
                # above traceback option will avoid this?
                'halt_level': 10,
                }
    if context:
        if hasattr(req, 'url'):
            base_url = req.url()
        elif hasattr(context, 'absolute_url'):
            base_url = context.absolute_url()
        else:
            base_url = req.base_url()
    else:
        base_url = None
    try:
        pub = CWReSTPublisher(context, settings,
                              parser=CubicWebReSTParser(),
                              writer=Writer(base_url=base_url),
                              source_class=io.StringInput,
                              destination_class=io.StringOutput)
        pub.set_source(data)
        pub.set_destination()
        res = pub.publish(enable_exit_status=None)
        # necessary for proper garbage collection, else a ref is kept somewhere in docutils...
        del pub.settings.context
        return res
    except BaseException:
        LOGGER.exception('error while publishing ReST text')
        if not isinstance(data, unicode):
            data = unicode(data, encoding, 'replace')
        return xml_escape(req._('error while publishing ReST text')
                           + '\n\n' + data)


_INITIALIZED = False
def cw_rest_init():
    global _INITIALIZED
    if _INITIALIZED:
        return
    _INITIALIZED = True
    register_canonical_role('eid', eid_reference_role)
    register_canonical_role('rql', rql_role)
    register_canonical_role('bookmark', bookmark_role)
    directives.register_directive('winclude', winclude_directive)
    if pygments_directive is not None:
        directives.register_directive('sourcecode', pygments_directive)
    directives.register_directive('rql-table', RQLTableDirective)