[java-source-utils] Add response file support (#744)

Add support for ["response files"][0] to `java-source-utils.jar`,
allowing `java-source-utils.jar` options to be present within a plain-
text file, and the file provided as an option:
$ cat >response-file <<EOF
--help
EOF
$ java -jar java-source-utils.jar @response-file
# equivalent to: java -jar java-source-utils.jar --help
In this case, the "scare quotes" is because of limitations when
parsing the response file: only one value per line. Blank lines are
ignored, as are lines starting with `#`.
Thus, a response file with contents:
--source
/path/to/source/directory
is fine, while a response file with the contents:
--source /path/to/source/directory
will not be parsed properly.
[0]: https://docs.microsoft.com/en-us/windows/win32/midl/response-files

Author: jonpryor

tools/java-source-utils/src/main/java/com/microsoft/android/JavaSourceUtilsOptions.java

@@ -10,8 +10,10 @@
 importjava.util.Comparator;
 importjava.util.Enumeration;
 importjava.util.HashSet;
+importjava.util.Iterator;
 importjava.util.List;
 importjava.util.ArrayList;
+importjava.util.Arrays;
 importjava.util.zip.ZipEntry;
 importjava.util.zip.ZipFile;
 
@@ -40,7 +42,8 @@
 publicclassJavaSourceUtilsOptionsimplementsAutoCloseable {
 publicstaticfinalStringHELP_STRING = "[-v] [<-a|--aar> AAR]* [<-j|--jar> JAR]* [<-s|--source> DIRS]*\n" +
 "\t[--bootclasspath CLASSPATH]\n" +
-"\t[<-P|--output-params> OUT.params.txt] [<-D|--output-javadoc> OUT.xml] FILES";
+"\t[<-P|--output-params> OUT.params.txt] [<-D|--output-javadoc> OUT.xml]\n" +
+"\t[@RESPONSE-FILE]* FILES";
 
 publicstaticbooleanverboseOutput;
 
@@ -111,14 +114,15 @@ private final TypeSolver createTypeSolver(ParserConfiguration config) throws IOE
 returntypeSolver;
 	}
 
-publicstaticJavaSourceUtilsOptionsparse(finalString[] args) throwsIOException {
-finalJavaSourceUtilsOptionsoptions = newJavaSourceUtilsOptions();
+privatefinalJavaSourceUtilsOptionsparse(Iterator<String> args) throwsIOException {
+if (args == null || !args.hasNext())
+returnthis;
 
-for (inti = 0; i < args.length; ++i) {
-finalStringarg= args[i];
+while (args.hasNext()) {
+Stringarg = args.next();
 switch (arg) {
 case"-bootclasspath": {
-finalStringbootClassPath = getOptionValue(args, ++i, arg);
+finalStringbootClassPath = getNextOptionValue(args, arg);
 finalArrayList<File> files = newArrayList<File>();
 for (finalStringcp : bootClassPath.split(File.pathSeparator)) {
 finalFilefile = newFile(cp);
@@ -129,46 +133,46 @@ public static JavaSourceUtilsOptions parse(final String[] args) throws IOExcepti
 files.add(file);
  }
 for (intj = files.size(); j > 0; --j) {
-options.jarFiles.add(0, files.get(j-1));
+jarFiles.add(0, files.get(j-1));
  }
-options.haveBootClassPath = true;
+haveBootClassPath = true;
 break;
  }
 case"-a":
 case"--aar": {
-finalFilefile = getOptionFile(args, ++i, arg);
+finalFilefile = getNextOptionFile(args, arg);
 if (file == null) {
 break;
  }
-options.aarFiles.add(file);
+aarFiles.add(file);
 break;
  }
 case"-j":
 case"--jar": {
-finalFilefile = getOptionFile(args, ++i, arg);
+finalFilefile = getNextOptionFile(args, arg);
 if (file == null) {
 break;
  }
-options.jarFiles.add(file);
+jarFiles.add(file);
 break;
  }
 case"-s":
 case"--source": {
-finalFiledir = getOptionFile(args, ++i, arg);
+finalFiledir = getNextOptionFile(args, arg);
 if (dir == null) {
 break;
  }
-options.sourceDirectoryFiles.add(dir);
+sourceDirectoryFiles.add(dir);
 break;
  }
 case"-D":
 case"--output-javadoc": {
-options.outputJavadocXml = getOptionValue(args, ++i, arg);
+outputJavadocXml = getNextOptionValue(args, arg);
 break;
  }
 case"-P":
 case"--output-params": {
-options.outputParamsTxt = getOptionValue(args, ++i, arg);
+outputParamsTxt = getNextOptionValue(args, arg);
 break;
  }
 case"-v": {
@@ -180,37 +184,63 @@ public static JavaSourceUtilsOptions parse(final String[] args) throws IOExcepti
 returnnull;
  }
 default: {
-finalFilefile = getOptionFile(args, i, "FILES");
-if (file == null)
+if (arg.startsWith("@")) {
+// response file?
+finalStringresponseFileName = arg.substring(1);
+finalFileresponseFile = newFile(responseFileName);
+if (responseFile.exists()) {
+finalIterator<String> lines =
+Files.readAllLines(responseFile.toPath())
+ .stream()
+ .filter(line -> line.length() > 0 && !line.startsWith("#"))
+ .iterator();
+
+finalJavaSourceUtilsOptionsr = parse(lines);
+if (r == null)
+returnnull;
+break;
+ }
+ }
+finalFilefile = newFile(arg);
+if (!file.exists()) {
+System.err.println(App.APP_NAME + ": warning: invalid file path for option `FILES`: " + arg);
 break;
+ }
 
 if (file.isDirectory()) {
-options.sourceDirectoryFiles.add(file);
+sourceDirectoryFiles.add(file);
 Files.walk(file.toPath())
  .filter(f -> Files.isRegularFile(f) && f.getFileName().toString().endsWith(".java"))
  .map(Path::toFile)
- .forEach(f -> options.inputFiles.add(f));
+ .forEach(f -> inputFiles.add(f));
 break;
  }
 if (file.getName().endsWith(".java")) {
-options.inputFiles.add(file);
+inputFiles.add(file);
 break;
  }
 if (!file.getName().endsWith(".jar") && !file.getName().endsWith(".zip")) {
 System.err.println(App.APP_NAME + ": warning: ignoring input file `" + file.getAbsolutePath() +"`.");
 break;
  }
-if (options.extractedTempDir == null) {
-options.extractedTempDir = Files.createTempDirectory("ji-jst").toFile();
+if (extractedTempDir == null) {
+extractedTempDir = Files.createTempDirectory("ji-jst").toFile();
  }
-FiletoDir = newFile(options.extractedTempDir, file.getName());
-options.sourceDirectoryFiles.add(toDir);
-extractTo(file, toDir, options.inputFiles);
+FiletoDir = newFile(extractedTempDir, file.getName());
+sourceDirectoryFiles.add(toDir);
+extractTo(file, toDir, inputFiles);
 break;
  }
  }
  }
-returnoptions;
+returnthis;
+	}
+
+publicstaticJavaSourceUtilsOptionsparse(finalString[] args) throwsIOException {
+finalJavaSourceUtilsOptionsoptions = newJavaSourceUtilsOptions();
+finalIterator<String> a = Arrays.stream(args).iterator();
+
+returnoptions.parse(a);
 	}
 
 privatestaticvoidextractTo(finalFilezipFilePath, finalFiletoDir, finalCollection<File> inputFiles) throwsIOException {
@@ -235,18 +265,18 @@ private static void extractTo(final File zipFilePath, final File toDir, final Co
  }
 	}
 
-staticStringgetOptionValue(finalString[]args, finalintindex, finalStringoption) {
-if (index >= args.length)
+staticStringgetNextOptionValue(finalIterator<String>args, finalStringoption) {
+if (!args.hasNext())
 thrownewIllegalArgumentException(
-"Expected required value for option `" + option + "` at index " + index + ".");
-returnargs[index];
+"Expected required value for option `" + option + "`.");
+returnargs.next();
 	}
 
-staticFilegetOptionFile(finalString[]args, finalintindex, finalStringoption) {
-if (index >= args.length)
+staticFilegetNextOptionFile(finalIterator<String>args, finalStringoption) {
+if (!args.hasNext())
 thrownewIllegalArgumentException(
-"Expected required value for option `" + option + "` at index " + index + ".");
-finalStringfileName = args[index];
+"Expected required value for option `" + option + "`.");
+finalStringfileName = args.next();
 finalFilefile = newFile(fileName);
 if (!file.exists()) {
 System.err.println(App.APP_NAME + ": warning: invalid file path for option `" + option + "`: " + fileName);

tools/java-source-utils/src/test/java/com/microsoft/android/JavaSourceUtilsOptionsTest.java

@@ -3,9 +3,14 @@
  */
 packagecom.microsoft.android;
 
+importjava.io.File;
 importjava.io.IOException;
+importjava.io.*;
 
 importorg.junit.Test;
+
+importjdk.nashorn.internal.AssertsEnabled;
+
 importstaticorg.junit.Assert.*;
 
 publicclassJavaSourceUtilsOptionsTest {
@@ -17,4 +22,52 @@ public class JavaSourceUtilsOptionsTest {
 options = JavaSourceUtilsOptions.parse(newString[]{"-h"});
 assertNull(options);
 	}
+
+@TestpublicvoidtestParse_ResponseFiles() throwsIOException {
+JavaSourceUtilsOptionsoptions;
+
+finalFileresponseFile = File.createTempFile("jsu-test", ".java");
+finalStringresponseFilePath = responseFile.getAbsolutePath();
+
+try (PrintWritercontents = newPrintWriter(responseFile)) {
+contents.println("--help");
+ }
+
+options = JavaSourceUtilsOptions.parse(newString[]{"@" + responseFilePath});
+responseFile.delete();
+assertNull(options);
+
+try (PrintWritercontents = newPrintWriter(responseFile)) {
+contents.println("# aar?");
+contents.println("-a");
+contents.println(responseFilePath);
+contents.println("# jar?");
+contents.println("-j");
+contents.println(responseFilePath);
+contents.println("# source?");
+contents.println("-s");
+contents.println(responseFilePath);
+contents.println("-bootclasspath");
+contents.println(responseFilePath + File.pathSeparator + responseFilePath);
+contents.println("# params output?");
+contents.println("-P");
+contents.println("params.txt");
+contents.println("# xml javadoc output?");
+contents.println("-D");
+contents.println("javadoc.xml");
+contents.println("# comment; FILEs…");
+contents.println(responseFilePath);
+ }
+
+options = JavaSourceUtilsOptions.parse(newString[]{"@" + responseFilePath});
+responseFile.delete();
+
+assertEquals(responseFilePath, options.aarFiles.get(0).getAbsolutePath());
+assertEquals(responseFilePath, options.jarFiles.get(0).getAbsolutePath());
+assertEquals("params.txt", options.outputParamsTxt);
+assertEquals("javadoc.xml", options.outputJavadocXml);
+assertEquals(1, options.inputFiles.size());
+assertEquals(responseFilePath, options.inputFiles.iterator().next().getAbsolutePath());
+assertTrue(options.haveBootClassPath);
+	}
 }