~ubuntu-branches/ubuntu/intrepid/moin/intrepid-updates

    dl_rule = ur"^\s+.*?::\s"

 

    # the big, fat, ugly one ;)

(?:(?P<emph_ibb>'''''(?=[^']+'''))

(?P<emph_ibi>'''''(?=[^']+''))

(?P<emph_ib_or_bi>'{5}(?=[^']))

(?P<macro>\[\[(%%(macronames)s)(?:\(.*?\))?\]\]))

(?P<ol>%(ol_rule)s)

(?P<dl>%(dl_rule)s)

(?P<tableZ>\|\| $)

(?P<table>(?:\|\|)+(?:<[^>]*?>)?(?!\|? $))

(?P<heading>^\s*(?P<hmarker>=+)\s.*\s(?P=hmarker) $)

(?P<email>[-\w._+]+\@[\w-]+(\.[\w-]+)+)

(?P<smiley>(?<=\s)(%(smiley)s)(?=\s))

(?P<smileyA>^(%(smiley)s)(?=\s))

(?P<ent>[<>&])

(?P<wikiname_bracket>\[".*?"\])

(?P<tt_bt>`.*?`)"""  % {

        'smiley': u'|'.join(map(re.escape, config.smileys.keys()))}

 

    # Don't start p before these 

 

    def __init__(self, raw, request, **kw):

        self.raw = raw

            return self.attachment(words, pretty_url=1)

 

        if wikiutil.isPicture(words[1]) and re.match(self.url_rule, words[1]):

                    self.formatter.image(title=words[0], alt=words[0], src=words[1]) +

                    self.formatter.url(0))

        else:

                    self.formatter.text(words[1]) +

                    self.formatter.url(0))

 

        #        '<': '&lt;',

        #        '>': '&gt;'}[word]

 

    def _ent_numeric_repl(self, word):

 

    def _li_repl(self, match):

        result = []

        self._close_item(result)

        self.in_li = 1

        if self.line_was_empty and not self.first_list_item:

            css_class = 'gap'

        return ''.join(result)

 

    def _ol_repl(self, match):

        """Handle numbered lists."""

        return self._li_repl(match)

        #        self.inhibit_p = 1

    

        # Close lists while char-wise indent is greater than the current one

            self._close_item(close)

            if self.list_types[-1] == 'ol':

                tag = self.formatter.number_list(0)

            ##self.inhibit_p = 1

            self.in_li = 0

            self.in_dd = 0

        # If list level changes, close an open table

        if self.in_table and (open or close):

            close[0:0] = [self.formatter.table(0)]

        result = []

        #result.append("<!-- _undent start -->\n")

        self._close_item(result)

            if type == 'ol':

                result.append(self.formatter.number_list(0))

            elif type == 'dl':

                        'arg': arg, 'key': key}

                else:

                    attrs['bgcolor'] = '"#%s"' % arg

            else:

            #print "key: %s\nattrs: %s" % (key, str(attrs))

            return self.formatter.rawHTML(msg)

 

    def _macro_repl(self, word):

        """Handle macros ([[macroname]])."""

        macro_name = word[2:-2]

 

        # check for arguments

        args = None

                ###result.append(u'<span class="info">[add text before match: <tt>"%s"</tt>]</span>' % line[lastpos:match.start()])

                

                if not (self.inhibit_p or self.in_pre or self.formatter.in_p):

                result.append(self.formatter.text(line[lastpos:match.start()]))

            

            # Replace match with markup

        # No match: Add paragraph with the text of the line

        if not (self.in_pre or self.inhibit_p or

                self.formatter.in_p) and lastpos < len(line):

        result.append(self.formatter.text(line[lastpos:]))

        return u''.join(result)

 

                    # Open p for certain types

                    if not (self.inhibit_p or self.formatter.in_p

                            or self.in_pre or (type in self.no_new_p_before)):

                    

                    # Get replace method and replece hit

                    replace = getattr(self, '_' + type + '_repl')

                    self.processor = None

 

                    # send rest of line through regex machinery

            else:

                # we don't have \n as whitespace any more

                # This is the space between lines we join to one paragraph

                        self.in_table = 0

                    # CHANGE: removed check for not self.list_types

                    # p should close on every empty line

                        self.request.write(self.formatter.paragraph(0))

                    self.line_is_empty = 1

                    continue

                            indtype = "dl"

 

                # output proper indentation tags

 

                # Table mode

                # TODO: move into function?                

                    and line[-3:] == "|| " and len(line) >= 5 + indlen):

                    # Start table

                    if self.list_types and not self.in_li:

                        ## CHANGE: no automatic p on li

                        ##self.request.write(self.formatter.paragraph(1))

                        self.in_li = 1

            formatted_line = self.scan(scan_re, line)

            self.request.write(formatted_line)

 

                self.request.write(self.formatter.linebreak())

 

        # Close code displays, paragraphs, tables and open lists

                self.processor_is_parser = 1

            except wikiutil.PluginMissingError:

                self.processor = None