feat: non-greedy quantifiers (#59)

Author: mdjastrzebski

README.md

@@ -109,14 +109,19 @@ See [API document](./docs/API.md).
 
 ### Quantifiers
 
-| Quantifier                       | Regex Syntax | Description                                       |
-| -------------------------------- | ------------ | ------------------------------------------------- |
-| `zeroOrMore(x)`                  | `x*`         | Zero or more occurence of a pattern               |
-| `oneOrMore(x)`                   | `x+`         | One or more occurence of a pattern                |
-| `optional(x)`                    | `x?`         | Zero or one occurence of a pattern                |
-| `repeat(x, n)`                   | `x{n}`       | Pattern repeats exact number of times             |
-| `repeat(x, { min: n, })`         | `x{n,}`      | Pattern repeats at least given number of times    |
-| `repeat(x, { min: n, max: n2 })` | `x{n1,n2}`   | Pattern repeats between n1 and n2 number of times |
+| Quantifier                                      | Regex Syntax | Description                                                    |
+| ----------------------------------------------- | ------------ | -------------------------------------------------------------- |
+| `zeroOrMore(x)`                                 | `x*`         | Zero or more occurence of a pattern                            |
+| `zeroOrMore(x, { greedy: false })`              | `x*?`        | Zero or more occurence of a pattern (non-greedy)               |
+| `oneOrMore(x)`                                  | `x+`         | One or more occurence of a pattern                             |
+| `oneOrMore(x, { greedy: false })`               | `x+?`        | One or more occurence of a pattern (non-greedy)                |
+| `optional(x)`                                   | `x?`         | Zero or one occurence of a pattern                             |
+| `optional(x, { greedy: false })`                | `x??`        | Zero or one occurence of a pattern (non-greedy)                |
+| `repeat(x, n)`                                  | `x{n}`       | Pattern repeats exact number of times                          |
+| `repeat(x, { min: n, })`                        | `x{n,}`      | Pattern repeats at least given number of times                 |
+| `repeat(x, { min: n, greedy: false })`          | `x{n,}?`     | Pattern repeats at least given number of times (non-greedy)    |
+| `repeat(x, { min: n, max: n2 })`                | `x{n1,n2}`   | Pattern repeats between n1 and n2 number of times              |
+| `repeat(x, { min: n, max: n2, greedy: false })` | `x{n1,n2}?`  | Pattern repeats between n1 and n2 number of times (non-greedy) |
 
 ### Character classes
 

docs/API.md

@@ -81,10 +81,15 @@ Quantifiers in regex define the number of occurrences to match for a pattern.
 ```ts
 function zeroOrMore(
   sequence: RegexSequence,
+  options?: {
+    greedy?: boolean, // default=true
+  }
 ): ZeroOrMore
 ```
 
-Regex syntax: `x*`;
+Regex syntax:
+* `x*` for default greedy behavior (match as many characters as possible)
+* `x*?` for non-greedy behavior (match as few characters as possible)
 
 The `zeroOrMore` quantifier matches zero or more occurrences of a given pattern, allowing a flexible number of repetitions of that element.
 
@@ -93,10 +98,15 @@ The `zeroOrMore` quantifier matches zero or more occurrences of a given pattern,
 ```ts
 function oneOrMore(
   sequence: RegexSequence,
+  options?: {
+    greedy?: boolean, // default=true
+  }
 ): OneOrMore
 ```
 
-Regex syntax: `x+`;
+Regex syntax:
+* `x+` for default greedy behavior (match as many characters as possible)
+* `x+?` for non-greedy behavior (match as few characters as possible)
 
 The `oneOrMore` quantifier matches one or more occurrences of a given pattern, allowing a flexible number of repetitions of that element.
 
@@ -105,10 +115,15 @@ The `oneOrMore` quantifier matches one or more occurrences of a given pattern, a
 ```ts
 function optional(
   sequence: RegexSequence,
+  options?: {
+    greedy?: boolean, // default=true
+  }
 ): Optionally
 ```
 
-Regex syntax: `x?`;
+Regex syntax:
+* `x?` for default greedy behavior (match as many characters as possible)
+* `x??` for non-greedy behavior (match as few characters as possible)
 
 The `optional` quantifier matches zero or one occurrence of a given pattern, making it optional.
 
@@ -117,11 +132,17 @@ The `optional` quantifier matches zero or one occurrence of a given pattern, mak
 ```ts
 function repeat(
   sequence: RegexSequence,
-  count: number | { min: number; max?: number },
+  options: number | { 
+    min: number;
+    max?: number; 
+    greedy?: boolean;  // default=true
+  },
 ): Repeat
 ```
 
-Regex syntax: `x{n}`, `x{min,}`, `x{min, max}`.
+Regex syntax:
+* `x{n}`, `x{min,}`, `x{min, max}` for default greedy behavior (match as many characters as possible)
+* `x{min,}?`, `x{min, max}?` for non-greedy behavior (match as few characters as possible)
 
 The `repeat` quantifier in regex matches either exactly `count` times or between `min` and `max` times. If only `min` is provided, it matches at least `min` times.
 

src/constructs/__tests__/quantifiers.test.tsx

@@ -37,3 +37,25 @@ test('base quantifiers optimize grouping for atoms', () => {
   expect(optional('a')).toEqualRegex(/a?/);
   expect(zeroOrMore('a')).toEqualRegex(/a*/);
 });
+
+test('greedy quantifiers', () => {
+  expect(oneOrMore('a', { greedy: true })).toEqualRegex(/a+/);
+  expect(oneOrMore('ab', { greedy: true })).toEqualRegex(/(?:ab)+/);
+
+  expect(optional('a', { greedy: true })).toEqualRegex(/a?/);
+  expect(optional('ab', { greedy: true })).toEqualRegex(/(?:ab)?/);
+
+  expect(zeroOrMore('a', { greedy: true })).toEqualRegex(/a*/);
+  expect(zeroOrMore('ab', { greedy: true })).toEqualRegex(/(?:ab)*/);
+});
+
+test('non-greedy quantifiers', () => {
+  expect(oneOrMore('a', { greedy: false })).toEqualRegex(/a+?/);
+  expect(oneOrMore('ab', { greedy: false })).toEqualRegex(/(?:ab)+?/);
+
+  expect(optional('a', { greedy: false })).toEqualRegex(/a??/);
+  expect(optional('ab', { greedy: false })).toEqualRegex(/(?:ab)??/);
+
+  expect(zeroOrMore('a', { greedy: false })).toEqualRegex(/a*?/);
+  expect(zeroOrMore('ab', { greedy: false })).toEqualRegex(/(?:ab)*?/);
+});

src/constructs/__tests__/repeat.test.tsx

@@ -22,3 +22,13 @@ test('`repeat` throws on no children', () => {
     `"\`repeat\` should receive at least one element"`,
   );
 });
