writers.py

# Richard Darst, June 2009

###
# Copyright (c) 2009, Richard Darst
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
#   * Redistributions of source code must retain the above copyright notice,
#     this list of conditions, and the following disclaimer.
#   * Redistributions in binary form must reproduce the above copyright notice,
#     this list of conditions, and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#   * Neither the name of the author of this software nor the name of
#     contributors to this software may be used to endorse or promote products
#     derived from this software without specific prior written consent.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###

import os
import re
import textwrap
import time
import traceback

rstReplaceRE = re.compile('_( |-|$)')


# Data sanitizing for various output methods
def html(text):
    """Escape bad sequences (in HTML) in user-generated lines."""
    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")


def rst(text):
    """Escapes bad sequences in reST"""
    return rstReplaceRE.sub(r'\_\1', text)


def text(text):
    """Escapes bad sequences in text (not implemented yet)"""
    return text


# wraping functions (for RST)
class TextWrapper(textwrap.TextWrapper):
    wordsep_re = re.compile(r'(\s+)')


def wrapList(item, indent=0):
    return TextWrapper(width=72, initial_indent=' '*indent,
                       subsequent_indent=' '*(indent+2),
                       break_long_words=False).fill(item)


def replaceWRAP(item):
    re_wrap = re.compile(r'sWRAPs(.*)eWRAPe', re.DOTALL)

    def repl(m):
        return TextWrapper(width=72, break_long_words=False).fill(m.group(1))
    return re_wrap.sub(repl, item)


def MeetBotVersion():
    from . import meeting
    if hasattr(meeting, '__version__'):
        return ' '+meeting.__version__
    else:
        return ''


class _BaseWriter(object):
    def __init__(self, M, **kwargs):
        self.M = M

    def format(self, extension=None):
        """Override this method to implement the formatting.

        For file output writers, the method should return a unicode
        object containing the contents of the file to write.

        The argument 'extension' is the key from `writer_map`.  For
        file writers, this can (and should) be ignored.  For non-file
        outputs, this can be used to This can be used to pass data,
        """
        raise NotImplementedError

    @property
    def pagetitle(self):
        if self.M._meetingTopic:
            return "%s: %s" % (self.M.channel, self.M._meetingTopic)
        return "%s Meeting" % self.M.channel

    def replacements(self):
        return {
            'pageTitle': self.pagetitle,
            'owner': self.M.owner,
            'starttime': time.strftime("%H:%M:%S", self.M.starttime),
            'endtime': time.strftime("%H:%M:%S", self.M.endtime),
            'timeZone': self.M.config.timeZone,
            'fullLogs': self.M.config.basename+'.log.html',
            'fullLogsFullURL': self.M.config.filename(url=True)+'.log.html',
            'MeetBotInfoURL': self.M.config.MeetBotInfoURL,
            'MeetBotVersion': MeetBotVersion(),
        }

    def iterNickCounts(self):
        nicks = [(n, c) for n, c in self.M.attendees.items()]
        nicks.sort(key=lambda x: x[1], reverse=True)
        return nicks

    def iterActionItemsNick(self):
        for nick in sorted(
                list(self.M.attendees.keys()),
                key=lambda x: x.lower()
        ):
            def nickitems():
                for m in self.M.minutes:
                    # The hack below is needed because of pickling problems
                    if m.itemtype != "ACTION":
                        continue
                    if m.line.find(nick) == -1:
                        continue
                    m.assigned = True
                    yield m
            yield nick, nickitems()

    def iterActionItemsUnassigned(self):
        for m in self.M.minutes:
            if m.itemtype != "ACTION":
                continue
            if getattr(m, 'assigned', False):
                continue
            yield m


class _CSSmanager(object):
    _css_head = textwrap.dedent('''\
        <style type="text/css">
        %s
        </style>
        ''')

    def getCSS(self, name):
        cssfile = getattr(self.M.config, 'cssFile_'+name, '')
        if cssfile.lower() == 'none':
            # special string 'None' means no style at all
            return ''
        elif cssfile in ('', 'default'):
            # default CSS file
            css_fname = os.path.join(os.path.dirname(__file__),
                                     'css-'+name+'-default.css')
        else:
            css_fname = cssfile
        try:
            # Stylesheet specified
            if getattr(self.M.config, 'cssEmbed_'+name, True):
                # external stylesheet
                css = open(css_fname).read()
                return self._css_head % css
            else:
                # linked stylesheet
                css_head = ('''<link rel="stylesheet" type="text/css" '''
                            '''href="%s">''' % cssfile)
                return css_head
        except Exception:
            if not self.M.config.safeMode:
                raise
            traceback.print_exc()
            print("(exception above ignored, continuing)")
            try:
                css_fname = os.path.join(os.path.dirname(__file__),
                                         'css-'+name+'-default.css')
                css = open(css_fname).read()
                return self._css_head % css
            except Exception:
                if not self.M.config.safeMode:
                    raise
                traceback.print_exc()
                return ''


