Add TerminalSizeCache (#118)

Author: alexarchambault

README.md

@@ -50,6 +50,26 @@ int width = size.getWidth();
 int height = size.getHeight();
 ```
 
+If you call this method often, on Unix-es, you might want to use `TerminalSizeCache` instead.
+
+```java
+import io.github.alexarchambault.nativeterm.TerminalSize;
+import io.github.alexarchambault.nativeterm.TerminalSizeCache;
+
+TerminalSize size = TerminalSizeCache.size();
+int width = size.getWidth();
+int height = size.getHeight();
+```
+
+On Unix-es, `TerminalSizeCache` registers a handler for the WINCH signal, that invalidates
+the cached terminal size. That way, the terminal size is queried only when the terminal size
+changes, or if it's not cached yet (or the cached value has been invalidated).
+If the terminal size didn't change, the cached value is returned, and no unnecessary system call
+querying the terminal size is made.
+
+On Windows, this class just calls `NativeTerminal.size()` upon every call to
+`TerminalSizeCache.size()`.
+
 ## License
 
 All files in this repository, except `NativeImageFeature.java`, can be used either under the

build.sc

@@ -7,6 +7,10 @@ import mill._
 import mill.scalalib._
 import mill.scalalib.publish._
 
+import java.util.Locale
+
+import scala.util.Properties
+
 trait WindowsAnsiPublishModule extends PublishModule with Mima {
   def pomSettings = PomSettings(
     description = artifactName(),
@@ -39,9 +43,39 @@ trait WindowsAnsiPublishModule extends PublishModule with Mima {
     else value
   }
 
-  def javacOptions = super.javacOptions() ++ Seq(
-    "--release", "8"
-  )
+  private def isArm64 =
+    Option(System.getProperty("os.arch")).map(_.toLowerCase(Locale.ROOT)) match {
+      case Some("aarch64" | "arm64") => true
+      case _                         => false
+    }
+  def javacSystemJvmId = T {
+    if (Properties.isMac && isArm64) "zulu:8"
+    else "adoptium:8"
+  }
+  def javacSystemJvm = T.source {
+    val output = os.proc("cs", "java-home", "--jvm", javacSystemJvmId())
+      .call(cwd = T.workspace)
+      .out.trim()
+    val javaHome = os.Path(output)
+    assert(os.isDir(javaHome))
+    PathRef(javaHome, quick = true)
+  }
+  // adds options equivalent to --release 8 + allowing access to unsupported JDK APIs
+  // (no more straightforward options to achieve that AFAIK)
+  def maybeJdk8JavacOpt = T {
+    val javaHome   = javacSystemJvm().path
+    val rtJar      = javaHome / "jre/lib/rt.jar"
+    val hasModules = os.isDir(javaHome / "jmods")
+    val hasRtJar   = os.isFile(rtJar)
+    assert(hasModules || hasRtJar)
+    if (hasModules)
+      Seq("--system", javaHome.toString)
+    else
+      Seq("-source", "8", "-target", "8", "-bootclasspath", rtJar.toString)
+  }
+  def javacOptions = T {
+    super.javacOptions() ++ maybeJdk8JavacOpt()
+  }
 
   def mimaPreviousVersions: T[Seq[String]] = T.input {
     val current = os.proc("git", "describe", "--tags", "--match", "v*")

native-graalvm/src/io/github/alexarchambault/nativeterm/internal/SigWinchNativeWindows.java

@@ -0,0 +1,21 @@
+package io.github.alexarchambault.nativeterm.internal;
+
+import com.oracle.svm.core.annotate.Substitute;
+import com.oracle.svm.core.annotate.TargetClass;
+import org.graalvm.nativeimage.Platform;
+import org.graalvm.nativeimage.Platforms;
+
+/**
+ * Voids the SigWinch class when building native images on Windows,
+ * so that its sun.misc use aren't an issue there.
+ */
+@TargetClass(className = "io.github.alexarchambault.nativeterm.internal.SigWinch")
+@Platforms(Platform.WINDOWS.class)
+public final class SigWinchNativeWindows {
+
+  @Substitute
+  public static void addHandler(Runnable runnable) {
+    // terminal size changes ignored for now
+  }
+
+}

native/src/io/github/alexarchambault/nativeterm/TerminalSizeCache.java

@@ -0,0 +1,58 @@
+package io.github.alexarchambault.nativeterm;
+
+import io.github.alexarchambault.nativeterm.internal.SigWinch;
+
+/**
+ * Helper caching the terminal size, and re-querying it only if a SIGWINCH has been received
+ *
+ * On Windows, this doesn't cache anything and just re-queries the terminal size upon
+ * every [[getSize]] call.
+ */
+public final class TerminalSizeCache {
+    /**
+     * Create a new TerminalSizeCache
+     *
+     * This sets up a signal handle for the WINCH signal.
+     *
+     * As much as possible, only create a single instance of this class,
+     * and re-use it through your application.
+     */
+    public TerminalSizeCache() {
+        SigWinch.addHandler(
+                new Runnable() {
+                    @Override
+                    public void run() {
+                        terminalSize = null;
+                    }
+                }
+        );
+    }
+
+    private TerminalSize terminalSize = null;
+
+    /**
+     * Get the terminal size
+     *
+     * If the terminal size is in cache, it's returned straightaway.
+     *
+     * If the terminal size isn't in cache (not queried yet or recently invalidated by a SIGWINCH),
+     * it's queried, put in cache, and returned.
+     *
+     * @return the terminal size
+     */
+    public TerminalSize getSize() {
+        if (NativeTerminal.isWindows)
+            return NativeTerminal.getSize();
+
+        TerminalSize terminalSize0 = terminalSize;
+        if (terminalSize0 == null)
+            terminalSize0 = update();
+        return terminalSize0;
+    }
+
+    private TerminalSize update() {
+        TerminalSize terminalSize0 = NativeTerminal.getSize();
+        terminalSize = terminalSize0;
+        return terminalSize0;
+    }
+}

native/src/io/github/alexarchambault/nativeterm/internal/SigWinch.java

@@ -0,0 +1,28 @@
+package io.github.alexarchambault.nativeterm.internal;
+
+import sun.misc.Signal;
+import sun.misc.SignalHandler;
+
+/**
+ * Helper to register handlers of the WINCH signal (terminal size change)
+ */
+public final class SigWinch {
+    private SigWinch() {}
+
+    /**
+     * Register a new WINCH handler
+     * @param runnable A Runnable, run every time a WINCH signal is received
+     */
+    public static void addHandler(Runnable runnable) {
+
+        SignalHandler handler = new SignalHandler() {
+            @Override
+            public void handle(Signal arg0) {
+                runnable.run();
+            }
+        };
+
+        Signal.handle(new Signal("WINCH"), handler);
+    }
+
+}