@darabonba/python-generator 1.2.19 → 2.0.1

package/src/resolver/model.js

@@ -1,159 +0,0 @@
-'use strict';
-
-// eslint-disable-next-line no-unused-vars
-const debug = require('../lib/debug');
-const assert = require('assert');
-const BaseResolver = require('./base');
-
-const {
-  _string,
-  _escape,
-  _isBasicType,  
-} = require('../lib/helper');
-
-const {
-  ObjectItem,
-  AnnotationItem,
-  PropItem,
-  NoteItem,
-} = require('../langs/common/items');
-
-const {
-  Modify,
-} = require('../langs/common/enum');
-
-class ModelResolver extends BaseResolver {
-  constructor(astNode, combinator, globalAst) {
-    super(astNode, combinator, globalAst);
-    this.object = new ObjectItem('model');
-  }
-
-  resolve() {
-    const object = this.object;
-    const combinator = this.combinator;
-    const config = this.config;
-    const ast = this.ast;
-
-    assert.equal(ast.type, 'model');
-      
-    combinator.config.emitType = 'model';
-
-    object.name = ast.modelName.lexeme;
-    if (config.modelDirName) {
-      config.model.dir = config.modelDirName;
-    }
-    config.layer = config.model.dir;
-      
-    if (ast.annotation) {
-      this.initAnnotation(ast.annotation);
-    }
-      
-    object.topAnnotation.push(new AnnotationItem(
-      object.index,
-      'single',
-      config.generateFileInfo
-    ));
-      
-    object.addExtends(combinator.addInclude('$Model'));
-      
-    this.initProp(ast.modelBody.nodes);
-    if (ast.modelBody.nodes.length === 0) {
-      if (ast.tokenRange) {
-        this.resolveAnnotations(
-          this.getBetweenComments(ast.tokenRange[0], ast.tokenRange[1]),
-          object.index
-        ).forEach(c => {
-          object.addBodyNode(c);
-        });
-      }
-    }
-    
-    object.includeList = this.combinator.includeList;
-    return object;
-  }
-
-  initProp(nodes) {
-    const object = this.object;
-
-    for (let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      if (typeof node.fieldValue.fieldType === 'undefined') {
-        let subModelUsed = [];
-        this.findSubModelsUsed(node, subModelUsed, object.name);
-        subModelUsed.forEach(subModel => {
-          this.combinator.addModelInclude(subModel);
-        });
-      } else if (node.fieldValue.fieldType === 'array') {
-        let name = '';
-        if (node.fieldValue.fieldItemType.lexeme) {
-          name = node.fieldValue.fieldItemType.lexeme;
-        } else if (node.fieldValue.itemType) {
-          name = node.fieldValue.fieldItemType.lexeme;
-        }
-        if (name && !_isBasicType(name)) {
-          this.combinator.addModelInclude(name);
-        }
-      }
-
-      const prop = new PropItem();
-      prop.belong = object.index;
-      prop.name = _escape(node.fieldName.lexeme) || _string(node.fieldName);
-      prop.type = this.resolveType(node.fieldValue, node);
-      
-      prop.modify.push(Modify.public());
-      if (node.required) {
-        prop.addNote(new NoteItem('required', true));
-      }
-      if (node.tokenRange) {
-        let annotations = this.resolveAnnotations(
-          this.getFrontComments(node.tokenRange[0]),
-          object.index
-        );
-        annotations.forEach(c => {
-          object.addBodyNode(c);
-        });
-      }
-      for (let i = 0; i < node.attrs.length; i++) {
-        const attr = node.attrs[i];
-        let value;
-        if (typeof attr.attrValue.string !== 'undefined') {
-          value = attr.attrValue.string;
-        } else if (typeof attr.attrValue.value !== 'undefined') {
-          value = attr.attrValue.value;
-        } else if (typeof attr.attrValue.lexeme !== 'undefined') {
-          value = attr.attrValue.lexeme;
-        }
-        let note = new NoteItem(
-          attr.attrName.lexeme,
-          value
-        );
-        prop.addNote(note);
-      }
-      object.addBodyNode(prop);
-    }
-    if (nodes[nodes.length - 1] && nodes[nodes.length - 1].tokenRange) {
-      let annotations = this.resolveAnnotations(
-        this.getBackComments(nodes[nodes.length - 1].tokenRange[1]),
-        object.index
-      );
-      annotations.forEach(c => {
-        object.addBodyNode(c);
-      });
-    }
-  }
-
-  findSubModelsUsed(node, subModelUsed = [], pre = '') {
-    let name = _escape(node.fieldName.lexeme) || _string(node.fieldName);
-    if (pre !== '') {
-      name = pre + '.' + name;
-    }
-    subModelUsed.push(name);
-    node.fieldValue.nodes.forEach(item => {
-      if (typeof item.fieldValue.fieldType === 'undefined') {
-        this.findSubModelsUsed(item, subModelUsed, name);
-      }
-    });
-  }
-}
-
-module.exports = ModelResolver;

