refactor: self code review

Author: mdjastrzebski

src/constructs/__tests__/capture.test.tsx

@@ -1,4 +1,15 @@
-import { capture, oneOrMore } from '../..';
+import {
+  any,
+  anyOf,
+  buildRegExp,
+  capture,
+  digit,
+  inverted,
+  oneOrMore,
+  reference,
+  word,
+  wordBoundary,
+} from '../..';
 
 test('`capture` pattern', () => {
   expect(capture('a')).toEqualRegex(/(a)/);
@@ -12,3 +23,97 @@ test('`capture` matching', () => {
   expect(['a', capture('b')]).toMatchGroups('ab', ['ab', 'b']);
   expect(['a', capture('b'), capture('c')]).toMatchGroups('abc', ['abc', 'b', 'c']);
 });
+
+test('named `capture` pattern', () => {
+  expect(capture('a', { ref: 'xyz' })).toEqualRegex('(?<xyz>a)');
+  expect(capture('abc', { ref: 'xyz' })).toEqualRegex('(?<xyz>abc)');
+  expect(capture(oneOrMore('abc'), { ref: 'xyz' })).toEqualRegex('(?<xyz>(?:abc)+)');
+  expect(oneOrMore(capture('abc', { ref: 'xyz' }))).toEqualRegex('(?<xyz>abc)+');
+});
+
+test('named `capture` matching', () => {
+  expect(capture('b', { ref: 'x1' })).toMatchGroups('ab', ['b', 'b']);
+  expect(capture('b', { ref: 'x1' })).toMatchNamedGroups('ab', { x1: 'b' });
+
+  expect(['a', capture('b', { ref: 'x1' })]).toMatchGroups('ab', ['ab', 'b']);
+  expect(['a', capture('b', { ref: 'x1' })]).toMatchNamedGroups('ab', { x1: 'b' });
+
+  expect([capture('a'), capture('b', { ref: 'x1' }), capture('c', { ref: 'x2' })]).toMatchGroups(
+    'abc',
+    ['abc', 'a', 'b', 'c'],
+  );
+  expect([
+    capture('a'),
+    capture('b', { ref: 'x1' }),
+    capture('c', { ref: 'x2' }),
+  ]).toMatchNamedGroups('abc', { x1: 'b', x2: 'c' });
+});
+
+// Should have `ref0` as name.
+const firstRef = reference();
+
+test('`reference` pattern', () => {
+  expect([firstRef]).toEqualRegex(/\k<ref0>/);
+  expect([reference('xyz')]).toEqualRegex(/\k<xyz>/);
+  expect([capture(any, { ref: firstRef }), ' ', firstRef]).toEqualRegex('(?<ref0>.) \\k<ref0>');
+
+  const otherRef = reference('r123');
+  expect(['xx', capture(any, { ref: otherRef }), ' ', otherRef, 'xx']).toEqualRegex(
+    'xx(?<r123>.) \\k<r123>xx',
+  );
+});
+
+test('`reference` matching basic case', () => {
+  const ref = reference();
+  expect([capture(word, { ref }), ref]).toMatchString('aa');
+  expect([capture(digit, { ref }), ref]).toMatchString('11');
+
+  expect([capture(any, { ref }), ref]).not.toMatchString('ab');
+
+  expect([capture(digit, { ref }), ref]).not.toMatchString('1a');
+  expect([capture(digit, { ref }), ref]).not.toMatchString('a1');
+});
+
+test('`reference` matching HTML attributes', () => {
+  const quoteRef = reference('quote');
+  const quote = anyOf('"\'');
+  const htmlAttributeRegex = buildRegExp([
+    wordBoundary,
+    capture(oneOrMore(word), { ref: 'name' }),
+    '=',
+    capture(quote, { ref: quoteRef }),
+    capture(oneOrMore(inverted(quote)), { ref: 'value' }),
+    quoteRef,
+  ]);
+
+  expect(htmlAttributeRegex).toMatchNamedGroups('a="b"', {
+    name: 'a',
+    quote: '"',
+    value: 'b',
+  });
+  expect(htmlAttributeRegex).toMatchNamedGroups('aa="bbb"', {
+    name: 'aa',
+    quote: '"',
+    value: 'bbb',
+  });
+  expect(htmlAttributeRegex).toMatchNamedGroups(`aa='bbb'`, {
+    name: 'aa',
+    quote: `'`,
+    value: 'bbb',
+  });
+  expect(htmlAttributeRegex).toMatchNamedGroups('<input type="number" />', {
+    quote: '"',
+    name: 'type',
+    value: 'number',
+  });
+  expect(htmlAttributeRegex).toMatchNamedGroups(`<input type='number' />`, {
+    quote: "'",
+    name: 'type',
+    value: 'number',
+  });
+
+  expect(htmlAttributeRegex).not.toMatchString(`aa="bbb'`);
+  expect(htmlAttributeRegex).not.toMatchString(`aa='bbb"`);
+  expect(htmlAttributeRegex).not.toMatchString(`<input type='number" />`);
+  expect(htmlAttributeRegex).not.toMatchString(`<input type="number' />`);
+});

src/constructs/__tests__/references.test.ts

@@ -13,14 +13,17 @@ export interface CaptureOptions {
   ref?: Reference | string;
 }
 
-/**
- * Reference to a capturing group.
- */
 export interface Reference extends RegexConstruct {
   type: 'reference';
   name: string;
 }
 
+/**
+ * Capturing group.
+ *
+ * Captures the matched text and allows it to be referenced later both in the match results as well
+ * as in the regex itself (@see Reference).
+ */
 export function capture(sequence: RegexSequence, options?: CaptureOptions): Capture {
   return {
     type: 'capture',
@@ -32,6 +35,9 @@ export function capture(sequence: RegexSequence, options?: CaptureOptions): Capt
 
 let counter = 0;
 
+/**
+ * Reference to a capturing group.
+ */
 export function reference(name?: string): Reference {
   return {
     type: 'reference',
@@ -58,7 +64,7 @@ function encodeCapture(this: Capture): EncodeResult {
 
 function encodeReference(this: Reference): EncodeResult {
   return {
-    precedence: 'sequence',
+    precedence: 'atom',
     pattern: `\\k<${this.name}>`,
   };
 }