code-analyzer.js

/*
 * Copyright (c) 2014-2018 MKLab. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 */

const fs = require('fs')
const path = require('path')
const java7 = require('./grammar/java7')

// Java Primitive Types
var javaPrimitiveTypes = [
  'void',
  'byte',
  'short',
  'int',
  'long',
  'float',
  'double',
  'boolean',
  'char',
  'Byte',
  'Double',
  'Float',
  'Integer',
  'Long',
  'Short',
  'String',
  'Character',
  'java.lang.Byte',
  'java.lang.Double',
  'java.lang.Float',
  'java.lang.Integer',
  'java.lang.Long',
  'java.lang.Short',
  'java.lang.String',
  'java.lang.Character'
]

// Java Collection Types
var javaCollectionTypes = [
  'Collection',
  'Set',
  'SortedSet',
  'NavigableSet',
  'HashSet',
  'TreeSet',
  'LinkedHashSet',
  'List',
  'ArrayList',
  'LinkedList',
  'Deque',
  'ArrayDeque',
  'Queue'
]

// Java Collection Types (full names)
var javaUtilCollectionTypes = javaCollectionTypes.map(c => { return 'java.util.' + c })

/**
 * Java Code Analyzer
 */
class JavaCodeAnalyzer {

  /**
   * @constructor
   */
  constructor () {
    /** @member {type.UMLModel} */
    this._root = new type.UMLModel()
    this._root.name = 'JavaReverse'

    /** @member {Array.<File>} */
    this._files = []

    /** @member {Object} */
    this._currentCompilationUnit = null

    /**
     * @member {{classifier:type.UMLClassifier, node: Object, kind:string}}
     */
    this._extendPendings = []

    /**
     * @member {{classifier:type.UMLClassifier, node: Object}}
     */
    this._implementPendings = []

    /**
     * @member {{classifier:type.UMLClassifier, association: type.UMLAssociation, node: Object}}
     */
    this._associationPendings = []

    /**
     * @member {{operation:type.UMLOperation, node: Object}}
     */
    this._throwPendings = []

    /**
     * @member {{namespace:type.UMLModelElement, feature:type.UMLStructuralFeature, node: Object}}
     */
    this._typedFeaturePendings = []
  }

  /**
   * Add File to Reverse Engineer
   * @param {File} file
   */
  addFile (file) {
    this._files.push(file)
  }

  /**
   * Analyze all files.
   * @param {Object} options
   */
  analyze (options) {
    // Perform 1st Phase
    this.performFirstPhase(options)

    // Perform 2nd Phase
    this.performSecondPhase(options)

    // Load To Project
    var writer = new app.repository.Writer()
    writer.writeObj('data', this._root)
    var json = writer.current.data
    app.project.importFromJson(app.project.getProject(), json)

    // Generate Diagrams
    this.generateDiagrams(options)
    console.log('[Java] done.')
  }

  /**
   * Perform First Phase
   *   - Create Packages, Classes, Interfaces, Enums, AnnotationTypes.
   *
   * @param {Object} options
   */
  performFirstPhase (options) {
    this._files.forEach(file => {
      var data = fs.readFileSync(file, 'utf8')
      try {
        /* Not processing empty file @author Rtfsc8(rtfsc8@rtfsc8.top) */
        if (!!!data) {
            return;
        }
        var ast = java7.parse(data)
        this._currentCompilationUnit = ast
        this._currentCompilationUnit.file = file
        this.translateCompilationUnit(options, this._root, ast)
      } catch (ex) {
        console.error('[Java] Failed to parse - ' + file)
        console.error(ex)
      }
    })
  }

