#!/usr/bin/env python

"""

Confluence XML dump conversion to a MoinMoin-compatible representation.

Copyright (C) 2012 Paul Boddie <paul@boddie.org.uk>

This software 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 software 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 library; see the file LICENCE.txt

If not, write to the Free Software Foundation, Inc.,

51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

"""

from os import listdir, mkdir, makedirs

from os.path import exists, extsep, join, splitext

from zipfile import ZipFile

from cStringIO import StringIO

import codecs

import xmlread

import parser

class ConfluenceHandler:

    "Handle content from a Confluence Wiki dump."

    def __init__(self, space, no_translate=False):

        self.content = {}

        self.elements = []

        self.space = space

        self.no_translate = no_translate

    def handle_object(self, name, elements, attributes, all_text, text):

        "Handle objects according to type."

        objecttype = attributes[-1]["class"]

        identifier = text.strip()

        content = self.content

        pages_dir = join(self.space, "pages")

        versions_dir = join(self.space, "versions")

        # Handle particular types.

        if objecttype in ("Page", "Comment", "BlogPost"):

            # Handle pages and revisions, adding revisions to the page manifest.

            # The original version is used as a unifying identifier for all the

            # different revisions (each of which being defined by a Page

            # element). Although "original" implies the first identifier used,

            # it actually appears to be the latest and will have the highest

            # version number.

            if content.has_key("originalVersion"):

                pageid = content["originalVersion"]

            else:

                pageid = identifier

            versionfile = join(versions_dir, identifier)

            # Note page metadata, not necessarily in the correct order.

            # For comments, the title will need to be rewritten, since they

            # should be defined in terms of their owner page.

            mkdirs(join(pages_dir, pageid))

            title = content["title"]

            if title:

                title = "%s/%s" % (self.space, title)

            append(join(pages_dir, pageid, "manifest"), "%s|AddRevision|%s|%s|%s|%s\n" % (

                content["version"],

                versionfile,

                title or content["version"], # comment titles will incorporate the version

                content["lastModifierName"],

                content["versionComment"]))

            # Write comments as subpages.

            if content.has_key("comments"):

                # Define a page directory for each comment, and write the page

                # title in a special file for later processing.

                for _comment, commentid in content["comments"]:

                    mkdirs(join(pages_dir, commentid))

                    append(join(pages_dir, commentid, "pagetitle"), title)

            # Some metadata is not particularly relevant. For example,

            # ancestors, children, parent are navigation-related.

            # Other metadata could be added to the page content itself.

            # For example, labelling could be converted to categories.

        # Handle revisions.

        elif objecttype == "BodyContent":

            body = content["body"]

            if not body:

                body = "## Empty page."

            if no_translate:

                fn = write

            else:

                fn = translate

            fn(join(versions_dir, content["content"]), body)

        self.content = {}

    def handle_property(self, name, elements, attributes, all_text, text):

        "Record properties in the current content dictionary."

        self.content[attributes[-1]["name"]] = text.strip()

    def handle_id(self, name, elements, attributes, all_text, text):

        "Promote identifiers to the parent element's text."

        all_text[-2].append(text)

    def handle_collection(self, name, elements, attributes, all_text, text):

        "Record collections in the current content dictionary."

        self.content[attributes[-1]["name"]] = self.elements

        self.elements = []

    def handle_element(self, name, elements, attributes, all_text, text):

        "Add elements to the current collection."

        self.elements.append((attributes[-1]["class"], text.strip()))

def mkdirs(name):

    "Make the directory with the given 'name' at any depth."

    try:

        makedirs(name)

    except OSError:

        pass

def append(filename, s):

    "Append to the file with the given 'filename' the string 's'."

    write(filename, s, True)

def write(filename, s, append=False):

    """

    Write to the file with the given 'filename' the string 's'. If the optional

    'append' parameter is set to a true value, 's' will be appended to the file.

    """

    f = codecs.open(filename, append and "a" or "w", encoding="utf-8")

    try:

        f.write(s)

    finally:

        f.close()

