vstack-typescript-generator/dist-spec/c-sharp-parser.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var c_sharp_objects_1 = require("./c-sharp-objects");
var CSharpParser = /** @class */ (function () {
    function CSharpParser() {
    }
    CSharpParser.parse = function (input) {
        input = CSharpParser.stripIgnored(input);
        input = CSharpParser.stripComments(input);
        var namespaceMatch = input.match(/namespace\s+([\w\.]+)/);
        var namespace = namespaceMatch ? namespaceMatch[1] : '';
        var types = [];
        var typeMatch;
        // tslint:disable-next-line:max-line-length
        var typeRegex = /^([\t ]*)(?:public\s*|partial\s*|abstract\s*)*\s*(enum|class|struct|interface)\s+([\w\d_<>]+)(?:\s*:\s*((?:(?:[\w\d\.\<\>_]+)(?:,\s+)?)+))?\s*\{((?:.|\n|\r)*?)^\1\}/gm;
        var getNextTypeMatch = function () { return typeMatch = typeRegex.exec(input); };
        while (getNextTypeMatch() !== null) {
            var type = typeMatch[2];
            var name = typeMatch[3];
            var inherits = CSharpParser.parseInherits(typeMatch[4]);
            var body = typeMatch[5];
            if (type === 'class' || type === 'struct') {
                types.push(CSharpParser.parseClassOrStruct(namespace, name, inherits, body));
            }
            else if (type === 'interface') {
                types.push(CSharpParser.parseInterface(namespace, name, inherits, body));
            }
            else if (type === 'enum') {
                types.push(CSharpParser.parseEnum(namespace, name, inherits, body));
            }
        }
        return types;
    };
    CSharpParser.stripIgnored = function (input) {
        var ignoredRegex = /\/\/\s*ts-generator-ignore\s*.*(enum|class|struct|interface)\s+/gm;
        return input.replace(ignoredRegex, '');
    };
    CSharpParser.stripComments = function (input) {
        var blockCommentRegex = /\/\*([\s\S]*?)\*\//gm;
        var lineCommentRegex = /\/\/(.*)/g;
        return input
            .replace(blockCommentRegex, '')
            .split('\n')
            .map(function (line) { return line.replace(lineCommentRegex, ''); })
            .join('\n');
    };
    CSharpParser.parseInherits = function (inheritsStr) {
        var inherits = [];
        if (inheritsStr) {
            var inheritsMatch_1;
            var inheritsRegex_1 = /(?:[\w\d\.\_]+)(?:\<.+?\>)?/g;
            var getNextInheritsMatch = function () { return inheritsMatch_1 = inheritsRegex_1.exec(inheritsStr); };
            while (getNextInheritsMatch() !== null) {
                inherits.push(inheritsMatch_1[0]);
            }
        }
        return inherits;
    };
    CSharpParser.parseClassOrStruct = function (namespace, name, inherits, body) {
        var constructors = [];
        var constructorMatch;
        var constructorRegex = /public\s+([\w]+)\s*\(((?:.|\r|\n)*?)\)/gm;
        var getNextConstructorMatch = function () { return constructorMatch = constructorRegex.exec(body); };
        while (getNextConstructorMatch() !== null) {
            var typeName = constructorMatch[1];
            var parameterList = constructorMatch[2];
            if (typeName === name) {
                var parameters = parameterList.length ? parameterList
                    .split(',')
                    .map(function (parameter) {
                    var parameterMatch = parameter.trim().match(/([^\s]+)\s+([\w\d]+)(?:\s+=\s+((?:[\w\d]+)|(?:"[\w\d ]+")))?/);
                    var parameterType = CSharpParser.parseMemberTypeName(parameterMatch[1]);
                    var parameterName = parameterMatch[2];
                    var rawDefaultParameter = parameterMatch[3];
                    var defaultValue = rawDefaultParameter && rawDefaultParameter.startsWith('"') && rawDefaultParameter.endsWith('"') ?
                        "'" + rawDefaultParameter.substr(1, rawDefaultParameter.length - 2) + "'" : rawDefaultParameter;
                    return new c_sharp_objects_1.CSharpParameter(parameterType, parameterName, defaultValue);
                }) : [];
                constructors.push(new c_sharp_objects_1.CSharpContructor(parameters));
            }
        }
        var properties = CSharpParser.getProperties(body, false);
        return new c_sharp_objects_1.CSharpClassOrStructOrInterface(namespace, name, inherits, constructors, properties);
    };
    CSharpParser.parseInterface = function (namespace, name, inherits, body) {
        var properties = CSharpParser.getProperties(body, true);
        return new c_sharp_objects_1.CSharpClassOrStructOrInterface(namespace, name, inherits, null, properties);
    };
    CSharpParser.parseEnum = function (namespace, name, inherits, body) {
        var entries = [];
        var entryMatch;
        var entryRegex = /^\s*([\w\d_]+)\s*=?\s*((?:0x|-|~)?[0-9A-Za-z_]+)?,?\s*$/gm;
        var getNextEntryMatch = function () { return entryMatch = entryRegex.exec(body); };
        while (getNextEntryMatch() !== null) {
            var entryName = entryMatch[1];
            var entryValue = entryMatch[2];
            if (entryName.indexOf('[') === -1) {
                entries.push(new c_sharp_objects_1.CSharpEnumEntry(entryName, entryValue));
            }
        }
        return new c_sharp_objects_1.CSharpEnum(namespace, name, inherits, entries);
    };
    CSharpParser.parseMemberTypeName = function (typeName) {
        var lastNameRegex = /\.?([\w<>\[\]\?]+)$/;
        var nullableRegex = /(?:^Nullable<([^\s]+)>$)|(?:^([^\s]+)\?$)/;
        var nullableMatch = nullableRegex.exec(typeName);
        if (nullableMatch) {
            typeName = (nullableMatch[1] || nullableMatch[2]);
        }
        var collectionRegex = /(?:List|IEnumerable)<([\w\d\.]+)>$|(?:^([\w\d\.]+)\[\]$)/;
        var collectionMatch = collectionRegex.exec(typeName);
        if (collectionMatch) {
            typeName = (collectionMatch[1] || collectionMatch[2]);
        }
        typeName = typeName.match(lastNameRegex)[1];
        return new c_sharp_objects_1.CSharpMemberType(typeName, !!nullableMatch, !!collectionMatch);
    };
    CSharpParser.getProperties = function (body, isInterface) {
        var properties = [];
        var propertyMatch;
        var propertyRegex = isInterface ? /\s*([^\s]+)\s*([\w\d]+)\s*{\s*get/gm : /public\s*(?:virtual|abstract|override)?\s*([^\s]+)\s*([\w\d]+)\s*{\s*get/gm;
        var getNextPropertyMatch = function () { return propertyMatch = propertyRegex.exec(body); };
        while (getNextPropertyMatch() !== null) {
            var typeName = propertyMatch[1];
            var propertyName = propertyMatch[2];
            var memberType = CSharpParser.parseMemberTypeName(typeName);
            properties.push(new c_sharp_objects_1.CSharpProperty(memberType, propertyName));
        }
        return properties;
    };
    return CSharpParser;
}());
exports.CSharpParser = CSharpParser;
//# sourceMappingURL=c-sharp-parser.js.map