/** @see #compile(String, String, String, boolean) */
public static boolean compile(
String jarFile, String mainClass, String javaFiles[], boolean allErrors) {
try {
String buildDir = ".build";
JarManager.rmDir(new File(buildDir));
new File(buildDir).mkdirs();
JarManager.jarExtract(Core.javascoolJar(), buildDir, "org/javascool");
for (int i = 0; i < javaFiles.length; i++) {
String file = javaFiles[i];
javaFiles[i] = buildDir + File.separator + file;
JarManager.copyFiles(file, javaFiles[i]);
}
if (!Java2Class.compile(javaFiles, allErrors)) {
return false;
}
String mfFile = buildDir + File.separator + "manifest.jmf";
Pml manifest =
new Pml()
.set("Main-Class", mainClass)
.set("Implementation-URL", "http://javascool.gforge.inria.fr")
.save(mfFile);
JarManager.jarCreate(jarFile, mfFile, buildDir);
JarManager.rmDir(new File(buildDir));
return true;
} catch (IOException e) {
throw new RuntimeException("Erreur d'entrées-sorties à la compilation : " + e);
}
}
/**
* Copie un répertoire/fichier dans un autre en oubliant les svn.
*
* @param srcDir Dossier source.
* @param dstDir Dossier cible.
*/
public static void copyFiles(String srcDir, String dstDir) throws IOException {
if (new File(srcDir).isDirectory()) {
if (!new File(srcDir).getName().equals(".svn")) {
for (String s : FileManager.list(srcDir)) {
String d = dstDir + File.separator + new File(s).getAbsoluteFile().getName();
JarManager.copyFiles(s, d);
}
}
} else {
new File(dstDir).getParentFile().mkdirs();
JarManager.copyStream(new FileInputStream(srcDir), new FileOutputStream(dstDir));
}
}
/**
* Extrait une arborescence d'un jar.
*
* @param jarFile Jarre dont on extrait les fichiers.
* @param destDir Dossier où on déploie les fichiers.
* @param jarEntry Racine des sous-dossiers à extraire. Si null extrait tout les fichiers.
*/
public static void jarExtract(String jarFile, String destDir, String jarEntry) {
try {
ProgletsBuilder.log(
"Extract files from "
+ jarFile
+ " to "
+ destDir
+ ((!jarEntry.isEmpty()) ? " which start with " + jarEntry : ""),
true);
JarFile jf = new JarFile(jarFile);
JarInputStream jip = new JarInputStream(new FileInputStream(jarFile));
jf.entries();
JarEntry je;
while ((je = jip.getNextJarEntry()) != null) {
if ((jarEntry.isEmpty() ? true : je.getName().startsWith(jarEntry))
&& !je.isDirectory()
&& !je.getName().contains("META-INF")) {
File dest = new File(destDir + File.separator + je.getName());
dest.getParentFile().mkdirs();
JarManager.copyStream(jip, new FileOutputStream(dest));
}
}
jip.close();
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
}
/**
* Détruit récursivement un fichier ou répertoire. *
*
* <p>Irréversible: à utiliser avec la plus grande prudence.
*/
public static void rmDir(File dir) {
if (dir.isDirectory()) {
for (File f : dir.listFiles()) {
JarManager.rmDir(f);
}
}
dir.delete();
}
// Ajoute un stream a un jar
private static void copyFileToJar(
File source, JarOutputStream target, File root, String[] jarEntries) throws IOException {
// Teste si la source est dans les fichier à extraire
if (jarEntries != null) {
boolean skip = true;
for (String jarEntry : jarEntries) {
String entry = root.toString() + File.separator + jarEntry;
skip &= !(entry.startsWith(source.toString()) | source.toString().startsWith(entry));
}
if (skip) return;
}
try {
if (source.isDirectory()) {
String name =
source
.getPath()
.replace(root.getAbsolutePath() + File.separator, "")
.replace(File.separator, "/");
if (!name.isEmpty() && (!source.equals(root))) {
if (!name.endsWith("/")) {
name += "/";
}
JarEntry entry = new JarEntry(name);
entry.setTime(source.lastModified());
target.putNextEntry(entry);
target.closeEntry();
}
for (File nestedFile : source.listFiles()) {
JarManager.copyFileToJar(nestedFile, target, root, jarEntries);
}
} else {
JarEntry entry =
new JarEntry(
source
.getPath()
.replace(root.getAbsolutePath() + File.separator, "")
.replace(File.separator, "/"));
entry.setTime(source.lastModified());
target.putNextEntry(entry);
JarManager.copyStream(new BufferedInputStream(new FileInputStream(source)), target);
}
} catch (Throwable e) {
e.printStackTrace(System.out);
throw new IllegalStateException(e);
}
}
/**
* Crée un jar à partir d'une arborescence.
*
* @param jarFile Jar à construire. Elle est détruite avant d'être crée.
* @param mfFile Fichier de manifeste (obligatoire).
* @param srcDir Dossier source avec les fichiers à mettre en jarre.
* @param jarEntries Racine des sous-dossiers à extraire. Si null extrait tout les fichiers.
*/
public static void jarCreate(String jarFile, String mfFile, String srcDir, String[] jarEntries) {
try {
ProgletsBuilder.log("Création du jar " + jarFile, true);
File parent = new File(jarFile).getParentFile();
if (parent != null) {
parent.mkdirs();
}
new File(jarFile).delete();
srcDir = new File(srcDir).getCanonicalPath();
Manifest manifest = new Manifest(new FileInputStream(mfFile));
manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
JarOutputStream target = new JarOutputStream(new FileOutputStream(jarFile), manifest);
JarManager.copyFileToJar(new File(srcDir), target, new File(srcDir), jarEntries);
target.close();
} catch (Exception ex) {
ex.printStackTrace();
throw new RuntimeException(ex);
}
}
/** @see #jarExtract(String, String, String) */
public static void jarExtract(String jarFile, String destDir) {
JarManager.jarExtract(jarFile, destDir, "");
}
/** @see #jarCreate(String, String, String, String[]) */
public static void jarCreate(String jarFile, String mfFile, String srcDir) {
JarManager.jarCreate(jarFile, mfFile, srcDir, null);
}
