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,
} = (() => {
Object.getOwnPropertyDescriptor(rePrototype, "unicode").get;
const Matcher = class extends identity {
+ #constraint;
#regExp;
/**
*
* 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 two
+ * arguments whenever a match appears successful: first, the string
+ * being matched, and second, 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") {
} 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] === $;
+ return call(reExec, regExp, [$])?.[0] === $ &&
+ (constraint === null || constraint($, this));
}
},
);
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. */
*/
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, 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;
}
}
import {
assert,
assertEquals,
+ assertSpyCall,
+ assertSpyCalls,
assertStrictEquals,
assertThrows,
describe,
it,
+ spy,
} from "./dev-deps.js";
import {
asciiLowercase,
assert(new Matcher("") instanceof RegExp);
});
+ it("[[Construct]] throws when provided with a noncallable, non·null third argument", () => {
+ assertThrows(() => new Matcher("", undefined, "failure"));
+ });
+
describe("::dotAll", () => {
it("[[Get]] returns true when the dotAll flag is present", () => {
assertStrictEquals(new Matcher(/(?:)/su).dotAll, true);
[...new Matcher(/.(?<wow>(?:.(?=.))*)(.)?/u).exec("success")],
["success", "ucces", "s"],
);
+ assertEquals(
+ [...new Matcher(
+ /.(?<wow>(?:.(?=.))*)(.)?/u,
+ undefined,
+ ($) => $ === "success",
+ ).exec("success")],
+ ["success", "ucces", "s"],
+ );
+ });
+
+ it("[[Call]] calls the constraint if the match succeeds", () => {
+ const constraint = spy((_) => true);
+ const matcher = new Matcher(".*", undefined, constraint);
+ matcher.exec({
+ toString() {
+ return "etaoin";
+ },
+ });
+ assertSpyCalls(constraint, 1);
+ assertSpyCall(constraint, 0, {
+ args: ["etaoin", matcher],
+ self: undefined,
+ });
+ });
+
+ it("[[Call]] does not call the constraint if the match fails", () => {
+ const constraint = spy((_) => true);
+ const matcher = new Matcher("", undefined, constraint);
+ matcher.exec("failure");
+ assertSpyCalls(constraint, 0);
});
it("[[Call]] returns null given a partial match", () => {
- assertEquals(new Matcher("").exec("failure"), null);
+ assertStrictEquals(new Matcher("").exec("failure"), null);
+ });
+
+ it("[[Call]] returns null if the constraint fails", () => {
+ assertStrictEquals(
+ new Matcher(".*", undefined, () => false).exec(""),
+ null,
+ );
});
});
it("[[Call]] returns true for a complete match", () => {
assertStrictEquals(new Matcher("")(""), true);
assertStrictEquals(new Matcher(/.*/su)("success\nyay"), true);
+ assertStrictEquals(
+ new Matcher(/.*/su, undefined, ($) => $ === "success")(
+ "success",
+ ),
+ true,
+ );
+ });
+
+ it("[[Call]] calls the constraint if the match succeeds", () => {
+ const constraint = spy((_) => true);
+ const matcher = new Matcher(".*", undefined, constraint);
+ matcher("etaoin");
+ assertSpyCalls(constraint, 1);
+ assertSpyCall(constraint, 0, {
+ args: ["etaoin", matcher],
+ self: undefined,
+ });
+ });
+
+ it("[[Call]] does not call the constraint if the match fails", () => {
+ const constraint = spy((_) => true);
+ const matcher = new Matcher("", undefined, constraint);
+ matcher("failure");
+ assertSpyCalls(constraint, 0);
});
it("[[Call]] returns false for a partial match", () => {
assertStrictEquals(new Matcher("")("failure"), false);
assertStrictEquals(new Matcher(/.*/u)("failure\nno"), false);
});
+
+ it("[[Call]] returns false if the constraint fails", () => {
+ assertStrictEquals(
+ new Matcher(".*", undefined, () => false)(""),
+ false,
+ );
+ });
});
describe("~lastIndex", () => {
Lady’s Gitweb / Pisces / commitdiff