  /**
   * Perform Second Phase
   *   - Create Generalizations
   *   - Create InterfaceRealizations
   *   - Create Fields or Associations
   *   - Resolve Type References
   *
   * @param {Object} options
   */
  performSecondPhase (options) {
    var i, len, j, len2, _typeName, _type, _itemTypeName, _itemType, _pathName

    // Create Generalizations
    //     if super type not found, create a Class correspond to the super type.
    for (i = 0, len = this._extendPendings.length; i < len; i++) {
      var _extend = this._extendPendings[i]
      _typeName = _extend.node.qualifiedName.name

      _type = this._findType(_extend.classifier, _typeName, _extend.compilationUnitNode)
      if (!_type) {
        _pathName = this._toPathName(_typeName)
        if (_extend.kind === 'interface') {
          _type = this._ensureInterface(this._root, _pathName)
        } else {
          _type = this._ensureClass(this._root, _pathName)
        }
      }

      var generalization = new type.UMLGeneralization()
      generalization._parent = _extend.classifier
      generalization.source = _extend.classifier
      generalization.target = _type
      _extend.classifier.ownedElements.push(generalization)
    }

    // Create InterfaceRealizations
    //     if super interface not found, create a Interface correspond to the super interface
    for (i = 0, len = this._implementPendings.length; i < len; i++) {
      var _implement = this._implementPendings[i]
      _typeName = _implement.node.qualifiedName.name
      _type = this._findType(_implement.classifier, _typeName, _implement.compilationUnitNode)
      if (!_type) {
        _pathName = this._toPathName(_typeName)
        _type = this._ensureInterface(this._root, _pathName)
      }
      var realization = new type.UMLInterfaceRealization()
      realization._parent = _implement.classifier
      realization.source = _implement.classifier
      realization.target = _type
      _implement.classifier.ownedElements.push(realization)
    }

    // Create Associations
    for (i = 0, len = this._associationPendings.length; i < len; i++) {
      var _asso = this._associationPendings[i]
      _typeName = _asso.node.type.qualifiedName.name
      _type = this._findType(_asso.classifier, _typeName, _asso.node.compilationUnitNode)
      _itemTypeName = this._isGenericCollection(_asso.node.type, _asso.node.compilationUnitNode)
      if (_itemTypeName) {
        _itemType = this._findType(_asso.classifier, _itemTypeName, _asso.node.compilationUnitNode)
      } else {
        _itemType = null
      }

      // if type found, add as Association
      if (_type || _itemType) {
        for (j = 0, len2 = _asso.node.variables.length; j < len2; j++) {
          var variableNode = _asso.node.variables[j]

          // Create Association
          var association = new type.UMLAssociation()
          association._parent = _asso.classifier
          _asso.classifier.ownedElements.push(association)

          // Set End1
          association.end1.reference = _asso.classifier
          association.end1.name = ''
          association.end1.visibility = type.UMLModelElement.VK_PACKAGE
          association.end1.navigable = false

          // Set End2
          if (_itemType) {
            association.end2.reference = _itemType
            association.end2.multiplicity = '*'
            this._addTag(association.end2, type.Tag.TK_STRING, 'collection', _asso.node.type.qualifiedName.name)
          } else {
            association.end2.reference = _type
          }
          association.end2.name = variableNode.name
          association.end2.visibility = this._getVisibility(_asso.node.modifiers)
          association.end2.navigable = true

          // Final Modifier
          if (_asso.node.modifiers && _asso.node.modifiers.includes('final')) {
            association.end2.isReadOnly = true
          }

          // Static Modifier
          if (_asso.node.modifiers && _asso.node.modifiers.includes('static')) {
            this._addTag(association.end2, type.Tag.TK_BOOLEAN, 'static', true)
          }

          // Volatile Modifier
          if (_asso.node.modifiers && _asso.node.modifiers.includes('volatile')) {
            this._addTag(association.end2, type.Tag.TK_BOOLEAN, 'volatile', true)
          }

          // Transient Modifier
          if (_asso.node.modifiers && _asso.node.modifiers.includes('transient')) {
            this._addTag(association.end2, type.Tag.TK_BOOLEAN, 'transient', true)
          }
        }
        // if type not found, add as Attribute
      } else {
        this.translateFieldAsAttribute(options, _asso.classifier, _asso.node)
      }
    }

    // Assign Throws to Operations
    for (i = 0, len = this._throwPendings.length; i < len; i++) {
      var _throw = this._throwPendings[i]
      _typeName = _throw.node.name
      _type = this._findType(_throw.operation, _typeName, _throw.compilationUnitNode)
      if (!_type) {
        _pathName = this._toPathName(_typeName)
        _type = this._ensureClass(this._root, _pathName)
      }
      _throw.operation.raisedExceptions.push(_type)
    }

    // Resolve Type References
    for (i = 0, len = this._typedFeaturePendings.length; i < len; i++) {
      var _typedFeature = this._typedFeaturePendings[i]
      //Fix bug: some reverse code error like qualifiedName attribute undefined
      if (!!!_typedFeature.node.type.qualifiedName) {
        continue;
      }
      _typeName = _typedFeature.node.type.qualifiedName.name

      // Find type and assign
      _type = this._findType(_typedFeature.namespace, _typeName, _typedFeature.node.compilationUnitNode)

      // if type is exists
      if (_type) {
        _typedFeature.feature.type = _type
        // if type is not exists
      } else {
        // if type is generic collection type (e.g. java.util.List<String>)
        _itemTypeName = this._isGenericCollection(_typedFeature.node.type, _typedFeature.node.compilationUnitNode)
        if (_itemTypeName) {
          _typeName = _itemTypeName
          _typedFeature.feature.multiplicity = '*'
          this._addTag(_typedFeature.feature, type.Tag.TK_STRING, 'collection', _typedFeature.node.type.qualifiedName.name)
        }

        // if type is primitive type
        if (javaPrimitiveTypes.includes(_typeName)) {
          _typedFeature.feature.type = _typeName
          // otherwise
        } else {
          _pathName = this._toPathName(_typeName)
          var _newClass = this._ensureClass(this._root, _pathName)
          _typedFeature.feature.type = _newClass
        }
      }

      // Translate type's arrayDimension to multiplicity
      if (_typedFeature.node.type.arrayDimension && _typedFeature.node.type.arrayDimension.length > 0) {
        var _dim = []
        for (j = 0, len2 = _typedFeature.node.type.arrayDimension.length; j < len2; j++) {
          _dim.push('*')
        }
        _typedFeature.feature.multiplicity = _dim.join(',')
      }
    }
  }

