source: java2python/src/test/java/tudelft/utilities/j2p/t/PyTest.java@ 383

package tudelft.utilities.j2p.t;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ParseResult;
import com.github.javaparser.ParserConfiguration;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.symbolsolver.JavaSymbolSolver;
import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;

import tudelft.utilities.j2p.formatting.Block;
import tudelft.utilities.pyrunner.Call;
import tudelft.utilities.pyrunner.PythonError;
import tudelft.utilities.pyrunner.PythonVenv;

public class PyTest {
        private static final String TESTFILE = "test.py";
        private static final File TESTDIR = new File("test/");

        /**
         * Run the program as plain file. Installs are ignored so only usable if the
         * code only uses basic system calls
         * 
         * @param pycode       the python code to run.
         * @param fullclaspath a "package/class/path/filename.py" name containing
         *                     the full filename where the file should be placed.
         *                     This must be a RELATIVE name, we will prefix it with
         *                     {@link #TESTDIR} as needed
         * @return the text lines that the code printed to stdout.
         * @throws Exception
         */
        public List<String> runPython(Block pycode, String fullclaspath)
                        throws Exception {
                TESTDIR.delete();
                File f = TESTDIR.toPath().resolve(fullclaspath).toFile();
                System.out.println(f);
                f.getParentFile().mkdirs();// create dir, massaging java...
                FileOutputStream fos = new FileOutputStream(f);
                BufferedOutputStream bos = new BufferedOutputStream(fos);
                // convert string to byte array
                byte[] bytes = pycode.toCode(
                                "from " + fullclaspath.replace("/", "\\.").replace(".py", "")
                                                + " import .*")
                                .getBytes();
                // write byte array to file
                bos.write(bytes);
                bos.close();
                fos.close();

                Process process = Runtime.getRuntime().exec("python " + fullclaspath,
                                new String[0], TESTDIR);
                List<String> errors = readAll(process.getErrorStream());
                if (!errors.isEmpty())
                        throw new IllegalStateException("Python failed. " + errors);

                return readAll(process.getInputStream());
        }

        private List<String> readAll(InputStream in) throws IOException {
                BufferedReader Buffered_Reader = new BufferedReader(
                                new InputStreamReader(in));
                List<String> lines = new LinkedList<>();

                String line;
                while ((line = Buffered_Reader.readLine()) != null) {
                        lines.add(line);
                }
                return lines;
        }

        /**
         * 
         * @param pycode       the python code to be zipped as pip-installable zip.
         *                     It is assumed that the code is just 1 file.
         * @param fullpathname the java file that was translated..
         * @return a zip {@link File} containing all the code, as a python tar.gz
         *         package that can be pip install'ed .
         * @throws IOException
         * @throws PythonError          if python code to build tar.gz fails for
         *                              some reason
         * @throws InterruptedException
         */
        public File zip(Block pycode, File fullpathname)
                        throws IOException, InterruptedException, PythonError {

                Path tmppath = Files.createTempDirectory("j2p");
                System.out.println(tmppath);

                String baremodule = fullpathname.getPath().replace(".java", "");
                String modulename = baremodule + ".py";
                String version = "1";

                // write the translated file
                File f = tmppath.resolve(modulename).toFile();
                f.getParentFile().mkdirs();// create dirs
                FileOutputStream fos = new FileOutputStream(f);
                BufferedOutputStream bos = new BufferedOutputStream(fos);
                // convert string to byte array
                byte[] bytes = pycode
                                .toCode("from " + baremodule.replace("/", ".") + " import .*")
                                .getBytes();
                // write byte array to file
                bos.write(bytes);
                bos.close();
                fos.close();

                String zipname = fullpathname.getName().replace(".java", "");

                List<String> requirements = pycode.getInstalls().stream()
                                .map(str -> "\"" + str + "\"").toList();
                // we must provide many nonsense fields like url and author to get this
                // working...
                String setuppy = "from setuptools import setup, find_packages\n" + "\n"
                                + "setup(\n" + "    name='" + zipname + "',\n" + "    version="
                                + version + ",\n" + "    author='Whatever',\n"
                                + "    author_email='Whatever',\n"
                                + "    url='http://nonsense',\n" + "    py_modules=['"
                                + baremodule + "'],\n" + "    install_requires=" + requirements
                                + ",\n" + "\n" + "    classifiers=[\n"
                                + "        'Programming Language :: Python :: 3.8',\n"
                                + "        'Programming Language :: Python :: 3.9'\n"
                                + "    ],\n" + ")\n" + "";

                f = tmppath.resolve("setup.py").toFile();
                FileWriter fw = new FileWriter(f);
                fw.write(setuppy);
                fw.close();

                // without readme, python complains
                f = tmppath.resolve("README").toFile();
                fw = new FileWriter(f);
                fw.write("");
                fw.close();

                // call python to build the package to be sure we have a correct package
                new Call(PythonVenv.PYTHON3, Arrays.asList("setup.py", "sdist"), 30000,
                                tmppath.toFile()).run();

                // -1 is the version number added py setup.py to the file
                return tmppath.resolve("dist/" + zipname + "-" + version + ".tar.gz")
                                .toFile();
        }

        /**
         * @param javaFile a java file name to be translated
         * @return a string containing python code translated from the java.
         * @throws FileNotFoundException
         */
        public Block translate(String javaFile) throws FileNotFoundException {
                ParserConfiguration conf = new ParserConfiguration();
                CombinedTypeSolver typeSolver = new CombinedTypeSolver();
                typeSolver.add(new ReflectionTypeSolver(false));
                // FIXME add sources of jars source code etc
                // typeSolver.add(new JavaParserTypeSolver(new File(SOURCE_PATH)));
                // typeSolver.add(new JarTypeSolver(jarSourceFile));
                JavaSymbolSolver symbolSolver = new JavaSymbolSolver(typeSolver);
                conf.setSymbolResolver(symbolSolver);
                JavaParser parser = new JavaParser(conf);

                ParseResult<CompilationUnit> res = parser.parse(new File(javaFile));
//              fixparseissues(res.getResult().get());

                Block translation = Translator.translate(res.getResult().get());
                return translation;
        }

}