def _compile_xsl(XSLT_FILE, XSLT_COMPILED_FILE):
    """
        compiling docbook stylesheet

        reference: http://155.210.85.193:8010/ccia/nodes/2005-03-18/compileXslt?xslt=/akara/akara.xslt
    """
    from Ft.Xml.Xslt.Processor import Processor
    from Ft.Xml.Xslt import Stylesheet
    from Ft.Xml import InputSource
    from Ft.Lib import Uri

    # New docbook processor
    db_processor = Processor()

    # Docbook Stylesheet
    my_sheet_uri = Uri.OsPathToUri(XSLT_FILE, 1)
    sty_isrc = InputSource.DefaultFactory.fromUri(my_sheet_uri)

    # Append Stylesheet
    db_processor.appendStylesheet(sty_isrc)

    # Pickled stylesheet will be self.abs_db_compiled_xsl file
    db_root = db_processor.stylesheet.root
    fw = file(XSLT_COMPILED_FILE, 'wb')
    cPickle.dump(db_root, fw) # , protocol=2)
    fw.close()
    def __init__(self, stylesheetAltUris=None,
                 documentReader=None, implementation=None,
                 stylesheetIncPaths=None):
      """ Optional constructor arguments are:
 
     stylesheetAltUris: a list of alternative base URIs to use when
      resolving relative hrefs in xsl:import/xsl:include instructions.
       These URIs are only tried when the standard XSLT behavior of
       using the base URI of the xsl:import/include element itself
       fails to result in retrieval of a document.
 
   documentReader: an object that will be used to parse XML source
       documents (not stylesheets). It defaults to
      Ft.Xml.Domlette.NonvalidatingReader, but it can be any object
       that has a parse() method that returns a DOM or Domlette tree.
 
     implementation: a DOM implementation instance that will be used
       by the processor to create new source tree nodes, such as when
       generating result tree fragments or duplicating the source tree
       when runNode(node, preserveSrc=1) is called. Defaults to
       Ft.Xml.Domlette.implementation. Needs to have a
           createRootNode() method.
      """
                 
      # Calling superclass constructor
      Processor.__init__(self, stylesheetAltUris=stylesheetAltUris, 
                         documentReader=documentReader, implementation=implementation,
                         stylesheetIncPaths=stylesheetIncPaths)
      Observer.__init__(self)
      self.first_pass = True 
      self.changed_nodes = [] #the list of the changed nodes.
      self.last_result = None  #the last dom tree generated.
      self.currentRule = None  #a hierachy of reevaluation rules
      self.our_writer = Dom.CustomDomWriter() #the dom writer
Exemplo n.º 3
0
def _compile_xsl(XSLT_FILE, XSLT_COMPILED_FILE):
    """
        compiling docbook stylesheet

        reference: http://155.210.85.193:8010/ccia/nodes/2005-03-18/compileXslt?xslt=/akara/akara.xslt
    """
    from Ft.Xml.Xslt.Processor import Processor
    from Ft.Xml.Xslt import Stylesheet
    from Ft.Xml import InputSource
    from Ft.Lib import Uri

    # New docbook processor
    db_processor = Processor()

    # Docbook Stylesheet
    my_sheet_uri = Uri.OsPathToUri(XSLT_FILE, 1)
    sty_isrc = InputSource.DefaultFactory.fromUri(my_sheet_uri)

    # Append Stylesheet
    db_processor.appendStylesheet(sty_isrc)

    # Pickled stylesheet will be self.abs_db_compiled_xsl file
    db_root = db_processor.stylesheet.root
    fw = file(XSLT_COMPILED_FILE, 'wb')
    cPickle.dump(db_root, fw)  # , protocol=2)
    fw.close()
