"""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() |