DjangoDocumentKoreanTranslation: wiki_formatter.py

# -*- coding: utf-8 -*-
"""
 Copyright 2005 Spike^ekipS <spikeekips@gmail.com>

    This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
"""

import sys, re

try :
    pagename = sys.argv[2]
except :
    pagename = ""

PAGE_URL = "DjangoDocumentKoreanTranslation"

RE_HEAD = re.compile("^==[=][=]*$")
RE_HEAD0 = re.compile("^\-\-[\-][\-]*$")
RE_HEAD1 = re.compile("^~~[~][~]*$")
RE_HEAD2 = re.compile("^\*\*(?P<strings>.*):\*\*$")
RE_LINK = re.compile("(?P<linkcode>!?`(?P<link>.*?)`_)")
RE_LINK_TARGET = re.compile("[ ]*\.\. _(?P<name>.*): (?P<target>.*)")
RE_MONOSPACE = re.compile("(?P<inlinecode>!?``(?P<inline>.*?)``)")
RE_DEFINITION = re.compile("[ ]*\.\..*:: (?P<title>.*)$")
RE_LIST = re.compile("^[ ][ ]*(?P<s>\*)")
RE_PREFIX_BLANK = re.compile("^[ ][ ]*")
RE_DASH = re.compile("[ ][ ]*\-\-[ ][ ]*")
RE_BOLD = re.compile("(?P<s_orig>!?\*\*(?P<s>.*?)\*\*)")
RE_LINK_INTERNAL = re.compile("(?P<inlinecode>!?_`(?P<inline>.*?)`)")
RE_IMAGE = re.compile("^.. image:: (?P<src>.*)")
RE_IMAGE_ALT = re.compile("^   :(?P<k>(alt|target)): (?P<v>.*)")

TEMPLATE_WIKI_LINK_INSIDE = "[wiki:%(target)s %(name)s]"
TEMPLATE_WIKI_LINK_OUTSIDE = "[%(target)s %(name)s]"

n = 0
lines = list()

links = list()
link_targets = dict()
found_code_block = False
found_list = None
found_list_newline = False
found_list_newline_inline = False
found_image = False
data_image = {"alt" : "", "src": "", "target": "", }

lines_code = list()
for i in file(sys.argv[1]) :

    n += 1

    # list
    # check is in list block
    if found_list is not None :
        if RE_LIST.findall(i) :
            found_list_newline = False
            found_list = i.index("*")
        else :
            if RE_PREFIX_BLANK.findall(i) and ( (found_list) == len(RE_PREFIX_BLANK.findall(i)[0]) or (found_list + 2) == len(RE_PREFIX_BLANK.findall(i)[0]) ) :
                if found_list_newline :
                    found_list_newline = False
                    found_list_newline_inline = len(RE_PREFIX_BLANK.findall(i)[0])
                    i = re.compile("^  ").sub("", i)
                elif found_list_newline_inline == len(RE_PREFIX_BLANK.findall(i)[0]) :
                    i = re.compile("^  ").sub("", i)

            elif i.strip() :
                found_list_newline = False
                found_list = None
            elif not i.strip() :
                found_list_newline = True

    if RE_LIST.findall(i) :
        found_list_newline = False
        found_list = i.index("*")

    if found_code_block :
        if i.strip() and not re.compile("^[ ][ ]*").findall(i) :
            #i = "}}}\n" + i
            lines.append("{{{\n%s\n}}}" % "".join(lines_code).strip())
            found_code_block = False
        else :
            lines_code.append(re.compile("^    ").sub("", i))
            continue

    if re.compile("::$").findall(i) :
        found_code_block = True
        lines_code = list()
        i = re.compile("::$").sub(":", i)

    if RE_MONOSPACE.findall(i) :
        for j in RE_MONOSPACE.finditer(i) :
            inline = j.groupdict().get("inline")
            if inline.endswith("}") and inline.startswith("{") :
                inline = " %s " % inline

            i = i.replace(j.groupdict().get("inlinecode"), "{{{%s}}}" % inline)


    if RE_HEAD.findall(i) :
        if len(lines) > 0 :
            lines[-1] = "= %s =" % lines[-1]
        continue

    if RE_HEAD0.findall(i) :
        if len(lines) > 1 :
            lines[-1] = "== %s ==" % lines[-1]
        continue

    if RE_HEAD1.findall(i) :
        if len(lines) > 1 :
            lines[-1] = "=== %s ===" % lines[-1]
        continue

    if found_image and RE_IMAGE_ALT.findall(i) :
        a = RE_IMAGE_ALT.search(i).groupdict()
        data_image.update({a["k"]: a["v"].replace("\"", "'")})
        continue
    elif RE_IMAGE.findall(i) :
        found_image = True
        data_image = {"alt" : "", "src": "", "target": "", }
        data_image.update(RE_IMAGE.search(i).groupdict())
        continue

    if RE_DEFINITION.findall(i) :
        i = " %s::" % RE_DEFINITION.search(i).groupdict().get("title")

    if RE_HEAD2.findall(i) :
        i = "'''%s''':" % RE_HEAD2.search(i).groupdict()["strings"]

    if RE_LINK_TARGET.findall(i) :
        name = RE_LINK_TARGET.search(i).groupdict().get("name")
        target = RE_LINK_TARGET.search(i).groupdict().get("target")
        link_targets[name] = target
        continue

    # wiki dash
    if RE_DASH.findall(i) :
        i = RE_DASH.sub(" - ", i)

    if RE_BOLD.findall(i) :
        for j in RE_BOLD.finditer(i) :
            i = i.replace(
                j.groupdict().get("s_orig"),
                "'''%s'''" % j.groupdict().get("s")
            )

    if RE_LINK_INTERNAL.findall(i) :
        for j in RE_LINK_INTERNAL.finditer(i) :
            i = i.replace(
                j.groupdict().get("inlinecode"),
                "[wiki: %s/%s#%s %s]" % (
                    PAGE_URL,
                    pagename,
                    j.groupdict().get("inline"),
                    j.groupdict().get("inline")
                ),
            )

    if found_image and not i.strip():
        found_image = False
        i = """{{{
#!html
<a target=\"%(target)s\" href=\"%(target)s\"><img src=\"%(src)s\" alt=\"%(alt)s\" /></a>
}}}
""" % data_image

    lines.append(i.rstrip())

    if RE_LINK.findall(i) :
        for j in RE_LINK.finditer(i) :
            links.append((j.groupdict(), len(lines) - 1, ))

# create wiki link to target
for i in links :
    name = i[0].get("link")
    name_orig = i[0].get("linkcode")
    n = i[1]
    if link_targets.has_key(name) :
        target = link_targets[name]

        if target.startswith("http://") :
            __template = TEMPLATE_WIKI_LINK_OUTSIDE
        else :
            __template = TEMPLATE_WIKI_LINK_INSIDE

        if target.startswith("../") :
            target = "%s/%s" % (PAGE_URL, target.replace("../", ""), )

        lines[n] = lines[n].replace(
            name_orig,
            __template % {"name" : name, "target": target}
        )

if found_code_block :
    lines.append("}}}")

print "[[PageOutline]]\n"
print "[wiki:%s ìž¥ê³  도움말 페읎지로 가Ʞ]\n\n" % PAGE_URL

for i in lines :
    print i


"""
Description
-----------


ChangeLog
---------


Usage
-----


"""

__author__ =  "Spike^ekipS <spikeekips@gmail.com>"
__version__=  "0.1"
__nonsense__ = ""