  /**
   * Generate Diagrams (Type Hierarchy, Package Structure, Package Overview)
   * @param {Object} options
   */
  generateDiagrams (options) {
    var baseModel = app.repository.get(this._root._id)
    if (options.packageStructure) {
      app.commands.execute('diagram-generator:package-structure', baseModel, true)
    }
    if (options.typeHierarchy) {
      app.commands.execute('diagram-generator:type-hierarchy', baseModel, true)
    }
    if (options.packageOverview) {
      baseModel.traverse(elem => {
        if (elem instanceof type.UMLPackage) {
          app.commands.execute('diagram-generator:overview', elem, true)
        }
      })
    }
  }

  /**
   * Convert string type name to path name (Array of string)
   * @param {string} typeName
   * @return {Array.<string>} pathName
   */
  _toPathName (typeName) {
    var pathName = (typeName.indexOf('.') > 0 ? typeName.trim().split('.') : null)
    if (!pathName) {
      pathName = [ typeName ]
    }
    return pathName
  }

  /**
   * Find Type.
   *
   * @param {type.Model} namespace
   * @param {string|Object} type Type name string or type node.
   * @param {Object} compilationUnitNode To search type with import statements.
   * @return {type.Model} element correspond to the type.
   */
  _findType (namespace, type, compilationUnitNode) {
    var typeName, pathName
    var _type = null

    if (type.node === 'Type') {
      typeName = type.qualifiedName.name
    } else if (typeof type === 'string') {
      typeName = type
    }

    pathName = this._toPathName(typeName)

    // 1. Lookdown from context
    if (pathName.length > 1) {
      _type = namespace.lookdown(pathName)
    } else {
      _type = namespace.findByName(typeName)
    }

    // 2. Lookup from context
    if (!_type) {
      _type = namespace.lookup(typeName, null, this._root)
    }

    // 3. Find from imported namespaces
    if (!_type) {
      if (compilationUnitNode.imports) {
        var i, len
        for (i = 0, len = compilationUnitNode.imports.length; i < len; i++) {
          var _import = compilationUnitNode.imports[i]
          // Find in wildcard imports (e.g. import java.lang.*)
          if (_import.wildcard) {
            var _namespace = this._root.lookdown(_import.qualifiedName.name)
            if (_namespace) {
              _type = _namespace.findByName(typeName)
            }
            // Find in import exact matches (e.g. import java.lang.String)
          } else {
            _type = this._root.lookdown(_import.qualifiedName.name)
          }
        }
      }
    }

    // 4. Lookdown from Root
    if (!_type) {
      if (pathName.length > 1) {
        _type = this._root.lookdown(pathName)
      } else {
        _type = this._root.findByName(typeName)
      }
    }

    return _type
  }