+
+test('greedy `repeat` quantifier', () => {
+  expect(repeat('a', { min: 1, greedy: true })).toEqualRegex(/a{1,}/);
+  expect(repeat('a', { min: 1, max: 5, greedy: true })).toEqualRegex(/a{1,5}/);
+});
+
+test('non-greedy `repeat` quantifier', () => {
+  expect(repeat('a', { min: 1, greedy: false })).toEqualRegex(/a{1,}?/);
+  expect(repeat('a', { min: 1, max: 5, greedy: false })).toEqualRegex(/a{1,5}?/);
+});

src/constructs/quantifiers.ts

@@ -3,62 +3,71 @@ import type { EncodeResult } from '../encoder/types';
 import { ensureArray } from '../utils/elements';
 import type { RegexConstruct, RegexElement, RegexSequence } from '../types';
 
+export interface QuantifierOptions {
+  greedy?: boolean;
+}
 export interface ZeroOrMore extends RegexConstruct {
   type: 'zeroOrMore';
   children: RegexElement[];
+  options?: QuantifierOptions;
 }
 
 export interface OneOrMore extends RegexConstruct {
   type: 'oneOrMore';
   children: RegexElement[];
+  options?: QuantifierOptions;
 }
 
 export interface Optional extends RegexConstruct {
   type: 'optional';
   children: RegexElement[];
+  options?: QuantifierOptions;
 }
 
