feat: implemented non-capturing groups

README.md

@@ -77,7 +77,7 @@ Based on the classfication within the [MDN cheatsheet](https://developer.mozilla
 - [x] (x) capturing group
 - [ ] \n back reference
 - [ ] (?<Name>x) named capturing group
-- [ ] (?:x) Non-capturing group
+- [x] (?:x) Non-capturing group
 
 **Quantifiers**
 

assembly/__spec_tests__/generated.spec.ts

@@ -1076,7 +1076,22 @@ it("line: 207 - matches ^(a(b(c)))(d(e(f)))(h(i(j)))(k(l(m)))$ against 'abcdefhi
  expect(match.matches[11]).toBe("abcdefhijklm".substring(10, 12));
  expect(match.matches[12]).toBe("abcdefhijklm".substring(11, 12));
 });
-xit("line: 208 - non capturing groups not supported", () => {});
+it("line: 208 - matches ^(?:a(b(c)))(?:d(e(f)))(?:h(i(j)))(?:k(l(m)))$ against 'abcdefhijklm'", () => {
+ const match = exec(
+ "^(?:a(b(c)))(?:d(e(f)))(?:h(i(j)))(?:k(l(m)))$",
+ "abcdefhijklm",
+ "ms"
+ );
+ expect(match.matches[0]).toBe("abcdefhijklm".substring(0, 12));
+ expect(match.matches[1]).toBe("abcdefhijklm".substring(1, 3));
+ expect(match.matches[2]).toBe("abcdefhijklm".substring(2, 3));
+ expect(match.matches[3]).toBe("abcdefhijklm".substring(4, 6));
+ expect(match.matches[4]).toBe("abcdefhijklm".substring(5, 6));
+ expect(match.matches[5]).toBe("abcdefhijklm".substring(7, 9));
+ expect(match.matches[6]).toBe("abcdefhijklm".substring(8, 9));
+ expect(match.matches[7]).toBe("abcdefhijklm".substring(10, 12));
+ expect(match.matches[8]).toBe("abcdefhijklm".substring(11, 12));
+});
 xit("line: 209 - back references are not supported", () => {});
 it("line: 210 - matches ^[.^$|()*+?{,}]+ against '.^$(*+)|{?,?}'", () => {
  const match = exec("^[.^$|()*+?{,}]+", ".^$(*+)|{?,?}", "ms");
@@ -1305,10 +1320,10 @@ it("line: 266 - matches ^12.34 against '12\r34'", () => {
 });
 xit("line: 267 - lookaheads not supported", () => {});
 xit("line: 268 - lookaheads not supported", () => {});
-xit("line: 269 - non capturing groups not supported", () => {});
-xit("line: 270 - non capturing groups not supported", () => {});
-xit("line: 271 - non capturing groups not supported", () => {});
-xit("line: 272 - non capturing groups not supported", () => {});
+xit("line: 269 - lookaheads not supported", () => {});
+xit("line: 270 - lookaheads not supported", () => {});
+xit("line: 271 - lookaheads not supported", () => {});
+xit("line: 272 - lookaheads not supported", () => {});
 xit("line: 273 - lookaheads not supported", () => {});
 xit("line: 274 - lookaheads not supported", () => {});
 xit("line: 281 - test regex contains syntax not supported in JS", () => {});
@@ -1564,8 +1579,14 @@ it("line: 1162 - matches \\Aabc\\Z against 'qqq\nabc\nzzz'", () => {
 });
 xit("line: 1163 - JS does not support the A Z syntax for start and end of string", () => {});
 xit("line: 1164 - JS does not support the A Z syntax for start and end of string", () => {});
-xit("line: 1165 - non capturing groups not supported", () => {});
-xit("line: 1166 - non capturing groups not supported", () => {});
+it("line: 1165 - matches (?:b)|(?::+) against 'b::c'", () => {
+ const match = exec("(?:b)|(?::+)", "b::c", "ms");
+ expect(match.matches[0]).toBe("b::c".substring(0, 1));
+});
+it("line: 1166 - matches (?:b)|(?::+) against 'c::b'", () => {
+ const match = exec("(?:b)|(?::+)", "c::b", "ms");
+ expect(match.matches[0]).toBe("c::b".substring(1, 3));
+});
 it("line: 1167 - matches [-az]+ against 'az-'", () => {
  const match = exec("[-az]+", "az-", "ms");
  expect(match.matches[0]).toBe("az-".substring(0, 3));
@@ -1954,9 +1975,21 @@ it("line: 1311 - matches \\d\\d\\/\\d\\d\\/\\d\\d\\d\\d against '01/01/2000'", (
  const match = exec("\\d\\d\\/\\d\\d\\/\\d\\d\\d\\d", "01/01/2000", "ms");
  expect(match.matches[0]).toBe("01/01/2000".substring(0, 10));
 });
-xit("line: 1312 - non capturing groups not supported", () => {});
-xit("line: 1313 - non capturing groups not supported", () => {});
-xit("line: 1314 - non capturing groups not supported", () => {});
+it("line: 1312 - matches word (?:[a-zA-Z0-9]+ ){0,10}otherword against 'word cat dog elephant mussel cow horse canary baboon snake shark otherword'", () => {
+ const match = exec(
+ "word (?:[a-zA-Z0-9]+ ){0,10}otherword",
+ "word cat dog elephant mussel cow horse canary baboon snake shark otherword",
+ "ms"
+ );
+ expect(match.matches[0]).toBe(
+ "word cat dog elephant mussel cow horse canary baboon snake shark otherword".substring(
+ 0,
+ 74
+ )
+ );
+});
+xit("line: 1313 - peformance issue", () => {});
+xit("line: 1314 - peformance issue", () => {});
 it("line: 1315 - matches ^(a){0,0} against 'bcd'", () => {
  const match = exec("^(a){0,0}", "bcd", "ms");
  expect(match.matches[0]).toBe("bcd".substring(0, 0));

assembly/__tests__/capture-group.spec.ts

@@ -45,3 +45,9 @@ it("range repitition capture groups should return the last match", () => {
  expect(match.matches[0]).toBe("ac");
  expect(match.matches[1]).toBe("c");
 });
+
+it("non-capturing groups should not capture", () => {
+ const match = exec("(?:foo)bar(baz)", "foobarbaz");
+ expect(match.matches[0]).toBe("foobarbaz");
+ expect(match.matches[1]).toBe("baz");
+});

assembly/char.ts

@@ -16,6 +16,7 @@ export const enum Char {
  Dot = 0x2e, // "."
  Zero = 0x30,
  Nine = 0x39,
+ Colon = 0x3a,
  Question = 0x3f, // "?"
  A = 0x41,
  D = 0x44,

assembly/nfa/nfa.ts

@@ -42,7 +42,7 @@ export class GroupStartMarkerState extends State {
  // captures from the path through the NFA that reaches the end are flagged
  flagged: bool = false;
 
- constructor(next: State, public groupId: i32) {
+ constructor(next: State, public capturing: bool, public groupId: i32) {
  super();
  this.transitions.push(next);
  }
@@ -60,10 +60,12 @@ export class GroupEndMarkerState extends State {
  }
 
  matches(input: string, position: u32): MatchResult {
- this.startMarker.capture = input.substring(
- this.startMarker.location,
- position
- );
+ if (this.startMarker.capturing) {
+ this.startMarker.capture = input.substring(
+ this.startMarker.location,
+ position
+ );
+ }
  return MatchResult.Ignore;
  }
 }
@@ -164,10 +166,10 @@ function oneOrMore(nfa: Automata, greedy: bool): Automata {
  return new Automata(start, end);
 }
 
-function group(nfa: Automata, id: i32): Automata {
+function group(nfa: Automata, capturing: bool, id: i32): Automata {
  // groups are implemented by wrapping the automata with
  // a pair of markers that record matches
- const startMarker = new GroupStartMarkerState(nfa.start, id);
+ const startMarker = new GroupStartMarkerState(nfa.start, capturing, id);
  const end = new State();
  const endMarker = new GroupEndMarkerState(end, startMarker);
  nfa.end.transitions.push(endMarker);
@@ -238,7 +240,11 @@ class AutomataFactor {
  );
  case NodeType.Group: {
  const node = expression as GroupNode;
- return group(this.automataForNode(node.expression), node.id);
+ return group(
+ this.automataForNode(node.expression),
+ node.capturing,
+ node.id
+ );
  }
  case NodeType.Assertion:
  return Automata.fromEpsilon();

assembly/parser/node.ts

@@ -209,7 +209,11 @@ export class AlternationNode extends Node {
 let _id = 0;
 
 export class GroupNode extends Node {
- constructor(public expression: Node, public id: i32 = -1) {
+ constructor(
+ public expression: Node,
+ public capturing: bool,
+ public id: i32 = -1
+ ) {
  super(NodeType.Group);
  if (id == -1) {
  this.id = _id++;
@@ -221,7 +225,7 @@ export class GroupNode extends Node {
  }
 
  clone(): Node {
- return new GroupNode(this.expression.clone(), this.id);
+ return new GroupNode(this.expression.clone(), this.capturing, this.id);
  }
 
  replace(node: Node, replacement: Node): void {

assembly/parser/parser.ts

@@ -204,6 +204,18 @@ export class Parser {
  return true;
  }
 
+ private isCapturing(): bool {
+ if (
+ this.iterator.current == Char.Question &&
+ this.iterator.lookahead(1) == Char.Colon
+ ) {
+ this.eatToken(Char.Question);
+ this.eatToken(Char.Colon);
+ return false;
+ }
+ return true;
+ }
+
  // parses a sequence of chars
  private parseSequence(): Node {
  let nodes = new Array<Node>();
@@ -218,7 +230,8 @@ export class Parser {
  // @ts-ignore
  } else if (token == Char.LeftParenthesis) {
  this.eatToken(Char.LeftParenthesis);
- nodes.push(new GroupNode(this.parseSequence()));
+ const capturing = this.isCapturing();
+ nodes.push(new GroupNode(this.parseSequence(), capturing));
  this.eatToken(Char.RightParenthesis);
  // @ts-ignore
  } else if (token == Char.LeftCurlyBrace) {

assembly/regexp.ts

@@ -89,9 +89,9 @@ export class Flags {
 
 // capture groups are implemented as GroupStart / GroupEnd states that record (capture)
 // the value of the current state of the string being matched.
-// Repeated capture groups, via rage repetitions (e.g. {2,3}) share the same 'id'. The
+// Repeated capture groups, via range repetitions (e.g. {2,3}) share the same 'id'. The
 // returned regex should only return the value of the final repetition.
-function filterCaptures(groupMarkers: GroupStartMarkerState[]): string[] {
+function lastCapturesForGroup(groupMarkers: GroupStartMarkerState[]): string[] {
  if (!groupMarkers.length) {
  return [];
  }
@@ -139,7 +139,10 @@ export class RegExp {
  gm = new Array<GroupStartMarkerState>();
  nfaWalker(this.nfa.start, (state) => {
  if (state instanceof GroupStartMarkerState) {
- gm.push(state as GroupStartMarkerState);
+ const startMarker = state as GroupStartMarkerState;
+ if (startMarker.capturing) {
+ gm.push(state as GroupStartMarkerState);
+ }
  }
  });
  this.groupMarkers = gm;
@@ -181,7 +184,7 @@ export class RegExp {
  });
 
  const match = new Match(
- [matchStr!].concat(filterCaptures(groupMarkers)),
+ [matchStr!].concat(lastCapturesForGroup(groupMarkers)),
  matchIndex,
  str
  );

spec/test-generator.js

@@ -22,6 +22,7 @@ const knownIssues = {
  ...range(141, 143),
  1288,
  ],
+ "peformance issue": [1313, 1314],
 
  /* -------- issues with the tests ------------ */
  "test appears to be incorrect?": [203, 204],
@@ -108,11 +109,6 @@ lines.forEach((line, index) => {
  return;
  }
 
- if (["(?:"].some((f) => regex.includes(f))) {
- testCase += `xit("line: ${index} - non capturing groups not supported", () => {});`;
- return;
- }
-
  if (["(?!", "(?="].some((f) => regex.includes(f))) {
  testCase += `xit("line: ${index} - lookaheads not supported", () => {});`;
  return;

ts/index.ts

@@ -5,13 +5,8 @@ globalAny.log = console.log;
 
 import { RegExp } from "../assembly/regexp";
 
-const regexObj = new RegExp("abc$", "m");
-let match = regexObj.exec("abc\n");
+const regexObj = new RegExp("word (?:[a-zA-Z0-9]+ ){0,300}otherword", "");
+let match = regexObj.exec(
+ "word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope"
+);
 console.log(JSON.stringify(match, null, 2));
-// match = regexObj.exec("f1\nbar\nbaz\nf2");
-// console.log(JSON.stringify(match, null, 2));
-
-// const regex = new RegExp("^f\\d{1}$", "gm");
-
-// let match = regex.exec("f1\nbar\nbaz\nf2");
-// expect(match!.matches[0]).toBe("f1");