  /**
   * Return visiblity from modifiers
   *
   * @param {Array.<string>} modifiers
   * @return {string} Visibility constants for UML Elements
   */
  _getVisibility (modifiers) {
    if (modifiers) {
      if (modifiers.includes('public')) {
        return type.UMLModelElement.VK_PUBLIC
      } else if (modifiers.includes('protected')) {
        return type.UMLModelElement.VK_PROTECTED
      } else if (modifiers.includes('private')) {
        return type.UMLModelElement.VK_PRIVATE
      }
    }
    return type.UMLModelElement.VK_PACKAGE
  }

  /**
   * Add a Tag
   * @param {type.Model} elem
   * @param {string} kind Kind of Tag
   * @param {string} name
   * @param {?} value Value of Tag
   */
  _addTag (elem, kind, name, value) {
    var tag = new type.Tag()
    tag._parent = elem
    tag.name = name
    tag.kind = kind
    switch (kind) {
    case type.Tag.TK_STRING:
      tag.value = value
      break
    case type.Tag.TK_BOOLEAN:
      tag.checked = value
      break
    case type.Tag.TK_NUMBER:
      tag.number = value
      break
    case type.Tag.TK_REFERENCE:
      tag.reference = value
      break
    case type.Tag.TK_HIDDEN:
      tag.value = value
      break
    }
    elem.tags.push(tag)
  }

  /**
   * Return the package of a given pathNames. If not exists, create the package.
   * @param {type.Model} namespace
   * @param {Array.<string>} pathNames
   * @return {type.Model} Package element corresponding to the pathNames
   */
  _ensurePackage (namespace, pathNames) {
    if (pathNames.length > 0) {
      var name = pathNames.shift()
      if (name && name.length > 0) {
        var elem = namespace.findByName(name)
        if (elem !== null) {
          // Package exists
          if (pathNames.length > 0) {
            return this._ensurePackage(elem, pathNames)
          } else {
            return elem
          }
        } else {
          // Package not exists, then create one.
          var _package = new type.UMLPackage()
          namespace.ownedElements.push(_package)
          _package._parent = namespace
          _package.name = name
          if (pathNames.length > 0) {
            return this._ensurePackage(_package, pathNames)
          } else {
            return _package
          }
        }
      }
    } else {
      return namespace
    }
  }

  /**
  * Return the class of a given pathNames. If not exists, create the class.
  * @param {type.Model} namespace
  * @param {Array.<string>} pathNames
  * @return {type.Model} Class element corresponding to the pathNames
  */
  _ensureClass (namespace, pathNames) {
    if (pathNames.length > 0) {
      var _className = pathNames.pop()
      var _package = this._ensurePackage(namespace, pathNames)
      var _class = _package.findByName(_className)
      if (!_class) {
        _class = new type.UMLClass()
        _class._parent = _package
        _class.name = _className
        _class.visibility = type.UMLModelElement.VK_PUBLIC
        _package.ownedElements.push(_class)
      }
      return _class
    }
    return null
  }

  /**
   * Return the interface of a given pathNames. If not exists, create the interface.
   * @param {type.Model} namespace
   * @param {Array.<string>} pathNames
   * @return {type.Model} Interface element corresponding to the pathNames
   */
  _ensureInterface (namespace, pathNames) {
    if (pathNames.length > 0) {
      var _interfaceName = pathNames.pop()
      var _package = this._ensurePackage(namespace, pathNames)
      var _interface = _package.findByName(_interfaceName)
      if (!_interface) {
        _interface = new type.UMLInterface()
        _interface._parent = _package
        _interface.name = _interfaceName
        _interface.visibility = type.UMLModelElement.VK_PUBLIC
        _package.ownedElements.push(_interface)
      }
      return _interface
    }
    return null
  }

