feat: adopt google-java-format 1.35.0 and chunk large file lists

Chunk positional .java args into batches of 30 (matching --glob= behaviour)
so xargs invocations with many files do not rely on a single JVM process.

Author: mikehardy

index.js

@@ -14,19 +14,75 @@ const LOCATION = __dirname;
 
 // Glob pattern option name
 const GLOB_OPTION = "--glob=";
+const CHUNK_SIZE = 30;
 
 function errorFromExitCode(exitCode) {
   return new Error(`google-java-format exited with exit code ${exitCode}.`);
 }
 
+function isJavaFile(arg) {
+  return !arg.startsWith("-") && arg.endsWith(".java");
+}
+
+function splitJarArgs(args) {
+  if (args[0] === "-jar") {
+    return {
+      prefix: args.slice(0, 2),
+      rest: args.slice(2),
+    };
+  }
+  return { prefix: [], rest: args };
+}
+
+function splitFlagsAndFiles(args) {
+  const flags = [];
+  const files = [];
+  for (const arg of args) {
+    if (isJavaFile(arg)) files.push(arg);
+    else flags.push(arg);
+  }
+  return { flags, files };
+}
+
+function runSpawn(nativeBinary, args, stdio, done) {
+  const proc = spawn(nativeBinary, args, { stdio: stdio });
+  proc.on("close", function (exit) {
+    if (exit) done(errorFromExitCode(exit));
+    else done();
+  });
+  return proc;
+}
+
+function runChunks(nativeBinary, prefix, flags, files, stdio, done) {
+  const chunks = [];
+  for (let i = 0; i < files.length; i += CHUNK_SIZE) {
+    chunks.push(files.slice(i, i + CHUNK_SIZE));
+  }
+
+  async.series(
+    chunks.map((chunk) => (callback) => {
+      runSpawn(nativeBinary, prefix.concat(flags, chunk), stdio, callback);
+    }),
+    (err) => {
+      if (err) {
+        done(err);
+        return;
+      }
+      if (files.length > 1) {
+        console.log("\n");
+        console.log(
+          `ran google-java-format on ${files.length} ${
+            files.length === 1 ? "file" : "files"
+          }`
+        );
+      }
+      done();
+    }
+  );
+}
+
 /**
  * Starts a child process running the native google-java-format binary.
- *
- * @param file a Vinyl virtual file reference
- * @param enc the encoding to use for reading stdout
- * @param style valid argument to google-java-format's '-style' flag
- * @param done callback invoked when the child process terminates
- * @returns {stream.Readable} the formatted code as a Readable stream
  */
 function googleJavaFormat(file, enc, style, done) {
   let args = [`-style=${style}`, file.path];
@@ -36,22 +92,16 @@ function googleJavaFormat(file, enc, style, done) {
     process.stderr,
   ]);
   if (result) {
-    // must be ChildProcess
     result.stdout.setEncoding(enc);
     return result.stdout;
-  } else {
-    // We shouldn't be able to reach this line, because it's not possible to
-    // set the --glob arg in this function.
-    throw new Error("Can't get output stream when --glob flag is set");
   }
