RhodeCode

# used by concat_line(line)

concatsplit_rex = re.compile('\s*#\s*')

# split on {, }, or " in verify_out_of_braces

delimiter_rex = re.compile('([{}"])',re.I)

field_rex = re.compile('\s*(\w*)\s*=\s*(.*)')

data_rex = re.compile('\s*(\w*)\s*=\s*([^,]*),?')

url_rex = re.compile('\\\url\{([^}]*)\}')

#

# return the string parameter without braces

#

def transformurls(str):

    return url_rex.sub(r'<a href="\1">\1</a>', str)

#

# return the string parameter without braces

#

def removebraces(str):

    return rembraces_rex.sub('', str)

        # encode character entities

        line = string.replace(line, '&', '&')

        line = string.replace(line, '<', '&lt;')

        line = string.replace(line, '>', '>')

        # start entry: publication type (store for later use)

        if pubtype_rex.match(line):

        # want @<alphanumeric chars><spaces>{<spaces><any chars>,

            entrycont = {}

            entry = []

            entrytype = pubtype_rex.sub('\g<1>',line)

            entrytype = string.lower(entrytype)

        # end entry if just a }

        elif endtype_rex.match(line):

            # generate doxygen code for the entry

            # enty type related formattings

            if entrytype in ('book', 'inbook'):

                entrycont['title'] = '<em>' + entrycont['title'] + '</em>'

                if not entrycont.has_key('author'):

                    entrycont['author'] = entrycont['editor']

                    entrycont['author']['text'] += ', editors'

            elif entrytype == 'article':

            else:

                bibkey = 'x'

            if entrycont.has_key('year'):

                sortkey += entrycont['year']

                bibkey += entrycont['year'][-2:]

            if entrycont.has_key('title'):

                sortkey += entrycont['title']

            if entrycont.has_key('key'):

                sortkey = entrycont['key'] + sortkey

                bibkey = entrycont['key']

            entry.insert(0, sortkey)

            entry.insert(1, bibkey)

            # add the entry to the file contents

            filecont.append(entry)

        else:

            # field, publication info

            field = ''

            data = ''

            # field = {data} entries

            if bracedata_rex.match(line):

                field = bracefield_rex.sub('\g<1>', line)

        if not keytable.has_key(bibkey):

            keytable[bibkey] = 1

        else:

            keytable[bibkey] += 1

    for bibkey in keytable.keys():

        counttable[bibkey] = 0

    # generate output

    for entry in filecont:

        # generate output key form the bibtex key

        bibkey = entry[1]

        if keytable[bibkey] == 1:

            outkey = bibkey

        else:

            outkey = bibkey + chr(97 + counttable[bibkey])

        counttable[bibkey] += 1

        # append the entry code to the output

            file.append(line)

        file.append('')

    return file

#

# return 1 iff abbr is in line but not inside braces or quotes

# assumes that abbr appears only once on the line (out of braces and quotes)

#

def verify_out_of_braces(line, abbr):

    phrase_split = delimiter_rex.split(line)

def filehandler(filepath):

    try:

        fd = open(filepath, 'r')

        filecont_source = fd.readlines()

        fd.close()

    except:

        print 'Could not open file:', filepath

    washeddata = bibtexwasher(filecont_source)

    outdata = bibtexdecoder(washeddata)

    print '/**'

    print '\page references References'

    print

    for line in outdata:

        print line

    print '*/'

# main program

def main():

    import sys

    if sys.argv[1:]:

        filepath = sys.argv[1]

    else:

        print "No input file"

        sys.exit()