Merge pull request #217 from samchon/v3.3

Fix #216 - json schema's pattern does use `/`

package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-json",
-  "version": "3.3.1",
+  "version": "3.3.2",
   "description": "Runtime type checkers and 5x faster JSON.stringify() function",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

src/programmers/internal/application_default_string.ts

@@ -27,10 +27,6 @@ export const application_default_string =
             if (schema.maxLength !== undefined)
                 conditions.push(str.length <= schema.maxLength);
             if (schema.pattern !== undefined)
-                conditions.push(
-                    new RegExp(
-                        schema.pattern.substring(1, schema.pattern.length - 1),
-                    ).test(str),
-                );
+                conditions.push(new RegExp(schema.pattern).test(str));
             return conditions.every((c) => c);
         })((str) => str);

src/programmers/internal/application_templates.ts

@@ -25,8 +25,7 @@ export const application_templates = (
         (c) => c.type === "string",
     );
     if (constant) patterns.push(...(constant.values as string[]));
-
-    output.pattern = "/" + patterns.map((str) => `(${str})`).join("|") + "/";
+    output.pattern = patterns.map((str) => `(${str})`).join("|");
 
     // DEFAULT VALUE
     output.default = application_default_string(meta, attribute)(output);

src/programmers/internal/metadata_to_pattern.ts

@@ -0,0 +1,26 @@
+import { Metadata } from "../../metadata/Metadata";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { template_to_pattern } from "./template_to_pattern";
+
+export function metadata_to_pattern(meta: Metadata): string {
+    if (meta.atomics.find((type) => type === "string") !== undefined)
+        return "(.*)";
+
+    const values: string[] = ArrayUtil.flat(
+        meta.constants.map((c) => {
+            if (c.type !== "string") return c.values.map((v) => v.toString());
+            return c.values.map((str) => PatternUtil.escape(str));
+        }),
+    );
+    for (const type of meta.atomics)
+        if (type === "number" || type === "bigint")
+            values.push(PatternUtil.NUMBER);
+        else if (type === "boolean") values.push(PatternUtil.BOOLEAN);
+    for (const childTpl of meta.templates)
+        values.push("(" + template_to_pattern(childTpl) + ")");
+
+    return values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
+}

src/programmers/internal/template_to_pattern.ts

@@ -1,32 +1,9 @@
 import { Metadata } from "../../metadata/Metadata";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { metadata_to_pattern } from "./metadata_to_pattern";
 
 /**
  * @internal
  */
 export const template_to_pattern = (template: Metadata[]) =>
-    template
-        .map((meta) => {
-            if (meta.atomics.find((type) => type === "string") !== undefined)
-                return "(.*)";
-
-            const values: string[] = ArrayUtil.flat(
-                meta.constants.map((c) => {
-                    if (c.type !== "string")
-                        return c.values.map((v) => v.toString());
-                    return c.values.map((str) => escape(str));
-                }),
-            );
-            for (const type of meta.atomics)
-                if (type === "number" || type === "bigint")
-                    values.push("\\d+(\\.\\d+)?");
-                else if (type === "boolean") values.push("true|false");
-            for (const childTpl of meta.templates)
-                values.push("(" + template_to_pattern(childTpl) + ")");
-            return "(" + values.join("|") + ")";
-        })
-        .join("");
-
-const escape = (str: string) =>
-    str.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+    template.map((meta) => metadata_to_pattern(meta)).join("");

src/utils/PatternUtil.ts

@@ -0,0 +1,11 @@
+export namespace PatternUtil {
+    export function escape(str: string): string {
+        return str
+            .replace(/[|\\{}()[\]^$+*?.]/g, "\\$&")
+            .replace(/-/g, "\\x2d");
+    }
+
+    export const NUMBER = "\\d+(\\.\\d+)?";
+    export const BOOLEAN = "true|false";
+    export const STRING = "(.*)";
+}

test/features/application/test_application_tag_default.ts

@@ -94,7 +94,7 @@ export const test_application_tag_format = _test_application(
                                     ],
                                 },
                             ],
