MoinLight

Annotated moinformat/parsers/table.py

297:f6d55a661579
176:47af441b48bf
109:da161661f733
2018-11-26 Paul Boddie file changeset files shortlog Support linking to stylesheets based on the collection of available files.
paul@38 1 
#!/usr/bin/env python
paul@38 2 
 
 paul@38      3 
"""
 
 paul@38      4 
Moin wiki table parser.
 
 paul@38      5 
 
 paul@54      6 
Copyright (C) 2017, 2018 Paul Boddie <paul@boddie.org.uk>
 
 paul@38      7 
 
 paul@38      8 
This program is free software; you can redistribute it and/or modify it under
 
 paul@38      9 
the terms of the GNU General Public License as published by the Free Software
 
 paul@38     10 
Foundation; either version 3 of the License, or (at your option) any later
 
 paul@38     11 
version.
 
 paul@38     12 
 
 paul@38     13 
This program is distributed in the hope that it will be useful, but WITHOUT
 
 paul@38     14 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
 paul@38     15 
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 
 paul@38     16 
details.
 
 paul@38     17 
 
 paul@38     18 
You should have received a copy of the GNU General Public License along with
 
 paul@38     19 
this program.  If not, see <http://www.gnu.org/licenses/>.
 
 paul@38     20 
"""
 
 paul@38     21 
 
 paul@55     22 
from moinformat.parsers.common import get_patterns, \
 
 paul@55     23 
                                      excl, expect, group
 
 paul@42     24 
from moinformat.parsers.moin import MoinParser
 
 paul@83     25 
from moinformat.tree.moin import Table, TableAttrs, TableCell, TableRow, Text
 
 paul@83     26 
from moinformat.tree.table import Continuation
 
 paul@38     27 
 
 paul@55     28 
join = "".join
 
 paul@38     29 
 
 paul@38     30 
# Parser functionality.
 
 paul@38     31 
 
 paul@42     32 
class TableParser(MoinParser):
 
 paul@38     33 
 
 paul@38     34 
    "A parser for improved table syntax."
 
 paul@38     35 
 
 paul@109     36 
    format = "table"
 
 paul@109     37 
 
 paul@38     38 
    # Principal parser methods.
 
 paul@38     39 
 
 paul@38     40 
    def parse_region_content(self, items, region):
 
 paul@38     41 
 
 paul@98     42 
        """
 
 paul@98     43 
        Parse the data provided by 'items' to populate the given 'region'. For
 
 paul@98     44 
        table regions, normal region handling is wrapped by management of the
 
 paul@98     45 
        table structure.
 
 paul@98     46 
        """
 
 paul@38     47 
 
 paul@38     48 
        self.set_region(items, region)
 
 paul@38     49 
 
 paul@38     50 
        # Start to populate table rows.
 
 paul@38     51 
 
 paul@38     52 
        cell = TableCell([])
 
 paul@38     53 
        row = TableRow([cell])
 
 paul@38     54 
        table = Table([row])
 
 paul@43     55 
        self.append_node(self.region, table)
 
 paul@38     56 
 
 paul@38     57 
        while True:
 
 paul@98     58 
            self.parse_region_details(cell, self.region_pattern_names)
 
 paul@38     59 
 
 paul@38     60 
            # Detect the end of the table.
 
 paul@38     61 
 
 paul@54     62 
            pattern = self.matching_pattern()
 
 paul@54     63 
 
 paul@54     64 
            if pattern == "regionend":
 
 paul@38     65 
                break
 
 paul@38     66 
 
 paul@54     67 
            elif pattern == "columnsep":
 
 paul@38     68 
                cell = TableCell([])
 
 paul@38     69 
                row.append(cell)
 
 paul@38     70 
 
 paul@54     71 
            elif pattern == "rowsep":
 
 paul@38     72 
                row = TableRow([])
 
 paul@38     73 
                table.append(row)
 
 paul@38     74 
                cell = TableCell([])
 
 paul@38     75 
                row.append(cell)
 
 paul@38     76 
 
 paul@38     77 
    # Parser handler methods.
 
 paul@38     78 
 
 paul@38     79 
    def parse_continuation(self, cell):
 
 paul@72     80 
 
 paul@72     81 
        "Handle continuation padding."
 
 paul@72     82 
 
 paul@72     83 
        feature = self.match_group("feature")
 
 paul@72     84 
        cell.append(Continuation(feature))
 
 paul@38     85 
 
 paul@38     86 
 
 paul@38     87 
 
 paul@38     88 
    # Regular expressions.
 
 paul@38     89 
 
 paul@38     90 
    syntax = {}
 
 paul@42     91 
    syntax.update(MoinParser.syntax)
 
 paul@38     92 
    syntax.update({
 
 paul@38     93 
        # At start of line:
 
 paul@55     94 
 
 paul@55     95 
        "rowsep"        : join(("^==",                      # ==
 
 paul@55     96 
                                excl(r".*==\s*?$"),         # not-heading
 
 paul@55     97 
                                expect(r"\N*?"))),          # ws-excl-nl
 
 paul@55     98 
 
 paul@72     99 
        "continuation"  : group("feature",
 
 paul@72    100 
                          join(("^",
 
 paul@55    101 
                                group("indent", r"\N*"),    # ws... (optional)
 
 paul@55    102 
                                r"\.\.",                    # ..
 
 paul@72    103 
                                excl(r"\.")))),             # not-.
 
 paul@38    104 
 
 paul@38    105 
        # Within text:
 
 paul@55    106 
 
 paul@55    107 
        "columnsep"     : join((r"\|\|",                    # ||
 
 paul@72    108 
                                excl(r"\|"))),              # not-|
 
 paul@38    109 
        })
 
 paul@38    110 
 
 paul@38    111 
    patterns = get_patterns(syntax)
 
 paul@38    112 
 
 paul@38    113 
 
 paul@38    114 
 
 paul@38    115 
    # Pattern details.
 
 paul@38    116 
 
 paul@98    117 
    region_pattern_names = [
 
 paul@102    118 
        "columnsep", "continuation", "rowsep", "tableattrs",
 
 paul@73    119 
        ] + MoinParser.region_without_table_pattern_names
 
 paul@38    120 
 
 paul@38    121 
 
 paul@38    122 
 
 paul@38    123 
    # Pattern handlers.
 
 paul@38    124 
 
 paul@98    125 
    end_region = MoinParser.end_region
 
 paul@98    126 
    parse_table_end = MoinParser.parse_region_end
 
 paul@98    127 
 
 paul@38    128 
    handlers = {}
 
 paul@42    129 
    handlers.update(MoinParser.handlers)
 
 paul@38    130 
    handlers.update({
 
 paul@98    131 
        "columnsep" : end_region,
 
 paul@38    132 
        "continuation" : parse_continuation,
 
 paul@98    133 
        "rowsep" : end_region,
 
 paul@38    134 
        "regionend" : parse_table_end,
 
 paul@38    135 
        })
 
 paul@38    136 
 
 paul@40    137 
parser = TableParser
 
 paul@40    138 
 
 paul@38    139 
# vim: tabstop=4 expandtab shiftwidth=4