| """Generic output formatting. | |
| Formatter objects transform an abstract flow of formatting events into | |
| specific output events on writer objects. Formatters manage several stack | |
| structures to allow various properties of a writer object to be changed and | |
| restored; writers need not be able to handle relative changes nor any sort | |
| of ``change back'' operation. Specific writer properties which may be | |
| controlled via formatter objects are horizontal alignment, font, and left | |
| margin indentations. A mechanism is provided which supports providing | |
| arbitrary, non-exclusive style settings to a writer as well. Additional | |
| interfaces facilitate formatting events which are not reversible, such as | |
| paragraph separation. | |
| Writer objects encapsulate device interfaces. Abstract devices, such as | |
| file formats, are supported as well as physical devices. The provided | |
| implementations all work with abstract devices. The interface makes | |
| available mechanisms for setting the properties which formatter objects | |
| manage and inserting data into the output. | |
| """ | |
| import sys | |
| AS_IS = None | |
| class NullFormatter: | |
| """A formatter which does nothing. | |
| If the writer parameter is omitted, a NullWriter instance is created. | |
| No methods of the writer are called by NullFormatter instances. | |
| Implementations should inherit from this class if implementing a writer | |
| interface but don't need to inherit any implementation. | |
| """ | |
| def __init__(self, writer=None): | |
| if writer is None: | |
| writer = NullWriter() | |
| self.writer = writer | |
| def end_paragraph(self, blankline): pass | |
| def add_line_break(self): pass | |
| def add_hor_rule(self, *args, **kw): pass | |
| def add_label_data(self, format, counter, blankline=None): pass | |
| def add_flowing_data(self, data): pass | |
| def add_literal_data(self, data): pass | |
| def flush_softspace(self): pass | |
| def push_alignment(self, align): pass | |
| def pop_alignment(self): pass | |
| def push_font(self, x): pass | |
| def pop_font(self): pass | |
| def push_margin(self, margin): pass | |
| def pop_margin(self): pass | |
| def set_spacing(self, spacing): pass | |
| def push_style(self, *styles): pass | |
| def pop_style(self, n=1): pass | |
| def assert_line_data(self, flag=1): pass | |
| class AbstractFormatter: | |
| """The standard formatter. | |
| This implementation has demonstrated wide applicability to many writers, | |
| and may be used directly in most circumstances. It has been used to | |
| implement a full-featured World Wide Web browser. | |
| """ | |
| # Space handling policy: blank spaces at the boundary between elements | |
| # are handled by the outermost context. "Literal" data is not checked | |
| # to determine context, so spaces in literal data are handled directly | |
| # in all circumstances. | |
| def __init__(self, writer): | |
| self.writer = writer # Output device | |
| self.align = None # Current alignment | |
| self.align_stack = [] # Alignment stack | |
| self.font_stack = [] # Font state | |
| self.margin_stack = [] # Margin state | |
| self.spacing = None # Vertical spacing state | |
| self.style_stack = [] # Other state, e.g. color | |
| self.nospace = 1 # Should leading space be suppressed | |
| self.softspace = 0 # Should a space be inserted | |
| self.para_end = 1 # Just ended a paragraph | |
| self.parskip = 0 # Skipped space between paragraphs? | |
| self.hard_break = 1 # Have a hard break | |
| self.have_label = 0 | |
| def end_paragraph(self, blankline): | |
| if not self.hard_break: | |
| self.writer.send_line_break() | |
| self.have_label = 0 | |
| if self.parskip < blankline and not self.have_label: | |
| self.writer.send_paragraph(blankline - self.parskip) | |
| self.parskip = blankline | |
| self.have_label = 0 | |
| self.hard_break = self.nospace = self.para_end = 1 | |
| self.softspace = 0 | |
| def add_line_break(self): | |
| if not (self.hard_break or self.para_end): | |
| self.writer.send_line_break() | |
| self.have_label = self.parskip = 0 | |
| self.hard_break = self.nospace = 1 | |
| self.softspace = 0 | |
| def add_hor_rule(self, *args, **kw): | |
| if not self.hard_break: | |
| self.writer.send_line_break() | |
| self.writer.send_hor_rule(*args, **kw) | |
| self.hard_break = self.nospace = 1 | |
| self.have_label = self.para_end = self.softspace = self.parskip = 0 | |
| def add_label_data(self, format, counter, blankline = None): | |
| if self.have_label or not self.hard_break: | |
| self.writer.send_line_break() | |
| if not self.para_end: | |
| self.writer.send_paragraph((blankline and 1) or 0) | |
| if isinstance(format, str): | |
| self.writer.send_label_data(self.format_counter(format, counter)) | |
| else: | |
| self.writer.send_label_data(format) | |
| self.nospace = self.have_label = self.hard_break = self.para_end = 1 | |
| self.softspace = self.parskip = 0 | |
| def format_counter(self, format, counter): | |
| label = '' | |
| for c in format: | |
| if c == '1': | |
| label = label + ('%d' % counter) | |
| elif c in 'aA': | |
| if counter > 0: | |
| label = label + self.format_letter(c, counter) | |
| elif c in 'iI': | |
| if counter > 0: | |
| label = label + self.format_roman(c, counter) | |
| else: | |
| label = label + c | |
| return label | |
| def format_letter(self, case, counter): | |
| label = '' | |
| while counter > 0: | |
| counter, x = divmod(counter-1, 26) | |
| # This makes a strong assumption that lowercase letters | |
| # and uppercase letters form two contiguous blocks, with | |
| # letters in order! | |
| s = chr(ord(case) + x) | |
| label = s + label | |
| return label | |
| def format_roman(self, case, counter): | |
| ones = ['i', 'x', 'c', 'm'] | |
| fives = ['v', 'l', 'd'] | |
| label, index = '', 0 | |
| # This will die of IndexError when counter is too big | |
| while counter > 0: | |
| counter, x = divmod(counter, 10) | |
| if x == 9: | |
| label = ones[index] + ones[index+1] + label | |
| elif x == 4: | |
| label = ones[index] + fives[index] + label | |
| else: | |
| if x >= 5: | |
| s = fives[index] | |
| x = x-5 | |
| else: | |
| s = '' | |
| s = s + ones[index]*x | |
| label = s + label | |
| index = index + 1 | |
| if case == 'I': | |
| return label.upper() | |
| return label | |
| def add_flowing_data(self, data): | |
| if not data: return | |
| prespace = data[:1].isspace() | |
| postspace = data[-1:].isspace() | |
| data = " ".join(data.split()) | |
| if self.nospace and not data: | |
| return | |
| elif prespace or self.softspace: | |
| if not data: | |
| if not self.nospace: | |
| self.softspace = 1 | |
| self.parskip = 0 | |
| return | |
| if not self.nospace: | |
| data = ' ' + data | |
| self.hard_break = self.nospace = self.para_end = \ | |
| self.parskip = self.have_label = 0 | |
| self.softspace = postspace | |
| self.writer.send_flowing_data(data) | |
| def add_literal_data(self, data): | |
| if not data: return | |
| if self.softspace: | |
| self.writer.send_flowing_data(" ") | |
| self.hard_break = data[-1:] == '\n' | |
| self.nospace = self.para_end = self.softspace = \ | |
| self.parskip = self.have_label = 0 | |
| self.writer.send_literal_data(data) | |
| def flush_softspace(self): | |
| if self.softspace: | |
| self.hard_break = self.para_end = self.parskip = \ | |
| self.have_label = self.softspace = 0 | |
| self.nospace = 1 | |
| self.writer.send_flowing_data(' ') | |
| def push_alignment(self, align): | |
| if align and align != self.align: | |
| self.writer.new_alignment(align) | |
| self.align = align | |
| self.align_stack.append(align) | |
| else: | |
| self.align_stack.append(self.align) | |
| def pop_alignment(self): | |
| if self.align_stack: | |
| del self.align_stack[-1] | |
| if self.align_stack: | |
| self.align = align = self.align_stack[-1] | |
| self.writer.new_alignment(align) | |
| else: | |
| self.align = None | |
| self.writer.new_alignment(None) | |
| def push_font(self, font): | |
| size, i, b, tt = font | |
| if self.softspace: | |
| self.hard_break = self.para_end = self.softspace = 0 | |
| self.nospace = 1 | |
| self.writer.send_flowing_data(' ') | |
| if self.font_stack: | |
| csize, ci, cb, ctt = self.font_stack[-1] | |
| if size is AS_IS: size = csize | |
| if i is AS_IS: i = ci | |
| if b is AS_IS: b = cb | |
| if tt is AS_IS: tt = ctt | |
| font = (size, i, b, tt) | |
| self.font_stack.append(font) | |
| self.writer.new_font(font) | |
| def pop_font(self): | |
| if self.font_stack: | |
| del self.font_stack[-1] | |
| if self.font_stack: | |
| font = self.font_stack[-1] | |
| else: | |
| font = None | |
| self.writer.new_font(font) | |
| def push_margin(self, margin): | |
| self.margin_stack.append(margin) | |
| fstack = filter(None, self.margin_stack) | |
| if not margin and fstack: | |
| margin = fstack[-1] | |
| self.writer.new_margin(margin, len(fstack)) | |
| def pop_margin(self): | |
| if self.margin_stack: | |
| del self.margin_stack[-1] | |
| fstack = filter(None, self.margin_stack) | |
| if fstack: | |
| margin = fstack[-1] | |
| else: | |
| margin = None | |
| self.writer.new_margin(margin, len(fstack)) | |
| def set_spacing(self, spacing): | |
| self.spacing = spacing | |
| self.writer.new_spacing(spacing) | |
| def push_style(self, *styles): | |
| if self.softspace: | |
| self.hard_break = self.para_end = self.softspace = 0 | |
| self.nospace = 1 | |
| self.writer.send_flowing_data(' ') | |
| for style in styles: | |
| self.style_stack.append(style) | |
| self.writer.new_styles(tuple(self.style_stack)) | |
| def pop_style(self, n=1): | |
| del self.style_stack[-n:] | |
| self.writer.new_styles(tuple(self.style_stack)) | |
| def assert_line_data(self, flag=1): | |
| self.nospace = self.hard_break = not flag | |
| self.para_end = self.parskip = self.have_label = 0 | |
| class NullWriter: | |
| """Minimal writer interface to use in testing & inheritance. | |
| A writer which only provides the interface definition; no actions are | |
| taken on any methods. This should be the base class for all writers | |
| which do not need to inherit any implementation methods. | |
| """ | |
| def __init__(self): pass | |
| def flush(self): pass | |
| def new_alignment(self, align): pass | |
| def new_font(self, font): pass | |
| def new_margin(self, margin, level): pass | |
| def new_spacing(self, spacing): pass | |
| def new_styles(self, styles): pass | |
| def send_paragraph(self, blankline): pass | |
| def send_line_break(self): pass | |
| def send_hor_rule(self, *args, **kw): pass | |
| def send_label_data(self, data): pass | |
| def send_flowing_data(self, data): pass | |
| def send_literal_data(self, data): pass | |
| class AbstractWriter(NullWriter): | |
| """A writer which can be used in debugging formatters, but not much else. | |
| Each method simply announces itself by printing its name and | |
| arguments on standard output. | |
| """ | |
| def new_alignment(self, align): | |
| print "new_alignment(%r)" % (align,) | |
| def new_font(self, font): | |
| print "new_font(%r)" % (font,) | |
| def new_margin(self, margin, level): | |
| print "new_margin(%r, %d)" % (margin, level) | |
| def new_spacing(self, spacing): | |
| print "new_spacing(%r)" % (spacing,) | |
| def new_styles(self, styles): | |
| print "new_styles(%r)" % (styles,) | |
| def send_paragraph(self, blankline): | |
| print "send_paragraph(%r)" % (blankline,) | |
| def send_line_break(self): | |
| print "send_line_break()" | |
| def send_hor_rule(self, *args, **kw): | |
| print "send_hor_rule()" | |
| def send_label_data(self, data): | |
| print "send_label_data(%r)" % (data,) | |
| def send_flowing_data(self, data): | |
| print "send_flowing_data(%r)" % (data,) | |
| def send_literal_data(self, data): | |
| print "send_literal_data(%r)" % (data,) | |
| class DumbWriter(NullWriter): | |
| """Simple writer class which writes output on the file object passed in | |
| as the file parameter or, if file is omitted, on standard output. The | |
| output is simply word-wrapped to the number of columns specified by | |
| the maxcol parameter. This class is suitable for reflowing a sequence | |
| of paragraphs. | |
| """ | |
| def __init__(self, file=None, maxcol=72): | |
| self.file = file or sys.stdout | |
| self.maxcol = maxcol | |
| NullWriter.__init__(self) | |
| self.reset() | |
| def reset(self): | |
| self.col = 0 | |
| self.atbreak = 0 | |
| def send_paragraph(self, blankline): | |
| self.file.write('\n'*blankline) | |
| self.col = 0 | |
| self.atbreak = 0 | |
| def send_line_break(self): | |
| self.file.write('\n') | |
| self.col = 0 | |
| self.atbreak = 0 | |
| def send_hor_rule(self, *args, **kw): | |
| self.file.write('\n') | |
| self.file.write('-'*self.maxcol) | |
| self.file.write('\n') | |
| self.col = 0 | |
| self.atbreak = 0 | |
| def send_literal_data(self, data): | |
| self.file.write(data) | |
| i = data.rfind('\n') | |
| if i >= 0: | |
| self.col = 0 | |
| data = data[i+1:] | |
| data = data.expandtabs() | |
| self.col = self.col + len(data) | |
| self.atbreak = 0 | |
| def send_flowing_data(self, data): | |
| if not data: return | |
| atbreak = self.atbreak or data[0].isspace() | |
| col = self.col | |
| maxcol = self.maxcol | |
| write = self.file.write | |
| for word in data.split(): | |
| if atbreak: | |
| if col + len(word) >= maxcol: | |
| write('\n') | |
| col = 0 | |
| else: | |
| write(' ') | |
| col = col + 1 | |
| write(word) | |
| col = col + len(word) | |
| atbreak = 1 | |
| self.col = col | |
| self.atbreak = data[-1].isspace() | |
| def test(file = None): | |
| w = DumbWriter() | |
| f = AbstractFormatter(w) | |
| if file is not None: | |
| fp = open(file) | |
| elif sys.argv[1:]: | |
| fp = open(sys.argv[1]) | |
| else: | |
| fp = sys.stdin | |
| for line in fp: | |
| if line == '\n': | |
| f.end_paragraph(1) | |
| else: | |
| f.add_flowing_data(line) | |
| f.end_paragraph(0) | |
| if __name__ == '__main__': | |
| test() |