  /**
   * Test a given type is a generic collection or not
   * @param {Object} typeNode
   * @return {string} Collection item type name
   */
  _isGenericCollection (typeNode, compilationUnitNode) {
    if (typeNode.qualifiedName.typeParameters && typeNode.qualifiedName.typeParameters.length > 0) {
      var _collectionType = typeNode.qualifiedName.name
      var _itemType = typeNode.qualifiedName.typeParameters[0].name

      // Used Full name (e.g. java.util.List)
      if (javaUtilCollectionTypes.includes(_collectionType)) {
        return _itemType
      }

      // Used name with imports (e.g. List and import java.util.List or java.util.*)
      if (javaCollectionTypes.includes(_collectionType)) {
        if (compilationUnitNode.imports) {
          var i, len
          for (i = 0, len = compilationUnitNode.imports.length; i < len; i++) {
            var _import = compilationUnitNode.imports[i]

            // Full name import (e.g. import java.util.List)
            if (_import.qualifiedName.name === 'java.util.' + _collectionType) {
              return _itemType
            }

            // Wildcard import (e.g. import java.util.*)
            if (_import.qualifiedName.name === 'java.util' && _import.wildcard) {
              return _itemType
            }
          }
        }
      }
    }
    return null
  }

  /**
   * Translate Java CompilationUnit Node.
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} compilationUnitNode
   */
  translateCompilationUnit (options, namespace, compilationUnitNode) {
    var _namespace = namespace

    if (compilationUnitNode['package']) {
      var _package = this.translatePackage(options, namespace, compilationUnitNode['package'])
      if (_package !== null) {
        _namespace = _package
      }
    }

    // Translate Types
    this.translateTypes(options, _namespace, compilationUnitNode.types)
  }

  /**
   * Translate Type Nodes
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Array.<Object>} typeNodeArray
   */
  translateTypes (options, namespace, typeNodeArray) {
    var i, len
    if (Array.isArray(typeNodeArray) && typeNodeArray.length > 0) {
      for (i = 0, len = typeNodeArray.length; i < len; i++) {
        var typeNode = typeNodeArray[i]
        switch (typeNode.node) {
        case 'Class':
          this.translateClass(options, namespace, typeNode)
          break
        case 'Interface':
          this.translateInterface(options, namespace, typeNode)
          break
        case 'Enum':
          this.translateEnum(options, namespace, typeNode)
          break
        case 'AnnotationType':
          this.translateAnnotationType(options, namespace, typeNode)
          break
        }
      }
    }
  }

  /**
   * Translate Java Package Node.
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} compilationUnitNode
   */
  translatePackage (options, namespace, packageNode) {
    if (packageNode && packageNode.qualifiedName && packageNode.qualifiedName.name) {
      var pathNames = packageNode.qualifiedName.name.split('.')
      return this._ensurePackage(namespace, pathNames)
    }
    return null
  }

  /**
   * Translate Members Nodes
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Array.<Object>} memberNodeArray
   */
  translateMembers (options, namespace, memberNodeArray) {
    var i, len
    if (Array.isArray(memberNodeArray) && memberNodeArray.length > 0) {
      for (i = 0, len = memberNodeArray.length; i < len; i++) {
        var memberNode = memberNodeArray[i]
        if (memberNode && (typeof memberNode.node === 'string')) {
          var visibility = this._getVisibility(memberNode.modifiers)

          // Generate public members only if publicOnly == true
          if (options.publicOnly && visibility !== type.UMLModelElement.VK_PUBLIC) {
            continue
          }

          memberNode.compilationUnitNode = this._currentCompilationUnit

          switch (memberNode.node) {
          case 'Field':
            if (options.association) {
              this.translateFieldAsAssociation(options, namespace, memberNode)
            } else {
              this.translateFieldAsAttribute(options, namespace, memberNode)
            }
            break
          case 'Constructor':
            this.translateMethod(options, namespace, memberNode, true)
            break
          case 'Method':
            this.translateMethod(options, namespace, memberNode)
            break
          case 'EnumConstant':
            this.translateEnumConstant(options, namespace, memberNode)
            break
          }
        }
      }
    }
  }

