getFieldType()

in lib/semantic.js [1802:1923]
65 lines of code
11 McCabe index (conditional complexity)

  getFieldType(find, modelName, moduleName) {
    if (find.fieldValue.fieldType === 'map') {
      if (find.fieldValue.valueType.idType === 'model') {
        return {
          type: 'map',
          keyType: _basic(find.fieldValue.keyType.lexeme),
          valueType: _model(find.fieldValue.valueType.lexeme, moduleName)
        };
      }
      if (find.fieldValue.valueType.type === 'array') {
        return {
          type: 'map',
          keyType: _basic(find.fieldValue.keyType.lexeme),
          valueType: this.getType(find.fieldValue.valueType, moduleName)
        };
      }
      if (find.fieldValue.valueType.type === 'moduleModel') {
        const [mainId, ...rest] = find.fieldValue.valueType.path;
        let filedName = rest.map((tag) => {
          return tag.lexeme;
        }).join('.');
        return {
          type: 'map',
          keyType: _basic(find.fieldValue.keyType.lexeme),
          valueType: this.getModel(filedName, mainId.lexeme)
        };
      }
      return {
        type: 'map',
        keyType: _basic(find.fieldValue.keyType.lexeme),
        valueType: _basic(find.fieldValue.valueType.lexeme)
      };
    }

    if (find.fieldValue.fieldType === 'entry') {
      if (find.fieldValue.valueType.idType === 'model') {
        return {
          type: 'entry',
          valueType: this.getModel(find.fieldValue.valueType.lexeme, moduleName)
        };
      }
      if (find.fieldValue.valueType.type === 'array') {
        return {
          type: 'entry',
          valueType: this.getType(find.fieldValue.valueType, moduleName)
        };
      }
      return {
        type: 'entry',
        valueType: _basic(find.fieldValue.valueType.lexeme)
      };
    }

    if (find.fieldValue.type === 'modelBody') {
      return this.getModel([modelName, find.fieldName.lexeme].join('.'), moduleName);
    }

    if (find.fieldValue.fieldType === 'array') {
      return this.getArrayFiledType(find.fieldValue, find.fieldValue.itemType, moduleName);
    }
    
    if (find.fieldValue.fieldType.tag === Tag.ID) {
      const id = find.fieldValue.fieldType.lexeme;
      if (this.models.has(id)) {
        return this.getModel(id, moduleName);
      }

      if (this.dependencies.has(id)) {
        return {
          type: 'module_instance',
          name: id
        };
      }

      if (this.enums.has(id)) {
        return _enum(id, moduleName);
      }

      if (this.typedefs.has(id)) {
        return _typedef(id, moduleName);
      }

      if(builtin.has(id)) {
        return this.getModel(find.fieldValue.fieldType.lexeme);
      }

      return this.getModel(find.fieldValue.fieldType.lexeme, moduleName);
    }

    if (find.fieldValue.fieldType.type === 'moduleModel') {
      const [mainId, ...rest] = find.fieldValue.fieldType.path;
      let filedName = rest.map((tag) => {
        return tag.lexeme;
      }).join('.');
      return this.getModel(filedName, mainId.lexeme);
    }

    if (find.fieldValue.fieldType.type === 'moduleEnum') {
      const [mainId, ...rest] = find.fieldValue.fieldType.path;
      let filedName = rest.map((tag) => {
        return tag.lexeme;
      }).join('.');
      return _enum(filedName, mainId.lexeme);
    }

    if (find.fieldValue.fieldType.type === 'moduleTypedef') {
      const [mainId, ...rest] = find.fieldValue.fieldType.path;
      let filedName = rest.map((tag) => {
        return tag.lexeme;
      }).join('.');
      return _typedef(filedName, mainId.lexeme);
    }

    if (find.fieldValue.fieldType.type === 'subModel') {
      let modelName = find.fieldValue.fieldType.path.map((tag) => {
        return tag.lexeme;
      }).join('.');
      return this.getModel(modelName);
    }

    return _basic(find.fieldValue.fieldType);
  }