+  throw new Error("Can't get output stream when --glob flag is set");
 }
 
 /**
  * Spawn the google-java-format binary with given arguments.
  */
 function spawnGoogleJavaFormat(args, done, stdio) {
-  // WARNING: This function's interface should stay stable across versions for the cross-version
-  // loading below to work.
   let nativeBinary;
 
   try {
@@ -62,91 +112,43 @@ function spawnGoogleJavaFormat(args, done, stdio) {
   }
 
   if (args.find((a) => a === "-version" || a === "--version")) {
-    // Print our version.
-    // This makes it impossible to format files called '-version' or '--version'. That's a feature.
-    // minimist & Co don't support single dash args, which we need to match binary google-java-format.
     console.log(`google-java-format NPM version ${VERSION} at ${LOCATION}`);
     args = ["--version"];
   }
 
-  // Add the library in, with java 16 compat
   args = [
     "-jar",
     `${LOCATION}/lib/google-java-format-1.35.0-all-deps.jar`,
   ].concat(args);
 
-  // extract glob, if present
   const filesGlob = getGlobArg(args);
-
   if (filesGlob) {
-    // remove glob from arg list
     args = args.filter((arg) => arg.indexOf(GLOB_OPTION) === -1);
-
     const files = globSync(filesGlob);
+    const { prefix, rest } = splitJarArgs(args);
+    const { flags } = splitFlagsAndFiles(rest);
+    runChunks(nativeBinary, prefix, flags, files, stdio, done);
+    return;
+  }
 
-    // split file array into chunks of 30
-    let i,
-      j,
-      chunks = [],
-      chunkSize = 30;
-
-    for (i = 0, j = files.length; i < j; i += chunkSize) {
-      chunks.push(files.slice(i, i + chunkSize));
-    }
+  const { prefix, rest } = splitJarArgs(args);
+  const { flags, files } = splitFlagsAndFiles(rest);
 
-    // launch a new process for each chunk
-    async.series(
-      chunks.map(function (chunk) {
-        return function (callback) {
-          const googlejavaFormatProcess = spawn(
-            nativeBinary,
-            args.concat(chunk),
-            { stdio: stdio }
-          );
-          googlejavaFormatProcess.on("close", function (exit) {
-            if (exit !== 0) callback(errorFromExitCode(exit));
-            else callback();
-          });
-        };
-      }),
-      function (err) {
-        if (err) {
-          done(err);
-          return;
-        }
-        console.log("\n");
-        console.log(
-          `ran google-java-format on ${files.length} ${
-            files.length === 1 ? "file" : "files"
-          }`
-        );
-        done();
-      }
-    );
-  } else {
-    const googlejavaFormatProcess = spawn(nativeBinary, args, { stdio: stdio });
-    googlejavaFormatProcess.on("close", function (exit) {
-      if (exit) {
-        done(errorFromExitCode(exit));
-      } else {
-        done();
-      }
-    });
-    return googlejavaFormatProcess;
+  if (files.length > CHUNK_SIZE) {
+    runChunks(nativeBinary, prefix, flags, files, stdio, done);
+    return;
   }
+
+  return runSpawn(nativeBinary, prefix.concat(flags, files), stdio, done);
 }
 
 function main() {
-  // Find google-java-format in node_modules of the project of the .js file, or cwd.
   const nonDashArgs = process.argv.filter(
     (arg, idx) => idx > 1 && arg[0] != "-"
   );
 
-  // Using the last file makes it less likely to collide with google-java-format's argument parsing.
   const lastFileArg = nonDashArgs[nonDashArgs.length - 1];
-  const basedir = lastFileArg
-    ? path.dirname(lastFileArg) // relative to the last .js file given.
-    : process.cwd(); // or relative to the cwd()
+  const basedir = lastFileArg ? path.dirname(lastFileArg) : process.cwd();
   let resolvedGoogleJavaFormat;
   let googleJavaFormatLocation;
   try {
@@ -155,6 +157,7 @@ function main() {
   } catch (e) {
     // Ignore and use the google-java-format that came with this package.
   }
+
   let actualSpawnFn;
   if (!resolvedGoogleJavaFormat) {
     actualSpawnFn = spawnGoogleJavaFormat;
@@ -165,9 +168,8 @@ function main() {
       `Incompatible google-java-format loaded from ${googleJavaFormatLocation}`
     );
   }
-  // Run google-java-format.
+
   try {
-    // Pass all arguments to google-java-format, including e.g. -version etc.
     actualSpawnFn(
       process.argv.slice(2),
       function (e) {
@@ -186,25 +188,14 @@ function main() {
   }
 }
 
-/**
- * @returns the native `java` binary for the current platform
- * @throws when the `java` executable can not be found
- */
 function getNativeBinary() {
   let nativeBinary = "java";
-  const platform = os.platform();
-  const arch = os.arch();
-  if (platform === "win32") {
+  if (os.platform() === "win32") {
     nativeBinary = "java.exe";
   }
   return nativeBinary;
 }
 
-/**
- * Filters the arguments to return the value of the `--glob=` option.
- *
- * @returns The value of the glob option or null if not found
- */
 function getGlobArg(args) {
   const found = args.find((a) => a.startsWith(GLOB_OPTION));
   return found ? found.substring(GLOB_OPTION.length) : null;