Tools/faqwiz/faqwiz.py

   1 """Generic FAQ Wizard.
   2
   3 This is a CGI program that maintains a user-editable FAQ.  It uses RCS
   4 to keep track of changes to individual FAQ entries.  It is fully
   5 configurable; everything you might want to change when using this
   6 program to maintain some other FAQ than the Python FAQ is contained in
   7 the configuration module, faqconf.py.
   8
   9 Note that this is not an executable script; it's an importable module.
  10 The actual script to place in cgi-bin is faqw.py.
  11
  12 """
  13
  14 import sys, time, os, stat, re, cgi, faqconf
  15 from faqconf import *                   # This imports all uppercase names
  16 now = time.time()
  17
  18 class FileError:
  19     def __init__(self, file):
  20         self.file = file
  21
  22 class InvalidFile(FileError):
  23     pass
  24
  25 class NoSuchSection(FileError):
  26     def __init__(self, section):
  27         FileError.__init__(self, NEWFILENAME %(section, 1))
  28         self.section = section
  29
  30 class NoSuchFile(FileError):
  31     def __init__(self, file, why=None):
  32         FileError.__init__(self, file)
  33         self.why = why
  34
  35 def escape(s):
  36     s = s.replace('&', '&amp;')
  37     s = s.replace('<', '&lt;')
  38     s = s.replace('>', '&gt;')
  39     return s
  40
  41 def escapeq(s):
  42     s = escape(s)
  43     s = s.replace('"', '&quot;')
  44     return s
  45
  46 def _interpolate(format, args, kw):
  47     try:
  48         quote = kw['_quote']
  49     except KeyError:
  50         quote = 1
  51     d = (kw,) + args + (faqconf.__dict__,)
  52     m = MagicDict(d, quote)
  53     return format % m
  54
  55 def interpolate(format, *args, **kw):
  56     return _interpolate(format, args, kw)
  57
  58 def emit(format, *args, **kw):
  59     try:
  60         f = kw['_file']
  61     except KeyError:
  62         f = sys.stdout
  63     f.write(_interpolate(format, args, kw))
  64
  65 translate_prog = None
  66
  67 def translate(text, pre=0):
  68     global translate_prog
  69     if not translate_prog:
  70         translate_prog = prog = re.compile(
  71             r'\b(http|ftp|https)://\S+(\b|/)|\b[-.\w]+@[-.\w]+')
  72     else:
  73         prog = translate_prog
  74     i = 0
  75     list = []
  76     while 1:
  77         m = prog.search(text, i)
  78         if not m:
  79             break
  80         j = m.start()
  81         list.append(escape(text[i:j]))
  82         i = j
  83         url = m.group(0)
  84         while url[-1] in '();:,.?\'"<>':
  85             url = url[:-1]
  86         i = i + len(url)
  87         url = escape(url)
  88         if not pre or (pre and PROCESS_PREFORMAT):
  89             if ':' in url:
  90                 repl = '<A HREF="%s">%s</A>' % (url, url)
  91             else:
  92                 repl = '<A HREF="mailto:%s">%s</A>' % (url, url)
  93         else:
  94             repl = url
  95         list.append(repl)
  96     j = len(text)
  97     list.append(escape(text[i:j]))
  98     return ''.join(list)
  99
 100 def emphasize(line):
 101     return re.sub(r'\*([a-zA-Z]+)\*', r'<I>\1</I>', line)
 102
 103 revparse_prog = None
 104
 105 def revparse(rev):
 106     global revparse_prog
 107     if not revparse_prog:
 108         revparse_prog = re.compile(r'^(\d{1,3})\.(\d{1,4})$')
 109     m = revparse_prog.match(rev)
 110     if not m:
 111         return None
 112     [major, minor] = map(int, m.group(1, 2))
 113     return major, minor
 114
 115 logon = 0
 116 def log(text):
 117     if logon:
 118         logfile = open("logfile", "a")
 119         logfile.write(text + "\n")
 120         logfile.close()
 121
 122 def load_cookies():
 123     if not os.environ.has_key('HTTP_COOKIE'):
 124         return {}
 125     raw = os.environ['HTTP_COOKIE']
 126     words = [s.strip() for s in raw.split(';')]
 127     cookies = {}
 128     for word in words:
 129         i = word.find('=')
 130         if i >= 0:
 131             key, value = word[:i], word[i+1:]
 132             cookies[key] = value
 133     return cookies
 134
 135 def load_my_cookie():
 136     cookies = load_cookies()
 137     try:
 138         value = cookies[COOKIE_NAME]
 139     except KeyError:
 140         return {}
 141     import urllib
 142     value = urllib.unquote(value)
 143     words = value.split('/')
 144     while len(words) < 3:
 145         words.append('')
 146     author = '/'.join(words[:-2])
 147     email = words[-2]
 148     password = words[-1]
 149     return {'author': author,
 150             'email': email,
 151             'password': password}
 152
 153 def send_my_cookie(ui):
 154     name = COOKIE_NAME
 155     value = "%s/%s/%s" % (ui.author, ui.email, ui.password)
 156     import urllib
 157     value = urllib.quote(value)
 158     then = now + COOKIE_LIFETIME
 159     gmt = time.gmtime(then)
 160     path = os.environ.get('SCRIPT_NAME', '/cgi-bin/')
 161     print "Set-Cookie: %s=%s; path=%s;" % (name, value, path),
 162     print time.strftime("expires=%a, %d-%b-%y %X GMT", gmt)
 163
 164 class MagicDict:
 165
 166     def __init__(self, d, quote):
 167         self.__d = d
 168         self.__quote = quote
 169
 170     def __getitem__(self, key):
 171         for d in self.__d:
 172             try:
 173                 value = d[key]
 174                 if value:
 175                     value = str(value)
 176                     if self.__quote:
 177                         value = escapeq(value)
 178                     return value
 179             except KeyError:
 180                 pass
 181         return ''
 182
 183 class UserInput:
 184
 185     def __init__(self):
 186         self.__form = cgi.FieldStorage()
 187         #log("\n\nbody: " + self.body)
 188
 189     def __getattr__(self, name):
 190         if name[0] == '_':
 191             raise AttributeError
 192         try:
 193             value = self.__form[name].value
 194         except (TypeError, KeyError):
 195             value = ''
 196         else:
 197             value = value.strip()
 198         setattr(self, name, value)
 199         return value
 200
 201     def __getitem__(self, key):
 202         return getattr(self, key)
 203
 204 class FaqEntry:
 205
 206     def __init__(self, fp, file, sec_num):
 207         self.file = file
 208         self.sec, self.num = sec_num
 209         if fp:
 210             import rfc822
 211             self.__headers = rfc822.Message(fp)
 212             self.body = fp.read().strip()
 213         else:
 214             self.__headers = {'title': "%d.%d. " % sec_num}
 215             self.body = ''
 216
 217     def __getattr__(self, name):
 218         if name[0] == '_':
 219             raise AttributeError
 220         key = '-'.join(name.split('_'))
 221         try:
 222             value = self.__headers[key]
 223         except KeyError:
 224             value = ''
 225         setattr(self, name, value)
 226         return value
 227
 228     def __getitem__(self, key):
 229         return getattr(self, key)
 230
 231     def load_version(self):
 232         command = interpolate(SH_RLOG_H, self)
 233         p = os.popen(command)
 234         version = ''
 235         while 1:
 236             line = p.readline()
 237             if not line:
 238                 break
 239             if line[:5] == 'head:':
 240                 version = line[5:].strip()
 241         p.close()
 242         self.version = version
 243
 244     def getmtime(self):
 245         if not self.last_changed_date:
 246             return 0
 247         try:
 248             return os.stat(self.file)[stat.ST_MTIME]
 249         except os.error:
 250             return 0
 251
 252     def emit_marks(self):
 253         mtime = self.getmtime()
 254         if mtime >= now - DT_VERY_RECENT:
 255             emit(MARK_VERY_RECENT, self)
 256         elif mtime >= now - DT_RECENT:
 257             emit(MARK_RECENT, self)
 258
 259     def show(self, edit=1):
 260         emit(ENTRY_HEADER1, self)
 261         self.emit_marks()
 262         emit(ENTRY_HEADER2, self)
 263         pre = 0
 264         raw = 0
 265         for line in self.body.split('\n'):
 266             # Allow the user to insert raw html into a FAQ answer
 267             # (Skip Montanaro, with changes by Guido)
 268             tag = line.rstrip().lower()
 269             if tag == '<html>':
 270                 raw = 1
 271                 continue
 272             if tag == '</html>':
 273                 raw = 0
 274                 continue
 275             if raw:
 276                 print line
 277                 continue
 278             if not line.strip():
 279                 if pre:
 280                     print '</PRE>'
 281                     pre = 0
 282                 else:
 283                     print '<P>'
 284             else:
 285                 if not line[0].isspace():
 286                     if pre:
 287                         print '</PRE>'
 288                         pre = 0
 289                 else:
 290                     if not pre:
 291                         print '<PRE>'
 292                         pre = 1
 293                 if '/' in line or '@' in line:
 294                     line = translate(line, pre)
 295                 elif '<' in line or '&' in line:
 296                     line = escape(line)
 297                 if not pre and '*' in line:
 298                     line = emphasize(line)
 299                 print line
 300         if pre:
 301             print '</PRE>'
 302             pre = 0
 303         if edit:
 304             print '<P>'
 305             emit(ENTRY_FOOTER, self)
 306             if self.last_changed_date:
 307                 emit(ENTRY_LOGINFO, self)
 308         print '<P>'
 309
 310 class FaqDir:
 311
 312     entryclass = FaqEntry
 313
 314     __okprog = re.compile(OKFILENAME)
 315
 316     def __init__(self, dir=os.curdir):
 317         self.__dir = dir
 318         self.__files = None
 319
 320     def __fill(self):
 321         if self.__files is not None:
 322             return
 323         self.__files = files = []
 324         okprog = self.__okprog
 325         for file in os.listdir(self.__dir):
 326             if self.__okprog.match(file):
 327                 files.append(file)
 328         files.sort()
 329
 330     def good(self, file):
 331         return self.__okprog.match(file)
 332
 333     def parse(self, file):
 334         m = self.good(file)
 335         if not m:
 336             return None
 337         sec, num = m.group(1, 2)
 338         return int(sec), int(num)
 339
 340     def list(self):
 341         # XXX Caller shouldn't modify result
 342         self.__fill()
 343         return self.__files
 344
 345     def open(self, file):
 346         sec_num = self.parse(file)
 347         if not sec_num:
 348             raise InvalidFile(file)
 349         try:
 350             fp = open(file)
 351         except IOError, msg:
 352             raise NoSuchFile(file, msg)
 353         try:
 354             return self.entryclass(fp, file, sec_num)
 355         finally:
 356             fp.close()
 357
 358     def show(self, file, edit=1):
 359         self.open(file).show(edit=edit)
 360
 361     def new(self, section):
 362         if not SECTION_TITLES.has_key(section):
 363             raise NoSuchSection(section)
 364         maxnum = 0
 365         for file in self.list():
 366             sec, num = self.parse(file)
 367             if sec == section:
 368                 maxnum = max(maxnum, num)
 369         sec_num = (section, maxnum+1)
 370         file = NEWFILENAME % sec_num
 371         return self.entryclass(None, file, sec_num)
 372
 373 class FaqWizard:
 374
 375     def __init__(self):
 376         self.ui = UserInput()
 377         self.dir = FaqDir()
 378
 379     def go(self):
 380         print 'Content-type: text/html'
 381         req = self.ui.req or 'home'
 382         mname = 'do_%s' % req
 383         try:
 384             meth = getattr(self, mname)
 385         except AttributeError:
 386             self.error("Bad request type %r." % (req,))
 387         else:
 388             try:
 389                 meth()
 390             except InvalidFile, exc:
 391                 self.error("Invalid entry file name %s" % exc.file)
 392             except NoSuchFile, exc:
 393                 self.error("No entry with file name %s" % exc.file)
 394             except NoSuchSection, exc:
 395                 self.error("No section number %s" % exc.section)
 396         self.epilogue()
 397
 398     def error(self, message, **kw):
 399         self.prologue(T_ERROR)
 400         emit(message, kw)
 401
 402     def prologue(self, title, entry=None, **kw):
 403         emit(PROLOGUE, entry, kwdict=kw, title=escape(title))
 404
 405     def epilogue(self):
 406         emit(EPILOGUE)
 407
 408     def do_home(self):
 409         self.prologue(T_HOME)
 410         emit(HOME)
 411
 412     def do_debug(self):
 413         self.prologue("FAQ Wizard Debugging")
 414         form = cgi.FieldStorage()
 415         cgi.print_form(form)
 416         cgi.print_environ(os.environ)
 417         cgi.print_directory()
 418         cgi.print_arguments()
 419
 420     def do_search(self):
 421         query = self.ui.query
 422         if not query:
 423             self.error("Empty query string!")
 424             return
 425         if self.ui.querytype == 'simple':
 426             query = re.escape(query)
 427             queries = [query]
 428         elif self.ui.querytype in ('anykeywords', 'allkeywords'):
 429             words = filter(None, re.split('\W+', query))
 430             if not words:
 431                 self.error("No keywords specified!")
 432                 return
 433             words = map(lambda w: r'\b%s\b' % w, words)
 434             if self.ui.querytype[:3] == 'any':
 435                 queries = ['|'.join(words)]
 436             else:
 437                 # Each of the individual queries must match
 438                 queries = words
 439         else:
 440             # Default to regular expression
 441             queries = [query]
 442         self.prologue(T_SEARCH)
 443         progs = []
 444         for query in queries:
 445             if self.ui.casefold == 'no':
 446                 p = re.compile(query)
 447             else:
 448                 p = re.compile(query, re.IGNORECASE)
 449             progs.append(p)
 450         hits = []
 451         for file in self.dir.list():
 452             try:
 453                 entry = self.dir.open(file)
 454             except FileError:
 455                 constants
 456             for p in progs:
 457                 if not p.search(entry.title) and not p.search(entry.body):
 458                     break
 459             else:
 460                 hits.append(file)
 461         if not hits:
 462             emit(NO_HITS, self.ui, count=0)
 463         elif len(hits) <= MAXHITS:
 464             if len(hits) == 1:
 465                 emit(ONE_HIT, count=1)
 466             else:
 467                 emit(FEW_HITS, count=len(hits))
 468             self.format_all(hits, headers=0)
 469         else:
 470             emit(MANY_HITS, count=len(hits))
 471             self.format_index(hits)
 472
 473     def do_all(self):
 474         self.prologue(T_ALL)
 475         files = self.dir.list()
 476         self.last_changed(files)
 477         self.format_index(files, localrefs=1)
 478         self.format_all(files)
 479
 480     def do_compat(self):
 481         files = self.dir.list()
 482         emit(COMPAT)
 483         self.last_changed(files)
 484         self.format_index(files, localrefs=1)
 485         self.format_all(files, edit=0)
 486         sys.exit(0)                     # XXX Hack to suppress epilogue
 487
 488     def last_changed(self, files):
 489         latest = 0
 490         for file in files:
 491             entry = self.dir.open(file)
 492             if entry:
 493                 mtime = mtime = entry.getmtime()
 494                 if mtime > latest:
 495                     latest = mtime
 496         print time.strftime(LAST_CHANGED, time.localtime(latest))
 497         emit(EXPLAIN_MARKS)
 498
 499     def format_all(self, files, edit=1, headers=1):
 500         sec = 0
 501         for file in files:
 502             try:
 503                 entry = self.dir.open(file)
 504             except NoSuchFile:
 505                 continue
 506             if headers and entry.sec != sec:
 507                 sec = entry.sec
 508                 try:
 509                     title = SECTION_TITLES[sec]
 510                 except KeyError:
 511                     title = "Untitled"
 512                 emit("\n<HR>\n<H1>%(sec)s. %(title)s</H1>\n",
 513                      sec=sec, title=title)
 514             entry.show(edit=edit)
 515
 516     def do_index(self):
 517         self.prologue(T_INDEX)
 518         files = self.dir.list()
 519         self.last_changed(files)
 520         self.format_index(files, add=1)
 521
 522     def format_index(self, files, add=0, localrefs=0):
 523         sec = 0
 524         for file in files:
 525             try:
 526                 entry = self.dir.open(file)
 527             except NoSuchFile:
 528                 continue
 529             if entry.sec != sec:
 530                 if sec:
 531                     if add:
 532                         emit(INDEX_ADDSECTION, sec=sec)
 533                     emit(INDEX_ENDSECTION, sec=sec)
 534                 sec = entry.sec
 535                 try:
 536                     title = SECTION_TITLES[sec]
 537                 except KeyError:
 538                     title = "Untitled"
 539                 emit(INDEX_SECTION, sec=sec, title=title)
 540             if localrefs:
 541                 emit(LOCAL_ENTRY, entry)
 542             else:
 543                 emit(INDEX_ENTRY, entry)
 544             entry.emit_marks()
 545         if sec:
 546             if add:
 547                 emit(INDEX_ADDSECTION, sec=sec)
 548             emit(INDEX_ENDSECTION, sec=sec)
 549
 550     def do_recent(self):
 551         if not self.ui.days:
 552             days = 1
 553         else:
 554             days = float(self.ui.days)
 555         try:
 556             cutoff = now - days * 24 * 3600
 557         except OverflowError:
 558             cutoff = 0
 559         list = []
 560         for file in self.dir.list():
 561             entry = self.dir.open(file)
 562             if not entry:
 563                 continue
 564             mtime = entry.getmtime()
 565             if mtime >= cutoff:
 566                 list.append((mtime, file))
 567         list.sort()
 568         list.reverse()
 569         self.prologue(T_RECENT)
 570         if days <= 1:
 571             period = "%.2g hours" % (days*24)
 572         else:
 573             period = "%.6g days" % days
 574         if not list:
 575             emit(NO_RECENT, period=period)
 576         elif len(list) == 1:
 577             emit(ONE_RECENT, period=period)
 578         else:
 579             emit(SOME_RECENT, period=period, count=len(list))
 580         self.format_all(map(lambda (mtime, file): file, list), headers=0)
 581         emit(TAIL_RECENT)
 582
 583     def do_roulette(self):
 584         import random
 585         files = self.dir.list()
 586         if not files:
 587             self.error("No entries.")
 588             return
 589         file = random.choice(files)
 590         self.prologue(T_ROULETTE)
 591         emit(ROULETTE)
 592         self.dir.show(file)
 593
 594     def do_help(self):
 595         self.prologue(T_HELP)
 596         emit(HELP)
 597
 598     def do_show(self):
 599         entry = self.dir.open(self.ui.file)
 600         self.prologue(T_SHOW)
 601         entry.show()
 602
 603     def do_add(self):
 604         self.prologue(T_ADD)
 605         emit(ADD_HEAD)
 606         sections = SECTION_TITLES.items()
 607         sections.sort()
 608         for section, title in sections:
 609             emit(ADD_SECTION, section=section, title=title)
 610         emit(ADD_TAIL)
 611
 612     def do_delete(self):
 613         self.prologue(T_DELETE)
 614         emit(DELETE)
 615
 616     def do_log(self):
 617         entry = self.dir.open(self.ui.file)
 618         self.prologue(T_LOG, entry)
 619         emit(LOG, entry)
 620         self.rlog(interpolate(SH_RLOG, entry), entry)
 621
 622     def rlog(self, command, entry=None):
 623         output = os.popen(command).read()
 624         sys.stdout.write('<PRE>')
 625         athead = 0
 626         lines = output.split('\n')
 627         while lines and not lines[-1]:
 628             del lines[-1]
 629         if lines:
 630             line = lines[-1]
 631             if line[:1] == '=' and len(line) >= 40 and \
 632                line == line[0]*len(line):
 633                 del lines[-1]
 634         headrev = None
 635         for line in lines:
 636             if entry and athead and line[:9] == 'revision ':
 637                 rev = line[9:].split()
 638                 mami = revparse(rev)
 639                 if not mami:
 640                     print line
 641                 else:
 642                     emit(REVISIONLINK, entry, rev=rev, line=line)
 643                     if mami[1] > 1:
 644                         prev = "%d.%d" % (mami[0], mami[1]-1)
 645                         emit(DIFFLINK, entry, prev=prev, rev=rev)
 646                     if headrev:
 647                         emit(DIFFLINK, entry, prev=rev, rev=headrev)
 648                     else:
 649                         headrev = rev
 650                     print
 651                 athead = 0
 652             else:
 653                 athead = 0
 654                 if line[:1] == '-' and len(line) >= 20 and \
 655                    line == len(line) * line[0]:
 656                     athead = 1
 657                     sys.stdout.write('<HR>')
 658                 else:
 659                     print line
 660         print '</PRE>'
 661
 662     def do_revision(self):
 663         entry = self.dir.open(self.ui.file)
 664         rev = self.ui.rev
 665         mami = revparse(rev)
 666         if not mami:
 667             self.error("Invalid revision number: %r." % (rev,))
 668         self.prologue(T_REVISION, entry)
 669         self.shell(interpolate(SH_REVISION, entry, rev=rev))
 670
 671     def do_diff(self):
 672         entry = self.dir.open(self.ui.file)
 673         prev = self.ui.prev
 674         rev = self.ui.rev
 675         mami = revparse(rev)
 676         if not mami:
 677             self.error("Invalid revision number: %r." % (rev,))
 678         if prev:
 679             if not revparse(prev):
 680                 self.error("Invalid previous revision number: %r." % (prev,))
 681         else:
 682             prev = '%d.%d' % (mami[0], mami[1])
 683         self.prologue(T_DIFF, entry)
 684         self.shell(interpolate(SH_RDIFF, entry, rev=rev, prev=prev))
 685
 686     def shell(self, command):
 687         output = os.popen(command).read()
 688         sys.stdout.write('<PRE>')
 689         print escape(output)
 690         print '</PRE>'
 691
 692     def do_new(self):
 693         entry = self.dir.new(section=int(self.ui.section))
 694         entry.version = '*new*'
 695         self.prologue(T_EDIT)
 696         emit(EDITHEAD)
 697         emit(EDITFORM1, entry, editversion=entry.version)
 698         emit(EDITFORM2, entry, load_my_cookie())
 699         emit(EDITFORM3)
 700         entry.show(edit=0)
 701
 702     def do_edit(self):
 703         entry = self.dir.open(self.ui.file)
 704         entry.load_version()
 705         self.prologue(T_EDIT)
 706         emit(EDITHEAD)
 707         emit(EDITFORM1, entry, editversion=entry.version)
 708         emit(EDITFORM2, entry, load_my_cookie())
 709         emit(EDITFORM3)
 710         entry.show(edit=0)
 711
 712     def do_review(self):
 713         send_my_cookie(self.ui)
 714         if self.ui.editversion == '*new*':
 715             sec, num = self.dir.parse(self.ui.file)
 716             entry = self.dir.new(section=sec)
 717             entry.version = "*new*"
 718             if entry.file != self.ui.file:
 719                 self.error("Commit version conflict!")
 720                 emit(NEWCONFLICT, self.ui, sec=sec, num=num)
 721                 return
 722         else:
 723             entry = self.dir.open(self.ui.file)
 724             entry.load_version()
 725         # Check that the FAQ entry number didn't change
 726         if self.ui.title.split()[:1] != entry.title.split()[:1]:
 727             self.error("Don't change the entry number please!")
 728             return
 729         # Check that the edited version is the current version
 730         if entry.version != self.ui.editversion:
 731             self.error("Commit version conflict!")
 732             emit(VERSIONCONFLICT, entry, self.ui)
 733             return
 734         commit_ok = ((not PASSWORD
 735                       or self.ui.password == PASSWORD)
 736                      and self.ui.author
 737                      and '@' in self.ui.email
 738                      and self.ui.log)
 739         if self.ui.commit:
 740             if not commit_ok:
 741                 self.cantcommit()
 742             else:
 743                 self.commit(entry)
 744             return
 745         self.prologue(T_REVIEW)
 746         emit(REVIEWHEAD)
 747         entry.body = self.ui.body
 748         entry.title = self.ui.title
 749         entry.show(edit=0)
 750         emit(EDITFORM1, self.ui, entry)
 751         if commit_ok:
 752             emit(COMMIT)
 753         else:
 754             emit(NOCOMMIT_HEAD)
 755             self.errordetail()
 756             emit(NOCOMMIT_TAIL)
 757         emit(EDITFORM2, self.ui, entry, load_my_cookie())
 758         emit(EDITFORM3)
 759
 760     def cantcommit(self):
 761         self.prologue(T_CANTCOMMIT)
 762         print CANTCOMMIT_HEAD
 763         self.errordetail()
 764         print CANTCOMMIT_TAIL
 765
 766     def errordetail(self):
 767         if PASSWORD and self.ui.password != PASSWORD:
 768             emit(NEED_PASSWD)
 769         if not self.ui.log:
 770             emit(NEED_LOG)
 771         if not self.ui.author:
 772             emit(NEED_AUTHOR)
 773         if not self.ui.email:
 774             emit(NEED_EMAIL)
 775
 776     def commit(self, entry):
 777         file = entry.file
 778         # Normalize line endings in body
 779         if '\r' in self.ui.body:
 780             self.ui.body = re.sub('\r\n?', '\n', self.ui.body)
 781         # Normalize whitespace in title
 782         self.ui.title = ' '.join(self.ui.title.split())
 783         # Check that there were any changes
 784         if self.ui.body == entry.body and self.ui.title == entry.title:
 785             self.error("You didn't make any changes!")
 786             return
 787
 788         # need to lock here because otherwise the file exists and is not writable (on NT)
 789         command = interpolate(SH_LOCK, file=file)
 790         p = os.popen(command)
 791         output = p.read()
 792
 793         try:
 794             os.unlink(file)
 795         except os.error:
 796             pass
 797         try:
 798             f = open(file, 'w')
 799         except IOError, why:
 800             self.error(CANTWRITE, file=file, why=why)
 801             return
 802         date = time.ctime(now)
 803         emit(FILEHEADER, self.ui, os.environ, date=date, _file=f, _quote=0)
 804         f.write('\n')
 805         f.write(self.ui.body)
 806         f.write('\n')
 807         f.close()
 808
 809         import tempfile
 810         tf = tempfile.NamedTemporaryFile()
 811         emit(LOGHEADER, self.ui, os.environ, date=date, _file=tf)
 812         tf.flush()
 813         tf.seek(0)
 814
 815         command = interpolate(SH_CHECKIN, file=file, tfn=tf.name)
 816         log("\n\n" + command)
 817         p = os.popen(command)
 818         output = p.read()
 819         sts = p.close()
 820         log("output: " + output)
 821         log("done: " + str(sts))
 822         log("TempFile:\n" + tf.read() + "end")
 823
 824         if not sts:
 825             self.prologue(T_COMMITTED)
 826             emit(COMMITTED)
 827         else:
 828             self.error(T_COMMITFAILED)
 829             emit(COMMITFAILED, sts=sts)
 830         print '<PRE>%s</PRE>' % escape(output)
 831
 832         try:
 833             os.unlink(tf.name)
 834         except os.error:
 835             pass
 836
 837         entry = self.dir.open(file)
 838         entry.show()
 839
 840 wiz = FaqWizard()
 841 wiz.go()