src/Pure/Admin/build_release.scala

 */
 
 package isabelle
 
 
-object Build_Release
-{
+object Build_Release {
   /** release context **/
 
   private def execute(dir: Path, script: String): Unit =
     Isabelle_System.bash(script, cwd = dir.file).check
 

     Isabelle_System.gnutar(args, dir = dir, strip = strip).check
 
   private def bash_java_opens(args: String*): String =
     Bash.strings(args.toList.flatMap(arg => List("--add-opens", arg + "=ALL-UNNAMED")))
 
-  object Release_Context
-  {
+  object Release_Context {
     def apply(
       target_dir: Path,
       release_name: String = "",
       components_base: Path = Components.default_components_base,
-      progress: Progress = new Progress): Release_Context =
-    {
+      progress: Progress = new Progress
+    ): Release_Context = {
       val date = Date.now()
       val dist_name = proper_string(release_name) getOrElse ("Isabelle_" + Date.Format.date(date))
       val dist_dir = (target_dir + Path.explode("dist-" + dist_name)).absolute
       new Release_Context(release_name, dist_name, dist_dir, components_base, progress)
     }

   class Release_Context private[Build_Release](
     val release_name: String,
     val dist_name: String,
     val dist_dir: Path,
     val components_base: Path,
-    val progress: Progress)
-  {
+    val progress: Progress
+  ) {
     override def toString: String = dist_name
 
     val isabelle: Path = Path.explode(dist_name)
     val isabelle_dir: Path = dist_dir + isabelle
     val isabelle_archive: Path = dist_dir + isabelle.tar.gz

     def other_isabelle(dir: Path): Other_Isabelle =
       Other_Isabelle(dir + isabelle,
         isabelle_identifier = dist_name + "-build",
         progress = progress)
 
-    def make_announce(id: String): Unit =
-    {
+    def make_announce(id: String): Unit = {
       if (release_name.isEmpty) {
         File.write(isabelle_dir + Path.explode("ANNOUNCE"),
           """
 IMPORTANT NOTE
 ==============

 This is a snapshot of Isabelle/""" + id + """ from the repository.
 """)
       }
     }
 
-    def make_contrib(): Unit =
-    {
+    def make_contrib(): Unit = {
       Isabelle_System.make_directory(Components.contrib(isabelle_dir))
       File.write(Components.contrib(isabelle_dir, name = "README"),
         """This directory contains add-on components that contribute to the main
 Isabelle distribution.  Separate licensing conditions apply, see each
 directory individually.

   }
 
   sealed case class Bundle_Info(
     platform: Platform.Family.Value,
     platform_description: String,
-    name: String)
-  {
+    name: String
+  ) {
     def path: Path = Path.explode(name)
   }
 
 
 

   val ISABELLE: Path = Path.basic("Isabelle")
   val ISABELLE_ID: Path = Path.explode("etc/ISABELLE_ID")
   val ISABELLE_TAGS: Path = Path.explode("etc/ISABELLE_TAGS")
   val ISABELLE_IDENTIFIER: Path = Path.explode("etc/ISABELLE_IDENTIFIER")
 
-  object Release_Archive
-  {
-    def make(bytes: Bytes, rename: String = ""): Release_Archive =
-    {
+  object Release_Archive {
+    def make(bytes: Bytes, rename: String = ""): Release_Archive = {
       Isabelle_System.with_tmp_dir("tmp")(dir =>
-        Isabelle_System.with_tmp_file("archive", ext = "tar.gz")(archive_path =>
-        {
+        Isabelle_System.with_tmp_file("archive", ext = "tar.gz")(archive_path => {
           val isabelle_dir = Isabelle_System.make_directory(dir + ISABELLE)
 
           Bytes.write(archive_path, bytes)
           execute_tar(isabelle_dir, "-xzf " + File.bash_path(archive_path), strip = 1)
 

     }
 
     def read(path: Path, rename: String = ""): Release_Archive =
       make(Bytes.read(path), rename = rename)
 
-    def get(url: String, rename: String = "", progress: Progress = new Progress): Release_Archive =
-    {
+    def get(
+      url: String,
+      rename: String = "",
+      progress: Progress = new Progress
+    ): Release_Archive = {
       val bytes =
         if (Path.is_wellformed(url)) Bytes.read(Path.explode(url))
         else Isabelle_System.download(url, progress = progress).bytes
       make(bytes, rename = rename)
     }
   }
 
   case class Release_Archive private[Build_Release](
-    bytes: Bytes, id: String, tags: String, identifier: String)
-  {
+    bytes: Bytes, id: String, tags: String, identifier: String) {
     override def toString: String = identifier
   }
 
 
 
   /** generated content **/
 
   /* bundled components */
 
-  class Bundled(platform: Option[Platform.Family.Value] = None)
-  {
+  class Bundled(platform: Option[Platform.Family.Value] = None) {
     def detect(s: String): Boolean =
       s.startsWith("#bundled") && !s.startsWith("#bundled ")
 
     def apply(name: String): String =
       "#bundled" + (platform match { case None => "" case Some(plat) => "-" + plat }) + ":" + name

         case Pattern2(Platform.Family(plat), name) if platform == Some(plat) => Some(name)
         case _ => None
       }
   }
 
-  def record_bundled_components(dir: Path): Unit =
-  {
+  def record_bundled_components(dir: Path): Unit = {
     val catalogs =
       List("main", "bundled").map((_, new Bundled())) :::
       Platform.Family.list.flatMap(platform =>
         List(platform.toString, "bundled-" + platform.toString).
           map((_, new Bundled(platform = Some(platform)))))

           line <- split_lines(File.read(path))
           if line.nonEmpty && !line.startsWith("#")
         } yield bundled(line)).toList))
   }
 
-  def get_bundled_components(dir: Path, platform: Platform.Family.Value): (List[String], String) =
-  {
+  def get_bundled_components(dir: Path, platform: Platform.Family.Value): (List[String], String) = {
     val Bundled = new Bundled(platform = Some(platform))
     val components =
       for { Bundled(name) <- Components.read_components(dir) } yield name
     val jdk_component =
       components.find(_.startsWith("jdk")) getOrElse error("Missing jdk component")
     (components, jdk_component)
   }
 
   def activate_components(
-    dir: Path, platform: Platform.Family.Value, more_names: List[String]): Unit =
-  {
+    dir: Path, platform: Platform.Family.Value, more_names: List[String]): Unit = {
     def contrib_name(name: String): String =
       Components.contrib(name = name).implode
 
     val Bundled = new Bundled(platform = Some(platform))
     Components.write_components(dir,

 
   private def build_heaps(
     options: Options,
     platform: Platform.Family.Value,
     build_sessions: List[String],
-    local_dir: Path): Unit =
-  {
+    local_dir: Path
+  ): Unit = {
     val server_option = "build_host_" + platform.toString
     val ssh =
       options.string(server_option) match {
         case "" =>
           if (Platform.family == platform) SSH.Local

         case SSH.Target(user, host) =>
           SSH.open_session(options, host = host, user = user)
         case s => error("Malformed option " + server_option + ": " + quote(s))
       }
     try {
-      Isabelle_System.with_tmp_file("tmp", ext = "tar")(local_tmp_tar =>
-      {
+      Isabelle_System.with_tmp_file("tmp", ext = "tar")(local_tmp_tar => {
         execute_tar(local_dir, "-cf " + File.bash_path(local_tmp_tar) + " .")
-        ssh.with_tmp_dir(remote_dir =>
-        {
+        ssh.with_tmp_dir(remote_dir => {
           val remote_tmp_tar = remote_dir + Path.basic("tmp.tar")
           ssh.write_file(remote_tmp_tar, local_tmp_tar)
           val remote_commands =
             List(
               "cd " + File.bash_path(remote_dir),

   }
 
 
   /* Isabelle application */
 
-  def make_isabelle_options(path: Path, options: List[String], line_ending: String = "\n"): Unit =
-  {
+  def make_isabelle_options(path: Path, options: List[String], line_ending: String = "\n"): Unit = {
     val title = "# Java runtime options"
     File.write(path, (title :: options).map(_ + line_ending).mkString)
   }
 
   def make_isabelle_app(
     platform: Platform.Family.Value,
     isabelle_target: Path,
     isabelle_name: String,
     jdk_component: String,
     classpath: List[Path],
-    dock_icon: Boolean = false): Unit =
-  {
+    dock_icon: Boolean = false): Unit = {
     val script = """#!/usr/bin/env bash
 #
 # Author: Makarius
 #
 # Main Isabelle application script.

       isabelle_target + Path.explode(isabelle_name))
     Isabelle_System.rm_tree(component_dir)
   }
 
 
-  def make_isabelle_plist(path: Path, isabelle_name: String, isabelle_rev: String): Unit =
-  {
+  def make_isabelle_plist(path: Path, isabelle_name: String, isabelle_rev: String): Unit = {
     File.write(path, """<?xml version="1.0" ?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
 <key>CFBundleDevelopmentRegion</key>

   /* main */
 
   def use_release_archive(
     context: Release_Context,
     archive: Release_Archive,
-    id: String = ""): Unit =
-  {
+    id: String = ""
+  ): Unit = {
     if (id.nonEmpty && id != archive.id) {
       error("Mismatch of release identification " + id + " vs. archive " + archive.id)
     }
 
     if (!context.isabelle_archive.is_file || Bytes.read(context.isabelle_archive) != archive.bytes) {

   }
 
   def build_release_archive(
     context: Release_Context,
     version: String,
-    parallel_jobs: Int = 1): Unit =
-  {
+    parallel_jobs: Int = 1
+  ): Unit = {
     val progress = context.progress
 
     val hg = Mercurial.repository(Path.ISABELLE_HOME)
     val id =
       try { hg.id(version) }

     platform_families: List[Platform.Family.Value] = default_platform_families,
     more_components: List[Path] = Nil,
     website: Option[Path] = None,
     build_sessions: List[String] = Nil,
     build_library: Boolean = false,
-    parallel_jobs: Int = 1): Unit =
-  {
+    parallel_jobs: Int = 1
+  ): Unit = {
     val progress = context.progress
 
 
     /* release directory */
 

 
     for (path <- List(context.isabelle, ISABELLE)) {
       Isabelle_System.rm_tree(context.dist_dir + path)
     }
 
-    Isabelle_System.with_tmp_file("archive", ext = "tar.gz")(archive_path =>
-    {
+    Isabelle_System.with_tmp_file("archive", ext = "tar.gz")(archive_path => {
       Bytes.write(archive_path, archive.bytes)
       val extract =
         List("README", "NEWS", "ANNOUNCE", "COPYRIGHT", "CONTRIBUTORS", "doc").
           map(name => context.dist_name + "/" + name)
       execute_tar(context.dist_dir,

       val isabelle_name = context.dist_name
       val platform = bundle_info.platform
 
       progress.echo("\nApplication bundle for " + platform)
 
-      Isabelle_System.with_tmp_dir("build_release")(tmp_dir =>
-      {
+      Isabelle_System.with_tmp_dir("build_release")(tmp_dir => {
         // release archive
 
         execute_tar(tmp_dir, "-xzf " + File.bash_path(context.isabelle_archive))
         val other_isabelle = context.other_isabelle(tmp_dir)
         val isabelle_target = other_isabelle.isabelle_home

           yield {
             val s = "-Dapple.awt.application.name="
             if (opt.startsWith(s)) s + isabelle_name else opt
           }) ::: List("-Disabelle.jedit_server=" + isabelle_name)
 
-        val classpath: List[Path] =
-        {
+        val classpath: List[Path] = {
           val base = isabelle_target.absolute
           val classpath1 = Path.split(other_isabelle.getenv("ISABELLE_CLASSPATH"))
           val classpath2 = Path.split(other_isabelle.getenv("ISABELLE_SETUP_CLASSPATH"))
-          (classpath1 ::: classpath2).map(path =>
-          {
+          (classpath1 ::: classpath2).map(path => {
             val abs_path = path.absolute
             File.relative_path(base, abs_path) match {
               case Some(rel_path) => rel_path
               case None => error("Bad classpath element: " + abs_path)
             }

     if (build_library) {
       if (context.isabelle_library_archive.is_file) {
         progress.echo_warning("Library archive already exists: " + context.isabelle_library_archive)
       }
       else {
-        Isabelle_System.with_tmp_dir("build_release")(tmp_dir =>
-          {
+        Isabelle_System.with_tmp_dir("build_release")(tmp_dir => {
             val bundle =
               context.dist_dir + Path.explode(context.dist_name + "_" + Platform.family + ".tar.gz")
             execute_tar(tmp_dir, "-xzf " + File.bash_path(bundle))
 
             val other_isabelle = context.other_isabelle(tmp_dir)

 
 
 
   /** command line entry point **/
 
-  def main(args: Array[String]): Unit =
-  {
+  def main(args: Array[String]): Unit = {
     Command_Line.tool {
       var afp_rev = ""
       var components_base: Path = Components.default_components_base
       var target_dir = Path.current
       var release_name = ""