Lib/formatter.py

   1 import string
   2 import sys
   3 from types import StringType
   4
   5
   6 AS_IS = None
   7
   8
   9 class NullFormatter:
  10
  11     def __init__(self, writer=None):
  12         if not writer:
  13             writer = NullWriter()
  14         self.writer = writer
  15     def end_paragraph(self, blankline): pass
  16     def add_line_break(self): pass
  17     def add_hor_rule(self, *args, **kw): pass
  18     def add_label_data(self, format, counter, blankline=None): pass
  19     def add_flowing_data(self, data): pass
  20     def add_literal_data(self, data): pass
  21     def flush_softspace(self): pass
  22     def push_alignment(self, align): pass
  23     def pop_alignment(self): pass
  24     def push_font(self, x): pass
  25     def pop_font(self): pass
  26     def push_margin(self, margin): pass
  27     def pop_margin(self): pass
  28     def set_spacing(self, spacing): pass
  29     def push_style(self, *styles): pass
  30     def pop_style(self, n=1): pass
  31     def assert_line_data(self, flag=1): pass
  32
  33
  34 class AbstractFormatter:
  35
  36     #  Space handling policy:  blank spaces at the boundary between elements
  37     #  are handled by the outermost context.  "Literal" data is not checked
  38     #  to determine context, so spaces in literal data are handled directly
  39     #  in all circumstances.
  40
  41     def __init__(self, writer):
  42         self.writer = writer            # Output device
  43         self.align = None               # Current alignment
  44         self.align_stack = []           # Alignment stack
  45         self.font_stack = []            # Font state
  46         self.margin_stack = []          # Margin state
  47         self.spacing = None             # Vertical spacing state
  48         self.style_stack = []           # Other state, e.g. color
  49         self.nospace = 1                # Should leading space be suppressed
  50         self.softspace = 0              # Should a space be inserted
  51         self.para_end = 1               # Just ended a paragraph
  52         self.parskip = 0                # Skipped space between paragraphs?
  53         self.hard_break = 1             # Have a hard break
  54         self.have_label = 0
  55
  56     def end_paragraph(self, blankline):
  57         if not self.hard_break:
  58             self.writer.send_line_break()
  59             self.have_label = 0
  60         if self.parskip < blankline and not self.have_label:
  61             self.writer.send_paragraph(blankline - self.parskip)
  62             self.parskip = blankline
  63             self.have_label = 0
  64         self.hard_break = self.nospace = self.para_end = 1
  65         self.softspace = 0
  66
  67     def add_line_break(self):
  68         if not (self.hard_break or self.para_end):
  69             self.writer.send_line_break()
  70             self.have_label = self.parskip = 0
  71         self.hard_break = self.nospace = 1
  72         self.softspace = 0
  73
  74     def add_hor_rule(self, *args, **kw):
  75         if not self.hard_break:
  76             self.writer.send_line_break()
  77         apply(self.writer.send_hor_rule, args, kw)
  78         self.hard_break = self.nospace = 1
  79         self.have_label = self.para_end = self.softspace = self.parskip = 0
  80
  81     def add_label_data(self, format, counter, blankline = None):
  82         if self.have_label or not self.hard_break:
  83             self.writer.send_line_break()
  84         if not self.para_end:
  85             self.writer.send_paragraph((blankline and 1) or 0)
  86         if type(format) is StringType:
  87             self.writer.send_label_data(self.format_counter(format, counter))
  88         else:
  89             self.writer.send_label_data(format)
  90         self.nospace = self.have_label = self.hard_break = self.para_end = 1
  91         self.softspace = self.parskip = 0
  92
  93     def format_counter(self, format, counter):
  94         label = ''
  95         for c in format:
  96             try:
  97                 if c == '1':
  98                     label = label + ('%d' % counter)
  99                 elif c in 'aA':
 100                     if counter > 0:
 101                         label = label + self.format_letter(c, counter)
 102                 elif c in 'iI':
 103                     if counter > 0:
 104                         label = label + self.format_roman(c, counter)
 105                 else:
 106                     label = label + c
 107             except:
 108                 label = label + c
 109         return label
 110
 111     def format_letter(self, case, counter):
 112         label = ''
 113         while counter > 0:
 114             counter, x = divmod(counter-1, 26)
 115             s = chr(ord(case) + x)
 116             label = s + label
 117         return label
 118
 119     def format_roman(self, case, counter):
 120         ones = ['i', 'x', 'c', 'm']
 121         fives = ['v', 'l', 'd']
 122         label, index = '', 0
 123         # This will die of IndexError when counter is too big
 124         while counter > 0:
 125             counter, x = divmod(counter, 10)
 126             if x == 9:
 127                 label = ones[index] + ones[index+1] + label
 128             elif x == 4:
 129                 label = ones[index] + fives[index] + label
 130             else:
 131                 if x >= 5:
 132                     s = fives[index]
 133                     x = x-5
 134                 else:
 135                     s = ''
 136                 s = s + ones[index]*x
 137                 label = s + label
 138             index = index + 1
 139         if case == 'I':
 140             return string.upper(label)
 141         return label
 142
 143     def add_flowing_data(self, data,
 144                          # These are only here to load them into locals:
 145                          whitespace = string.whitespace,
 146                          join = string.join, split = string.split):
 147         if not data: return
 148         # The following looks a bit convoluted but is a great improvement over
 149         # data = regsub.gsub('[' + string.whitespace + ']+', ' ', data)
 150         prespace = data[:1] in whitespace
 151         postspace = data[-1:] in whitespace
 152         data = join(split(data))
 153         if self.nospace and not data:
 154             return
 155         elif prespace or self.softspace:
 156             if not data:
 157                 if not self.nospace:
 158                     self.softspace = 1
 159                     self.parskip = 0
 160                 return
 161             if not self.nospace:
 162                 data = ' ' + data
 163         self.hard_break = self.nospace = self.para_end = \
 164                           self.parskip = self.have_label = 0
 165         self.softspace = postspace
 166         self.writer.send_flowing_data(data)
 167
 168     def add_literal_data(self, data):
 169         if not data: return
 170         if self.softspace:
 171             self.writer.send_flowing_data(" ")
 172         self.hard_break = data[-1:] == '\n'
 173         self.nospace = self.para_end = self.softspace = \
 174                        self.parskip = self.have_label = 0
 175         self.writer.send_literal_data(data)
 176
 177     def flush_softspace(self):
 178         if self.softspace:
 179             self.hard_break = self.para_end = self.parskip = \
 180                               self.have_label = self.softspace = 0
 181             self.nospace = 1
 182             self.writer.send_flowing_data(' ')
 183
 184     def push_alignment(self, align):
 185         if align and align != self.align:
 186             self.writer.new_alignment(align)
 187             self.align = align
 188             self.align_stack.append(align)
 189         else:
 190             self.align_stack.append(self.align)
 191
 192     def pop_alignment(self):
 193         if self.align_stack:
 194             del self.align_stack[-1]
 195         if self.align_stack:
 196             self.align = align = self.align_stack[-1]
 197             self.writer.new_alignment(align)
 198         else:
 199             self.align = None
 200             self.writer.new_alignment(None)
 201
 202     def push_font(self, (size, i, b, tt)):
 203         if self.softspace:
 204             self.hard_break = self.para_end = self.softspace = 0
 205             self.nospace = 1
 206             self.writer.send_flowing_data(' ')
 207         if self.font_stack:
 208             csize, ci, cb, ctt = self.font_stack[-1]
 209             if size is AS_IS: size = csize
 210             if i is AS_IS: i = ci
 211             if b is AS_IS: b = cb
 212             if tt is AS_IS: tt = ctt
 213         font = (size, i, b, tt)
 214         self.font_stack.append(font)
 215         self.writer.new_font(font)
 216
 217     def pop_font(self):
 218         if self.font_stack:
 219             del self.font_stack[-1]
 220         if self.font_stack:
 221             font = self.font_stack[-1]
 222         else:
 223             font = None
 224         self.writer.new_font(font)
 225
 226     def push_margin(self, margin):
 227         self.margin_stack.append(margin)
 228         fstack = filter(None, self.margin_stack)
 229         if not margin and fstack:
 230             margin = fstack[-1]
 231         self.writer.new_margin(margin, len(fstack))
 232
 233     def pop_margin(self):
 234         if self.margin_stack:
 235             del self.margin_stack[-1]
 236         fstack = filter(None, self.margin_stack)
 237         if fstack:
 238             margin = fstack[-1]
 239         else:
 240             margin = None
 241         self.writer.new_margin(margin, len(fstack))
 242
 243     def set_spacing(self, spacing):
 244         self.spacing = spacing
 245         self.writer.new_spacing(spacing)
 246
 247     def push_style(self, *styles):
 248         if self.softspace:
 249             self.hard_break = self.para_end = self.softspace = 0
 250             self.nospace = 1
 251             self.writer.send_flowing_data(' ')
 252         for style in styles:
 253             self.style_stack.append(style)
 254         self.writer.new_styles(tuple(self.style_stack))
 255
 256     def pop_style(self, n=1):
 257         del self.style_stack[-n:]
 258         self.writer.new_styles(tuple(self.style_stack))
 259
 260     def assert_line_data(self, flag=1):
 261         self.nospace = self.hard_break = not flag
 262         self.para_end = self.parskip = self.have_label = 0
 263
 264
 265 class NullWriter:
 266     """Minimal writer interface to use in testing & inheritance."""
 267     def __init__(self): pass
 268     def flush(self): pass
 269     def new_alignment(self, align): pass
 270     def new_font(self, font): pass
 271     def new_margin(self, margin, level): pass
 272     def new_spacing(self, spacing): pass
 273     def new_styles(self, styles): pass
 274     def send_paragraph(self, blankline): pass
 275     def send_line_break(self): pass
 276     def send_hor_rule(self, *args, **kw): pass
 277     def send_label_data(self, data): pass
 278     def send_flowing_data(self, data): pass
 279     def send_literal_data(self, data): pass
 280
 281
 282 class AbstractWriter(NullWriter):
 283
 284     def __init__(self):
 285         pass
 286
 287     def new_alignment(self, align):
 288         print "new_alignment(%s)" % `align`
 289
 290     def new_font(self, font):
 291         print "new_font(%s)" % `font`
 292
 293     def new_margin(self, margin, level):
 294         print "new_margin(%s, %d)" % (`margin`, level)
 295
 296     def new_spacing(self, spacing):
 297         print "new_spacing(%s)" % `spacing`
 298
 299     def new_styles(self, styles):
 300         print "new_styles(%s)" % `styles`
 301
 302     def send_paragraph(self, blankline):
 303         print "send_paragraph(%s)" % `blankline`
 304
 305     def send_line_break(self):
 306         print "send_line_break()"
 307
 308     def send_hor_rule(self, *args, **kw):
 309         print "send_hor_rule()"
 310
 311     def send_label_data(self, data):
 312         print "send_label_data(%s)" % `data`
 313
 314     def send_flowing_data(self, data):
 315         print "send_flowing_data(%s)" % `data`
 316
 317     def send_literal_data(self, data):
 318         print "send_literal_data(%s)" % `data`
 319
 320
 321 class DumbWriter(NullWriter):
 322
 323     def __init__(self, file=None, maxcol=72):
 324         self.file = file or sys.stdout
 325         self.maxcol = maxcol
 326         NullWriter.__init__(self)
 327         self.reset()
 328
 329     def reset(self):
 330         self.col = 0
 331         self.atbreak = 0
 332
 333     def send_paragraph(self, blankline):
 334         self.file.write('\n'*blankline)
 335         self.col = 0
 336         self.atbreak = 0
 337
 338     def send_line_break(self):
 339         self.file.write('\n')
 340         self.col = 0
 341         self.atbreak = 0
 342
 343     def send_hor_rule(self, *args, **kw):
 344         self.file.write('\n')
 345         self.file.write('-'*self.maxcol)
 346         self.file.write('\n')
 347         self.col = 0
 348         self.atbreak = 0
 349
 350     def send_literal_data(self, data):
 351         self.file.write(data)
 352         i = string.rfind(data, '\n')
 353         if i >= 0:
 354             self.col = 0
 355             data = data[i+1:]
 356         data = string.expandtabs(data)
 357         self.col = self.col + len(data)
 358         self.atbreak = 0
 359
 360     def send_flowing_data(self, data):
 361         if not data: return
 362         atbreak = self.atbreak or data[0] in string.whitespace
 363         col = self.col
 364         maxcol = self.maxcol
 365         write = self.file.write
 366         for word in string.split(data):
 367             if atbreak:
 368                 if col + len(word) >= maxcol:
 369                     write('\n')
 370                     col = 0
 371                 else:
 372                     write(' ')
 373                     col = col + 1
 374             write(word)
 375             col = col + len(word)
 376             atbreak = 1
 377         self.col = col
 378         self.atbreak = data[-1] in string.whitespace
 379
 380
 381 def test(file = None):
 382     w = DumbWriter()
 383     f = AbstractFormatter(w)
 384     if file:
 385         fp = open(file)
 386     elif sys.argv[1:]:
 387         fp = open(sys.argv[1])
 388     else:
 389         fp = sys.stdin
 390     while 1:
 391         line = fp.readline()
 392         if not line:
 393             break
 394         if line == '\n':
 395             f.end_paragraph(1)
 396         else:
 397             f.add_flowing_data(line)
 398     f.end_paragraph(0)
 399
 400
 401 if __name__ == '__main__':
 402     test()