#!/usr/bin/env python

"A WebStack application for a PEP 241 repository."

import WebStack.Generic

import XSLForms.Fields

import XSLForms.Output

import XSLOutput

import libxml2dom

import os

def add_elements(positions, element_name, element_parent_name=None):

    if not positions:

        return

    for position in positions:

        if element_parent_name:

            parent_elements = position.xpath(element_parent_name)

            if not parent_elements:

                parent_element = position.ownerDocument.createElementNS(None, element_parent_name)

                position.appendChild(parent_element)

            else:

                parent_element = parent_elements[0]

        else:

            parent_element = position

        parent_element.appendChild(position.ownerDocument.createElementNS(None, element_name))

def remove_elements(positions):

    if not positions:

        return

    for position in positions:

        position.parentNode.removeChild(position)

class PEP241Resource:

    "A resource providing repository browsing."

    resource_dir = os.path.join(os.path.split(__file__)[0], "Resources")

    encoding = "utf-8"

    def respond(self, trans):

        # Produce stylesheet.

        if trans.get_path_info().split("/")[-1] == "styles.css":

            trans.set_content_type(WebStack.Generic.ContentType("text/css", self.encoding))

            out = trans.get_response_stream()

            f = open(os.path.join(self.resource_dir, "styles.css"), "rb")

            out.write(f.read())

            f.close()

            raise WebStack.Generic.EndOfResponse

        # Handle other requests.

        global XSLForms # NOTE: Strangely required to avoid UnboundLocalError!

        method = trans.get_request_method()

        # Only obtain field information according to the stated method.

        if method == "GET":

            fields = XSLForms.Fields.Fields(encoding="iso-8859-1", values_are_lists=1)

            parameters = trans.get_fields_from_path()

            documents = fields.make_documents(parameters.items())

        elif method == "POST":

            fields = XSLForms.Fields.Fields(encoding=self.encoding, values_are_lists=1)

            parameters = trans.get_fields_from_body(self.encoding)

            documents = fields.make_documents(parameters.items())

        else:

            trans.set_response_code(405)

            raise WebStack.Generic.EndOfResponse

        # Ensure the presence of a document.

        if documents.has_key("package"):

            package = documents["package"]

        else:

            package = fields.new_instance("package")

        # Add and remove elements according to the selectors found.

        selectors = fields.get_selectors(parameters.items(), documents)

        add_elements(selectors.get("add_platform"), "platform", "platforms")

        remove_elements(selectors.get("remove_platform"))

        add_elements(selectors.get("add_supported_platform"), "supported-platform", "supported-platforms")

        remove_elements(selectors.get("remove_supported_platform"))

        add_elements(selectors.get("add_keyword"), "keyword", "keywords")

        remove_elements(selectors.get("remove_keyword"))

        add_elements(selectors.get("add_author"), "author", "authors")

        remove_elements(selectors.get("remove_author"))

        add_elements(selectors.get("add_dependency"), "dependency", "dependencies")

        remove_elements(selectors.get("remove_dependency"))

        # Send a response according to certain parameters.

        # When exported, an XML version of the data is returned.

        if parameters.has_key("export"):

            trans.set_content_type(WebStack.Generic.ContentType("text/xml", self.encoding))

            libxml2dom.toStream(package, trans.get_response_stream(), trans.get_response_stream_encoding())

        # When not exported, the data is transformed to produce a normal Web

        # page.

        else:

            # Transform, adding enumerations/ranges.

            categories_xsl = os.path.join(self.resource_dir, "pep241_categories.xsl")

            categories_xml = os.path.join(self.resource_dir, "pep241_categories.xml")

            proc = XSLOutput.Processor([categories_xsl], {"categories" : categories_xml})

            package = proc.get_result(package)

            # Start the response.

            trans.set_content_type(WebStack.Generic.ContentType("application/xhtml+xml", self.encoding))

            # Ensure that an output stylesheet exists.

            trans_xsl = os.path.join(self.resource_dir, "pep241_output.xsl")

            template_xml = os.path.join(self.resource_dir, "pep241_template.xhtml")

            if not os.path.exists(trans_xsl) or \

                os.path.getmtime(trans_xsl) < os.path.getmtime(template_xml):

                import XSLForms.Prepare

                template_xml = os.path.join(self.resource_dir, "pep241_template.xhtml")

                XSLForms.Prepare.make_stylesheet(template_xml, trans_xsl)

            # Complete the response.

            proc = XSLOutput.Processor([trans_xsl])

            proc.send_output(trans.get_response_stream(), trans.get_response_stream_encoding(),

                package)

# vim: tabstop=4 expandtab shiftwidth=4