Examples with TransformOutput org.metaborg.spoofax.core.unit.TransformOutput used on opensource projects

Example 1 with TransformOutput

use of org.metaborg.spoofax.core.unit.TransformOutput in project spoofax by metaborg.

the class StrategoTransformer method output.

private TransformOutput output(IStrategoTerm resourceTerm, IStrategoTerm contentTerm, FileObject location, ITransformConfig config) throws MetaborgException {
    if (!(resourceTerm instanceof IStrategoString)) {
        throw new MetaborgException("First term of result tuple {} is not a string, cannot write output file");
    } else {
        final String resourceString = Tools.asJavaString(resourceTerm);
        final String resultContents = common.toString(contentTerm);
        // writing to output file is allowed
        FileObject output;
        if (!config.dryRun()) {
            output = resourceService.resolve(location, resourceString);
            try (OutputStream stream = output.getContent().getOutputStream()) {
                IOUtils.write(resultContents, stream, Charset.defaultCharset());
            } catch (IOException e) {
                logger.error("Error occurred while writing output file", e);
            }
        } else {
            output = null;
        }
        return new TransformOutput(resourceString, output, contentTerm);
    }
}

Example 2 with TransformOutput

use of org.metaborg.spoofax.core.unit.TransformOutput in project spoofax by metaborg.

the class StrategoTransformer method transform.

private <I extends IUnit> ISpoofaxTransformUnit<I> transform(I input, IContext context, TransformActionContrib actionContribution, FileObject source, IStrategoTerm term, ITransformConfig config) throws TransformException {
    final FileObject location = context.location();
    final ILanguageComponent component = actionContribution.contributor;
    final TransformAction action = action(actionContribution.action);
    // Get input term
    final IStrategoTerm inputTerm = common.builderInputTerm(term, source, location);
    // Get Stratego runtime
    final HybridInterpreter runtime;
    try {
        runtime = strategoRuntimeService.runtime(component, context, true);
    } catch (MetaborgException e) {
        throw new TransformException("Transformation failed unexpectedly; cannot get Stratego interpreter", e);
    }
    // Transform
    logger.debug("Transforming {} with '{}'", source, action.name);
    final Timer timer = new Timer(true);
    final IStrategoTerm outputTerm;
    try {
        outputTerm = common.invoke(runtime, inputTerm, action.strategy);
    } catch (MetaborgException e) {
        throw new TransformException(e.getMessage(), e.getCause());
    }
    final long duration = timer.stop();
    if (outputTerm == null) {
        final String message = logger.format("Invoking Stratego strategy {} failed", action.strategy);
        throw new TransformException(message);
    }
    // Get the result and, if allowed and required, write to file
    List<TransformOutput> outputs;
    IStrategoTerm resultTerm;
    if (outputTerm.getSubtermCount() == 2 && (outputTerm instanceof IStrategoTuple)) {
        final IStrategoTerm resourceTerm = outputTerm.getSubterm(0);
        final IStrategoTerm contentTerm = outputTerm.getSubterm(1);
        try {
            if (resourceTerm instanceof IStrategoString) {
                resultTerm = contentTerm;
                outputs = Lists.newArrayList(output(resourceTerm, contentTerm, location, config));
            } else if (resourceTerm instanceof IStrategoList) {
                if (!(contentTerm instanceof IStrategoList) || resourceTerm.getSubtermCount() != contentTerm.getSubtermCount()) {
                    logger.error("List of terms does not match list of file names, cannot write to file.");
                    resultTerm = null;
                    outputs = Collections.emptyList();
                } else {
                    outputs = Lists.newArrayListWithExpectedSize(resourceTerm.getSubtermCount());
                    for (int i = 0; i < resourceTerm.getSubtermCount(); i++) {
                        outputs.add(output(resourceTerm.getSubterm(i), contentTerm.getSubterm(i), location, config));
                    }
                    resultTerm = resourceTerm.getSubtermCount() == 1 ? resourceTerm.getSubterm(0) : null;
                }
            } else {
                logger.error("First term of result tuple {} is neither a string, nor a list, cannot write output file", resourceTerm);
                resultTerm = null;
                outputs = Collections.emptyList();
            }
        } catch (MetaborgException ex) {
            resultTerm = null;
            outputs = Collections.emptyList();
        }
    } else {
        resultTerm = outputTerm;
        outputs = Collections.emptyList();
    }
    // Open editor
    if (action.flags.openEditor) {
        List<FileObject> resources = Lists.newArrayListWithExpectedSize(outputs.size());
        for (TransformOutput output : outputs) {
            if (output.resource != null) {
                resources.add(output.resource);
            }
        }
        editorRegistry.open(resources, context.project());
    }
    // Return result
    final TransformContrib contrib = new TransformContrib(resultTerm != null || !Iterables.isEmpty(outputs), true, resultTerm, outputs, Iterables2.<IMessage>empty(), duration);
    return unitService.transformUnit(input, contrib, context, actionContribution);
}