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

    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