-                            pattern: "/((prefix_)(.*))/",
+                            pattern: "(prefix_(.*))",
                             default: "prefix_A",
                         },
                         boolean_and_number_and_string: {
@@ -474,7 +474,7 @@ export const test_application_tag_format = _test_application(
                                     ],
                                 },
                             ],
-                            pattern: "/((prefix_)(.*))/",
+                            pattern: "(prefix_(.*))",
                         },
                         boolean_and_number_and_template: {
                             oneOf: [
@@ -510,7 +510,7 @@ export const test_application_tag_format = _test_application(
                                             ],
                                         },
                                     ],
-                                    pattern: "/((prefix_)(.*))/",
+                                    pattern: "(prefix_(.*))",
                                     default: "prefix_B",
                                 },
                                 {

test/features/application/test_application_template_atomic.ts

@@ -19,27 +19,27 @@ export const test_application_template_atomic = _test_application(
                         prefix: {
                             type: "string",
                             nullable: false,
-                            pattern: "/((prefix_)(.*))/",
+                            pattern: "(prefix_(.*))",
                         },
                         postfix: {
                             type: "string",
                             nullable: false,
-                            pattern: "/((.*)(_postfix))/",
+                            pattern: "((.*)_postfix)",
                         },
                         middle_string: {
                             type: "string",
                             nullable: false,
-                            pattern: "/((the_)(.*)(_value))/",
+                            pattern: "(the_(.*)_value)",
                         },
                         middle_string_empty: {
                             type: "string",
                             nullable: false,
-                            pattern: "/((the_)(.*)(_value))/",
+                            pattern: "(the_(.*)_value)",
                         },
                         middle_numeric: {
                             type: "string",
                             nullable: false,
-                            pattern: "/((the_)(\\d+(\\.\\d+)?)(_value))/",
+                            pattern: "(the_\\d+(\\.\\d+)?_value)",
                         },
                         middle_boolean: {
                             type: "string",
@@ -50,12 +50,12 @@ export const test_application_template_atomic = _test_application(
                             type: "string",
                             nullable: false,
                             pattern:
-                                "/((\\d+(\\.\\d+)?)(\\.)(\\d+(\\.\\d+)?)(\\.)(\\d+(\\.\\d+)?)(\\.)(\\d+(\\.\\d+)?))/",
+                                "(\\d+(\\.\\d+)?\\.\\d+(\\.\\d+)?\\.\\d+(\\.\\d+)?\\.\\d+(\\.\\d+)?)",
                         },
                         email: {
                             type: "string",
                             nullable: false,
-                            pattern: "/((.*)(@)(.*)(\\.)(.*))/",
+                            pattern: "((.*)@(.*)\\.(.*))",
                         },
                     },
                     nullable: false,

test/features/application/test_application_template_union.ts

@@ -19,28 +19,26 @@ export const test_application_template_union = _test_application(
                         prefix: {
                             type: "string",
                             nullable: false,
-                            pattern:
-                                "/((prefix_)(.*))|((prefix_)(\\d+(\\.\\d+)?))/",
+                            pattern: "(prefix_(.*))|(prefix_\\d+(\\.\\d+)?)",
                         },
                         postfix: {
                             type: "string",
                             nullable: false,
-                            pattern:
-                                "/((.*)(_postfix))|((\\d+(\\.\\d+)?)(_postfix))/",
+                            pattern: "((.*)_postfix)|(\\d+(\\.\\d+)?_postfix)",
                         },
                         middle: {
                             type: "string",
                             nullable: false,
                             pattern:
-                                "/((the_)(\\d+(\\.\\d+)?)(_value))|(the_false_value)|(the_true_value)/",
+                                "(the_\\d+(\\.\\d+)?_value)|(the_false_value)|(the_true_value)",
                         },
                         mixed: {
                             oneOf: [
                                 {
                                     type: "string",
                                     nullable: false,
                                     pattern:
-                                        "/((the_)(\\d+(\\.\\d+)?)(_value))|(the_A_value)|(the_B_value)/",
+                                        "(the_\\d+(\\.\\d+)?_value)|(the_A_value)|(the_B_value)",
                                 },
                                 {
                                     type: "number",