|
"""Generic FAQ Wizard. |
|
|
|
This is a CGI program that maintains a user-editable FAQ. It uses RCS |
|
to keep track of changes to individual FAQ entries. It is fully |
|
configurable; everything you might want to change when using this |
|
program to maintain some other FAQ than the Python FAQ is contained in |
|
the configuration module, faqconf.py. |
|
|
|
Note that this is not an executable script; it's an importable module. |
|
The actual script to place in cgi-bin is faqw.py. |
|
|
|
""" |
|
|
|
import sys, time, os, stat, re, cgi, faqconf |
|
from faqconf import * # This imports all uppercase names |
|
now = time.time() |
|
|
|
class FileError: |
|
def __init__(self, file): |
|
self.file = file |
|
|
|
class InvalidFile(FileError): |
|
pass |
|
|
|
class NoSuchSection(FileError): |
|
def __init__(self, section): |
|
FileError.__init__(self, NEWFILENAME %(section, 1)) |
|
self.section = section |
|
|
|
class NoSuchFile(FileError): |
|
def __init__(self, file, why=None): |
|
FileError.__init__(self, file) |
|
self.why = why |
|
|
|
def escape(s): |
|
s = s.replace('&', '&') |
|
s = s.replace('<', '<') |
|
s = s.replace('>', '>') |
|
return s |
|
|
|
def escapeq(s): |
|
s = escape(s) |
|
s = s.replace('"', '"') |
|
return s |
|
|
|
def _interpolate(format, args, kw): |
|
try: |
|
quote = kw['_quote'] |
|
except KeyError: |
|
quote = 1 |
|
d = (kw,) + args + (faqconf.__dict__,) |
|
m = MagicDict(d, quote) |
|
return format % m |
|
|
|
def interpolate(format, *args, **kw): |
|
return _interpolate(format, args, kw) |
|
|
|
def emit(format, *args, **kw): |
|
try: |
|
f = kw['_file'] |
|
except KeyError: |
|
f = sys.stdout |
|
f.write(_interpolate(format, args, kw)) |
|
|
|
translate_prog = None |
|
|
|
def translate(text, pre=0): |
|
global translate_prog |
|
if not translate_prog: |
|
translate_prog = prog = re.compile( |
|
r'\b(http|ftp|https)://\S+(\b|/)|\b[-.\w]+@[-.\w]+') |
|
else: |
|
prog = translate_prog |
|
i = 0 |
|
list = [] |
|
while 1: |
|
m = prog.search(text, i) |
|
if not m: |
|
break |
|
j = m.start() |
|
list.append(escape(text[i:j])) |
|
i = j |
|
url = m.group(0) |
|
while url[-1] in '();:,.?\'"<>': |
|
url = url[:-1] |
|
i = i + len(url) |
|
url = escape(url) |
|
if not pre or (pre and PROCESS_PREFORMAT): |
|
if ':' in url: |
|
repl = '<A HREF="%s">%s</A>' % (url, url) |
|
else: |
|
repl = '<A HREF="mailto:%s">%s</A>' % (url, url) |
|
else: |
|
repl = url |
|
list.append(repl) |
|
j = len(text) |
|
list.append(escape(text[i:j])) |
|
return ''.join(list) |
|
|
|
def emphasize(line): |
|
return re.sub(r'\*([a-zA-Z]+)\*', r'<I>\1</I>', line) |
|
|
|
revparse_prog = None |
|
|
|
def revparse(rev): |
|
global revparse_prog |
|
if not revparse_prog: |
|
revparse_prog = re.compile(r'^(\d{1,3})\.(\d{1,4})$') |
|
m = revparse_prog.match(rev) |
|
if not m: |
|
return None |
|
[major, minor] = map(int, m.group(1, 2)) |
|
return major, minor |
|
|
|
logon = 0 |
|
def log(text): |
|
if logon: |
|
logfile = open("logfile", "a") |
|
logfile.write(text + "\n") |
|
logfile.close() |
|
|
|
def load_cookies(): |
|
if not os.environ.has_key('HTTP_COOKIE'): |
|
return {} |
|
raw = os.environ['HTTP_COOKIE'] |
|
words = [s.strip() for s in raw.split(';')] |
|
cookies = {} |
|
for word in words: |
|
i = word.find('=') |
|
if i >= 0: |
|
key, value = word[:i], word[i+1:] |
|
cookies[key] = value |
|
return cookies |
|
|
|
def load_my_cookie(): |
|
cookies = load_cookies() |
|
try: |
|
value = cookies[COOKIE_NAME] |
|
except KeyError: |
|
return {} |
|
import urllib |
|
value = urllib.unquote(value) |
|
words = value.split('/') |
|
while len(words) < 3: |
|
words.append('') |
|
author = '/'.join(words[:-2]) |
|
email = words[-2] |
|
password = words[-1] |
|
return {'author': author, |
|
'email': email, |
|
'password': password} |
|
|
|
def send_my_cookie(ui): |
|
name = COOKIE_NAME |
|
value = "%s/%s/%s" % (ui.author, ui.email, ui.password) |
|
import urllib |
|
value = urllib.quote(value) |
|
then = now + COOKIE_LIFETIME |
|
gmt = time.gmtime(then) |
|
path = os.environ.get('SCRIPT_NAME', '/cgi-bin/') |
|
print "Set-Cookie: %s=%s; path=%s;" % (name, value, path), |
|
print time.strftime("expires=%a, %d-%b-%y %X GMT", gmt) |
|
|
|
class MagicDict: |
|
|
|
def __init__(self, d, quote): |
|
self.__d = d |
|
self.__quote = quote |
|
|
|
def __getitem__(self, key): |
|
for d in self.__d: |
|
try: |
|
value = d[key] |
|
if value: |
|
value = str(value) |
|
if self.__quote: |
|
value = escapeq(value) |
|
return value |
|
except KeyError: |
|
pass |
|
return '' |
|
|
|
class UserInput: |
|
|
|
def __init__(self): |
|
self.__form = cgi.FieldStorage() |
|
#log("\n\nbody: " + self.body) |
|
|
|
def __getattr__(self, name): |
|
if name[0] == '_': |
|
raise AttributeError |
|
try: |
|
value = self.__form[name].value |
|
except (TypeError, KeyError): |
|
value = '' |
|
else: |
|
value = value.strip() |
|
setattr(self, name, value) |
|
return value |
|
|
|
def __getitem__(self, key): |
|
return getattr(self, key) |
|
|
|
class FaqEntry: |
|
|
|
def __init__(self, fp, file, sec_num): |
|
self.file = file |
|
self.sec, self.num = sec_num |
|
if fp: |
|
import rfc822 |
|
self.__headers = rfc822.Message(fp) |
|
self.body = fp.read().strip() |
|
else: |
|
self.__headers = {'title': "%d.%d. " % sec_num} |
|
self.body = '' |
|
|
|
def __getattr__(self, name): |
|
if name[0] == '_': |
|
raise AttributeError |
|
key = '-'.join(name.split('_')) |
|
try: |
|
value = self.__headers[key] |
|
except KeyError: |
|
value = '' |
|
setattr(self, name, value) |
|
return value |
|
|
|
def __getitem__(self, key): |
|
return getattr(self, key) |
|
|
|
def load_version(self): |
|
command = interpolate(SH_RLOG_H, self) |
|
p = os.popen(command) |
|
version = '' |
|
while 1: |
|
line = p.readline() |
|
if not line: |
|
break |
|
if line[:5] == 'head:': |
|
version = line[5:].strip() |
|
p.close() |
|
self.version = version |
|
|
|
def getmtime(self): |
|
if not self.last_changed_date: |
|
return 0 |
|
try: |
|
return os.stat(self.file)[stat.ST_MTIME] |
|
except os.error: |
|
return 0 |
|
|
|
def emit_marks(self): |
|
mtime = self.getmtime() |
|
if mtime >= now - DT_VERY_RECENT: |
|
emit(MARK_VERY_RECENT, self) |
|
elif mtime >= now - DT_RECENT: |
|
emit(MARK_RECENT, self) |
|
|
|
def show(self, edit=1): |
|
emit(ENTRY_HEADER1, self) |
|
self.emit_marks() |
|
emit(ENTRY_HEADER2, self) |
|
pre = 0 |
|
raw = 0 |
|
for line in self.body.split('\n'): |
|
# Allow the user to insert raw html into a FAQ answer |
|
# (Skip Montanaro, with changes by Guido) |
|
tag = line.rstrip().lower() |
|
if tag == '<html>': |
|
raw = 1 |
|
continue |
|
if tag == '</html>': |
|
raw = 0 |
|
continue |
|
if raw: |
|
print line |
|
continue |
|
if not line.strip(): |
|
if pre: |
|
print '</PRE>' |
|
pre = 0 |
|
else: |
|
print '<P>' |
|
else: |
|
if not line[0].isspace(): |
|
if pre: |
|
print '</PRE>' |
|
pre = 0 |
|
else: |
|
if not pre: |
|
print '<PRE>' |
|
pre = 1 |
|
if '/' in line or '@' in line: |
|
line = translate(line, pre) |
|
elif '<' in line or '&' in line: |
|
line = escape(line) |
|
if not pre and '*' in line: |
|
line = emphasize(line) |
|
print line |
|
if pre: |
|
print '</PRE>' |
|
pre = 0 |
|
if edit: |
|
print '<P>' |
|
emit(ENTRY_FOOTER, self) |
|
if self.last_changed_date: |
|
emit(ENTRY_LOGINFO, self) |
|
print '<P>' |
|
|
|
class FaqDir: |
|
|
|
entryclass = FaqEntry |
|
|
|
__okprog = re.compile(OKFILENAME) |
|
|
|
def __init__(self, dir=os.curdir): |
|
self.__dir = dir |
|
self.__files = None |
|
|
|
def __fill(self): |
|
if self.__files is not None: |
|
return |
|
self.__files = files = [] |
|
okprog = self.__okprog |
|
for file in os.listdir(self.__dir): |
|
if self.__okprog.match(file): |
|
files.append(file) |
|
files.sort() |
|
|
|
def good(self, file): |
|
return self.__okprog.match(file) |
|
|
|
def parse(self, file): |
|
m = self.good(file) |
|
if not m: |
|
return None |
|
sec, num = m.group(1, 2) |
|
return int(sec), int(num) |
|
|
|
def list(self): |
|
# XXX Caller shouldn't modify result |
|
self.__fill() |
|
return self.__files |
|
|
|
def open(self, file): |
|
sec_num = self.parse(file) |
|
if not sec_num: |
|
raise InvalidFile(file) |
|
try: |
|
fp = open(file) |
|
except IOError, msg: |
|
raise NoSuchFile(file, msg) |
|
try: |
|
return self.entryclass(fp, file, sec_num) |
|
finally: |
|
fp.close() |
|
|
|
def show(self, file, edit=1): |
|
self.open(file).show(edit=edit) |
|
|
|
def new(self, section): |
|
if not SECTION_TITLES.has_key(section): |
|
raise NoSuchSection(section) |
|
maxnum = 0 |
|
for file in self.list(): |
|
sec, num = self.parse(file) |
|
if sec == section: |
|
maxnum = max(maxnum, num) |
|
sec_num = (section, maxnum+1) |
|
file = NEWFILENAME % sec_num |
|
return self.entryclass(None, file, sec_num) |
|
|
|
class FaqWizard: |
|
|
|
def __init__(self): |
|
self.ui = UserInput() |
|
self.dir = FaqDir() |
|
|
|
def go(self): |
|
print 'Content-type: text/html' |
|
req = self.ui.req or 'home' |
|
mname = 'do_%s' % req |
|
try: |
|
meth = getattr(self, mname) |
|
except AttributeError: |
|
self.error("Bad request type %r." % (req,)) |
|
else: |
|
try: |
|
meth() |
|
except InvalidFile, exc: |
|
self.error("Invalid entry file name %s" % exc.file) |
|
except NoSuchFile, exc: |
|
self.error("No entry with file name %s" % exc.file) |
|
except NoSuchSection, exc: |
|
self.error("No section number %s" % exc.section) |
|
self.epilogue() |
|
|
|
def error(self, message, **kw): |
|
self.prologue(T_ERROR) |
|
emit(message, kw) |
|
|
|
def prologue(self, title, entry=None, **kw): |
|
emit(PROLOGUE, entry, kwdict=kw, title=escape(title)) |
|
|
|
def epilogue(self): |
|
emit(EPILOGUE) |
|
|
|
def do_home(self): |
|
self.prologue(T_HOME) |
|
emit(HOME) |
|
|
|
def do_debug(self): |
|
self.prologue("FAQ Wizard Debugging") |
|
form = cgi.FieldStorage() |
|
cgi.print_form(form) |
|
cgi.print_environ(os.environ) |
|
cgi.print_directory() |
|
cgi.print_arguments() |
|
|
|
def do_search(self): |
|
query = self.ui.query |
|
if not query: |
|
self.error("Empty query string!") |
|
return |
|
if self.ui.querytype == 'simple': |
|
query = re.escape(query) |
|
queries = [query] |
|
elif self.ui.querytype in ('anykeywords', 'allkeywords'): |
|
words = filter(None, re.split('\W+', query)) |
|
if not words: |
|
self.error("No keywords specified!") |
|
return |
|
words = map(lambda w: r'\b%s\b' % w, words) |
|
if self.ui.querytype[:3] == 'any': |
|
queries = ['|'.join(words)] |
|
else: |
|
# Each of the individual queries must match |
|
queries = words |
|
else: |
|
# Default to regular expression |
|
queries = [query] |
|
self.prologue(T_SEARCH) |
|
progs = [] |
|
for query in queries: |
|
if self.ui.casefold == 'no': |
|
p = re.compile(query) |
|
else: |
|
p = re.compile(query, re.IGNORECASE) |
|
progs.append(p) |
|
hits = [] |
|
for file in self.dir.list(): |
|
try: |
|
entry = self.dir.open(file) |
|
except FileError: |
|
constants |
|
for p in progs: |
|
if not p.search(entry.title) and not p.search(entry.body): |
|
break |
|
else: |
|
hits.append(file) |
|
if not hits: |
|
emit(NO_HITS, self.ui, count=0) |
|
elif len(hits) <= MAXHITS: |
|
if len(hits) == 1: |
|
emit(ONE_HIT, count=1) |
|
else: |
|
emit(FEW_HITS, count=len(hits)) |
|
self.format_all(hits, headers=0) |
|
else: |
|
emit(MANY_HITS, count=len(hits)) |
|
self.format_index(hits) |
|
|
|
def do_all(self): |
|
self.prologue(T_ALL) |
|
files = self.dir.list() |
|
self.last_changed(files) |
|
self.format_index(files, localrefs=1) |
|
self.format_all(files) |
|
|
|
def do_compat(self): |
|
files = self.dir.list() |
|
emit(COMPAT) |
|
self.last_changed(files) |
|
self.format_index(files, localrefs=1) |
|
self.format_all(files, edit=0) |
|
sys.exit(0) # XXX Hack to suppress epilogue |
|
|
|
def last_changed(self, files): |
|
latest = 0 |
|
for file in files: |
|
entry = self.dir.open(file) |
|
if entry: |
|
mtime = mtime = entry.getmtime() |
|
if mtime > latest: |
|
latest = mtime |
|
print time.strftime(LAST_CHANGED, time.localtime(latest)) |
|
emit(EXPLAIN_MARKS) |
|
|
|
def format_all(self, files, edit=1, headers=1): |
|
sec = 0 |
|
for file in files: |
|
try: |
|
entry = self.dir.open(file) |
|
except NoSuchFile: |
|
continue |
|
if headers and entry.sec != sec: |
|
sec = entry.sec |
|
try: |
|
title = SECTION_TITLES[sec] |
|
except KeyError: |
|
title = "Untitled" |
|
emit("\n<HR>\n<H1>%(sec)s. %(title)s</H1>\n", |
|
sec=sec, title=title) |
|
entry.show(edit=edit) |
|
|
|
def do_index(self): |
|
self.prologue(T_INDEX) |
|
files = self.dir.list() |
|
self.last_changed(files) |
|
self.format_index(files, add=1) |
|
|
|
def format_index(self, files, add=0, localrefs=0): |
|
sec = 0 |
|
for file in files: |
|
try: |
|
entry = self.dir.open(file) |
|
except NoSuchFile: |
|
continue |
|
if entry.sec != sec: |
|
if sec: |
|
if add: |
|
emit(INDEX_ADDSECTION, sec=sec) |
|
emit(INDEX_ENDSECTION, sec=sec) |
|
sec = entry.sec |
|
try: |
|
title = SECTION_TITLES[sec] |
|
except KeyError: |
|
title = "Untitled" |
|
emit(INDEX_SECTION, sec=sec, title=title) |
|
if localrefs: |
|
emit(LOCAL_ENTRY, entry) |
|
else: |
|
emit(INDEX_ENTRY, entry) |
|
entry.emit_marks() |
|
if sec: |
|
if add: |
|
emit(INDEX_ADDSECTION, sec=sec) |
|
emit(INDEX_ENDSECTION, sec=sec) |
|
|
|
def do_recent(self): |
|
if not self.ui.days: |
|
days = 1 |
|
else: |
|
days = float(self.ui.days) |
|
try: |
|
cutoff = now - days * 24 * 3600 |
|
except OverflowError: |
|
cutoff = 0 |
|
list = [] |
|
for file in self.dir.list(): |
|
entry = self.dir.open(file) |
|
if not entry: |
|
continue |
|
mtime = entry.getmtime() |
|
if mtime >= cutoff: |
|
list.append((mtime, file)) |
|
list.sort() |
|
list.reverse() |
|
self.prologue(T_RECENT) |
|
if days <= 1: |
|
period = "%.2g hours" % (days*24) |
|
else: |
|
period = "%.6g days" % days |
|
if not list: |
|
emit(NO_RECENT, period=period) |
|
elif len(list) == 1: |
|
emit(ONE_RECENT, period=period) |
|
else: |
|
emit(SOME_RECENT, period=period, count=len(list)) |
|
self.format_all(map(lambda (mtime, file): file, list), headers=0) |
|
emit(TAIL_RECENT) |
|
|
|
def do_roulette(self): |
|
import random |
|
files = self.dir.list() |
|
if not files: |
|
self.error("No entries.") |
|
return |
|
file = random.choice(files) |
|
self.prologue(T_ROULETTE) |
|
emit(ROULETTE) |
|
self.dir.show(file) |
|
|
|
def do_help(self): |
|
self.prologue(T_HELP) |
|
emit(HELP) |
|
|
|
def do_show(self): |
|
entry = self.dir.open(self.ui.file) |
|
self.prologue(T_SHOW) |
|
entry.show() |
|
|
|
def do_add(self): |
|
self.prologue(T_ADD) |
|
emit(ADD_HEAD) |
|
sections = SECTION_TITLES.items() |
|
sections.sort() |
|
for section, title in sections: |
|
emit(ADD_SECTION, section=section, title=title) |
|
emit(ADD_TAIL) |
|
|
|
def do_delete(self): |
|
self.prologue(T_DELETE) |
|
emit(DELETE) |
|
|
|
def do_log(self): |
|
entry = self.dir.open(self.ui.file) |
|
self.prologue(T_LOG, entry) |
|
emit(LOG, entry) |
|
self.rlog(interpolate(SH_RLOG, entry), entry) |
|
|
|
def rlog(self, command, entry=None): |
|
output = os.popen(command).read() |
|
sys.stdout.write('<PRE>') |
|
athead = 0 |
|
lines = output.split('\n') |
|
while lines and not lines[-1]: |
|
del lines[-1] |
|
if lines: |
|
line = lines[-1] |
|
if line[:1] == '=' and len(line) >= 40 and \ |
|
line == line[0]*len(line): |
|
del lines[-1] |
|
headrev = None |
|
for line in lines: |
|
if entry and athead and line[:9] == 'revision ': |
|
rev = line[9:].split() |
|
mami = revparse(rev) |
|
if not mami: |
|
print line |
|
else: |
|
emit(REVISIONLINK, entry, rev=rev, line=line) |
|
if mami[1] > 1: |
|
prev = "%d.%d" % (mami[0], mami[1]-1) |
|
emit(DIFFLINK, entry, prev=prev, rev=rev) |
|
if headrev: |
|
emit(DIFFLINK, entry, prev=rev, rev=headrev) |
|
else: |
|
headrev = rev |
|
print |
|
athead = 0 |
|
else: |
|
athead = 0 |
|
if line[:1] == '-' and len(line) >= 20 and \ |
|
line == len(line) * line[0]: |
|
athead = 1 |
|
sys.stdout.write('<HR>') |
|
else: |
|
print line |
|
print '</PRE>' |
|
|
|
def do_revision(self): |
|
entry = self.dir.open(self.ui.file) |
|
rev = self.ui.rev |
|
mami = revparse(rev) |
|
if not mami: |
|
self.error("Invalid revision number: %r." % (rev,)) |
|
self.prologue(T_REVISION, entry) |
|
self.shell(interpolate(SH_REVISION, entry, rev=rev)) |
|
|
|
def do_diff(self): |
|
entry = self.dir.open(self.ui.file) |
|
prev = self.ui.prev |
|
rev = self.ui.rev |
|
mami = revparse(rev) |
|
if not mami: |
|
self.error("Invalid revision number: %r." % (rev,)) |
|
if prev: |
|
if not revparse(prev): |
|
self.error("Invalid previous revision number: %r." % (prev,)) |
|
else: |
|
prev = '%d.%d' % (mami[0], mami[1]) |
|
self.prologue(T_DIFF, entry) |
|
self.shell(interpolate(SH_RDIFF, entry, rev=rev, prev=prev)) |
|
|
|
def shell(self, command): |
|
output = os.popen(command).read() |
|
sys.stdout.write('<PRE>') |
|
print escape(output) |
|
print '</PRE>' |
|
|
|
def do_new(self): |
|
entry = self.dir.new(section=int(self.ui.section)) |
|
entry.version = '*new*' |
|
self.prologue(T_EDIT) |
|
emit(EDITHEAD) |
|
emit(EDITFORM1, entry, editversion=entry.version) |
|
emit(EDITFORM2, entry, load_my_cookie()) |
|
emit(EDITFORM3) |
|
entry.show(edit=0) |
|
|
|
def do_edit(self): |
|
entry = self.dir.open(self.ui.file) |
|
entry.load_version() |
|
self.prologue(T_EDIT) |
|
emit(EDITHEAD) |
|
emit(EDITFORM1, entry, editversion=entry.version) |
|
emit(EDITFORM2, entry, load_my_cookie()) |
|
emit(EDITFORM3) |
|
entry.show(edit=0) |
|
|
|
def do_review(self): |
|
send_my_cookie(self.ui) |
|
if self.ui.editversion == '*new*': |
|
sec, num = self.dir.parse(self.ui.file) |
|
entry = self.dir.new(section=sec) |
|
entry.version = "*new*" |
|
if entry.file != self.ui.file: |
|
self.error("Commit version conflict!") |
|
emit(NEWCONFLICT, self.ui, sec=sec, num=num) |
|
return |
|
else: |
|
entry = self.dir.open(self.ui.file) |
|
entry.load_version() |
|
# Check that the FAQ entry number didn't change |
|
if self.ui.title.split()[:1] != entry.title.split()[:1]: |
|
self.error("Don't change the entry number please!") |
|
return |
|
# Check that the edited version is the current version |
|
if entry.version != self.ui.editversion: |
|
self.error("Commit version conflict!") |
|
emit(VERSIONCONFLICT, entry, self.ui) |
|
return |
|
commit_ok = ((not PASSWORD |
|
or self.ui.password == PASSWORD) |
|
and self.ui.author |
|
and '@' in self.ui.email |
|
and self.ui.log) |
|
if self.ui.commit: |
|
if not commit_ok: |
|
self.cantcommit() |
|
else: |
|
self.commit(entry) |
|
return |
|
self.prologue(T_REVIEW) |
|
emit(REVIEWHEAD) |
|
entry.body = self.ui.body |
|
entry.title = self.ui.title |
|
entry.show(edit=0) |
|
emit(EDITFORM1, self.ui, entry) |
|
if commit_ok: |
|
emit(COMMIT) |
|
else: |
|
emit(NOCOMMIT_HEAD) |
|
self.errordetail() |
|
emit(NOCOMMIT_TAIL) |
|
emit(EDITFORM2, self.ui, entry, load_my_cookie()) |
|
emit(EDITFORM3) |
|
|
|
def cantcommit(self): |
|
self.prologue(T_CANTCOMMIT) |
|
print CANTCOMMIT_HEAD |
|
self.errordetail() |
|
print CANTCOMMIT_TAIL |
|
|
|
def errordetail(self): |
|
if PASSWORD and self.ui.password != PASSWORD: |
|
emit(NEED_PASSWD) |
|
if not self.ui.log: |
|
emit(NEED_LOG) |
|
if not self.ui.author: |
|
emit(NEED_AUTHOR) |
|
if not self.ui.email: |
|
emit(NEED_EMAIL) |
|
|
|
def commit(self, entry): |
|
file = entry.file |
|
# Normalize line endings in body |
|
if '\r' in self.ui.body: |
|
self.ui.body = re.sub('\r\n?', '\n', self.ui.body) |
|
# Normalize whitespace in title |
|
self.ui.title = ' '.join(self.ui.title.split()) |
|
# Check that there were any changes |
|
if self.ui.body == entry.body and self.ui.title == entry.title: |
|
self.error("You didn't make any changes!") |
|
return |
|
|
|
# need to lock here because otherwise the file exists and is not writable (on NT) |
|
command = interpolate(SH_LOCK, file=file) |
|
p = os.popen(command) |
|
output = p.read() |
|
|
|
try: |
|
os.unlink(file) |
|
except os.error: |
|
pass |
|
try: |
|
f = open(file, 'w') |
|
except IOError, why: |
|
self.error(CANTWRITE, file=file, why=why) |
|
return |
|
date = time.ctime(now) |
|
emit(FILEHEADER, self.ui, os.environ, date=date, _file=f, _quote=0) |
|
f.write('\n') |
|
f.write(self.ui.body) |
|
f.write('\n') |
|
f.close() |
|
|
|
import tempfile |
|
tf = tempfile.NamedTemporaryFile() |
|
emit(LOGHEADER, self.ui, os.environ, date=date, _file=tf) |
|
tf.flush() |
|
tf.seek(0) |
|
|
|
command = interpolate(SH_CHECKIN, file=file, tfn=tf.name) |
|
log("\n\n" + command) |
|
p = os.popen(command) |
|
output = p.read() |
|
sts = p.close() |
|
log("output: " + output) |
|
log("done: " + str(sts)) |
|
log("TempFile:\n" + tf.read() + "end") |
|
|
|
if not sts: |
|
self.prologue(T_COMMITTED) |
|
emit(COMMITTED) |
|
else: |
|
self.error(T_COMMITFAILED) |
|
emit(COMMITFAILED, sts=sts) |
|
print '<PRE>%s</PRE>' % escape(output) |
|
|
|
try: |
|
os.unlink(tf.name) |
|
except os.error: |
|
pass |
|
|
|
entry = self.dir.open(file) |
|
entry.show() |
|
|
|
wiz = FaqWizard() |
|
wiz.go() |