class TextLog(_BaseWriter):
    def format(self, extension=None):
        M = self.M
        """Write raw text logs."""
        return "\n".join(M.lines)
    update_realtime = True


class HTMLlog(_BaseWriter):
    def format(self, extension=None):
        """Write pretty HTML logs."""
        M = self.M
        # pygments lexing setup:
        # (pygments HTML-formatter handles HTML-escaping)
        import pygments
        from pygments.lexers import IrcLogsLexer
        from pygments.formatters import HtmlFormatter
        import pygments.token as token
        from pygments.lexer import bygroups
        # Don't do any encoding in this function with pygments.
        # That's only right before the i/o functions in the Config
        # object.
        formatter = HtmlFormatter(lineanchors='l',
                                  full=True, style=M.config.pygmentizeStyle,
                                  outencoding=self.M.config.output_codec)
        Lexer = IrcLogsLexer
        Lexer.tokens['msg'][1:1] = [
            # match:   #topic commands
            (r"(\#topic[ \t\f\v]*)(.*\n)",
             bygroups(token.Keyword, token.Generic.Heading), '#pop'),
            # match:   #command   (others)
            (r"(\#[^\s]+[ \t\f\v]*)(.*\n)",
             bygroups(token.Keyword, token.Generic.Strong), '#pop'),
        ]
        lexer = Lexer()

        out = pygments.highlight("\n".join(M.lines), lexer, formatter)
        # Hack it to add "pre { white-space: pre-wrap; }", which make
        # it wrap the pygments html logs.  I think that in a newer
        # version of pygmetns, the "prestyles" HTMLFormatter option
        # would do this, but I want to maintain compatibility with
        # lenny.  Thus, I do these substitution hacks to add the
        # format in.  Thanks to a comment on the blog of Francis
        # Giannaros (http://francis.giannaros.org) for the suggestion
        # and instructions for how.
        out, n = re.subn(
            r"(\n\s*pre\s*\{[^}]+;\s*)(\})",
            r"\1\n      white-space: pre-wrap;\2",
            out, count=1
        )
        if n == 0:
            out = re.sub(
                r"(\n\s*</style>)",
                r"\npre { white-space: pre-wrap; }\1",
                out, count=1
            )
        return out


class HTMLlog2(_BaseWriter, _CSSmanager):
    def format(self, extension=None):
        """Write pretty HTML logs."""
        M = self.M
        lines = []
        line_re = re.compile(r"""\s*
            (?P<time> \[?[0-9:\s]*\]?)\s*
            (?P<nick>\s+<[@+\s]?[^>]+>)\s*
            (?P<line>.*)
        """, re.VERBOSE)
        action_re = re.compile(r"""\s*
            (?P<time> \[?[0-9:\s]*\]?)\s*
            (?P<nick>\*\s+[@+\s]?[^\s]+)\s*
            (?P<line>.*)
        """, re.VERBOSE)
        command_re = re.compile(r"(#[^\s]+[ \t\f\v]*)(.*)")
        command_topic_re = re.compile(r"(#topic[ \t\f\v]*)(.*)")
        hilight_re = re.compile(r"([^\s]+:)( .*)")
        lineNumber = 0
        for l in M.lines:
            lineNumber += 1  # starts from 1
            # is it a regular line?
            m = line_re.match(l)
            if m is not None:
                line = m.group('line')
                # Match #topic
                m2 = command_topic_re.match(line)
                if m2 is not None:
                    outline = (
                        '<span class="topic">%s</span>'
                        '<span class="topicline">%s</span>' %
                        (html(m2.group(1)), html(m2.group(2)))
                    )
                # Match other #commands
                if m2 is None:
                    m2 = command_re.match(line)
                    if m2 is not None:
                        outline = (
                            '<span class="cmd">%s</span>'
                            '<span class="cmdline">%s</span>' %
                            (html(m2.group(1)), html(m2.group(2)))
                        )
                # match hilights
                if m2 is None:
                    m2 = hilight_re.match(line)
                    if m2 is not None:
                        outline = (
                            '<span class="hi">%s</span>%s' %
                            (html(m2.group(1)), html(m2.group(2)))
                        )
                if m2 is None:
                    outline = html(line)
                lines.append(
                    '<a name="l-%(lineno)s"></a>'
                    '<span class="tm">%(time)s</span>'
                    '<span class="nk">%(nick)s</span> '
                    '%(line)s' % {
                        'lineno': lineNumber,
                        'time': html(m.group('time')),
                        'nick': html(m.group('nick')),
                        'line': outline,
                    }
                )
                continue
            m = action_re.match(l)
            # is it a action line?
            if m is not None:
                lines.append(
                    '<a name="l-%(lineno)s"></a>'
                    '<span class="tm">%(time)s</span>'
                    '<span class="nka">%(nick)s</span> '
                    '<span class="ac">%(line)s</span>' % {
                        'lineno': lineNumber,
                        'time': html(m.group('time')),
                        'nick': html(m.group('nick')),
                        'line': html(m.group('line')),
                    }
                )
                continue
            print(l)
            print(m.groups())
            print("**error**", l)

        css = self.getCSS(name='log')
        return html_template % {
            'pageTitle': "%s log" % html(M.channel),
            'body': "<pre>" + ("\n".join(lines)) + "</pre>",
            'headExtra': css,
        }