package/tests/common.tests.js

@@ -1,244 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const mm = require('mm');
-const expect = require('chai').expect;
-require('mocha-sinon');
-
-const {
-  Symbol,
-  Modify
-} = require('../src/langs/common/enum');
-
-const {
-  Counter,
-  Grammer,
-  GrammerCall,
-  GrammerValue,
-  GrammerSymbol,
-  GrammerThrows,
-  GrammerNewLine,
-  GrammerCondition,
-  NoteItem,
-  ObjectItem,
-} = require('../src/langs/common/items');
-
-const PackageInfo = require('../src/langs/common/package_info');
-
-const Combinator = require('../src/langs/common/combinator');
-const Emitter = require('../src/lib/emitter');
-
-describe('common tests', function () {
-  beforeEach(function () {
-    this.sinon.stub(console, 'log');
-  });
-
-  it('enum should be ok', function () {
-    // test Symbol enum
-    expect(Symbol.eq()).to.be.eql('EQ');
-    expect(Symbol.not()).to.be.eql('NOT');
-    expect(Symbol.multi()).to.be.eql('MULTI');
-    expect(Symbol.div()).to.be.eql('DIV');
-    expect(Symbol.power()).to.be.eql('POWER');
-    expect(Symbol.greaterEq()).to.be.eql('GREATER_EQ');
-    expect(Symbol.less()).to.be.eql('LESS');
-    expect(Symbol.lessEq()).to.be.eql('LESS_EQ');
-    expect(Symbol.judge()).to.be.eql('JUDGE');
-    expect(Symbol.risk()).to.be.eql('RISK');
-
-    // test Modify enum
-    expect(Modify.private()).to.be.eql('PRIVATE');
-    expect(Modify.internal()).to.be.eql('INTERNAL');
-    expect(Modify.final()).to.be.eql('FINAL');
-    expect(Modify.abstract()).to.be.eql('ABSTRACT');
-  });
-
-  it('counter should be ok', function () {
-    const counter = new Counter(-2);
-    expect(counter.index).to.be.eql(-2);
-    counter.step(2, 10);
-    expect(counter.index).to.be.eql(18);
-    counter.once();
-    expect(counter.index).to.be.eql(19);
-  });
-
-  it('items : Item.getItemByIndex&getParent should be ok', function () {
-    const parentGrammer = new Grammer();
-    const childGrammer = new GrammerNewLine();
-    const childGrammer2 = new GrammerSymbol();
-    childGrammer.belong = parentGrammer.index;
-
-    expect(function () {
-      childGrammer.getItemByIndex(-100);
-    }).to.be.throw('Index [-100] not exist in ItemSet');
-
-    expect(childGrammer.getItemByIndex(parentGrammer.index)).to.be.eql(parentGrammer);
-    expect(childGrammer.getParent()).to.be.eql(parentGrammer);
-    expect(childGrammer2.getParent()).to.be.eql(parentGrammer);
-  });
-
-  it('items : GrammerCall.addPath should be ok', function () {
-    const call = new GrammerCall();
-    expect(function () {
-      call.addPath({ type: 'invalid-type' });
-    }).to.be.throw('invalid-type path.type should be parent|object|object_static|call|call_static|prop|prop_static|map|list');
-  });
-
-  it('items : NoteItem should be ok', function () {
-    let noteItem = new NoteItem('', null);
-    expect(noteItem.type).to.be.eql('null');
-    expect(function () {
-      noteItem = new NoteItem('', {});
-    }).to.be.throw('Not suppoted type : object  [number,string,boolean]');
-  });
-
-  it('items : ObjectItem should be ok', function () {
-    const objectItem = new ObjectItem('client');
-    expect(function () {
-      objectItem.addBodyNode(null);
-    }).to.be.throw('Only suppoted PropItem | FuncItem | ObjectItem | AnnotationItem | ConstructItem');
-    objectItem.addModify(Modify.private());
-    expect(objectItem.modify.indexOf('PRIVATE') !== -1).to.be.true;
-  });
-
-  it('package_info : render should be ok', function () {
-    const packageInfo = new PackageInfo();
-    expect(
-      packageInfo.render('${key}', { key: 'render-key' })
-    ).to.be.eql('render-key');
-  });
-
-  it('package_info : checkParams should be ok', function () {
-    const packageInfo = new PackageInfo();
-    const param = { key: 'value' };
-    packageInfo.checkParams(param);
-    try {
-      packageInfo.checkParams(param, ['someRequeiredKey']);
-    } catch (e) {
-      expect(e.message).to.be.eql('need config packageInfo.someRequeiredKey');
-      expect(console.log.calledWith(param)).to.be.true;
-    }
-  });
-
-  it('package_info : renderAuto should be ok', function () {
-    const packageInfo = new PackageInfo();
-    mm(fs, 'readFileSync', function (filename) {
-      return '${key}';
-    });
-    mm(fs, 'existsSync', function (filename) {
-      return true;
-    });
-    mm(fs, 'writeFileSync', function (filename, content) {
-      return true;
-    });
-    // not throw exception
-    packageInfo.renderAuto('/tmp/template-file-path.tmpl', '/tmp/target-path.tmp', { key: 'RenderAutoKey' });
-
-    mm(fs, 'existsSync', function (filename) {
-      return false;
-    });
-    mm(fs, 'mkdirSync', function (filename) {
-      return true;
-    });
-    // not throw exception
-    packageInfo.renderAuto('/tmp/template-file-path.tmpl', '/tmp/target-path.tmp', { key: 'RenderAutoKey' });
-  });
-
-  it('package_info : resolveOutputDir should be ok', function () {
-    const packageInfo = new PackageInfo();
-    packageInfo.config = { dir: '/tmp/' };
-    expect(packageInfo.resolveOutputDir({ outputDir: null }, './')).to.be.eql('/tmp/');
-
-    mm(fs, 'existsSync', function (filename) {
-      return false;
-    });
-    expect(packageInfo.resolveOutputDir({ outputDir: 'output/' }, './')).to.be.eql('/tmp/output/');
-    mm.restore();
-  });
-
-  it('combinator : coreClass should be ok', function () {
-    const combinator = new Combinator({ tea: {} });
-    expect(function () {
-      combinator.coreClass('test');
-    }).to.be.throw('Unsupported core class name : test');
-  });
-
-  it('combinator : findThrows should be ok', function () {
-    const combinator = new Combinator();
-    const grammer = new GrammerCondition();
-    expect(combinator.findThrows(grammer).length).to.be.eql(0);
-    grammer.addBodyNode(new GrammerThrows());
-    expect(combinator.findThrows(grammer).length).to.be.eql(1);
-    const childGrammer = new GrammerCondition();
-    childGrammer.addBodyNode(new GrammerThrows());
-    grammer.addBodyNode(childGrammer);
-    expect(combinator.findThrows(grammer).length).to.be.eql(2);
-  });
-
-  it('combinator : unimpelemented should be ok', function () {
-    const combinator = new Combinator();
-    expect(function () {
-      combinator.init({});
-    }).to.be.throw('unimpelemented');
-    expect(function () {
-      combinator.addModelInclude('foo');
-    }).to.be.throw('unimpelemented');
-    expect(function () {
-      combinator.addInclude('foo');
-    }).to.be.throw('unimpelemented');
-  });
-
-  it('combinator : systemfunc should be ok', function () {
-    const combinator = new Combinator();
-    const emitter = new Emitter();
-    const gram = new GrammerCall();
-    expect(function () {
-      combinator.systemfunc(emitter, gram);
-    }).to.be.throw('Invalid path. path list cannot be empty.');
-    gram.addPath({ type: 'call', name: 'test' });
-    expect(function () {
-      combinator.systemfunc(emitter, gram);
-    }).to.be.throw('unimpelemented sysTest(emitter, gram){} method\n');
-
-    combinator.sysTest = function () {
-      console.log('test call combinator.sysTest');
-      return true;
-    };
-    combinator.systemfunc(emitter, gram);
-    expect(console.log.calledWith('test call combinator.sysTest')).to.be.true;
-  });
-
-  it('combinator : grammerNewLine should be ok', function () {
-    const combinator = new Combinator();
-    const emitter = new Emitter();
-    emitter.output = '';
-    const grammerNewLine = new GrammerNewLine(2);
-    combinator.grammerNewLine(emitter, grammerNewLine);
-    expect(emitter.output).to.be.eql(emitter.eol + emitter.eol);
-  });
-
-  it('combinator : emitGrammerValue should be ok', function () {
-    const combinator = new Combinator();
-    combinator.grammerValue = function (emitter) {
-      emitter.emit('test');
-    };
-    const grammerValue = new GrammerValue();
-    expect(combinator.emitGrammerValue(grammerValue)).to.be.eql('test');
-  });
-
-  it('combinator : grammer should be ok', function () {
-    const combinator = new Combinator();
-    const emitter = new Emitter();
-
-    emitter.output = '';
-    const obj = new ObjectItem('client');
-    expect(function () {
-      combinator.grammer(emitter, obj);
-    }).to.be.throw('Unsupported');
-    expect(console.log.calledWith(obj)).to.be.true;
-
-    expect(function () {
-      combinator.grammer(emitter, new GrammerCondition());
-    }).to.be.throw('Unimpelemented : grammerCondition');
-  });
-});

