!7

sS standardCredentials() { ret ""; } // public snippets only

// (transpilation md5, snippetID) => jar file

//static new SerializeComputations<PairS, File> computations;

// transpilation md5 => jar file

static new SerializeComputations<S, File> computations;

static File compileSrcLib(S srcLibID) {

  new CompilerBot2 subBot;

  subBot.dontCompile = true;

  ret assertFileExists(subBot.compileSnippet(srcLibID));

}

html {

  // lock lock; // now using SerializeComputations

  uri = dropPrefixSlash(uri);

  S snippetID = fsI(uri);

  if (!isSnippetPublic(snippetID)) fail("Snippet not public: " + snippetID);

  S transpiledSrc = getServerTranspiled2(snippetID);

  // md5 check (if parameter supplied)

  S md5 = params.get('md5);

  S srcMD5 = md5(transpiledSrc);

  if (md5 != null && !eq(md5, srcMD5)) ret "md5 mismatch";

  bool forceCompilation = eq(params.get("forceCompilation"), "1");

  File jar;

  try {

    jar = computations.get(srcMD5/*, snippetID)*/, -> {

      print("Entering compilation (forceCompilation=" + forceCompilation + ")");

      new CompilerBot2 bot;

      bot.forceCompilation = forceCompilation;

      bot.compileSrcLib = lambda1 compileSrcLib;

      ret bot.compileSnippet(snippetID);

    });

  } catch print e {

    // dexcompile.php can't handle code 500

    ret /*subBot_serve500*/("Error. " + e);

  }

  bool forceRepackage = eq("1", params.get("repackage"));

  bool withLibs = eq("1", params.get("withLibs"));

  bool noCompiler = eq("1", params.get("noCompiler"));

  bool withX30 = eq("1", params.get("withX30"));

  bool noSrc = eq("1", params.get("noSrc"));

  bool dynamicObjectOnly = eq("dynamicObjectOnly", params.get("mode"));

  bool uncompressed = eq("1", params.get("uncompressed"));

  File jar2 = jar;

  if (withLibs) jar2 = appendToBaseFileName(jar2, ".with-libs"); 

  if (noCompiler) jar2 = appendToBaseFileName(jar2, ".no-compiler"); 

  if (dynamicObjectOnly) jar2 = appendToBaseFileName(jar2, ".dynamicObjectOnly"); 

  if (noSrc) jar2 = appendToBaseFileName(jar2, ".noSrc"); 

  if (uncompressed) jar2 = appendToBaseFileName(jar2, ".uncomp"); 

  bool withSrc = !noSrc;

  IPred<S> generalFileFilter = f -> 

       (withSrc || !endsWith(f, ".java"))

    && !startsWith(f, "META-INF/versions/"); // see flatlaf jar

  if (!eq(jar, jar2)) {

    if (fileLength(jar2) <= 22 || forceRepackage) {

      temp var jarOut = zipOutputStream(jar2);

      if (uncompressed) jarOut.setMethod(ZipOutputStream.STORED);

      new Set<S> entries;

      text2zip(jarOut, "source.txt", f2s(jar2));

      zip2zip_collectFiles(jar, jarOut, entries, generalFileFilter);

      if (withLibs) {

        Pair<S, LS> srcAndLibs = extractLibsFromTranspilation(transpiledSrc);

        fOr (S libID : srcAndLibs.b) {

          File fixer = compilerBotDestDir("fixer" + psI(libID) + ".jar");

          if (fileExists(fixer)) {

            println("APPLYING FIXER: " + fixer);

            zip2zip_collectFiles(fixer, jarOut, entries);

          }

          zip2zip_collectFiles(loadLibraryOrSrcLib(libID, lambda1 compileSrcLib), jarOut, entries, generalFileFilter);

        }

      }

      if (withX30)

        zip2zip_collectFiles(pathToJavaxJar(), jarOut, entries);

      else if (noCompiler)

        zip2zip_collectFiles(pathToJavaxJar(), jarOut, entries, name -> !

          startsWithOneOf(name, "org/eclipse/", "META-INF/"));

      else if (dynamicObjectOnly)

        zip2zip_collectFiles(pathToJavaxJar(), jarOut, entries, name -> contains(name, "DynamicObject"));

    }

    jar = jar2;

  }

  print("Serving jar for " + snippetID + ": " + renderFileInfo(jar));

  if (eq(params.get("makeJarOnly"), "1"))

    ret "OK: " + f2s(jar);

  else

    ret subBot_serveFileWithName(jar, psI(snippetID) + ".jar", "application/java-archive");

}