HTMLlog = HTMLlog2  # noqa TODO: Drop the other HTMLlog


html_template = textwrap.dedent('''\
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
    <head>
    <meta http-equiv="Content-type" content="text/html;charset=UTF-8">
    <title>%(pageTitle)s</title>
    %(headExtra)s</head>

    <body>
    %(body)s
    </body></html>
    ''')


class HTML(_BaseWriter):

    body = textwrap.dedent('''\
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
    <head>
    <meta http-equiv="Content-type" content="text/html;charset=UTF-8">
    <title>%(pageTitle)s</title>
    </head>
    <body>
    <h1>%(pageTitle)s</h1>
    Meeting started by %(owner)s at %(starttime)s %(timeZone)s.
    (<a href="%(fullLogs)s">full logs</a>)<br>


    <table border=1>
    %(MeetingItems)s
    </table>
    Meeting ended at %(endtime)s %(timeZone)s.
    (<a href="%(fullLogs)s">full logs</a>)

    <br><br><br>

    <b>Action Items</b><ol>
    %(ActionItems)s
    </ol>
    <br>

    <b>Action Items, by person</b>
    <ol>
    %(ActionItemsPerson)s
    </ol><br>

    <b>People Present (lines said):</b><ol>
    %(PeoplePresent)s
    </ol>

    <br>
    Generated by <a href="%(MeetBotInfoURL)s">MeetBot</a>%(MeetBotVersion)s.
    </body></html>
    ''')

    def format(self, extension=None):
        """Write the minutes summary."""
        M = self.M

        # Add all minute items to the table
        MeetingItems = []
        for m in M.minutes:
            MeetingItems.append(m.html(M))
        MeetingItems = "\n".join(MeetingItems)

        # Action Items
        ActionItems = []
        for m in M.minutes:
            # The hack below is needed because of pickling problems
            if m.itemtype != "ACTION":
                continue
            ActionItems.append("  <li>%s</li>" % html(m.line))
        if len(ActionItems) == 0:
            ActionItems.append("  <li>(none)</li>")
        ActionItems = "\n".join(ActionItems)

        # Action Items, by person (This could be made lots more efficient)
        ActionItemsPerson = []
        for nick, items in self.iterActionItemsNick():
            headerPrinted = False
            for m in items:
                if not headerPrinted:
                    ActionItemsPerson.append("  <li> %s <ol>" % html(nick))
                    headerPrinted = True
                ActionItemsPerson.append("    <li>%s</li>" % html(m.line))
            if headerPrinted:
                ActionItemsPerson.append("  </ol></li>")
        # unassigned items:
        ActionItemsPerson.append("  <li><b>UNASSIGNED</b><ol>")
        numberUnassigned = 0
        for m in self.iterActionItemsUnassigned():
            ActionItemsPerson.append("    <li>%s</li>" % html(m.line))
            numberUnassigned += 1
        if numberUnassigned == 0:
            ActionItemsPerson.append("    <li>(none)</li>")
        ActionItemsPerson.append('  </ol>\n</li>')
        ActionItemsPerson = "\n".join(ActionItemsPerson)

        # People Attending
        PeoplePresent = []
        # sort by number of lines spoken
        for nick, count in self.iterNickCounts():
            PeoplePresent.append('  <li>%s (%s)</li>' % (html(nick), count))
        PeoplePresent = "\n".join(PeoplePresent)

        # Actual formatting and replacement
        repl = self.replacements()
        repl.update({
            'MeetingItems': MeetingItems,
            'ActionItems': ActionItems,
            'ActionItemsPerson': ActionItemsPerson,
            'PeoplePresent': PeoplePresent,
        })
        body = self.body
        body = body % repl
        body = replaceWRAP(body)
        return body


