home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pyos2bin.zip / Lib / formatter.py < prev    next >
Text File  |  1997-10-22  |  11KB  |  403 lines
  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' + '\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()
  403.