public void writeFile(BaseGenerator generator, Element... originatingElements) throws IOException { Writer writer = null; try { JavaFileObject jfo = filer.createSourceFile(generator.getFqcn(), originatingElements); writer = jfo.openWriter(); if (isDebugEnabled) { System.out.println("File generated:\n" + generator.brewJava() + "---"); } writer.write(generator.brewJava()); } finally { if (writer != null) { writer.close(); } } } }
if (file.getKind() == Kind.CLASS && file.getName().startsWith(packageName)) { files.add(file); } else if (location == StandardLocation.SOURCE_PATH && kinds.contains(JavaFileObject.Kind.SOURCE)) { for (JavaFileObject file : fileObjects.values()) { if (file.getKind() == Kind.SOURCE && file.getName().startsWith(packageName)) { files.add(file);
private DescriptionBasedDiff( JCCompilationUnit compilationUnit, boolean ignoreOverlappingFixes, ImportOrganizer importOrganizer) { this.compilationUnit = checkNotNull(compilationUnit); URI sourceFileUri = compilationUnit.getSourceFile().toUri(); this.sourcePath = (sourceFileUri.isAbsolute() && Objects.equals(sourceFileUri.getScheme(), "file")) ? Paths.get(sourceFileUri).toAbsolutePath().toString() : sourceFileUri.getPath(); this.ignoreOverlappingFixes = ignoreOverlappingFixes; this.importsToAdd = new LinkedHashSet<>(); this.importsToRemove = new LinkedHashSet<>(); this.endPositions = compilationUnit.endPositions; this.importOrganizer = importOrganizer; }
public static SourceFile create(JavaFileObject fileObject) throws IOException { return new SourceFile(fileObject.toUri().getPath(), fileObject.getCharContent(false)); }
/** Writes this to {@code filer}. */ public void writeTo(Filer filer) throws IOException { String fileName = packageName.isEmpty() ? typeSpec.name : packageName + "." + typeSpec.name; List<Element> originatingElements = typeSpec.originatingElements; JavaFileObject filerSourceFile = filer.createSourceFile(fileName, originatingElements.toArray(new Element[originatingElements.size()])); try (Writer writer = filerSourceFile.openWriter()) { writeTo(writer); } catch (Exception e) { try { filerSourceFile.delete(); } catch (Exception ignored) { } throw e; } }
public long findSourceTimestamp(DecoratedProcessingEnvironment env, Element apiElement) { SourcePosition sp = env.findSourcePosition(apiElement); URI uri = sp == null ? null : sp.getPath() == null ? null : sp.getPath().getCompilationUnit() == null ? null : sp.getPath().getCompilationUnit().getSourceFile() == null ? null : sp.getPath().getCompilationUnit().getSourceFile().toUri(); if (uri != null && "file".equalsIgnoreCase(uri.getScheme())) { //it's a file uri. return new File(uri.getPath()).lastModified(); } return 0; }
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { if (!processed) { processed = true; try (Writer writer = processingEnv.getFiler() .createSourceFile(generatedClassName) .openWriter()) { writer.append(generatedSource); } catch (IOException e) { throw new RuntimeException(e); } } return false; } }
ImmutableList<JavaFileObject> getGeneratedSources() { ImmutableList.Builder<JavaFileObject> result = ImmutableList.builder(); for (Entry<URI, JavaFileObject> entry : inMemoryFileObjects.asMap().entrySet()) { if (entry.getKey().getPath().startsWith("/" + StandardLocation.SOURCE_OUTPUT.name()) && (entry.getValue().getKind() == Kind.SOURCE)) { result.add(entry.getValue()); } } return result.build(); }
private static void assertCompilationDiagnostingOn(Kind expectedDiagnosticKind, File expectedErrorClassFile, String expectedContentInError, CompileResult result) throws IOException { String expectedErrorPath; boolean fileNameOnly = expectedErrorClassFile.getPath().split(Pattern.quote(File.separator)).length == 1; if (fileNameOnly) { // this is just the filename expectedErrorPath = expectedErrorClassFile.getPath(); } else { expectedErrorPath = expectedErrorClassFile.toURI().toString(); } for (Diagnostic<? extends JavaFileObject> diagnostic : result.diagnostics) { if (diagnostic.getKind() == expectedDiagnosticKind) { JavaFileObject source = diagnostic.getSource(); if (source != null) { if (expectedErrorPath.endsWith(source.toUri().toString()) || fileNameOnly && source.toUri().toString().endsWith(expectedErrorPath)) { CharSequence sourceContent = source.getCharContent(true); if (diagnostic.getPosition() != Diagnostic.NOPOS) { CharSequence contentInError = sourceContent.subSequence((int) diagnostic.getStartPosition(), (int) diagnostic.getEndPosition()); if (contentInError.toString().contains(expectedContentInError)) { return; } } } } } } fail("Expected a compilation " + expectedDiagnosticKind + " in " + expectedErrorClassFile.toString() + " on " + expectedContentInError + ", diagnostics: " + result.diagnostics); }
JavaFileObject fileObject = processingEnv.getFiler().createSourceFile(applicationPackageName + "." + applicationClassName); processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Creating " + fileObject.toUri()); Writer writer = fileObject.openWriter(); try { PrintWriter pw = new PrintWriter(writer); writer.close(); processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, x.toString());
public void testDir() throws Exception { File root = toExploded(archive, ""); ClassLoader cl = new URLClassLoader(new URL[]{root.toURI().toURL()}, parent); ClasspathResolver resolver = new ClasspathResolver(cl); // No recurse List<JavaFileObject> classes = collect(Utils.list(resolver.resolve("java.util", false))); assertEquals(2, classes.size()); assertEndsWith("/HashMap.class", classes.get(0).getName()); assertEndsWith("/Map.class", classes.get(1).getName()); // Recurse classes = collect(Utils.list(resolver.resolve("java.util", true))); assertEquals(3, classes.size()); assertEndsWith("/ConcurrentHashMap.class", classes.get(0).getName()); assertEndsWith("/HashMap.class", classes.get(1).getName()); assertEndsWith("/Map.class", classes.get(2).getName()); }
unscannedTopElements.addAll(pkgE.getEnclosedElements()); } catch (/*NullPointerException,BadClassFile*/RuntimeException x) { // #196556 processingEnv.getMessager().printMessage(Kind.WARNING, "#196556: reading " + pkg + " failed with " + x + " in " + x.getStackTrace()[0] + "; do a clean build!"); processingEnv.getMessager().printMessage(Kind.WARNING, "Could not check for other source files in " + pkg); InputStream is = processingEnv.getFiler().getResource(StandardLocation.SOURCE_PATH, pkg, "Bundle.properties").openInputStream(); try { p.load(is); InputStream is = processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT, pkg, "Bundle.properties").openInputStream(); try { p.setComment(entry2.getKey(), entry2.getValue(), false); OutputStream os = processingEnv.getFiler().createResource(StandardLocation.CLASS_OUTPUT, pkg, "Bundle.properties", elements).openOutputStream(); try { p.store(os); Writer w = processingEnv.getFiler().createSourceFile(fqn, elements).openWriter(); try { PrintWriter pw = new PrintWriter(w); pw.close(); } finally { w.close();
@Override public String apply(CompilationUnitTree generated) { return String.format( "- %s in <%s>", actualTypes.get(generated), generated.getSourceFile().toUri().getPath()); } })
private void generate(Set<ClassModel> classModels) { final Filer filer = processingEnv.getFiler(); for (ClassModel classModel : classModels) { final String derivedClassName = deriveClassName(classModel); final String code = Generator.generate(derivedClassName, classModel); final String fqn = (classModel.hasDefaultPackage() ? "" : classModel.getPackageName() + ".") + derivedClassName; try (final Writer writer = filer.createSourceFile(fqn, classModel.typeElement()).openWriter()) { writer.write(code); } catch (IOException x) { throw new Error("Error writing " + fqn, x); } } }
@Test public void test1_UniqueNames() { JavaFileObject source1 = new TestBuilder().build().selectName(seenNames); assertThat(source1.toUri().toString()).endsWith( "/org/inferred/freebuilder/processor/source/testing/generatedcode/TestBuilderTest.java"); JavaFileObject source2 = new TestBuilder().build().selectName(seenNames); assertThat(source2.toUri().toString()).endsWith("TestBuilderTest__2.java"); assertEquals(2, seenNames.size()); }
public FileObject getFileObject() { try { return URLMapper.findFileObject(getController().getCompilationUnit().getSourceFile().toUri().toURL()); } catch (MalformedURLException ex) { Exceptions.printStackTrace(ex); } return null; }
private boolean writeJavaFile(JavaFile javaFile) { StringBuilder builder = new StringBuilder(); JavaFileObject filerSourceFile = null; try { builder.append(LICENSE_HEADER); javaFile.writeTo(builder); String fileName = javaFile.packageName.isEmpty() ? javaFile.typeSpec.name : javaFile.packageName + "." + javaFile.typeSpec.name; List<Element> originatingElements = javaFile.typeSpec.originatingElements; filerSourceFile = mFiler.createSourceFile(fileName, originatingElements.toArray(new Element[0])); try (Writer writer = filerSourceFile.openWriter()) { writer.write(builder.toString()); } return true; } catch (Exception e) { mMessager.printMessage(Diagnostic.Kind.ERROR, "Couldn't generate classes " + javaFile.packageName + '.' + javaFile.typeSpec.name); e.printStackTrace(); if (filerSourceFile != null) { filerSourceFile.delete(); } return false; } }
private void generateBinder(Set<String> erasedTargetNames, List<? extends Element> elements, Element hostElement) throws IOException { PackageElement packageElement = processingEnv.getElementUtils().getPackageOf(hostElement); final String simpleClassName = binderName(hostElement.getSimpleName().toString()); final String qualifiedClassName = packageElement.getQualifiedName() + "." + simpleClassName; JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile( qualifiedClassName, elements.toArray(new Element[elements.size()])); ClassName hostElementName = ClassName.bestGuess(hostElement.getSimpleName().toString()); MethodSpec bindMethod = MethodSpec.methodBuilder(METHOD_BIND_NAME) .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .returns(void.class) .addParameter(hostElementName, METHOD_BIND_ARGUMENT_NAME) .addCode(generateBindMethod(erasedTargetNames, hostElement, elements)) .build(); TypeSpec classType = TypeSpec.classBuilder(simpleClassName) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .addMethod(bindMethod) .build(); final Writer writer = sourceFile.openWriter(); JavaFile.builder(packageElement.getQualifiedName().toString(), classType) .build() .writeTo(writer); writer.close(); }
@Test public void testFailuresSuppressed() throws IOException { Writer mockWriter = Mockito.mock(Writer.class); doThrow(new IOException("Error appending")).when(mockWriter).append(any()); doThrow(new IOException("Error closing")).when(mockWriter).close(); when(sourceFile.openWriter()).thenReturn(mockWriter); thrown.expect(IOException.class); thrown.expectMessage("Error appending"); thrown.expect(suppressed(instanceOf(IOException.class))); thrown.expect(suppressed(hasProperty("message", equalTo("Error closing")))); FilerUtils.writeCompilationUnit(filer, unit, originatingElement); }