@darabonba/python-generator 2.0.0 → 2.0.2

package/src/langs/common/combinator.js

@@ -1,193 +0,0 @@
-'use strict';
-
-const debug = require('../../lib/debug');
-const Emitter = require('../../lib/emitter');
-
-const {
-  Grammer,
-  GrammerThrows,
-
-  Behavior,
-  PropItem,
-  AnnotationItem,
-  ObjectItem,
-} = require('./items');
-
-const {
-  _config,
-  _upperFirst,
-  _lowerFirst,
-} = require('../../lib/helper.js');
-
-class BaseCombinator {
-  constructor(config = {}, imports = {}) {
-    this.level = 0;
-    this.eol = '';
-
-    this.includeList = [];
-    this.includeModelList = [];
-    this.includeSet = [];
-
-    this.config = config;
-    this.imports = imports;
-
-    this.requirePackage = imports.requirePackage;
-    this.thirdPackageNamespace = imports.thirdPackageNamespace;
-    this.thirdPackageClient = imports.thirdPackageClient;
-    this.thirdPackageClientAlias = imports.thirdPackageClientAlias;
-    this.thirdPackageModel = imports.thirdPackageModel;
-    this.typedef = imports.typedef;
-    this.importsTypedef = imports.importsTypedef;
-    this.additionalPackage = imports.additionalPackage;
-
-    _config(this.config);
-  }
-
-  combine(objects = []) {
-    if (objects.some(Object => !(Object instanceof ObjectItem))) {
-      throw new Error('Only supported ObjectItem.');
-    }
-  }
-
-  combineOutputParts(config, outputParts) {
-    const globalEmitter = new Emitter(config);
-    globalEmitter.emit(outputParts.head);
-    globalEmitter.emit(outputParts.body);
-    globalEmitter.emit(outputParts.foot);
-    globalEmitter.save();
-  }
-
-  coreClass(objName) {
-    const key = _lowerFirst(objName.split('$').join(''));
-    if (this.config.tea[key]) {
-      return this.config.tea[key].name;
-    }
-    debug.stack('Unsupported core class name : ' + objName);
-  }
-
-  resolveNotes(nodes) {
-    let notes = {};
-    nodes.filter(node => node instanceof PropItem).map(prop => {
-      if (prop.notes.length > 0) {
-        prop.notes.forEach(note => {
-          note.belong = prop.index;
-          note.prop = prop.name;
-          if (typeof notes[note.key] === 'undefined') {
-            notes[note.key] = [];
-          }
-          notes[note.key].push(note);
-        });
-      }
-    });
-    return notes;
-  }
-
-  emitAnnotations(emitter, annotations) {
-    annotations.forEach(annotation => {
-      this.emitAnnotation(emitter, annotation);
-    });
-  }
-
-  findThrows(grammer, set = []) {
-    if (grammer.body) {
-      grammer.body.filter(node => {
-        if (node instanceof GrammerThrows) {
-          set.push(node);
-        } else if (node.body) {
-          this.findThrows(node, set);
-        }
-      });
-    }
-    return set;
-  }
-
-  init(ast) {
-    throw new Error('unimpelemented');
-  }
-
-  levelUp() {
-    this.level++;
-    return this.level;
-  }
-
-  levelDown() {
-    this.level--;
-    return this.level;
-  }
-
-  addModelInclude(modelName) {
-    throw new Error('unimpelemented');
-  }
-
-  addInclude(include) {
-    throw new Error('unimpelemented');
-  }
-
-  systemfunc(emitter, gram) {
-    let tmp = [];
-    gram.path.forEach(path => {
-      tmp.push(_upperFirst(path.name));
-    });
-    if (tmp.length === 0) {
-      debug.stack('Invalid path. path list cannot be empty.');
-    }
-    let systemFunc = 'sys' + tmp.join('');
-    if (this[systemFunc]) {
-      this[systemFunc].apply(this, [emitter, gram]);
-    } else {
-      debug.stack(`unimpelemented ${systemFunc}(emitter, gram){} method\n`, gram);
-    }
-  }
-
-  grammer(emit, gram, eol = true, newLine = true) {
-    if (gram instanceof AnnotationItem) {
-      this.emitAnnotation(emit, gram);
-      return;
-    }
-
-    let emitter = new Emitter();
-    let method = null;
-    if (gram instanceof Behavior) {
-      method = gram.name;
-    } else if (gram instanceof Grammer) {
-      method = _lowerFirst(gram.constructor.name);
-    } else {
-      debug.stack('Unsupported', gram);
-    }
-    if (typeof this[method] !== 'undefined') {
-      this[method].call(this, emitter, gram);
-    } else {
-      debug.stack('Unimpelemented : ' + method);
-    }
-    if (gram.eol !== null) {
-      eol = gram.eol;
-    }
-    if (gram.newLine !== null) {
-      newLine = gram.newLine;
-    }
-    if (newLine) {
-      emit.emit('', this.level);
-    }
-    emit.emit(emitter.output);
-    if (eol) {
-      emit.emitln(this.eol);
-    }
-    emitter = null;
-  }
-
-  grammerNewLine(emitter, gram) {
-    let number = gram.number;
-    while (number > 0) {
-      emitter.emitln();
-      number--;
-    }
-  }
-
-  emitGrammerValue(gram) {
-    let emitter = new Emitter();
-    this.grammerValue(emitter, gram);
-    return emitter.output;
-  }
-}
-
-module.exports = BaseCombinator;

