Merge pull request #10 from CrissNamon/dev

1.2

Author: CrissNamon

LEARN.md

@@ -1,38 +1,84 @@
 ## About
 
 [![Build](https://github.com/CrissNamon/aide/actions/workflows/maven.yml/badge.svg)](https://github.com/CrissNamon/aide/actions/workflows/maven.yml)
+[![Releases](https://img.shields.io/github/v/release/crissnamon/aide?include_prereleases)](https://github.com/CrissNamon/aide/releases)
+[![Maven](https://maven-badges.herokuapp.com/maven-central/tech.hiddenproject/aide/badge.svg)](https://central.sonatype.com/artifact/tech.hiddenproject/aide/1.2)
 
-Aide is a set of useful utils to simplify your code
+Aide is a set of useful utils for fast reflection, extended optionals and conditionals. It can help you with development of some service or your own framework.
 
 ## Content
 
-* Reflection
-    - contains utils for reflection such as fast method invocation, annotation processing and other useful methods
-* Optional
-    - contains extended optional classes for String, Boolean types, IfTrue and When conditionals, Object utils
+#### Reflection
+
+Aide reflection contains utils for reflection such as fast method invocation with lambda wrapping, annotation processing and other useful methods.
+
+Reflective method calls with Aide are simple:
+
+```java
+// Get LambdaWrapperHolder isntance with default LambdaWrapper interface loaded
+LambdaWrapperHolder lambdaWrapperHolder = LambdaWrapperHolder.DEFAULT;
+// Find static method
+Method staticMethod = ReflectionUtil.getMethod(TestClass.class, "staticMethod", String.class);
+// Wrap static method
+// LambdaWrapper - default wrapper interface from Aide
+// Test class - caller class
+// Integer - return type
+MethodHolder<LambdaWrapper, TestClass, Integer> staticHolder = lambdaWrapperHolder.wrapSafe(staticMethod);
+// Invoke static method without caller
+int staticResult = staticHolder.invokeStatic("Hello");
+```
+
+#### Optional
+
+Aide optional contains extended optional classes for String, Boolean types, IfTrue and When conditionals, Object utils.
+
+Extended optionals provides new methods for some types:
+
+```java
+BooleanOptional.of(Modifier.isPublic(executable.getModifiers()))
+        .ifFalseThrow(() -> ReflectionException.format("Wrapping is supported for PUBLIC methods only!"));
+```
+
+With conditionals you can make your code more functional. Thats how Aide reflection uses them:
+
+```java
+AbstractSignature signature = IfTrueConditional.create()
+        .ifTrue(exact).then(() -> ExactMethodSignature.from(method))
+        .ifTrue(someObj, Objects::isNull).then(() -> new MethodSignature())
+        .orElseGet(() -> MethodSignature.from(method));
+```
+
+Or WhenConditional:
+
+```java
+WhenConditional.create()
+    .when(someObj, Objects::nonNull).then(MyClass::nonNull)
+    .when(someObj, Objects::isNull).then(MyClass::isNull)
+    .orDoNothing();
+```
 
 ## Use
 
 Artifact ids:
 
-- all -> aide-all
-- reflection -> aide-reflection
-- optional -> aide-optional
+- `tech.hiddenproject:aide-all` - all components
+- `tech.hiddenproject:aide-optional` - optionals and conditionals
+- `tech.hiddenproject:aide-reflection` - reflection utils
 
 ### Maven
 
 ```xml
 <dependency>
   <groupId>tech.hiddenproject</groupId>
   <artifactId>aide-all</artifactId>
-  <version>1.1</version>
+  <version>1.2</version>
 </dependency>
 ```
 
 ### Gradle
 
 ```groovy
-implementation 'tech:hiddenproject:aide-all:1.1'
+implementation 'tech:hiddenproject:aide-all:1.2'
 ```
 
 ## Resources
@@ -48,7 +94,7 @@ ___
 
 ___
 
-Aide has no dependencies and use only Java 8.</p>
+Aide has no dependencies and use only Java 8.
 
 ## Repository info
 

README.md

@@ -0,0 +1,10 @@
+package tech.hiddenproject.aide.optional;
+
+/**
+ * @author Danila Rassokhin
+ */
+public interface SneakyAction {
+
+  void make() throws Throwable;
+
+}

aide-optional/src/main/java/tech/hiddenproject/aide/optional/SneakyAction.java

@@ -10,12 +10,12 @@
 public class ThrowableOptional {
 
   /**
-   * Executes {@link Action} and catches any Throwable, then converts Throwable to RuntimeException
+   * Executes {@link SneakyAction} and catches any Throwable, then converts Throwable to RuntimeException
    * and throws it. Can be used to work with checked exceptions in lambdas.
    *
-   * @param action {@link Action}
+   * @param action {@link SneakyAction}
    */
-  public static void sneaky(Action action) {
+  public static void sneaky(SneakyAction action) {
     try {
       action.make();
     } catch (Throwable throwable) {
@@ -24,14 +24,14 @@ public static void sneaky(Action action) {
   }
 
   /**
-   * Executes {@link Action}. Catches any Throwable if it will be thrown, then converts Throwable to
+   * Executes {@link SneakyAction}. Catches any Throwable if it will be thrown, then converts Throwable to
    * RuntimeException with given mapper function and throws it. Can be used to work with checked
    * exceptions in lambdas.
    *
-   * @param action {@link Action}
+   * @param action {@link SneakyAction}
    * @param mapper Mapper function to convert {@link Throwable} to {@link RuntimeException}
    */
-  public static void sneaky(Action action, Function<Throwable, ? extends RuntimeException> mapper) {
+  public static void sneaky(SneakyAction action, Function<Throwable, ? extends RuntimeException> mapper) {
     try {
       action.make();
     } catch (Throwable throwable) {

aide-optional/src/main/java/tech/hiddenproject/aide/optional/ThrowableOptional.java

@@ -28,7 +28,11 @@ public void mapTest() {
 
     String expected = "MyString";
     String actual = stringOptional.mapOnCondition(s -> true, v -> "My" + v).get();
-
+    ThrowableOptional.sneaky(() -> exceptional());
     Assertions.assertEquals(expected, actual);
   }
+
+  public void exceptional() throws Throwable {
+
+  }
 }

aide-optional/src/test/java/tech/hiddenproject/aide/optional/StringOptionalTest.java

@@ -2,6 +2,7 @@
 
 import static org.mockito.ArgumentMatchers.any;
 
+import java.util.Objects;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import org.junit.jupiter.api.Assertions;
@@ -126,4 +127,21 @@ public void orElseThrowTest() {
 
     Mockito.verifyNoMoreInteractions(predicate1, predicate2, action1, action2, supplier);
   }
+
+  @Test
+  public void whenTest() {
+
+    WhenConditional.create()
+        .when(false).then(WhenConditionalTest::action)
+        .when(new Object(), Objects::nonNull).then(() -> WhenConditionalTest.action())
+        .orDoNothing();
+
+  }
+
+  public static int id = 1;
+
+  public static void action() {
+    System.out.println("ACTION: " + id);
+    id++;
+  }
 }

aide-optional/src/test/java/tech/hiddenproject/aide/optional/WhenConditionalTest.java

@@ -191,6 +191,6 @@
     <maven.compiler.target>8</maven.compiler.target>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
-  <version>1.1</version>
+  <version>1.2</version>
 
 </project>