spoon.compiler.Environment Java Examples

private void initSpoonProperties(Launcher launcher) throws MojoExecutionException {
	Environment environment = launcher.getEnvironment();

	for (ProcessorProperties processorProperties : this.getProcessorProperties()) {
		spoon.processing.ProcessorProperties properties = new ProcessorPropertiesImpl();

		Properties xmlProperties = processorProperties.getProperties();

		for (Object key : xmlProperties.keySet()) {
			String sKey = (String) key;
			String value = (String) xmlProperties.get(key);

			properties.set(sKey, value);
		}

		environment.setProcessorProperties(processorProperties.getName(), properties);
	}
}
 

public void generateOutputFile(File destinationFolder) {
    Environment env = factory.getEnvironment();
    env.setSourceOutputDirectory(destinationFolder);
    JavaOutputProcessor javaOutputProcessor = new JavaOutputProcessor(prettyPrinter);
    javaOutputProcessor.setFactory(factory);
    Processor<?> writer = javaOutputProcessor;
    process(writer);
}
 

Spoonerism writeTransformedClasses () {
    // And now just write the transformed classes
    Environment env = spoonUniverse.getEnvironment();
    // replace FQN with imports and short names
    env.setAutoImports(true);
    // include comments - source is for human consumption
    env.setCommentEnabled(true);

    // where to write
    spoonUniverse.setSourceOutputDirectory(OUT_DIR);
    // default printing, use a different printer for even fancier formatting
    spoonUniverse.prettyprint();
    return this;
}
 

@Test
public void main() {
    String projectPath = ".";

    MavenLauncher launcher = new MavenLauncher(projectPath, MavenLauncher.SOURCE_TYPE.APP_SOURCE);

    Environment environment = launcher.getEnvironment();
    environment.setCommentEnabled(true);
    environment.setAutoImports(true);

    launcher.addProcessor(new APICheckingProcessor());
    launcher.run();
}
 

public static Environment getEnvironment() {
	StandardEnvironment env = new StandardEnvironment();

	Integer complianceLevel = ConfigurationProperties.getPropertyInt("javacompliancelevel");
	env.setComplianceLevel((complianceLevel > 2) ? complianceLevel : 3);
	env.setVerbose(false);
	env.setDebug(true);
	env.setTabulationSize(5);
	env.useTabulations(true);
	return env;
}
 

protected Environment spoonEnvironment() {
    return spoonFactory().getEnvironment();
}
 

@Override
public void init() {
	ignoredTypes.add(getFactory().Type().createReference(Environment.class));
	ignoredTypes.add(getFactory().Type().createReference(Factory.class));
	ignoredTypes.add(getFactory().Type().createReference(FactoryAccessor.class));
}
 

@SuppressWarnings("all")
@Test
public void main() {
    MavenLauncher launcher = new MavenLauncher(
            "./src/test/resources/project/",
            MavenLauncher.SOURCE_TYPE.APP_SOURCE);

    CtModel model = launcher.buildModel();
    List<CtMethod> methodList = model.
            filterChildren(new NamedElementFilter<CtPackage>(CtPackage.class, "ow2con")).
            filterChildren(new NamedElementFilter<CtPackage>(CtPackage.class, "publicapi")).
            filterChildren(new TypeFilter<CtMethod>(CtMethod.class)).
            filterChildren(new Filter<CtMethod>() {
                @Override
                public boolean matches(CtMethod element) {
                    boolean isPublic = element.isPublic();
                    CtTypeReference returnType = element.getType();
                    String privateApiPackage = "ow2con.privateapi";
                    boolean isTypeFromPrivateApi = returnType.getQualifiedName().contains(privateApiPackage);
                    return isPublic && isTypeFromPrivateApi;
                }
            }).list();

    Factory factory = launcher.getFactory();
    CtClass<? extends Throwable> exceptionClass = factory.createClass("ow2con.PrivateAPIException");
    CtConstructorCall<? extends Throwable> exceptionInstance = factory.createConstructorCall(exceptionClass.getReference());

    for (CtMethod method : methodList) {
        CtBlock methodBody = method.getBody();
        List<CtComment> bodyComments = new ArrayList<>();

        ArrayList<CtStatement> ctStatements = new ArrayList<>(methodBody.getStatements());

        for (CtStatement ctStatement : ctStatements) {
            String statement = ctStatement.toString();
            CtComment statementAsComment = factory.createInlineComment(statement);
            bodyComments.add(statementAsComment);
            methodBody.removeStatement(ctStatement);
        }

        CtThrow throwMyException = factory.createThrow();
        CtConstructorCall<? extends Throwable> constructorCall = exceptionInstance.clone();
        throwMyException.setThrownExpression(constructorCall);
        methodBody.addStatement(throwMyException);

        bodyComments.add(
                factory.createInlineComment(
                "FIXME: The private API type should never be return in a public API."
                )
        );

        for (CtComment bodyComment : bodyComments) {
            throwMyException.addComment(bodyComment);
        }
    }

    Environment environment = launcher.getEnvironment();
    environment.setCommentEnabled(true);
    environment.setAutoImports(true);
    // the transformation must produce compilable code
    environment.setShouldCompile(true);
    launcher.prettyprint();

    // look in folder spooned/ow2con/publicapi/ the transformed code
}
 

public Environment getEnvironment() {
	return this.getFactory().getEnvironment();
}
 

public MutationSupporter(Factory factory, Environment environment) {
	this.factory = factory;
	this.currentSupporter = this;
	this.output = new OutputWritter(factory);
}
 

private static Factory createFactory() {
	Environment env = getEnvironment();
	Factory factory = new FactoryImpl(new DefaultCoreFactory(), env);

	return factory;
}