chore: character class <=> character set

fixes #9

Author: ColinEberhardt

README.md

@@ -33,7 +33,7 @@ The next phase of development will focussed on more extensive testing and perfor
 
 Based on the classfication within the [MDN cheatsheet](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Cheatsheet)
 
-**Character classes**
+**Character sets**
 
 - [x] .
 - [x] \d

assembly/__tests__/character-classes.spec.ts

@@ -1,55 +1,54 @@
-import { RegExp } from "..";
-import { expectMatch, expectNotMatch, exec } from "./utils";
+import { expectMatch, expectNotMatch } from "./utils";
 
-it("dot", () => {
-  expectMatch(".", [" ", "B", "|", "9"]);
-  expectNotMatch(".", ["", "\n"]);
+it("throws an error if no closing bracket is found", () => {
+  // expect(() => new RegExp("[abce")).toThrow();
 });
 
-it("digit", () => {
-  expectMatch("\\d", ["0", "9"]);
-  expectNotMatch("\\d", ["", "b"]);
+it("matches discrete characters", () => {
+  expectMatch("[abce]", ["a", "b", "c", "e"]);
+  expectNotMatch("[abce]", ["", "f", "h"]);
 });
 
-it("non-digit", () => {
-  expectNotMatch("\\D", ["0", "9", ""]);
-  expectMatch("\\D", ["b", "|"]);
+it("matches character ranges", () => {
+  expectMatch("[a-c]", ["a", "b", "c"]);
+  expectNotMatch("[a-c]", ["d", "e", ""]);
+  expectMatch("[K-M]", ["K", "L", "M"]);
+  expectNotMatch("[K-M]", ["9", "J"]);
+  expectMatch("[0-9]", ["0", "9"]);
+  expectNotMatch("[0-9]", ["a", "A"]);
 });
 
-it("word", () => {
-  expectMatch("\\w", ["A", "a", "Z", "z", "0", "9", "_"]);
-  expectNotMatch("\\w", ["", "$"]);
+it("matches multiple ranges", () => {
+  expectMatch("[a-ce-f]", ["a", "b", "c", "e", "f"]);
+  expectNotMatch("[a-ce-f]", ["d"]);
 });
 
-it("not word", () => {
-  expectNotMatch("\\W", ["A", "a", "Z", "z", "0", "9", "_", ""]);
-  expectMatch("\\W", ["&", "$"]);
+it("supports closing brackets", () => {
+  expectMatch("[]a]", ["]", "a"]);
 });
 
-it("whitespace", () => {
-  expectMatch("\\s", ["\f", "\n", "\r", "\t", "\v"]);
-  expectNotMatch("\\s", ["", "a", "0"]);
+it("supports negated sets", () => {
+  expectNotMatch("[^a-c]", ["a", "b", "c"]);
+  expectMatch("[^a-c]", ["d", "e"]);
+  expectNotMatch("[^a-ce-f]", ["a", "b", "c", "e", "f"]);
+  expectMatch("[^a-ce-f]", ["d"]);
 });
 
-it("not whitespace", () => {
-  expectNotMatch("\\S", ["", "\f", "\n", "\r", "\t", "\v"]);
-  expectMatch("\\S", ["a", "0"]);
+it("treats - as a literal", () => {
+  expectMatch("[-abc]", ["-", "a", "b", "c"]);
+  expectMatch("[abc-]", ["-", "a", "b", "c"]);
 });
 
-it("tab, cr, lf, vt, ff", () => {
-  expectMatch("\\t", ["\t"]);
-  expectMatch("\\r", ["\r"]);
-  expectMatch("\\n", ["\n"]);
-  expectMatch("\\v", ["\v"]);
-  expectMatch("\\f", ["\f"]);
-  expectNotMatch("\\t", ["a", " ", ""]);
+it("treats - as a literal in negated sets", () => {
+  expectNotMatch("[^-abc]", ["-", "a", "b", "c"]);
+  expectMatch("[^-abc]", ["1", "A"]);
 });
 
-it("escaped dot", () => {
-  expectMatch("\\.", ["."]);
-  expectNotMatch("\\.", ["", "a"]);
-});
-
-it("unrecognised character classes are treated as characters", () => {
-  expectMatch("\\g\\m", ["gm"]);
+it("supports case insensitive matching", () => {
+  // simple ranges
+  expectMatch("[a-c]", ["A", "C", "a", "c"], "i");
+  expectNotMatch("[a-c]", ["D", "d"], "i");
+  // complex
+  expectMatch("[W-c]", ["W", "w", "C", "c"], "i");
+  expectNotMatch("[W-c]", ["V", "v", "D", "d"], "i");
 });

assembly/__tests__/character-sets.spec.ts

@@ -1,54 +1,55 @@
-import { expectMatch, expectNotMatch } from "./utils";
+import { RegExp } from "..";
+import { expectMatch, expectNotMatch, exec } from "./utils";
 
-it("throws an error if no closing bracket is found", () => {
-  // expect(() => new RegExp("[abce")).toThrow();
+it("dot", () => {
+  expectMatch(".", [" ", "B", "|", "9"]);
+  expectNotMatch(".", ["", "\n"]);
 });
 
-it("matches discrete characters", () => {
-  expectMatch("[abce]", ["a", "b", "c", "e"]);
-  expectNotMatch("[abce]", ["", "f", "h"]);
+it("digit", () => {
+  expectMatch("\\d", ["0", "9"]);
+  expectNotMatch("\\d", ["", "b"]);
 });
 
-it("matches character ranges", () => {
-  expectMatch("[a-c]", ["a", "b", "c"]);
-  expectNotMatch("[a-c]", ["d", "e", ""]);
-  expectMatch("[K-M]", ["K", "L", "M"]);
-  expectNotMatch("[K-M]", ["9", "J"]);
-  expectMatch("[0-9]", ["0", "9"]);
-  expectNotMatch("[0-9]", ["a", "A"]);
+it("non-digit", () => {
+  expectNotMatch("\\D", ["0", "9", ""]);
+  expectMatch("\\D", ["b", "|"]);
 });
 
-it("matches multiple ranges", () => {
-  expectMatch("[a-ce-f]", ["a", "b", "c", "e", "f"]);
-  expectNotMatch("[a-ce-f]", ["d"]);
+it("word", () => {
+  expectMatch("\\w", ["A", "a", "Z", "z", "0", "9", "_"]);
+  expectNotMatch("\\w", ["", "$"]);
 });
 
-it("supports closing brackets", () => {
-  expectMatch("[]a]", ["]", "a"]);
+it("not word", () => {
+  expectNotMatch("\\W", ["A", "a", "Z", "z", "0", "9", "_", ""]);
+  expectMatch("\\W", ["&", "$"]);
 });
 
-it("supports negated sets", () => {
-  expectNotMatch("[^a-c]", ["a", "b", "c"]);
-  expectMatch("[^a-c]", ["d", "e"]);
-  expectNotMatch("[^a-ce-f]", ["a", "b", "c", "e", "f"]);
-  expectMatch("[^a-ce-f]", ["d"]);
+it("whitespace", () => {
+  expectMatch("\\s", ["\f", "\n", "\r", "\t", "\v"]);
+  expectNotMatch("\\s", ["", "a", "0"]);
 });
 
-it("treats - as a literal", () => {
-  expectMatch("[-abc]", ["-", "a", "b", "c"]);
-  expectMatch("[abc-]", ["-", "a", "b", "c"]);
+it("not whitespace", () => {
+  expectNotMatch("\\S", ["", "\f", "\n", "\r", "\t", "\v"]);
+  expectMatch("\\S", ["a", "0"]);
 });
 
-it("treats - as a literal in negated sets", () => {
-  expectNotMatch("[^-abc]", ["-", "a", "b", "c"]);
-  expectMatch("[^-abc]", ["1", "A"]);
+it("tab, cr, lf, vt, ff", () => {
+  expectMatch("\\t", ["\t"]);
+  expectMatch("\\r", ["\r"]);
+  expectMatch("\\n", ["\n"]);
+  expectMatch("\\v", ["\v"]);
+  expectMatch("\\f", ["\f"]);
+  expectNotMatch("\\t", ["a", " ", ""]);
 });
 
-it("supports case insensitive matching", () => {
-  // simple ranges
-  expectMatch("[a-c]", ["A", "C", "a", "c"], "i");
-  expectNotMatch("[a-c]", ["D", "d"], "i");
-  // complex
-  expectMatch("[W-c]", ["W", "w", "C", "c"], "i");
-  expectNotMatch("[W-c]", ["V", "v", "D", "d"], "i");
+it("escaped dot", () => {
+  expectMatch("\\.", ["."]);
+  expectNotMatch("\\.", ["", "a"]);
+});
+
+it("unrecognised character classes are treated as characters", () => {
+  expectMatch("\\g\\m", ["gm"]);
 });

assembly/nfa/matcher.ts

@@ -2,8 +2,8 @@ import { isDigit, isAlpha, isWhitespace, Char } from "../char";
 
 import {
   CharacterNode,
-  CharacterSetNode,
   CharacterClassNode,
+  CharacterSetNode,
   CharacterRangeNode,
   NodeType,
 } from "../parser/node";
@@ -13,8 +13,8 @@ import { Range } from "../util";
 const enum MatcherType {
   Character,
   CharacterRange,
-  CharacterClass,
   CharacterSet,
+  CharacterClass,
 }
 
 let _flags: Flags;
@@ -27,10 +27,10 @@ export class Matcher {
   }
 
   static fromCharacterClassNode(
-    node: CharacterClassNode,
+    node: CharacterSetNode,
     flags: Flags
-  ): CharacterClassMatcher {
-    return new CharacterClassMatcher(node.charClass, flags.dotAll);
+  ): CharacterSetMatcher {
+    return new CharacterSetMatcher(node.charClass, flags.dotAll);
   }
 
   static fromCharacterRangeNode(
@@ -44,9 +44,9 @@ export class Matcher {
   }
 
   static fromCharacterSetNode(
-    node: CharacterSetNode,
+    node: CharacterClassNode,
     flags: Flags
-  ): CharacterSetMatcher {
+  ): CharacterClassMatcher {
     _flags = flags;
     const matchers = node.expressions.map<Matcher>((exp) => {
       switch (exp.type) {
@@ -57,16 +57,16 @@ export class Matcher {
           );
         case NodeType.Character:
           return Matcher.fromCharacterNode(exp as CharacterNode, _flags);
-        case NodeType.CharacterClass:
+        case NodeType.CharacterSet:
           return Matcher.fromCharacterClassNode(
-            exp as CharacterClassNode,
+            exp as CharacterSetNode,
             _flags
           );
         default:
           throw new Error("unsupported node type within character set");
       }
     });
-    return new CharacterSetMatcher(matchers, node.negated);
+    return new CharacterClassMatcher(matchers, node.negated);
   }
 
   static fromCharacterNode(
@@ -126,9 +126,9 @@ export class CharacterRangeMatcher extends Matcher {
   }
 }
 
-export class CharacterClassMatcher extends Matcher {
+export class CharacterSetMatcher extends Matcher {
   constructor(public charClass: Char, private dotAll: bool) {
-    super(MatcherType.CharacterClass);
+    super(MatcherType.CharacterSet);
   }
 
   matches(code: u32): bool {
@@ -171,9 +171,9 @@ export class CharacterClassMatcher extends Matcher {
   }
 }
 
-export class CharacterSetMatcher extends Matcher {
+export class CharacterClassMatcher extends Matcher {
   constructor(public matchers: Matcher[], public negated: bool) {
-    super(MatcherType.CharacterSet);
+    super(MatcherType.CharacterClass);
   }
 
   matches(code: u32): bool {
@@ -189,13 +189,13 @@ export class CharacterSetMatcher extends Matcher {
           match = (matcher as CharacterRangeMatcher).matches(code);
           break;
 
-        case MatcherType.CharacterClass:
-          match = (matcher as CharacterClassMatcher).matches(code);
-          break;
-
         case MatcherType.CharacterSet:
           match = (matcher as CharacterSetMatcher).matches(code);
           break;
+
+        case MatcherType.CharacterClass:
+          match = (matcher as CharacterClassMatcher).matches(code);
+          break;
       }
       if (match) break;
     }

assembly/nfa/nfa.ts

@@ -5,8 +5,8 @@ import {
   ConcatenationNode,
   RepetitionNode,
   AlternationNode,
-  CharacterSetNode,
   CharacterClassNode,
+  CharacterSetNode,
   GroupNode,
   NodeType,
 } from "../parser/node";
@@ -222,17 +222,17 @@ class AutomataFactor {
           this.automataForNode(node.right)
         );
       }
-      case NodeType.CharacterSet:
+      case NodeType.CharacterClass:
         return Automata.fromMatcher(
           Matcher.fromCharacterSetNode(
-            expression as CharacterSetNode,
+            expression as CharacterClassNode,
             this.flags
           )
         );
-      case NodeType.CharacterClass:
+      case NodeType.CharacterSet:
         return Automata.fromMatcher(
           Matcher.fromCharacterClassNode(
-            expression as CharacterClassNode,
+            expression as CharacterSetNode,
             this.flags
           )
         );

assembly/parser/node.ts

@@ -7,8 +7,8 @@ export const enum NodeType {
   Alternation,
   Concatenation,
   Character,
-  CharacterSet,
   CharacterClass,
+  CharacterSet,
   CharacterRange,
   Repetition,
   RangeRepetition,
@@ -72,13 +72,13 @@ export class ConcatenationNode extends Node {
   }
 }
 
-export class CharacterSetNode extends Node {
+export class CharacterClassNode extends Node {
   constructor(public expressions: Node[], public negated: bool) {
-    super(NodeType.CharacterSet);
+    super(NodeType.CharacterClass);
   }
 
   clone(): Node {
-    return new CharacterSetNode(
+    return new CharacterClassNode(
       this.expressions.slice(0).map<Node>((s) => s.clone()),
       this.negated
     );
@@ -126,13 +126,13 @@ export class AssertionNode extends Node {
   }
 }
 
-export class CharacterClassNode extends Node {
+export class CharacterSetNode extends Node {
   constructor(public charClass: Char) {
-    super(NodeType.CharacterClass);
+    super(NodeType.CharacterSet);
   }
 
   clone(): Node {
-    return new CharacterClassNode(this.charClass);
+    return new CharacterSetNode(this.charClass);
   }
 }