update

pom.xml

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.bsc.processor</groupId>
+  <artifactId>java2ts-processor</artifactId>
+  <version>1.0.0-SNAPSHOT</version>
+  <build>
+    <finalName>java2ts-processor</finalName>
+  </build>
+  <properties>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.12</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.reactivex.rxjava2</groupId>
+      <artifactId>rxjava</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>edu.washington.cs.types.jsr308</groupId>
+      <artifactId>jsr308-compiler</artifactId>
+    </dependency>
+  </dependencies>
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>io.reactivex.rxjava2</groupId>
+        <artifactId>rxjava</artifactId>
+        <version>2.0.6</version>
+      </dependency>
+      <dependency>
+        <groupId>edu.washington.cs.types.jsr308</groupId>
+        <artifactId>jsr308-compiler</artifactId>
+        <version>1.7.5</version>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+</project>

src/main/java/org/bsc/processor/AbstractProcessorEx.java

@@ -0,0 +1,132 @@
+package org.bsc.processor;
+
+import io.reactivex.Observable;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.Filer;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic.Kind;
+import javax.tools.FileObject;
+import javax.tools.StandardLocation;
+
+/**
+ * 
+ * @author bsoorentino
+ */
+public abstract class AbstractProcessorEx extends AbstractProcessor {
+
+        /**
+         * 
+         */
+	public class Context {
+
+            public final Set<? extends TypeElement> annotations;
+            public final RoundEnvironment roundEnv;
+
+            /**
+             * 
+             * @param annotations
+             * @param roundEnv
+             */
+            public Context( Set<? extends TypeElement> annotations,
+                            RoundEnvironment roundEnv ) 
+            {
+                    this.annotations    = annotations;
+                    this.roundEnv       = roundEnv;
+            }
+
+            /**
+             * 
+             * @return 
+             */
+            public final com.sun.source.util.Trees getTrees() {
+                return com.sun.source.util.Trees.instance(processingEnv);
+            }
+
+            /**
+             * 
+             * @return 
+             */
+            public final java.util.Map<String, String> getOptionMap() {
+                return processingEnv.getOptions();
+            }
+
+            /**
+             * 
+             * @return 
+             */
+            public Observable<? extends Element> rxElementFromAnnotations() {
+
+                    return Observable
+                            .fromIterable(annotations)
+                            .flatMap( (e) -> Observable.fromIterable(roundEnv.getElementsAnnotatedWith(e) ))
+                                ;
+            }
+        }
+
+    	protected void info(String fmt, Object...args) {
+		final String msg = java.lang.String.format( fmt, (Object[])args);
+		processingEnv.getMessager().printMessage(Kind.NOTE, msg );
+	}
+
+	protected void warn(String fmt, Object...args) {
+		final String msg = java.lang.String.format( fmt, (Object[])args);
+		processingEnv.getMessager().printMessage(Kind.WARNING, msg);
+	}
+
+	protected void warn(String msg, Throwable t) {
+		processingEnv.getMessager().printMessage(Kind.WARNING, msg);
+		t.printStackTrace(System.err);
+	}
+
+	protected void error(String fmt, Object...args) {
+		final String msg = java.lang.String.format( fmt, (Object[])args);
+		processingEnv.getMessager().printMessage(Kind.ERROR, msg);
+	}
+
+	protected void error(String msg, Throwable t) {
+		processingEnv.getMessager().printMessage(Kind.ERROR, msg );
+		t.printStackTrace(System.err);
+	}
+
+
+	/**
+	 * @filer
+	 * @param subfolder subfolder (e.g. confluence)
+	 * @param filePath  relative path (e.g. children/file.wiki)
+	 * @return
+	 * @throws IOException
+	 */
+	protected FileObject getSourceOutputFile( Filer filer, 
+                                            Path subfolder,
+                                            Path filePath) throws IOException 
+        {
+
+		Element e = null;
+		final FileObject res = 
+                        filer.createResource(
+                                StandardLocation.SOURCE_OUTPUT,
+				subfolder.toString(), 
+                                filePath.toString(), 
+                                e);
+		return res;
+	}
+
+    @Override
+    public final boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+        if (roundEnv.processingOver())
+                return false;
+
+        final Context processinContext = new Context( annotations, roundEnv );
+
+        return process( processinContext );
+    }
+
+    public abstract boolean process( Context processingContext );
+
+}

src/main/java/org/bsc/processor/TypescriptProcessor.java

@@ -0,0 +1,60 @@
+package org.bsc.processor;
+
+import io.reactivex.Observable;
+import io.reactivex.functions.Function;
+import java.util.List;
+import java.util.Set;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+
+/**
+ * 
+ * @author bsoorentino
+ */
+public class TypescriptProcessor extends AbstractProcessorEx {
+
+    /**
+     *
+     * @param processingContext
+     * @return
+     */
+    @Override
+    public boolean process( Context processingContext ) {
+
+        return true;
+    }
+
+    private Observable<Class<?>> rxEnumerateDeclaredPackageAndClass( final Context processingContext ) {
+
+        final  Observable<Class<?>> result = processingContext.rxElementFromAnnotations()
+            .doOnNext((e) -> info( "Anotation [%s]", e.getKind().name()) )
+            .filter( (e) -> ElementKind.PACKAGE==e.getKind() || ElementKind.CLASS==e.getKind() )
+            .flatMap( (e) -> Observable.fromIterable(e.getAnnotationMirrors()) ) 
+            .doOnNext((m) -> info( "Mirror [%s]", m.toString() ))
+            .flatMap( (am) -> Observable.fromIterable(am.getElementValues().entrySet() ))
+            .filter( (entry) -> "declare".equals(String.valueOf(entry.getKey().getSimpleName())) )
+            .flatMap( (entry) -> {
+                final AnnotationValue av =  entry.getValue();
+                return Observable.fromIterable((List<? extends AnnotationValue>)av.getValue());
+            })
+            .map( (av) -> av.getValue() )
+            .doOnNext((av) -> info( "AnnotationValue [%s]",av) )
+            .ofType(DeclaredType.class)
+            .doOnNext((dt) -> info( "DeclaredType [%s]",dt) )
+            .onExceptionResumeNext(Observable.empty())
+             .map((DeclaredType dt) -> {
+                try {
+                    return Class.forName(dt.toString());
+                } catch (ClassNotFoundException e1) {
+                    error( "class not found [%s]",dt );
+                    throw new RuntimeException(String.format("class not found [%s]",dt), e1); 
+                }
+            });
+
+            return result;
+    }    
+
+}