Exemplo n.º 4
0
def processDocumentNode( c ):
    '''this executes the stylesheet node against the current node'''
    try:
        if not styleNodeSelected( c ): return
        proc = Processor()
        stylenode = stylenodes[ c ]
        pos = c.p
        c.selectPosition( stylenode )
        sIO = getString( c )
        mdom1 = minidom.parseString( sIO )
        sIO = str( mdom1.toxml() )
        hstring = str( stylenode.h )
        if hstring == "": hstring = "no headline"
        stylesource = InputSource.DefaultFactory.fromString( sIO, uri = hstring)
        proc.appendStylesheet( stylesource )
        c.selectPosition( pos )
        xmlnode = pos.v
        xIO = getString( c )
        mdom2 = minidom.parseString( xIO )
        xIO = str( mdom2.toxml())
        xhead = str( xmlnode.headString )
        if xhead == "": xhead = "no headline"
        xmlsource = InputSource.DefaultFactory.fromString( xIO, uri = xhead )
        result = proc.run( xmlsource )
        nhline = "xsl:transform of " + str( xmlnode.headString )
        p2 = pos.insertAfter() # tnode )
        p2.setBodyString(result)
        p2.setHeadString(nhline)
        c.redraw()

    except Exception as x:
        g.es( 'exception ' + str( x ))
    c.redraw()
Exemplo n.º 5
0
def processDocumentNode( c ):
    '''this executes the stylesheet node against the current node'''
    try:
        if not styleNodeSelected( c ): return
        proc = Processor()
        stylenode = stylenodes[ c ]
        pos = c.p
        c.selectPosition( stylenode )
        sIO = getString( c )
        mdom1 = minidom.parseString( sIO )
        sIO = str( mdom1.toxml() )
        hstring = str( stylenode.h )
        if hstring == "": hstring = "no headline"
        stylesource = InputSource.DefaultFactory.fromString( sIO, uri = hstring)
        proc.appendStylesheet( stylesource )
        c.selectPosition( pos )
        xmlnode = pos.v
        xIO = getString( c )
        mdom2 = minidom.parseString( xIO )
        xIO = str( mdom2.toxml())
        xhead = str( xmlnode.headString )
        if xhead == "": xhead = "no headline"
        xmlsource = InputSource.DefaultFactory.fromString( xIO, uri = xhead )
        result = proc.run( xmlsource )
        nhline = "xsl:transform of " + str( xmlnode.headString )
        p2 = pos.insertAfter() # tnode )
        p2.setBodyString(result)
        p2.setHeadString(nhline)
        c.redraw()

    except Exception as x:
        g.es( 'exception ' + str( x ))
    c.redraw()
Exemplo n.º 6
0
 def __init__(self, config, parent):
     C3Object.__init__(self, config, parent)
     xfrPath = self.get_path(None, "xsltPath")
     dfp = self.get_path(None, "defaultPath")
     path = os.path.join(dfp, xfrPath)
     xfr = InputSource.DefaultFactory.fromStream(file(path), "file://" + dfp)
     processor = Processor()
     processor.appendStylesheet(xfr)
     self.processor = processor
 def runNode(self,DomNode):
   """ classic XSLT transformation """
   self.first_pass = True
   self.currentRule = None
   self.our_writer = Dom.CustomDomWriter()
   Processor.runNode(self,DomNode,writer=self.our_writer)
   self.last_result = self.our_writer.getResult()
   self.first_pass = False
   return self.our_writer.getResult()
 def runNode(self, DomNode):
     """ classic XSLT transformation """
     self.first_pass = True
     self.currentRule = None
     self.our_writer = Dom.CustomDomWriter()
     Processor.runNode(self, DomNode, writer=self.our_writer)
     self.last_result = self.our_writer.getResult()
     self.first_pass = False
     return self.our_writer.getResult()
Exemplo n.º 9
0
        def applyXslt(self,
                      xslStylesheet,
                      topLevelParams=None,
                      extFunctionMap=None,
                      baseUri='file:',
                      styleSheetCache=None):
            extFunctionMap = extFunctionMap or {}

            from Ft.Xml.Xslt.Processor import Processor
            processor = Processor()

            if styleSheetCache:
                styleSheet = styleSheetCache.getValue(xslStylesheet, baseUri)
                processor.appendStylesheetInstance(styleSheet, baseUri)
            else:
                processor.appendStylesheet(
                    InputSource.DefaultFactory.fromString(
                        xslStylesheet, baseUri))  #todo: fix baseUri

            for (k, v) in extFunctionMap.items():
                namespace, localName = k
                processor.registerExtensionFunction(namespace, localName, v)

            return processor.runNode(self.dom, None, 0,
                                     topLevelParams), processor.stylesheet
