Substituted the customized Optional with java.util.Optional

Author: javadev

src/main/java/com/github/underscore/Optional.java

@@ -47,6 +47,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
@@ -63,6 +64,7 @@
 @SuppressWarnings({
     "java:S135",
     "java:S1168",
+    "java:S3655",
     "java:S3740",
     "java:S3776",
     "java:S4423",

src/main/java/com/github/underscore/U.java

@@ -41,6 +41,7 @@
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
 import java.util.function.BiConsumer;
@@ -57,7 +58,14 @@
  *
  * @author Valentyn Kolesnikov
  */
-@SuppressWarnings({"java:S106", "java:S2189", "java:S2272", "java:S3740", "java:S5852"})
+@SuppressWarnings({
+    "java:S106",
+    "java:S2189",
+    "java:S2272",
+    "java:S2789",
+    "java:S3740",
+    "java:S5852"
+})
 public class Underscore<T> {
     private static final Map<String, Function<String, String>> FUNCTIONS = newLinkedHashMap();
     private static final Map<String, String> TEMPLATE_SETTINGS = new HashMap<>();
@@ -531,7 +539,7 @@ public static <T, E> E foldr(
     public static <E> Optional<E> find(final Iterable<E> iterable, final Predicate<E> pred) {
         for (E element : iterable) {
             if (pred.test(element)) {
-                return Optional.of(element);
+                return isNull(element) ? null : Optional.of(element);
             }
         }
         return Optional.empty();
@@ -664,7 +672,8 @@ public boolean all(final Predicate<T> pred) {
     }
 
     public static <E> boolean some(final Iterable<E> iterable, final Predicate<E> pred) {
-        return find(iterable, pred).isPresent();
+        Optional<E> optional = find(iterable, pred);
+        return optional == null || optional.isPresent();
     }
 
     public boolean some(final Predicate<T> pred) {

src/main/java/com/github/underscore/Underscore.java

@@ -38,13 +38,7 @@
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
-@SuppressWarnings({
-    "java:S107",
-    "java:S1119",
-    "java:S3740",
-    "java:S3776",
-    "java:S4276"
-})
+@SuppressWarnings({"java:S107", "java:S1119", "java:S3740", "java:S3776", "java:S4276"})
 public final class Xml {
     private Xml() {}
 

src/main/java/com/github/underscore/Xml.java

@@ -39,6 +39,7 @@
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.function.BinaryOperator;

src/test/java/com/github/underscore/CollectionsTest.java

@@ -33,6 +33,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import java.util.function.Predicate;

src/test/java/com/github/underscore/FunctionsTest.java

@@ -37,7 +37,9 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Predicate;
 import org.junit.jupiter.api.Test;
 
@@ -488,46 +490,45 @@ void optional() {
         assertTrue(one.equals(one));
         assertFalse(Optional.of(1L).equals(Optional.of(1)));
         assertFalse(Optional.of(1L).equals(null));
-        assertTrue(Optional.of(null).equals(Optional.of(null)));
+        assertTrue(Optional.ofNullable(null).equals(Optional.ofNullable(null)));
         assertFalse(Optional.empty().equals(Optional.of(1)));
-        assertFalse(Optional.of(null).equals(Optional.of(1)));
-        assertFalse(Optional.of(1).equals(Optional.of(null)));
+        assertFalse(Optional.ofNullable(null).equals(Optional.of(1)));
+        assertFalse(Optional.of(1).equals(Optional.ofNullable(null)));
         assertFalse(Optional.of(1).equals(Optional.empty()));
         assertFalse(Optional.of(1).equals(Optional.of(2)));
         assertFalse(Optional.of(1).equals("test"));
-        assertEquals(1, Optional.empty().hashCode());
+        assertEquals(0, Optional.empty().hashCode());
         assertEquals(Optional.of("123").hashCode(), Optional.of("123").hashCode());
         assertEquals("Optional.empty", Optional.empty().toString());
         assertEquals("Optional[1]", Optional.of(1).toString());
-        assertEquals("Optional.empty", Optional.fromNullable(null).toString());
-        assertEquals("Optional[1]", Optional.fromNullable(1).toString());
-        assertEquals("1", Optional.empty().or(1).toString());
-        assertEquals("1", Optional.of(1).or(2).toString());
-        assertEquals(null, Optional.empty().orNull());
-        assertEquals("1", Optional.of(1).orNull().toString());
+        assertEquals("Optional.empty", Optional.ofNullable(null).toString());
+        assertEquals("Optional[1]", Optional.ofNullable(1).toString());
+        assertEquals("1", Optional.<Integer>empty().orElse(1).toString());
+        assertEquals("1", Optional.of(1).orElse(2).toString());
+        assertEquals(null, Optional.empty().orElse(null));
+        assertEquals("1", Optional.of(1).orElse(null).toString());
         assertFalse(Optional.<Integer>empty().map(arg -> "" + arg).isPresent());
         assertTrue(Optional.<Integer>empty().map(arg -> "" + arg).isEmpty());
         assertEquals("1", Optional.of(1).map(arg -> "" + arg).get().toString());
         try {
             Optional.empty().get();
             fail("IllegalStateException expected");
-        } catch (IllegalStateException ignored) {
+        } catch (NoSuchElementException ignored) {
         }
         assertFalse(Optional.<Integer>empty().filter(arg -> true).isPresent());
         assertTrue(Optional.<Integer>empty().filter(arg -> false).isEmpty());
         assertEquals("1", Optional.of(1).filter(arg -> true).get().toString());
         assertTrue(Optional.of(1).filter(arg -> false).isEmpty());
-        assertEquals("Optional[1]", Optional.of(1).toJavaOptional().toString());
     }
 
     @Test
     void optionalOrThrow() throws RuntimeException {
-        assertThrows(Exception.class, () -> Optional.empty().orThrow(RuntimeException::new));
+        assertThrows(Exception.class, () -> Optional.empty().orElseThrow(RuntimeException::new));
     }
 
     @Test
     void optionalOrThrowWithValue() {
-        assertEquals("1", Optional.of(1).orThrow(RuntimeException::new).toString());
+        assertEquals("1", Optional.of(1).orElseThrow(RuntimeException::new).toString());
     }
 
     @Test

src/test/java/com/github/underscore/UnderscoreTest.java

@@ -229,7 +229,8 @@ void unescape() {
     */
     @Test
     void template() {
-        Underscore.Template<Map<String, Object>> compiled = Underscore.template("hello: <%= name %>");
+        Underscore.Template<Map<String, Object>> compiled =
+                Underscore.template("hello: <%= name %>");
         assertEquals(
                 "hello: moe",
                 compiled.apply(
@@ -283,7 +284,8 @@ void template4() {
                         put("interpolate", "\\{\\{=([\\s\\S]+?)\\}\\}");
                     }
                 });
-        Underscore.Template<Map<String, Object>> compiled = Underscore.template("hello: {{= name }}");
+        Underscore.Template<Map<String, Object>> compiled =
+                Underscore.template("hello: {{= name }}");
         assertEquals(
                 "hello: moe",
                 compiled.apply(
@@ -307,7 +309,8 @@ void template4() {
     */
     @Test
     void templateValue() {
-        Underscore.Template<Map<String, Object>> template = Underscore.template("<b><%- value %></b>");
+        Underscore.Template<Map<String, Object>> template =
+                Underscore.template("<b><%- value %></b>");
         assertEquals(
                 "<b>&lt;script&gt;</b>",
                 template.apply(
@@ -365,7 +368,8 @@ void templateValue4() {
 
     @Test
     void templateCheck() {
-        Underscore.Template<Map<String, Object>> compiled = Underscore.template("hello: <%= name %>");
+        Underscore.Template<Map<String, Object>> compiled =
+                Underscore.template("hello: <%= name %>");
         assertTrue(
                 compiled.check(
                                 new LinkedHashMap<String, Object>() {