package/tests/lib.tests.js

@@ -1,269 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const debug = require('../src/lib/debug');
-const mm = require('mm');
-const expect = require('chai').expect;
-const Emitter = require('../src/lib/emitter');
-require('mocha-sinon');
-
-const {
-  _camelCase,
-  _subModelName,
-  _string,
-  _upperFirst,
-  _config,
-  _avoidKeywords,
-  _avoidFuncKeywords,
-  _avoidClassKeywords,
-  _avoidVarKeywords,
-  _modify,
-  _symbol,
-  _toSnakeCase,
-  _toCamelCase,
-  _isSnakeCase
-} = require('../src/lib/helper');
-
-describe('debug should be ok', function () {
-  beforeEach(function () {
-    this.sinon.stub(console, 'log');
-    this.sinon.stub(process, 'exit');
-    this.sinon.stub(fs, 'mkdirSync');
-    this.sinon.stub(fs, 'writeFileSync');
-    this.sinon.stub(fs, 'appendFileSync');
-    this.sinon.stub(fs, 'existsSync');
-  });
-
-  it('dump should be ok', function () {
-    debug.dump(null, 1, '1', 1.11111);
-    expect(console.log.calledWith('foo')).to.be.false;
-    expect(console.log.calledWith(null)).to.be.true;
-    expect(console.log.calledWith(1)).to.be.true;
-    expect(console.log.calledWith('1')).to.be.true;
-    expect(console.log.calledWith(1.11111)).to.be.true;
-    expect(process.exit.calledWith(-1)).to.be.false;
-  });
-
-  it('halt should be ok', function () {
-    debug.halt(null, 1, '1', 1.11111);
-    expect(console.log.calledWith('foo')).to.be.false;
-    expect(console.log.calledWith(null)).to.be.true;
-    expect(console.log.calledWith(1)).to.be.true;
-    expect(console.log.calledWith('1')).to.be.true;
-    expect(console.log.calledWith(1.11111)).to.be.true;
-    expect(process.exit.calledWith(-1)).to.be.true;
-  });
-
-  it('jump should be ok', function () {
-    for (let i = 0; i < 3; i++) {
-      debug.jump(1, `jump output : ${i}`);
-    }
-    expect(console.log.calledWith('jump output : 0')).to.be.false;
-    expect(console.log.calledWith('jump output : 1')).to.be.true;
-    expect(console.log.calledWith('jump output : 2')).to.be.false;
-    expect(process.exit.calledWith(-1)).to.be.true;
-  });
-
-  it('stack should be ok', function () {
-    try {
-      debug.stack('called debug stack with message', 'data1', 'data2');
-    } catch (e) {
-      expect(e.message).to.be.eql('called debug stack with message');
-      expect(console.log.calledWith('called debug stack with message')).to.be.false;
-      expect(console.log.calledWith('data1')).to.be.true;
-      expect(console.log.calledWith('data2')).to.be.true;
-      expect(process.exit.calledWith(-1)).to.be.false;
-    }
-
-    try {
-      debug.stack(1, 'called debug stack without message', 'some data');
-    } catch (e) {
-      expect(e.message).to.be.eql('');
-      expect(console.log.calledWith(1)).to.be.true;
-      expect(console.log.calledWith('called debug stack without message')).to.be.true;
-      expect(console.log.calledWith('some data')).to.be.true;
-      expect(process.exit.calledWith(-1)).to.be.false;
-    }
-  });
-});
-
-describe('emitter should be ok', function () {
-  beforeEach(function () {
-    this.sinon.stub(console, 'log');
-    this.sinon.stub(process, 'exit');
-    this.sinon.stub(fs, 'mkdirSync');
-    this.sinon.stub(fs, 'writeFileSync');
-    this.sinon.stub(fs, 'appendFileSync');
-    this.sinon.stub(fs, 'existsSync');
-  });
-
-  it('indent should be ok', function () {
-    const emitter = new Emitter();
-    expect(emitter.indent(1)).to.be.eql('    ');
-  });
-
-  it('emit should be ok', function () {
-    const emitter = new Emitter();
-    emitter.emit('emit some string');
-    expect(emitter.output).to.be.eql('emit some string');
-  });
-
-  it('emitln should be ok', function () {
-    const emitter = new Emitter();
-    emitter.emitln('emitln some string');
-    expect(emitter.output).to.be.eql('emitln some string' + emitter.eol);
-  });
-
-  it('emits should be ok', function () {
-    const emitter = new Emitter();
-    emitter.emits(1);
-    expect(emitter.output).to.be.eql('');
-    emitter.emits(0, 'row1', 'row2');
-    expect(emitter.output).to.be.eql('row1' + emitter.eol + 'row2' + emitter.eol);
-  });
-
-  it('erase should be ok', function () {
-    const emitter = new Emitter();
-    emitter.emit('full string');
-    emitter.erase(3);
-    expect(emitter.output).to.be.eql('full str');
-  });
-
-  it('savePath should be ok', function () {
-    const emitter = new Emitter({
-      dir: '/tmp/',
-      layer: 'a.b.c',
-      filename: 'filename',
-      ext: '.tmp'
-    });
-    expect(emitter.savePath()).to.be.eql('/tmp/a/b/c/filename.tmp');
-  });
-
-  it('save should be ok', function () {
-    const emitter = new Emitter();
-    try {
-      emitter.save();
-    } catch (e) {
-      expect(e.message).to.be.eql('`option.dir` should not be empty');
-    }
-    emitter.config.dir = '/tmp/';
-    try {
-      emitter.save();
-    } catch (e) {
-      expect(e.message).to.be.eql('filename cannot be empty');
-    }
-    emitter.config.filename = 'filename';
-    emitter.config.ext = '.tmp';
-
-    emitter.emit('test');
-
-    emitter.save();
-    emitter.emit();
-    mm(fs, 'existsSync', function (filename) {
-      return true;
-    });
-    emitter.save(true);
-    mm.restore();
-
-    // show emit info
-    emitter.config.showInfo = true;
-    emitter.emit('test');
-    emitter.save();
-    const filename = emitter.savePath();
-
-    expect(filename).to.be.eql('/tmp/filename.tmp');
-  });
-});
-
-describe('helper tests', function () {
-  it('_upperFirst should be ok', function () {
-    expect(_upperFirst(null)).to.be.eql('');
-  });
-
-  it('_camelCase should be ok', function () {
-    expect(_camelCase('test_camel_case')).to.be.eql('testCamelCase');
-  });
-
-  it('_subModelName should be ok', function () {
-    expect(_subModelName('test.model.name')).to.be.eql('TestModelName');
-  });
-
-  it('_string should be ok', function () {
-    const obj = {
-      string: 'test'
-    };
-    expect(_string(obj)).to.be.eql('test');
-  });
-
-  it('_avoidKeywords should be ok', function () {
-    _config({
-      keywords: {
-        general: 'key',
-        function: ['function'],
-        class: ['class'],
-        param_variables: ['var']
-      }
-    });
-    expect(_avoidKeywords('key')).to.be.eql('key_');
-    expect(_avoidFuncKeywords('key')).to.be.eql('key_');
-    expect(_avoidFuncKeywords('function')).to.be.eql('function_');
-    expect(_avoidClassKeywords('key')).to.be.eql('key_');
-    expect(_avoidClassKeywords('class')).to.be.eql('class_');
-    expect(_avoidVarKeywords('key')).to.be.eql('key_');
-    expect(_avoidVarKeywords('var')).to.be.eql('var_');
-  });
-
-  it('_modify should be ok', function () {
-    _config({
-      modifyOrder: [
-        'PRIVATE',
-        'PROTECTED',
-        'PUBLIC',
-        'FINAL',
-        'ABSTRACT',
-        'STATIC'
-      ]
-    });
-    expect(_modify('PRIVATE')).to.be.eql('private');
-  });
-
-  it('_symbol should be ok', function () {
-    _config({ symbolMap: { 'ASSIGN': '=' } });
-    expect(function () {
-      _symbol('InvalidSymbol');
-    }).to.be.throw('Unsupported symbol : InvalidSymbol');
-
-    expect(_symbol('ASSIGN')).to.be.eql('=');
-  });
-
-  it('_isSnakeCase should be ok', function () {
-    expect(_isSnakeCase('tea_rpc')).to.be.eql(true);
-    expect(_isSnakeCase('tea')).to.be.eql(true);
-    expect(_isSnakeCase('tearpc')).to.be.eql(true);
-    expect(_isSnakeCase('tearpc01')).to.be.eql(true);
-    expect(_isSnakeCase('_tearpc')).to.be.eql(true);
-    expect(_isSnakeCase('teaRpc')).to.be.eql(false);
-    expect(_isSnakeCase('tea-rpc')).to.be.eql(false);
-    expect(_isSnakeCase('tea-Rpc')).to.be.eql(false);
-    expect(_isSnakeCase('tea rpc')).to.be.eql(false);
-    expect(_isSnakeCase('01tearpc')).to.be.eql(false);
-  });
-
-  it('_toSnakeCase should be ok', function () {
-    expect(_toSnakeCase('TestABC')).to.be.eql('test_abc');
-    expect(_toSnakeCase(null)).to.be.eql('');
-    expect(_toSnakeCase('SLS')).to.be.eql('sls');
-    expect(_toSnakeCase('_runtime')).to.be.eql('_runtime');
-    expect(_toSnakeCase('TT123')).to.be.eql('tt123');
-    expect(_toSnakeCase('fooBar')).to.be.eql('foo_bar');
-  });
-
-  it('_toCamelCase should be ok', function () {
-    expect(_toCamelCase('test_abc')).to.be.eql('TestAbc');
-    expect(_toCamelCase(null)).to.be.eql('');
-    expect(_toCamelCase('sls')).to.be.eql('Sls');
-    expect(_toCamelCase('_runtime')).to.be.eql('Runtime');
-    expect(_toCamelCase('tt_123')).to.be.eql('Tt123');
-    expect(_toCamelCase('foo_bar')).to.be.eql('FooBar');
-  });
-});