Merge pull request #10 from javaquery/v1.0.7

release: 1.0.7

Author: javaquery

README.md

@@ -46,12 +46,12 @@ framework and objects.
 <dependency>
   <groupId>com.javaquery</groupId>
   <artifactId>util</artifactId>
-  <version>1.0.6.1</version>
+  <version>1.0.7</version>
 </dependency>
 ``` 
 
 # Gradle
 
 ```
-implementation 'com.javaquery:util:1.0.6.1'
+implementation 'com.javaquery:util:1.0.7'
 ```

build.gradle

@@ -6,7 +6,7 @@ plugins {
 
 sourceCompatibility = 1.8
 group 'com.javaquery'
-version '1.0.6.1'
+version '1.0.7'
 
 repositories {
     mavenCentral()

src/main/java/com/javaquery/util/exception/AbstractRuntimeException.java

@@ -0,0 +1,29 @@
+package com.javaquery.util.exception;
+
+/**
+ * @author vicky.thakor
+ * @since 1.0.7
+ */
+public abstract class AbstractRuntimeException extends RuntimeException {
+    static final long serialVersionUID = -1497632070387643027L;
+    private final String errorCode;
+
+    public AbstractRuntimeException(String errorCode, String message) {
+        super(message);
+        this.errorCode = errorCode;
+    }
+
+    public AbstractRuntimeException(String errorCode, String message, Throwable cause) {
+        super(message, cause);
+        this.errorCode = errorCode;
+    }
+
+    public AbstractRuntimeException(String errorCode, Throwable cause) {
+        super(cause);
+        this.errorCode = errorCode;
+    }
+
+    public String getErrorCode() {
+        return errorCode;
+    }
+}

src/main/java/com/javaquery/util/exception/ParameterAwareException.java

@@ -0,0 +1,54 @@
+package com.javaquery.util.exception;
+
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Use this exception to log parameters you sent to method for debugging.
+ * Make sure you do not log any confidential details.
+ * @author vicky.thakor
+ * @since 1.0.7
+ */
+public class ParameterAwareException extends AbstractRuntimeException {
+    static final long serialVersionUID = 4721842774212273469L;
+    private static final String PARAMETERS = "Parameters: ";
+    private final Object[] parameters;
+
+    /**
+     * @param errorCode error code of exception to distinguish your project specific exception
+     * @param message exception message
+     * @param parameters parameters to log
+     */
+    public ParameterAwareException(String errorCode, String message, Object... parameters) {
+        super(errorCode, message + "\n" + PARAMETERS + Stream.of(parameters).map(String::valueOf).collect(Collectors.toList()));
+        this.parameters = parameters;
+    }
+
+    /**
+     * @param errorCode error code of exception to distinguish your project specific exception
+     * @param cause an exception
+     * @param parameters parameters to log
+     */
+    public ParameterAwareException(String errorCode, Throwable cause, Object... parameters){
+        super(errorCode, PARAMETERS + Stream.of(parameters).map(String::valueOf).collect(Collectors.toList()), cause);
+        this.parameters = parameters;
+    }
+
+    /**
+     * @param errorCode error code of exception to distinguish your project specific exception
+     * @param message exception message
+     * @param cause an exception
+     * @param parameters parameters to log
+     */
+    public ParameterAwareException(String errorCode, String message, Throwable cause, Object... parameters){
+        super(errorCode, message + "\n" + PARAMETERS + Stream.of(parameters).map(String::valueOf).collect(Collectors.toList()), cause);
+        this.parameters = parameters;
+    }
+
+    /**
+     * @return parameters provided in exception
+     */
+    public Object[] getParameters() {
+        return parameters;
+    }
+}

src/main/java/com/javaquery/util/string/Strings.java

@@ -185,4 +185,61 @@ public static boolean hasDiacritics(String str) {
     String str2 = normalize(str);
     return str2.matches("(?s).*\\p{InCombiningDiacriticalMarks}.*");
   }
+
+  /**
+   * Compares this string to the specified string. The result is true if and only if the argument is not null and
+   * is a String object that represents the same sequence of characters as this object.
+   * @param a String
+   * @param b String to be compared with {@code a} for equality
+   * @param executableFunction lambda function given executed if the provided Strings are equals.
+   */
+  public static void equals(String a, String b, ExecutableFunction executableFunction){
+    if(Objects.equals(a, b)){
+      executableFunction.execute();
+    }
+  }
+
+  /**
+   * Compares this string to the specified string. The result is true if and only if the one argument is null or
+   * a String object that represents the different sequence of characters as this object.
+   * @param a String
+   * @param b String to be compared with {@code a} for non equality
+   * @param executableFunction lambda function given executed if the provided Strings are not equals.
+   */
+  public static void notEquals(String a, String b, ExecutableFunction executableFunction){
+    if(!Objects.equals(a, b)){
+      executableFunction.execute();
+    }
+  }
+
+  /**
+   * Compares this String to another String, ignoring case considerations. Two strings are considered equal ignoring case if they are of the same length and corresponding characters in the two strings are equal ignoring case.
+   * Two characters c1 and c2 are considered the same ignoring case if at least one of the following is true:
+   * <ul>
+   *     <li>The two characters are the same (as compared by the == operator)</li>
+   *     <li>Calling Character.toLowerCase(Character.toUpperCase(char)) on each character produces the same result</li>
+   * </ul>
+   *
+   * @param a String
+   * @param b String to be compared with {@code a} for equality (ignoring case considerations)
+   * @param executableFunction lambda function given executed if the provided Strings are equals (ignoring case considerations).
+   */
+  public static void equalsIgnoreCase(String a, String b, ExecutableFunction executableFunction){
+    if(a != null && a.equalsIgnoreCase(b)){
+      executableFunction.execute();
+    }
+  }
+
+  /**
+   * Compares this String to another String, ignoring case considerations. Two strings are considered not equal ignoring case if they are of the not same length and corresponding characters in the two strings are not equal ignoring case.
+   *
+   * @param a String
+   * @param b String to be compared with {@code a} for non equality (ignoring case considerations)
+   * @param executableFunction lambda function given executed if the provided Strings are non equals (ignoring case considerations).
+   */
+  public static void notEqualsIgnoreCase(String a, String b, ExecutableFunction executableFunction){
+    if(a != null && !a.equalsIgnoreCase(b)){
+      executableFunction.execute();
+    }
+  }
 }

src/main/java/com/javaquery/util/time/Dates.java

@@ -15,7 +15,6 @@
 public final class Dates {
 
   public static final TimeZone SYSTEM_TIMEZONE = TimeZone.getDefault();
-  private static final Calendar CALENDAR = Calendar.getInstance();
 
   private Dates() {}
 
@@ -205,8 +204,9 @@ public static long epochSeconds(Date date) {
    * @return Returns {@code Date} with given year, month, day, hour, minute, seconds
    */
   public static Date getDate(int year, int month, int day, int hour, int minute, int seconds) {
-    CALENDAR.set(year, --month, day, hour, minute, seconds);
-    return CALENDAR.getTime();
+    Calendar calendar = Calendar.getInstance();
+    calendar.set(year, --month, day, hour, minute, seconds);
+    return calendar.getTime();
   }
 
   /**

src/test/java/com/javaquery/util/exception/TestParameterAwareException.java

@@ -0,0 +1,28 @@
+package com.javaquery.util.exception;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author vicky.thakor
+ * @since 1.0.7
+ */
+public class TestParameterAwareException {
+
+    @Test
+    public void test_constructor(){
+        ParameterAwareException parameterAwareException = new ParameterAwareException("ERR:1", new Exception(), "a", 1);
+        Assertions.assertTrue(parameterAwareException.getMessage().contains("1"));
+        Assertions.assertEquals("ERR:1", parameterAwareException.getErrorCode());
+
+        ParameterAwareException parameterAwareExceptionWithMessage = new ParameterAwareException("ERR:2", "Exception Message", new Exception(), "a", 1);
+        Assertions.assertTrue(parameterAwareExceptionWithMessage.getMessage().contains("Exception Message"));
+        Assertions.assertEquals("ERR:2", parameterAwareExceptionWithMessage.getErrorCode());
+        Assertions.assertEquals(1, parameterAwareException.getParameters()[1]);
+
+        ParameterAwareException parameterAwareException2 = new ParameterAwareException("ERR:3", "Exception Message", 2);
+        Assertions.assertTrue(parameterAwareException2.getMessage().contains("2"));
+        Assertions.assertEquals("ERR:3", parameterAwareException2.getErrorCode());
+        Assertions.assertEquals(2, parameterAwareException2.getParameters()[0]);
+    }
+}

src/test/java/com/javaquery/util/string/TestStrings.java

@@ -1,6 +1,5 @@
 package com.javaquery.util.string;
 
-import com.javaquery.util.io.Console;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
@@ -101,4 +100,31 @@ public void test_hasDiacritics(){
     Assertions.assertTrue(Strings.hasDiacritics(str));
     Assertions.assertFalse(Strings.hasDiacritics(HELLO));
   }
+
+  @Test
+  public void test_equals(){
+    Assertions.assertThrows(RuntimeException.class, () -> Strings.equals("A", "A", () -> {throw new RuntimeException("Function executed when two Strings are equal");}));
+    Strings.equals("A", "a", () -> {throw new RuntimeException("Function won't execute when two Strings are equal with ignore case");});
+    Strings.equals("A", "B", () -> {throw new RuntimeException("Function won't execute when two Strings are not equal");});
+  }
+
+  @Test
+  public void test_notEquals(){
+    Assertions.assertThrows(RuntimeException.class, () -> Strings.notEquals("A", "B", () -> {throw new RuntimeException("Function executed when two Strings are not equal");}));
+    Strings.notEquals("A", "A", () -> {throw new RuntimeException("Function won't execute when two Strings are equal");});
+  }
+
+  @Test
+  public void test_equalsIgnoreCase(){
+    Assertions.assertThrows(RuntimeException.class, () -> Strings.equalsIgnoreCase("A", "A", () -> {throw new RuntimeException("Function executed when two Strings are equalsIgnoreCase");}));
+    Assertions.assertThrows(RuntimeException.class, () -> Strings.equalsIgnoreCase("A", "a", () -> {throw new RuntimeException("Function executed when two Strings are equalsIgnoreCase");}));
+    Strings.equalsIgnoreCase("A", "b", () -> {throw new RuntimeException("Function won't execute when two Strings are not equalsIgnoreCase");});
+  }
+
+  @Test
+  public void test_notEqualsIgnoreCase(){
+    Assertions.assertThrows(RuntimeException.class, () -> Strings.notEqualsIgnoreCase("A", "B", () -> {throw new RuntimeException("Function executed when two Strings are not equalsIgnoreCase");}));
+    Assertions.assertThrows(RuntimeException.class, () -> Strings.notEqualsIgnoreCase("A", "b", () -> {throw new RuntimeException("Function executed when two Strings are not equalsIgnoreCase");}));
+    Strings.notEqualsIgnoreCase("A", "a", () -> {throw new RuntimeException("Function won't execute when two Strings are equalsIgnoreCase");});
+  }
 }