__oneliner__="Convert ASCII source files for HTML presentation"
__longdoc__="""
This program is not yet particularly smart, and will produce
undefined output (or even traceback) if the source file does
not meet expected format. With time, it may get better about
this.
#------------------- Shell Usage -----------------------#
Usage: python dmTxt2Html.py [options] [filename] (or)
txt2html.cgi [options] [filename]
-h, /h, -?, /?, ?: Show this help screen
-type:: Set conversion type
(see discussion of types)
-REBUILD_DOCS: Generate 'txt2html.txt'
-out:: Output filename (default STDOUT)
-proxy:: Use proxy element(s) in output
, -, /: Input from STDIN (default)
Proxy modes are: NAVIGATOR, TRAP_LINKS, ALL, NONE.
Elements are "navigation bar" at top of pages and
virtualization of in-page links. Shell default in NONE.
Note: CGI is detected by the absence of arguments;, if
all defaults are wanted, specify STDIN explicitly:
python txt2html.py - < MyArticle.txt > MyArticle.html
-
#-------------------- CGI Usage ------------------------#
Usage: A URL string may be composed manually, but the
normal usage will be to call txt2html.cgi from an
HTML form with the fields: 'source', 'preface,
'type', 'proxy'. 'preface' allows explicit
overriding of HTTP headers in the returned page,
normally as a hidden field. Use with caution (or
don't use at all, the default is sensible).
Example:
------------------------------------------------------------------------
Expected input format for [HTML]
Source HTML is presented unmodified except for the inclusion
of the Txt2HTML proxy at the top of each page.
Expected input format for [PYTHON]
Source Python code is marked up with syntax highlighting, but
no other HTML elements are introduced (no headers, no bold, no
URLs, etc)
Expected input format for [SMART_ASCII]
#--- Paragraph rules: ---#
- Title occurs on first line of document, unindented and in
all caps.
- Subtitle occurs on second line, unindented and in mixed
case.
- Name, affiliation, date occur, unindented and in mixed
case, on lines 4-6.
- Section headings are preceded by two blank lines,
unindented, in all caps, followed by one line of 72
dashes and one blank line.
- Regular text paragraphs are block style, and are indented
two spaces.
- Block quotations are indented four spaces, rather than
the two of original text.
- Code samples are indented six spaces (with internal
indentation of code lines in the proper relative
position).
- Code samples may begin with a line indicating a title for
that block. If present, this title is indented the same
six spaces as the rest of the block, and begins and ends
with a pound sign ('#'). Dashes are used to fill space
within the title for ASCII asthetics.
-
#--- Character rules: ---#
- All character markup has the pattern:
whitespace-symbol-words(s)-symbol-whitespace
Examples are given, and this can be searched for
programmatically. The use of character markup applies
*only* to text paragraphs, *not* to code samples!
- Asterisks are used for an inflectional emphasis. For
example, "All good boys *deserve* fudge." This would
typically be indicated typographically with boldface or
italics.
- Underscores are used for book/journal citation. For
example, "Knuth's _Art of Computer Programming_ is
essential." This would typically be indicated
typographically with italics or underline.
- Single-stroke is used to indicate filenames and function
names. For example, "Every C program has a 'main()'
function." This might be indicated typographically by a
fixed font, by boldface, or simply by single-quotes.
- Braces are used to indicate a module, package or library.
For example, "The [cre] module will replace [re] in
Python 1.6." This will probably be indicated
typographically as a fixed font.
- Double-stroke is used as either inline quotation or scare
quotes. For example, "It may not be as "easy" as
suggested." In either case, typographic quotes are
probably the best format; italics would make some sense
also.
- Parenthesis are used, and should be preserved as is.
- Angle brackets and curly brackets have no special meaning
yet. I may choose to use those if there is something I
think the above forms do not capture.
- Em-dashes, diacritics, ligatures, and typographic
quotations are not available, and standard ASCII
approximations are used.
-
#--- Miscellany: ---#
- URL's are automatically transformed into a hotlink.
Basically, anything that starts with 'http://', 'ftp://',
'file://' or 'gopher://' looks like a URL to the program.
"""
__doc__=__oneliner__+__longdoc__
__comments__="""
This script utilizes the services of the Marc-Andre Lemburg's Python
Highlighter for HTML (v0.5+) [py2html]. [py2html] in turn relies on
Just van Rossum's [PyFontify] (v.0.3.1+) If these are not present,
Txt2HTML hopes to degrade gracefully, but will not provide syntax
highlighting for Python source code.
"""
__author__=["David Mertz (mertz@gnosis.cx)",]
__copyright__="""
This file is released to the public domain. I (dqm) would
appreciate it if you choose to keep derived works under terms
that promote freedom, but obviously am giving up any rights
to compel such.
"""
__version__="version 0.2 (August 2000)"
#-- import stuff, or at least try
import py2html, sys, re, string, time
from urllib import urlopen
from cStringIO import *
try:
import py2html
py_formatter = 1
except:
py_formatter = 0
#-- Define some HTML boilerplate
cgi_home = "http://gnosis.cx/cgi-bin/"
html_open =\
"""
%s
"""
html_title = "Automatically Generated HTML"
html_close = ""
code_block = \
"""
"""
#-- End of boilerplate
def main(cfg_dict):
"""Process input source, as per configuration dictionary.
Just one value is passed to txt2html.main(): a dictionary of operation
options. The dictionary must hold the following keys:
'source': URL of source (or local filename) or ''
'target': Filename of output or ''
'preface': (optional) HTTP header for output, esp. if CGI
'type': (of input) 'HTML','SMART_ASCII','PYTHON','SIMPLE',...
'proxy': 'NAVIGATOR', 'TRAP_LINKS', 'ALL', 'NONE'
"""
replace = string.replace
#-- Read the configuration, set options
source = cfg_dict['source']
if source == '':
fhin = sys.stdin
cfg_dict['source'] = '<STDIN>'
else:
try:
fhin = urlopen(source)
except:
ErrReport(source+' could not be opened!', cfg_dict)
return
target = cfg_dict['target']
if target == '':
fhout = sys.stdout
else:
fhout = open(target, 'w')
#-- Get intype and the regex list
intype = cfg_dict['type']
re_list = Regex_by_filetype(intype)
#-- Process as needed for input type
if intype in ['HTML']:
if cfg_dict.has_key('preface'): fhout.write(cfg_dict['preface'])
doc = ''
for line in fhin.readlines(): # Need to normalize line endings!
doc = doc+string.rstrip(line)+'\n'
if cfg_dict['proxy'] in ['ALL', 'NAVIGATOR']: # proxy nav bar
doc = re.sub('(?im)()','\\1'+(promo % cfg_dict),doc)
if cfg_dict['proxy'] <> 'NONE': # absolute links
doc = Absolutize(doc, source)
if cfg_dict['proxy'] in ['ALL', 'TRAP_LINKS']: # proxy links
doc = Proxify(doc, cgi_home+'txt2html.cgi?source=')
fhout.write(doc)
elif intype in ['SMART_ASCII']:
#sys.stderr.write(' start: ' + time.ctime(time.time())+"\n")
blocks = Make_Blocks(fhin, re_list)
#sys.stderr.write(' blocks made: ' + time.ctime(time.time())+"\n")
Process_Blocks(fhout, blocks, cfg_dict, title_block=1)
#sys.stderr.write('blocks processed: ' + time.ctime(time.time())+"\n")
elif intype in ['PYTHON', 'FAQ', 'SIMPLE', 'RAW']:
blocks = Make_Blocks(fhin, re_list)
Process_Blocks(fhout, blocks, cfg_dict)
else:
ErrReport('Something is amiss with filetype detection', cfg_dict)
return
def Make_Blocks(fhin, re_list):
#-- Initialize the globals
global state, blocks, bl_num, newblock
state = "HEADER"
blocks = [""]
bl_num = 0
newblock = 1
#-- Unpack the regex list
blankln, headln, textln, quoteln, codeln = re_list
#-- Break the file into relevant chunks
for line in fhin.readlines():
line = string.rstrip(line)+'\n' # Need to normalize line endings!
if state == "HEADER": # blank line means new block of ??
if blankln.match(line): newblock = 1
elif textln.match(line): startText(line)
elif quoteln.match(line): startQuote(line)
elif codeln.match(line): startCode(line)
else:
if newblock: startHead(line)
else: blocks[bl_num] = blocks[bl_num] + line
elif state == "TEXT": # blank line means new block of ??
if blankln.match(line): newblock = 1
elif headln.match(line): startHead(line)
elif quoteln.match(line): startQuote(line)
elif codeln.match(line): startCode(line)
else:
if newblock: startText(line)
else: blocks[bl_num] = blocks[bl_num] + line
elif state == "QUOTE": # blank line means new block of ??
if blankln.match(line): newblock = 1
elif headln.match(line): startHead(line)
elif textln.match(line): startText(line)
# do not transition quote->code without a blank line
# elif codeln.match(line): startCode(line)
else:
if newblock: startQuote(line)
else: blocks[bl_num] = blocks[bl_num] + line
elif state == "CODE": # blank line does not change state
if blankln.match(line): blocks[bl_num] = blocks[bl_num] + line
elif headln.match(line): startHead(line)
elif textln.match(line): startText(line)
else: blocks[bl_num] = blocks[bl_num] + line
else:
raise ValueError, "unexpected input block state: "+state
return blocks
def Process_Blocks(fhout, blocks, cfg_dict, title_block=0):
# Process all blocks, then write out headers and body
# (performance might be snappier in CGI if we wrote block-by-block...)
#-- check for server errors
re_err = re.compile('^.*.*(404)|(403).*', re.I | re.S | re.M)
block = string.join(blocks[0:3])
if re_err.match(block):
html_title = 'Server reported error on URL'
re_body = re.compile('(.*)
', re.I | re.M | re.S)
body = re_body.match(block).group(1)
else:
# Worry about having the right number of blocks
if len(blocks) == 1:
blocks = ['',cfg_dict['type'],cfg_dict['source'],
'Weird failure parsing source experienced!']
elif len(blocks) <= 3 or not title_block:
blocks = ['','Type of file: '+cfg_dict['type'],
cfg_dict['source']] + blocks[1:]
# Give it a nice page title
html_title = string.join(string.split(blocks[1], '\n'),' -- ')
html_title = string.replace(html_title, '[HEAD]', '')
# Massage each block as needed
body = Titleify(blocks[1]) + Authorify(blocks[2])
for block in blocks[3:]:
if block[:6]=='[CODE]': block = fixcode(block[6:],cfg_dict['type'])
elif block[:6]=='[QUOT]': block = fixquote(block[6:])
elif block[:6]=='[TEXT]': block = fixtext(block[6:])
elif block[:6]=='[HEAD]': block = fixhead(block[6:])
else: raise ValueError, "unexpected block marker: "+block[:6]
if cfg_dict['proxy'] in ['ALL', 'TRAP_LINKS']:
block = Proxify(block, cgi_home+'txt2html.cgi?source=')
body = body+block
#-- Output with surrounding document HTML/HTTP
if cfg_dict.has_key('preface'):
fhout.write(cfg_dict['preface'])
fhout.write(html_open % html_title)
if cfg_dict['proxy'] in ['ALL', 'NAVIGATOR']:
fhout.write(promo % cfg_dict)
fhout.write(body)
fhout.write(html_close)
def ErrReport(mess, cfg_dict):
if cfg_dict.has_key('preface'): print cfg_dict['preface']
print (html_open % html_title)
if cfg_dict['proxy'] in ['ALL', 'NAVIGATOR']:
print (promo % cfg_dict)
print '