WIP: Handlebars works on Java 15

Author: jknack

handlebars/src/main/java/com/github/jknack/handlebars/Handlebars.java

@@ -39,6 +39,7 @@
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.slf4j.Logger;
 
@@ -176,6 +177,8 @@ public boolean equals(final Object obj) {
    */
   public static class Utils {
 
+    public static final int javaVersion = javaVersion();
+
     /**
      * Evaluate the given object and return true is the object is considered
      * empty. Nulls, empty list or array and false values are considered empty.
@@ -233,6 +236,23 @@ public static boolean isEmpty(final Object value) {
     public static CharSequence escapeExpression(final CharSequence input) {
       return EscapingStrategy.DEF.escape(input);
     }
+
+    private static int javaVersion() {
+      String version = System.getProperty("java.version");
+      if (version.startsWith("1.")) {
+        version = version.substring(2, 3);
+      } else {
+        int dot = version.indexOf(".");
+        if (dot != -1) {
+          version = version.substring(0, dot);
+        }
+      }
+      try {
+        return Integer.parseInt(version);
+      } catch (NumberFormatException e) {
+        return 8;
+      }
+    }
   }
 
   /**

handlebars/src/main/java/com/github/jknack/handlebars/internal/BaseTemplate.java

@@ -25,6 +25,7 @@
 import java.io.IOException;
 import java.io.Writer;
 import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
@@ -264,17 +265,26 @@ private boolean isDefault(final Method method) {
 
           private Object invokeDefaultMethod(final Method method, final Class<?> lookupClass,
               final Object proxy, final Object... args) throws Throwable {
-            // Jumping through these hoops is needed because calling unreflectSpecial requires that
-            // the lookup instance have private access to the special caller. None of the static
-            // factory methods for Lookup will give us an instance with the access modes we need,
-            // so we work around it by calling the private constructor via reflection.
-            Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
-                .getDeclaredConstructor(Class.class, int.class);
-            constructor.setAccessible(true);
-            return constructor.newInstance(lookupClass, -1 /* trusted */)
-                .unreflectSpecial(method, lookupClass)
-                .bindTo(proxy)
-                .invokeWithArguments(args);
+            if (Handlebars.Utils.javaVersion >= 15) {
+              MethodType methodType = MethodType.methodType(method.getReturnType(),
+                  method.getParameterTypes());
+              return MethodHandles.lookup()
+                  .findSpecial(lookupClass, method.getName(), methodType, lookupClass)
+                  .bindTo(proxy)
+                  .invokeWithArguments(args);
+            } else {
+              // Jumping through these hoops is needed because calling unreflectSpecial requires that
+              // the lookup instance have private access to the special caller. None of the static
+              // factory methods for Lookup will give us an instance with the access modes we need,
+              // so we work around it by calling the private constructor via reflection.
+              Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
+                  .getDeclaredConstructor(Class.class, int.class);
+              constructor.setAccessible(true);
+              return constructor.newInstance(lookupClass, -1 /* trusted */)
+                  .unreflectSpecial(method, lookupClass)
+                  .bindTo(proxy)
+                  .invokeWithArguments(args);
+            }
           }
 
           @Override

handlebars/src/test/java/com/github/jknack/handlebars/AbstractTest.java

@@ -161,25 +161,8 @@ protected Handlebars newHandlebars() {
   }
 
   public void withJava(Predicate<Integer> predicate, Task task) throws IOException {
-    if (predicate.test(getJavaVersion())) {
+    if (predicate.test(Handlebars.Utils.javaVersion)) {
       task.run();
     }
   }
-
-  static int getJavaVersion() {
-    String version = System.getProperty("java.version");
-    if (version.startsWith("1.")) {
-      version = version.substring(2, 3);
-    } else {
-      int dot = version.indexOf(".");
-      if (dot != -1) {
-        version = version.substring(0, dot);
-      }
-    }
-    try {
-      return Integer.parseInt(version);
-    } catch (NumberFormatException e) {
-      return 8;
-    }
-  }
 }

handlebars/src/test/java/com/github/jknack/handlebars/context/SetAccessibleValueResolverTest.java

@@ -7,52 +7,54 @@
 import java.lang.reflect.Method;
 import java.util.Collections;
 
-import org.junit.Ignore;
 import org.junit.Test;
 
+import com.github.jknack.handlebars.Handlebars;
+import com.github.jknack.handlebars.ValueResolver;
+
 public class SetAccessibleValueResolverTest {
 
   /*
    * The following tests require JDK 9 or greater.
    * To keep the tests from failing we use junit assume.
    */
-
-  @Ignore
-  public void testSetAccessibleOnJDK9OrGreater() throws Exception {
-    assumeTrue(getJavaVersion() >= 9);
+  @Test
+  public void shouldPrintWarningAndNotThrowExceptionSetAccesibleOnOnJava9Or17() throws Exception {
+    assumeTrue(Handlebars.Utils.javaVersion > 8 && Handlebars.Utils.javaVersion <= 14);
     MethodValueResolver mv = new MethodValueResolver() {
 
       @Override
       protected boolean isUseSetAccessible(Method m) {
         return true;
       }
     };
-    try {
-      mv.resolve(Collections.emptyMap(), "doesNotMatter");
-      fail("Expect InaccessibleObjectException");
-    } catch (/* InaccessibleObjectException */ Exception e) {
-    }
+    Object result = mv.resolve(Collections.emptyMap(), "doesNotMatter");
+    assertEquals(ValueResolver.UNRESOLVED, result);
+  }
 
-    mv = new MethodValueResolver();
-    mv.resolve(Collections.emptyMap(), "doesNotMatter");
+  @Test
+  public void shouldNotPrintWarningAndNotThrowExceptionSetAccesibleOnOnJava9Or17()
+      throws Exception {
+    assumeTrue(Handlebars.Utils.javaVersion > 8 && Handlebars.Utils.javaVersion <= 17);
+    MethodValueResolver mv = new MethodValueResolver();
     Object result = mv.resolve(Collections.emptyMap(), "isEmpty");
     assertEquals(Boolean.TRUE, result);
   }
 
-  static int getJavaVersion() {
-    String version = System.getProperty("java.version");
-    if (version.startsWith("1.")) {
-      version = version.substring(2, 3);
-    } else {
-      int dot = version.indexOf(".");
-      if (dot != -1) {
-        version = version.substring(0, dot);
+  @Test
+  public void shouldThrowExceptionOnJava17orHigher() throws Exception {
+    assumeTrue(Handlebars.Utils.javaVersion >= 17);
+    MethodValueResolver mv = new MethodValueResolver() {
+
+      @Override
+      protected boolean isUseSetAccessible(Method m) {
+        return true;
       }
-    }
+    };
     try {
-      return Integer.parseInt(version);
-    } catch (NumberFormatException e) {
-      return 8;
+      mv.resolve(Collections.emptyMap(), "doesNotMatter");
+      fail("Expect InaccessibleObjectException");
+    } catch (/* InaccessibleObjectException */ Exception e) {
     }
   }