  /**
   * Translate Java Type Parameter Nodes.
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} typeParameterNodeArray
   */
  translateTypeParameters (options, namespace, typeParameterNodeArray) {
    if (Array.isArray(typeParameterNodeArray)) {
      var i, len, _typeParam
      for (i = 0, len = typeParameterNodeArray.length; i < len; i++) {
        _typeParam = typeParameterNodeArray[i]
        if (_typeParam.node === 'TypeParameter') {
          var _templateParameter = new type.UMLTemplateParameter()
          _templateParameter._parent = namespace
          _templateParameter.name = _typeParam.name
          if (_typeParam.type) {
            _templateParameter.parameterType = _typeParam.type
          }
          namespace.templateParameters.push(_templateParameter)
        }
      }
    }
  }

  /**
   * Translate Java Class Node.
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} compilationUnitNode
   */
  translateClass (options, namespace, classNode) {
    var i, len, _class

    // Create Class
    _class = new type.UMLClass()
    _class._parent = namespace
    _class.name = classNode.name

    // Access Modifiers
    _class.visibility = this._getVisibility(classNode.modifiers)

    // Abstract Class
    if (classNode.modifiers && classNode.modifiers.includes('abstract')) {
      _class.isAbstract = true
    }

    // Final Class
    if (classNode.modifiers && classNode.modifiers.includes('final')) {
      _class.isFinalSpecialization = true
      _class.isLeaf = true
    }

    // JavaDoc
    if (classNode.comment) {
      _class.documentation = classNode.comment
    }

    namespace.ownedElements.push(_class)

    // Register Extends for 2nd Phase Translation
    if (classNode['extends']) {
      var _extendPending = {
        classifier: _class,
        node: classNode['extends'],
        kind: 'class',
        compilationUnitNode: this._currentCompilationUnit
      }
      this._extendPendings.push(_extendPending)
    }

    // - 1) 타입이 소스에 있는 경우 --> 해당 타입으로 Generalization 생성
    // - 2) 타입이 소스에 없는 경우 (e.g. java.util.ArrayList) --> 타입을 생성(어디에?)한 뒤 Generalization 생성
    // 모든 타입이 생성된 다음에 Generalization (혹은 기타 Relationships)이 연결되어야 하므로, 어딘가에 등록한 다음이 2nd Phase에서 처리.

    // Register Implements for 2nd Phase Translation
    if (classNode['implements']) {
      for (i = 0, len = classNode['implements'].length; i < len; i++) {
        var _impl = classNode['implements'][i]
        var _implementPending = {
          classifier: _class,
          node: _impl,
          compilationUnitNode: this._currentCompilationUnit
        }
        this._implementPendings.push(_implementPending)
      }
    }
    // Translate Type Parameters
    this.translateTypeParameters(options, _class, classNode.typeParameters)
    // Translate Types
    this.translateTypes(options, _class, classNode.body)
    // Translate Members
    this.translateMembers(options, _class, classNode.body)
  }

  /**
   * Translate Java Interface Node.
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} interfaceNode
   */
  translateInterface (options, namespace, interfaceNode) {
    var i, len, _interface

    // Create Interface
    _interface = new type.UMLInterface()
    _interface._parent = namespace
    _interface.name = interfaceNode.name
    _interface.visibility = this._getVisibility(interfaceNode.modifiers)

    // JavaDoc
    if (interfaceNode.comment) {
      _interface.documentation = interfaceNode.comment
    }

    namespace.ownedElements.push(_interface)

    // Register Extends for 2nd Phase Translation
    if (interfaceNode['extends']) {
      for (i = 0, len = interfaceNode['extends'].length; i < len; i++) {
        var _extend = interfaceNode['extends'][i]
        this._extendPendings.push({
          classifier: _interface,
          node: _extend,
          kind: 'interface',
          compilationUnitNode: this._currentCompilationUnit
        })
      }
    }

    // Translate Type Parameters
    this.translateTypeParameters(options, _interface, interfaceNode.typeParameters)
    // Translate Types
    this.translateTypes(options, _interface, interfaceNode.body)
    // Translate Members
    this.translateMembers(options, _interface, interfaceNode.body)
  }

  /**
   * Translate Java Enum Node.
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} enumNode
   */
  translateEnum (options, namespace, enumNode) {
    var _enum

    // Create Enumeration
    _enum = new type.UMLEnumeration()
    _enum._parent = namespace
    _enum.name = enumNode.name
    _enum.visibility = this._getVisibility(enumNode.modifiers)

    // JavaDoc
    if (enumNode.comment) {
      _enum.documentation = enumNode.comment
    }

    namespace.ownedElements.push(_enum)

    // Translate Type Parameters
    this.translateTypeParameters(options, _enum, enumNode.typeParameters)
    // Translate Types
    this.translateTypes(options, _enum, enumNode.body)
    // Translate Members
    this.translateMembers(options, _enum, enumNode.body)
  }

