improve the deploy jar creation

scala/scala.bzl

@@ -233,25 +233,27 @@ def _compile_or_empty(ctx, jars, srcjars, buildijar):
     return struct(ijar=ijar, class_jar=ctx.outputs.jar)
 
 def _build_deployable(ctx, jars):
-  cmd = "rm -rf {out}_tmp\n"
-  cmd += "mkdir -p {out}_tmp\n"
-  for jar in jars:
-    cmd += "unzip -o {jar} -d {{out}}_tmp >/dev/null\n".format(jar=jar.path)
-  cmd += "{java} -jar {jar} -m {manifest} {out} {out}_tmp\n"
-  cmd += "rm -rf {out}_tmp\n"
-
-  cmd = cmd.format(
-      out=ctx.outputs.deploy_jar.path,
-      jar=_get_jar_path(ctx.files._jar),
-      java=ctx.file._java.path,
-      manifest=ctx.outputs.manifest.path)
+  # the _jar_bin program we call below expects one optional argument:
+  # -m is the argument to pass a manifest to our jar creation code
+  # the next argument is the path manifest itself
+  # the manifest is set up by methods that call this function (see usages
+  # of _build_deployable and note that they always first call write_manifest).
+  # that is what creates the manifest content
+  #
+  # following the manifest argument and the manifest, the next argument is
+  # the output path for the target jar
+  #
+  # finally all the rest of the arguments are jars to be flattened into one
+  # fat jar
+  args = ["-m", ctx.outputs.manifest.path, ctx.outputs.deploy_jar.path]
+  args.extend([j.path for j in jars])
   ctx.action(
-      inputs=list(jars) + ctx.files._jdk + ctx.files._jar + [ctx.outputs.manifest],
+      inputs=list(jars) + [ctx.outputs.manifest],
       outputs=[ctx.outputs.deploy_jar],
-      command=cmd,
+      executable=ctx.executable._jar_bin,
       mnemonic="ScalaDeployJar",
       progress_message="scala deployable %s" % ctx.label,
-      arguments=[])
+      arguments=args)
 
 def write_manifest(ctx):
   # TODO(bazel-team): I don't think this classpath is what you want
@@ -471,6 +473,7 @@ _implicit_deps = {
   "_java": attr.label(executable=True, default=Label("@bazel_tools//tools/jdk:java"), single_file=True, allow_files=True),
   "_javac": attr.label(executable=True, default=Label("@bazel_tools//tools/jdk:javac"), single_file=True, allow_files=True),
   "_jar": attr.label(executable=True, default=Label("//src/java/io/bazel/rulesscala/jar:jar_deploy.jar"), allow_files=True),
+  "_jar_bin": attr.label(executable=True, default=Label("//src/java/io/bazel/rulesscala/jar")),
   "_jdk": attr.label(default=Label("//tools/defaults:jdk"), allow_files=True),
 }
 

src/java/io/bazel/rulesscala/jar/JarCreator.java

