Add new elements (#16)

* Added new whitespace RegexBuilder methods

* Added RegexBuilder.possibleWhitespace()

* Deprecated RegexQuantifier.noneOrOne(), replaced with zeroOrOne()

* Changed RegexBuilder.anyOf() to take variable args and fixed bug in anyOf(String, RegexQuantifier)

* Bug fix in makeSafeForRegex()

Author: Mark Whitaker

src/main/java/uk/co/mainwave/regextoolbox/RegexBuilder.java

@@ -218,6 +218,102 @@ public RegexBuilder nonWhitespace(final RegexQuantifier quantifier) {
         return this;
     }
 
+    /**
+     * Add an element to represent any amount of white space, including none. This is just a convenient alias for
+     * {@code whitespace(RegexQuantifier.zeroOrMore())}.
+     *
+     * @return The current {@link RegexBuilder} object, for method chaining
+     */
+    public RegexBuilder possibleWhitespace() {
+        return whitespace(RegexQuantifier.zeroOrMore());
+    }
+
+    /**
+     * Add an element to match a single space character. If you want to match any kind of white space, use
+     * {@link #whitespace()}.
+     *
+     * @return The current {@link RegexBuilder} object, for method chaining
+     */
+    public RegexBuilder space() {
+        return space(null);
+    }
+
+    /**
+     * Add an element to match a single space character. If you want to match any kind of white space, use
+     * {@link #whitespace()}.
+     *
+     * @param quantifier Quantifier to apply to this element
+     * @return The current {@link RegexBuilder} object, for method chaining
+     */
+    public RegexBuilder space(final RegexQuantifier quantifier) {
+        stringBuilder.append(" ");
+        addQuantifier(quantifier);
+        return this;
+    }
+
+    /**
+     * Add an element to match a single tab character.
+     *
+     * @return The current {@link RegexBuilder} object, for method chaining
+     */
+    public RegexBuilder tab() {
+        return tab(null);
+    }
+
+    /**
+     * Add an element to match a single tab character.
+     *
+     * @param quantifier Quantifier to apply to this element
+     * @return The current {@link RegexBuilder} object, for method chaining
+     */
+    public RegexBuilder tab(final RegexQuantifier quantifier) {
+        stringBuilder.append("\\t");
+        addQuantifier(quantifier);
+        return this;
+    }
+
+    /**
+     * Add an element to match a single line feed character.
+     *
+     * @return The current {@link RegexBuilder} object, for method chaining
+     */
+    public RegexBuilder lineFeed() {
+        return lineFeed(null);
+    }
+
+    /**
+     * Add an element to match a single line feed character.
+     *
+     * @param quantifier Quantifier to apply to this element
+     * @return The current {@link RegexBuilder} object, for method chaining
+     */
+    public RegexBuilder lineFeed(final RegexQuantifier quantifier) {
+        stringBuilder.append("\\n");
+        addQuantifier(quantifier);
+        return this;
+    }
+
+    /**
+     * Add an element to match a single carriage return character.
+     *
+     * @return The current {@link RegexBuilder} object, for method chaining
+     */
+    public RegexBuilder carriageReturn() {
+        return carriageReturn(null);
+    }
+
+    /**
+     * Add an element to match a single carriage return character.
+     *
+     * @param quantifier Quantifier to apply to this element
+     * @return The current {@link RegexBuilder} object, for method chaining
+     */
+    public RegexBuilder carriageReturn(final RegexQuantifier quantifier) {
+        stringBuilder.append("\\r");
+        addQuantifier(quantifier);
+        return this;
+    }
+
     /**
      * Add an element to match any single decimal digit (0-9).
      *
@@ -574,7 +670,7 @@ public RegexBuilder anyCharacterExcept(final String characters, final RegexQuant
      * @param strings A number of strings, any one of which will be matched
      * @return The current {@link RegexBuilder} object, for method chaining
      */
-    public RegexBuilder anyOf(final String[] strings) {
+    public RegexBuilder anyOf(final String... strings) {
         return anyOf(strings, null);
     }
 
@@ -604,7 +700,7 @@ public RegexBuilder anyOf(final String[] strings, final RegexQuantifier quantifi
         RegexBuilder builder = null;
         try {
             builder = startNonCapturingGroup()
-                    .regexText(String.join("|", safeStrings), quantifier)
+                    .regexText(String.join("|", safeStrings))
                     .endGroup(quantifier);
         } catch (RegexBuilderException ignored) {
             // We won't get an exception from endGroup() as we know we started the group properly
@@ -760,8 +856,7 @@ private String makeSafeForCharacterClass(final String s) {
     }
 
     private static String makeSafeForRegex(final String s) {
-
-        return s
+        return (s == null) ? "" : s
                 // Make sure this always comes first!
                 .replace("\\", "\\\\")
                 .replace("?", "\\?")

src/main/java/uk/co/mainwave/regextoolbox/RegexQuantifier.java

@@ -30,13 +30,24 @@ public static RegexGreedyQuantifier oneOrMore() {
 
     /**
      * Quantifier to match the preceding element once or not at all
+     * @deprecated Use {@link #zeroOrOne()} instead
      *
      * @return A greedy quantifier: use {@link RegexGreedyQuantifier#butAsFewAsPossible()} to make it non-greedy
      */
+    @Deprecated
     public static RegexGreedyQuantifier noneOrOne() {
         return new RegexGreedyQuantifier("?");
     }
 
+    /**
+     * Quantifier to match the preceding element once or not at all
+     *
+     * @return A greedy quantifier: use {@link RegexGreedyQuantifier#butAsFewAsPossible()} to make it non-greedy
+     */
+    public static RegexGreedyQuantifier zeroOrOne() {
+        return new RegexGreedyQuantifier("?");
+    }
+
     /**
      * Quantifier to match an exact number of occurrences of the preceding element
      *