class HTML2(_BaseWriter, _CSSmanager):
    """HTML formatter without tables.
    """
    def meetingItems(self):
        """Return the main 'Meeting minutes' block."""

        # Add all minute items to the table
        MeetingItems = []
        MeetingItems.append(self.heading('Meeting summary'))
        MeetingItems.append("<ol>")

        haveTopic = None
        inSublist = False
        for m in self.M.minutes:
            item = '<li>'+m.html2(self.M)
            if m.itemtype == "TOPIC":
                if inSublist:
                    MeetingItems.append("</ol>")
                    inSublist = False
                if haveTopic:
                    MeetingItems.append("<br></li>")
                item = item
                haveTopic = True
            else:
                if not inSublist:
                    if not haveTopic:
                        MeetingItems.append('<li>')
                        haveTopic = True
                    MeetingItems.append('<ol type="a">')
                    inSublist = True
                if haveTopic:
                    item = wrapList(item, 2)+"</li>"
                else:
                    item = wrapList(item, 0)+"</li>"
            MeetingItems.append(item)

        if inSublist:
            MeetingItems.append("</ol>")
        if haveTopic:
            MeetingItems.append("</li>")

        MeetingItems.append("</ol>")
        MeetingItems = "\n".join(MeetingItems)
        return MeetingItems

    def actionItems(self):
        """Return the 'Action items' block."""
        # Action Items
        ActionItems = []
        ActionItems.append(self.heading('Action items'))
        ActionItems.append('<ol>')
        numActionItems = 0
        for m in self.M.minutes:
            # The hack below is needed because of pickling problems
            if m.itemtype != "ACTION":
                continue
            ActionItems.append("  <li>%s</li>" % html(m.line))
            numActionItems += 1
        if numActionItems == 0:
            ActionItems.append("  <li>(none)</li>")
        ActionItems.append('</ol>')
        ActionItems = "\n".join(ActionItems)
        return ActionItems

    def actionItemsPerson(self):
        """Return the 'Action items, by person' block."""
        # Action Items, by person (This could be made lots more efficient)
        ActionItemsPerson = []
        ActionItemsPerson.append(self.heading('Action items, by person'))
        ActionItemsPerson.append('<ol>')
        numberAssigned = 0
        for nick, items in self.iterActionItemsNick():
            headerPrinted = False
            for m in items:
                numberAssigned += 1
                if not headerPrinted:
                    ActionItemsPerson.append("  <li> %s <ol>" % html(nick))
                    headerPrinted = True
                ActionItemsPerson.append("    <li>%s</li>" % html(m.line))
            if headerPrinted:
                ActionItemsPerson.append("  </ol></li>")
        # unassigned items:
        Unassigned = []
        Unassigned.append("  <li><b>UNASSIGNED</b><ol>")
        numberUnassigned = 0
        for m in self.iterActionItemsUnassigned():
            Unassigned.append("    <li>%s</li>" % html(m.line))
            numberUnassigned += 1
        if numberUnassigned == 0:
            Unassigned.append("    <li>(none)</li>")
        Unassigned.append('  </ol>\n</li>')
        if numberUnassigned > 1:
            ActionItemsPerson.extend(Unassigned)
        ActionItemsPerson.append('</ol>')
        ActionItemsPerson = "\n".join(ActionItemsPerson)

        # Only return anything if there are assigned items.
        if numberAssigned == 0:
            return None
        else:
            return ActionItemsPerson

    def peoplePresent(self):
        """Return the 'People present' block."""
        # People Attending
        PeoplePresent = []
        PeoplePresent.append(self.heading('People present (lines said)'))
        PeoplePresent.append('<ol>')
        # sort by number of lines spoken
        for nick, count in self.iterNickCounts():
            PeoplePresent.append('  <li>%s (%s)</li>' % (html(nick), count))
        PeoplePresent.append('</ol>')
        PeoplePresent = "\n".join(PeoplePresent)
        return PeoplePresent

    def heading(self, name):
        return '<h3>%s</h3>' % name

    def format(self, extension=None):
        """Write the minutes summary."""
        repl = self.replacements()

        body = []
        body.append(textwrap.dedent("""\
            <h1>%(pageTitle)s</h1>
            <span class="details">
            Meeting started by %(owner)s at %(starttime)s %(timeZone)s
            (<a href="%(fullLogs)s">full logs</a>).</span>
            """ % repl))
        body.append(self.meetingItems())
        body.append(textwrap.dedent("""\
            <span class="details">
            Meeting ended at %(endtime)s %(timeZone)s
            (<a href="%(fullLogs)s">full logs</a>).</span>
            """ % repl))
        body.append(self.actionItems())
        body.append(self.actionItemsPerson())
        body.append(self.peoplePresent())
        body.append('<span class="details">'
                    'Generated by <a href="%(MeetBotInfoURL)s">MeetBot</a>'
                    '%(MeetBotVersion)s.</span>' % repl)
        body = [b for b in body if b is not None]
        body = "\n<br><br>\n\n\n\n".join(body)
        body = replaceWRAP(body)

        css = self.getCSS(name='minutes')
        repl.update({'body': body,
                     'headExtra': css,
                     })
        html = html_template % repl

        return html


