typescript-closure-tools/definition-generator/test/generate_spec.js

Command-line tools to convert closure-style JSDoc annotations to typescript, and to convert typescript sources to closure externs files

"use strict";
/// <reference path="../index/node.d.ts"/>
/// <reference path="../index/jasmine.d.ts"/>
exports.__esModule = true;
var fs = require("fs");
var options = require("../src/options");
options.provides = 'test/symbols.tsv';
var parser = require("../src/parser");
var combine = require("../src/combine");
var generate = require("../src/generate");
function parse(fileName) {
    var file = parser.jsdoc(fs.readFileSync(fileName, 'utf8'));
    var symbols = combine.members(file);
    var result = generate.defs(symbols).modules;
    Object.keys(result).forEach(function (moduleName) {
        Object.keys(result[moduleName]).forEach(function (memberName) {
            var text = result[moduleName][memberName];
            var noComments = text.replace(/\/\*\*[^]*?\*\//g, '');
            var simpleSpace = noComments.replace(/\s+/g, ' ');
            result[moduleName][memberName] = simpleSpace.trim();
        });
    });
    return result;
}
describe('generate', function () {
    it('class', function () {
        expect(parse('test/class.js')).toEqual({
            "example": {
                "Class": "class Class extends Class__Class { } class Class__Class implements example.Interface { constructor(x: number|string); thisAssignment: string; thisDeclaration: number; overloadedMethod(x: number|string): void; interfaceMethod(x: number|string): void; }"
            }
        });
    });
    it('interface', function () {
        expect(parse('test/interface.js')).toEqual({
            "example": {
                "Interface": "interface Interface { interfaceMethod(x: number|string): void; }"
            }
        });
    });
    it('function with missing @param', function () {
        expect(parse('test/missing_params.js')).toEqual({
            "example": {
                "missingParams": "function missingParams(x: any /* jsdoc error */, y: any /* jsdoc error */): void;"
            }
        });
    });
    it('function with no arguments', function () {
        expect(parse('test/no_params.js')).toEqual({
            "example": {
                "noParams": "function noParams(): void;"
            }
        });
    });
    it('overloaded function', function () {
        expect(parse('test/overloaded_function.js')).toEqual({
            "example": {
                "overloadedFunction": "function overloadedFunction(x: number|string): void;"
            }
        });
    });
    it('subclass', function () {
        expect(parse('test/subclass.js')).toEqual({
            "example": {
                "SubClass": "class SubClass extends SubClass__Class { } class SubClass__Class extends example.Class__Class { constructor(); }"
            }
        });
    });
    it('subinterface', function () {
        expect(parse('test/subinterface.js')).toEqual({
            "example": {
                "SubInterface": "interface SubInterface extends example.Interface { }"
            }
        });
    });
    it('typedef array', function () {
        expect(parse('test/typedef_array.js')).toEqual({
            "example": {
                "ArrayType": "interface ArrayType extends Array<string> { }"
            }
        });
    });
    it('typedef bang', function () {
        expect(parse('test/typedef_bang.js')).toEqual({
            "example": {
                "BangType": "interface BangType extends Array<string> { }"
            }
        });
    });
    it('typedef union', function () {
        expect(parse('test/typedef_union.js')).toEqual({
            "example": {
                "UnionType": 'type UnionType = string|number;',
                "unionFunction": 'function unionFunction(x: example.UnionType): void;',
                "genericUnionFunction": 'function genericUnionFunction(x: example.UnionType<any>): void;'
            }
        });
    });
    describe('requirejs', function () {
        it('function declaration', function () {
            expect(parse('test/requirejs_function_declaration.js')).toEqual({
                MODULE: {
                    functionDeclaration: 'function functionDeclaration(x: number): void;'
                }
            });
        });
        it('function expression', function () {
            expect(parse('test/requirejs_function_expression.js')).toEqual({
                MODULE: {
                    functionExpression: 'function functionExpression(x: number): void;'
                }
            });
        });
        it('local class', function () {
            expect(parse('test/requirejs_local_class.js')).toEqual({
                MODULE: {
                    LocalClass: 'class LocalClass extends LocalClass__Class { } class LocalClass__Class { constructor(x: number); memberFunction(x: number): void; }'
                }
            });
        });
        it('local variable', function () {
            expect(parse('test/requirejs_local_variable.js')).toEqual({
                MODULE: {
                    localVariable: 'var localVariable: number;'
                }
            });
        });
    });
});