@cicctencent/tars2node-cli 0.0.1

package/README.md

@@ -0,0 +1,74 @@
+# Tars2Node CLI
+该项目fork by`@tencent/jce2node-cli`
+提供了node环境的tars2node编译器，方便和框架进行工程化集成。
+
+## Install
+`npm i -D @jv/tars2node-cli`
+
+## Usage
+
+### With CLI:
+Command: `tars [options] <entry-file>`
+
+Options:
+```
+-T --type       编译出的文件类型，默认为es5，可选项：ts | es5
+-W --watch      监听指定文件或文件夹，支持模式匹配
+-O --output     指定存放编译后文件的文件夹的路径
+-M --mode       指定编译的目标服务类型，默认为all，可选项：client | service | all | web
+-R --return     仅对生成service代码有效，service代码调用中添加ret参数
+-G --gather     仅对生成service代码有效，service代码调用中的参数根据入参和出参聚合
+-I --interface  仅对生成ts格式的service代码有效，service中附带含有servant所有的方法的interface
+-E --entry (deprected) 入口文件路径
+-L --long       long转译的类型，默认为string，可选项：string | number | bigint
+```
+
+Example: `tars -T ts -W ./demo/**/*.tars -O ./dist -M web demo/interface.tar`
+
+
+tars  -T ts -W ./_Proto/**/*.tars -O ./dist -M web
+### With Node:
+```javascript
+const tars = require('tars2node-cli');
+const ast = tars.ast('./foo/bar/your-tars-entry.tar');
+/*
+ * type与options中的type相同
+ * mode与options中的mode相同，默认为'service'
+ * config支持的选项：
+ *  * withReturn: 与options中-R相同
+ *  * gather: 与options中-G相同
+ *  * interface: 与options中-I相同
+ *  * long: 与options中-L相同
+ *
+ */
+const runCompiler = tars.run('./foo/bar/your-tars-entry.tar', 'ts', './dist', 'client', { withReturn: true });
+```
+
+## Featrue List
+[x] 生成服务端代码
+[x] Interface -> js
+[x] Enum -> js
+[x] Struct -> js
+[x] 生成typescript代码
+[x] 生成客户端代码
+[x] 添加默认值
+[x] 添加const类型
+
+## TODO
+
+### P0
+[ ] 生成d.ts代码
+
+### P1
+[ ] 添加key类型
+
+
+## Author
+@tencent/kealxiao
+
+## Contributors
+* @tencent/shanelv
+* @tencent/carvenzhang
+
+## License
+MIT

package/bin/tars.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const program = require('commander');
+const pkg = require('../package.json');
+
+
+program
+  .version(pkg.version)
+  .usage('[options] <file>')
+  .option('-T, --type <type>', '输出文件类型')
+  .option('-M, --mode <type>', '目标服务类型')
+  .option('-W, --watch <path>', '监听文件夹')
+  .option('-O, --output <path>', '输出文件夹')
+  .option('-R, --return', '添加ret参数')
+  .option('-G, --gather', '聚合出入参数')
+  .option('-I, --interface', '生成服务接口类型')
+  .option('-L, --long <type>', 'long转译的类型')
+  .action(action)
+  .parse(process.argv);
+
+
+function action(file, cmd) {
+  console.info('\x1b[36m', `☕️ Generating JCE files from entry: ${file}.\n`);
+  const startTime = new Date();
+
+  /* eslint-disable global-require */
+  const type = cmd.type || 'es5';
+  const mode = cmd.mode || 'all';
+  const long = cmd.long || 'string';
+
+  const Generator = require('../lib/generator/ts/generator');
+  const TsParser = require('../lib/parser/parser');
+
+  const Parser = TsParser;
+
+  const options = {
+    mode,
+    type,
+    long,
+    withReturn: Boolean(cmd.return),
+    gather: Boolean(cmd.gather),
+    interface: Boolean(cmd.interface),
+    output: cmd.output,
+  };
+
+  const build = parser => new Generator(parser.buildAST(), file, options).build();
+
+  const buildOnce = async () => {
+    try {
+      const parser = new Parser(file);
+
+      await build(parser);
+      const endTime = new Date();
+      const timeDiff = (endTime - startTime).toFixed(2);
+      console.info();
+      console.info('\x1b[32m', `⚡️ Spend Time: ${timeDiff}ms.`);
+    } catch (e) {
+      console.error('\x1b[31m', '💔 An error occur!');
+      console.error('\x1b[31m', `💔 ${e.message}\n`);
+      console.error('\x1b[31m', `💔 ${e.stack}\n`);
+    }
+  };
+
+  if (cmd.watch) {
+    const chokidar = require('chokidar');
+
+    const watcher = chokidar.watch(cmd.watch);
+    watcher.on('ready', () => {
+      buildOnce();
+      watcher.on('all', () => {
+        buildOnce();
+      });
+    });
+  } else {
+    buildOnce();
+  }
+
+  /* eslint-enable global-require */
+}

