net.sf.saxon.s9api.XsltExecutable Java Examples

/**
 * Lädt ein XSL von der angegebenen URI
 *
 * @param uri die URI der XSL Definition
 * @return ein XSLT Executable
 */
public XsltExecutable loadXsltScript(final URI uri) {
    log.info("Loading XSLT script from  {}", uri);
    final XsltCompiler xsltCompiler = getProcessor().newXsltCompiler();
    final CollectingErrorEventHandler listener = new CollectingErrorEventHandler();
    try {
        xsltCompiler.setErrorListener(listener);
        if (getResolver() != null) {
            // otherwise use default resolver
            xsltCompiler.setURIResolver(getResolver());
        }

        return xsltCompiler.compile(resolveInRepository(uri));
    } catch (final SaxonApiException e) {
        listener.getErrors().forEach(event -> event.log(log));
        throw new IllegalStateException("Can not compile xslt executable for uri " + uri, e);
    } finally {
        if (!listener.hasErrors() && listener.hasEvents()) {
            log.warn("Received warnings or errors while loading a xslt script {}", uri);
            listener.getErrors().forEach(e -> e.log(log));
        }
    }
}
 

@Test
public void testProcessingError() throws IOException, SaxonApiException {
    final CheckAction.Bag bag = createBag(InputFactory.read(Simple.SIMPLE_VALID.toURL()), true);

    final Scenario scenario = bag.getScenarioSelectionResult().getObject();
    final XsltExecutable exec = mock(XsltExecutable.class);
    final XsltTransformer transformer = mock(XsltTransformer.class);
    doThrow(new SaxonApiException("invalid")).when(transformer).transform();
    when(exec.load()).thenReturn(transformer);
    final ResourceType resourceType = new ResourceType();
    resourceType.setName("invalid internal");
    scenario.setSchematronValidations(Collections.singletonList(new Transformation(exec, resourceType)));
    this.action.check(bag);
    assertThat(bag.getReportInput().getProcessingError().getError()).isNotEmpty();
}
 

@Test
public void testEvilStylesheets() throws IOException {
    final Processor p = TestObjectFactory.createProcessor();
    for (int i = 1; i <= 5; i++) {
        try {
            final URL resource = SaxonSecurityTest.class.getResource(String.format("/evil/evil%s.xsl", i));
            final XsltCompiler compiler = p.newXsltCompiler();
            final RelativeUriResolver resolver = new RelativeUriResolver(Simple.REPOSITORY_URI);
            compiler.setURIResolver(resolver);
            final XsltExecutable executable = compiler.compile(new StreamSource(resource.openStream()));
            final XsltTransformer transformer = executable.load();
            final Source document = InputFactory.read("<root/>".getBytes(), "dummy").getSource();
            // transformer.getUnderlyingController().setUnparsedTextURIResolver(resolver);
            transformer.setURIResolver(resolver);
            transformer.setSource(document);
            final XdmDestination result = new XdmDestination();
            transformer.setDestination(result);
            transformer.transform();

            // wenn der Punkt erreicht wird, sollte wenigstens, das Element evil nicht mit 'bösen' Inhalten gefüllt sein!
            if (StringUtils.isNotBlank(result.getXdmNode().getStringValue())) {
                fail(String.format("Saxon configuration should prevent expansion within %s", resource));
            }

        } catch (final SaxonApiException | RuntimeException e) {
            log.info("Expected exception detected {}", e.getMessage(), e);
        }
    }
}
 

XPathContext getXPathContext(TestEntry test, String sourcesName,
        XdmNode contextNode) throws Exception {
  XPathContext context = null;
  if (test.usesContext()) {
    XsltExecutable xe = engine.loadExecutable(test, sourcesName);
    Executable ex = xe.getUnderlyingCompiledStylesheet()
            .getExecutable();
    context = new XPathContextMajor(contextNode.getUnderlyingNode(), ex);
  }
  return context;
}
 

public XdmNode executeTemplate(TemplateEntry template, XdmNode params,
        XPathContext context) throws Exception {
  if (stop) {
    throw new Exception("Execution was stopped by the user.");
  }
  XsltExecutable executable = engine.loadExecutable(template,
          opts.getSourcesName());
  XsltTransformer xt = executable.load();
  XdmDestination dest = new XdmDestination();
  xt.setDestination(dest);
  if (template.usesContext() && context != null) {
    xt.setSource((NodeInfo) context.getContextItem());
  } else {
    xt.setSource(new StreamSource(new StringReader("<nil/>")));
  }
      xt.setParameter(TECORE_QNAME, new ObjValue(this));
  if (params != null) {
          xt.setParameter(TEPARAMS_QNAME, params);
  }
  // test may set global verdict, e.g. by calling ctl:fail
  if (LOGR.isLoggable( FINE)) {
    LOGR.log( FINE,
            "Executing TemplateEntry {0}" + template.getQName());
  }
  xt.transform();
  XdmNode ret = dest.getXdmNode();
      if (ret != null && LOGR.isLoggable( FINE)) {
          LOGR.log( FINE, "Output:\n" + ret.toString());
      }
  return ret;
}
 

private static XsltExecutable loadFromScenario(final Scenario object) {
    return object.getReportTransformation().getExecutable();
}
 

private static XsltExecutable getTransformation(final Bag results) {
    return loadFromScenario(results.getScenarioSelectionResult().getObject());
}
 

public Transformation createTransformation(final ResourceType resource) {
    final XsltExecutable executable = loadXsltScript(URI.create(resource.getLocation()));
    return new Transformation(executable, resource);
}
 

@Test
public void testLoadXSLT() {
    final XsltExecutable executable = this.repository.loadXsltScript(Simple.REPORT_XSL);
    assertThat(executable).isNotNull();
}
 

public Map<String, XsltExecutable> getLoadedExecutables() {
    return loadedExecutables;
}
 

public XsltExecutable getFormExecutable() {
    return formExecutable;
}