update: Use JsonUrlOptions in JsonUrl static's and ParseResultFacade

The static methods in org.jsonurl.JsonUrl should follow the same
pattern and accept an instance of the JsonUrl options interface.

Additionally, while it's not visible to code outside the package,
ParseResultFacade has been updated to use them as well.

Author: dmaccormack

module/jsonurl-core/src/main/java/org/jsonurl/JsonUrl.java

@@ -306,18 +306,17 @@ static String literalToJavaString(
                 CharSequence text,
                 int start,
                 int stop,
-                boolean isEmptyUnquotedStringOK,
-                boolean isImpliedStringLiteral) {
+                JsonUrlOptions options) {
 
             if (stop <= start) {
-                if (isEmptyUnquotedStringOK) {
+                if (JsonUrlOptions.isEmptyUnquotedKeyAllowed(options)) {
                     return EMPTY_STRING;
                 }
 
                 throw new SyntaxException(MSG_EXPECT_LITERAL, start);
             }
 
-            if (isImpliedStringLiteral) {
+            if (JsonUrlOptions.isImpliedStringLiterals(options)) {
                 return string(buf, text, start, stop, false);
             }
 
@@ -373,18 +372,17 @@ static <V> V literal(
                 int start,
                 int stop,
                 ValueFactory<V,?,?,?,?,?,?,?,?,?> factory,
-                boolean isEmptyUnquotedStringOK,
-                boolean isImpliedStringLiteral) {
+                JsonUrlOptions options) {
 
             if (stop <= start) {
-                if (isEmptyUnquotedStringOK) {
+                if (JsonUrlOptions.isEmptyUnquotedValueAllowed(options)) {
                     return factory.getString("");
                 }
 
                 throw new SyntaxException(MSG_EXPECT_LITERAL, start);
             }
 
-            if (isImpliedStringLiteral) {
+            if (JsonUrlOptions.isImpliedStringLiterals(options)) {
                 return factory.getString(
                         string(buf, text, start, stop, false));
             }
@@ -745,17 +743,15 @@ public static int parseLiteralLength(CharSequence text) {
      * @param start start position in text
      * @param length number of characters to parse
      * @param factory a valid ValueFactory
-     * @param isEmptyUnquotedStringOK if true, allow empty unquoted strings
-     * @param isImpliedStringLiteral if true, assume all literals are strings
+     * @param options parse options
      * @return an object for the parsed literal
      */
     public static <V> V parseLiteral(
             CharSequence text,
             int start,
             int length,
             ValueFactory<V,?,?,?,?,?,?,?,?,?> factory,
-            boolean isEmptyUnquotedStringOK,
-            boolean isImpliedStringLiteral) {
+            JsonUrlOptions options) {
 
         //
         // Note: not checking length == 0 here. That case is handled properly
@@ -764,8 +760,9 @@ public static <V> V parseLiteral(
 
         int stop = start + length;
 
-        final SyntaxException.Message errmsg = isEmptyUnquotedStringOK
-            ? null : MSG_EXPECT_LITERAL;
+        final SyntaxException.Message errmsg =
+                JsonUrlOptions.isEmptyUnquotedValueAllowed(options)
+                    ? null : MSG_EXPECT_LITERAL;
 
         parseLiteralLength(text, start, stop, errmsg);
 
@@ -776,18 +773,17 @@ public static <V> V parseLiteral(
                 start,
                 stop,
                 factory,
-                isEmptyUnquotedStringOK,
-                isImpliedStringLiteral);
+                options);
     }
 
     /**
      * Parse a single literal value.
      *
      * <p>This simply calls
-     * {@link #parseLiteral(CharSequence, int, int, ValueFactory, boolean, boolean)
+     * {@link #parseLiteral(CharSequence, int, int, ValueFactory, JsonUrlOptions)
      * parseLiteral(s, start, length, JavaValueFactory.PRIMITIVE, false, false)}.
      *
-     * @see #parseLiteral(CharSequence, int, int, ValueFactory, boolean, boolean)
+     * @see #parseLiteral(CharSequence, int, int, ValueFactory, JsonUrlOptions)
      * @see JavaValueFactory#PRIMITIVE
      */
     public static Object parseLiteral(
@@ -800,18 +796,17 @@ public static Object parseLiteral(
                 start,
                 length,
                 JavaValueFactory.PRIMITIVE,
-                false,
-                false);
+                null);
     }
 
     /**
      * Parse a single literal value.
      *
      * <p>This simply calls
-     * {@link #parseLiteral(CharSequence, int, int, ValueFactory, boolean, boolean)
+     * {@link #parseLiteral(CharSequence, int, int, ValueFactory, JsonUrlOptions)
      * parseLiteral(s, 0, s.length(), JavaValueFactory.PRIMITIVE, false, false)}.
      *
-     * @see #parseLiteral(CharSequence, int, int, ValueFactory, boolean, boolean)
+     * @see #parseLiteral(CharSequence, int, int, ValueFactory, JsonUrlOptions)
      * @see JavaValueFactory#PRIMITIVE
      */
     public static Object parseLiteral(CharSequence text) {
@@ -820,22 +815,21 @@ public static Object parseLiteral(CharSequence text) {
                 0,
                 text.length(),
                 JavaValueFactory.PRIMITIVE,
-                false,
-                false);
+                null);
     }
 
     /**
      * Parse a single literal value.
      *
      * <p>This simply calls
-     * {@link #parseLiteral(CharSequence, int, int, ValueFactory, boolean, boolean)
+     * {@link #parseLiteral(CharSequence, int, int, ValueFactory, JsonUrlOptions)
      * parseLiteral(s, 0, s.length(), factory, false, false)}.
-     * @see #parseLiteral(CharSequence, int, int, ValueFactory, boolean, boolean)
+     * @see #parseLiteral(CharSequence, int, int, ValueFactory, JsonUrlOptions)
      */
     public static <V> V parseLiteral(
             CharSequence text,
             ValueFactory<V,?,?,?,?,?,?,?,?,?> factory) {
-        return parseLiteral(text, 0, text.length(), factory, false, false);
+        return parseLiteral(text, 0, text.length(), factory, null);
     }
 
     /**
@@ -854,18 +848,21 @@ public static <T extends Appendable> boolean appendLiteral(// NOPMD - Cyclomatic
             int start,
             int end,
             boolean isKey,
-            boolean isEmptyUnquotedStringOK,
-            boolean isImpliedStringLiteral) throws IOException {
+            JsonUrlOptions options) throws IOException {
 
         if (end <= start) {
             //
             // empty string
             //
-            if (isEmptyUnquotedStringOK) {
+            boolean emptyOK = isKey
+                    ? JsonUrlOptions.isEmptyUnquotedKeyAllowed(options)
+                    : JsonUrlOptions.isEmptyUnquotedValueAllowed(options);
+
+            if (emptyOK) {
                 return false;
             }
 
-            if (isImpliedStringLiteral) {
+            if (JsonUrlOptions.isImpliedStringLiterals(options)) {
                 throw new IOException("implied strings: unexpected empty string");
             }
 
@@ -876,7 +873,7 @@ public static <T extends Appendable> boolean appendLiteral(// NOPMD - Cyclomatic
             return true;
         }
 
-        if (isImpliedStringLiteral) {
+        if (JsonUrlOptions.isImpliedStringLiterals(options)) {
             Encode.encode(dest, text, start, end, false, true);
             return true;
         }

module/jsonurl-core/src/main/java/org/jsonurl/JsonUrlTextAppender.java

@@ -185,17 +185,13 @@ public JsonUrlTextAppender<A,R> add(
             return addNull();
         }
 
-        boolean emptyOK = isKey
-                ? isEmptyUnquotedKeyAllowed() : isEmptyUnquotedValueAllowed();
-
         JsonUrl.appendLiteral(
                 out,
                 text,
                 start,
                 end,
                 isKey,
-                emptyOK,
-                isImpliedStringLiterals());
+                this);
 
         return this;
     }

module/jsonurl-core/src/main/java/org/jsonurl/ParseResultFacade.java

@@ -68,12 +68,7 @@ interface ParseResultFacade<R> {
     /**
      * Add the given literal.
      */
-    void addLiteral(
-            CharSequence text,
-            int start,
-            int stop,
-            boolean isEmptyUnquotedStringOK,
-            boolean isImpliedStringLiteral);
+    void addLiteral(CharSequence text, int start, int stop);
 
     /**
      * Add a single element array.
@@ -86,22 +81,12 @@ void addLiteral(
      * endArray();
      * </pre>
      */
-    void addSingleElementArray(
-            CharSequence text,
-            int start,
-            int stop,
-            boolean isEmptyUnquotedStringOK,
-            boolean isImpliedStringLiteral);
+    void addSingleElementArray(CharSequence text, int start, int stop);
 
     /**
      * Add object key.
      */
-    void addObjectKey(
-        CharSequence text,
-        int start,
-        int stop,
-        boolean isEmptyUnquotedStringOK,
-        boolean isImpliedStringLiteral);
+    void addObjectKey(CharSequence text, int start, int stop);
 
     /**
      * Add an array element.
@@ -121,12 +106,7 @@ void addObjectKey(
     /**
      * Get a top-level literal result.
      */
-    R getResult(
-            CharSequence text,
-            int start,
-            int stop,
-            boolean isEmptyUnquotedStringOK,
-            boolean isImpliedStringLiteral);
+    R getResult(CharSequence text, int start, int stop);
 
     /**
      * Test if the given result is valid.
@@ -153,6 +133,5 @@ R getResult(
     ParseResultFacade<R> addMissingValue(
             CharSequence text,
             int start,
-            int stop,
-            boolean isImpliedStringLiteral);
+            int stop);
 }