  /**
   * Translate Java AnnotationType Node.
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} annotationTypeNode
   */
  translateAnnotationType (options, namespace, annotationTypeNode) {
    var _annotationType

    // Create Class <<annotationType>>
    _annotationType = new type.UMLClass()
    _annotationType._parent = namespace
    _annotationType.name = annotationTypeNode.name
    _annotationType.stereotype = 'annotationType'
    _annotationType.visibility = this._getVisibility(annotationTypeNode.modifiers)

    // JavaDoc
    if (annotationTypeNode.comment) {
      _annotationType.documentation = annotationTypeNode.comment
    }

    namespace.ownedElements.push(_annotationType)

    // Translate Type Parameters
    this.translateTypeParameters(options, _annotationType, annotationTypeNode.typeParameters)
    // Translate Types
    this.translateTypes(options, _annotationType, annotationTypeNode.body)
    // Translate Members
    this.translateMembers(options, _annotationType, annotationTypeNode.body)
  }

  /**
   * Translate Java Field Node as UMLAssociation.
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} fieldNode
   */
  translateFieldAsAssociation (options, namespace, fieldNode) {
    if (fieldNode.variables && fieldNode.variables.length > 0) {
      // Add to _associationPendings
      var _associationPending = {
        classifier: namespace,
        node: fieldNode
      }
      this._associationPendings.push(_associationPending)
    }
  }

  /**
   * Translate Java Field Node as UMLAttribute.
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} fieldNode
   */
  translateFieldAsAttribute (options, namespace, fieldNode) {
    var i, len
    if (fieldNode.variables && fieldNode.variables.length > 0) {
      for (i = 0, len = fieldNode.variables.length; i < len; i++) {
        var variableNode = fieldNode.variables[i]

        // Create Attribute
        var _attribute = new type.UMLAttribute()
        _attribute._parent = namespace
        _attribute.name = variableNode.name

        // Access Modifiers
        _attribute.visibility = this._getVisibility(fieldNode.modifiers)
        if (variableNode.initializer) {
          _attribute.defaultValue = variableNode.initializer
        }

        // Static Modifier
        if (fieldNode.modifiers && fieldNode.modifiers.includes('static')) {
          _attribute.isStatic = true
        }

        // Final Modifier
        if (fieldNode.modifiers && fieldNode.modifiers.includes('final')) {
          _attribute.isLeaf = true
          _attribute.isReadOnly = true
        }

        // Volatile Modifier
        if (fieldNode.modifiers && fieldNode.modifiers.includes('volatile')) {
          this._addTag(_attribute, type.Tag.TK_BOOLEAN, 'volatile', true)
        }

        // Transient Modifier
        if (fieldNode.modifiers && fieldNode.modifiers.includes('transient')) {
          this._addTag(_attribute, type.Tag.TK_BOOLEAN, 'transient', true)
        }

        // JavaDoc
        if (fieldNode.comment) {
          _attribute.documentation = fieldNode.comment
        }

        namespace.attributes.push(_attribute)

        // Add to _typedFeaturePendings
        var _typedFeature = {
          namespace: namespace,
          feature: _attribute,
          node: fieldNode
        }
        this._typedFeaturePendings.push(_typedFeature)
      }
    }
  }