Exemplo n.º 10
0
def transform(xml, xsl):
    """
    A simple wrapper for 4XSLT.
    """
    from Ft.Xml.Xslt.Processor import Processor
    from Ft.Xml.InputSource import DefaultFactory
    proc = Processor()
    xslObj = DefaultFactory.fromString(xsl, "http://rantelope.com/")
    proc.appendStylesheet(xslObj)
    xmlObj = DefaultFactory.fromString(xml)
    return proc.run(xmlObj)
Exemplo n.º 11
0
    def build_dom_and_apply_style_sheet(self, xsl, file):
        #doc = xml.dom.minidom.Document()
        doc = implementation.createRootNode('file:///article.xml')

        self.app.ann_frame.build_xml(doc)
            
        xsltproc = Processor()
        xsltproc.appendStylesheet(DefaultFactory.fromUri(Uri.OsPathToUri(xsl)))
        output = xsltproc.runNode(doc, 'file:///article.xml')

        outFile = open(file,'w')
        outFile.write(output)
        outFile.close()                  
Exemplo n.º 12
0
    def build_dom_and_apply_style_sheet(self, xsl, file):
        #doc = xml.dom.minidom.Document()
        doc = implementation.createRootNode('file:///article.xml')

        self.app.ann_frame.build_xml(doc)

        xsltproc = Processor()
        xsltproc.appendStylesheet(DefaultFactory.fromUri(Uri.OsPathToUri(xsl)))
        output = xsltproc.runNode(doc, 'file:///article.xml')

        outFile = open(file, 'w')
        outFile.write(output)
        outFile.close()
Exemplo n.º 13
0
 def GET(self, query_string):
     try: 
         xml = urllib2.urlopen('http://localhost:8080/marcxml/%s' % query_string).read()
         xml = InputSource.DefaultFactory.fromString(xml)
         xslt = InputSource.DefaultFactory.fromUri(XSLT_URIS['mods'])
         processor = Processor()
         processor.appendStylesheet(xslt)
         web.header('Content-Type', 'application/xml')
         print processor.run(xml)
     except urllib2.HTTPError, e:
         if e.code == 404:
             web.notfound()
         else:
             raise
Exemplo n.º 14
0
def Test(tester):
    # We don't use test_harness.XsltTest and friends because they hide away
    # the API details we're testing in this module.
    # See http://bugs.4suite.org/641693

    tester.startGroup("Test multiple stylesheet invokation")
    xp = Processor()
    xp.appendStylesheet(
        DefaultFactory.fromString(stylesheet_string, uri="data:ss"))
    result1 = xp.run(DefaultFactory.fromString(source_string, uri="data:src1"))
    result2 = xp.run(DefaultFactory.fromString(source_string, uri="data:src2"))
    tester.compare(result1, EXPECTED_1)
    tester.compare(result2, EXPECTED_1)
    tester.groupDone()
    return
Exemplo n.º 15
0
    def __transform_4suite(self, file, xsl_file, output, params):

        import codecs
        from Ft.Xml import InputSource
        from Ft.Xml.Xslt.Processor import Processor

        document = InputSource.DefaultFactory.fromUri(file)
        stylesheet = InputSource.DefaultFactory.fromUri(xsl_file)
            # there's also a fromString() method

        processor = Processor()
        processor.appendStylesheet(stylesheet)  
        result = processor.run(document, topLevelParams=params)
        (utf8_encode, utf8_decode, utf8_reader, utf8_writer) = codecs.lookup("utf-8")
        write_obj = utf8_writer(open(output, 'w'))
        write_obj.write(result)
        write_obj.close()
