attachment:tables-1.1.py of tables.py

   1 #-*- coding: utf-8 -*-
   2 '''
   3 MoinMoin - tables parser, Version 1.1, 23.01.2011
   4 
   5 A simple parser that reads key:value pairs from a listing of tables (moin table markup from page or attachment) and captions then formats these for display within an enclosing borderless table. Defaults to single column layout with captions above centred tables. If more key:value pairs are provided additional rows are added to the layout. The user can set options to (1) force double or triple column layout, (2) place captions to the left or right of the tables, (3) set tables left or right justified, (4) give tables a width other than the default of 66% (a value from 25 to 100% is permitted), and (5) show only the markup for re-use with modifications, if desired, or for debugging purposes.
   6 
   7 The key:value list must be in the form " table_page/file:: caption" with a leading space (as moin dictionary entries). All non-conforming lines are ignored without warning.
   8 
   9 The key is a page or attachment name. The parser checks for a page first. Processing instructions are permitted at the head of a page but not in an attachment. Comment lines beginning with `##` are permitted within the table. Otherwise, both the page and file must contain a markup for a single table only.
  10 
  11 The parser is intended for page section use only. The parser name is followed by a list of keywords separated by spaces to specify any options required.
  12 
  13 Keywords
  14 
  15 c-2 : forces double column layout, if the requested with is 50% or less. Overides c-3, if both options given, as double column takes precedence.
  16 
  17 c-3 : forces triple column layout, if the requested width is 33% or less. Default is one columns, so no c-1 is not needed.
  18 
  19 c-left : caption to left of image. Overides c-none or c-right, if more than one option given, as left takes precedence.
  20 
  21 c-none : ignore captions.
  22 
  23 c-right : caption to right of image. Overides c-none, if both options given, as right takes precedence over none.
  24 
  25 t-left : tables set left. Overides f-right, if both options given, as left takes precedence.
  26 
  27 t-right : tables set right.
  28 
  29 nnn% : requested width of table (including caption if set to left or right), where n is digits from 25 to 100. If outside this range, the default 50% is applied and no warning is given. If two or more width options are given, the first takes precedence and others are ignored (even if the first is invalid and the default widith applied).
  30 
  31 markup : shows the markup if you wish to re-use this with modification (assuming the default tabulation does not suit a specific purpose) or for debugging purposes.
  32 
  33 # : inserted at the beginning of the caption overrides caption inclusion and any associated padding. Inclusion of caption text is option and effectively acts as a comment. Overidding captions can result in uneven multiple row layout where rows have different number of images and/or overidden captions. Therefore, this feature in recommended only for single row layouts. Also, caption and padding cells are not generated, so the sum of the cell widths is less than the table width and the tables and remaining captions will increase in size proportionally. Values set by the nnn% argument therefore become nominal only.
  34 
  35 Defaults are caption and table centred, width 66%, one column (so no options for these are needed).
  36 
  37 Keywords can appear in any order, other than as indicated above for conflicting choices.
  38 
  39 Dependency
  40 
  41 The parser requires a macro RenderText.py to be installed in plugin/macros. This macro un-glues the inserted table's lines, renders the markup text and inserts it in the enclosing table cell.
  42 
  43 {{{
  44 from MoinMoin import wikiutil
  45 from MoinMoin.parser.text_moin_wiki import Parser as wiki
  46 def execute(macro, text):
  47      text = (text.replace('&&', '\n')).replace(')+>>', ')>>')
  48      return wikiutil.renderText(macro.request, wiki, text)
  49 }}}
  50 
  51 Usage
  52 
  53 {{{#!tables [c-2|c-3 ][c-left|c-none|c-right ][t-left|t-right ][nnn% ][markup ]
  54  table_page/file:: [#]caption
  55  table_page/file:: [#]caption
  56  ...
  57 }}}
  58 
  59 History
  60 
  61 Version 1.1 - 23.01.2011: escaped macro syntax; revised RenderText macro accordingly
  62 Version 1.0 - 22.01.2011: initial version
  63 
  64 Developed with inspiration and code from:
  65 
  66 figures.py parser - @copyright: 2011 Ian Riley
  67 keyval.py parser - @copyright: 2006 by Matt Cooper <macooper@vt.edu>
  68 sort.py parser - @copyright: 2005 ReimarBauer
  69 
  70 Copyright
  71 
  72 @copyright: 2011 Ian Riley <ian.riley@adelaide.edu.au>
  73 
  74 License
  75 
  76 GNU GPL, see COPYING for details.
  77 '''
  78 
  79 Dependencies = []
  80 
  81 from MoinMoin.action import AttachFile
  82 from MoinMoin.Page import Page
  83 from MoinMoin.parser import text_moin_wiki as wiki
  84 from MoinMoin import wikiutil
  85 
  86 class Parser:
  87     parsername = 'tables'
  88 
  89     def __init__(self, raw, request, **kw):
  90         self.raw = raw
  91         self.request = request
  92         self.form = request.form
  93         self._ = request.getText
  94         self.args = kw.get('format_args', '')
  95 
  96     def format(self, formatter):
  97         empty = u''
  98         eol = u'\n'
  99         rtn = u'\r'
 100         glue = u'&&'
 101         sep = u':: '
 102         sep_dir = u'/'
 103         space = u' '
 104         monospace = u'` `'
 105         macro_end = u')>>'
 106         macro_esc = u')+>>'
 107         ignore = u'#'
 108         comment = u'##'
 109         percent = u'%'
 110         brk = u'<<BR>>'
 111         parsing = (u"{{{", u"}}}", )
 112         tab = u'||<tablestyle="width:100%; " '
 113         cell  = u'||<style="border:none; width:%(width)s%%; ">'
 114         cella  = u'||<%(align)s style="border:none; width:%(width)s%%; ">'
 115         padcell  = u'||<style="border:none; width:%(pad)s%%; ">'
 116         celli = u'||'
 117         cellf = u'||\n'
 118         tbl = u'<<RenderText(%(tbl)s)>>'
 119         cap = u'%(cap)s'
 120         capc = u'<<RenderText(||<tablestyle="width:100%%; " style="border:none; ">%(cap)s ||)>>'
 121         tfile = u'.txt'
 122         warning_msg =  u'||<style="color: #ff0000; font-weight: bold;">%s: %s||'
 123         options, tables, rows, results = ([], [], [], [])
 124         tbls, ignored, layout, padding = (0, 0, 0, 0, )
 125         left, centre, right, void = (0, 1, 2, 3, )
 126         top, mid, bot, ljust, cjust, rjust = (u'^', u'', u'v', u'(', u':', u')', )
 127         max_cols = 1
 128         std_width = 66
 129         min_widths = (0, 25, 25, 25, )
 130         max_widths = (0, 100, 50, 33, )
 131         aligns = (mid, top, mid, mid, ) # TODO consider making this a selectable option
 132         justs = (rjust, ljust, ljust, ljust, ) # leave centred (ie above) caption left justified
 133         # for captions (left, centre, right, none,)
 134         layouts = (cella+cap+cell+tbl, cell+capc+tbl, cell+tbl+cella+cap, cell+tbl, ) 
 135 
 136         #set defaults which might get changed
 137         cap_pos = centre
 138         tbl_pos = centre
 139         req_width = std_width
 140 
 141         # set options
 142         options = self.args.split(space)
 143         if "c-none" in options:
 144             cap_pos = void
 145         if "c-right" in options:  # do second as right takes precedence
 146             cap_pos = right
 147         if "c-left" in options: # do last as left takes precedence
 148             cap_pos = left
 149         if "c-3" in options:
 150             max_cols = 3
 151         if "c-2" in options: # do second as single column takes precedence
 152             max_cols = 2
 153         if "t-right" in options:
 154             tbl_pos = right
 155         if "t-left" in options: # do second as left takes precedence
 156             tbl_pos = left
 157         markup = "markup" in options
 158         for option in options:
 159             if option.endswith(percent):
 160                 try:
 161                     req_width = int(option.rstrip(percent)) # will check this value later
 162                 except:
 163                     pass
 164                 break # do not look for any more width options
 165         del options
 166         # check requested width in range or set default
 167         if (req_width > max_widths[1]) or (req_width < min_widths[3]):
 168             req_width = std_width
 169         # dynamically set maximum columns depending on requested width
 170         while (max_cols > 1) and (req_width > max_widths[max_cols]):
 171             max_cols = max_cols - 1
 172         # calculate widths for captions (left, centre, right)
 173         widths = (int(req_width / 2), req_width, int(req_width / 2), req_width, )
 174 
 175         def get_attachment(request, page_name, source):
 176             if AttachFile.exists(request, page_name, source):
 177                 file_name = Page(request, page_name).getPagePath("attachments")
 178                 file_name = file_name+sep_dir+source
 179                 f = open(file_name,'r')
 180                 text = f.read()
 181                 f.close()
 182                 text = text.replace(rtn,empty)
 183                 if text == empty:
 184                     text = warning_msg % (source, 'attachment empty', )
 185             else:
 186                 text = warning_msg % (source, 'not found', )
 187             return text
 188 
 189         def get_content(source):
 190             content = []
 191             page_name = self.request.page.page_name
 192             abs_source = wikiutil.AbsPageName(page_name, source)
 193             # is there a page?
 194             if not Page(self.request, abs_source).isStandardPage(abs_source):
 195                 #try for an attachment instead
 196                 text = get_attachment(self.request, page_name, (source + tfile))
 197             else:
 198                 if self.request.user.may.read(abs_source):
 199                     content = Page(self.request, abs_source)
 200                     text = content.getPageText()
 201                     if (content is None) or (text == empty):
 202                         text = warning_msg % (source, 'page empty', )
 203                 else:
 204                     text = warning_msg % (source, 'access denied', )
 205             # crudely check that text conforms to table markup
 206             text = text.strip()
 207             lines = text.split(eol)
 208             text = empty
 209             for line in lines:
 210                 if line.startswith(comment):
 211                     continue
 212                 if (not line.startswith(celli)) or (not line.endswith(celli)):
 213                      text = warning_msg % (source, 'invalid table markup', )
 214                      break
 215                 text = text + line.strip() + glue
 216             text = text.rstrip(glue)
 217             text = text.replace(macro_end, macro_esc)
 218             return text
 219 
 220         # process the lines of text provided
 221         lines = self.raw.split(eol)
 222         for line in lines:
 223             if line:
 224                 # handle table lines
 225                 if (line[0] == space) and (sep in line):
 226                     key, val = (line.lstrip(space)).split(sep)
 227                     val = val.replace(macro_end, macro_esc)
 228                     tables.append((key, val, get_content(key)))
 229                     if val.startswith(ignore):
 230                         ignored = ignored + 1
 231         del lines
 232 
 233         # construct a list of row column numbers
 234         tbls = len(tables)
 235         while tbls >= max_cols:
 236            rows.append(max_cols)
 237            tbls = tbls - max_cols
 238         if tbls > 0:
 239            rows.append(tbls)
 240 
 241         # construct output for columns in rows
 242         def calc_padding():
 243             table_width = int(100 / max_cols) * max_cols
 244             item_width = widths[cap_pos]
 245             if (cap_pos in (left, right, )): # offset caption so double for image + caption
 246                 item_width = item_width * 2
 247             if tbl_pos == centre: # centred so needs smaller interspersed padding
 248                 padding = int((table_width - (item_width * cols)) / (cols + 1))
 249             else: # not centred so just one wider padding
 250                 padding = int(table_width - (item_width * cols))
 251             return padding
 252 
 253         def add_padding(seq):
 254             yes_pad = False
 255             if padding == 0:
 256                 return ''
 257             if seq == 0:
 258                 yes_pad = (tbl_pos == right)
 259             elif seq == 1:
 260                 yes_pad = (tbl_pos == centre) and \
 261                           ((cap_pos in (centre, void, )) or \
 262                            (first_col) or \
 263                            ((cap_pos == left) and (layout != void)))
 264             elif seq == 2:
 265                 yes_pad = (tbl_pos == centre) and \
 266                           ((cols == 1) or \
 267                            ((cap_pos == right) and (layout != void)))
 268             elif seq == 3:
 269                 yes_pad = (tbl_pos == left)
 270 
 271             if yes_pad:
 272                 return (padcell % {'pad': padding})
 273             else:
 274                 return ''
 275 
 276         for cols in rows:
 277             first_col = True
 278             pending = ''
 279             padding = calc_padding()
 280             pending = pending + add_padding(0)
 281             while cols > 0:
 282                 table = tables.pop(0)
 283                 if table[1].startswith(ignore):
 284                     layout = void
 285                 else:
 286                     layout = cap_pos
 287                 pending = pending + add_padding(1)
 288                 pending = pending + \
 289                          (layouts[layout] % {'align': aligns[cap_pos]+justs[cap_pos], \
 290                                              'width': widths[cap_pos], \
 291                                              'tbl': table[2], \
 292                                              'cap': table[1]})
 293                 pending = pending + add_padding(2)
 294                 cols = cols - 1
 295                 first_col = False
 296             pending = pending + add_padding(3)
 297             pending = tab + pending[3:] + cellf # insert tablestyle and close table
 298             results.append(pending)
 299         del rows, tables
 300 
 301         # escape markup if requested
 302         if markup:
 303             results.insert(0, parsing[0])
 304             results.append(parsing[1])
 305 
 306         wikiizer = wiki.Parser(eol.join(results), self.request)
 307         wikiizer.format(formatter, inhibit_p=True)