add parser plugin options for decorators (#99)

* upgrade dependency to the latest

* add new options for decorators plugin

* adding limited paserPluginOptions to parse function

* update README

* correct typo

Author: connectdotz

README.md

@@ -10,21 +10,49 @@ The engine that allows editors to build on top of Jest.
 This is only useful if you are interested in building an editor integration for Jest.
 
 ## API
-```
+```ts
 parse(   
   filePath: string,   
   serializedData?: string,   
-  strictMode: boolean = false,     
-)
+  options?: JESParserOptions
+);
+
+JESParserOptions = 
+{
+    plugins?: JESParserPluginOptions;
+    strictMode?: boolean;
+};
+
+JESParserPluginOptions = 
+{
+  decorators?: 'legacy' | {
+    decoratorsBeforeExport?: boolean;
+    allowCallParenthesized?: boolean;
+  }
+}
 ```
+
 Parse is a static Jest parser which uses Babel 7 and supports js,jsx,mjs,ts,tsx files.   
 
 [Supported ECMAScript proposals](https://github.com/babel/babel/blob/928b9f8c9518284eac6d0598633f2ec373fc6d0c/packages/babel-parser/typings/babel-parser.d.ts#L97)
 
 - filePath = Path to the file you want to parse.
 - serializedData = Serialized data, will be used instead of the filePath if available (optional).
-- strictMode = If this option is activated the parser throws an exception if the filetype is not detected, defaults to false.
-
+- options: 
+  - strictMode = If this option is activated the parser throws an exception if the filetype is not detected, defaults to false.
+  - pluginOptions = allow override for selected [plugins](https://babeljs.io/docs/en/babel-parser#plugins) options. Currently only support `decorators`. 
+
+examples:
+```ts
+parse('test.spec.ts');
+parse('parameterDecorators.spec.ts', undefined, {plugins: {decorators: 'legacy'}})
+parse('parameterDecorators.spec.ts', undefined, 
+  {plugins: 
+    {decorators: 
+      {decoratorsBeforeExport: false}
+    }
+  })
+```
 
 ## Note
 

index.d.ts

@@ -10,9 +10,10 @@ import {ChildProcess} from 'child_process';
 import {Config as JestConfig} from '@jest/types';
 import { CoverageMapData } from 'istanbul-lib-coverage';
 import ProjectWorkspace, {ProjectWorkspaceConfig, createProjectWorkspace,  LoginShell } from './build/project_workspace';
-export {createProjectWorkspace, ProjectWorkspaceConfig, ProjectWorkspace, LoginShell};
 import {SourceLocation} from '@babel/types';
 import { SnapshotData } from 'jest-snapshot/build/types';
+import parse, {JESParserPluginOptions, JESParserOptions} from './build/parsers/';
+export {parse, JESParserPluginOptions, JESParserOptions, createProjectWorkspace, ProjectWorkspaceConfig, ProjectWorkspace, LoginShell};
 export interface RunArgs {
   args: string[];
   replace?: boolean; // default is false
@@ -59,8 +60,6 @@ export interface IParseResults {
   file: string;
 }
 
-export function parse(file: string, data?: string, strict?: boolean): IParseResults;
-
 export interface Location {
   column: number;
   line: number;
@@ -233,11 +232,16 @@ export interface SnapshotBlock{
   node: SnapshotNode;
   parents: SnapshotNode[];
 } 
+export interface SnapshotParserOptions {
+  verbose?: boolean;
+  // $FlowIgnore[value-as-type]
+  parserOptions?: JESParserOptions;
+}
 export class Snapshot {
   constructor(parser?: any, customMatchers?: string[]);
-  getMetadata(filepath: string, verbose?: boolean): SnapshotMetadata[];
-  getMetadataAsync(filePath: string, verbose?: boolean): Promise<Array<SnapshotMetadata>>; 
-  parse(filePath: string, verbose?: boolean): SnapshotBlock[];
+  getMetadata(filepath: string, options?: SnapshotParserOptions): SnapshotMetadata[];
+  getMetadataAsync(filePath: string, options?: SnapshotParserOptions): Promise<Array<SnapshotMetadata>>; 
+  parse(filePath: string, options?: SnapshotParserOptions): SnapshotBlock[];
   getSnapshotContent(filePath: string, name: string | RegExp): Promise<string | SnapshotData | undefined>; 
 }
 

src/Snapshot.js

@@ -13,6 +13,7 @@ import {buildSnapshotResolver, type SnapshotResolver, type SnapshotData, utils}
 import type {ProjectConfig} from '../types/Config';
 
 import {getASTfor} from './parsers/babel_parser';
+import {JESParserOptions} from './parsers';
 
 type Node = any;
 
@@ -83,6 +84,11 @@ export interface SnapshotNode {
   parents: Node[];
 }
 
+export interface SnapshotParserOptions {
+  verbose?: boolean;
+  // $FlowIgnore[value-as-type]
+  parserOptions?: JESParserOptions;
+}
 export default class Snapshot {
   _parser: Function;
 
@@ -107,12 +113,12 @@ export default class Snapshot {
     );
   }
 
-  parse(filePath: string, verbose: boolean = false): SnapshotNode[] {
+  parse(filePath: string, options?: SnapshotParserOptions): SnapshotNode[] {
     let fileNode;
     try {
-      fileNode = this._parser(filePath);
+      fileNode = this._parser(filePath, undefined, options?.parserOptions);
     } catch (error) {
-      if (verbose) {
+      if (options?.verbose) {
         // eslint-disable-next-line no-console
         console.warn(error);
       }
@@ -183,17 +189,17 @@ export default class Snapshot {
     return Object.entries(data).length > 0 ? data : null;
   }
 
-  async getMetadataAsync(filePath: string, verbose: boolean = false): Promise<Array<SnapshotMetadata>> {
+  async getMetadataAsync(filePath: string, options?: SnapshotParserOptions): Promise<Array<SnapshotMetadata>> {
     await this._getSnapshotResolver();
-    return this.getMetadata(filePath, verbose);
+    return this.getMetadata(filePath, options);
   }
 
-  getMetadata(filePath: string, verbose: boolean = false): Array<SnapshotMetadata> {
+  getMetadata(filePath: string, options?: SnapshotParserOptions): Array<SnapshotMetadata> {
     if (!this.snapshotResolver) {
       throw new Error('snapshotResolver is not ready yet, consider migrating to "getMetadataAsync" instead');
     }
     const snapshotPath = this.snapshotResolver.resolveSnapshotPath(filePath);
-    const snapshotNodes = this.parse(filePath, verbose);
+    const snapshotNodes = this.parse(filePath, options);
     const snapshots = utils.getSnapshotData(snapshotPath, 'none').data;
 
     let lastParent = null;

src/__tests__/fixtures/snapshots/decorator-legacy.example

@@ -0,0 +1,18 @@
+
+// parameter decorator
+function first(
+  target: any,
+  propertyKey: string,
+  parameterIndex: number,
+){};
+class Example {
+  method1(
+    @first
+    _a: string
+  ){}
+}
+
+fit('fit', () => {
+  expect(fake).toMatchSnapshot();
+  expect(fake).toMatchSnapshot();
+})

src/__tests__/parsers/babel_parser.test.ts

@@ -14,7 +14,7 @@
 import * as path from 'path';
 import {NamedBlock, ParseResult} from '../..';
 import {parse} from '../../parsers/babel_parser';
-import {parseOptions} from '../../parsers/helper';
+import {JESParserOptions, parseOptions} from '../../parsers/helper';
 
 const fixtures = path.resolve('fixtures');
 
@@ -26,10 +26,11 @@ describe('parsers', () => {
     ${'whatever.ts'}
     ${'whatever.tsx'}
   `('can parse file like $fileName', ({fileName}) => {
-    const parseFunction = (file: string, data?: string) => parse(file, data, parseOptions(fileName));
+    const parseFunction = (file: string, data?: string, options?: JESParserOptions) =>
+      parse(file, data, parseOptions(fileName, options));
     const assertBlock = (block, start, end, name: string = null) => {
-      expect(block.start).toEqual(start);
-      expect(block.end).toEqual(end);
+      expect(block.start).toEqual(expect.objectContaining(start));
+      expect(block.end).toEqual(expect.objectContaining(end));
       if (name) {
         expect(block.name).toEqual(name);
       }
@@ -210,17 +211,17 @@ describe('parsers', () => {
         expect(data.expects.length).toEqual(8);
 
         const firstExpect = data.expects[0];
-        expect(firstExpect.start).toEqual({column: 5, line: 13});
-        expect(firstExpect.end).toEqual({column: 36, line: 13});
+        expect(firstExpect.start).toEqual(expect.objectContaining({column: 5, line: 13}));
+        expect(firstExpect.end).toEqual(expect.objectContaining({column: 36, line: 13}));
       });
 
       it('finds Expects in a danger flow test file ', () => {
         const data = parseFunction(`${fixtures}/dangerjs/github.example`);
         expect(data.expects.length).toEqual(3);
 
         const thirdExpect = data.expects[2];
-        expect(thirdExpect.start).toEqual({column: 5, line: 33});
-        expect(thirdExpect.end).toEqual({column: 39, line: 33});
+        expect(thirdExpect.start).toEqual(expect.objectContaining({column: 5, line: 33}));
+        expect(thirdExpect.end).toEqual(expect.objectContaining({column: 39, line: 33}));
       });
 
       it('finds Expects in a metaphysics test file', () => {
@@ -373,7 +374,7 @@ describe('parsers', () => {
       startCol: number,
       endLine: number,
       endCol: number,
-      nameType = 'Literal',
+      nameType = 'StringLiteral',
       lastProperty: string = null
     ) => {
       expect(nBlock.name).toEqual(name);
@@ -464,7 +465,7 @@ describe('parsers', () => {
 
         const itBlock = parseResult.itBlocks[0];
         assertBlock2(itBlock, 2, 7, 4, 9, 'each test %p');
-        assertNameInfo(itBlock, 'each test %p', 2, 33, 2, 44, 'Literal', 'each');
+        assertNameInfo(itBlock, 'each test %p', 2, 33, 2, 44, 'StringLiteral', 'each');
       });
       it('should be able to detect it.skip.each', () => {
         const data = `
@@ -478,7 +479,7 @@ describe('parsers', () => {
 
         const itBlock = parseResult.itBlocks[0];
         assertBlock2(itBlock, 2, 7, 4, 9, 'each test %p');
-        assertNameInfo(itBlock, 'each test %p', 2, 38, 2, 49, 'Literal', 'each');
+        assertNameInfo(itBlock, 'each test %p', 2, 38, 2, 49, 'StringLiteral', 'each');
       });
 
       it('For the simplest it.each cases', () => {
@@ -933,6 +934,83 @@ describe('parsers', () => {
         expect(parseResult.expects.length).toEqual(0);
       });
     });
+    describe('pluginOptions', () => {
+      describe('decorators', () => {
+        it('legacy', () => {
+          const data = `
+          import { asMockedFunction, type AnyFunction } from '@whatever/jest-types';
+          test('a test', () => {
+            expect(true).toBe(true);
+          });
+          class SimpleTestController {
+            handlerMethod(@Body() xxx) {
+              return;
+            }
+          }
+        `;
+          const parseResult = parseFunction('whatever', data, {plugins: {decorators: 'legacy'}});
+          expect(parseResult.itBlocks.length).toEqual(1);
+
+          const name = 'a test';
+          const itBlock = parseResult.itBlocks[0];
+          assertBlock2(itBlock, 3, 11, 5, 13, name);
+          assertNameInfo(itBlock, name, 3, 17, 3, 22);
+        });
+        it('decoratorsBeforeExport', () => {
+          const beforeExport = `
+          test('a test', () => {
+            expect(true).toBe(true);
+          });
+          @dec
+          export class C {} 
+        `;
+          const afterExport = `
+          test('a test', () => {
+            expect(true).toBe(true);
+          });
+          export @dec class C {} 
+          `;
+          const beforePlugin = {decorators: {decoratorsBeforeExport: true}};
+          const afterPlugin = {decorators: {decoratorsBeforeExport: false}};
+
+          let parseResult = parseFunction('whatever', beforeExport, {plugins: beforePlugin});
+          expect(parseResult.itBlocks.length).toEqual(1);
+
+          parseResult = parseFunction('whatever', afterExport, {plugins: afterPlugin});
+          expect(parseResult.itBlocks.length).toEqual(1);
+
+          expect(() => parseFunction('whatever', beforeExport, {plugins: afterPlugin})).toThrow();
+          expect(() => parseFunction('whatever', afterExport, {plugins: beforePlugin})).toThrow();
+        });
+        it('allowCallParenthesized', () => {
+          const callParenthesized = `
+          test('a test', () => {
+            expect(true).toBe(true);
+          });
+          @(dec)() class C {};
+          `;
+          const callNotParenthesized = `
+          test('a test', () => {
+            expect(true).toBe(true);
+          });
+          @(dec()) class C {};
+          `;
+
+          const allowPlugin = {decorators: {allowCallParenthesized: true}};
+          const notAllowPlugin = {decorators: {allowCallParenthesized: false}};
+
+          let parseResult = parseFunction('whatever', callParenthesized, {plugins: allowPlugin});
+          expect(parseResult.itBlocks.length).toEqual(1);
+
+          parseResult = parseFunction('whatever', callNotParenthesized, {plugins: allowPlugin});
+          expect(parseResult.itBlocks.length).toEqual(1);
+          parseResult = parseFunction('whatever', callNotParenthesized, {plugins: notAllowPlugin});
+          expect(parseResult.itBlocks.length).toEqual(1);
+
+          expect(() => parseFunction('whatever', callParenthesized, {plugins: notAllowPlugin})).toThrow();
+        });
+      });
+    });
     describe('parse error use case', () => {
       it('https://github.com/jest-community/vscode-jest/issues/405', () => {
         const data = `
@@ -1023,6 +1101,26 @@ describe('parsers', () => {
         const parseResult = parseFunction('whatever', data);
         expect(parseResult.itBlocks.length).toEqual(1);
 
+        const name = 'a test';
+        const itBlock = parseResult.itBlocks[0];
+        assertBlock2(itBlock, 3, 9, 5, 11, name);
+        assertNameInfo(itBlock, name, 3, 15, 3, 20);
+      });
+      it('https://github.com/jest-community/jest-editor-support/issues/89', () => {
+        const data = `
+        import { asMockedFunction, type AnyFunction } from '@whatever/jest-types';
+        test('a test', () => {
+          expect(true).toBe(true);
+        });
+        class SimpleTestController {
+          handlerMethod(@Body() xxx) {
+            return;
+          }
+        }
+      `;
+        const parseResult = parseFunction('whatever', data, {plugins: {decorators: 'legacy'}});
+        expect(parseResult.itBlocks.length).toEqual(1);
+
         const name = 'a test';
         const itBlock = parseResult.itBlocks[0];
         assertBlock2(itBlock, 3, 9, 5, 11, name);