class ReST(_BaseWriter):

    body = textwrap.dedent("""\
    %(titleBlock)s
    %(pageTitle)s
    %(titleBlock)s


    sWRAPsMeeting started by %(owner)s at %(starttime)s %(timeZone)s.
    The `full logs`_ are available.eWRAPe

    .. _`full logs`: %(fullLogs)s



    Meeting summary
    ---------------
    %(MeetingItems)s

    Meeting ended at %(endtime)s %(timeZone)s.




    Action Items
    ------------
    %(ActionItems)s




    Action Items, by person
    -----------------------
    %(ActionItemsPerson)s




    People Present (lines said)
    ---------------------------
    %(PeoplePresent)s




    Generated by `MeetBot`_%(MeetBotVersion)s

    .. _`MeetBot`: %(MeetBotInfoURL)s
    """)

    def format(self, extension=None):
        """Return a ReStructured Text minutes summary."""
        M = self.M

        # Agenda items
        MeetingItems = []
        M.rst_urls = []
        M.rst_refs = {}
        haveTopic = None
        for m in M.minutes:
            item = "* "+m.rst(M)
            if m.itemtype == "TOPIC":
                if haveTopic:
                    MeetingItems.append("")
                item = wrapList(item, 0)
                haveTopic = True
            else:
                if haveTopic:
                    item = wrapList(item, 2)
                else:
                    item = wrapList(item, 0)
            MeetingItems.append(item)
        MeetingItems = '\n\n'.join(MeetingItems)
        MeetingURLs = "\n".join(M.rst_urls)
        del M.rst_urls, M.rst_refs
        MeetingItems = MeetingItems + '\n\n'+MeetingURLs

        # Action Items
        ActionItems = []
        for m in M.minutes:
            # The hack below is needed because of pickling problems
            if m.itemtype != "ACTION":
                continue
            # already escaped
            ActionItems.append(wrapList("* %s" % rst(m.line), indent=0))
        ActionItems = "\n\n".join(ActionItems)

        # Action Items, by person (This could be made lots more efficient)
        ActionItemsPerson = []
        for nick in sorted(list(M.attendees.keys()), key=lambda x: x.lower()):
            headerPrinted = False
            for m in M.minutes:
                # The hack below is needed because of pickling problems
                if m.itemtype != "ACTION":
                    continue
                if m.line.find(nick) == -1:
                    continue
                if not headerPrinted:
                    ActionItemsPerson.append("* %s" % rst(nick))
                    headerPrinted = True
                ActionItemsPerson.append(wrapList("* %s" % rst(m.line), 2))
                m.assigned = True
        # unassigned items:
        ActionItemsPerson.append("* **UNASSIGNED**")
        numberUnassigned = 0
        for m in M.minutes:
            if m.itemtype != "ACTION":
                continue
            if getattr(m, 'assigned', False):
                continue
            ActionItemsPerson.append(wrapList("* %s" % rst(m.line), 2))
            numberUnassigned += 1
        if numberUnassigned == 0:
            ActionItemsPerson.append("  * (none)")
        ActionItemsPerson = "\n\n".join(ActionItemsPerson)

        # People Attending
        PeoplePresent = []
        # sort by number of lines spoken
        for nick, count in self.iterNickCounts():
            PeoplePresent.append('* %s (%s)' % (rst(nick), count))
        PeoplePresent = "\n\n".join(PeoplePresent)

        # Actual formatting and replacement
        repl = self.replacements()
        repl.update({
            'titleBlock': ('='*len(repl['pageTitle'])),
            'MeetingItems': MeetingItems,
            'ActionItems': ActionItems,
            'ActionItemsPerson': ActionItemsPerson,
            'PeoplePresent': PeoplePresent,
        })
        body = self.body
        body = body % repl
        body = replaceWRAP(body)
        return body