Exemplo n.º 16
0
def Test(tester):
    # We don't use test_harness.XsltTest and friends because they hide away
    # the API details we're testing in this module.
    # See http://bugs.4suite.org/641693

    tester.startGroup("Test multiple stylesheet invokation")
    xp = Processor()
    xp.appendStylesheet(DefaultFactory.fromString(stylesheet_string,
                                                  uri="data:ss"))
    result1 = xp.run(DefaultFactory.fromString(source_string,
                                     uri="data:src1"))
    result2 = xp.run(DefaultFactory.fromString(source_string,
                                     uri="data:src2"))
    tester.compare(result1, EXPECTED_1)
    tester.compare(result2, EXPECTED_1)
    tester.groupDone()
    return
    def __init__(self,
                 stylesheetAltUris=None,
                 documentReader=None,
                 implementation=None,
                 stylesheetIncPaths=None):
        """ Optional constructor arguments are:
 
     stylesheetAltUris: a list of alternative base URIs to use when
      resolving relative hrefs in xsl:import/xsl:include instructions.
       These URIs are only tried when the standard XSLT behavior of
       using the base URI of the xsl:import/include element itself
       fails to result in retrieval of a document.
 
   documentReader: an object that will be used to parse XML source
       documents (not stylesheets). It defaults to
      Ft.Xml.Domlette.NonvalidatingReader, but it can be any object
       that has a parse() method that returns a DOM or Domlette tree.
 
     implementation: a DOM implementation instance that will be used
       by the processor to create new source tree nodes, such as when
       generating result tree fragments or duplicating the source tree
       when runNode(node, preserveSrc=1) is called. Defaults to
       Ft.Xml.Domlette.implementation. Needs to have a
           createRootNode() method.
      """

        # Calling superclass constructor
        Processor.__init__(self,
                           stylesheetAltUris=stylesheetAltUris,
                           documentReader=documentReader,
                           implementation=implementation,
                           stylesheetIncPaths=stylesheetIncPaths)
        Observer.__init__(self)
        self.first_pass = True
        self.changed_nodes = []  #the list of the changed nodes.
        self.last_result = None  #the last dom tree generated.
        self.currentRule = None  #a hierachy of reevaluation rules
        self.our_writer = Dom.CustomDomWriter()  #the dom writer
Exemplo n.º 18
0
    def get_processor(self, transform_hash, ext_functions=None, ext_elements=None):
        try:
            # First make sure we avoid race conditions...
            self._main_lock.acquire()
            if transform_hash not in self._granular_locks:
                self._granular_locks[transform_hash] = thread.allocate_lock()
        finally:
            self._main_lock.release()

        proc = None
        try:
            self._granular_locks[transform_hash].acquire()
            # If we do not have that stylesheet yet in the pool, let's add it
            if not self._processors.has_key(transform_hash):
                processor = Processor()
                self._processors[transform_hash] = processor_info(
                    thread.allocate_lock(), stat(transform_hash)[ST_MTIME], processor
                )
                for (ns, local), func in ext_functions.items():
                    processor.registerExtensionFunction(ns, local, func)
                for (ns, local), elem in ext_elements.items():
                    processor.registerExtensionElement(ns, local, elem)

                self._processors[transform_hash].instance.append_transform(iri.os_path_to_uri(transform_hash))
            # If the stylesheet has been modified, reload it
            elif stat(transform_hash)[ST_MTIME] != self._processors[transform_hash].last_modified:
                self._processors[transform_hash].instance.reset()
                self._processors[transform_hash].last_modified = stat(transform_hash)[ST_MTIME]
                self._processors[transform_hash].instance.append_transform(iri.os_path_to_uri(transform_hash))

            # now we can lock the processor...
            self._processors[transform_hash]['lock'].acquire()
            proc = self._processors[transform_hash].instance
        finally:
            self._granular_locks[transform_hash].release()
        # ... and return it
        return proc
Exemplo n.º 19
0
 def __init__(self,stream=sys.stdout,encoding='ascii'):
     XsltProcessor.__init__(self)
     NodePrinter.__init__(self,stream,encoding)
     self.writer = codecs.getwriter(encoding)(stream,'xmlcharrefreplace')
Exemplo n.º 20
0
 def runNode(self,node,nameSpace=EMPTY_NAMESPACE):
     self.writer.write(codecs.getdecoder('utf-8')(XsltProcessor.runNode(self,node,nameSpace))[0])
