Fixed generating typescript definitions (#1032)

* changed parser

* fixed typescript definitions

* fixed linting

* fixed parser error

Author: DavertMik

lib/command/definitions.js

@@ -3,14 +3,24 @@ const getTestRoot = require('./utils').getTestRoot;
 const Codecept = require('../codecept');
 const container = require('../container');
 const methodsOfObject = require('../utils').methodsOfObject;
-const getParamsToString = require('../utils').getParamsToString;
 const output = require('../output');
+const { toTypeDef } = require('../parser');
 const fs = require('fs');
 const path = require('path');
 
 const template = `
 type ICodeceptCallback = (i: CodeceptJS.{{I}}) => void;
 
+interface ILocator {
+  xpath?: string;
+  css?: string;
+  name?: string;
+  value?: string;
+  frame?: string;
+  android?: string;
+  ios?: string;
+}
+
 declare const actor: () => CodeceptJS.{{I}};
 declare const Feature: (string: string) => void;
 declare const Scenario: (string: string, callback: ICodeceptCallback) => void;
@@ -47,26 +57,25 @@ module.exports = function (genPath, options) {
     const helpers = container.helpers();
     const suppportI = container.support('I');
     const translations = container.translation();
-    const methods = [];
+    let methods = [];
     const actions = [];
     for (const name in helpers) {
       const helper = helpers[name];
-      methodsOfObject(helper).forEach((action) => {
+      for (const action of methodsOfObject(helper)) {
         const actionAlias = container.translation() ? container.translation().actionAliasFor(action) : action;
         if (!actions[actionAlias]) {
-          const params = getParamsToString(helper[action]);
-          methods.push(`    ${(actionAlias)}: (${params}) => any; \n`);
+          methods = methods.concat(toTypeDef(helper[action]));
           actions[actionAlias] = 1;
         }
-      });
+      }
     }
     for (const name in suppportI) {
       if (actions[name]) {
         continue;
       }
       const actor = suppportI[name];
-      const params = getParamsToString(actor);
-      methods.push(`    ${(name)}: (${params}) => any; \n`);
+      // const params = toTypeDef(actor);
+      // methods.push(`    ${(name)}: (${params}) => any; \n`);
     }
     let definitionsTemplate = template.replace('{{methods}}', methods.join(''));
     definitionsTemplate = definitionsTemplate.replace(/\{\{I\}\}/g, container.translation().I);

lib/command/list.js

@@ -2,7 +2,7 @@ const getConfig = require('./utils').getConfig;
 const getTestRoot = require('./utils').getTestRoot;
 const Codecept = require('../codecept');
 const container = require('../container');
-const getParamsToString = require('../utils').getParamsToString;
+const getParamsToString = require('../parser').getParamsToString;
 const methodsOfObject = require('../utils').methodsOfObject;
 const output = require('../output');
 

lib/parser.js

@@ -0,0 +1,82 @@
+const parser = require('parse-function')({ ecmaVersion: 2017 });
+const { flatTail } = require('./utils');
+
+module.exports.getParamsToString = function (fn) {
+  return getParams(fn).join(', ');
+};
+
+module.exports.toTypeDef = function (fn) {
+  const types = [];
+  const paramNames = [];
+  const params = getParams(fn);
+  for (const key in params) {
+    let paramName = params[key];
+    const paramValue = paramName.split('=');
+    const isOptional = paramValue.length !== 1;
+    if (isOptional) {
+      paramName = paramValue[0];
+    }
+    paramNames[key] = paramName;
+    if (isOptional) {
+      paramNames[key] += '?';
+    }
+    types[key] = guessParamTypes(paramName);
+  }
+
+  let combinedTypes = types[types.length - 1];
+  if (!combinedTypes) return methodSignature(fn);
+  if (types.length === 1) return methodSignature(fn, paramNames, combinedTypes);
+
+
+  for (let i = types.length - 2; i >= 0; i--) {
+    combinedTypes = flatTail(combinedTypes, types[i]);
+  }
+  return combinedTypes.map(type => methodSignature(fn, paramNames, type)).join('');
+};
+
+function methodSignature(fn, paramNames, params) {
+  if (!params) params = [];
+  params = params.map((p, i) => `${paramNames[i]}: ${p}`).join(', ');
+  let returnType = 'void';
+  if (fn.name.indexOf('grab') === 0) {
+    returnType = 'Promise';
+  }
+  return `    ${fn.name}(${params}) : ${returnType},\n`;
+}
+
+function guessParamTypes(paramName) {
+  switch (paramName) {
+    case 'fn':
+      return ['Function'];
+    case 'locator':
+    case 'field':
+    case 'context':
+    case 'select':
+      return ['ILocator', 'string'];
+    case 'num':
+    case 'sec':
+    case 'width':
+    case 'height':
+      return ['number'];
+  }
+  return ['string'];
+}
+
+function getParams(fn) {
+  if (fn.isSinonProxy) return [];
+  const newFn = fn.toString().replace(/^async/, 'async function');
+  try {
+    const reflected = parser.parse(newFn);
+    const params = reflected.args.map((p) => {
+      const def = reflected.defaults[p];
+      if (def) {
+        return `${p}=${def}`;
+      }
+      return p;
+    });
+    return params;
+  } catch (err) {
+    console.error(err, newFn);
+  }
+}
+

lib/utils.js

@@ -1,13 +1,28 @@
 const fs = require('fs');
 const path = require('path');
-const getParams = require('js-function-reflector');
 const getFunctionArguments = require('fn-args');
 const { convertColorToRGBA, isColorProperty } = require('./colorUtils');
 
+function getParams(fn) {
+  return parser.parse(fn);
+}
+
 function isObject(item) {
   return item && typeof item === 'object' && !Array.isArray(item);
 }
 
+function flatTail(flatParams, params) {
+  const res = [];
+  for (const fp of flatParams) {
+    for (const p of params) {
+      res.push([p].concat(fp));
+    }
+  }
+  return res;
+}
+
+module.exports.flatTail = flatTail;
+
 function deepMerge(target, source) {
   if (isObject(target) && isObject(source)) {
     for (const key in source) {
@@ -64,15 +79,6 @@ module.exports.getParamNames = function (fn) {
 };
 
 
-module.exports.getParamsToString = function (fn) {
-  if (fn.isSinonProxy) return [];
-  const params = getParams(fn).args.map(p => (Array.isArray(p) ? `${p[0]}=${p[1]}` : p));
-  if (isGenerator(fn) && params[0] && params[0][0] === '*') {
-    params[0] = params[2].substr(2);
-  }
-  return params.join(', ');
-};
-
 module.exports.installedLocally = function () {
   return path.resolve(`${__dirname}/../`).indexOf(process.cwd()) === 0;
 };

package.json

@@ -35,15 +35,17 @@
     "test": "npm run lint && mocha test/unit && mocha test/runner"
   },
   "dependencies": {
+    "acorn": "^5.5.3",
     "chalk": "^1.1.3",
     "commander": "^2.14.1",
     "escape-string-regexp": "^1.0.3",
     "fn-args": "^3.0.0",
     "glob": "^6.0.1",
     "inquirer": "^0.11.0",
-    "js-function-reflector": "^1.3.1",
+    "js-function-reflector": "^1.3.0",
     "mkdirp": "^0.5.1",
     "mocha": "^4.1.0",
+    "parse-function": "^5.2.7",
     "promise-retry": "^1.1.1",
     "requireg": "^0.1.5"
   },

test/runner/list_test.js

@@ -1,3 +1,4 @@
+const fs = require('fs');
 const assert = require('assert');
 const path = require('path');
 const exec = require('child_process').exec;
@@ -18,29 +19,32 @@ describe('list/def commands', () => {
 
   it('def should create definition file', (done) => {
     try {
-      require('fs').unlinkSync(`${codecept_dir}/steps.d.ts`);
+      fs.unlinkSync(`${codecept_dir}/steps.d.ts`);
     } catch (e) {
       // continue regardless of error
     }
     exec(`${runner} def ${codecept_dir}`, (err, stdout, stderr) => {
       stdout.should.include('Definitions were generated in steps.d.ts');
       stdout.should.include('<reference path="./steps.d.ts" />');
-      require('fs').existsSync(`${codecept_dir}/steps.d.ts`).should.be.ok;
+      fs.existsSync(`${codecept_dir}/steps.d.ts`).should.be.ok;
+      const def = fs.readFileSync(`${codecept_dir}/steps.d.ts`).toString();
+      def.should.include('amInPath(openPath: string) : void');
+      def.should.include('    seeFile(name: string) : void');
       assert(!err);
       done();
     });
   });
 
   it('def should create definition file given a config file', (done) => {
     try {
-      require('fs').unlinkSync(`${codecept_dir}/steps.d.ts`);
+      fs.unlinkSync(`${codecept_dir}/steps.d.ts`);
     } catch (e) {
       // continue regardless of error
     }
     exec(`${runner} def --config ${codecept_dir}/codecept.ddt.json`, (err, stdout, stderr) => {
       stdout.should.include('Definitions were generated in steps.d.ts');
       stdout.should.include('<reference path="./steps.d.ts" />');
-      require('fs').existsSync(`${codecept_dir}/steps.d.ts`).should.be.ok;
+      fs.existsSync(`${codecept_dir}/steps.d.ts`).should.be.ok;
       assert(!err);
       done();
     });

test/unit/parser_test.js

@@ -0,0 +1,57 @@
+const parser = require('../../lib/parser');
+const assert = require('assert');
+const chai = require('chai');
+
+const expect = chai.expect;
+
+class Obj {
+  method1(locator, sec) {}
+  method2(locator, value, sec) {}
+  method3(locator, context) {}
+  async method4(locator, context) {
+    return false;
+  }
+}
+
+describe('parser', () => {
+  const obj = new Obj();
+
+  describe('#getParamsToString', () => {
+    it('should get params for normal function', () => {
+      expect(parser.getParamsToString(obj.method1)).to.eql('locator, sec');
+    });
+    it('should get params for async function', () => {
+      expect(parser.getParamsToString(obj.method4)).to.eql('locator, context');
+    });
+  });
+
+  describe('#toTypeDef', () => {
+    it('should transform function to TS types', () => {
+      const res = parser.toTypeDef(obj.method1);
+      expect(res).to.include('    method1(locator: ILocator, sec: number) : void');
+      expect(res).to.include('    method1(locator: string, sec: number) : void');
+    });
+
+    it('should transform function to TS types', () => {
+      const res = parser.toTypeDef(obj.method2);
+      expect(res).to.include('method2(locator: ILocator, value: string, sec: number) : void');
+      expect(res).to.include('method2(locator: string, value: string, sec: number) : void');
+    });
+
+    it('should transform function to TS types', () => {
+      const res = parser.toTypeDef(obj.method3);
+      expect(res).to.include('method3(locator: ILocator, context: ILocator) : void');
+      expect(res).to.include('method3(locator: ILocator, context: string) : void');
+      expect(res).to.include('method3(locator: string, context: ILocator) : void');
+      expect(res).to.include('method3(locator: string, context: string) : void');
+    });
+
+    it('should transform function to TS types', () => {
+      const res = parser.toTypeDef(obj.method4);
+      expect(res).to.include('method4(locator: ILocator, context: ILocator) : void');
+      expect(res).to.include('method4(locator: ILocator, context: string) : void');
+      expect(res).to.include('method4(locator: string, context: ILocator) : void');
+      expect(res).to.include('method4(locator: string, context: string) : void');
+    });
+  });
+});