package/jce.pegjs

@@ -0,0 +1,359 @@
+Tars
+  = refs:RefDefinition* m:ModuleDefinition+ {
+    return [...refs, ...m];
+  }
+
+RefDefinition
+  = _* '#include' _* '"' cs:Char+ '"' _* {
+    return {
+      type: 'ref',
+      target: cs.join(''),
+    };
+  }
+
+ModuleDefinition
+  = _* 'module' _+ id:Identifier _* '{' value:Definition+ _* '}' _* ';'? _* {
+    return {
+      type: 'module',
+      id,
+      value,
+    }
+  }
+
+Definition
+  = ConstDefinition
+  / EnumDefinition
+  / StructDefinition
+  / InterfaceDefinition
+  / CompareDefinition
+  / KeyDeclaration
+
+TypeSpecifier
+  = VectorSpecifier
+  / MapSpecifier
+  / SimpleTypeSpecifier
+
+SimpleTypeSpecifier
+  = 'void'
+  / 'bool'
+  / 'byte'
+  / 'short'
+  / 'int'
+  / type:('unsigned' blank 'int') { return type.join("") }
+  / type:('unsigned' blank 'short') { return type.join("") }
+  / 'long'
+  / 'float'
+  / 'double'
+  / 'string'
+  / nest:((Identifier _* '::' _* )*)? target:Identifier {
+    return nest.reduce((acc, [key]) => Object.assign({}, acc, { nested: [...acc.nested, key] }), { target, nested:[] });
+  }
+
+VectorSpecifier
+  = 'vector' blank* '<' blank* target:TypeSpecifier blank* '>' {
+    return {
+      type: 'vector',
+      target,
+    };
+  }
+
+MapSpecifier
+  = 'map' blank* '<' blank* key:TypeSpecifier _* ',' _* value:TypeSpecifier blank* '>' {
+    return {
+      type: 'map',
+      key,
+      value,
+    };
+  }
+
+ConstDefinition
+  = beforeComment:_* 'const' _+ t:TypeSpecifier _+ id:Identifier _* init:ConstInitializer _* ';' {
+    return {
+      id,
+      type: 'const',
+      beforeComment: beforeComment.join(''),
+      value: {
+        type: t,
+        init,
+      },
+    };
+  }
+
+ConstInitializer
+  = '=' _* value:ConstValuer {
+    return value;
+  }
+
+ConstValuer
+  = value:(FloatingLiteral / IntegerLiteral / StringLiteral / BooleanLiteral) {
+    return value;
+  }
+  / nest:((Identifier _* '::' _* )*)? target:Identifier {
+    return nest.reduce((acc, [key]) => Object.assign({}, acc, { nested: [...acc.nested, key] }), { target, nested:[] });
+  }
+
+EnumDefinition
+  = beforeComment:_* 'enum' _+ id:Identifier _* '{' _* es:EnumeratorSequence _* '}' _* ';' {
+    return {
+      id,
+      type: 'enum',
+      value: es,
+      beforeComment: beforeComment.join(''),
+    };
+  }
+
+EnumeratorSequence
+  = head:Enumerator _* tail:EnumeratorSequence {
+    return [head, ...tail];
+  }
+  / e:Enumerator {
+    return [e];
+  }
+
+Enumerator
+  = id:Identifier _* '=' _* v:IntegerLiteral  _* ','? comment: _* {
+    return {
+      id,
+      value: v,
+      comment: comment.join('').replace(/^[\n\r]+|\s+$/g, '')
+    };
+  }
+  / id:Identifier ','? comment: _* {
+    return {
+      id,
+      value: undefined,
+    };
+  }
+  / id:Identifier {
+    return {
+      id,
+      value: undefined,
+    };
+  }
+
+StructDefinition
+  = beforeComment:_* 'struct' _+ id:Identifier _* '{' _* ms:MemberDeclaration* _* '}' _* ';' {
+    return {
+      id,
+      type: 'struct',
+      members: ms,
+      beforeComment: beforeComment.join(''),
+    };
+  }
+
+KeyDeclaration
+  = beforeComment:_* 'key' _* '[' v:KeyMemberList _* ']' _* ';' mock:Mockcomment? comment:_* {
+    comment = comment.join('').replace(/^[\n\r]+|\s+$/g, '');
+    return {
+        type: 'key',
+        value:v,
+        beforeComment: beforeComment.join(''),
+        mock: mock,
+        comment,
+      };
+  }
+
+MemberDeclaration
+  = i:IntegerLiteral _+ r:('require' / 'optional') _+ t:TypeSpecifier _+ id:Identifier _* init:ConstInitializer? _* ';' mock:Mockcomment? comment:_* {
+    comment = comment.join('').replace(/^[\n\r]+|\s+$/g, '');
+    if(mock ){
+        return {
+          index: parseInt(i, 10),
+          id,
+          require: r === 'require',
+          type: t,
+          init,
+          mock: mock,
+          comment,
+        };
+    }
+    return {
+      index: parseInt(i, 10),
+      id,
+      require: r === 'require',
+      type: t,
+      init,
+      comment,
+    };
+  }
+
+InterfaceDefinition
+  = beforeComment:_*  'interface' _+ id:Identifier _* '{' _* fn:FunctionDefinition* _* '}' _* ';' {
+    return {
+      id,
+      type: 'interface',
+      methods: fn,
+    };
+  }
+
+FunctionDefinition
+  = t:TypeSpecifier _+ id:Identifier _* '(' _* ps:ParameterDefinitionList? _* ')' _* ';' _* {
+    return {
+      id,
+      type: 'func',
+      output: t,
+      params: ps,
+    };
+  }
+
+ParameterDefinitionList
+  = head:ParameterDefinition _* ',' _* tail:ParameterDefinitionList {
+    return [head, ...tail];
+  }
+  / p:ParameterDefinition {
+    return [p];
+  }
+
+ParameterDefinition
+  = 'out' _+ type:TypeSpecifier _+ id:Identifier {
+    return {
+      id,
+      io: 'out',
+      type,
+    };
+  }
+  / 'routekey' _+ type:TypeSpecifier _+ id:Identifier {
+    return {
+      id,
+      io: 'routekey',
+      type,
+    };
+  }
+  / type:TypeSpecifier _+ id:Identifier {
+    return {
+      id,
+      io: 'in',
+      type,
+    }
+  }
+
+CompareDefinition
+  = beforeComment:_* 'key' _+ '[' _* nest:((Identifier '::')*)? target:Identifier _* ',' _* v:KeyMemberList _* ']' _* ';' {
+    const t = nest.reduce((acc, [key]) => Object.assign({}, acc, { nested: [...acc.nested, key] }), { target, nested:[] });
+    return {
+      type: 'key',
+      value: t,
+      seq: v,
+      beforeComment: beforeComment.join(''),
+    };
+  }
+
+KeyMemberList
+  = head:Identifier _* ',' _* tail:KeyMemberList {
+    return [head, ...tail];
+  }
+  / id:Identifier {
+    return [id];
+  }
+
+IntegerLiteral
+  = num:(HexLiteral / OctalLiteral / DecimalLiteral) { return Number(num); }
+
+
+DecimalLiteral
+  = head:(Sign? NonezeroDigit) tail:Digit* {
+    return [head.join(''), ...tail].join('');
+  }
+
+OctalLiteral
+  = head:(Sign? [0]+) tail:OctalDigit* {
+    return [head.join(''), ...tail].join('');
+  }
+
+HexLiteral
+  = head:(Sign? "0x"i) tail:HexDigit+ {
+    return [head.join(''), ...tail].join('');
+  }
+
+FloatingLiteral
+  = f:FractionalConstant e:ExponentPart? FloatingSuffix? {
+    if (e !== null) return (f + e);
+    return f;
+  }
+  / d:Digit+ e:ExponentPart? FloatingSuffix? {
+    const ds = d.join('');
+    if (e !== null) return (ds + e);
+    return ds;
+  }
+
+FractionalConstant
+ = s:Sign? l:Digit* '.' r:Digit+ {
+    if (s === '-') {
+      return [s, ...l, '.', ...r].join('');
+    }
+    return [...l, '.', ...r].join('');
+ }
+ / s:Sign? head:Digit+ '.' {
+    if (s === '-') {
+      return [s, ...head].join('');
+    }
+    return head.join('');
+ }
+
+Digit
+  = [0-9]
+
+NonezeroDigit
+  = [1-9]
+
+OctalDigit
+  = [1-6]
+
+HexDigit
+  = [0-9a-fA-F]
+
+ExponentPart
+  = 'e'i s:Sign? d:Digit+ {
+    if (s === null) {
+      return ['e', ...d].join('');
+    }
+    return ['e', s, ...d].join('');
+  }
+
+Sign
+  = [+-]
+
+FloatingSuffix
+  = 'f'i
+
+BooleanLiteral
+  = 'true'
+  / 'false'
+
+StringLiteral
+  = '"' str:Char* '"' {
+    return `"${str.join('')}"`;
+  }
+
+Char
+  = [^\n\"]
+
+Identifier
+  = head:NonDigit tail:(NonDigit / Digit)* {
+    return [head, ...tail].join('');
+  }
+
+NonDigit
+  = [_a-zA-Z]
+
+
+Mockcomment
+  =  [^\n\/]*'//' [^\n\{]* '{{' str:[^\n\{\}]+ '}}' [^\n\}]* {
+    return str.join('');
+  }
+
+comment
+  = c:('/*' (!'*/' .)* '*/'
+  / '//' [^\n]*){
+    // console.log('comment', c);
+    const toString = (a) =>  typeof a === 'string' ? a : ( a && a.length ? a.map(toString).join('') : '');
+    return toString(c);
+  }
+
+blank
+  = [ ]
+
+_
+  = c:([ \t\n\r] / comment) {
+    return c;
+  }

package/lib/generator/finder.js

@@ -0,0 +1,122 @@
+'use strict';
+
+/**
+ *
+ * 声明JCE-Struct节点类型
+ * @typedef { refType | vecType | string | mapType } tarsType
+ *
+ * @typedef {object} refType
+ * @property {string} target
+ * @property {string[]} nested
+ *
+ * @typedef {object} vecType
+ * @property {'vector'} type
+ * @property {tarsType} target
+ *
+ * @typedef {object} mapType
+ * @property {'map'} type
+ * @property {tarsType} key
+ * @property {tarsType} value
+ *
+ * @typedef {object} constValue
+ * @property {tarsType} type
+ * @property {*} init
+ *
+ * @typedef {object} TarsConstNode
+ * @property {string} id
+ * @property {'const'} type
+ * @property {constValue} value
+ *
+ * @typedef {object} enumValue
+ * @property {string} id
+ * @property {number} value
+ *
+ * @typedef {object} TarsEnumNode
+ * @property {string} id
+ * @property {'enum'} type
+ * @property {enumValue[]} value
+ *
+ * @typedef {object} param
+ * @property {string} id
+ * @property {'in'|'out'} io
+ * @property {tarsType} type
+ *
+ * @typedef {object} TarsInterfMethod
+ * @property {string} id
+ * @property {'func'} type
+ * @property {tarsType} output
+ * @property {param[]} params
+ *
+ * @typedef {object} TarsInterfNode
+ * @property {string} id
+ * @property {'interface'} type
+ * @property {TarsInterfMethod[]} methods
+ *
+ * @typedef {object} member
+ * @property {number} index
+ * @property {string} id
+ * @property {boolean} require
+ * @property {tarsType} type
+ * @property {null|string} init
+ *
+ * @typedef {object} TarsStructNode
+ * @property {string} id
+ * @property {'struct'} type
+ * @property {member[]} members
+ *
+ * @typedef {TarsStructNode|TarsInterfNode|TarsEnumNode|TarsConstNode} TarsNode
+ *
+ * @typedef {object} TarsModule
+ * @property {string} pathname
+ * @property {TarsNode[]} value
+ *
+ * @typedef {Object.<string, TarsModule>} TarsTree
+*
+* 工具类类型
+* @typedef {import("./printer")} Printer
+* @typedef {import("./typing")} Typing
+*
+*/
+class Finder {
+  /**
+   * @param {TarsTree} tree
+   */
+  constructor(tree) {
+    this._tree = tree;
+    /** @type {Map<string, *>} */
+    this._memo = new Map();
+  }
+
+  refresh() {
+    this._memo = new Map();
+  }
+
+  /**
+   * @param {refType} type
+   * @param {string} current
+   * @return {*}
+   */
+  find(type, current) {
+    const jsonType = JSON.stringify(type);
+    if (!this._memo.has(jsonType)) {
+      if (!type.target || !type.nested) throw new Error(`Type: #${JSON.stringify(type)}# is not a ref type`);
+
+      let currentPath;
+      if (type.nested.length === 0) currentPath = [current];
+      else currentPath = [...type.nested];
+
+      try {
+        const [moduleName] = currentPath;
+        const targetModule = this._tree[moduleName];
+        const target = targetModule.value.find(({ id: mid }) => mid === type.target);
+        this._memo.set(jsonType, target);
+      } catch (e) {
+        throw new Error(`Cannot find target for type: #${JSON.stringify(type)}#`);
+      }
+    }
+
+    return this._memo.get(jsonType);
+  }
+}
+
+module.exports = Finder;