sl-cia/lib/js_diff/method-signature.js

var guessMethodLocation = require('./guess-method-location').guessMethodLocation;
var guessMethodName = require('./guess-method-name').guessMethodName;
var astUtils = require('sl-esprima-ast-utils');
var md5 = require('md5');
var babelGenerator = require("@babel/generator");
var traverse = require('ast-traverse');
var AstNodeTypes = require("./ast-node-types");
var utils = require("../utils");
var globalMethodIndexer = require("./globalMethodIndexer");

/**
 * Crates method object from node recived from ast
 * @constructor
 */
function MethodSignature(node, parentNode, nodeToParent, absolutePath, relativePath, logger) {
    this.node = node;
    this.parentNode = parentNode;
    this.nodeToParent = nodeToParent;
    this.logger = logger;
    this.generatedData = new MethodData(absolutePath, relativePath);
    this.srcData = new MethodData();
    this.meta = {};
    this.type = null;
    this.shouldSkip = false;
    this.hasSourceData = false;
    this.techSpecificInfo = this.createTechSpecificInfoInterface();
    this.idxInMapping = globalMethodIndexer.getCurrentIndex()
}

MethodSignature.prototype._createSignature = function () {
    var location = guessMethodLocation(this.node, this.nodeToParent);
    var nameObject = guessMethodName(this.node, this.parentNode);
    this.type = nameObject.type;
    this.generatedData.position = formatLocationToArray(location.start);
    this.generatedData.endPosition = formatLocationToArray(this.node.loc.end);
    this.generatedData.hash = this.calculateHash();
    this.generatedData.sigHash = this.calculateSigHash();
    this.generatedData.displayName = nameObject.name;
    this.meta.anonymous = nameObject.isAnonymous;
    this.techSpecificInfo.isAnonymous = nameObject.isAnonymous;
    this.srcData = utils.cloneObject(this.generatedData, this.logger);
};

MethodSignature.prototype.calculateHash = function () {
    var context = this;
    var clonedNode = astUtils.clone(this.node);
    // Visit node in pre order and calculate body hash.
    traverse(clonedNode, {
        pre: function (node) {
            // If current node is the root node given return (we want to calculate the body hash only).
            if (node == clonedNode)
                return;
            if (AstNodeTypes.isMethodNode(node)) {
                context.emptyNode(node);
            }
        }
    });
    var generatedCode = this.generateCodeFromAST(clonedNode);
    return md5(generatedCode);
};

MethodSignature.prototype.calculateSigHash = function () {
    var context = this;
    if (!this.node.params || this.node.params.length == 0) {
        return "";
    }
    var paramsStr = this.node.params.map(function (param) {
        return context.generateCodeFromAST(param);
    }).join(',');

    return md5(paramsStr);
};

MethodSignature.prototype.emptyNode = function (node) {
    node.body = {
        type: AstNodeTypes.BlockStatement,
        body: []
    }
    node.params = [];
    node.id = {
        name: '_',
        type: AstNodeTypes.Identifier
    };
};

MethodSignature.prototype.generateCodeFromAST = function (node) {
    return babelGenerator.default(node, {
        comments: false
    }, '').code;

};

MethodSignature.prototype.createTechSpecificInfoInterface = function () {
    return {
        isAsync: this.node.async || false,
        isComputed: this.node.computed || false,
        isExpression: this.node.expression || false,
        isGenerator: this.node.generator || false,
        kind: this.node.kind,
        isStatic: this.node.static || false
    }
};

MethodSignature.prototype.createUniqueId = function() {
    var relevantData = this.hasSourceData ? this.srcData : this.generatedData;
  return [relevantData.relativeFilename, relevantData.position.join(',')].join('@')
};


MethodSignature.prototype.createDTO = function() {
  return {
    meta: this.meta,
    techSpecificInfo: this.techSpecificInfo,
    type: this.type,
    srcData: this.srcData,
    generatedData: this.generatedData,
    uniqueId: this.createUniqueId(),
    idxInMapping: this.idxInMapping
  }
};

MethodSignature.create = function (node, parentNode, nodeToParent, absolutePath, relativePath, logger) {
    var signature = new this(node, parentNode, nodeToParent, absolutePath, relativePath, logger);
    signature._createSignature();
    return signature;
}

function formatLocationToArray(loc) {
    return [loc.line, loc.column];
}

function MethodData(absolutePath, relativePath) {
    this.position = null;
    this.endPosition = null;
    this.displayName = null;
    this.hash = null;
    this.sigHash = null;
    this.relativeFilename = relativePath;
    this.absoluteFilename = absolutePath;
}
module.exports = MethodSignature;