Exemplo n.º 21
0
    for module in map(__import__, modules_to_test):
        suite.addTest(findTestCases(module))

    output, result = XMLTestRunner().run(suite, options.timestamp)

    ro = output
    if options.format is not None:
        try:
            from Ft.Lib import Uri
            from Ft.Xml.InputSource import DefaultFactory
            from Ft.Xml.Xslt.Processor import Processor
        except:
            print "Couldn't import modules to generate HTML."

        processor = Processor()

        if options.format == "html":
            xform = DefaultFactory.fromString(html_xform, "uri")
        elif options.format == "text":
            xform = DefaultFactory.fromString(text_xform, "uri")

        processor.appendStylesheet(xform)

        try:
            ro = processor.run(DefaultFactory.fromString(output, "uri"))
        except Exception, e:
            print "Failed to generate HTML. (%s)" % e
            ro = None

    if options.outputFile is not None and ro is not None:
Exemplo n.º 22
0
    def format(self, formatter):
        """ Send the text.
        """
        _ = self._
        if not self.request.cfg.allow_xslt:
            from MoinMoin.parser import plain
            self.request.write(formatter.sysmsg(1) +
                               formatter.text(_('XSLT option disabled!'))+
                               formatter.sysmsg(0))
            plain.Parser(self.raw, self.request).format(formatter)
            return

        arena = formatter.page
        key   = 'xslt'
        cache = caching.CacheEntry(self.request, arena, key)
        if not cache.needsUpdate(formatter.page._text_filename()):
            self.request.write(cache.content())
            self._add_refresh(formatter, cache, arena, key)
            return

        try:
            # assert we have 4Suite 1.x available
            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!')) +
                               self.request.formatter.sysmsg(0))
        else:
            import xml.sax
            from Ft.Lib import Uri
            from Ft.Xml import InputSource
            from Ft.Xml.Xslt.Processor import Processor

            processor = Processor()
            msg = None
            try:
                base_uri = u'wiki://Self/'

                # patch broken 4Suite 1.0a1 (announces as "1.0a")
                # 1.0a3 ("1.0a3") is broken, too
                # thus, I assume 1.0a2 is also broken and announces either as "1.0a" or "1.0a2", hopefully
                if ft_version not in ["1.0a", "1.0a2", "1.0a3", "1.0a4",]: # you can add more broken versions here
                    MoinResolver = Uri.SchemeRegistryResolver
                else:
                    if ft_version == "1.0a4":  # 1.0a4 changes location of SchemeRegistryResolver
                        from Ft.Lib import Resolvers
                        SchemeRegistryResolverPATH = Resolvers.SchemeRegistryResolver
                    else:
                        SchemeRegistryResolverPATH = Uri.SchemeRegistryResolver

                    class MoinResolver(SchemeRegistryResolverPATH):
                        def normalize(self, uri, base):
                            from Ft.Lib import Uri
                            if ft_version == "1.0a4":
                                GetSchemeFunc = Uri.GetScheme
                            else:
                                GetSchemeFunc = Uri._getScheme

                            scheme = GetSchemeFunc(uri)

                            if not scheme:
                                if base:
                                    scheme = GetSchemeFunc(base)
                                if not scheme:
                                    return Uri.BaseUriResolver.normalize(self, uri, base)
                                else:
                                    uri = Uri.Absolutize(uri, base)
                                    if not uri:
                                        return base
                            return uri

                wiki_resolver = MoinResolver()

                def _resolve_page(uri, base=None, Uri=Uri, base_uri=base_uri, resolver=wiki_resolver, request=self.request):
                    """ Check whether uri is a valid pagename.
                    """
                    if uri.startswith(base_uri):
                        pagename = uri[len(base_uri):]
                        page = Page.Page(request, pagename)
                        if page.exists():
                            return StringIO.StringIO(page.get_raw_body())
                        else:
                            raise Uri.UriException(Uri.UriException.RESOURCE_ERROR, uri,
                                'Page does not exist')
                    return Uri.BaseUriResolver.resolve(resolver, uri, base)

                wiki_resolver.handlers = {
                    'wiki': _resolve_page,
                }

                out_file = StringIO.StringIO()
                input_factory = InputSource.InputSourceFactory(resolver=wiki_resolver)
                page_uri = u"%s%s" % (base_uri, formatter.page.page_name)

                processor.run(input_factory.fromString(self.raw, uri=page_uri), outputStream=out_file)
                result = out_file.getvalue()
            except xml.sax.SAXParseException, msg:
                etype = "SAX"
            except xml.sax.SAXException, msg:
                etype = "SAX"
