"""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('<', '&lt;')
   s = s.replace('>', '&gt;')
   return s

def escapeq(s):
   s = escape(s)
   s = s.replace('"', '&quot;')
   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()

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.