feat: Add support for implied string literals

dmaccormack · dmaccormack · commit 1ff72c6c590b · 2020-10-15T13:05:56.000-04:00
diff --git a/src/JsonURL.js b/src/JsonURL.js
@@ -275,13 +275,39 @@ function parseLiteralLength(text, i, end, errmsg) {
   return end;
 }
 
+function parseStringLiteral(text, pos, end, removeQuotes) {
+  let ret = removeQuotes
+    ? text.substring(pos + 1, end - 1)
+    : text.substring(pos, end);
+
+  ret = ret.replace(rx_decode_space, " ");
+  ret = decodeURIComponent(ret);
+
+  return ret;
+}
+
+function encodeStringLiteral(text) {
+  let ret = encodeURIComponent(text);
+  ret = ret.replace(rx_encode_pctspace, "+");
+  ret = ret.replace(",", "%x2C");
+  ret = ret.replace(":", "%x3A");
+  ret = ret.replace("(", "%x28");
+  ret = ret.replace(")", "%x29");
+
+  return ret;
+}
+
 function toJsonURLText_Boolean() {
   return this === true ? "true" : "false";
 }
 function toJsonURLText_Number() {
   return String(this);
 }
 function toJsonURLText_String(options, depth, isKey) {
+  if (options.impliedStringLiterals) {
+    return encodeStringLiteral(this);
+  }
+
   if (this.length === 0) {
     return "''";
   }
@@ -324,8 +350,7 @@ function toJsonURLText_String(options, depth, isKey) {
     return "'" + this.replace(rx_encode_space, "+") + "'";
   }
 
-  let ret = encodeURIComponent(this);
-  ret = ret.replace(rx_encode_pctspace, "+");
+  let ret = encodeStringLiteral(this);
 
   if (ret.charCodeAt(0) == CHAR_QUOTE) {
     //
@@ -638,7 +663,17 @@ class JsonURL {
    * @param {boolean} forceString True if the resulting literal should be
    * a string, such as in the case of an object key.
    */
-  parseLiteral(text, pos = 0, end = text.length, forceString = false) {
+  parseLiteral(
+    text,
+    pos = 0,
+    end = text.length,
+    forceString = false,
+    impliedStringLiteral = false
+  ) {
+    if (impliedStringLiteral === true) {
+      return parseStringLiteral(text, pos, end, false);
+    }
+
     let c1, c2, c3, c4, c5;
 
     switch (end - pos) {
@@ -707,18 +742,7 @@ class JsonURL {
     //
     // this is a string
     //
-    var ret;
-
-    if (isQuotedString) {
-      ret = text.substring(pos + 1, end - 1);
-    } else {
-      ret = text.substring(pos, end);
-    }
-
-    ret = ret.replace(rx_decode_space, " ");
-    ret = decodeURIComponent(ret);
-
-    return ret;
+    return parseStringLiteral(text, pos, end, isQuotedString);
   }
 
   /**
@@ -745,6 +769,8 @@ class JsonURL {
    * is may use ampersand and equal characters as the value and member
    * separator characters, respetively, at the top-level. This may be
    * combined with prop.impliedArray or prop.impliedObject.
+   * @param {boolean} options.impliedStringLiterals Assume all literals
+   * are strings.
    * @throws SyntaxError if there is a syntax error in the given text
    * @throws Error if a limit given in the constructor (or its default)
    * is exceeded.
@@ -798,7 +824,13 @@ class JsonURL {
         throw new SyntaxError(errorMessage(ERR_MSG_EXPECT_LITERAL, 0));
       }
 
-      return this.parseLiteral(text, 0, end, false);
+      return this.parseLiteral(
+        text,
+        0,
+        end,
+        false,
+        options.impliedStringLiterals
+      );
     } else {
       stateStack.push(STATE_PAREN);
       pos = 1;
@@ -878,7 +910,13 @@ class JsonURL {
           valueStack.checkValueLimit(pos);
 
           c = text.charCodeAt(lvpos);
-          lv = this.parseLiteral(text, pos, lvpos, c === CHAR_COLON);
+          lv = this.parseLiteral(
+            text,
+            pos,
+            lvpos,
+            c === CHAR_COLON,
+            options.impliedStringLiterals
+          );
           pos = lvpos;
 
           switch (c) {
@@ -963,7 +1001,13 @@ class JsonURL {
           lvpos = parseLiteralLength(text, pos, end, ERR_MSG_EXPECT_VALUE);
 
           valueStack.checkValueLimit(pos);
-          lv = this.parseLiteral(text, pos, lvpos, false);
+          lv = this.parseLiteral(
+            text,
+            pos,
+            lvpos,
+            false,
+            options.impliedStringLiterals
+          );
           pos = lvpos;
 
           if (pos === end) {
@@ -1039,7 +1083,13 @@ class JsonURL {
           lvpos = parseLiteralLength(text, pos, end, ERR_MSG_EXPECT_VALUE);
 
           valueStack.checkValueLimit(pos);
-          lv = this.parseLiteral(text, pos, lvpos, false);
+          lv = this.parseLiteral(
+            text,
+            pos,
+            lvpos,
+            false,
+            options.impliedStringLiterals
+          );
           pos = lvpos;
 
           if (lvpos === end) {
@@ -1132,7 +1182,13 @@ class JsonURL {
               throw new SyntaxError((ERR_MSG_EXPECT_OBJVALUE, lvpos));
           }
 
-          lv = this.parseLiteral(text, pos, lvpos, true);
+          lv = this.parseLiteral(
+            text,
+            pos,
+            lvpos,
+            true,
+            options.impliedStringLiterals
+          );
           pos = lvpos + 1;
 
           stateStack.replace(STATE_OBJECT_HAVE_KEY);
@@ -1167,10 +1223,18 @@ class JsonURL {
    * structural characters.
    * @param {boolean} options.isImplied Create JSON->URL text for an implied
    * array or object.
+   * @param {boolean} options.impliedStringLiterals Assume all literals
+   * are strings.
    * @returns {string} JSON->URL text, or undefined if the given value
    * is undefined.
    */
-  static stringify(value, options = { ignoreUndefinedObjectMembers: true }) {
+  static stringify(
+    value,
+    options = {
+      ignoreUndefinedObjectMembers: true,
+      impliedStringLiterals: false,
+    }
+  ) {
     if (value === undefined) {
       return undefined;
     }
diff --git a/test/parseImpliedStringLiterals.test.js b/test/parseImpliedStringLiterals.test.js
@@ -0,0 +1,76 @@
+/*
+  MIT License
+
+  Copyright (c) 2020 David MacCormack
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+import JsonURL from "../src/JsonURL.js";
+
+const u = new JsonURL();
+
+test.each([
+  ["()", u.emptyValue],
+  [
+    "(true:true,false:false,null:null,empty:(),single:(0),nested:((1)),many:(-1,2.0,3e1,4e-2,5e+0))",
+    {
+      true: "true",
+      false: "false",
+      null: "null",
+      empty: {},
+      single: ["0"],
+      nested: [["1"]],
+      many: ["-1", "2.0", "3e1", "4e-2", "5e 0"],
+    },
+  ],
+  ["(1)", ["1"]],
+  ["(1,(2))", ["1", ["2"]]],
+  ["(1,(a:2),3)", ["1", { a: "2" }, "3"]],
+  [
+    "(age:64,name:(first:Fred))",
+    {
+      age: "64",
+      name: { first: "Fred" },
+    },
+  ],
+  ["(null,null)", ["null", "null"]],
+  ["(a:b,c:d,e:f)", { a: "b", c: "d", e: "f" }],
+  ["1e%2B1", "1e+1"],
+  ["'Hello,+(World)!'", "'Hello, (World)!'"],
+  ["Bob's+house", "Bob's house"],
+  ["('Hello,+(World)!')", ["'Hello, (World)!'"]],
+  ["('','')", ["''", "''"]],
+  ["('qkey':g)", { "'qkey'": "g" }],
+])("JsonURL.parse(%s)", (text, expected) => {
+  expect(u.parse(text, { impliedStringLiterals: true })).toEqual(expected);
+
+  //
+  // verify that stringify returns the same content as the
+  // original text.
+  //
+  // expect(JsonURL.stringify(expected)).toBe(
+  //   text
+  //     .replace("3e1", "30")
+  //     .replace("2.0", "2")
+  //     .replace("4e-2", "0.04")
+  //     .replace("5e+0", "5")
+  //     .replace("'qkey'", "qkey")
+  // );
+});
diff --git a/test/parseLiteral.test.js b/test/parseLiteral.test.js
@@ -34,9 +34,10 @@ function encodedString(s) {
     .replace(/:/, "%3A");
 }
 
-function runTest(text, value, keyValue) {
+function runTest(text, value, keyValue, strLitValue) {
   expect(u.parseLiteral(text)).toBe(value);
   expect(u.parseLiteral(text, 0, text.length, true)).toBe(keyValue);
+  expect(u.parseLiteral(text, 0, text.length, true, true)).toBe(strLitValue);
 
   //
   // verify that parseLiteral() and parse() return the same thing (as
@@ -116,36 +117,39 @@ test.each([
 ])("JsonURL.parseLiteral(%p)", (value) => {
   let keyValue = String(value);
   let text = typeof value === "string" ? encodedString(keyValue) : keyValue;
-  runTest(text, value, keyValue);
+  runTest(text, value, keyValue, keyValue);
 });
 
 test.each([
   //
   // fixed point
   //
-  ["-3e0", -3],
-  ["1e+2", 1e2],
-  ["-2e+1", -2e1],
+  ["-3e0", -3, "-3e0"],
+  ["1e+2", 1e2, "1e 2"],
+  ["-2e+1", -2e1, "-2e 1"],
 
   //
   // floating point
   //
-  ["156.911e+2", 156.911e2],
+  ["156.911e+2", 156.911e2, "156.911e 2"],
 
   //
   // string
   //
-  ["'hello'", "hello"],
-  ["hello%2Bworld", "hello+world"],
-  ["y+%3D+mx+%2B+b", "y = mx + b"],
-  ["a%3Db%26c%3Dd", "a=b&c=d"],
-  ["hello%F0%9F%8D%95world", "hello\uD83C\uDF55world"],
-  ["-e+", "-e "],
-  ["-e+1", "-e 1"],
-  ["1e%2B1", "1e+1"],
-])("JsonURL.parseLiteral(%p)", (text, value) => {
+  ["'hello'", "hello", "'hello'", undefined],
+  ["hello%2Bworld", "hello+world", undefined],
+  ["y+%3D+mx+%2B+b", "y = mx + b", undefined],
+  ["a%3Db%26c%3Dd", "a=b&c=d", undefined],
+  ["hello%F0%9F%8D%95world", "hello\uD83C\uDF55world", undefined],
+  ["-e+", "-e ", undefined],
+  ["-e+1", "-e 1", undefined],
+  ["1e%2B1", "1e+1", undefined],
+])("JsonURL.parseLiteral(%p)", (text, value, strLitValue) => {
   let keyValue = typeof value === "string" ? value : text;
-  runTest(text, value, keyValue);
+  if (strLitValue === undefined) {
+    strLitValue = value;
+  }
+  runTest(text, value, keyValue, strLitValue);
 });
 
 test("JsonURL.parseLiteral('null')", () => {
diff --git a/test/stringify.test.js b/test/stringify.test.js
@@ -33,31 +33,35 @@ test("JsonURL.stringify(undefined)", () => {
 });
 
 test.each([
-  [true, "true"],
-  [false, "false"],
-  [null, "null"],
-  ["true", "'true'"],
-  ["false", "'false'"],
-  ["null", "'null'"],
-  ["()", "'()'"],
-  ["{}", "%7B%7D"],
-  [0, "0"],
-  [1.1, "1.1"],
-  ["a", "a"],
-  ["1", "'1'"],
-  ["2.3", "'2.3'"],
-  ["2e1", "'2e1'"],
-  ["-4", "'-4'"],
-  ["5a", "5a"],
-  ["'1+2'", "%271%2B2'"],
-  ["1e+1", "1e%2B1"],
-  ["a b c", "a+b+c"],
-  ["a,b", "'a,b'"],
-  ["a,b c", "'a,b+c'"],
-  ["Bob & Frank", "Bob+%26+Frank"],
-  ["'hello", "%27hello"],
-])("JsonURL.stringify(%p)", (value, expected) => {
+  [true, "true", "true"],
+  [false, "false", "false"],
+  [null, "null", "null"],
+  ["true", "'true'", "true"],
+  ["false", "'false'", "false"],
+  ["null", "'null'", "null"],
+  ["()", "'()'", "%x28%x29"],
+  ["{}", "%7B%7D", "%7B%7D"],
+  [0, "0", "0"],
+  [1.1, "1.1", "1.1"],
+  ["a", "a", "a"],
+  ["1", "'1'", "1"],
+  ["2.3", "'2.3'", "2.3"],
+  ["2e1", "'2e1'", "2e1"],
+  ["-4", "'-4'", "-4"],
+  ["5a", "5a", "5a"],
+  ["'1+2'", "%271%2B2'", "'1%2B2'"],
+  ["1e+1", "1e%2B1", "1e%2B1"],
+  ["a b c", "a+b+c", "a+b+c"],
+  ["a,b", "'a,b'", "a%2Cb"],
+  ["a,b c", "'a,b+c'", "a%2Cb+c"],
+  ["Bob & Frank", "Bob+%26+Frank", "Bob+%26+Frank"],
+  ["'hello", "%27hello", "'hello"],
+])("JsonURL.stringify(%p)", (value, expected, expectedISL) => {
   expect(JsonURL.stringify(value)).toBe(expected);
+
+  expect(JsonURL.stringify(value, { impliedStringLiterals: true })).toBe(
+    expectedISL
+  );
 });
 
 test.each([
