/**
* Finds a {@code imagebundler.properties} file.
*
* <p>This uses a heuristic because in Eclipse we will not know what our working directory is (it
* is wherever Eclipse was started from), so project/workspace-relative paths will not work.
*
* <p>As far as passing in a imagebundler.properties path as a {@code -Afile=path} setting,
* Eclipse also lacks any {@code $ basepath} -type interpolation in its APT key/value pairs (like
* Ant would be able to do). So only fixed values are accepted, meaning an absolute path, which
* would be too tied to any one developer's particular machine.
*
* <p>The one thing the APT API gives us is the CLASS_OUTPUT (e.g. bin/apt). So we start there and
* walk up parent directories looking for {@code imagebundler.properties} files.
*/
private File resolveImageBundlerPropertiesIfExists(Location location) {
// Find a dummy /bin/apt/dummy.txt path to start at
final String dummyPath;
try {
// We don't actually create this, we just want its URI
FileObject dummyFileObject = CurrentEnv.getFiler().getResource(location, "", "dummy.txt");
dummyPath = dummyFileObject.toUri().toString().replaceAll("file:", "");
} catch (IOException e1) {
return null;
}
// Walk up looking for a imagebundler.properties
File current = new File(dummyPath).getParentFile();
while (current != null) {
File possible = new File(current, "imagebundler.properties");
if (possible.exists()) {
return possible;
}
current = current.getParentFile();
}
// Before giving up, try just grabbing it from the current directory
File possible = new File("imagebundler.properties");
if (possible.exists()) {
return possible;
}
// No imagebundler.properties found
return null;
}
/* (non-Javadoc)
* @see javax.tools.JavaFileManager#getJavaFileForOutput(javax.tools.JavaFileManager.Location, java.lang.String, javax.tools.JavaFileObject.Kind, javax.tools.FileObject)
*/
@Override
public JavaFileObject getJavaFileForOutput(
Location location, String className, Kind kind, FileObject sibling) throws IOException {
if (kind != Kind.CLASS && kind != Kind.SOURCE) {
throw new IllegalArgumentException("Invalid kind : " + kind); // $NON-NLS-1$
}
Iterable<? extends File> files = getLocation(location);
if (files == null) {
if (!location.equals(StandardLocation.CLASS_OUTPUT)
&& !location.equals(StandardLocation.SOURCE_OUTPUT))
throw new IllegalArgumentException("Unknown location : " + location); // $NON-NLS-1$
// we will use either the sibling or user.dir
if (sibling != null) {
String normalizedFileName = normalized(className);
int index = normalizedFileName.lastIndexOf('/');
if (index != -1) {
normalizedFileName = normalizedFileName.substring(index + 1);
}
normalizedFileName += kind.extension;
URI uri = sibling.toUri();
URI uri2 = null;
try {
String path = uri.getPath();
index = path.lastIndexOf('/');
if (index != -1) {
path = path.substring(0, index + 1);
path += normalizedFileName;
}
uri2 = new URI(uri.getScheme(), uri.getHost(), path, uri.getFragment());
} catch (URISyntaxException e) {
throw new IllegalArgumentException("invalid sibling"); // $NON-NLS-1$
}
return new EclipseFileObject(className, uri2, kind, this.charset);
} else {
String normalizedFileName = normalized(className);
normalizedFileName += kind.extension;
File f = new File(System.getProperty("user.dir"), normalizedFileName); // $NON-NLS-1$
return new EclipseFileObject(className, f.toURI(), kind, this.charset);
}
}
final Iterator<? extends File> iterator = files.iterator();
if (iterator.hasNext()) {
File file = iterator.next();
String normalizedFileName = normalized(className);
normalizedFileName += kind.extension;
File f = new File(file, normalizedFileName);
return new EclipseFileObject(className, f.toURI(), kind, this.charset);
} else {
throw new IllegalArgumentException("location is empty : " + location); // $NON-NLS-1$
}
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
Set<? extends Element> elements = env.getElementsAnnotatedWith(Struct.class);
for (Element element : elements) {
String pakage = eltUtils.getPackageOf(element).toString();
try {
Struct struct = element.getAnnotation(Struct.class);
String headerRelPath = struct.header();
// yes, this is a hack but there are simple to many bugs in this api.
// e.g.: 6647998
FileObject header = filer.getResource(StandardLocation.SOURCE_PATH, pakage, headerRelPath);
String root = basedir;
File headerFile = null;
if (header.toUri().isAbsolute()) {
headerFile = new File(header.toUri());
root = headerFile.getAbsolutePath();
root = root.substring(0, root.length() - headerFile.getName().length() - 1);
root = root.substring(0, root.length() - pakage.length()) + "../";
} else {
root = System.getProperty("user.dir");
headerFile = new File(root + separator + header.toUri());
}
System.out.println("processing header: " + header.toUri());
generateStructBinding(element, struct, root, pakage, headerFile);
} catch (IOException ex) {
throw new RuntimeException("IOException encountered, run if you can!", ex);
}
}
return true;
}
private void addEntry(JarOutputStream jar, FileObject file) throws IOException {
assert jar != null;
String path = file.toUri().getPath();
while (path.startsWith("/")) {
path = path.substring(1);
}
JarEntry entry = new JarEntry(path);
jar.putNextEntry(entry);
InputStream input = file.openInputStream();
try {
byte[] buffer = new byte[1024];
while (true) {
int read = input.read(buffer);
if (read < 0) {
break;
}
jar.write(buffer, 0, read);
}
jar.closeEntry();
} finally {
input.close();
}
}
@Override
protected void outputResults() throws IOException {
StringBuilder sb = new StringBuilder();
sb.append('[');
String separator = "";
// Components are already sorted.
for (Map.Entry<String, ComponentInfo> entry : components.entrySet()) {
ComponentInfo component = entry.getValue();
sb.append(separator);
outputComponent(component, sb);
separator = ",\n";
}
sb.append(']');
FileObject src = createOutputFileObject(OUTPUT_FILE_NAME);
Writer writer = src.openWriter();
writer.write(sb.toString());
writer.flush();
writer.close();
messager.printMessage(Diagnostic.Kind.NOTE, "Wrote file " + src.toUri());
}
private <M extends Serializable> void resolvedQualified(
TemplateProvider<?> provider, Template<M> template, Element[] elements) {
//
TemplatesMetaModel metaModel = application.getChild(TemplatesMetaModel.KEY);
//
Path.Relative path = template.getRelativePath();
if (classCache.containsKey(path)) {
log.log("Template class " + path + " was found in cache");
return;
}
//
Path.Absolute resolvedPath = metaModel.resolvePath(path);
//
Writer writer = null;
try {
// Template qualified class
FileObject classFile =
application.getProcessingContext().createSourceFile(resolvedPath.getName(), elements);
writer = classFile.openWriter();
writer.append("package ").append(resolvedPath.getDirs()).append(";\n");
writer.append("import ").append(TemplateDescriptor.class.getCanonicalName()).append(";\n");
writer.append("import ").append(TemplatePlugin.class.getCanonicalName()).append(";\n");
writer.append("@").append(Generated.class.getName()).append("({})\n");
writer
.append("@")
.append(juzu.Path.class.getName())
.append("(\"")
.append(path.getValue())
.append("\")\n");
writer
.append("public class ")
.append(path.getRawName())
.append(" extends ")
.append(juzu.template.Template.class.getName())
.append("\n");
writer.append("{\n");
writer.append("@javax.inject.Inject\n");
writer
.append("public ")
.append(path.getRawName())
.append("(")
.append(TemplatePlugin.class.getSimpleName())
.append(" templatePlugin")
.append(")\n");
writer.append("{\n");
writer
.append("super(templatePlugin, \"")
.append(path.getValue())
.append("\"")
.append(", ")
.append(provider.getTemplateStubType().getName())
.append(".class);\n");
writer.append("}\n");
//
writer
.append("public static final ")
.append(TemplateDescriptor.class.getName())
.append(" DESCRIPTOR = new ")
.append(TemplateDescriptor.class.getName())
.append("(")
.append(resolvedPath.getName())
.append(".class,")
.append(provider.getTemplateStubType().getName())
.append(".class")
.append(");\n");
//
String baseBuilderName = juzu.template.Template.Builder.class.getCanonicalName();
if (template.getParameters() != null) {
// Implement abstract method with this class Builder covariant return type
writer.append("public Builder builder() {\n");
writer.append("return new Builder();\n");
writer.append("}\n");
// Covariant return type of with()
writer.append("public Builder with() {\n");
writer.append("return (Builder)super.with();\n");
writer.append("}\n");
// Setters on builders
writer.append("public class Builder extends ").append(baseBuilderName).append("\n");
writer.append("{\n");
for (String paramName : template.getParameters()) {
writer
.append("public Builder ")
.append(paramName)
.append("(Object ")
.append(paramName)
.append(") {\n");
writer.append("set(\"").append(paramName).append("\",").append(paramName).append(");\n");
writer.append("return this;\n");
writer.append(("}\n"));
}
writer.append("}\n");
} else {
// Implement abstract factory method
writer.append("public ").append(baseBuilderName).append(" builder() {\n");
writer.append("return new ").append(baseBuilderName).append("();\n");
writer.append("}\n");
}
// Close class
writer.append("}\n");
//
classCache.put(path, classFile);
//
log.log(
"Generated template class "
+ path
+ " as "
+ classFile.toUri()
+ " with originating elements "
+ Arrays.asList(elements));
} catch (IOException e) {
throw TemplateMetaModel.CANNOT_WRITE_TEMPLATE_CLASS.failure(e, elements[0], path);
} finally {
Tools.safeClose(writer);
}
}
