def render(self, source_xml, content_type):
"""Render document using 4suite.
"""
#pubUrl = self.REQUEST['PUBLISHED'].absolute_url()
pubUrl = self.REQUEST['URL']
proc = Processor.Processor()
resolver = ZBaseUriResolver(self)
factory = InputSource.InputSourceFactory(resolver=resolver)
source = factory.fromString(self().encode(self.char_encoding), '/'.join(self.getPhysicalPath()))
proc.appendStylesheet(source)
if content_type in ['text/xml','text/html']:
writer = XmlWriter.XmlWriter(proc.outputParams,StringIO.StringIO())
else:
writer = StringWriter.StringWriter(proc.outputParams,
StringIO.StringIO())
# Apply the stylesheet to the XMLTemplate. The result is
# written to the output stream attribute of the writer so
# grab that and send it back to the caller.
proc.run(factory.fromString(source_xml),pubUrl,writer=writer)
return writer.getStream().getvalue()
def fromUri(self, uri, baseUri='', ownerDoc=None, stripElements=None):
"""
Creates a default InputSource from a URI (the uri argument).
The baseUri and ownerDoc arguments are ignored.
"""
# why complain if we're not using baseUri?
#if not baseUri:
# warnings.warn("InputSource created without a document URI",
# RuntimeWarning, 2)
src = InputSource.InputSource(None,
uri,
processIncludes=self.processIncludes,
stripElements=stripElements)
src = src.resolve(uri)
return self._parseMethod[0](src)
def get_factory(self):
system_catalogs = ['/etc/xml/catalog', '/usr/local/share/xml/catalog']
system_catalogs = [p for p in system_catalogs if os.path.exists(p)]
if system_catalogs:
xml_catalog_files = os.getenv("XML_CATALOG_FILES")
if xml_catalog_files:
xml_catalog_files += " " + " ".join(system_catalogs)
else:
xml_catalog_files = " ".join(system_catalogs)
os.environ["XML_CATALOG_FILES"] = xml_catalog_files
# The factory now takes into account the new XSML_CATALOG_FILES
factory = InputSource.InputSourceFactory(
catalog=Catalog.GetDefaultCatalog())
return factory
def fromStream(self, stream, refUri='', ownerDoc=None, stripElements=None):
"""
Creates a default InputSource from a python file-like object
(the stream argument). The document URI should be provided as
the refUri argument. This will be used in the resolution of
system IDs in the DTD and document type declaration, and will
be embedded in the Domlette nodes for use by the application,
such as for resolution of relative URI references in XSLT's
document(), xsl:import, and xsl:include, among others.
"""
if not refUri:
warnings.warn("InputSource created without a document URI",
RuntimeWarning, 2)
src = InputSource.InputSource(stream,
refUri,
processIncludes=self.processIncludes,
stripElements=stripElements)
return self._parseMethod[0](src)
def format(self, formatter):
""" Send the text. """
_ = self._
if not self.request.cfg.allow_xslt:
# use plain text parser if XSLT is not allowed
# can be activated in wikiconfig.py
from MoinMoin.parser.text import Parser as TextParser
self.request.write(
formatter.sysmsg(1) + formatter.rawHTML(
_('XSLT option disabled, please look at HelpOnConfiguration.',
wiki=True)) + formatter.sysmsg(0))
TextParser(self.raw, self.request).format(formatter)
return
try:
# try importing Ft from 4suite
# if import fails or its version is not 1.x, error msg
from Ft.Xml import __version__ as ft_version
assert ft_version.startswith('1.')
except (ImportError, AssertionError):
self.request.write(
self.request.formatter.sysmsg(1) + self.request.formatter.text(
_('XSLT processing is not available, please install 4suite 1.x.'
)) + self.request.formatter.sysmsg(0))
else:
from Ft.Lib import Uri
from Ft.Xml import InputSource
from Ft.Xml.Xslt.Processor import Processor
from Ft import FtException
msg = None
try:
# location of SchemeRegisteryResolver has changed since 1.0a4
if ft_version >= "1.0a4" or ft_version == "1.0" or (
"1.0.1" <= ft_version <= "1.0.9"):
# such version numbers suck!
import Ft.Lib.Resolvers # Do not remove! it looks unused, but breaks when removed!!!
class MoinResolver(Uri.SchemeRegistryResolver):
""" supports resolving self.base_uri for actual pages in MoinMoin """
def __init__(self, handlers, base_scheme):
Uri.SchemeRegistryResolver.__init__(self, handlers)
self.supportedSchemes.append(base_scheme)
# setting up vars for xslt Processor
out_file = StringIO.StringIO()
wiki_resolver = MoinResolver(handlers={
self.base_scheme:
self._resolve_page,
},
base_scheme=self.base_scheme)
input_factory = InputSource.InputSourceFactory(
resolver=wiki_resolver)
page_uri = self.base_uri + wikiutil.url_quote(
formatter.page.page_name)
# 4Suite needs an utf-8 encoded byte string instead of an unicode object
raw = self.raw.strip().encode('utf-8')
self.processor = Processor()
self.append_stylesheet() # hook, for extending this parser
self.processor.run(input_factory.fromString(raw, uri=page_uri),
outputStream=out_file)
# Convert utf-8 encoded byte string into unicode
result = out_file.getvalue().decode('utf-8')
result = self.parse_result(
result) # hook, for extending this parser
except FtException, msg:
etype = "XSLT"
except Uri.UriException, msg:
etype = "XSLT"
def GetMappingFactory(uriMapping):
return InputSource.InputSourceFactory(resolver=MappingResolver(uriMapping))
BASE_URI + 'STY2': style2,
BASE_URI + 'STY3': style3,
BASE_URI + 'STY4': style4,
}
class GenericInputSource(InputSource.InputSource):
def _openStream(self, uri, ignoreErrors=False, hint=None):
scheme = urlparse.urlparse(uri)[0]
#if scheme in ['', 'http', 'ftp', 'file', 'gopher']:
# raise uri
st = URIS[uri]
return cStringIO.StringIO(st)
InputSourceFactory = InputSource.InputSourceFactory(GenericInputSource)
DOC1_STY1_EXPECTED = """<?xml version="1.0" encoding="UTF-8"?>
STY1DOC1"""
DOC1_STY2_EXPECTED = """<?xml version="1.0" encoding="UTF-8"?>
STY2DOC1"""
DOC1_STY3_EXPECTED = """<?xml version="1.0" encoding="UTF-8"?>
STY3DOC1"""
DOC1_STY4_EXPECTED = """<?xml version="1.0" encoding="UTF-8"?>
STY4DOC2"""
def Test(tester):