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