Use --snapshot flag for index-dependency command.

Author: olafurpg

lsif-java/src/main/scala/com/sourcegraph/lsif_java/commands/IndexDependencyCommand.scala

@@ -14,18 +14,29 @@ import com.sourcegraph.lsif_semanticdb.JavaVersion
 import moped.cli.Command
 import moped.cli.CommandParser
 import moped.annotations.DeprecatedName
+import moped.annotations.Hidden
+import com.sourcegraph.io.DeleteVisitor
 
 final case class IndexDependencyCommand(
     @DeprecatedName("target", "Use --output instead", "0.6.10") output: Path =
       Paths.get("maven"),
     index: IndexCommand = IndexCommand(),
+    @Hidden
+    snapshotCommand: SnapshotLsifCommand = SnapshotLsifCommand(),
     dependency: String = "",
-    provided: List[String] = Nil
+    provided: List[String] = Nil,
+    snapshot: Boolean = false
 ) extends Command {
   def app = index.app
   private val absoluteTarget = AbsolutePath
     .of(output, app.env.workingDirectory)
     .resolve(dependency.replace(":", "__"))
+  private val indexTarget =
+    if (!snapshot)
+      absoluteTarget
+    else
+      Files.createTempDirectory("lsif-java-index")
+  private val snapshotTarget = absoluteTarget
   def run(): Int = {
     if (dependency == "") {
       app.reporter.error("dependency can't be empty")
@@ -34,59 +45,78 @@ final case class IndexDependencyCommand(
       val deps = Dependencies
         .resolveDependencies(dependency :: provided, transitive = false)
       deps.sources.headOption match {
+        case None =>
+          app.reporter.error(s"no sources for dependency '$dependency'")
+          1
         case Some(sources) =>
           unzipJar(sources)
           deps.classpath.headOption match {
+            case None =>
+              app.reporter.error(s"no classpath for dependency '$dependency'")
+              1
             case Some(classpath) =>
-              Option(
-                JavaVersion.classfileJvmVersion(classpath).orElse(8)
-              ) match {
-                case Some(jvmVersion) =>
-                  val roundedVersion = JavaVersion
-                    .roundToNearestStableRelease(jvmVersion)
-                  val config =
-                    s"""{"kind":"maven","jvm":"${roundedVersion}","dependencies":["$dependency"]}"""
-                  Files.createDirectories(absoluteTarget)
-                  Files.write(
-                    absoluteTarget.resolve("lsif-java.json"),
-                    config.getBytes(StandardCharsets.UTF_8),
-                    StandardOpenOption.CREATE,
-                    StandardOpenOption.TRUNCATE_EXISTING
-                  )
-                  index
-                    .copy(
-                      buildTool = Some("lsif"),
-                      app = app
-                        .withEnv(app.env.withWorkingDirectory(absoluteTarget))
-                    )
-                    .run()
+              inferJvmVersion(classpath) match {
                 case None =>
                   app
                     .reporter
                     .error(
                       s"failed to infer JVM version for classpath '$classpath'"
                     )
                   1
+                case Some(jvmVersion) =>
+                  val exit = indexJar(jvmVersion)
+                  if (exit == 0 && snapshot) {
+                    try {
+                      snapshotCommand
+                        .copy(
+                          output = snapshotTarget,
+                          app = app
+                            .withEnv(app.env.withWorkingDirectory(indexTarget))
+                        )
+                        .run()
+                    } finally {
+                      Files.walkFileTree(indexTarget, new DeleteVisitor())
+                    }
+                  } else {
+                    exit
+                  }
               }
-            case None =>
-              app.reporter.error(s"no classpath for dependency '$dependency'")
-              1
           }
-        case None =>
-          app.reporter.error(s"no sources for dependency '$dependency'")
-          1
       }
     }
   }
 
+  private def inferJvmVersion(jar: Path): Option[Int] = {
+    Option(JavaVersion.classfileJvmVersion(jar).orElse(8))
+      .map(JavaVersion.roundToNearestStableRelease(_))
+  }
+
+  private def indexJar(jvmVersion: Int): Int = {
+    val config =
+      s"""{"kind":"maven","jvm":"$jvmVersion","dependencies":["$dependency"]}"""
+    Files.createDirectories(indexTarget)
+    Files.write(
+      indexTarget.resolve("lsif-java.json"),
+      config.getBytes(StandardCharsets.UTF_8),
+      StandardOpenOption.CREATE,
+      StandardOpenOption.TRUNCATE_EXISTING
+    )
+    index
+      .copy(
+        buildTool = Some("lsif"),
+        app = app.withEnv(app.env.withWorkingDirectory(indexTarget))
+      )
+      .run()
+  }
+
   private def unzipJar(file: Path): Unit = {
     val jar = new JarFile(file.toFile())
     try {
       val entries = jar.entries()
       while (entries.hasMoreElements()) {
         val entry = entries.nextElement()
         if (!entry.isDirectory()) {
-          val out = absoluteTarget.resolve(entry.getName())
+          val out = indexTarget.resolve(entry.getName())
           Files.createDirectories(out.getParent())
           val in = jar.getInputStream(entry)
           try Files.copy(in, out, StandardCopyOption.REPLACE_EXISTING)

tests/snapshots/src/main/scala/tests/LibrarySnapshotGenerator.scala

@@ -66,40 +66,28 @@ class LibrarySnapshotGenerator extends SnapshotGenerator {
       println(s"indexing library '$name'")
       val providedArguments = provided.flatMap(p => List("--provided", p))
       val targetroot = Files.createTempDirectory("semanticdb-javac")
-      val indexDir = Files.createTempDirectory("semanticdb-javac")
+      val snapshotDir = Files.createTempDirectory("semanticdb-javac")
       runLsifJava(
         List(
           "index-dependency",
+          "--snapshot",
           "--dependency",
           name,
           "--output",
-          indexDir.toString()
+          snapshotDir.toString()
         ) ++ providedArguments
       )
-      val snapshotDir = Files.createTempDirectory("semanticdb-javac")
-      val dumpDir = indexDir.toFile().listFiles().head.toPath
-      val outputDir = snapshotDir.resolve(dumpDir.getFileName())
-      runLsifJava(
-        List(
-          "snapshot-lsif",
-          "--cwd",
-          dumpDir.toString(),
-          "--output",
-          outputDir.toString()
-        )
-      )
+      val root = snapshotDir.toFile().listFiles().head.toPath()
       Files.walkFileTree(
-        outputDir,
+        root,
         new SimpleFileVisitor[Path] {
           override def visitFile(
               file: Path,
               attrs: BasicFileAttributes
           ): FileVisitResult = {
             val print =
               new String(Files.readAllBytes(file), StandardCharsets.UTF_8)
-            val out = context
-              .expectDirectory
-              .resolve(outputDir.relativize(file))
+            val out = context.expectDirectory.resolve(root.relativize(file))
             handler.onSnapshotTest(context, out, () => print)
             super.visitFile(file, attrs)
           }