portal_transforms import/export try 2

from persistent.mapping import PersistentMapping
from Products.CMFCore.exportimport.content import importSiteStructure as \
     orig_importSiteStructure
from Products.CMFCore.utils import getToolByName
from Products.GenericSetup.utils import XMLAdapterBase
from Products.GenericSetup.utils import PropertyManagerHelpers
from Products.GenericSetup.utils import exportObjects
from Products.GenericSetup.utils import importObjects
from Products.MimetypesRegistry.common import MimeTypeException
from Products.PortalTransforms.Transform import Transform
from Products.PortalTransforms.chain import TransformsChain


# Support for declarative export / import of the 'portal_transforms' tool.
#
# XXX: The following code should be in Products.PortalTransforms.  See
#      https://dev.plone.org/ticket/12785
#
# Credit to Tres Seaver @tseaver
class PortalTransformsToolXMLAdapter(XMLAdapterBase, PropertyManagerHelpers):
    """XML im- and exporter for PortalTransforms tool.

    <object name="portal_transforms" meta_type="Portal Transforms Tool">
     <property name="xxx">SIMPLE VALUE</property>
     <property name="yyy">
      <element value="SIMPLE VALUE">
      ...
     </property>
     ...
     <transform name="abc" module="foo.bar.doBaz"/>
     ...
     <chain name="pqr" transforms="abc def ghi"/>
     ...
     <mimetype input="foo/bar">
      <target output="baz/bam" name="abc"/>
      ...
     </mimetype>
     ...
     <policy output="baz/bam" transforms="def ghi"/>
     ...
    </object>
    """
    _LOGGER_ID = 'PortalTransforms.tool'

    _PYTHON_CODE_ATTRS = ['CLOSE_COMMENT',
                          'CLOSE_ERRORTOKEN',
                          'CLOSE_KEYWORD',
                          'CLOSE_NAME',
                          'CLOSE_NUMBER',
                          'CLOSE_OP',
                          'CLOSE_STRING',
                          'CLOSE_TEXT',
                          'OPEN_COMMENT',
                          'OPEN_ERRORTOKEN',
                          'OPEN_KEYWORD',
                          'OPEN_NAME',
                          'OPEN_NUMBER',
                          'OPEN_OP',
                          'OPEN_STRING',
                          'OPEN_TEXT',
                         ]

    def _extractTransforms(self):
        fragment = self._doc.createDocumentFragment()
        for key, value in sorted(self.context.objectItems('Transform')):
            node = self._doc.createElement('transform')
            node.setAttribute('name', key)
            node.setAttribute('module', value.module)
            fragment.appendChild(node)
            c_nodes = []

            # generic
            for input_mt in value._config.get('inputs', ()):
                c_nodes.append(
                    ('input', [('mimetype', input_mt)]))

            output_mt = value._config.get('output')
            if output_mt is not None:
                c_nodes.append(
                    ('output', [('mimetype', output_mt)]))

            # html_to_web_intelligent_plain_text and
            # web_intelligent_plain_text_to_html
            tab_width = value._config.get('tab_width')
            if tab_width is not None:
                c_nodes.append(
                    ('tab_width', [('value', str(tab_width))]))

            # rest_to_html
            report_level = value._config.get('report_level')
            if report_level is not None:
                c_nodes.append(
                    ('report_level', [('value', str(report_level))]))

            init_hdr_level = value._config.get('initial_header_level')
            if init_hdr_level is not None:
                c_nodes.append(
                    ('initial_header_level', [('value', str(init_hdr_level))]))

            # safe_html
            disable_transform = value._config.get('disable_transform')
            if disable_transform is not None:
                c_nodes.append(
                    ('disable_transform', [('value', str(disable_transform))]))

            remove_javascript = value._config.get('remove_javascript')
            if remove_javascript is not None:
                c_nodes.append(
                    ('remove_javascript', [('value', str(remove_javascript))]))

            class_blacklist = sorted(value._config.get('class_blacklist', ()))
            for klass in class_blacklist:
                c_nodes.append(
                    ('class_blacklist', [('class', klass)]))

            style_whitelist = sorted(value._config.get('style_whitelist', ()))
            for style in style_whitelist:
                c_nodes.append(
                    ('style_whitelist', [('style', style)]))

            stripped_attributes = sorted(
                                value._config.get('stripped_attributes', ()))
            for attr in stripped_attributes:
                c_nodes.append(
                    ('stripped', [('attr', attr)]))

            stripped_combo = value._config.get('stripped_combinations', {})
            for combo, attrs in sorted(stripped_combo.items()):
                c_nodes.append(
                    ('stripped', [('combo', combo), ('attrs', attrs)]))

            nasty = value._config.get('nasty_tags', {})
            for key, is_long in sorted(nasty.items()):
                c_nodes.append(
                    ('nasty_tag', [('tag', key),
                                   ('long', str(is_long))]))

            valid = value._config.get('valid_tags', {})
            for key, is_long in sorted(valid.items()):
                c_nodes.append(
                    ('valid_tag', [('tag', key),
                                   ('long', str(is_long))]))

            for c_key in self._PYTHON_CODE_ATTRS:
                c_value = value._config.get(c_key)
                if c_value is not None:
                    c_nodes.append((c_key, [('value', c_value)]))

            for typ, attrs in c_nodes:
                cfg = self._doc.createElement(typ)
                for k, v in attrs:
                    cfg.setAttribute(k, v)
                node.appendChild(cfg)

        return fragment

    def _extractChains(self):
        fragment = self._doc.createDocumentFragment()
        for key, value in sorted(self.context.objectItems('TransformsChain')):
            node = self._doc.createElement('chain')
            node.setAttribute('name', key)
            node.setAttribute('transforms', ' '.join(value._object_ids))
            fragment.appendChild(node)
        return fragment

    def _extractMTMap(self):
        fragment = self._doc.createDocumentFragment()
        for input_mt, segments in sorted(self.context._mtmap.items()):
            node = self._doc.createElement('mimetype')
            node.setAttribute('input', input_mt)
            for output_mt, transforms in segments.items():
                sub = self._doc.createElement('target')
                sub.setAttribute('output', output_mt)
                t_ids = [x.id for x in transforms]
                sub.setAttribute('transforms', ' '.join(t_ids))
                node.appendChild(sub)
            fragment.appendChild(node)
        return fragment

    def _extractPolicies(self):
        fragment = self._doc.createDocumentFragment()
        for output_mt, required in sorted(self.context.listPolicies()):
            node = self._doc.createElement('policy')
            node.setAttribute('output', output_mt)
            node.setAttribute('requirement', ' '.join(required))
            fragment.appendChild(node)
        return fragment

    def _exportNode(self):
        """Export the object as a DOM node.
        """
        node = self._getObjectNode('object')
        node.appendChild(self._extractProperties())
        node.appendChild(self._extractTransforms())
        node.appendChild(self._extractChains())
        node.appendChild(self._extractMTMap())
        node.appendChild(self._extractPolicies())

        self._logger.info('Tool exported.')
        return node



    def _initTransforms(self, node):
        for child in node.childNodes:
            if child.nodeName == 'transform':
                name = child.getAttribute('name')
                module = child.getAttribute('module')
                transform = Transform(name, module)
                cfg = transform._config
                cleared = {}
                for grand in child.childNodes:
                    gga = getattr(grand, 'getAttribute', None)
                    if gga is None:
                        continue
                    if grand.nodeName == 'input':
                        inputs = cfg.setdefault('inputs', [])
                        if 'inputs' not in cleared:
                            inputs[:] = []
                            cleared['inputs'] = 1
                        inputs.append(gga('mimetype'))
                    if grand.nodeName == 'output':
                        cfg['output'] = gga('mimetype')
                    if grand.nodeName == 'tab_width':
                        cfg['tab_width'] = int(gga('value'))
                    if grand.nodeName == 'report_level':
                        cfg['report_level'] = int(gga('value'))
                    if grand.nodeName == 'initial_header_level':
                        cfg['initial_header_level'] = int(gga('value'))
                    if grand.nodeName == 'disable_transform':
                        cfg['disable_transform'] = int(gga('value'))
                    if grand.nodeName == 'remove_javascript':
                        cfg['remove_javascript'] = int(gga('value'))
                    if grand.nodeName == 'class_blacklist':
                        blist = cfg.setdefault('class_blacklist', [])
                        if 'class_blacklist' not in cleared:
                            blist[:] = []
                            cleared['class_blacklist'] = 1
                        blist.append(gga('class'))
                    if grand.nodeName == 'style_whitelist':
                        wlist = cfg.setdefault('style_whitelist', [])
                        if 'style_whitelist' not in cleared:
                            wlist[:] = []
                            cleared['style_whitelist'] = 1
                        wlist.append(gga('style'))
                    if grand.nodeName == 'stripped':
                        attr = gga('attr')
                        if attr is not None:
                            slist = cfg.setdefault('stripped_attributes', [])
                            if 'stripped_attributes' not in cleared:
                                slist[:] = []
                                cleared['stripped_attributes'] = 1
                            slist.append(attr)
                        else:
                            sdict = cfg.setdefault('stripped_combinations', {})
                            if 'stripped_combinations' not in cleared:
                                sdict.clear()
                                cleared['stripped_combinations'] = 1
                            combo = gga('combo')
                            attrs = gga('attrs')
                            sdict[combo] = attrs
                    if grand.nodeName == 'nasty_tag':
                        ndict = cfg.setdefault('nasty_tags', {})
                        if 'nasty_tags' not in cleared:
                            ndict.clear()
                            cleared['nasty_tags'] = 1
                        tag = gga('tag')
                        is_long = int(gga('long'))
                        ndict[tag] = is_long
                    if grand.nodeName == 'valid_tag':
                        vdict = cfg.setdefault('valid_tags', {})
                        if 'valid_tags' not in cleared:
                            vdict.clear()
                            cleared['valid_tags'] = 1
                        tag = gga('tag')
                        is_long = int(gga('long'))
                        vdict[tag] = is_long
                    for aname in self._PYTHON_CODE_ATTRS:
                        if grand.nodeName == aname:
                            cfg[aname] = gga('value')
                self.context._setObject(str(name), transform)
                try:
                    self.context._mapTransform(transform)
                except MimeTypeException:
                    # don't choke on broken transforms
                    pass

    def _initChains(self, node):
        for child in node.childNodes:
            if child.nodeName == 'chain':
                name = child.getAttribute('name')
                description = '' # should be in XML
                transforms = child.getAttribute('transforms').split()
                chain = TransformsChain(id, description, transforms)
                self.context._setObject(id, chain)
                self.context._mapTransform(chain)

    def _initMTMap(self, node):
        # This should be handled by the '_mapTransform' call above.
        pass

    def _initPolicies(self, node):
        for child in node.childNodes:
            if child.nodeName == 'policy':
                output = child.getAttribute('output')
                transforms = child.getAttribute('transforms').split()
                self.context.manage_addPolicy(output, transforms)

    def _importNode(self, node):
        """Import the object from the DOM node.
        """
        if self.environ.shouldPurge():
            ids = self.context.objectIds()
            for id in ids:
                self.context._delOb(id)
            # suppress 'manage_beforeDelete' crap
            self.context._objects = ()
            self.context._mtmap = PersistentMapping()
            self.context._policies = PersistentMapping()
            self._purgeProperties()

        self._initProperties(node)
        self._initTransforms(node)
        self._initChains(node)
        self._initPolicies(node)
        self._initMTMap(node)

        self._logger.info('Tool imported.')

def importPortalTransformsTool(context):
    """Import PortalTransforms tool.
    """
    site = context.getSite()
    tool = getToolByName(site, 'portal_transforms')
    importObjects(tool, '', context)

def exportPortalTransformsTool(context):
    """Export PortalTransforms tool.
    """
    site = context.getSite()
    tool = getToolByName(site, 'portal_transforms', None)
    if tool is None:
        return
    exportObjects(tool, '', context)