Use strict equals in Matcher constraint tests

[Pisces] / string.js

diff --git a/string.js b/string.js
index 100f0bd13bfb0252d1ca846925e9c900cb03b02c..3dc39acade9259c7c5120c28cde20ad398225426 100644 (file)
--- a/string.js
+++ b/string.js
@@ -10,6 +10,7 @@
 import { bind, call, identity, makeCallable } from "./function.js";
 import {
   defineOwnProperties,
+  getOwnPropertyDescriptors,
   getPrototype,
   objectCreate,
   setPrototype,
@@ -17,12 +18,14 @@ import {
 
 export const {
   /**
-   * A RegExp·like object which only matches entire strings.
+   * A RegExp·like object which only matches entire strings, and may
+   * have additional constraints specified.
    *
    * Matchers are callable objects and will return true if they are
    * called with a string that they match, and false otherwise.
    * Matchers will always return false if called with nonstrings,
-   * although other methods like `exec` may still return true.
+   * although other methods like `exec` coerce their arguments and may
+   * still return true.
    */
   Matcher,
 } = (() => {
@@ -47,6 +50,7 @@ export const {
     Object.getOwnPropertyDescriptor(rePrototype, "unicode").get;
 
   const Matcher = class extends identity {
+    #constraint;
     #regExp;
 
     /**
@@ -61,13 +65,20 @@ export const {
      *
      * A name for the matcher may be provided as the second argument.
      *
+     * A callable constraint on acceptable inputs may be provided as a
+     * third argument. If provided, it will be called with three
+     * arguments whenever a match appears successful: first, the string
+     * being matched, second, the match result, and third, the Matcher
+     * object itself. If the return value of this call is falsey, then
+     * the match will be considered a failure.
+     *
      * ☡ If the provided source regular expression uses nongreedy
      * quantifiers, it may not match the whole string even if a match
      * with the whole string is possible. Surround the regular
      * expression with `^(?:` and `)$` if you don’t want nongreedy
      * regular expressions to fail when shorter matches are possible.
      */
-    constructor(source, name = undefined) {
+    constructor(source, name = undefined, constraint = null) {
       super(
         ($) => {
           if (typeof $ !== "string") {
@@ -76,9 +87,12 @@ export const {
           } else {
             // The provided value is a string. Set the `lastIndex` of
             // the regular expression to 0 and see if the first attempt
-            // at a match matches the whole string.
+            // at a match matches the whole string and passes the
+            // provided constraint (if present).
             regExp.lastIndex = 0;
-            return call(reExec, regExp, [$])?.[0] === $;
+            const result = call(reExec, regExp, [$]);
+            return result?.[0] === $ &&
+              (constraint === null || constraint($, result, this));
           }
         },
       );
@@ -100,22 +114,29 @@ export const {
           return new RE(source);
         }
       })();
-      return defineOwnProperties(
-        setPrototype(this, matcherPrototype),
-        {
-          lastIndex: {
-            configurable: false,
-            enumerable: false,
-            value: 0,
-            writable: false,
-          },
-          name: {
-            value: name != null
-              ? `${name}`
-              : `Matcher(${call(reToString, regExp, [])})`,
+      if (constraint !== null && typeof constraint !== "function") {
+        throw new TypeError(
+          "Piscēs: Cannot construct Matcher: Constraint is not callable.",
+        );
+      } else {
+        this.#constraint = constraint;
+        return defineOwnProperties(
+          setPrototype(this, matcherPrototype),
+          {
+            lastIndex: {
+              configurable: false,
+              enumerable: false,
+              value: 0,
+              writable: false,
+            },
+            name: {
+              value: name != null
+                ? `${name}`
+                : `Matcher(${call(reToString, regExp, [])})`,
+            },
           },
-        },
-      );
+        );
+      }
     }
 
     /** Gets whether the dotAll flag is present on this Matcher. */
@@ -129,17 +150,27 @@ export const {
      *
      * Matchers only match if they can match the entire value on the
      * first attempt.
+     *
+     * ☡ The match result returned by this method will be the same as
+     * that passed to the constraint function—and may have been
+     * modified by said function prior to being returned.
      */
     exec($) {
       const regExp = this.#regExp;
+      const constraint = this.#constraint;
       const string = `${$}`;
       regExp.lastIndex = 0;
       const result = call(reExec, regExp, [string]);
-      if (result?.[0] === string) {
-        // The entire string was matched.
+      if (
+        result?.[0] === string &&
+        (constraint === null || constraint(string, result, this))
+      ) {
+        // The entire string was matched and the constraint, if
+        // present, returned a truthy value.
         return result;
       } else {
-        // The entire string was not matched.
+        // The entire string was not matched or the constraint returned
+        // a falsey value.
         return null;
       }
     }
@@ -183,12 +214,25 @@ export const {
       return call(getUnicode, this.#regExp, []);
     }
   };
-  const matcherPrototype = setPrototype(
-    Matcher.prototype,
-    rePrototype,
+
+  const matcherConstructor = defineOwnProperties(
+    class extends RegExp {
+      constructor(...args) {
+        return new Matcher(...args);
+      }
+    },
+    {
+      name: { value: "Matcher" },
+      length: { value: 1 },
+    },
+  );
+  const matcherPrototype = defineOwnProperties(
+    matcherConstructor.prototype,
+    getOwnPropertyDescriptors(Matcher.prototype),
+    { constructor: { value: matcherConstructor } },
   );
 
-  return { Matcher };
+  return { Matcher: matcherConstructor };
 })();
 
 export const {