package/src/langs/common/config.js

@@ -1,60 +0,0 @@
-'use strict';
-
-module.exports = {
-  indent: '    ',
-  ext: '.tea',
-  resolvePathByPackage: false,
-  keywords: {
-    general: [],
-    function: [],
-    class: [],
-    param_variables: []
-  },
-  typeMap: {},
-  symbolMap: {},
-  modifyOrder: [],
-  exceptionMap: {},
-  model: {
-    include: [],
-    constructor: {
-      params: []
-    }
-  },
-  client: {
-    filename: 'client',
-    include: []
-  },
-  generateFileInfo: 'This file is auto-generated, don\'t edit it. Thanks.',
-  response: '_response',
-  request: '_request',
-  runtime: '_runtime',
-  baseClient: [],
-  tea: {
-    core: {
-      name: 'TeaCore',
-      doAction: 'doAction',
-      allowRetry: 'allowRetry',
-      sleep: 'sleep',
-      getBackoffTime: 'getBackoffTime',
-      isRetryable: 'isRetryable'
-    },
-    model: {
-      name: 'TeaModel'
-    },
-    converter: {
-      name: 'TeaConverter'
-    },
-    response: {
-      name: 'TeaResponse'
-    },
-    request: {
-      name: 'TeaRequest'
-    },
-    exception: {
-      name: 'TeaException'
-    },
-    exceptionUnretryable: {
-      name: 'TeaUnretryableException'
-    },
-  }
-};

package/src/langs/common/enum.js

@@ -1,179 +0,0 @@
-'use strict';
-
-const Enum = require('enum');
-
-class SymbolEnum extends Enum {
-  constructor() {
-    super([
-      'ASSIGN',
-      'EQ',
-      'NOT',
-      'AND',
-      'OR',
-      'PLUS',
-      'SUB',
-      'MULTI',
-      'DIV',
-      'POWER',
-      'GREATER',
-      'GREATER_EQ',
-      'LESS',
-      'LESS_EQ',
-      'REVERSE',
-      'CONCAT',
-      'JUDGE',
-      'RISK'
-    ], { name: 'symbol', ignoreCase: true });
-  }
-  assign() {
-    return this.ASSIGN.key;
-  }
-  eq() {
-    return this.EQ.key;
-  }
-  not() {
-    return this.NOT.key;
-  }
-  and() {
-    return this.AND.key;
-  }
-  or() {
-    return this.OR.key;
-  }
-  plus() {
-    return this.PLUS.key;
-  }
-  multi() {
-    return this.MULTI.key;
-  }
-  div() {
-    return this.DIV.key;
-  }
-  power() {
-    return this.POWER.key;
-  }
-  greater() {
-    return this.GREATER.key;
-  }
-  greaterEq() {
-    return this.GREATER_EQ.key;
-  }
-  less() {
-    return this.LESS.key;
-  }
-  lessEq() {
-    return this.LESS_EQ.key;
-  }
-  reverse() {
-    return this.REVERSE.key;
-  }
-  concat() {
-    return this.CONCAT.key;
-  }
-  judge() {
-    return this.JUDGE.key;
-  }
-  risk() {
-    return this.RISK.key;
-  }
-}
-
-class ModifyEnum extends Enum {
-  constructor() {
-    super([
-      'ASYNC',
-      'PRIVATE',
-      'PROTECTED',
-      'INTERNAL',
-      'PUBLIC',
-      'FINAL',
-      'ABSTRACT',
-      'STATIC'
-    ], { name: 'modify', ignoreCase: true });
-  }
-  async() {
-    return this.ASYNC.key;
-  }
-  private() {
-    return this.PRIVATE.key;
-  }
-  protected() {
-    return this.PROTECTED.key;
-  }
-  internal() {
-    return this.INTERNAL.key;
-  }
-  public() {
-    return this.PUBLIC.key;
-  }
-  final() {
-    return this.FINAL.key;
-  }
-  abstract() {
-    return this.ABSTRACT.key;
-  }
-  static() {
-    return this.STATIC.key;
-  }
-}
-
-class ExceptionEnum extends Enum {
-  constructor() {
-    super([
-      'BASE',
-    ], { name: 'exceptions', ignoreCase: true });
-  }
-
-  base() {
-    return this.BASE.key;
-  }
-}
-
-class TypeEnum extends Enum {
-  constructor() {
-    super([
-      'any',
-      'anyReference',
-      'void',
-      'null',
-      'empty',
-      'char',
-      'string',
-      'boolean',
-      'number',
-      'integer',
-      'uint8',
-      'int8',
-      'uint16',
-      'int16',
-      'uint32',
-      'int32',
-      'uint64',
-      'int64',
-      'long',
-      'ulong',
-      'float',
-      'double',
-      'single',
-      'decimal',
-      'byte',
-      'map',
-      'list',
-      'object',
-      'readable',
-      'writable'
-    ], { name: 'types', ignoreCase: true });
-  }
-}
-
-const Symbol = new SymbolEnum();
-const Modify = new ModifyEnum();
-const Exceptions = new ExceptionEnum();
-const Types = new TypeEnum();
-
-module.exports = {
-  Symbol,
-  Modify,
-  Exceptions,
-  Types
-};