  /**
   * Translate Method
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} methodNode
   * @param {boolean} isConstructor
   */
  translateMethod (options, namespace, methodNode, isConstructor) {
    var i, len
    var _operation = new type.UMLOperation()
    _operation._parent = namespace
    _operation.name = methodNode.name
    namespace.operations.push(_operation)

    // Modifiers
    _operation.visibility = this._getVisibility(methodNode.modifiers)
    if (methodNode.modifiers && methodNode.modifiers.includes('static')) {
      _operation.isStatic = true
    }
    if (methodNode.modifiers && methodNode.modifiers.includes('abstract')) {
      _operation.isAbstract = true
    }
    if (methodNode.modifiers && methodNode.modifiers.includes('final')) {
      _operation.isLeaf = true
    }
    if (methodNode.modifiers && methodNode.modifiers.includes('synchronized')) {
      _operation.concurrency = type.UMLBehavioralFeature.CCK_CONCURRENT
    }
    if (methodNode.modifiers && methodNode.modifiers.includes('native')) {
      this._addTag(_operation, type.Tag.TK_BOOLEAN, 'native', true)
    }
    if (methodNode.modifiers && methodNode.modifiers.includes('strictfp')) {
      this._addTag(_operation, type.Tag.TK_BOOLEAN, 'strictfp', true)
    }

    // Constructor
    if (isConstructor) {
      _operation.stereotype = 'constructor'
    }

    // Stuff to do here to grab the correct Javadoc and put it into parameters and return

    // Formal Parameters
    if (methodNode.parameters && methodNode.parameters.length > 0) {
      for (i = 0, len = methodNode.parameters.length; i < len; i++) {
        var parameterNode = methodNode.parameters[i]
        parameterNode.compilationUnitNode = methodNode.compilationUnitNode
        this.translateParameter(options, _operation, parameterNode)
      }
    }

    // Return Type
    if (methodNode.type) {
      var _returnParam = new type.UMLParameter()
      _returnParam._parent = _operation
      _returnParam.name = ''
      _returnParam.direction = type.UMLParameter.DK_RETURN
      // Add to _typedFeaturePendings
      this._typedFeaturePendings.push({
        namespace: namespace,
        feature: _returnParam,
        node: methodNode
      })
      _operation.parameters.push(_returnParam)
    }

    // Throws
    if (methodNode.throws) {
      for (i = 0, len = methodNode.throws.length; i < len; i++) {
        var _throwNode = methodNode.throws[i]
        var _throwPending = {
          operation: _operation,
          node: _throwNode,
          compilationUnitNode: methodNode.compilationUnitNode
        }
        this._throwPendings.push(_throwPending)
      }
    }

    // JavaDoc
    if (methodNode.comment) {
      _operation.documentation = methodNode.comment
    }

    // "default" for Annotation Type Element
    if (methodNode.defaultValue) {
      this._addTag(_operation, type.Tag.TK_STRING, 'default', methodNode.defaultValue)
    }

    // Translate Type Parameters
    this.translateTypeParameters(options, _operation, methodNode.typeParameters)
  }

  /**
   * Translate Enumeration Constant
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} enumConstantNode
   */
  translateEnumConstant (options, namespace, enumConstantNode) {
    var _literal = new type.UMLEnumerationLiteral()
    _literal._parent = namespace
    _literal.name = enumConstantNode.name

    // JavaDoc
    if (enumConstantNode.comment) {
      _literal.documentation = enumConstantNode.comment
    }

    namespace.literals.push(_literal)
  }

  /**
   * Translate Method Parameters
   * @param {Object} options
   * @param {type.Model} namespace
   * @param {Object} parameterNode
   */
  translateParameter (options, namespace, parameterNode) {
    var _parameter = new type.UMLParameter()
    _parameter._parent = namespace
    _parameter.name = parameterNode.variable.name
    namespace.parameters.push(_parameter)

    // Add to _typedFeaturePendings
    this._typedFeaturePendings.push({
      namespace: namespace._parent,
      feature: _parameter,
      node: parameterNode
    })
  }
}

/**
 * Analyze all java files in basePath
 * @param {string} basePath
 * @param {Object} options
 */
function analyze (basePath, options) {
  var javaAnalyzer = new JavaCodeAnalyzer()

  function visit (base) {
    var stat = fs.lstatSync(base)
    if (stat.isFile()) {
      var ext = path.extname(base).toLowerCase()
      if (ext === '.java') {
        javaAnalyzer.addFile(base)
      }
    } else if (stat.isDirectory()) {
      var files = fs.readdirSync(base)
      if (files && files.length > 0) {
        files.forEach(entry => {
          var fullPath = path.join(base, entry)
          visit(fullPath)
        })
      }
    }
  }

  // Traverse all file entries
  visit(basePath)

  // Perform reverse engineering
  javaAnalyzer.analyze(options)
}

exports.analyze = analyze