class HTMLfromReST(_BaseWriter):

    def format(self, extension=None):
        M = self.M
        import docutils.core
        rst = ReST(M).format(extension)
        rstToHTML = docutils.core.publish_string(
            rst, writer_name='html',
            settings_overrides={
                'file_insertion_enabled': 0,
                'raw_enabled': 0,
                'output_encoding': self.M.config.output_codec,
            }
        )
        return rstToHTML


class Text(_BaseWriter):

    body = textwrap.dedent("""\
    %(titleBlock)s
    %(pageTitle)s
    %(titleBlock)s


    sWRAPsMeeting started by %(owner)s at %(starttime)s %(timeZone)s.
    The full logs are available at %(fullLogsFullURL)s .eWRAPe



    Meeting summary
    ---------------
    %(MeetingItems)s

    Meeting ended at %(endtime)s %(timeZone)s.




    Action Items
    ------------
    %(ActionItems)s




    Action Items, by person
    -----------------------
    %(ActionItemsPerson)s




    People Present (lines said)
    ---------------------------
    %(PeoplePresent)s




    Generated by `MeetBot`_%(MeetBotVersion)s

    .. _`MeetBot`: %(MeetBotInfoURL)s
    """)

    def format(self, extension=None):
        """Return a ReStructured Text minutes summary."""
        M = self.M

        # Agenda items
        MeetingItems = []
        haveTopic = None
        for m in M.minutes:
            item = "* "+m.text(M)
            if m.itemtype == "TOPIC":
                if haveTopic:
                    MeetingItems.append("")
                item = wrapList(item, 0)
                haveTopic = True
            else:
                if haveTopic:
                    item = wrapList(item, 2)
                else:
                    item = wrapList(item, 0)
            MeetingItems.append(item)
        MeetingItems = '\n'.join(MeetingItems)
        MeetingItems = MeetingItems

        # Action Items
        ActionItems = []
        for m in M.minutes:
            # The hack below is needed because of pickling problems
            if m.itemtype != "ACTION":
                continue
            # already escaped
            ActionItems.append(wrapList("* %s" % text(m.line), indent=0))
        ActionItems = "\n".join(ActionItems)

        # Action Items, by person (This could be made lots more efficient)
        ActionItemsPerson = []
        for nick in sorted(list(M.attendees.keys()), key=lambda x: x.lower()):
            headerPrinted = False
            for m in M.minutes:
                # The hack below is needed because of pickling problems
                if m.itemtype != "ACTION":
                    continue
                if m.line.find(nick) == -1:
                    continue
                if not headerPrinted:
                    ActionItemsPerson.append("* %s" % text(nick))
                    headerPrinted = True
                ActionItemsPerson.append(wrapList("* %s" % text(m.line), 2))
                m.assigned = True
        # unassigned items:
        ActionItemsPerson.append("* **UNASSIGNED**")
        numberUnassigned = 0
        for m in M.minutes:
            if m.itemtype != "ACTION":
                continue
            if getattr(m, 'assigned', False):
                continue
            ActionItemsPerson.append(wrapList("* %s" % text(m.line), 2))
            numberUnassigned += 1
        if numberUnassigned == 0:
            ActionItemsPerson.append("  * (none)")
        ActionItemsPerson = "\n".join(ActionItemsPerson)

        # People Attending
        PeoplePresent = []
        # sort by number of lines spoken
        for nick, count in self.iterNickCounts():
            PeoplePresent.append('* %s (%s)' % (text(nick), count))
        PeoplePresent = "\n".join(PeoplePresent)

        # Actual formatting and replacement
        repl = self.replacements()
        repl.update({
            'titleBlock': ('='*len(repl['pageTitle'])),
            'MeetingItems': MeetingItems,
            'ActionItems': ActionItems,
            'ActionItemsPerson': ActionItemsPerson,
            'PeoplePresent': PeoplePresent,
        })
        body = self.body
        body = body % repl
        body = replaceWRAP(body)
        return body