Exemplo n.º 23
0
class Parser:
    """ Send XML file formatted via XSLT. """
    caching = 1
    Dependencies = Dependencies

    def __init__(self, raw, request, **kw):
        self.raw = raw.encode(config.charset)
        self.request = request
        self.form = request.form
        self._ = request.getText
        self.base_scheme = 'wiki'
        self.base_uri = 'wiki://Self/'
        self.key = 'xslt'

    def format(self, formatter):
        """ Send the text. """
        _ = self._

        if not self.request.cfg.allow_xslt:
            # use plain parser if XSLT is not allowed
            # can be activated in wikiconfig.py
            from MoinMoin.parser import plain
            self.request.write(formatter.sysmsg(1) +
                               formatter.raw_html(_('XSLT option disabled, please look at HelpOnConfiguration.')) +
                               formatter.sysmsg(0))
            plain.Parser(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":
                    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_name = formatter.page.page_name
                page_uri = u"%s%s" % (self.base_uri, page_name.encode(config.charset))

                raw = self.raw.strip()

                self.processor = Processor()
                self.append_stylesheet() # hook, for extending this parser
                self.processor.run(
                    input_factory.fromString(raw, uri=page_uri),
                    outputStream=out_file)
                result = out_file.getvalue()
                result = self.parse_result(result) # hook, for extending this parser

            except FtException, msg:
                etype = "XSLT"
            except Uri.UriException, msg:
                etype = "XSLT"
            except IOError, msg:
                etype = "I/O"
Exemplo n.º 24
0
#From Robert Sanderson AKA azaroth42
from Xml.Xslt import test_harness

EXPECTED_1 = """<?xml version="1.0" encoding="UTF-8"?>\n"""

from Ft.Xml.Xslt.Processor import Processor
from Ft.Xml.InputSource import DefaultFactory

processor = Processor()
TRANSFORM_2 = """<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                version="1.0">
  <xsl:output method="html"/>
  <xsl:template match="/">
  <xsl:text>Starting...</xsl:text>
  <xsl:apply-templates/>
  <xsl:text>Finished.</xsl:text>
  </xsl:template>
  <xsl:template match="aaa">
  <xsl:variable name="atxt">
  <xsl:value-of select="."/>
  </xsl:variable>
  <xsl:if test="atxt='now'">
  Now!
  </xsl:if>
  </xsl:template>
</xsl:stylesheet>
"""

EXPECTED = 'Starting...Finished.'
Exemplo n.º 25
0
def mongetattr(ins, attname):
    print "Aie!"
    return None


def monset(ins, d):
    print "On défini un truc sur le contexte"
    ancienset(ins, d)


def monsetattr(ins, attname, val):
    print "HeHo !"


print Ft.Xml.Xslt.XsltContext.XsltContext.__dict__.keys()
Ft.Xml.Xslt.XsltContext.XsltContext.__dict__['set'] = monset
Ft.Xml.Xslt.XsltContext.XsltContext.__dict__['addDocument'] = monsetattr
Ft.Xml.Xslt.XsltContext.XsltContext.__dict__['__setattr__'] = monsetattr
print Ft.Xml.Xslt.XsltContext.XsltContext.__dict__.keys()
xsltproc = Processor()

xsltproc.appendStylesheet(
    DefaultFactory.fromUri(
        "file:///home/t0rt00se/Travail/SILR3/pTrans/testset/persons_to_xhtml_list.xsl"
    ))
html = xsltproc.run(
    DefaultFactory.fromUri(
        "file:///home/t0rt00se/Travail/SILR3/pTrans/testset/persons.xml"))
print html
Exemplo n.º 26
0
    for module in map(__import__, modules_to_test):
       suite.addTest(findTestCases(module))

    output, result = XMLTestRunner().run(suite, options.timestamp)

    ro = output
    if options.format is not None:
        try:
            from Ft.Lib import Uri
            from Ft.Xml.InputSource import DefaultFactory
            from Ft.Xml.Xslt.Processor import Processor
        except:
            print "Couldn't import modules to generate HTML."
            
        processor = Processor()

        if options.format == "html":
            xform = DefaultFactory.fromString(html_xform, "uri")
        elif options.format == "text":
            xform = DefaultFactory.fromString(text_xform, "uri")

        processor.appendStylesheet(xform)
        
        try:
            ro = processor.run(DefaultFactory.fromString(output, "uri"))
        except Exception, e:
            print "Failed to generate HTML. (%s)" % e
            ro = None
                
    if options.outputFile is not None and ro is not None:
Exemplo n.º 27
0
 def get_processor(self):
     proc = Processor()
     if self.extensions:
         for ext in self.extensions:
             proc.registerExtensionFunction(*(ext))
     return proc
Exemplo n.º 28
0
    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"
Exemplo n.º 29
0
 def runNode(self,node,nameSpace=EMPTY_NAMESPACE):
     self.streamWriter.write(codecs.getdecoder(DEFAULT_ENCODING)(XsltProcessor.runNode(self,node,nameSpace))[0])
Exemplo n.º 30
0
import Ft
from Ft.Xml.InputSource import DefaultFactory
import trace,sys


from xml.xpath import Context, Util

ancienset = Ft.Xml.Xslt.XsltContext.XsltContext.set
def mongetattr(ins,attname):
  print "Aie!"
  return None

def monset(ins,d):
  print "On défini un truc sur le contexte"
  ancienset(ins,d)
  

def monsetattr(ins,attname,val):
  print "HeHo !"

print Ft.Xml.Xslt.XsltContext.XsltContext.__dict__.keys()
Ft.Xml.Xslt.XsltContext.XsltContext.__dict__['set'] = monset
Ft.Xml.Xslt.XsltContext.XsltContext.__dict__['addDocument'] = monsetattr
Ft.Xml.Xslt.XsltContext.XsltContext.__dict__['__setattr__'] = monsetattr
print Ft.Xml.Xslt.XsltContext.XsltContext.__dict__.keys()
xsltproc = Processor()

xsltproc.appendStylesheet(DefaultFactory.fromUri("file:///home/t0rt00se/Travail/SILR3/pTrans/testset/persons_to_xhtml_list.xsl"))
html = xsltproc.run(DefaultFactory.fromUri("file:///home/t0rt00se/Travail/SILR3/pTrans/testset/persons.xml"))
print html
Exemplo n.º 31
0
    def format(self, formatter, **kw):
        """ 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"
Exemplo n.º 32
0
    def error(self, message):
        print "B³±d: " + message

    def fatal(self, message):
        print "B³±d krytyczny: " + message


# Otwórz pliki HTML i XSTL jako strumienie.
html = open('mojblog.html')
xsl = open('HTMLnaRSS.xsl')

# Przetwórz strumienie i utwórz z nich Ÿród³a wejœciowe.
parsedxml = InputSource.DefaultFactory.fromStream(html, "mojblog.html")
parsedxsl = InputSource.DefaultFactory.fromStream(xsl, "HTMLnaRSS.xsl")

# Utwórz nowy procesor, do³¹cz do niego arkusz stylu a nastêpnie przekszta³æ XML.
processor = Processor()
processor.appendStylesheet(parsedxsl)
HTML = processor.run(parsedxml)

# Zapisz wyjœciowy dokument RSS w pliku.
output = open("kanalRSS.xml", 'w')
output.write(HTML)
output.close

# Dokonaj walidacji kana³u RSS.
parser = xmlval.XMLValidator()
parser.set_error_handler(docErrorHandler(parser))
parser.parse_resource("kanalRSS.xml")
Exemplo n.º 33
0
 def __init__(self,stream=sys.stdout,encoding=DEFAULT_ENCODING):
     XsltProcessor.__init__(self)
     NodePrinter.__init__(self,stream,encoding)
     self.streamWriter = codecs.getwriter(encoding)(stream,'xmlcharrefreplace')