@@ -66,10 +66,13 @@ public boolean addEntry(String entryName, String fileName) {
    *
    * @param directory the directory to add to the jar
    */
-  public void addDirectory(String directory) {
-    addDirectory(null, new File(directory));
+  public void addDirectory(File directory) {
+    addDirectory(null, directory);
   }
 
+  public void addJar(File file) {
+    jarEntries.put(file.getAbsolutePath(), file.getAbsolutePath());
+  }
   /**
    * Adds the contents of a directory to the Jar file. All files below this
    * directory will be added to the Jar file using the prefix and the name
@@ -189,7 +192,14 @@ public static void main(String[] args) {
     JarCreator createJar = new JarCreator(output);
     createJar.setManifestFile(manifestFile);
     for (int i = (idx+1); i < args.length; i++) {
-      createJar.addDirectory(args[i]);
+      String thisName = args[i];
+      File f = new File(thisName);
+      if (JarHelper.isJar(f)) {
+        createJar.addJar(f);
+      }
+      else {
+        createJar.addDirectory(f);
+      }
     }
     createJar.setCompression(true);
     createJar.setNormalize(true);

src/java/io/bazel/rulesscala/jar/JarHelper.java

@@ -16,15 +16,18 @@
 
 import java.io.File;
 import java.io.FileInputStream;
+import java.io.InputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 import java.util.jar.JarOutputStream;
 import java.util.zip.CRC32;
+import java.util.zip.ZipException;
 
 /**
  * A simple helper class for creating Jar files. All Jar entries are sorted alphabetically. Allows
@@ -61,6 +64,10 @@ public JarHelper(String filename) {
     jarFile = filename;
   }
 
+  public static boolean isJar(File file) {
+    return file.getName().endsWith(".jar") && (file.isFile());
+  }
+
   /**
    * Enables or disables the Jar entry normalization.
    *
@@ -170,6 +177,33 @@ protected void writeManifestEntry(byte[] content) throws IOException {
     }
   }
 
+  /**
+   * This copies the contents of jarFile into out
+   * This is a static method to make it clear what is mutated (and it
+   * was written by someone who really likes to minimize state changes).
+   */
+  static private void copyJar(JarFile nameJf, Set<String> names, JarOutputStream out) throws IOException {
+    byte[] buffer = new byte[2048];
+    for (Enumeration<JarEntry> e = nameJf.entries(); e.hasMoreElements();) {
+      JarEntry existing = e.nextElement();
+      String name = existing.getName();
+      if (!names.contains(name)) {
+        JarEntry outEntry = new JarEntry(name);
+        outEntry.setTime(existing.getTime());
+        outEntry.setSize(existing.getSize());
+        out.putNextEntry(outEntry);
+        InputStream in = nameJf.getInputStream(existing);
+        while (0 < in.available()) {
+          int read = in.read(buffer);
+          out.write(buffer, 0, read);
+        }
+        in.close();
+        out.closeEntry();
+        names.add(name);
+      }
+    }
+  }
+
   /**
    * Copies file or directory entries from the file system into the jar.
    * Directory entries will be detected and their names automatically '/'
@@ -189,24 +223,30 @@ protected void copyEntry(String name, File file) throws IOException {
           System.err.println("adding " + file);
         }
         // Create a new entry
-        long size = isDirectory ? 0 : file.length();
-        JarEntry outEntry = new JarEntry(name);
-        long newtime = normalize ? normalizedTimestamp(name) : file.lastModified();
-        outEntry.setTime(newtime);
-        outEntry.setSize(size);
-        if (size == 0L) {
-          outEntry.setMethod(JarEntry.STORED);
-          outEntry.setCrc(0);
-          out.putNextEntry(outEntry);
-        } else {
-          outEntry.setMethod(storageMethod);
-          if (storageMethod == JarEntry.STORED) {
-            outEntry.setCrc(hashFile(file));
+        if (JarHelper.isJar(file)) {
+          JarFile nameJf = new JarFile(file);
+          copyJar(nameJf, names, out);
+        }
+        else {
+          long size = isDirectory ? 0 : file.length();
+          JarEntry outEntry = new JarEntry(name);
+          long newtime = normalize ? normalizedTimestamp(name) : file.lastModified();
+          outEntry.setTime(newtime);
+          outEntry.setSize(size);
+          if (size == 0L) {
+            outEntry.setMethod(JarEntry.STORED);
+            outEntry.setCrc(0);
+            out.putNextEntry(outEntry);
+          } else {
+            outEntry.setMethod(storageMethod);
+            if (storageMethod == JarEntry.STORED) {
+              outEntry.setCrc(hashFile(file));
+            }
+            out.putNextEntry(outEntry);
+            Files.copy(file.toPath(), out);
           }
-          out.putNextEntry(outEntry);
-          Files.copy(file.toPath(), out);
+          out.closeEntry();
         }
-        out.closeEntry();
       }
     }
   }