commit 7c5f3cb81c74bd3792cb406426a946548de22f0b · kitten.sh/reghex

+5 -6

src/codegen.js

···

       2
       2
        
       const _match = 'match';

     

       3
       3
        
       const _node = 'node';

     

       4
       4
        
       

     

       5
       5
       -
       export function js(/* arguments */) {

     

       5
       5
       +
       function js(/* arguments */) {

     

       6
       6
        
         let body = arguments[0][0];

     

       7
       7
        
         for (let i = 1; i < arguments.length; i++)

     

       8
       8
       -
           body = body + arguments[i] + (arguments[0][i] || '');

     

       8
       8
       +
           body = body + arguments[i] + arguments[0][i];

     

       9
       9
        
         return body.trim();

     

       10
       10
        
       }

     

       11
       11
        
       

     
···

       144
       144
        
         }

     

       145
       145
        
       

     

       146
       146
        
         let child;

     

       147
       147
       -
         if (ast.quantifier && !ast.quantifier.singular && ast.quantifier.required) {

     

       147
       147
       +
         if (ast.quantifier === 'repeating') {

     

       148
       148
        
           child = astRepeating(ast, depth, opts);

     

       149
       149
       -
         } else if (ast.quantifier && !ast.quantifier.singular)

     

       149
       149
       +
         } else if (ast.quantifier === 'multiple')

     

       150
       150
        
           child = astMultiple(ast, depth, opts);

     

       151
       151
       -
         else if (ast.quantifier && !ast.quantifier.required)

     

       152
       152
       -
           child = astOptional(ast, depth, opts);

     

       151
       151
       +
         else if (ast.quantifier === 'optional') child = astOptional(ast, depth, opts);

     

       153
       152
        
         else child = astChild(ast, depth, opts);

     

       154
       153
        
       

     

       155
       154
        
         if (ast.lookahead === 'negative') {

+1 -2

src/core.js

···

       1
       1
       -
       import { js, astRoot } from './codegen';

     

       1
       1
       +
       import { astRoot } from './codegen';

     

       2
       2
        
       import { parse as parseDSL } from './parser';

     

       3
       3
        
       

     

       4
       4
        
       const isStickySupported = typeof /./g.sticky === 'boolean';

     

       5
       5
        
       

     

       6
       6
        
       export const _pattern = (input) => {

     

       7
       7
        
         if (typeof input === 'function') return input;

     

       8
       8
       -
       

     

       9
       8
        
         const source = typeof input !== 'string' ? input.source : input;

     

       10
       9
        
         return isStickySupported

     

       11
       10
        
           ? new RegExp(source, 'y')

+3 -10

src/parser.js

···

       86
       86
        
               (lastMatch =

     

       87
       87
        
                 currentSequence.sequence[currentSequence.sequence.length - 1])

     

       88
       88
        
             ) {

     

       89
       89
       -
               if (lastMatch.type === 'group' && lastMatch.lookahead) {

     

       90
       90
       -
                 throw new SyntaxError('Unexpected quantifier on lookahead group');

     

       91
       91
       -
               }

     

       92
       92
       -
       

     

       93
       93
       -
               lastMatch.quantifier = {

     

       94
       94
       -
                 type: 'quantifier',

     

       95
       95
       -
                 required: char === '+',

     

       96
       96
       -
                 singular: char === '?',

     

       97
       97
       -
               };

     

       98
       98
       -
       

     

       89
       89
       +
               lastMatch.quantifier = 'optional';

     

       90
       90
       +
               if (char === '+') lastMatch.quantifier = 'repeating';

     

       91
       91
       +
               if (char === '*') lastMatch.quantifier = 'multiple';

     

       99
       92
        
               continue;

     

       100
       93
        
             }

     

       101
       94

+5 -31

src/parser.test.js

···

       21
       21
        
       

     

       22
       22
        
         ast = parseTag`${1}?`;

     

       23
       23
        
         expect(ast).toHaveProperty('sequence.0.type', 'expression');

     

       24
       24
       -
         expect(ast).toHaveProperty('sequence.0.quantifier', {

     

       25
       25
       -
           type: 'quantifier',

     

       26
       26
       -
           required: false,

     

       27
       27
       -
           singular: true,

     

       28
       28
       -
         });

     

       24
       24
       +
         expect(ast).toHaveProperty('sequence.0.quantifier', 'optional');

     

       29
       25
        
       

     

       30
       26
        
         ast = parseTag`${1}+`;

     

       31
       27
        
         expect(ast).toHaveProperty('sequence.0.type', 'expression');

     

       32
       32
       -
         expect(ast).toHaveProperty('sequence.0.quantifier', {

     

       33
       33
       -
           type: 'quantifier',

     

       34
       34
       -
           required: true,

     

       35
       35
       -
           singular: false,

     

       36
       36
       -
         });

     

       28
       28
       +
         expect(ast).toHaveProperty('sequence.0.quantifier', 'repeating');

     

       37
       29
        
       

     

       38
       30
        
         ast = parseTag`${1}*`;

     

       39
       31
        
         expect(ast).toHaveProperty('sequence.0.type', 'expression');

     

       40
       40
       -
         expect(ast).toHaveProperty('sequence.0.quantifier', {

     

       41
       41
       -
           type: 'quantifier',

     

       42
       42
       -
           required: false,

     

       43
       43
       -
           singular: false,

     

       44
       44
       -
         });

     

       32
       32
       +
         expect(ast).toHaveProperty('sequence.0.quantifier', 'multiple');

     

       45
       33
        
       });

     

       46
       34
        
       

     

       47
       35
        
       it('supports top-level alternations', () => {

     
···

       55
       43
        
         expect(ast).toHaveProperty('alternation.sequence.0.expression', 2);

     

       56
       44
        
       

     

       57
       45
        
         ast = parseTag`${1}? | ${2}?`;

     

       58
       58
       -
         expect(ast).toHaveProperty('sequence.0.quantifier.type', 'quantifier');

     

       59
       59
       -
         expect(ast).toHaveProperty(

     

       60
       60
       -
           'alternation.sequence.0.quantifier.type',

     

       61
       61
       -
           'quantifier'

     

       62
       62
       -
         );

     

       46
       46
       +
         expect(ast).toHaveProperty('sequence.0.quantifier', 'optional');

     

       63
       47
        
       });

     

       64
       48
        
       

     

       65
       49
        
       it('supports groups with quantifiers', () => {

     
···

       75
       59
        
         ast = parseTag`(${1} ${2}?)?`;

     

       76
       60
        
         expect(ast).toHaveProperty('sequence.length', 1);

     

       77
       61
        
         expect(ast).toHaveProperty('sequence.0.type', 'group');

     

       78
       78
       -
         expect(ast).toHaveProperty('sequence.0.quantifier.type', 'quantifier');

     

       62
       62
       +
         expect(ast).toHaveProperty('sequence.0.quantifier', 'optional');

     

       79
       63
        
         expect(ast).toHaveProperty('sequence.0.sequence.sequence.0.quantifier', null);

     

       80
       80
       -
         expect(ast).toHaveProperty(

     

       81
       81
       -
           'sequence.0.sequence.sequence.1.quantifier.type',

     

       82
       82
       -
           'quantifier'

     

       83
       83
       -
         );

     

       84
       64
        
       });

     

       85
       65
        
       

     

       86
       66
        
       it('supports non-capturing groups', () => {

     
···

       108
       88
        
         expect(ast).toHaveProperty('sequence.0.capturing', false);

     

       109
       89
        
         expect(ast).toHaveProperty('sequence.0.lookahead', 'negative');

     

       110
       90
        
         expect(ast).toHaveProperty('sequence.0.sequence.sequence.length', 1);

     

       111
       111
       -
       });

     

       112
       112
       -
       

     

       113
       113
       -
       it('throws when a quantifier is combined with a lookahead', () => {

     

       114
       114
       -
         expect(() => parseTag`(?! ${1})+`).toThrow();

     

       115
       115
       -
         expect(() => parseTag`(?! ${1})?`).toThrow();

     

       116
       116
       -
         expect(() => parseTag`(?! ${1})*`).toThrow();

     

       117
       91
        
       });

     

       118
       92
        
       

     

       119
       93
        
       it('supports groups with alternates', () => {