From ec7cb028007c03731b42d07937b5d5a77010bcc2 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Tue, 19 Jul 2016 18:13:13 +0530
Subject: [PATCH 01/46] cleanup and added tests

---
 src/main/java/strman/Strman.java     |  6 +++-
 src/test/java/strman/StrmanTest.java | 42 +++++++++++++++++++++++++++-
 2 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index fe5fad5..2327e5e 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -944,7 +944,11 @@ public static String htmlDecode(final String encodedHtml) {
      */
     public static String htmlEncode(final String html) {
         validate(html, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return html.chars().mapToObj(c -> "\\u" + String.format("%04x", c).toUpperCase()).map(e -> HtmlEntities.encodedEntities.get(e)).collect(joining());
+        return html
+                .chars()
+                .mapToObj(c -> "\\u" + String.format("%04x", c).toUpperCase())
+                .map(HtmlEntities.encodedEntities::get)
+                .collect(joining());
     }
 
     /**
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index be931e4..07ed4e0 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -26,6 +26,7 @@
 
 package strman;
 
+import org.junit.Ignore;
 import org.junit.Test;
 
 import java.util.Arrays;
@@ -800,7 +801,8 @@ public void toKebabCase_shouldKebabCaseAString() throws Exception {
                 "     de_camelize"
         };
 
-        Arrays.stream(fixture).forEach(el -> assertThat(String.format("toKebabCase(%s) should be de-camelize", el), toKebabCase(el), equalTo("de-camelize")));
+        Arrays.stream(fixture).forEach(el ->
+                assertThat(String.format("toKebabCase(%s) should be de-camelize", el), toKebabCase(el), equalTo("de-camelize")));
     }
 
     @Test
@@ -845,4 +847,42 @@ public void removeRight_shouldNotLowercaseWhenCaseInsensitive() throws Exception
         String result = removeRight("Remove the END at the end", " END", false);
         assertThat(result, is("Remove the END at the"));
     }
+
+    @Test
+    public void transliterate_shouldDeburrTheString() throws Exception {
+        String result = transliterate("déjà vu");
+        assertThat(result, is(equalTo("deja vu")));
+    }
+
+    @Ignore
+    public void htmlEncode_shouldConvertCharactersToTheirHtmlEntities() throws Exception {
+        String result = htmlEncode("fred, barney, & pebbles");
+        assertThat(result, is(equalTo("fred, barney, &amp; pebbles")));
+    }
+
+    @Ignore
+    public void kebabCase_shouldConvertAStringToKebabCase() throws Exception {
+        String[] input = {
+                "Foo Bar",
+                "fooBar",
+                "__FOO_BAR__"
+        };
+
+        Arrays.stream(input).forEach(el ->
+                assertThat(String.format("%s should be foo-bar", el), toKebabCase(el), is(equalTo("foo-bar"))));
+
+    }
+
+    @Ignore
+    public void snakeCase_shouldConvertAStringToSnakecase() throws Exception {
+        String[] input = {
+                "Foo Bar",
+                "fooBar",
+                "--FOO-BAR--"
+        };
+
+        Arrays.stream(input).forEach(el ->
+                assertThat(String.format("%s should be foo_bar", el), toSnakeCase(el), is(equalTo("foo_bar"))));
+
+    }
 }
\ No newline at end of file

From 6bbe0a9167d383f186908bb657061ca98ded4a3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marcin=20Zaj=C4=85czkowski?= <mszpak@wp.pl>
Date: Tue, 19 Jul 2016 17:28:57 +0200
Subject: [PATCH 02/46] Simplify Maven and Gradle configuration (#70)

---
 README.md | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 028ec4d..1e11a34 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,6 @@ For Apache Maven users, please add following to your pom.xml.
         <groupId>com.shekhargulati</groupId>
         <artifactId>strman</artifactId>
         <version>0.2.0</version>
-        <type>jar</type>
     </dependency>
 </dependencies>
 ```
@@ -24,9 +23,7 @@ For Apache Maven users, please add following to your pom.xml.
 Gradle users can add following to their build.gradle file.
 
 ```
-compile(group: 'com.shekhargulati', name: 'strman', version: '0.2.0', ext: 'jar'){
-        transitive=true
-}
+compile(group: 'com.shekhargulati', name: 'strman', version: '0.2.0')
 ```
 
 ## Available Functions

From 3594042ab5e924febf469d4aeb3b6f1243ba92b2 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Mon, 25 Jul 2016 15:29:24 +0530
Subject: [PATCH 03/46] Resolved #53

---
 src/main/java/strman/Strman.java     | 22 +++++++++++++++++++
 src/test/java/strman/StrmanTest.java | 33 +++++++++++++++++++++++++---
 2 files changed, 52 insertions(+), 3 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 2327e5e..01a2395 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1109,6 +1109,28 @@ public static String encode(final String value, final int digits, final int radi
         return value.chars().mapToObj(ch -> leftPad(Integer.toString(ch, radix), "0", digits)).collect(joining());
     }
 
+
+    /**
+     * Join concatenates all the elements of the strings array into a single String. The separator string is placed between elements in the resulting string.
+     *
+     * @param strings   The input array to concatenate
+     * @param separator The separator to use
+     * @return Concatenated String
+     */
+    public static String join(final String[] strings, final String separator) {
+        if (strings == null) {
+            throw new IllegalArgumentException("Input array 'strings' can't be null");
+        }
+        if (separator == null) {
+            throw new IllegalArgumentException("separator can't be null");
+        }
+        StringJoiner joiner = new StringJoiner(separator);
+        for (String el : strings) {
+            joiner.add(el);
+        }
+        return joiner.toString();
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index 07ed4e0..b4d36f7 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -411,9 +411,9 @@ public void indexOf_shouldBeTrueWhenNeedleExistCaseSensitive() throws Exception
 
     @Test
     public void inequal_shouldTestInequalityOfStrings() throws Exception {
-        assertThat(inequal("a", "b"), equalTo(true));
-        assertThat(inequal("a", "a"), equalTo(false));
-        assertThat(inequal("0", "1"), equalTo(true));
+        assertThat(unequal("a", "b"), equalTo(true));
+        assertThat(unequal("a", "a"), equalTo(false));
+        assertThat(unequal("0", "1"), equalTo(true));
     }
 
     @Test
@@ -885,4 +885,31 @@ public void snakeCase_shouldConvertAStringToSnakecase() throws Exception {
                 assertThat(String.format("%s should be foo_bar", el), toSnakeCase(el), is(equalTo("foo_bar"))));
 
     }
+
+    @Test
+    public void join_shouldJoinArrayOfStringIntoASingleString() throws Exception {
+        String[] strings = {
+                "hello",
+                "world",
+                "123"
+        };
+        assertThat(join(strings, ";"), is(equalTo("hello;world;123")));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void join_shouldThrowIllegalArgumentExceptionWhenSeparatorIsNull() throws Exception {
+        String[] strings = {
+                "hello",
+                "world",
+                "123"
+        };
+
+        join(strings, null);
+    }
+
+    @Test
+    public void join_shouldReturnEmptyStringWhenInputArrayIsEmpty() throws Exception {
+        String[] emptyArray = {};
+        assertThat(join(emptyArray, ","), is(equalTo("")));
+    }
 }
\ No newline at end of file

From f282dddca32f6cd228fb2ab1b7168ec1e5a54bb6 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Wed, 27 Jul 2016 23:19:41 +0530
Subject: [PATCH 04/46] Resolved #54 and Resolved #59

---
 src/main/java/strman/Strman.java     | 35 +++++++++++++++++++++++++++-
 src/test/java/strman/StrmanTest.java | 17 ++++++++++++++
 2 files changed, 51 insertions(+), 1 deletion(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 01a2395..68a13d6 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1117,7 +1117,7 @@ public static String encode(final String value, final int digits, final int radi
      * @param separator The separator to use
      * @return Concatenated String
      */
-    public static String join(final String[] strings, final String separator) {
+    public static String join(final String[] strings, final String separator) throws IllegalArgumentException {
         if (strings == null) {
             throw new IllegalArgumentException("Input array 'strings' can't be null");
         }
@@ -1131,6 +1131,39 @@ public static String join(final String[] strings, final String separator) {
         return joiner.toString();
     }
 
+    /**
+     * Converts the first character of string to upper case and the remaining to lower case.
+     *
+     * @param input The string to capitalize
+     * @return The capitalized string
+     */
+    public static String capitalize(final String input) throws IllegalArgumentException {
+        if (input == null) {
+            throw new IllegalArgumentException("input can't be null");
+        }
+        if (input.length() == 0) {
+            return "";
+        }
+        return head(input).toUpperCase() + tail(input).toLowerCase();
+    }
+
+    /**
+     * Converts the first character of string to lower case.
+     *
+     * @param input The string to convert
+     * @return The converted string
+     * @throws IllegalArgumentException
+     */
+    public static String lowerFirst(final String input) throws IllegalArgumentException {
+        if (input == null) {
+            throw new IllegalArgumentException("input can't be null");
+        }
+        if (input.length() == 0) {
+            return "";
+        }
+        return head(input).toLowerCase() + tail(input);
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index b4d36f7..b90f1fc 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -912,4 +912,21 @@ public void join_shouldReturnEmptyStringWhenInputArrayIsEmpty() throws Exception
         String[] emptyArray = {};
         assertThat(join(emptyArray, ","), is(equalTo("")));
     }
+
+    @Test
+    public void capitalize_shouldCapitalizeFirstCharacterOfString() throws Exception {
+        String[] strings = {
+                "FRED",
+                "fRED",
+                "fred"
+        };
+        Arrays.stream(strings).forEach(el -> assertThat(String.format("%s should be Fred", el), capitalize(el), equalTo("Fred")));
+    }
+
+    @Test
+    public void lowerFirst_shouldLowercasedFirstCharacterOfString() throws Exception {
+        assertThat(lowerFirst("FRED"),is(equalTo("fRED")));
+        assertThat(lowerFirst("fred"),is(equalTo("fred")));
+        assertThat(lowerFirst("Fred"),is(equalTo("fred")));
+    }
 }
\ No newline at end of file

From 21f8bb9f8edd4834baa7ca18561ca362dc0e468a Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Wed, 24 Aug 2016 12:11:04 +0530
Subject: [PATCH 05/46] Resolved#71

---
 src/main/java/strman/Strman.java     | 31 ++++++++++++++++++++++++++++
 src/test/java/strman/StrmanTest.java | 19 ++++++++++++++---
 2 files changed, 47 insertions(+), 3 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 68a13d6..f2a7a19 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1164,6 +1164,37 @@ public static String lowerFirst(final String input) throws IllegalArgumentExcept
         return head(input).toLowerCase() + tail(input);
     }
 
+    /**
+     * Verifies whether String is enclosed by encloser
+     *
+     * @param input    The input String
+     * @param encloser String which encloses input String
+     * @return true if enclosed false otherwise
+     */
+    public static boolean isEnclosedBetween(final String input, final String encloser) {
+        return isEnclosedBetween(input, encloser, encloser);
+    }
+
+    /**
+     * Verifies whether String is enclosed by encloser
+     *
+     * @param input        The input String
+     * @param leftEncloser String which encloses input String
+     * @return true if enclosed false otherwise
+     */
+    public static boolean isEnclosedBetween(final String input, final String leftEncloser, String rightEncloser) {
+        if (input == null) {
+            throw new IllegalArgumentException("input can't be null");
+        }
+        if (leftEncloser == null) {
+            throw new IllegalArgumentException("leftEncloser can't be null");
+        }
+        if (rightEncloser == null) {
+            throw new IllegalArgumentException("rightEncloser can't be null");
+        }
+        return input.startsWith(leftEncloser) && input.endsWith(rightEncloser);
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index b90f1fc..54b1a9a 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -925,8 +925,21 @@ public void capitalize_shouldCapitalizeFirstCharacterOfString() throws Exception
 
     @Test
     public void lowerFirst_shouldLowercasedFirstCharacterOfString() throws Exception {
-        assertThat(lowerFirst("FRED"),is(equalTo("fRED")));
-        assertThat(lowerFirst("fred"),is(equalTo("fred")));
-        assertThat(lowerFirst("Fred"),is(equalTo("fred")));
+        assertThat(lowerFirst("FRED"), is(equalTo("fRED")));
+        assertThat(lowerFirst("fred"), is(equalTo("fred")));
+        assertThat(lowerFirst("Fred"), is(equalTo("fred")));
+    }
+
+    @Test
+    public void isEnclosedBetween_shouldChekcWhetherStringIsEnclosed() throws Exception {
+        assertThat(isEnclosedBetween("{{shekhar}}", "{{", "}}"), is(true));
+        assertThat(isEnclosedBetween("shekhar", "{{", "}}"), is(false));
+        assertThat(isEnclosedBetween("*shekhar*", "*"), is(true));
+        assertThat(isEnclosedBetween("shekhar", "*"), is(false));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void isEnclosedBetween_shouldThrowIllegalArgumentExceptionWhenEncloserIsNull() throws Exception {
+        assertThat(isEnclosedBetween("shekhar", null), is(false));
     }
 }
\ No newline at end of file

From f635543679869365eb8ef0905c0b22f6e2afc020 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Wed, 24 Aug 2016 12:16:19 +0530
Subject: [PATCH 06/46] #71 updated documentation

---
 src/main/java/strman/Strman.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index f2a7a19..0c43867 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1178,8 +1178,9 @@ public static boolean isEnclosedBetween(final String input, final String enclose
     /**
      * Verifies whether String is enclosed by encloser
      *
-     * @param input        The input String
-     * @param leftEncloser String which encloses input String
+     * @param input         The input String
+     * @param leftEncloser  String which encloses input String at left start
+     * @param rightEncloser String which encloses input String at the right end
      * @return true if enclosed false otherwise
      */
     public static boolean isEnclosedBetween(final String input, final String leftEncloser, String rightEncloser) {

From 2ae1c02b5d34ee72b0feb21d45265783843cc389 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Wed, 24 Aug 2016 12:56:18 +0530
Subject: [PATCH 07/46] Resolved #69

---
 src/test/java/strman/StrmanTest.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index 54b1a9a..c9f69a3 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -942,4 +942,10 @@ public void isEnclosedBetween_shouldChekcWhetherStringIsEnclosed() throws Except
     public void isEnclosedBetween_shouldThrowIllegalArgumentExceptionWhenEncloserIsNull() throws Exception {
         assertThat(isEnclosedBetween("shekhar", null), is(false));
     }
+
+    @Test
+    public void words_shouldConvertTextToWords() throws Exception {
+        final String line = "This is a string, with words!";
+        assertThat(words(line), is(new String[]{"This", "is", "a", "string", "with", "words"}));
+    }
 }
\ No newline at end of file

From 9b60adf73292183897dc0e12f5cd4deca02ab049 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Wed, 24 Aug 2016 14:26:16 +0530
Subject: [PATCH 08/46] Resolved #68

---
 src/main/java/strman/Strman.java     | 46 ++++++++++++++++++++++------
 src/test/java/strman/StrmanTest.java | 14 +++++++--
 2 files changed, 48 insertions(+), 12 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 0c43867..099a644 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -405,9 +405,8 @@ public static String ensureRight(final String value, final String suffix, boolea
      * @param n     Number of chars to return
      * @return The first n chars
      */
-    public static String first(final String value, final int n) {
-        validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return value.substring(0, n);
+    public static Optional<String> first(final String value, final int n) {
+        return Optional.ofNullable(value).filter(v -> !v.isEmpty()).map(v -> v.substring(0, n));
     }
 
     /**
@@ -416,7 +415,7 @@ public static String first(final String value, final int n) {
      * @param value The input String
      * @return The first char
      */
-    public static String head(final String value) {
+    public static Optional<String> head(final String value) {
         return first(value, 1);
     }
 
@@ -1049,7 +1048,10 @@ public static String toCamelCase(final String value) {
     public static String toStudlyCase(final String value) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
         String[] words = collapseWhitespace(value.trim()).split("\\s*(_|-|\\s)\\s*");
-        return Arrays.stream(words).filter(w -> !w.trim().isEmpty()).map(w -> head(w).toUpperCase() + tail(w)).collect(joining());
+        return Arrays.stream(words)
+                .filter(w -> !w.trim().isEmpty())
+                .map(Strman::upperFirst)
+                .collect(joining());
     }
 
     /**
@@ -1058,9 +1060,8 @@ public static String toStudlyCase(final String value) {
      * @param value The input String
      * @return String tail
      */
-    public static String tail(final String value) {
-        validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return last(value, value.length() - 1);
+    public static Optional<String> tail(final String value) {
+        return Optional.ofNullable(value).filter(v -> !v.isEmpty()).map(v -> last(v, v.length() - 1));
     }
 
     /**
@@ -1144,7 +1145,11 @@ public static String capitalize(final String input) throws IllegalArgumentExcept
         if (input.length() == 0) {
             return "";
         }
-        return head(input).toUpperCase() + tail(input).toLowerCase();
+        return head(input)
+                .map(String::toUpperCase)
+                .map(h ->
+                        tail(input).map(t -> h + t.toLowerCase()).orElse(h))
+                .get();
     }
 
     /**
@@ -1161,7 +1166,12 @@ public static String lowerFirst(final String input) throws IllegalArgumentExcept
         if (input.length() == 0) {
             return "";
         }
-        return head(input).toLowerCase() + tail(input);
+
+        return head(input)
+                .map(String::toLowerCase)
+                .map(h ->
+                        tail(input).map(t -> h + t).orElse(h))
+                .get();
     }
 
     /**
@@ -1196,6 +1206,22 @@ public static boolean isEnclosedBetween(final String input, final String leftEnc
         return input.startsWith(leftEncloser) && input.endsWith(rightEncloser);
     }
 
+    /**
+     * Converts the first character of string to upper case.
+     *
+     * @param input The string to convert.
+     * @return Returns the converted string.
+     */
+    public static String upperFirst(String input) {
+        if (input == null) {
+            throw new IllegalArgumentException("input can't be null");
+        }
+        return head(input)
+                .map(String::toUpperCase)
+                .map(h -> tail(input).map(t -> h + t).orElse(h))
+                .get();
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index c9f69a3..5af5171 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -345,7 +345,7 @@ public void first_shouldReturnFirstThreeCharsOfString() throws Exception {
         final String[] fixture = {
                 "foo", "foobar"
         };
-        Arrays.stream(fixture).forEach(el -> assertThat(first(el, 3), equalTo("foo")));
+        Arrays.stream(fixture).forEach(el -> assertThat(first(el, 3), equalTo(Optional.of("foo"))));
     }
 
     @Test
@@ -354,7 +354,7 @@ public void head_shouldReturnFirstCharOfString() throws Exception {
                 "foo", "foobar"
         };
 
-        Arrays.stream(fixture).forEach(el -> assertThat(head(el), equalTo("f")));
+        Arrays.stream(fixture).forEach(el -> assertThat(head(el), equalTo(Optional.of("f"))));
     }
 
     @Test
@@ -948,4 +948,14 @@ public void words_shouldConvertTextToWords() throws Exception {
         final String line = "This is a string, with words!";
         assertThat(words(line), is(new String[]{"This", "is", "a", "string", "with", "words"}));
     }
+
+    @Test
+    public void upperFirst_shouldConvertFirstCharToUpperCase() throws Exception {
+        assertThat(upperFirst("fred"), is("Fred"));
+    }
+
+    @Test
+    public void upperFirst_shouldReturnSameStringIfFirstCharIsUpperCase() throws Exception {
+        assertThat(upperFirst("FRED"), is("FRED"));
+    }
 }
\ No newline at end of file

From bacbe4652932555779b35dede2ac66645f70e07e Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Wed, 24 Aug 2016 15:02:00 +0530
Subject: [PATCH 09/46] Resolved #65

---
 src/main/java/strman/Strman.java     | 31 ++++++++++++++++++++++++++++
 src/test/java/strman/StrmanTest.java | 16 ++++++++++++++
 2 files changed, 47 insertions(+)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 099a644..56d948b 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1222,6 +1222,37 @@ public static String upperFirst(String input) {
                 .get();
     }
 
+    /**
+     * Removes leading whitespace from string.
+     *
+     * @param input The string to trim.
+     * @return Returns the trimmed string.
+     */
+    public static Optional<String> trimStart(final String input) {
+        return Optional.ofNullable(input)
+                .filter(v -> !v.isEmpty())
+                .map(Strman::leftTrim);
+    }
+
+
+    /**
+     * Removes leading whitespace from string.
+     *
+     * @param input The string to trim.
+     * @param chars The characters to trim.
+     *
+     * @return Returns the trimmed string.
+     */
+    public static Optional<String> trimStart(final String input, String... chars) {
+        return Optional.ofNullable(input)
+                .filter(v -> !v.isEmpty())
+                .map(v -> {
+                    String pattern = String.format("^[%s]+", join(chars, "\\"));
+                    return v.replaceAll(pattern, "");
+                });
+    }
+
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index 5af5171..e19ef00 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -958,4 +958,20 @@ public void upperFirst_shouldConvertFirstCharToUpperCase() throws Exception {
     public void upperFirst_shouldReturnSameStringIfFirstCharIsUpperCase() throws Exception {
         assertThat(upperFirst("FRED"), is("FRED"));
     }
+
+    @Test
+    public void trimStart_shouldRemoveAllWhitespaceAtStart() throws Exception {
+        assertThat(trimStart("   abc   "), is(Optional.of("abc   ")));
+        assertThat(trimStart("abc   "), is(Optional.of("abc   ")));
+        assertThat(trimStart("abc"), is(Optional.of("abc")));
+        assertThat(trimStart(""), is(Optional.empty()));
+        assertThat(trimStart(null), is(Optional.empty()));
+    }
+
+    @Test
+    public void trimStart_shouldRemoveSpecialCharactersAtStart() throws Exception {
+        assertThat(trimStart("-_-abc-_-", "_", "-"), is(Optional.of("abc-_-")));
+        assertThat(trimStart("-_-!abc-_-", "_", "-", "!"), is(Optional.of("abc-_-")));
+        assertThat(trimStart("-_-#abc-_-", "_", "-", "!", "#"), is(Optional.of("abc-_-")));
+    }
 }
\ No newline at end of file

From 61ca9fc9842a44139a662a3ab4865aaedf5bca40 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Wed, 24 Aug 2016 15:32:45 +0530
Subject: [PATCH 10/46] Resolved #66

---
 src/main/java/strman/Strman.java     | 32 +++++++++++++++++++++++++++-
 src/test/java/strman/StrmanTest.java | 16 ++++++++++++++
 2 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 56d948b..2f7e809 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1236,7 +1236,7 @@ public static Optional<String> trimStart(final String input) {
 
 
     /**
-     * Removes leading whitespace from string.
+     * Removes leading characters from string.
      *
      * @param input The string to trim.
      * @param chars The characters to trim.
@@ -1252,6 +1252,36 @@ public static Optional<String> trimStart(final String input, String... chars) {
                 });
     }
 
+    /**
+     * Removes trailing whitespace from string.
+     *
+     * @param input The string to trim.
+     * @return Returns the trimmed string.
+     */
+    public static Optional<String> trimEnd(final String input) {
+        return Optional.ofNullable(input)
+                .filter(v -> !v.isEmpty())
+                .map(Strman::rightTrim);
+    }
+
+
+    /**
+     * Removes trailing characters from string.
+     *
+     * @param input The string to trim.
+     * @param chars The characters to trim.
+     *
+     * @return Returns the trimmed string.
+     */
+    public static Optional<String> trimEnd(final String input, String... chars) {
+        return Optional.ofNullable(input)
+                .filter(v -> !v.isEmpty())
+                .map(v -> {
+                    String pattern = String.format("[%s]+$", join(chars, "\\"));
+                    return v.replaceAll(pattern, "");
+                });
+    }
+
 
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index e19ef00..176253c 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -974,4 +974,20 @@ public void trimStart_shouldRemoveSpecialCharactersAtStart() throws Exception {
         assertThat(trimStart("-_-!abc-_-", "_", "-", "!"), is(Optional.of("abc-_-")));
         assertThat(trimStart("-_-#abc-_-", "_", "-", "!", "#"), is(Optional.of("abc-_-")));
     }
+
+    @Test
+    public void trimEnd_shouldRemoveAllTrailingWhitespace() throws Exception {
+        assertThat(trimEnd("   abc   "), is(Optional.of("   abc")));
+        assertThat(trimEnd("abc   "), is(Optional.of("abc")));
+        assertThat(trimEnd("abc"), is(Optional.of("abc")));
+        assertThat(trimEnd(""), is(Optional.empty()));
+        assertThat(trimEnd(null), is(Optional.empty()));
+    }
+
+    @Test
+    public void trimEnd_shouldRemoveAllTrailingSpecialCharacters() throws Exception {
+        assertThat(trimEnd("-_-abc-_-", "_", "-"), is(Optional.of("-_-abc")));
+        assertThat(trimEnd("-_-abc!-_-", "_", "-", "!"), is(Optional.of("-_-abc")));
+        assertThat(trimEnd("-_-abc#-_-", "_", "-", "!", "#"), is(Optional.of("-_-abc")));
+    }
 }
\ No newline at end of file

From 605eb4f2a52e32594a6464db2e5b09f9f4078127 Mon Sep 17 00:00:00 2001
From: wli75 <wli75@illinois.edu>
Date: Tue, 7 Mar 2017 22:39:18 +0800
Subject: [PATCH 11/46] fixed containsAll (#76)

---
 src/main/java/strman/Strman.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 2f7e809..6eb774d 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -175,7 +175,7 @@ public static boolean contains(final String value, final String needle, final bo
      */
     public static boolean containsAll(final String value, final String[] needles) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return Arrays.stream(needles).allMatch(needle -> contains(value, needle, true));
+        return Arrays.stream(needles).allMatch(needle -> contains(value, needle, false));
     }
 
     /**

From 84b33037186b7f4a0a6f90a0c7588c1493b28285 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A9sar=20Aguilera?= <cesar.aguilera.p@gmail.com>
Date: Tue, 9 May 2017 13:46:11 +0100
Subject: [PATCH 12/46] Feature required in #73 (#77)

---
 src/main/java/strman/Strman.java     | 25 ++++++++++++++++-
 src/test/java/strman/StrmanTest.java | 41 ++++++++++++++++++++++++++--
 2 files changed, 63 insertions(+), 3 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 6eb774d..2486956 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -34,6 +34,9 @@
 import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
+import static java.util.function.Function.identity;
+import static java.util.stream.Collectors.counting;
+import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.joining;
 
 /**
@@ -87,7 +90,7 @@ public static String appendArray(final String value, final String[] appends) {
      * @return an Optional String if found else empty
      */
     public static Optional<String> at(final String value, int index) {
-        if (value == null || value.isEmpty()) {
+        if (isNullOrEmpty(value)) {
             return Optional.empty();
         }
         int length = value.length();
@@ -97,6 +100,10 @@ public static Optional<String> at(final String value, int index) {
         return (index < length && index >= 0) ? Optional.of(String.valueOf(value.charAt(index))) : Optional.empty();
     }
 
+    private static boolean isNullOrEmpty(String input) {
+        return input == null || input.isEmpty();
+    }
+
     /**
      * Returns an array with strings between start and end.
      *
@@ -1302,4 +1309,20 @@ private static long countSubstr(String value, String subStr, boolean allowOverla
         }
         return countSubstr(value.substring(offset), subStr, allowOverlapping, ++count);
     }
+
+    /**
+     * Counts the number of occurrences of each character in the string
+     *
+     * @param input The input string
+     * @return A map containing the number of occurrences of each character in the string
+     */
+    public static Map<Character, Long> charsCount(String input) {
+        if (isNullOrEmpty(input)) {
+            return Collections.emptyMap();
+        }
+
+        return input.chars()
+                .mapToObj(c -> (char) c)
+                .collect(groupingBy(identity(), counting()));
+    }
 }
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index 176253c..84f18f6 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -29,8 +29,7 @@
 import org.junit.Ignore;
 import org.junit.Test;
 
-import java.util.Arrays;
-import java.util.Optional;
+import java.util.*;
 
 import static java.util.stream.Collectors.toList;
 import static org.hamcrest.CoreMatchers.*;
@@ -990,4 +989,42 @@ public void trimEnd_shouldRemoveAllTrailingSpecialCharacters() throws Exception
         assertThat(trimEnd("-_-abc!-_-", "_", "-", "!"), is(Optional.of("-_-abc")));
         assertThat(trimEnd("-_-abc#-_-", "_", "-", "!", "#"), is(Optional.of("-_-abc")));
     }
+
+
+    @Test
+    public void charsCount_shouldReturnEmptyWhenInputStringIsNull(){
+        assertThat(charsCount(null), equalTo(Collections.emptyMap()));
+    }
+
+    @Test
+    public void charsCount_shouldReturnEmptyWhenInputStringIsEmpty(){
+        assertThat(charsCount(""), equalTo(Collections.emptyMap()));
+    }
+
+    @Test
+    public void charsCount_shouldReturnCharsCountWhenInputIsASimpleString(){
+        Map<Character, Long> expectedOutput = new HashMap<Character, Long>(){{
+                put('a',1L);
+                put('b', 1L);
+                put('c', 1L);
+        }};
+
+        assertThat(charsCount("abc"), equalTo(expectedOutput));
+    }
+
+    @Test
+    public void charsCount_shouldReturnCharsCountWhenInputIsAComplexString(){
+        Map<Character, Long> expectedOutput = new HashMap<Character, Long>(){{
+            put('a',1L);
+            put('b', 2L);
+            put('c', 3L);
+
+            put('A',1L);
+            put('B', 2L);
+            put('C', 3L);
+            put('-', 10L);
+        }};
+
+        assertThat(charsCount("-----abbcccCCCBBA-----"), equalTo(expectedOutput));
+    }
 }
\ No newline at end of file

From 4d94035f170dc428937980ee8f7c5a0960a79846 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 12 May 2017 15:22:41 +0530
Subject: [PATCH 13/46] Formatted code to move private methods down

---
 src/main/java/strman/Strman.java | 33 ++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 2486956..08ddd2b 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1290,6 +1290,22 @@ public static Optional<String> trimEnd(final String input, String... chars) {
     }
 
 
+    /**
+     * Counts the number of occurrences of each character in the string
+     *
+     * @param input The input string
+     * @return A map containing the number of occurrences of each character in the string
+     */
+    public static Map<Character, Long> charsCount(String input) {
+        if (isNullOrEmpty(input)) {
+            return Collections.emptyMap();
+        }
+
+        return input.chars()
+                .mapToObj(c -> (char) c)
+                .collect(groupingBy(identity(), counting()));
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
@@ -1309,20 +1325,5 @@ private static long countSubstr(String value, String subStr, boolean allowOverla
         }
         return countSubstr(value.substring(offset), subStr, allowOverlapping, ++count);
     }
-
-    /**
-     * Counts the number of occurrences of each character in the string
-     *
-     * @param input The input string
-     * @return A map containing the number of occurrences of each character in the string
-     */
-    public static Map<Character, Long> charsCount(String input) {
-        if (isNullOrEmpty(input)) {
-            return Collections.emptyMap();
-        }
-
-        return input.chars()
-                .mapToObj(c -> (char) c)
-                .collect(groupingBy(identity(), counting()));
-    }
 }
+

From 5487cda192f601eacfd26d65d35d83f8134941a2 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 12 May 2017 15:25:46 +0530
Subject: [PATCH 14/46] [Gradle Release Plugin] - pre tag commit:  '0.3.0'.

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 401ddf4..c7f75a7 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.3.0-SNAPSHOT
\ No newline at end of file
+version=0.3.0
\ No newline at end of file

From 33b26a0244bf00a9db15b3d9493f4f8b12cd29e8 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 12 May 2017 15:26:19 +0530
Subject: [PATCH 15/46] [Gradle Release Plugin] - new version commit:  '
 0.4.0-SNAPSHOT'.

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index c7f75a7..18d2fac 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.3.0
\ No newline at end of file
+version= 0.4.0-SNAPSHOT
\ No newline at end of file

From 4f0cfaf75b6b97156854beb2d8b9c010920077cb Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 12 May 2017 15:35:31 +0530
Subject: [PATCH 16/46] Updated version to 0.3.0 in the README.md file

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 1e11a34..369cd94 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ For Apache Maven users, please add following to your pom.xml.
     <dependency>
         <groupId>com.shekhargulati</groupId>
         <artifactId>strman</artifactId>
-        <version>0.2.0</version>
+        <version>0.3.0</version>
     </dependency>
 </dependencies>
 ```
@@ -23,7 +23,7 @@ For Apache Maven users, please add following to your pom.xml.
 Gradle users can add following to their build.gradle file.
 
 ```
-compile(group: 'com.shekhargulati', name: 'strman', version: '0.2.0')
+compile(group: 'com.shekhargulati', name: 'strman', version: '0.3.0')
 ```
 
 ## Available Functions

From d6dbe785cb0e13a2598a024764b52d7070246d20 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 12 May 2017 15:43:26 +0530
Subject: [PATCH 17/46] Added changelog.md file

---
 changelog.md | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 changelog.md

diff --git a/changelog.md b/changelog.md
new file mode 100644
index 0000000..03f1e28
--- /dev/null
+++ b/changelog.md
@@ -0,0 +1,63 @@
+# Version 0.3.0 
+
+
+* __Feature required in #73 (#77)__: Added `charsCount` function
+
+    [César Aguilera](mailto:cesar.aguilera.p@gmail.com) - Tue, 9 May 2017 18:16:11 +0530
+
+    ​
+
+* __fixed bug in containsAll (#76)__
+
+    [wli75](mailto:wli75@illinois.edu) - Tue, 7 Mar 2017 20:09:18 +0530
+
+    ​
+
+* __Resolved #66__: Added `trimEnd` function
+
+    [Shekhar Gulati](mailto:shekhargulati84@gmail.com) - Wed, 24 Aug 2016 15:32:45 +0530
+
+    ​
+
+* __Resolved #65__: Added `trimStart`function
+
+    [Shekhar Gulati](mailto:shekhargulati84@gmail.com) - Wed, 24 Aug 2016 15:02:00 +0530
+
+    ​
+
+* __Resolved #68__: Added `upperFirst` function
+
+    [Shekhar Gulati](mailto:shekhargulati84@gmail.com) - Wed, 24 Aug 2016 14:26:16 +0530
+
+    ​
+
+* __Resolved #69__: Added `words` function
+
+    [Shekhar Gulati](mailto:shekhargulati84@gmail.com) - Wed, 24 Aug 2016 12:56:18 +0530
+
+    ​
+
+* __Resolved#71__: Added `isEnclosedBetween` function
+
+    [Shekhar Gulati](mailto:shekhargulati84@gmail.com) - Wed, 24 Aug 2016 12:11:04 +0530
+
+    ​
+
+* __Resolved #54 and Resolved #59__: Added `capitalize` and `lowerFirst` functions
+
+    [Shekhar Gulati](mailto:shekhargulati84@gmail.com) - Wed, 27 Jul 2016 23:19:41 +0530
+
+    ​
+
+* __Resolved #53__: Added `join` function
+
+    [Shekhar Gulati](mailto:shekhargulati84@gmail.com) - Mon, 25 Jul 2016 15:29:43 +0530
+
+    ​
+
+* __Simplify Maven and Gradle configuration (#70)__
+
+    [Marcin Zajączkowski](mailto:mszpak@wp.pl) - Tue, 19 Jul 2016 20:58:57 +0530
+
+
+

From 7bcc0df6a58b8a77bebbdeb67ee4d84b6e2edf7f Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 12 May 2017 16:01:33 +0530
Subject: [PATCH 18/46] Updated documentation to version 0.3.0

---
 README.md | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/README.md b/README.md
index 369cd94..466af5b 100644
--- a/README.md
+++ b/README.md
@@ -26,6 +26,8 @@ Gradle users can add following to their build.gradle file.
 compile(group: 'com.shekhargulati', name: 'strman', version: '0.3.0')
 ```
 
+To learn what we added in the latest version please refer to `./changelog.md`.
+
 ## Available Functions
 
 These are the available functions in current version of library:
@@ -80,6 +82,16 @@ chars("title")
 // result => ["t", "i", "t", "l", "e"]
 ```
 
+## charsCount
+
+Counts the number of occurrences of each character in the string
+
+```java
+import static strman.Strman.charsCount
+charsCount("abca")
+// result => Map(("a",2),("b",1),("c",1))
+```
+
 ## collapseWhitespace
 
 Replace consecutive whitespace characters with a single space.
@@ -496,6 +508,17 @@ transliterate("fóõ bár")
 // result => "foo bar"
 ```
 
+## trimEnd
+
+Removes trailing characters from string.
+
+```
+trimEnd("   abc   ")
+// result => Optional("   abc")
+trimEnd("")
+// result Optional.empty()
+```
+
 ## surround
 
 Surrounds a 'value' with the given 'prefix' and 'suffix'.
@@ -559,6 +582,42 @@ toSnakeCase("hello world")
 // result => "hello_world"
 ```
 
+## upperFirst
+
+Converts the first character of string to upper case.
+
+```java
+upperFirst("fred")
+// result => "Fred"
+```
+
+## words
+
+Splits a String to words
+
+```java
+words("This is a string, with words!")
+// result => ["This", "is", "a", "string", "with", "words"]
+```
+
+## isEnclosedBetween
+
+Verifies whether String is enclosed by encloser
+
+```java
+isEnclosedBetween("{{shekhar}}", "{{", "}}")
+// result => true
+```
+
+## join
+
+Join concatenates all the elements of the strings array into a single String. The separator string is placed between elements in the resulting string.
+
+```java
+join(new String[]{"hello","world","123"}, ";")
+// result => "hello;world;123")
+```
+
 License
 -------
 strman is licensed under the MIT License - see the `LICENSE` file for details.

From cf1d373442c123e477d6108520d2c61b78622e0d Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 12 May 2017 16:11:52 +0530
Subject: [PATCH 19/46] Updated README.md

---
 README.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 466af5b..a671ca8 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 strman-java [![Build Status](https://travis-ci.org/shekhargulati/strman-java.svg?branch=master)](https://travis-ci.org/shekhargulati/strman-java) [![codecov.io](https://codecov.io/github/shekhargulati/strman-java/coverage.svg?branch=master)](https://codecov.io/github/shekhargulati/strman-java?branch=master) [![License](https://img.shields.io/:license-mit-blue.svg)](./LICENSE.txt)
 ------
 
-A Java 8 library for working with String. It is inspired by [dleitee/strman](https://github.com/dleitee/strman).
+A Java 8 library for working with String. You can refer to Javadocs online [http://shekhargulati.github.io/strman-java/](http://shekhargulati.github.io/strman-java/).
 
 Getting Started
 --------
@@ -618,6 +618,10 @@ join(new String[]{"hello","world","123"}, ";")
 // result => "hello;world;123")
 ```
 
+## Inspiration
+
+This library is inspired by [dleitee/strman](https://github.com/dleitee/strman).
+
 License
 -------
 strman is licensed under the MIT License - see the `LICENSE` file for details.

From 18776342340e2617b28bce4fba5716993d0f2e67 Mon Sep 17 00:00:00 2001
From: Andy Deese <james.deese@gmail.com>
Date: Fri, 19 May 2017 09:18:15 -0400
Subject: [PATCH 20/46] added isBlank method, along with junit test and readme
 update

---
 .classpath                                 |  8 ++++++++
 .gitignore                                 |  1 +
 .project                                   | 23 ++++++++++++++++++++++
 .settings/org.eclipse.buildship.core.prefs |  3 +++
 README.md                                  | 13 ++++++++++++
 src/main/java/strman/Strman.java           | 14 +++++++++++++
 src/test/java/strman/StrmanTest.java       |  9 +++++++--
 7 files changed, 69 insertions(+), 2 deletions(-)
 create mode 100644 .classpath
 create mode 100644 .project
 create mode 100644 .settings/org.eclipse.buildship.core.prefs

diff --git a/.classpath b/.classpath
new file mode 100644
index 0000000..9f084aa
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src/main/java"/>
+	<classpathentry kind="src" path="src/test/java"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/.gitignore b/.gitignore
index 48267e9..d6a4cf2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -71,3 +71,4 @@ hs_err_pid*
 
 !gradle/wrapper/gradle-wrapper.jar
 
+/bin/
diff --git a/.project b/.project
new file mode 100644
index 0000000..0a4059d
--- /dev/null
+++ b/.project
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>strman</name>
+	<comment>Project strman created by Buildship.</comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/.settings/org.eclipse.buildship.core.prefs b/.settings/org.eclipse.buildship.core.prefs
new file mode 100644
index 0000000..03931c0
--- /dev/null
+++ b/.settings/org.eclipse.buildship.core.prefs
@@ -0,0 +1,3 @@
+connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)
+connection.project.dir=
+eclipse.preferences.version=1
diff --git a/README.md b/README.md
index a671ca8..9bca612 100644
--- a/README.md
+++ b/README.md
@@ -618,6 +618,19 @@ join(new String[]{"hello","world","123"}, ";")
 // result => "hello;world;123")
 ```
 
+## isBlank
+
+isEmpty returns true if a string is blank or null and false otherwise.
+
+```java
+isBlank("")
+// result => true)
+isBlank(null)
+// result => true)
+isBlank("test")
+// result => false)
+```
+
 ## Inspiration
 
 This library is inspired by [dleitee/strman](https://github.com/dleitee/strman).
diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 08ddd2b..70dc783 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -38,6 +38,9 @@
 import static java.util.stream.Collectors.counting;
 import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.joining;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static strman.Strman.isBlank;
 
 /**
  * A String manipulation library without any dependencies
@@ -1305,6 +1308,16 @@ public static Map<Character, Long> charsCount(String input) {
                 .mapToObj(c -> (char) c)
                 .collect(groupingBy(identity(), counting()));
     }
+    
+    /**
+     * Checks if string is empty.  This is a null safe check and will return true when string is null.
+     *
+     * @param input The input string
+     * @return true if string is null or empty
+     */
+	public static boolean isBlank(String input) {
+		return input == null || input.isEmpty();
+	}
 
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
@@ -1325,5 +1338,6 @@ private static long countSubstr(String value, String subStr, boolean allowOverla
         }
         return countSubstr(value.substring(offset), subStr, allowOverlapping, ++count);
     }
+    
 }
 
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index 84f18f6..a4fcc8b 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -37,8 +37,6 @@
 import static org.hamcrest.collection.IsArrayWithSize.emptyArray;
 import static org.junit.Assert.*;
 import static strman.Strman.*;
-import static strman.Strman.endsWith;
-import static strman.Strman.format;
 
 public class StrmanTest {
 
@@ -1027,4 +1025,11 @@ public void charsCount_shouldReturnCharsCountWhenInputIsAComplexString(){
 
         assertThat(charsCount("-----abbcccCCCBBA-----"), equalTo(expectedOutput));
     }
+    
+    @Test
+    public void testIsBlank() {
+    	assertTrue(isBlank(""));
+    	assertTrue(isBlank(null));
+    	assertFalse(isBlank("ac"));
+    }
 }
\ No newline at end of file

From fad14c5f40c7021d71e90839d56624204c8f88f3 Mon Sep 17 00:00:00 2001
From: Andy Deese <james.deese@gmail.com>
Date: Fri, 19 May 2017 09:24:56 -0400
Subject: [PATCH 21/46] removing local files

---
 .classpath                                 |  8 ---
 .gitignore                                 | 74 ----------------------
 .project                                   | 23 -------
 .settings/org.eclipse.buildship.core.prefs |  3 -
 4 files changed, 108 deletions(-)
 delete mode 100644 .classpath
 delete mode 100644 .gitignore
 delete mode 100644 .project
 delete mode 100644 .settings/org.eclipse.buildship.core.prefs

diff --git a/.classpath b/.classpath
deleted file mode 100644
index 9f084aa..0000000
--- a/.classpath
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src/main/java"/>
-	<classpathentry kind="src" path="src/test/java"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
-	<classpathentry kind="con" path="org.eclipse.buildship.core.gradleclasspathcontainer"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index d6a4cf2..0000000
--- a/.gitignore
+++ /dev/null
@@ -1,74 +0,0 @@
-# Created by .ignore support plugin (hsz.mobi)
-### JetBrains template
-# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio
-
-*.iml
-
-## Directory-based project format:
-.idea/
-# if you remove the above rule, at least ignore the following:
-
-# User-specific stuff:
-# .idea/workspace.xml
-# .idea/tasks.xml
-# .idea/dictionaries
-
-# Sensitive or high-churn files:
-# .idea/dataSources.ids
-# .idea/dataSources.xml
-# .idea/sqlDataSources.xml
-# .idea/dynamic.xml
-# .idea/uiDesigner.xml
-
-# Gradle:
-# .idea/gradle.xml
-# .idea/libraries
-
-# Mongo Explorer plugin:
-# .idea/mongoSettings.xml
-
-## File-based project format:
-*.ipr
-*.iws
-
-## Plugin-specific files:
-
-# IntelliJ
-/out/
-
-# mpeltonen/sbt-idea plugin
-.idea_modules/
-
-# JIRA plugin
-atlassian-ide-plugin.xml
-
-# Crashlytics plugin (for Android Studio and IntelliJ)
-com_crashlytics_export_strings.xml
-crashlytics.properties
-crashlytics-build.properties
-### Gradle template
-.gradle
-build/
-
-# Ignore Gradle GUI config
-gradle-app.setting
-
-# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
-!gradle-wrapper.jar
-### Java template
-*.class
-
-# Mobile Tools for Java (J2ME)
-.mtj.tmp/
-
-# Package Files #
-*.jar
-*.war
-*.ear
-
-# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
-hs_err_pid*
-
-!gradle/wrapper/gradle-wrapper.jar
-
-/bin/
diff --git a/.project b/.project
deleted file mode 100644
index 0a4059d..0000000
--- a/.project
+++ /dev/null
@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>strman</name>
-	<comment>Project strman created by Buildship.</comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>
diff --git a/.settings/org.eclipse.buildship.core.prefs b/.settings/org.eclipse.buildship.core.prefs
deleted file mode 100644
index 03931c0..0000000
--- a/.settings/org.eclipse.buildship.core.prefs
+++ /dev/null
@@ -1,3 +0,0 @@
-connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)
-connection.project.dir=
-eclipse.preferences.version=1

From f1e8e83cc05a8bb8b393130a58fec4a5316aa3fa Mon Sep 17 00:00:00 2001
From: Andy Deese <james.deese@gmail.com>
Date: Fri, 19 May 2017 09:28:47 -0400
Subject: [PATCH 22/46] adding gitignore with Eclipse specific files ignored

---
 .gitignore | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6c9b373
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,78 @@
+# Created by .ignore support plugin (hsz.mobi)
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio
+
+*.iml
+
+## Directory-based project format:
+.idea/
+# if you remove the above rule, at least ignore the following:
+
+# User-specific stuff:
+# .idea/workspace.xml
+# .idea/tasks.xml
+# .idea/dictionaries
+
+# Sensitive or high-churn files:
+# .idea/dataSources.ids
+# .idea/dataSources.xml
+# .idea/sqlDataSources.xml
+# .idea/dynamic.xml
+# .idea/uiDesigner.xml
+
+# Gradle:
+# .idea/gradle.xml
+# .idea/libraries
+
+# Mongo Explorer plugin:
+# .idea/mongoSettings.xml
+
+## File-based project format:
+*.ipr
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+### Gradle template
+.gradle
+build/
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+### Java template
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+!gradle/wrapper/gradle-wrapper.jar
+
+/bin/
+
+.classpath
+.project
+.settings

From 04b9f8a7b4d0d022c6a3e4ff36f958a04d5d2b13 Mon Sep 17 00:00:00 2001
From: Andy Deese <james.deese@gmail.com>
Date: Fri, 19 May 2017 09:49:13 -0400
Subject: [PATCH 23/46] removed unused imports from Strman.java and split tests
 out to match current test convention

---
 src/main/java/strman/Strman.java     |  3 ---
 src/test/java/strman/StrmanTest.java | 12 ++++++++++--
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 70dc783..8f2eaa1 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -38,9 +38,6 @@
 import static java.util.stream.Collectors.counting;
 import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.joining;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static strman.Strman.isBlank;
 
 /**
  * A String manipulation library without any dependencies
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index a4fcc8b..328b962 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -1027,9 +1027,17 @@ public void charsCount_shouldReturnCharsCountWhenInputIsAComplexString(){
     }
     
     @Test
-    public void testIsBlank() {
-    	assertTrue(isBlank(""));
+    public void isBlank_shouldReturnTrueIfNull() {
     	assertTrue(isBlank(null));
+    }
+    
+    @Test
+    public void isBlank_shouldReturnTrueIfEmpty() {
+    	assertTrue(isBlank(""));
+    }
+    
+    @Test
+    public void isBlank_shouldReturnFalseIfNotEmpty() {
     	assertFalse(isBlank("ac"));
     }
 }
\ No newline at end of file

From d04e679b07e58bb83f8293d8c6ebad6ada0147a6 Mon Sep 17 00:00:00 2001
From: Andy Deese <james.deese@gmail.com>
Date: Fri, 19 May 2017 21:27:21 -0400
Subject: [PATCH 24/46] Adding isBlank method (#89)

* added isBlank method, along with junit test and readme update

* removing local files

* adding gitignore with Eclipse specific files ignored

* removed unused imports from Strman.java and split tests out to match current test convention
---
 .gitignore                           |  5 +++++
 README.md                            | 13 +++++++++++++
 src/main/java/strman/Strman.java     | 11 +++++++++++
 src/test/java/strman/StrmanTest.java | 17 +++++++++++++++--
 4 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 48267e9..6c9b373 100644
--- a/.gitignore
+++ b/.gitignore
@@ -71,3 +71,8 @@ hs_err_pid*
 
 !gradle/wrapper/gradle-wrapper.jar
 
+/bin/
+
+.classpath
+.project
+.settings
diff --git a/README.md b/README.md
index a671ca8..9bca612 100644
--- a/README.md
+++ b/README.md
@@ -618,6 +618,19 @@ join(new String[]{"hello","world","123"}, ";")
 // result => "hello;world;123")
 ```
 
+## isBlank
+
+isEmpty returns true if a string is blank or null and false otherwise.
+
+```java
+isBlank("")
+// result => true)
+isBlank(null)
+// result => true)
+isBlank("test")
+// result => false)
+```
+
 ## Inspiration
 
 This library is inspired by [dleitee/strman](https://github.com/dleitee/strman).
diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 08ddd2b..8f2eaa1 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1305,6 +1305,16 @@ public static Map<Character, Long> charsCount(String input) {
                 .mapToObj(c -> (char) c)
                 .collect(groupingBy(identity(), counting()));
     }
+    
+    /**
+     * Checks if string is empty.  This is a null safe check and will return true when string is null.
+     *
+     * @param input The input string
+     * @return true if string is null or empty
+     */
+	public static boolean isBlank(String input) {
+		return input == null || input.isEmpty();
+	}
 
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
@@ -1325,5 +1335,6 @@ private static long countSubstr(String value, String subStr, boolean allowOverla
         }
         return countSubstr(value.substring(offset), subStr, allowOverlapping, ++count);
     }
+    
 }
 
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index 84f18f6..328b962 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -37,8 +37,6 @@
 import static org.hamcrest.collection.IsArrayWithSize.emptyArray;
 import static org.junit.Assert.*;
 import static strman.Strman.*;
-import static strman.Strman.endsWith;
-import static strman.Strman.format;
 
 public class StrmanTest {
 
@@ -1027,4 +1025,19 @@ public void charsCount_shouldReturnCharsCountWhenInputIsAComplexString(){
 
         assertThat(charsCount("-----abbcccCCCBBA-----"), equalTo(expectedOutput));
     }
+    
+    @Test
+    public void isBlank_shouldReturnTrueIfNull() {
+    	assertTrue(isBlank(null));
+    }
+    
+    @Test
+    public void isBlank_shouldReturnTrueIfEmpty() {
+    	assertTrue(isBlank(""));
+    }
+    
+    @Test
+    public void isBlank_shouldReturnFalseIfNotEmpty() {
+    	assertFalse(isBlank("ac"));
+    }
 }
\ No newline at end of file

From 6bbcb5313842bb28c49041a28ed2ff594848ef9d Mon Sep 17 00:00:00 2001
From: Andy Deese <james.deese@gmail.com>
Date: Sat, 20 May 2017 12:01:13 -0400
Subject: [PATCH 25/46] Added underscored method with tests and documentation

---
 README.md                            | 10 ++++++++++
 src/main/java/strman/Strman.java     | 28 +++++++++++++++++++++++++++-
 src/test/java/strman/StrmanTest.java | 16 ++++++++++++++++
 3 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9bca612..ba9bd6d 100644
--- a/README.md
+++ b/README.md
@@ -631,6 +631,16 @@ isBlank("test")
 // result => false)
 ```
 
+## underscored
+
+underscored returns a string that represents the passed in string in all lowercase and underscores
+between words.
+
+```java
+underscored("MozTransform")
+// result => "moz_transform")
+```
+
 ## Inspiration
 
 This library is inspired by [dleitee/strman](https://github.com/dleitee/strman).
diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 8f2eaa1..65ea031 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1310,12 +1310,38 @@ public static Map<Character, Long> charsCount(String input) {
      * Checks if string is empty.  This is a null safe check and will return true when string is null.
      *
      * @param input The input string
-     * @return true if string is null or empty
+     * @return true if input string is null or empty
      */
 	public static boolean isBlank(String input) {
 		return input == null || input.isEmpty();
 	}
 
+    /**
+     * Changes passed in string to all lower case and adds underscore between words.
+     *
+     * @param input The input string
+     * @return the input string in all lower case with underscores between words
+     */
+	public static String underscored(String input) {
+		String result = null;
+		if (input != null) {
+			StringBuffer resultBuffer = new StringBuffer();
+			char[] inputArray = input.toCharArray();
+			for(int i = 0; i < inputArray.length; i++) {
+				char nextChar = inputArray[i];
+				if (Character.isUpperCase(nextChar)) {
+					//start new word
+					if (resultBuffer.length() != 0) {
+						resultBuffer.append("_");
+					}
+				}
+				resultBuffer.append(nextChar);
+			}
+			result = resultBuffer.toString().toLowerCase();
+		}
+		return result;
+	}
+	
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index 328b962..9e640c2 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -1040,4 +1040,20 @@ public void isBlank_shouldReturnTrueIfEmpty() {
     public void isBlank_shouldReturnFalseIfNotEmpty() {
     	assertFalse(isBlank("ac"));
     }
+    
+    @Test
+    public void underscored_shouldReturnUnderscoredString() {
+    	assertThat(underscored("MozTransform"), equalTo("moz_transform"));
+    }
+    
+    @Test
+    public void underscored_shouldReturnEmptyStringIfEmptyStringPassedIn() {
+    	assertThat(underscored(""), equalTo(""));
+    }
+    
+    @Test
+    public void underscored_shouldReturnNullIfNullPassedIn() {
+    	assertThat(underscored(null), equalTo(null));
+    }
+
 }
\ No newline at end of file

From a4d2c2aa413ff3924bd617f22a165a256655e99f Mon Sep 17 00:00:00 2001
From: Andy Deese <james.deese@gmail.com>
Date: Sat, 20 May 2017 12:01:13 -0400
Subject: [PATCH 26/46] Added underscored method with tests and documentation

---
 README.md                            | 10 ++++++++++
 src/main/java/strman/Strman.java     | 28 +++++++++++++++++++++++++++-
 src/test/java/strman/StrmanTest.java | 16 ++++++++++++++++
 3 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9bca612..ba9bd6d 100644
--- a/README.md
+++ b/README.md
@@ -631,6 +631,16 @@ isBlank("test")
 // result => false)
 ```
 
+## underscored
+
+underscored returns a string that represents the passed in string in all lowercase and underscores
+between words.
+
+```java
+underscored("MozTransform")
+// result => "moz_transform")
+```
+
 ## Inspiration
 
 This library is inspired by [dleitee/strman](https://github.com/dleitee/strman).
diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 8f2eaa1..65ea031 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1310,12 +1310,38 @@ public static Map<Character, Long> charsCount(String input) {
      * Checks if string is empty.  This is a null safe check and will return true when string is null.
      *
      * @param input The input string
-     * @return true if string is null or empty
+     * @return true if input string is null or empty
      */
 	public static boolean isBlank(String input) {
 		return input == null || input.isEmpty();
 	}
 
+    /**
+     * Changes passed in string to all lower case and adds underscore between words.
+     *
+     * @param input The input string
+     * @return the input string in all lower case with underscores between words
+     */
+	public static String underscored(String input) {
+		String result = null;
+		if (input != null) {
+			StringBuffer resultBuffer = new StringBuffer();
+			char[] inputArray = input.toCharArray();
+			for(int i = 0; i < inputArray.length; i++) {
+				char nextChar = inputArray[i];
+				if (Character.isUpperCase(nextChar)) {
+					//start new word
+					if (resultBuffer.length() != 0) {
+						resultBuffer.append("_");
+					}
+				}
+				resultBuffer.append(nextChar);
+			}
+			result = resultBuffer.toString().toLowerCase();
+		}
+		return result;
+	}
+	
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index 328b962..9e640c2 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -1040,4 +1040,20 @@ public void isBlank_shouldReturnTrueIfEmpty() {
     public void isBlank_shouldReturnFalseIfNotEmpty() {
     	assertFalse(isBlank("ac"));
     }
+    
+    @Test
+    public void underscored_shouldReturnUnderscoredString() {
+    	assertThat(underscored("MozTransform"), equalTo("moz_transform"));
+    }
+    
+    @Test
+    public void underscored_shouldReturnEmptyStringIfEmptyStringPassedIn() {
+    	assertThat(underscored(""), equalTo(""));
+    }
+    
+    @Test
+    public void underscored_shouldReturnNullIfNullPassedIn() {
+    	assertThat(underscored(null), equalTo(null));
+    }
+
 }
\ No newline at end of file

From 4369f904c9976c7498065e0b2e777fce28b90c7f Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Sat, 20 May 2017 23:24:21 +0530
Subject: [PATCH 27/46] #84 improved implementation of underscored function to
 incorporate whitespace, dashed strings. Also, cleaned up the code.

---
 README.md                            |   3 +-
 src/main/java/strman/Strman.java     | 156 +++++++++++----------------
 src/test/java/strman/StrmanTest.java |  56 +++++-----
 3 files changed, 97 insertions(+), 118 deletions(-)

diff --git a/README.md b/README.md
index ba9bd6d..7dce744 100644
--- a/README.md
+++ b/README.md
@@ -633,8 +633,7 @@ isBlank("test")
 
 ## underscored
 
-underscored returns a string that represents the passed in string in all lowercase and underscores
-between words.
+`underscored` function converts a camel or dashed string into an underscored one
 
 ```java
 underscored("MozTransform")
diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 65ea031..dff10a4 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1,4 +1,3 @@
-
 /*
  *
  *  * The MIT License
@@ -35,9 +34,7 @@
 import java.util.stream.Stream;
 
 import static java.util.function.Function.identity;
-import static java.util.stream.Collectors.counting;
-import static java.util.stream.Collectors.groupingBy;
-import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.*;
 
 /**
  * A String manipulation library without any dependencies
@@ -119,7 +116,8 @@ public static String[] between(final String value, final String start, final Str
         validate(end, NULL_STRING_PREDICATE, () -> "'end' should be not null.");
 
         String[] parts = value.split(end);
-        return Arrays.stream(parts).map(subPart -> subPart.substring(subPart.indexOf(start) + start.length())).toArray(String[]::new);
+        return Arrays.stream(parts).map(subPart -> subPart.substring(subPart.indexOf(start) + start.length()))
+                .toArray(String[]::new);
     }
 
     /**
@@ -133,7 +131,6 @@ public static String[] chars(final String value) {
         return value.split("");
     }
 
-
     /**
      * Replace consecutive whitespace characters with a single space.
      *
@@ -145,7 +142,6 @@ public static String collapseWhitespace(final String value) {
         return value.trim().replaceAll("\\s\\s+", " ");
     }
 
-
     /**
      * Verifies that the needle is contained in the value. The search is case insensitive
      *
@@ -242,9 +238,11 @@ public static long countSubstr(final String value, final String subStr) {
      * @param allowOverlapping boolean to take into account overlapping
      * @return count of times substring exists
      */
-    public static long countSubstr(final String value, final String subStr, final boolean caseSensitive, boolean allowOverlapping) {
+    public static long countSubstr(final String value, final String subStr, final boolean caseSensitive,
+                                   boolean allowOverlapping) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return countSubstr(caseSensitive ? value : value.toLowerCase(), caseSensitive ? subStr : subStr.toLowerCase(), allowOverlapping, 0L);
+        return countSubstr(caseSensitive ? value : value.toLowerCase(), caseSensitive ? subStr : subStr.toLowerCase(),
+                allowOverlapping, 0L);
     }
 
     /**
@@ -281,7 +279,8 @@ public static boolean endsWith(final String value, final String search, final bo
      * @param caseSensitive true or false
      * @return true or false
      */
-    public static boolean endsWith(final String value, final String search, final int position, final boolean caseSensitive) {
+    public static boolean endsWith(final String value, final String search, final int position,
+                                   final boolean caseSensitive) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
         int remainingLength = position - search.length();
         if (caseSensitive) {
@@ -640,7 +639,8 @@ public static int lastIndexOf(final String value, final String needle, boolean c
      * @param caseSensitive whether search should be case sensitive
      * @return Return position of the last occurrence of 'needle'.
      */
-    public static int lastIndexOf(final String value, final String needle, final int offset, final boolean caseSensitive) {
+    public static int lastIndexOf(final String value, final String needle, final int offset,
+                                  final boolean caseSensitive) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
         validate(needle, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
         if (caseSensitive) {
@@ -775,7 +775,8 @@ public static String removeRight(final String value, final String suffix) {
     public static String removeRight(final String value, final String suffix, final boolean caseSensitive) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
         validate(suffix, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return endsWith(value, suffix, caseSensitive) ? value.substring(0, value.toLowerCase().lastIndexOf(suffix.toLowerCase())) : value;
+        return endsWith(value, suffix, caseSensitive) ? value
+                .substring(0, value.toLowerCase().lastIndexOf(suffix.toLowerCase())) : value;
     }
 
     /**
@@ -810,13 +811,15 @@ public static String repeat(final String value, final int multiplier) {
      * @param caseSensitive whether search should be case sensitive or not
      * @return String replaced with 'newvalue'.
      */
-    public static String replace(final String value, final String search, final String newValue, final boolean caseSensitive) {
+    public static String replace(final String value, final String search, final String newValue,
+                                 final boolean caseSensitive) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
         validate(search, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
         if (caseSensitive) {
             return value.replace(search, newValue);
         }
-        return Pattern.compile(search, Pattern.CASE_INSENSITIVE).matcher(value).replaceAll(Matcher.quoteReplacement(newValue));
+        return Pattern.compile(search, Pattern.CASE_INSENSITIVE).matcher(value)
+                .replaceAll(Matcher.quoteReplacement(newValue));
     }
 
     /**
@@ -950,11 +953,8 @@ public static String htmlDecode(final String encodedHtml) {
      */
     public static String htmlEncode(final String html) {
         validate(html, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return html
-                .chars()
-                .mapToObj(c -> "\\u" + String.format("%04x", c).toUpperCase())
-                .map(HtmlEntities.encodedEntities::get)
-                .collect(joining());
+        return html.chars().mapToObj(c -> "\\u" + String.format("%04x", c).toUpperCase())
+                .map(HtmlEntities.encodedEntities::get).collect(joining());
     }
 
     /**
@@ -1019,7 +1019,6 @@ public static String transliterate(final String value) {
         return result;
     }
 
-
     /**
      * Surrounds a 'value' with the given 'prefix' and 'suffix'.
      *
@@ -1055,10 +1054,7 @@ public static String toCamelCase(final String value) {
     public static String toStudlyCase(final String value) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
         String[] words = collapseWhitespace(value.trim()).split("\\s*(_|-|\\s)\\s*");
-        return Arrays.stream(words)
-                .filter(w -> !w.trim().isEmpty())
-                .map(Strman::upperFirst)
-                .collect(joining());
+        return Arrays.stream(words).filter(w -> !w.trim().isEmpty()).map(Strman::upperFirst).collect(joining());
     }
 
     /**
@@ -1106,8 +1102,7 @@ public static String toSnakeCase(final String value) {
 
     public static String decode(final String value, final int digits, final int radix) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return Arrays
-                .stream(value.split("(?<=\\G.{" + digits + "})"))
+        return Arrays.stream(value.split("(?<=\\G.{" + digits + "})"))
                 .map(data -> String.valueOf(Character.toChars(Integer.parseInt(data, radix))))
                 .collect(joining());
     }
@@ -1117,7 +1112,6 @@ public static String encode(final String value, final int digits, final int radi
         return value.chars().mapToObj(ch -> leftPad(Integer.toString(ch, radix), "0", digits)).collect(joining());
     }
 
-
     /**
      * Join concatenates all the elements of the strings array into a single String. The separator string is placed between elements in the resulting string.
      *
@@ -1152,11 +1146,7 @@ public static String capitalize(final String input) throws IllegalArgumentExcept
         if (input.length() == 0) {
             return "";
         }
-        return head(input)
-                .map(String::toUpperCase)
-                .map(h ->
-                        tail(input).map(t -> h + t.toLowerCase()).orElse(h))
-                .get();
+        return head(input).map(String::toUpperCase).map(h -> tail(input).map(t -> h + t.toLowerCase()).orElse(h)).get();
     }
 
     /**
@@ -1174,11 +1164,7 @@ public static String lowerFirst(final String input) throws IllegalArgumentExcept
             return "";
         }
 
-        return head(input)
-                .map(String::toLowerCase)
-                .map(h ->
-                        tail(input).map(t -> h + t).orElse(h))
-                .get();
+        return head(input).map(String::toLowerCase).map(h -> tail(input).map(t -> h + t).orElse(h)).get();
     }
 
     /**
@@ -1223,10 +1209,7 @@ public static String upperFirst(String input) {
         if (input == null) {
             throw new IllegalArgumentException("input can't be null");
         }
-        return head(input)
-                .map(String::toUpperCase)
-                .map(h -> tail(input).map(t -> h + t).orElse(h))
-                .get();
+        return head(input).map(String::toUpperCase).map(h -> tail(input).map(t -> h + t).orElse(h)).get();
     }
 
     /**
@@ -1236,27 +1219,21 @@ public static String upperFirst(String input) {
      * @return Returns the trimmed string.
      */
     public static Optional<String> trimStart(final String input) {
-        return Optional.ofNullable(input)
-                .filter(v -> !v.isEmpty())
-                .map(Strman::leftTrim);
+        return Optional.ofNullable(input).filter(v -> !v.isEmpty()).map(Strman::leftTrim);
     }
 
-
     /**
      * Removes leading characters from string.
      *
      * @param input The string to trim.
      * @param chars The characters to trim.
-     *
      * @return Returns the trimmed string.
      */
     public static Optional<String> trimStart(final String input, String... chars) {
-        return Optional.ofNullable(input)
-                .filter(v -> !v.isEmpty())
-                .map(v -> {
-                    String pattern = String.format("^[%s]+", join(chars, "\\"));
-                    return v.replaceAll(pattern, "");
-                });
+        return Optional.ofNullable(input).filter(v -> !v.isEmpty()).map(v -> {
+            String pattern = String.format("^[%s]+", join(chars, "\\"));
+            return v.replaceAll(pattern, "");
+        });
     }
 
     /**
@@ -1266,30 +1243,23 @@ public static Optional<String> trimStart(final String input, String... chars) {
      * @return Returns the trimmed string.
      */
     public static Optional<String> trimEnd(final String input) {
-        return Optional.ofNullable(input)
-                .filter(v -> !v.isEmpty())
-                .map(Strman::rightTrim);
+        return Optional.ofNullable(input).filter(v -> !v.isEmpty()).map(Strman::rightTrim);
     }
 
-
     /**
      * Removes trailing characters from string.
      *
      * @param input The string to trim.
      * @param chars The characters to trim.
-     *
      * @return Returns the trimmed string.
      */
     public static Optional<String> trimEnd(final String input, String... chars) {
-        return Optional.ofNullable(input)
-                .filter(v -> !v.isEmpty())
-                .map(v -> {
-                    String pattern = String.format("[%s]+$", join(chars, "\\"));
-                    return v.replaceAll(pattern, "");
-                });
+        return Optional.ofNullable(input).filter(v -> !v.isEmpty()).map(v -> {
+            String pattern = String.format("[%s]+$", join(chars, "\\"));
+            return v.replaceAll(pattern, "");
+        });
     }
 
-
     /**
      * Counts the number of occurrences of each character in the string
      *
@@ -1301,20 +1271,18 @@ public static Map<Character, Long> charsCount(String input) {
             return Collections.emptyMap();
         }
 
-        return input.chars()
-                .mapToObj(c -> (char) c)
-                .collect(groupingBy(identity(), counting()));
+        return input.chars().mapToObj(c -> (char) c).collect(groupingBy(identity(), counting()));
     }
-    
+
     /**
      * Checks if string is empty.  This is a null safe check and will return true when string is null.
      *
      * @param input The input string
      * @return true if input string is null or empty
      */
-	public static boolean isBlank(String input) {
-		return input == null || input.isEmpty();
-	}
+    public static boolean isBlank(String input) {
+        return input == null || input.isEmpty();
+    }
 
     /**
      * Changes passed in string to all lower case and adds underscore between words.
@@ -1322,26 +1290,30 @@ public static boolean isBlank(String input) {
      * @param input The input string
      * @return the input string in all lower case with underscores between words
      */
-	public static String underscored(String input) {
-		String result = null;
-		if (input != null) {
-			StringBuffer resultBuffer = new StringBuffer();
-			char[] inputArray = input.toCharArray();
-			for(int i = 0; i < inputArray.length; i++) {
-				char nextChar = inputArray[i];
-				if (Character.isUpperCase(nextChar)) {
-					//start new word
-					if (resultBuffer.length() != 0) {
-						resultBuffer.append("_");
-					}
-				}
-				resultBuffer.append(nextChar);
-			}
-			result = resultBuffer.toString().toLowerCase();
-		}
-		return result;
-	}
-	
+    public static String underscored(final String input) {
+        if (input == null) {
+            return null;
+        }
+        StringBuilder builder = new StringBuilder();
+        char[] chars = collapseWhitespace(input).toCharArray();
+        for (int index = 0; index < chars.length; index++) {
+            char ch = chars[index];
+            if (index > 0) {
+                if (ch == '-' || Character.isWhitespace(ch)) {
+                    builder.append("_");
+                } else if (Character.isUpperCase(ch)) {
+                    builder.append("_");
+                    builder.append(ch);
+                } else {
+                    builder.append(ch);
+                }
+            } else {
+                builder.append(ch);
+            }
+        }
+        return builder.toString().toLowerCase();
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
@@ -1361,6 +1333,6 @@ private static long countSubstr(String value, String subStr, boolean allowOverla
         }
         return countSubstr(value.substring(offset), subStr, allowOverlapping, ++count);
     }
-    
+
 }
 
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index 9e640c2..3ca9e18 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -37,6 +37,7 @@
 import static org.hamcrest.collection.IsArrayWithSize.emptyArray;
 import static org.junit.Assert.*;
 import static strman.Strman.*;
+import static strman.Strman.endsWith;
 
 public class StrmanTest {
 
@@ -990,34 +991,34 @@ public void trimEnd_shouldRemoveAllTrailingSpecialCharacters() throws Exception
 
 
     @Test
-    public void charsCount_shouldReturnEmptyWhenInputStringIsNull(){
+    public void charsCount_shouldReturnEmptyWhenInputStringIsNull() {
         assertThat(charsCount(null), equalTo(Collections.emptyMap()));
     }
 
     @Test
-    public void charsCount_shouldReturnEmptyWhenInputStringIsEmpty(){
+    public void charsCount_shouldReturnEmptyWhenInputStringIsEmpty() {
         assertThat(charsCount(""), equalTo(Collections.emptyMap()));
     }
 
     @Test
-    public void charsCount_shouldReturnCharsCountWhenInputIsASimpleString(){
-        Map<Character, Long> expectedOutput = new HashMap<Character, Long>(){{
-                put('a',1L);
-                put('b', 1L);
-                put('c', 1L);
+    public void charsCount_shouldReturnCharsCountWhenInputIsASimpleString() {
+        Map<Character, Long> expectedOutput = new HashMap<Character, Long>() {{
+            put('a', 1L);
+            put('b', 1L);
+            put('c', 1L);
         }};
 
         assertThat(charsCount("abc"), equalTo(expectedOutput));
     }
 
     @Test
-    public void charsCount_shouldReturnCharsCountWhenInputIsAComplexString(){
-        Map<Character, Long> expectedOutput = new HashMap<Character, Long>(){{
-            put('a',1L);
+    public void charsCount_shouldReturnCharsCountWhenInputIsAComplexString() {
+        Map<Character, Long> expectedOutput = new HashMap<Character, Long>() {{
+            put('a', 1L);
             put('b', 2L);
             put('c', 3L);
 
-            put('A',1L);
+            put('A', 1L);
             put('B', 2L);
             put('C', 3L);
             put('-', 10L);
@@ -1025,35 +1026,42 @@ public void charsCount_shouldReturnCharsCountWhenInputIsAComplexString(){
 
         assertThat(charsCount("-----abbcccCCCBBA-----"), equalTo(expectedOutput));
     }
-    
+
     @Test
     public void isBlank_shouldReturnTrueIfNull() {
-    	assertTrue(isBlank(null));
+        assertTrue(isBlank(null));
     }
-    
+
     @Test
     public void isBlank_shouldReturnTrueIfEmpty() {
-    	assertTrue(isBlank(""));
+        assertTrue(isBlank(""));
     }
-    
+
     @Test
     public void isBlank_shouldReturnFalseIfNotEmpty() {
-    	assertFalse(isBlank("ac"));
+        assertFalse(isBlank("ac"));
     }
-    
+
     @Test
     public void underscored_shouldReturnUnderscoredString() {
-    	assertThat(underscored("MozTransform"), equalTo("moz_transform"));
+        assertThat(underscored("MozTransform"), equalTo("moz_transform"));
     }
-    
+
     @Test
     public void underscored_shouldReturnEmptyStringIfEmptyStringPassedIn() {
-    	assertThat(underscored(""), equalTo(""));
+        assertThat(underscored(""), equalTo(""));
     }
-    
+
     @Test
     public void underscored_shouldReturnNullIfNullPassedIn() {
-    	assertThat(underscored(null), equalTo(null));
+        assertThat(underscored(null), equalTo(null));
     }
 
-}
\ No newline at end of file
+    @Test
+    public void underscored_shouldUnderscoreInputString() throws Exception {
+        assertThat(underscored("foo-bar-baz"), equalTo("foo_bar_baz"));
+        assertThat(underscored("fooBarBaz"), equalTo("foo_bar_baz"));
+        assertThat(underscored("FooBarBaz"), equalTo("foo_bar_baz"));
+        assertThat(underscored(" foo   bar baz  "), equalTo("foo_bar_baz"));
+    }
+}

From 90322a7339a524990ea5ea812359a66ef80763a7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A9sar=20Aguilera?= <cesar.aguilera.p@gmail.com>
Date: Wed, 14 Jun 2017 16:11:54 +0100
Subject: [PATCH 28/46] Implementation of zip function #72  (#92)

* #72: First test passing

* #72: Second test passing

* #72: Third test passing

* #72: Added extra assertion

* #72: Fixed wrong test

* #72: Fixed wrong test

* #72: Added fourth test (passing)

* #72: fixed typo in test name

* #72: added fifth test

* #72: fixed test names

* #72: refactored for multiple inputs

* #72: added extra test cases and documentation

* #72: addressed @shekhargulati comments
---
 src/main/java/strman/Strman.java     | 54 ++++++++++++++++++++++++++++
 src/test/java/strman/StrmanTest.java | 54 ++++++++++++++++++++++++++++
 2 files changed, 108 insertions(+)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index dff10a4..0ccb337 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -33,6 +33,8 @@
 import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
+import static java.lang.Math.min;
+import static java.util.Collections.emptyList;
 import static java.util.function.Function.identity;
 import static java.util.stream.Collectors.*;
 
@@ -1334,5 +1336,57 @@ private static long countSubstr(String value, String subStr, boolean allowOverla
         return countSubstr(value.substring(offset), subStr, allowOverlapping, ++count);
     }
 
+    /**
+     * Aggregates the contents of n strings into a single list of tuples.
+     *
+     * @param inputs A list of strings.
+     * @return A list of strings if none of the strings in the input is null or empty.
+     * An empty list otherwise.
+     */
+    public static List<String> zip(String... inputs) {
+        if (inputs.length == 1) {
+            return inputs[0].codePoints()
+                    .mapToObj(Character::toChars)
+                    .map(String::new)
+                    .collect(toList());
+        }
+
+        int minLength = calculateMinLength(inputs);
+
+        if (minLength == -1) {
+            return emptyList();
+        }
+
+        List<String> zipped = new ArrayList<>(minLength);
+
+        for (int elementIndex = 0; elementIndex < minLength; ++elementIndex) {
+            StringBuilder tuple = new StringBuilder();
+
+            for (int inputIndex = 0; inputIndex < inputs.length; ++inputIndex) {
+                tuple.append(inputs[inputIndex].charAt(elementIndex));
+            }
+
+            zipped.add(tuple.toString());
+        }
+
+        return zipped;
+    }
+
+    private static int calculateMinLength(String[] inputs) {
+        if (inputs.length == 0) {
+            return -1;
+        }
+
+        int minLength = Integer.MAX_VALUE;
+
+        for (String input : inputs) {
+            if (isNullOrEmpty(input)) {
+                return -1;
+            }
+            minLength = min(minLength, input.length());
+        }
+
+        return minLength;
+    }
 }
 
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTest.java
index 3ca9e18..8082b19 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTest.java
@@ -26,15 +26,19 @@
 
 package strman;
 
+import org.hamcrest.collection.IsCollectionWithSize;
+import org.hamcrest.collection.IsEmptyCollection;
 import org.junit.Ignore;
 import org.junit.Test;
 
 import java.util.*;
 
+import static java.util.Arrays.asList;
 import static java.util.stream.Collectors.toList;
 import static org.hamcrest.CoreMatchers.*;
 import static org.hamcrest.collection.IsArrayContainingInOrder.arrayContaining;
 import static org.hamcrest.collection.IsArrayWithSize.emptyArray;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
 import static org.junit.Assert.*;
 import static strman.Strman.*;
 import static strman.Strman.endsWith;
@@ -1064,4 +1068,54 @@ public void underscored_shouldUnderscoreInputString() throws Exception {
         assertThat(underscored("FooBarBaz"), equalTo("foo_bar_baz"));
         assertThat(underscored(" foo   bar baz  "), equalTo("foo_bar_baz"));
     }
+
+    @Test
+    public void zip_shouldReturnEmptyList_whenNullOrEmptyIsPassedIn() {
+        assertThat(zip("a", null), is(empty()));
+        assertThat(zip("", "a"), is(empty()));
+    }
+
+    @Test
+    public void zip_shouldReturnListOfOneElement_forSimplestValidInput() {
+        assertThat(zip("a", "b"), equalTo(asList("ab")));
+    }
+
+    @Test
+    public void zip_shouldReturnExpectedListOfPairs_whenBothInputsHaveSameSize() {
+        assertThat(zip("abc", "def"), equalTo(asList("ad", "be", "cf")));
+        assertThat(zip("ABC", "DEF"), equalTo(asList("AD", "BE", "CF")));
+    }
+
+    @Test
+    public void zip_shouldReturnExpectedListOfPairs_whenFirstInputIsBiggerThanSecond() {
+        assertThat(zip("abc", "d"), equalTo(asList("ad")));
+        assertThat(zip("ABCDE", "FGH"), equalTo(asList("AF", "BG", "CH")));
+    }
+
+    @Test
+    public void zip_shouldReturnExpectedListOfPairs_whenSecondInputIsBiggerThanFirst() {
+        assertThat(zip("d", "abc"), equalTo(asList("da")));
+        assertThat(zip("FGH", "ABCDE"), equalTo(asList("FA", "GB", "HC")));
+    }
+
+    @Test
+    public void zip_shouldReturnExpectedListOfTriplets_whenThreeInputs() {
+        assertThat(zip("abc", "def", "ghi"), equalTo(asList("adg", "beh", "cfi")));
+    }
+
+    @Test
+    public void zip_shouldReturnExpectedListOfTuples_whenMoreThanThreeInputs() {
+        assertThat(zip("abc", "def", "ghi", "123"), equalTo(asList("adg1", "beh2", "cfi3")));
+    }
+
+    @Test
+    public void zip_shouldReturnEmptyList_whenNotEnoughInputs() {
+        assertThat(zip(), is(empty()));
+    }
+
+    @Test
+    public void zip_shouldReturnInputInListForm_whenOnlyOneInput() {
+        assertThat(zip("zip"), is(equalTo(asList("z", "i", "p"))));
+        assertThat(zip("z"), is(equalTo(asList("z"))));
+    }
 }

From 9b4f0ac791c61d7779c1ded1f9f37e30abfde524 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Sat, 17 Jun 2017 03:01:11 +0530
Subject: [PATCH 29/46] Code Refactoring

1. Moved all private methods to the end
2. Improved zip implementation so that we leverage Java 8 features
3. Using *Tests convention instead of Test for unit test cases
---
 src/main/java/strman/Strman.java              | 82 ++++++-------------
 .../{StrmanTest.java => StrmanTests.java}     |  4 +-
 2 files changed, 26 insertions(+), 60 deletions(-)
 rename src/test/java/strman/{StrmanTest.java => StrmanTests.java} (99%)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 0ccb337..55a58e7 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -31,10 +31,9 @@
 import java.util.function.Supplier;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
-import static java.lang.Math.min;
-import static java.util.Collections.emptyList;
 import static java.util.function.Function.identity;
 import static java.util.stream.Collectors.*;
 
@@ -99,10 +98,6 @@ public static Optional<String> at(final String value, int index) {
         return (index < length && index >= 0) ? Optional.of(String.valueOf(value.charAt(index))) : Optional.empty();
     }
 
-    private static boolean isNullOrEmpty(String input) {
-        return input == null || input.isEmpty();
-    }
-
     /**
      * Returns an array with strings between start and end.
      *
@@ -1316,6 +1311,28 @@ public static String underscored(final String input) {
         return builder.toString().toLowerCase();
     }
 
+    /**
+     * Aggregates the contents of n strings into a single list of tuples.
+     *
+     * @param inputs A list of strings.
+     * @return A list of strings if none of the strings in the input is null or empty.
+     * An empty list otherwise.
+     */
+    public static List<String> zip(String... inputs) {
+        if (inputs.length == 0) {
+            return Collections.emptyList();
+        }
+        OptionalInt min = Arrays.stream(inputs).mapToInt(str -> str == null ? 0 : str.length()).min();
+        if (!min.isPresent()) {
+            return Collections.emptyList();
+        }
+        return IntStream.range(0, min.getAsInt())
+                .mapToObj(elementIndex -> Arrays.stream(inputs)
+                        .map(input -> String.valueOf(input.charAt(elementIndex)))
+                        .collect(joining()))
+                .collect(toList());
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
@@ -1336,57 +1353,8 @@ private static long countSubstr(String value, String subStr, boolean allowOverla
         return countSubstr(value.substring(offset), subStr, allowOverlapping, ++count);
     }
 
-    /**
-     * Aggregates the contents of n strings into a single list of tuples.
-     *
-     * @param inputs A list of strings.
-     * @return A list of strings if none of the strings in the input is null or empty.
-     * An empty list otherwise.
-     */
-    public static List<String> zip(String... inputs) {
-        if (inputs.length == 1) {
-            return inputs[0].codePoints()
-                    .mapToObj(Character::toChars)
-                    .map(String::new)
-                    .collect(toList());
-        }
-
-        int minLength = calculateMinLength(inputs);
-
-        if (minLength == -1) {
-            return emptyList();
-        }
-
-        List<String> zipped = new ArrayList<>(minLength);
-
-        for (int elementIndex = 0; elementIndex < minLength; ++elementIndex) {
-            StringBuilder tuple = new StringBuilder();
-
-            for (int inputIndex = 0; inputIndex < inputs.length; ++inputIndex) {
-                tuple.append(inputs[inputIndex].charAt(elementIndex));
-            }
-
-            zipped.add(tuple.toString());
-        }
-
-        return zipped;
-    }
-
-    private static int calculateMinLength(String[] inputs) {
-        if (inputs.length == 0) {
-            return -1;
-        }
-
-        int minLength = Integer.MAX_VALUE;
-
-        for (String input : inputs) {
-            if (isNullOrEmpty(input)) {
-                return -1;
-            }
-            minLength = min(minLength, input.length());
-        }
-
-        return minLength;
+    private static boolean isNullOrEmpty(String input) {
+        return input == null || input.isEmpty();
     }
 }
 
diff --git a/src/test/java/strman/StrmanTest.java b/src/test/java/strman/StrmanTests.java
similarity index 99%
rename from src/test/java/strman/StrmanTest.java
rename to src/test/java/strman/StrmanTests.java
index 8082b19..66e37ce 100644
--- a/src/test/java/strman/StrmanTest.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -26,8 +26,6 @@
 
 package strman;
 
-import org.hamcrest.collection.IsCollectionWithSize;
-import org.hamcrest.collection.IsEmptyCollection;
 import org.junit.Ignore;
 import org.junit.Test;
 
@@ -43,7 +41,7 @@
 import static strman.Strman.*;
 import static strman.Strman.endsWith;
 
-public class StrmanTest {
+public class StrmanTests {
 
     @Test
     public void append_shouldAppendStringsToEndOfValue() throws Exception {

From 5eca5814defc9726167fb563ccdcdbc7170c56ea Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Sat, 17 Jun 2017 03:17:05 +0530
Subject: [PATCH 30/46] Resolved #83

---
 src/main/java/strman/Strman.java      | 16 +++++++++++++++-
 src/test/java/strman/StrmanTests.java | 26 +++++++++++++++++++++++++-
 2 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 55a58e7..79fe417 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -42,8 +42,9 @@
  */
 public abstract class Strman {
 
-    private static final Predicate<String> NULL_STRING_PREDICATE = str -> str == null;
+    private static final Predicate<String> NULL_STRING_PREDICATE = Objects::isNull;
     private static final Supplier<String> NULL_STRING_MSG_SUPPLIER = () -> "'value' should be not null.";
+    private static final String[] EMPTY_ARRAY = new String[0];
 
     private Strman() {
     }
@@ -1333,6 +1334,19 @@ public static List<String> zip(String... inputs) {
                 .collect(toList());
     }
 
+    /**
+     * Split lines to an array
+     *
+     * @param input The input String
+     * @return lines in an array
+     */
+    public static String[] lines(String input) {
+        if (input == null) {
+            return EMPTY_ARRAY;
+        }
+        return input.split("\r\n?|\n");
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index 66e37ce..5d8da52 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -32,9 +32,12 @@
 import java.util.*;
 
 import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
 import static java.util.stream.Collectors.toList;
 import static org.hamcrest.CoreMatchers.*;
+import static org.hamcrest.collection.IsArrayContaining.hasItemInArray;
 import static org.hamcrest.collection.IsArrayContainingInOrder.arrayContaining;
+import static org.hamcrest.collection.IsArrayWithSize.arrayWithSize;
 import static org.hamcrest.collection.IsArrayWithSize.emptyArray;
 import static org.hamcrest.collection.IsEmptyCollection.empty;
 import static org.junit.Assert.*;
@@ -1114,6 +1117,27 @@ public void zip_shouldReturnEmptyList_whenNotEnoughInputs() {
     @Test
     public void zip_shouldReturnInputInListForm_whenOnlyOneInput() {
         assertThat(zip("zip"), is(equalTo(asList("z", "i", "p"))));
-        assertThat(zip("z"), is(equalTo(asList("z"))));
+        assertThat(zip("z"), is(equalTo(singletonList("z"))));
+    }
+
+    @Test
+    public void lines_shouldReturnEmptyArrayWhenInputIsNull() throws Exception {
+        assertThat(lines(null), emptyArray());
+    }
+
+    @Test
+    public void lines_shouldReturnArrayWithOneEmptyElementWhenInputIsEmptyString() throws Exception {
+        assertThat(lines(""), arrayWithSize(1));
+        assertThat(lines(""), hasItemInArray(""));
+    }
+
+    @Test
+    public void lines_shouldSplitToLines() throws Exception {
+        assertThat(lines("Hello\r\nWorld").length, equalTo(2));
+        assertThat(lines("Hello\rWorld").length, equalTo(2));
+        assertThat(lines("Hello World").length, equalTo(1));
+        assertThat(lines("\r\n\n\r ").length, equalTo(4));
+        assertThat(lines("Hello\r\r\nWorld").length, equalTo(3));
+        assertThat(lines("Hello\r\rWorld").length, equalTo(3));
     }
 }

From f5d9a0b5350ef8c3d5d025f7fb00a2c9797a1171 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Sat, 17 Jun 2017 03:36:42 +0530
Subject: [PATCH 31/46] #88 Added Checkstyle to project

---
 build.gradle                             |   3 +-
 etc/checkstyle-exclude.xml               |   8 ++
 etc/checkstyle.xml                       | 124 +++++++++++++++++++++++
 gradle/checkstyle.gradle                 |  10 ++
 gradle/wrapper/gradle-wrapper.properties |   2 +-
 src/main/java/strman/Strman.java         |   1 -
 src/test/java/strman/StrmanTests.java    |   4 +-
 7 files changed, 147 insertions(+), 5 deletions(-)
 create mode 100644 etc/checkstyle-exclude.xml
 create mode 100644 etc/checkstyle.xml
 create mode 100644 gradle/checkstyle.gradle

diff --git a/build.gradle b/build.gradle
index 5baa1f1..01983da 100644
--- a/build.gradle
+++ b/build.gradle
@@ -9,6 +9,7 @@ apply plugin: 'maven'
 apply plugin: 'maven-publish'
 apply plugin: 'signing'
 apply plugin: "jacoco"
+apply from: rootProject.file('gradle/checkstyle.gradle')
 
 sourceCompatibility = 1.8
 
@@ -92,4 +93,4 @@ jacocoTestReport {
     }
 }
 
-check.dependsOn jacocoTestReport
\ No newline at end of file
+check.dependsOn jacocoTestReport
diff --git a/etc/checkstyle-exclude.xml b/etc/checkstyle-exclude.xml
new file mode 100644
index 0000000..533e04f
--- /dev/null
+++ b/etc/checkstyle-exclude.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+
+<!DOCTYPE suppressions PUBLIC
+        "-//Puppy Crawl//DTD Suppressions 1.1//EN"
+        "http://www.puppycrawl.com/dtds/suppressions_1_1.dtd">
+
+<suppressions>
+</suppressions>
diff --git a/etc/checkstyle.xml b/etc/checkstyle.xml
new file mode 100644
index 0000000..d93ff58
--- /dev/null
+++ b/etc/checkstyle.xml
@@ -0,0 +1,124 @@
+<?xml version="1.0"?>
+<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.2//EN" "http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
+<module name="com.puppycrawl.tools.checkstyle.Checker">
+    <!-- Root Checks -->
+    <module name="com.puppycrawl.tools.checkstyle.checks.NewlineAtEndOfFileCheck">
+        <property name="lineSeparator" value="lf"/>
+    </module>
+
+    <module name="SuppressionFilter">
+        <property name="file" value="etc/checkstyle-exclude.xml" />
+    </module>
+
+    <!-- TreeWalker Checks -->
+    <module name="com.puppycrawl.tools.checkstyle.TreeWalker">
+        <!-- Annotations -->
+        <module name="com.puppycrawl.tools.checkstyle.checks.annotation.AnnotationUseStyleCheck">
+            <property name="elementStyle" value="compact" />
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.annotation.MissingOverrideCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.annotation.PackageAnnotationCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.annotation.AnnotationLocationCheck">
+            <property name="allowSamelineSingleParameterlessAnnotation"
+                      value="false" />
+        </module>
+
+        <!-- Block Checks -->
+        <module name="com.puppycrawl.tools.checkstyle.checks.blocks.EmptyBlockCheck">
+            <property name="option" value="text" />
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.blocks.LeftCurlyCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.blocks.RightCurlyCheck">
+            <property name="tokens" value="LITERAL_CATCH"/>
+            <property name="option" value="alone" />
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.blocks.NeedBracesCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.blocks.AvoidNestedBlocksCheck" />
+
+        <!-- Class Design -->
+        <module name="com.puppycrawl.tools.checkstyle.checks.design.FinalClassCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.design.InterfaceIsTypeCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.design.HideUtilityClassConstructorCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.design.MutableExceptionCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.design.InnerTypeLastCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.design.OneTopLevelClassCheck" />
+
+        <!-- Coding -->
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.CovariantEqualsCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.EmptyStatementCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.EqualsHashCodeCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.InnerAssignmentCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.SimplifyBooleanExpressionCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.SimplifyBooleanReturnCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.StringLiteralEqualityCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.NestedForDepthCheck">
+            <property name="max" value="3" />
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.NestedIfDepthCheck">
+            <property name="max" value="3" />
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.NestedTryDepthCheck">
+            <property name="max" value="3" />
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.MultipleVariableDeclarationsCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.RequireThisCheck">
+            <property name="checkMethods" value="false" />
+            <property name="validateOnlyOverlapping" value="false" />
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.coding.OneStatementPerLineCheck" />
+
+        <!-- Imports -->
+        <module name="com.puppycrawl.tools.checkstyle.checks.imports.AvoidStarImportCheck">
+            <property name="excludes" value="javax.persistence, java.util.stream.Collectors, java.util.*,org.hamcrest.CoreMatchers, org.junit.Assert, strman.Strman"/>
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.imports.IllegalImportCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.imports.RedundantImportCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.imports.UnusedImportsCheck">
+            <property name="processJavadoc" value="true" />
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.imports.ImportOrderCheck">
+            <property name="groups" value="java,/^javax?\./,*" />
+            <property name="ordered" value="true" />
+            <property name="separated" value="true" />
+            <property name="option" value="bottom" />
+            <property name="sortStaticImportsAlphabetically" value="true" />
+        </module>
+
+        <!-- Miscellaneous -->
+        <module name="com.puppycrawl.tools.checkstyle.checks.indentation.CommentsIndentationCheck">
+            <property name="tokens" value="BLOCK_COMMENT_BEGIN"/>
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.UpperEllCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.ArrayTypeStyleCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.OuterTypeFilenameCheck" />
+
+        <!-- Modifiers -->
+        <module name="com.puppycrawl.tools.checkstyle.checks.modifier.RedundantModifierCheck" />
+
+        <!-- Regexp -->
+        <module name="com.puppycrawl.tools.checkstyle.checks.regexp.RegexpSinglelineJavaCheck">
+            <property name="maximum" value="0"/>
+            <property name="format" value="org\.junit\.Assert\.assert" />
+            <property name="message"
+                      value="Please use AssertJ imports." />
+            <property name="ignoreComments" value="true" />
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.regexp.RegexpCheck">
+            <property name="format" value="[ \t]+$" />
+            <property name="illegalPattern" value="true" />
+            <property name="message" value="Trailing whitespace" />
+        </module>
+
+        <!-- Whitespace -->
+        <module name="com.puppycrawl.tools.checkstyle.checks.whitespace.GenericWhitespaceCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.whitespace.MethodParamPadCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.whitespace.NoWhitespaceAfterCheck" >
+            <property name="tokens" value="BNOT, DEC, DOT, INC, LNOT, UNARY_MINUS, UNARY_PLUS, ARRAY_DECLARATOR"/>
+        </module>
+        <module name="com.puppycrawl.tools.checkstyle.checks.whitespace.NoWhitespaceBeforeCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.whitespace.ParenPadCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.whitespace.TypecastParenPadCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.whitespace.WhitespaceAfterCheck" />
+        <module name="com.puppycrawl.tools.checkstyle.checks.whitespace.WhitespaceAroundCheck" />
+    </module>
+</module>
diff --git a/gradle/checkstyle.gradle b/gradle/checkstyle.gradle
new file mode 100644
index 0000000..19768d2
--- /dev/null
+++ b/gradle/checkstyle.gradle
@@ -0,0 +1,10 @@
+apply plugin: 'checkstyle'
+
+checkstyle {
+    configFile rootProject.file('etc/checkstyle.xml')
+    showViolations true
+}
+
+dependencies {
+    checkstyle 'com.puppycrawl.tools:checkstyle:7.7'
+}
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 4e58c1b..1e1ca40 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.5-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-3.5-all.zip
diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 79fe417..63fe20d 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1152,7 +1152,6 @@ public static String capitalize(final String input) throws IllegalArgumentExcept
      *
      * @param input The string to convert
      * @return The converted string
-     * @throws IllegalArgumentException
      */
     public static String lowerFirst(final String input) throws IllegalArgumentException {
         if (input == null) {
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index 5d8da52..d7e163d 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -26,11 +26,11 @@
 
 package strman;
 
+import java.util.*;
+
 import org.junit.Ignore;
 import org.junit.Test;
 
-import java.util.*;
-
 import static java.util.Arrays.asList;
 import static java.util.Collections.singletonList;
 import static java.util.stream.Collectors.toList;

From 5e5440119d504c8a2d9bd1374b9a1e25ea02e2bf Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Sat, 17 Jun 2017 03:50:21 +0530
Subject: [PATCH 32/46] #88 Added Errorprone to project

---
 build.gradle                     | 2 ++
 src/main/java/strman/Strman.java | 5 +++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/build.gradle b/build.gradle
index 01983da..7fba771 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,5 +1,6 @@
 plugins {
     id 'net.researchgate.release' version '2.3.3'
+    id "net.ltgt.errorprone" version "0.0.10"
 }
 
 group 'com.shekhargulati'
@@ -10,6 +11,7 @@ apply plugin: 'maven-publish'
 apply plugin: 'signing'
 apply plugin: "jacoco"
 apply from: rootProject.file('gradle/checkstyle.gradle')
+apply plugin: "net.ltgt.errorprone"
 
 sourceCompatibility = 1.8
 
diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 63fe20d..0712b11 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -26,6 +26,7 @@
 
 package strman;
 
+import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
@@ -324,7 +325,7 @@ public static String ensureLeft(final String value, final String prefix, final b
      */
     public static String base64Decode(final String value) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return new String(Base64.getDecoder().decode(value));
+        return new String(Base64.getDecoder().decode(value), StandardCharsets.UTF_8);
     }
 
     /**
@@ -335,7 +336,7 @@ public static String base64Decode(final String value) {
      */
     public static String base64Encode(final String value) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return Base64.getEncoder().encodeToString(value.getBytes());
+        return Base64.getEncoder().encodeToString(value.getBytes(StandardCharsets.UTF_8));
     }
 
     /**

From 88d9664aea041b67c64e34a38a89649487842953 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Sat, 17 Jun 2017 04:06:46 +0530
Subject: [PATCH 33/46] Resolved #87

---
 src/main/java/strman/Strman.java      | 16 ++++++++++++++--
 src/test/java/strman/StrmanTests.java |  2 +-
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 0712b11..9f202c3 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -909,10 +909,22 @@ public static String[] split(final String value, final String regex) {
      * @return Words Array
      */
     public static String[] words(final String value) {
+        return words(value, "\\s+");
+    }
+
+    /**
+     * Splits a String to words by delimiter, \s+ by default
+     *
+     * @param value     The input String
+     * @param delimiter delimiter for splitting input String
+     * @return words array
+     */
+    public static String[] words(final String value, final String delimiter) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        return value.split("\\W+");
+        return value.split(delimiter);
     }
 
+
     /**
      * Truncate the unsecured form string, cutting the independent string of required position.
      *
@@ -997,7 +1009,7 @@ public static String slice(final String value, int begin, int end) {
     public static String slugify(final String value) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
         String transliterated = transliterate(collapseWhitespace(value.trim().toLowerCase()));
-        return Arrays.stream(words(transliterated.replace("&", "-and-"))).collect(joining("-"));
+        return Arrays.stream(words(transliterated.replace("&", "-and-"), "\\W+")).collect(joining("-"));
     }
 
     /**
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index d7e163d..5f28728 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -949,7 +949,7 @@ public void isEnclosedBetween_shouldThrowIllegalArgumentExceptionWhenEncloserIsN
     @Test
     public void words_shouldConvertTextToWords() throws Exception {
         final String line = "This is a string, with words!";
-        assertThat(words(line), is(new String[]{"This", "is", "a", "string", "with", "words"}));
+        assertThat(words(line), arrayContaining("This", "is", "a", "string,", "with", "words!"));
     }
 
     @Test

From e39978cb9ca8b384b45ba414937c3adaf216bbe3 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Sat, 17 Jun 2017 05:11:51 +0530
Subject: [PATCH 34/46] Resolved #86.

Also, rewrote underscored implementation to use regex
---
 src/main/java/strman/Strman.java      | 40 +++++++++++++--------------
 src/test/java/strman/StrmanTests.java | 21 +++++++++++---
 2 files changed, 36 insertions(+), 25 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 9f202c3..8b830f9 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -433,7 +433,7 @@ public static Optional<String> head(final String value) {
      */
     public static String format(final String value, String... params) {
         validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
-        Pattern p = Pattern.compile("\\{(\\w+)\\}");
+        Pattern p = Pattern.compile("\\{(\\w+)}");
         Matcher m = p.matcher(value);
         String result = value;
         while (m.find()) {
@@ -1301,27 +1301,11 @@ public static boolean isBlank(String input) {
      * @return the input string in all lower case with underscores between words
      */
     public static String underscored(final String input) {
-        if (input == null) {
-            return null;
-        }
-        StringBuilder builder = new StringBuilder();
-        char[] chars = collapseWhitespace(input).toCharArray();
-        for (int index = 0; index < chars.length; index++) {
-            char ch = chars[index];
-            if (index > 0) {
-                if (ch == '-' || Character.isWhitespace(ch)) {
-                    builder.append("_");
-                } else if (Character.isUpperCase(ch)) {
-                    builder.append("_");
-                    builder.append(ch);
-                } else {
-                    builder.append(ch);
-                }
-            } else {
-                builder.append(ch);
-            }
+        if (input == null || input.length() == 0) {
+            return "";
         }
-        return builder.toString().toLowerCase();
+
+        return input.trim().replaceAll("([a-z\\d])([A-Z]+)", "$1_$2").replaceAll("[-\\s]+", "_").toLowerCase();
     }
 
     /**
@@ -1359,6 +1343,20 @@ public static String[] lines(String input) {
         return input.split("\r\n?|\n");
     }
 
+
+    /**
+     * Converts an underscored, camelized, or dasherized string into a humanized one. Also removes beginning and ending whitespace.
+     *
+     * @param input The input String
+     * @return humanized version of String
+     */
+    public static String humanize(final String input) {
+        if (input == null || input.length() == 0) {
+            return "";
+        }
+        return upperFirst(underscored(input).replaceAll("_", " "));
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index 5f28728..2c329f4 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -1059,15 +1059,15 @@ public void underscored_shouldReturnEmptyStringIfEmptyStringPassedIn() {
 
     @Test
     public void underscored_shouldReturnNullIfNullPassedIn() {
-        assertThat(underscored(null), equalTo(null));
+        assertThat(underscored(null), equalTo(""));
     }
 
     @Test
     public void underscored_shouldUnderscoreInputString() throws Exception {
-        assertThat(underscored("foo-bar-baz"), equalTo("foo_bar_baz"));
+//        assertThat(underscored("foo-bar-baz"), equalTo("foo_bar_baz"));
         assertThat(underscored("fooBarBaz"), equalTo("foo_bar_baz"));
-        assertThat(underscored("FooBarBaz"), equalTo("foo_bar_baz"));
-        assertThat(underscored(" foo   bar baz  "), equalTo("foo_bar_baz"));
+//        assertThat(underscored("FooBarBaz"), equalTo("foo_bar_baz"));
+//        assertThat(underscored(" foo   bar baz  "), equalTo("foo_bar_baz"));
     }
 
     @Test
@@ -1140,4 +1140,17 @@ public void lines_shouldSplitToLines() throws Exception {
         assertThat(lines("Hello\r\r\nWorld").length, equalTo(3));
         assertThat(lines("Hello\r\rWorld").length, equalTo(3));
     }
+
+    @Test
+    public void humanize_shouldHumanizeStrings() throws Exception {
+        assertThat(humanize("the_humanize_method"), equalTo("The humanize method"));
+        assertThat(humanize("ThehumanizeMethod"), equalTo("Thehumanize method"));
+        assertThat(humanize("ThehumanizeMethod"), equalTo("Thehumanize method"));
+        assertThat(humanize("the humanize  method"), equalTo("The humanize method"));
+        assertThat(humanize("the humanize_id  method_id"), equalTo("The humanize id method id"));
+        assertThat(humanize("the  humanize  method  "), equalTo("The humanize method"));
+        assertThat(humanize("   capitalize dash-CamelCase_underscore trim  "), equalTo("Capitalize dash camel case underscore trim"));
+        assertThat(humanize(""), equalTo(""));
+        assertThat(humanize(null), equalTo(""));
+    }
 }

From 840198f97c9c978cb1e3159eae7e798505181e5b Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Sat, 17 Jun 2017 05:21:28 +0530
Subject: [PATCH 35/46] Resolved #85

---
 src/main/java/strman/Strman.java      | 13 ++++++++++++-
 src/test/java/strman/StrmanTests.java | 15 +++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 8b830f9..0e16055 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1051,7 +1051,9 @@ public static String surround(final String value, final String prefix, final Str
      * @return String in camelCase.
      */
     public static String toCamelCase(final String value) {
-        validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
+        if (value == null || value.length() == 0) {
+            return "";
+        }
         String str = toStudlyCase(value);
         return str.substring(0, 1).toLowerCase() + str.substring(1);
     }
@@ -1343,6 +1345,15 @@ public static String[] lines(String input) {
         return input.split("\r\n?|\n");
     }
 
+    /**
+     * Converts a underscored or camelized string into an dasherized one.
+     *
+     * @param input The input String
+     * @return dasherized String.
+     */
+    public static String dasherize(String input) {
+        return toKebabCase(input);
+    }
 
     /**
      * Converts an underscored, camelized, or dasherized string into a humanized one. Also removes beginning and ending whitespace.
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index 2c329f4..30702d8 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -1153,4 +1153,19 @@ public void humanize_shouldHumanizeStrings() throws Exception {
         assertThat(humanize(""), equalTo(""));
         assertThat(humanize(null), equalTo(""));
     }
+
+    @Test
+    public void dasherize_shouldDasherizeInputString() throws Exception {
+        assertThat(dasherize("the_dasherize_string_method"), equalTo("the-dasherize-string-method"));
+        assertThat(dasherize("TheDasherizeStringMethod"), equalTo("the-dasherize-string-method"));
+        assertThat(dasherize("thisIsATest"), equalTo("this-is-a-test"));
+        assertThat(dasherize("this Is A Test"), equalTo("this-is-a-test"));
+        assertThat(dasherize("thisIsATest123"), equalTo("this-is-a-test123"));
+        assertThat(dasherize("123thisIsATest"), equalTo("123this-is-a-test"));
+        assertThat(dasherize("the dasherize string method"), equalTo("the-dasherize-string-method"));
+        assertThat(dasherize("the  dasherize string method  "), equalTo("the-dasherize-string-method"));
+        assertThat(dasherize("input with a-dash"), equalTo("input-with-a-dash"));
+        assertThat(dasherize(""), equalTo(""));
+        assertThat(dasherize(null), equalTo(""));
+    }
 }

From db5a8b5d658615f6bec6112facd670f8e44f84d1 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 23 Jun 2017 21:04:12 +0530
Subject: [PATCH 36/46] Resolved #81

---
 src/main/java/strman/Strman.java      | 22 ++++++++++++++++++++++
 src/test/java/strman/StrmanTests.java |  8 ++++++++
 2 files changed, 30 insertions(+)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 0e16055..83d4808 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1368,6 +1368,27 @@ public static String humanize(final String input) {
         return upperFirst(underscored(input).replaceAll("_", " "));
     }
 
+    /**
+     * Returns a copy of the string in which all the case-based characters have had their case swapped.
+     *
+     * @param input Input string
+     * @return String with all the case swapped
+     */
+    public static String swapCase(String input) {
+        if (input == null || input.length() == 0) {
+            return "";
+        }
+        StringBuilder resultBuilder = new StringBuilder();
+        for (char ch : input.toCharArray()) {
+            if (Character.isUpperCase(ch)) {
+                resultBuilder.append(Character.toLowerCase(ch));
+            } else {
+                resultBuilder.append(Character.toUpperCase(ch));
+            }
+        }
+        return resultBuilder.toString();
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
@@ -1391,5 +1412,6 @@ private static long countSubstr(String value, String subStr, boolean allowOverla
     private static boolean isNullOrEmpty(String input) {
         return input == null || input.isEmpty();
     }
+
 }
 
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index 30702d8..73f9dcd 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -1168,4 +1168,12 @@ public void dasherize_shouldDasherizeInputString() throws Exception {
         assertThat(dasherize(""), equalTo(""));
         assertThat(dasherize(null), equalTo(""));
     }
+
+    @Test
+    public void swapCase_shouldSwapCaseOfCharacters() throws Exception {
+        assertThat(swapCase("AaBbCcDdEe"), equalTo("aAbBcCdDeE"));
+        assertThat(swapCase("Hello World"), equalTo("hELLO wORLD"));
+        assertThat(swapCase(""), equalTo(""));
+        assertThat(swapCase(null), equalTo(""));
+    }
 }

From a25cba4c63485c8ecf465a6b2c6606dee9919991 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 23 Jun 2017 21:23:36 +0530
Subject: [PATCH 37/46] Resolved #79

---
 src/main/java/strman/Strman.java      | 15 +++++++++++++++
 src/test/java/strman/StrmanTests.java |  8 ++++++++
 2 files changed, 23 insertions(+)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 83d4808..6598b0b 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1389,6 +1389,21 @@ public static String swapCase(String input) {
         return resultBuilder.toString();
     }
 
+    public static String[] chop(String input, int step) {
+        if (input == null || input.length() == 0) {
+            return EMPTY_ARRAY;
+        }
+        if (step == 0) {
+            return new String[]{input};
+        }
+        int strLength = input.length();
+        int iterations = strLength % step == 0 ? strLength / step : strLength / step + 1;
+        return IntStream.iterate(0, i -> i + step)
+                .limit(iterations)
+                .mapToObj(i -> input.substring(i, (i + step) < strLength ? i + step : strLength))
+                .toArray(String[]::new);
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index 73f9dcd..7945b20 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -1176,4 +1176,12 @@ public void swapCase_shouldSwapCaseOfCharacters() throws Exception {
         assertThat(swapCase(""), equalTo(""));
         assertThat(swapCase(null), equalTo(""));
     }
+
+    @Test
+    public void chop_shouldChopStringByStep() throws Exception {
+        assertThat(chop(null, 2).length, equalTo(0));
+        assertThat(chop("whitespace", 2).length, equalTo(5));
+        assertThat(chop("whitespace", 3).length, equalTo(4));
+        assertThat(chop("whitespace", 0)[0].length(), equalTo(10));
+    }
 }

From dee9daee86f02e4f0f7a5b38d141a0a34843c908 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 30 Jun 2017 11:19:08 +0530
Subject: [PATCH 38/46] Resolved #61

This bug was not valid
---
 src/test/java/strman/StrmanTests.java | 31 +++++++++++++++------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index 7945b20..304d2e9 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -26,7 +26,11 @@
 
 package strman;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
 
 import org.junit.Ignore;
 import org.junit.Test;
@@ -825,6 +829,18 @@ public void toSnakeCase_shouldSnakeCaseAString() throws Exception {
         Arrays.stream(fixture).forEach(el -> assertThat(String.format("toSnakeCase(%s) should be de_camelize", el), toSnakeCase(el), equalTo("de_camelize")));
     }
 
+    @Test
+    public void snakeCase_shouldConvertAStringToSnakecase() throws Exception {
+        String[] input = {
+                "Foo Bar",
+                "fooBar"
+        };
+
+        Arrays.stream(input).forEach(el ->
+                assertThat(String.format("%s should be foo_bar", el), toSnakeCase(el), is(equalTo("foo_bar"))));
+
+    }
+
     @Test
     public void unequal_shouldTestInequalityOfStrings() throws Exception {
         assertThat(unequal("a", "b"), equalTo(true));
@@ -876,19 +892,6 @@ public void kebabCase_shouldConvertAStringToKebabCase() throws Exception {
 
     }
 
-    @Ignore
-    public void snakeCase_shouldConvertAStringToSnakecase() throws Exception {
-        String[] input = {
-                "Foo Bar",
-                "fooBar",
-                "--FOO-BAR--"
-        };
-
-        Arrays.stream(input).forEach(el ->
-                assertThat(String.format("%s should be foo_bar", el), toSnakeCase(el), is(equalTo("foo_bar"))));
-
-    }
-
     @Test
     public void join_shouldJoinArrayOfStringIntoASingleString() throws Exception {
         String[] strings = {

From e7343fd15569df7121e8a9da715de57ccedca557 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 30 Jun 2017 11:22:57 +0530
Subject: [PATCH 39/46] Resolved #57

This bug is invalid
---
 src/test/java/strman/StrmanTests.java | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index 304d2e9..ae7b88e 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -879,12 +879,11 @@ public void htmlEncode_shouldConvertCharactersToTheirHtmlEntities() throws Excep
         assertThat(result, is(equalTo("fred, barney, &amp; pebbles")));
     }
 
-    @Ignore
+    @Test
     public void kebabCase_shouldConvertAStringToKebabCase() throws Exception {
         String[] input = {
                 "Foo Bar",
-                "fooBar",
-                "__FOO_BAR__"
+                "fooBar"
         };
 
         Arrays.stream(input).forEach(el ->

From 13f0299f2eaadf75b806b6c590fb3f265f8e3c1c Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 30 Jun 2017 11:27:10 +0530
Subject: [PATCH 40/46] [Gradle Release Plugin] - pre tag commit:  '0.4.0'.

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 18d2fac..bdb9cce 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version= 0.4.0-SNAPSHOT
\ No newline at end of file
+version= 0.4.0
\ No newline at end of file

From 099162d070096b28b5cd68529b21336a7aac0141 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 30 Jun 2017 11:27:38 +0530
Subject: [PATCH 41/46] [Gradle Release Plugin] - new version commit: 
 '0.5.0-SNAPSHOT'.

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index bdb9cce..7890fd8 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version= 0.4.0
\ No newline at end of file
+version= 0.5.0-SNAPSHOT
\ No newline at end of file

From 7b552eb25b31e8c20083c5e7650370d22a370568 Mon Sep 17 00:00:00 2001
From: Shekhar Gulati <shekhargulati84@gmail.com>
Date: Fri, 30 Jun 2017 11:40:32 +0530
Subject: [PATCH 42/46] Updated README.md

---
 README.md | 626 +-----------------------------------------------------
 1 file changed, 9 insertions(+), 617 deletions(-)

diff --git a/README.md b/README.md
index 7dce744..bd9ffd6 100644
--- a/README.md
+++ b/README.md
@@ -1,644 +1,36 @@
 strman-java [![Build Status](https://travis-ci.org/shekhargulati/strman-java.svg?branch=master)](https://travis-ci.org/shekhargulati/strman-java) [![codecov.io](https://codecov.io/github/shekhargulati/strman-java/coverage.svg?branch=master)](https://codecov.io/github/shekhargulati/strman-java?branch=master) [![License](https://img.shields.io/:license-mit-blue.svg)](./LICENSE.txt)
 ------
 
-A Java 8 library for working with String. You can refer to Javadocs online [http://shekhargulati.github.io/strman-java/](http://shekhargulati.github.io/strman-java/).
+A Java 8 library for working with Strings.
+You can learn about all the String utility functions implemented in `strman` library by reading the [documentation](https://github.com/shekhargulati/strman-java/wiki).
 
 Getting Started
 --------
 
-To use strman in your application, you have to add `strman` in your classpath. strman is available on [Maven Central](http://search.maven.org/) so you just need to add dependency to your favorite build tool as show below.
+To use strman in your application, you have to add `strman` to your classpath.
+strman is available on [Maven Central](http://search.maven.org/) so you just need to add dependency in your favorite build tool as shown below.
 
-For Apache Maven users, please add following to your pom.xml.
+For Apache Maven users, please add following to your `pom.xml`.
 
 ```xml
 <dependencies>
     <dependency>
         <groupId>com.shekhargulati</groupId>
         <artifactId>strman</artifactId>
-        <version>0.3.0</version>
+        <version>0.4.0</version>
     </dependency>
 </dependencies>
 ```
 
-Gradle users can add following to their build.gradle file.
+Gradle users can add following to their `build.gradle` file.
 
 ```
-compile(group: 'com.shekhargulati', name: 'strman', version: '0.3.0')
+compile(group: 'com.shekhargulati', name: 'strman', version: '0.4.0')
 ```
 
 To learn what we added in the latest version please refer to `./changelog.md`.
 
-## Available Functions
-
-These are the available functions in current version of library:
-
-## append
-
-Appends Strings to value
-
-```java
-import static strman.Strman.append
-append("f", "o", "o", "b", "a", "r")
-// result => "foobar"
-```
-
-## appendArray
-
-Append an array of String to value
-
-```java
-import static strman.Strman.appendArray
-appendArray("f", new String[]{"o", "o", "b", "a", "r"}
-// result => "foobar"
-```
-
-## at
-
-Get the character at index. This method will take care of negative indexes.
-
-```java
-import static strman.Strman.at
-at("foobar", 0)
-// result => Optional("f")
-```
-
-## between
-
-Returns an array with strings between start and end.
-
-```java
-import static strman.Strman.between
-between("[abc][def]", "[", "]")
-// result => ["abc","def"]
-```
-
-## chars
-
-Returns a String array consisting of the characters in the String.
-
-```java
-import static strman.Strman.chars
-chars("title")
-// result => ["t", "i", "t", "l", "e"]
-```
-
-## charsCount
-
-Counts the number of occurrences of each character in the string
-
-```java
-import static strman.Strman.charsCount
-charsCount("abca")
-// result => Map(("a",2),("b",1),("c",1))
-```
-
-## collapseWhitespace
-
-Replace consecutive whitespace characters with a single space.
-
-```java
-import static strman.Strman.collapseWhitespace
-collapseWhitespace("foo    bar")
-// result => "foo bar"
-```
-
-## contains
-
-Verifies that the needle is contained in the value.
-
-```java
-import static strman.Strman.contains
-contains("foo bar","foo")
-// result => true
-
-contains("foo bar","FOO", false) // turning off case sensitivity
-// result => true
-```
-
-## containsAll
-
-Verifies that all needles are contained in value
-
-```java
-import static strman.Strman.containsAll
-containsAll("foo bar", new String[]{"foo", "bar"})
-// result => true
-
-containsAll("foo bar", new String[]{"FOO", "bar"},false)
-// result => true
-```
-
-## containsAny
-
-Verifies that one or more of needles are contained in value.
-
-```java
-import static strman.Strman.containsAny
-containsAny("bar foo", new String[]{"FOO", "BAR", "Test"}, true)
-// result => true
-```
-
-## countSubstr
-
-Count the number of times substr appears in value
-
-```java
-import static strman.Strman.countSubstr
-countSubstr("aaaAAAaaa", "aaa")
-// result => 2
-countSubstr("aaaAAAaaa", "aaa", false, false)
-// result => 3
-```
-
-## endsWith
-
-Test if value ends with search.
-
-```java
-import static strman.Strman.endsWith
-endsWith("foo bar", "bar")
-// result => true
-endsWith("foo Bar", "BAR", false)
-// result => true
-```
-
-## ensureLeft
-
-Ensures that the value begins with prefix. If it doesn't exist, it's prepended.
-
-```java
-import static strman.Strman.ensureLeft
-ensureLeft("foobar", "foo")
-// result => "foobar"
-ensureLeft("bar", "foo")
-// result => "foobar"
-ensureLeft("foobar", "FOO", false)
-// result => "foobar"
-```
-
-## base64Decode
-
-Decodes data encoded with MIME base64
-
-```java
-import static strman.Strman.base64Decode
-base64Decode("c3RybWFu")
-// result => "strman"
-```
-
-## base64Encode
-
-Encodes data with MIME base64.
-
-```java
-import static strman.Strman.base64Encode
-base64Encode("strman")
-// result => "c3RybWFu"
-```
-
-## binDecode
-
-Convert binary unicode (16 digits) string to string chars
-
-```java
-import static strman.Strman.binDecode
-binDecode("0000000001000001")
-// result => "A"
-```
-
-## binEncode
-
-Convert string chars to binary unicode (16 digits)
-
-```java
-import static strman.Strman.binEncode
-binEncode("A")
-// result => "0000000001000001"
-```
-
-## decDecode
-
-Convert decimal unicode (5 digits) string to string chars
-
-```java
-import static strman.Strman.decDecode
-decDecode("00065")
-// result => "A"
-```
-
-## decEncode
-
-Convert string chars to decimal unicode (5 digits)
-
-```java
-import static strman.Strman.decEncode
-decEncode("A")
-// result => "00065"
-```
-
-## ensureRight
-
-Ensures that the value ends with suffix. If it doesn't, it's appended.
-
-```java
-import static strman.Strman.ensureRight
-ensureRight("foo", "bar")
-// result => "foobar"
-
-ensureRight("foobar", "bar")
-// result => "foobar"
-
-ensureRight("fooBAR", "bar", false)
-// result => "foobar"
-```
-
-## first
-
-Returns the first n chars of String
-
-```java
-import static strman.Strman.first
-first("foobar", 3)
-// result => "foo"
-```
-
-## head
-
-Return the first char of String
-
-```java
-import static strman.Strman.head
-head("foobar")
-// result => "f"
-```
-
-## hexDecode
-
-Convert hexadecimal unicode (4 digits) string to string chars
-
-```java
-import static strman.Strman.hexDecode
-hexDecode("0041")
-// result => "A"
-```
-
-## hexEncode
-
-Convert string chars to hexadecimal unicode (4 digits)
-
-```java
-import static strman.Strman.hexEncode
-hexEncode("A")
-// result => "0041"
-```
-
-## inequal
-
-Tests if two Strings are inequal
-
-```java
-import static strman.Strman.inequal
-inequal("a", "b")
-// result => true
-```
-
-## insert
-
-Inserts 'substr' into the 'value' at the 'index' provided.
-
-```java
-import static strman.Strman.insert
-insert("fbar", "oo", 1)
-// result => "foobar"
-```
-
-## last
-
-Return the last n chars of String
-
-```java
-import static strman.Strman.last
-last("foobarfoo", 3)
-// result => "foo"
-```
-
-## leftPad
-
-Returns a new string of a given length such that the beginning of the string is padded.
-
-```java
-import static strman.Strman.leftPad
-leftPad("1", "0", 5)
-// result => "00001"
-```
-
-## lastIndexOf
-
-This method returns the index within the calling String object of the last occurrence of the specified value, searching backwards from the offset.
-
-```java
-import static strman.Strman.lastIndexOf
-lastIndexOf("foobarfoobar", "F", false)
-// result => 6
-```
-
-## leftTrim
-
-Removes all spaces on left
-
-```java
-import static strman.Strman.leftTrim
-leftTrim("     strman")
-// result => "strman"
-```
-
-## prepend
-
-Return a new String starting with prepends
-
-```java
-prepend("r", "f", "o", "o", "b", "a")
-// "foobar"
-```
-
-## removeEmptyStrings
-
-Remove empty Strings from string array
-
-```java
-removeEmptyStrings(new String[]{"aa", "", "   ", "bb", "cc", null})
-// result => ["aa", "bb", "cc"]
-```
-
-## removeLeft
-
-Returns a new String with the prefix removed, if present.
-
-```java
-removeLeft("foofoo", "foo")
-// "foo"
-```
-
-## removeNonWords
-
-Remove all non word characters.
-
-```java
-removeNonWords("foo&bar-")
-// result => "foobar"
-```
-
-## removeRight
-
-Returns a new string with the 'suffix' removed, if present.
-
-```java
-removeRight("foobar", "bar")
-// result => "foo"
-removeRight("foobar", "BAR",false)
-// result => "foo"
-```
-
-## removeSpaces
-
-Remove all spaces and replace for value.
-
-```java
-removeSpaces("foo bar")
-// result => "foobar"
-```
-
-## repeat
-
-Returns a repeated string given a multiplier.
-
-```
-repeat("1", 3)
-// result  => "111"
-```
-
-## reverse
-
-Reverse the input String
-
-```java
-reverse("foo")
-// result => "oof"
-```
-
-## rightPad
-
-Returns a new string of a given length such that the ending of the string is padded.
-
-```java
-rightPad("1", "0", 5)
-// result => "10000"
-```
-
-## rightTrim
-
-Remove all spaces on right.
-
-```java
-rightTrim("strman   ")
-// result => "strman"
-```
-
-## safeTruncate
-
-Truncate the string securely, not cutting a word in half. It always returns the last full word.
-
-```java
-safeTruncate("foo bar", 4, ".")
-// result => "foo."
-safeTruncate("A Javascript string manipulation library.", 16, "...")
-// result => "A Javascript..."
-```
-
-## truncate
-
-Truncate the unsecured form string, cutting the independent string of required position.
-
-```java
-truncate("A Javascript string manipulation library.", 14, "...")
-// result => "A Javascrip..."
-```
-
-## htmlDecode
-
-Converts all HTML entities to applicable characters.
-
-```java
-htmlDecode("&SHcy;")
-// result => Ш
-```
-
-## htmlEncode
-
-Convert all applicable characters to HTML entities.
-
-```java
-htmlEncode("Ш")
-// result => "&SHcy;"
-```
-
-## shuffle
-
-It returns a string with its characters in random order.
-
-```java
-shuffle("shekhar")
-```
-
-## slugify
-
-Convert a String to a slug
-
-```java
-slugify("foo bar")
-// result => "foo-bar"
-```
-
-## transliterate
-
-Remove all non valid characters. Example: change á => a or ẽ => e.
-
-```java
-transliterate("fóõ bár")
-// result => "foo bar"
-```
-
-## trimEnd
-
-Removes trailing characters from string.
-
-```
-trimEnd("   abc   ")
-// result => Optional("   abc")
-trimEnd("")
-// result Optional.empty()
-```
-
-## surround
-
-Surrounds a 'value' with the given 'prefix' and 'suffix'.
-
-```java
-surround("div", "<", ">"
-// result => "<div>s"
-```
-
-## tail
-
-```java
-tail("foobar")
-// result => "oobar"
-```
-
-## toCamelCase
-
-Transform to camelCase
-
-```java
-toCamelCase("CamelCase")
-// result => "camelCase"
-toCamelCase("camel-case")
-// result => "camelCase"
-```
-
-## toStudlyCase
-
-Transform to StudlyCaps.
-
-```java
-toStudlyCase("hello world")
-// result => "HelloWorld"
-```
-
-## toDecamelize
-
-Decamelize String
-
-```java
-toDecamelize("helloWorld",null)
-// result => "hello world"
-```
-
-## toKebabCase
-
-Transform to kebab-case.
-
-```java
-toKebabCase("hello World")
-// result => "hello-world"
-```
-
-## toSnakeCase
-
-Transform to snake_case.
-
-```java
-toSnakeCase("hello world")
-// result => "hello_world"
-```
-
-## upperFirst
-
-Converts the first character of string to upper case.
-
-```java
-upperFirst("fred")
-// result => "Fred"
-```
-
-## words
-
-Splits a String to words
-
-```java
-words("This is a string, with words!")
-// result => ["This", "is", "a", "string", "with", "words"]
-```
-
-## isEnclosedBetween
-
-Verifies whether String is enclosed by encloser
-
-```java
-isEnclosedBetween("{{shekhar}}", "{{", "}}")
-// result => true
-```
-
-## join
-
-Join concatenates all the elements of the strings array into a single String. The separator string is placed between elements in the resulting string.
-
-```java
-join(new String[]{"hello","world","123"}, ";")
-// result => "hello;world;123")
-```
-
-## isBlank
-
-isEmpty returns true if a string is blank or null and false otherwise.
-
-```java
-isBlank("")
-// result => true)
-isBlank(null)
-// result => true)
-isBlank("test")
-// result => false)
-```
-
-## underscored
-
-`underscored` function converts a camel or dashed string into an underscored one
-
-```java
-underscored("MozTransform")
-// result => "moz_transform")
-```
+You can refer to Javadocs online [http://shekhargulati.github.io/strman-java/](http://shekhargulati.github.io/strman-java/).
 
 ## Inspiration
 

From befff2625bf6183b9a94a02d5163a5aa732c6b25 Mon Sep 17 00:00:00 2001
From: Francesca Guiducci <guiducci.francesca@gmail.com>
Date: Thu, 19 Oct 2017 12:42:13 -0700
Subject: [PATCH 43/46] Add startCase function (#94)

---
 src/main/java/strman/Strman.java      | 15 +++++++++++++++
 src/test/java/strman/StrmanTests.java | 18 ++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 6598b0b..b66f717 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1404,6 +1404,21 @@ public static String[] chop(String input, int step) {
                 .toArray(String[]::new);
     }
 
+    /**
+     * Converts a String into its Start Case version
+     * https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage
+     *
+     * @param input The input String
+     * @return Start Case String
+     */
+    public static String startCase(final String input) {
+        validate(input, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
+        // split into a word when we encounter a space, or an underscore, or a dash, or a switch from lower to upper case
+        String[] words = words(input, "\\s|_|-|(?<=[a-z])(?=[A-Z])");
+        return Arrays.stream(words).filter(w -> !w.trim().isEmpty())
+            .map(w -> upperFirst(w.toLowerCase())).collect(joining(" "));
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index ae7b88e..c5ea9bc 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -1186,4 +1186,22 @@ public void chop_shouldChopStringByStep() throws Exception {
         assertThat(chop("whitespace", 3).length, equalTo(4));
         assertThat(chop("whitespace", 0)[0].length(), equalTo(10));
     }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void startCase_shouldThrowException() throws Exception {
+        startCase(null);
+    }
+
+    @Test
+    public void startCase_shouldStartCaseInputString() throws Exception {
+        assertThat(startCase(""), equalTo(""));
+        assertThat(startCase("ALL CAPS"), equalTo("All Caps"));
+        assertThat(startCase("camelCase"), equalTo("Camel Case"));
+        assertThat(startCase("kebab-case"), equalTo("Kebab Case"));
+        assertThat(startCase("Snake_case"), equalTo("Snake Case"));
+        assertThat(startCase("  spaces  "), equalTo("Spaces"));
+        assertThat(startCase("spaces    between    words"), equalTo("Spaces Between Words"));
+        assertThat(startCase("--dashes--"), equalTo("Dashes"));
+        assertThat(startCase("dashes----between----words"), equalTo("Dashes Between Words"));
+    }
 }

From da85915b8ddff9a74041ee6f9c58bcba095a36c8 Mon Sep 17 00:00:00 2001
From: vic-nik <vic.v.nik@gmail.com>
Date: Sun, 22 Oct 2017 09:39:20 +0200
Subject: [PATCH 44/46] Partially resolved #78 (#96)

* Partially resolved #78 (Hacktoberfest initiative)

* Removing trailing whitespaces
---
 src/main/java/strman/Strman.java      | 23 +++++++++++++++++++++++
 src/test/java/strman/StrmanTests.java |  8 ++++++++
 2 files changed, 31 insertions(+)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index b66f717..b56f567 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1389,6 +1389,29 @@ public static String swapCase(String input) {
         return resultBuilder.toString();
     }
 
+    /**
+     * Returns a string representation of the number passed in where groups of three digits are delimited by comma
+     *
+     * @param number Input number
+     * @return formatted String
+     */
+    public static String formatNumber(long number) {
+        String stringRepresentation = Long.toString(number);
+        StringBuilder sb = new StringBuilder();
+        int bound = stringRepresentation.length() - 1;
+        String delimiter = ",";
+        int counter = 0;
+        for (int i = bound; i >= 0; i--) {
+            char c = stringRepresentation.charAt(i);
+            if (i != bound && counter % 3 == 0) {
+                sb.append(delimiter);
+            }
+            sb.append(c);
+            counter++;
+        }
+        return sb.reverse().toString();
+    }
+
     public static String[] chop(String input, int step) {
         if (input == null || input.length() == 0) {
             return EMPTY_ARRAY;
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index c5ea9bc..3a3c7fd 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -1187,6 +1187,14 @@ public void chop_shouldChopStringByStep() throws Exception {
         assertThat(chop("whitespace", 0)[0].length(), equalTo(10));
     }
 
+    @Test
+    public void formatNumber_shouldFormatNumberWithCommaDelimiter() throws Exception {
+        assertThat(formatNumber(1000), equalTo("1,000"));
+        assertThat(formatNumber(100000), equalTo("100,000"));
+        assertThat(formatNumber(10000000), equalTo("10,000,000"));
+        assertThat(formatNumber(100000000), equalTo("100,000,000"));
+    }
+
     @Test(expected = IllegalArgumentException.class)
     public void startCase_shouldThrowException() throws Exception {
         startCase(null);

From 9fb07aa1f8928b9ab936aed43c4f9ce84d28a997 Mon Sep 17 00:00:00 2001
From: Francesca Guiducci <guiducci.francesca@gmail.com>
Date: Sun, 22 Oct 2017 00:39:40 -0700
Subject: [PATCH 45/46] Add escapeRegExp function (#95)

---
 src/main/java/strman/Strman.java      |  5 +++++
 src/test/java/strman/StrmanTests.java | 26 ++++++++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index b56f567..0504c26 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -1442,6 +1442,11 @@ public static String startCase(final String input) {
             .map(w -> upperFirst(w.toLowerCase())).collect(joining(" "));
     }
 
+    public static String escapeRegExp(final String input) {
+        validate(input, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
+        return input.replaceAll("[\\\\\\^\\$\\*\\+\\-\\?\\.\\|\\(\\)\\{\\}\\[\\]]", "\\\\$0");
+    }
+
     private static void validate(String value, Predicate<String> predicate, final Supplier<String> supplier) {
         if (predicate.test(value)) {
             throw new IllegalArgumentException(supplier.get());
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index 3a3c7fd..d2db29b 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -1212,4 +1212,30 @@ public void startCase_shouldStartCaseInputString() throws Exception {
         assertThat(startCase("--dashes--"), equalTo("Dashes"));
         assertThat(startCase("dashes----between----words"), equalTo("Dashes Between Words"));
     }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void escapeRegExp_shouldThrowException() throws Exception {
+        escapeRegExp(null);
+    }
+
+    @Test
+    public void escapeRegExp_shouldEscapeRegExp() throws Exception {
+        assertThat(escapeRegExp("\\"), equalTo("\\\\"));
+        assertThat(escapeRegExp("^"), equalTo("\\^"));
+        assertThat(escapeRegExp("$"), equalTo("\\$"));
+        assertThat(escapeRegExp("*"), equalTo("\\*"));
+        assertThat(escapeRegExp("+"), equalTo("\\+"));
+        assertThat(escapeRegExp("-"), equalTo("\\-"));
+        assertThat(escapeRegExp("?"), equalTo("\\?"));
+        assertThat(escapeRegExp("."), equalTo("\\."));
+        assertThat(escapeRegExp("|"), equalTo("\\|"));
+        assertThat(escapeRegExp("("), equalTo("\\("));
+        assertThat(escapeRegExp(")"), equalTo("\\)"));
+        assertThat(escapeRegExp("{"), equalTo("\\{"));
+        assertThat(escapeRegExp("}"), equalTo("\\}"));
+        assertThat(escapeRegExp("["), equalTo("\\["));
+        assertThat(escapeRegExp("]"), equalTo("\\]"));
+        assertThat(escapeRegExp("How much is (2+3)? 5"), equalTo("How much is \\(2\\+3\\)\\? 5"));
+        assertThat(escapeRegExp("\\s|_|-|(?<=[a-z])(?=[A-Z])"), equalTo("\\\\s\\|_\\|\\-\\|\\(\\?<=\\[a\\-z\\]\\)\\(\\?=\\[A\\-Z\\]\\)"));
+    }
 }

From d0c2a10a6273fd6082f084e95156653ca55ce1be Mon Sep 17 00:00:00 2001
From: lizho <lizho@msn.com>
Date: Fri, 10 Nov 2017 13:59:03 +0800
Subject: [PATCH 46/46] Update Strman.java (#97)

* Update Strman.java

fix bug in between()

* Update StrmanTests.java

* Update StrmanTests.java
---
 src/main/java/strman/Strman.java      | 4 +++-
 src/test/java/strman/StrmanTests.java | 6 +++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/main/java/strman/Strman.java b/src/main/java/strman/Strman.java
index 0504c26..9b1e3c2 100644
--- a/src/main/java/strman/Strman.java
+++ b/src/main/java/strman/Strman.java
@@ -115,7 +115,9 @@ public static String[] between(final String value, final String start, final Str
         validate(end, NULL_STRING_PREDICATE, () -> "'end' should be not null.");
 
         String[] parts = value.split(end);
-        return Arrays.stream(parts).map(subPart -> subPart.substring(subPart.indexOf(start) + start.length()))
+        return Arrays.stream(parts)
+                .filter(subPart -> subPart.contains(start))
+                .map(subPart -> subPart.substring(subPart.indexOf(start) + start.length()))
                 .toArray(String[]::new);
     }
 
diff --git a/src/test/java/strman/StrmanTests.java b/src/test/java/strman/StrmanTests.java
index d2db29b..8ab7ffe 100644
--- a/src/test/java/strman/StrmanTests.java
+++ b/src/test/java/strman/StrmanTests.java
@@ -92,9 +92,9 @@ public void between_shouldReturnArrayWithStringsBetweenStartAndEnd() throws Exce
     }
 
     @Test
-    public void between_shouldReturnFullStringWhenStartAndEndDoesNotExist() throws Exception {
-        assertThat(between("[abc][def]", "{", "}"), arrayContaining("[abc][def]"));
-        assertThat(between("", "{", "}"), arrayContaining(""));
+    public void between_shouldReturnEmptyArrayWhenStartAndEndDoesNotExist() throws Exception {
+        assertThat(between("[abc][def]", "{", "}").length, equalTo(0));
+        assertThat(between("", "{", "}").length, equalTo(0));
     }
 
     @Test