def read(filename):

    """

    Read from the file with the given 'filename', returning a string containing

    its contents.

    """

    f = codecs.open(filename, encoding="utf-8")

    try:

        return f.read()

    finally:

        f.close()

def translate(filename, body):

    """

    Write to the file with the given 'filename' a translation of the given

    'body'.

    """

    out = codecs.open(filename, "w", encoding="utf-8")

    try:

        parser.parse(body, out)

    finally:

        out.close()

def sort_manifest(filename, pagetitle, output=None):

    """

    Sort the manifest given in 'filename' according to revision. If a

    'pagetitle' file exists, the title column in the manifest will be augmented

    with the contents of that file. If 'output' is given, the manifest details

    will be appended to the file having that filename instead of being rewritten

    to the original manifest file.

    """

    if exists(pagetitle):

        title = read(pagetitle)

    else:

        title = None

    f = codecs.open(filename, "r", encoding="utf-8")

    try:

        lines = [x.split("|") for x in f.readlines()]

        lines.sort(cmp=lambda x, y: cmp(int(x[0]), int(y[0])))

        # Reconstruct the lines, optionally changing the titles.

        result = []

        for x in lines:

            if title is not None:

                x[3] = "%s/%s" % (title, x[3])

            result.append("|".join(x[1:]))

    finally:

        f.close()

    s = "".join(result)

    if output is None:

        write(filename, s)

    else:

        append(output, s)

if __name__ == "__main__":

    import sys

    try:

        filename = sys.argv[1]

        is_zipfile = splitext(filename)[-1] == extsep + "zip"

        space = sys.argv[2]

    except IndexError:

        print >>sys.stderr, "Please specify an XML file containing Wiki data and a workspace name."

        print >>sys.stderr, "For example: com_entities.xml COM"

        sys.exit(1)

    no_translate = "--no-translate" in sys.argv

    if exists(space):

        print >>sys.stderr, "Directory exists for space %s. Please choose another or remove its contents." % space

        sys.exit(1)

    package_zip = space + extsep + "zip"

    if exists(package_zip):

        print >>sys.stderr, "Page package exists. Please remove or rename it:", package_zip

        sys.exit(1)

    mkdir(space)

    mkdirs(join(space, "pages"))

    mkdirs(join(space, "versions"))

    p = xmlread.ConfigurableParser()

    handler = ConfluenceHandler(space, no_translate)

    p["object"] = handler.handle_object

    p["property"] = handler.handle_property

    p["id"] = handler.handle_id

    p["collection"] = handler.handle_collection

    p["element"] = handler.handle_element

    # Open the XML dump.

    f = open(filename)

    if is_zipfile:

        zf = ZipFile(f)

        ff = StringIO(zf.read("entities.xml"))

    else:

        ff = f

    # Parse the data.

    try:

        p.parse(ff)

    finally:

        f.close()

    # Tidy up the import manifests, sorting each of them by revision and

    # finalising them.

    pages_dir = join(space, "pages")

    output_manifest = join(space, "MOIN_PACKAGE")

    append(output_manifest, "MoinMoinPackage|1\n")

    for pageid in listdir(pages_dir):

        manifest = join(pages_dir, pageid, "manifest")

        pagetitle = join(pages_dir, pageid, "pagetitle")

        sort_manifest(manifest, pagetitle, output_manifest)

    # Write the page package.

    page_package = ZipFile(package_zip, "w")

    try:

        # Include the page revisions.

        versions_dir = join(space, "versions")

        for versionid in listdir(versions_dir):

            page_package.write(join(versions_dir, versionid))

        # Include only the top-level manifest.

        page_package.write(output_manifest, "MOIN_PACKAGE")

    finally:

        page_package.close()

# vim: tabstop=4 expandtab shiftwidth=4