JAVA.jshell

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.io.InputStream;
import java.util.function.Consumer;
import java.util.concurrent.Future;
import io.github.spencerpark.ijava.IJava;
import io.github.spencerpark.ijava.JavaKernel;
import io.github.spencerpark.jupyter.kernel.magic.registry.UndefinedMagicException;
import com.github.javaparser.StaticJavaParser;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.CompilationUnit;


import javax.tools.JavaFileObject;
import io.github.spencerpark.jupyter.kernel.magic.registry.MagicsArgs;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import javax.tools.StandardJavaFileManager;
import java.util.stream.Collectors;
import io.github.classgraph.ClassGraph;

/**
%%javasrcMethodByAnnotationName Test POST 
/src/Test.java
*/
IJava.getKernelInstance().getMagics().registerCellMagic("javasrcMethodByAnnotationName", (args, body) -> {
    String filename=body;
    String className=args.get(0);
    String annotationName=args.get(1);
    int index=args.size()==3?Integer.valueOf(args.get(2)):0;
    CompilationUnit cu = StaticJavaParser.parse(Files.readString(Path.of(filename)));
            String out = cu.getClassByName(className).get()
                .getMethods()
                .stream()
                .filter(m -> m.getAnnotations().stream().anyMatch(a -> a.getNameAsString().equals(annotationName)))                
                .skip(index)
                .findFirst().get().toString();
     out = "```Java\n"+out+"\n```";
     display(out,"text/markdown");
     return out;
});

/**
%%javasrcMethodByName Test getAll 
/src/Test.java
*/
IJava.getKernelInstance().getMagics().registerCellMagic("javasrcMethodByName", (args, body) -> {
    String filename=body;
    String className=args.get(0);
    String methodName=args.get(1);
    int index=args.size()==3?Integer.valueOf(args.get(2)):0;
    CompilationUnit cu = StaticJavaParser.parse(Files.readString(Path.of(filename)));
            String out = cu.getClassByName(className).get()
                .getMethodsByName(methodName)                
                .get(index)
                .toString();
     out = "```Java\n"+out+"\n```";
     display(out,"text/markdown");
     return out;
});

/**
%%javasrcClassByName Test 
/src/Test.java
*/
IJava.getKernelInstance().getMagics().registerCellMagic("javasrcClassByName", (args, body) -> {
    String filename=body;
    String className=args.get(0);
    CompilationUnit cu = StaticJavaParser.parse(Files.readString(Path.of(filename)));
            String out = cu.getClassByName(className).get()
                .toString();
     out = "```Java\n"+out+"\n```";
     display(out,"text/markdown");
     return out;
});

/**
%%compile fr/univtln/bruno/Test.java
package fr.univtln.bruno;

import lombok.*;           

@Setter
@Getter         
@ToString
@AllArgsConstructor(staticName="of")
@NoArgsConstructor
public class Test {
 private int x;
 private int y;
    private int z;
}
*/
IJava.getKernelInstance().getMagics().registerCellMagic("compile",(args,body)->{
    try{
        //We parse the magics arguments
        MagicsArgs schema=MagicsArgs.builder()
        .required("filePath")
        //.optional("x")
        //.keyword("from", MagicsArgs.KeywordSpec.ONCE)
        //.flag("verbose", 'v',"true")
        .onlyKnownKeywords()
        .onlyKnownFlags()
        .build();
        Map<String, List<String>>params=schema.parse(args);
        //display(params);
        Map<String, List<String>>vals=schema.parse(args);
        
        //We create the tmp dit if necessary
//            File tempDirectory = Files.createTempDirectory("jupyterJava").toFile();
        File tempDirectory=new File("/tmp/jupyterJava");
        String filename = vals.get("filePath").get(0);
        File file=new File(tempDirectory,filename);
        Files.createDirectories(file.getParentFile().toPath());
        BufferedWriter writer=new BufferedWriter(new FileWriter(file));
        writer.write(body);
        writer.close();
        JavaCompiler compiler=ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager fileManager=compiler.getStandardFileManager(null,null,null);
        Iterable<?extends JavaFileObject> compilationUnits1=
        fileManager.getJavaFileObjectsFromFiles(Arrays.asList(new File[]{file}));

        //We use the ClassGraph reflection API
        List<URI> classpath = new ClassGraph().getClasspathURIs();
        List<String> optionList=new ArrayList<String>();
        optionList.addAll(Arrays.asList("-cp",classpath.stream().map(URI::toString).collect(Collectors.joining(":"))));
        optionList.addAll(Arrays.asList("--enable-preview","--release","19"));
        compiler.getTask(null,fileManager,null,optionList,null,compilationUnits1).call();
        //display("Compilation of "+file);
        
        IJava.getKernelInstance().addToClasspath(tempDirectory.toString());
        
        //display("added to classpath "+tempDirectory.toString());
        
        //String className=filename.substring(0,filename.lastIndexOf(".")).replace("/",".");        
        //display("Loading class "+className);
        //ClassLoader parentClassloader=((URLClassLoader)(Thread.currentThread().getContextClassLoader()));
        //Thread.currentThread().setContextClassLoader(URLClassLoader.newInstance(new URL[]{tempDirectory.toURI().toURL()}, parentClassloader));
        //URLClassLoader.newInstance(new URL[]{tempDirectory.toURI().toURL()}, parentClassloader).loadClass(className);
        //parentClassloader.loadClass(className);
        //display("Loaded");
        
    } catch(IOException e){ throw new RuntimeException(e);}
    return "ok";
});