-export function zeroOrMore(sequence: RegexSequence): ZeroOrMore {
+export function zeroOrMore(sequence: RegexSequence, options?: QuantifierOptions): ZeroOrMore {
   return {
     type: 'zeroOrMore',
     children: ensureArray(sequence),
+    options,
     encode: encodeZeroOrMore,
   };
 }
 
-export function oneOrMore(sequence: RegexSequence): OneOrMore {
+export function oneOrMore(sequence: RegexSequence, options?: QuantifierOptions): OneOrMore {
   return {
     type: 'oneOrMore',
     children: ensureArray(sequence),
+    options,
     encode: encodeOneOrMore,
   };
 }
 
-export function optional(sequence: RegexSequence): Optional {
+export function optional(sequence: RegexSequence, options?: QuantifierOptions): Optional {
   return {
     type: 'optional',
     children: ensureArray(sequence),
+    options,
     encode: encodeOptional,
   };
 }
 
 function encodeZeroOrMore(this: ZeroOrMore): EncodeResult {
   return {
     precedence: 'sequence',
-    pattern: `${encodeAtom(this.children).pattern}*`,
+    pattern: `${encodeAtom(this.children).pattern}*${this.options?.greedy === false ? '?' : ''}`,
   };
 }
 
 function encodeOneOrMore(this: OneOrMore): EncodeResult {
   return {
     precedence: 'sequence',
-    pattern: `${encodeAtom(this.children).pattern}+`,
+    pattern: `${encodeAtom(this.children).pattern}+${this.options?.greedy === false ? '?' : ''}`,
   };
 }
 
 function encodeOptional(this: Optional): EncodeResult {
   return {
     precedence: 'sequence',
-    pattern: `${encodeAtom(this.children).pattern}?`,
+    pattern: `${encodeAtom(this.children).pattern}?${this.options?.greedy === false ? '?' : ''}`,
   };
 }

src/constructs/repeat.ts

@@ -5,13 +5,13 @@ import type { RegexConstruct, RegexElement, RegexSequence } from '../types';
 
 export interface Repeat extends RegexConstruct {
   type: 'repeat';
-  count: RepeatCount;
   children: RegexElement[];
+  options: RepeatOptions;
 }
 
-export type RepeatCount = number | { min: number; max?: number };
+export type RepeatOptions = number | { min: number; max?: number; greedy?: boolean };
 
-export function repeat(sequence: RegexSequence, count: RepeatCount): Repeat {
+export function repeat(sequence: RegexSequence, options: RepeatOptions): Repeat {
   const children = ensureArray(sequence);
 
   if (children.length === 0) {
@@ -21,23 +21,25 @@ export function repeat(sequence: RegexSequence, count: RepeatCount): Repeat {
   return {
     type: 'repeat',
     children,
-    count: count,
+    options,
     encode: encodeRepeat,
   };
 }
 
 function encodeRepeat(this: Repeat): EncodeResult {
   const atomicNodes = encodeAtom(this.children);
 
-  if (typeof this.count === 'number') {
+  if (typeof this.options === 'number') {
     return {
       precedence: 'sequence',
-      pattern: `${atomicNodes.pattern}{${this.count}}`,
+      pattern: `${atomicNodes.pattern}{${this.options}}`,
     };
   }
 
   return {
     precedence: 'sequence',
-    pattern: `${atomicNodes.pattern}{${this.count.min},${this.count?.max ?? ''}}`,
+    pattern: `${atomicNodes.pattern}{${this.options.min},${this.options?.max ?? ''}}${
+      this.options.greedy === false ? '?' : ''
+    }`,
   };
 }