From c7a368b276ebfac7084e9686005c8d2c3cc8787a Mon Sep 17 00:00:00 2001 From: segayuu Date: Tue, 10 Oct 2017 06:47:48 +0900 Subject: [PATCH] [bluebird]Fix simple lint errors (#20222) * Fix lint-error dt-header * Fix lint-error no-var-keyword * Fix lint error no-padding * Fix lint error only-arrow-functions * Fix lint error space-before-function-paren * Fix lint error prefer-method-signature * Fix lint error typedef-whitespace * Fic Lint ignore whitespace * Fix lint error no-consecutive-blank-lines * Fix lint error semicolon * Fix lint error member-access * Fix lint error comment-format --- types/bluebird/bluebird-tests.ts | 230 +++++++++++++++---------------- types/bluebird/index.d.ts | 13 +- types/bluebird/tslint.json | 16 +-- 3 files changed, 118 insertions(+), 141 deletions(-) diff --git a/types/bluebird/bluebird-tests.ts b/types/bluebird/bluebird-tests.ts index a77a6262db..3fbf9a7c1e 100644 --- a/types/bluebird/bluebird-tests.ts +++ b/types/bluebird/bluebird-tests.ts @@ -7,26 +7,26 @@ import Promise = require("bluebird"); -var obj: Object; -var bool: boolean; -var num: number; -var str: string; -var err: Error; -var x: any; -var f: (...args: any[]) => any; -var asyncfunc: (...args: any[]) => Promise; -var arr: any[]; -var exp: RegExp; -var anyArr: any[]; -var strArr: string[]; -var numArr: number[]; -var voidVar: void; +let obj: Object; +let bool: boolean; +let num: number; +let str: string; +let err: Error; +let x: any; +let f: (...args: any[]) => any; +let asyncfunc: (...args: any[]) => Promise; +let arr: any[]; +let exp: RegExp; +let anyArr: any[]; +let strArr: string[]; +let numArr: number[]; +let voidVar: void; // - - - - - - - - - - - - - - - - - -var value: any; -var reason: any; -var insanity: any; +let value: any; +let reason: any; +let insanity: any; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -43,120 +43,120 @@ interface Baz { // - - - - - - - - - - - - - - - - - interface StrFooMap { - [key:string]:Foo; + [key: string]: Foo; } interface StrBarMap { - [key:string]:Bar; + [key: string]: Bar; } // - - - - - - - - - - - - - - - - - interface StrFooArrMap { - [key:string]:Foo[]; + [key: string]: Foo[]; } interface StrBarArrMap { - [key:string]:Bar[]; + [key: string]: Bar[]; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -var foo: Foo; -var bar: Bar; -var baz: Baz; +let foo: Foo; +let bar: Bar; +let baz: Baz; -var fooArr: Foo[]; -var barArr: Bar[]; +let fooArr: Foo[]; +let barArr: Bar[]; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -var numProm: Promise; -var strProm: Promise; -var anyProm: Promise; -var boolProm: Promise; -var objProm: Promise; -var voidProm: Promise; +let numProm: Promise; +let strProm: Promise; +let anyProm: Promise; +let boolProm: Promise; +let objProm: Promise; +let voidProm: Promise; -var fooProm: Promise; -var barProm: Promise; -var barOrVoidProm: Promise; -var fooOrBarProm: Promise; -var bazProm: Promise; +let fooProm: Promise; +let barProm: Promise; +let barOrVoidProm: Promise; +let fooOrBarProm: Promise; +let bazProm: Promise; // - - - - - - - - - - - - - - - - - -var numThen: PromiseLike; -var strThen: PromiseLike; -var anyThen: PromiseLike; -var boolThen: PromiseLike; -var objThen: PromiseLike; -var voidThen: PromiseLike; +let numThen: PromiseLike; +let strThen: PromiseLike; +let anyThen: PromiseLike; +let boolThen: PromiseLike; +let objThen: PromiseLike; +let voidThen: PromiseLike; -var fooThen: PromiseLike; -var barThen: PromiseLike; +let fooThen: PromiseLike; +let barThen: PromiseLike; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -var numArrProm: Promise; -var strArrProm: Promise; -var anyArrProm: Promise; +let numArrProm: Promise; +let strArrProm: Promise; +let anyArrProm: Promise; -var fooArrProm: Promise; -var barArrProm: Promise; +let fooArrProm: Promise; +let barArrProm: Promise; // - - - - - - - - - - - - - - - - - -var numArrThen: PromiseLike; -var strArrThen: PromiseLike; -var anyArrThen: PromiseLike; +let numArrThen: PromiseLike; +let strArrThen: PromiseLike; +let anyArrThen: PromiseLike; -var fooArrThen: PromiseLike; -var barArrThen: PromiseLike; +let fooArrThen: PromiseLike; +let barArrThen: PromiseLike; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -var numPromArr: Promise[]; -var strPromArr: Promise[]; -var anyPromArr: Promise[]; +let numPromArr: Promise[]; +let strPromArr: Promise[]; +let anyPromArr: Promise[]; -var fooPromArr: Promise[]; -var barPromArr: Promise[]; +let fooPromArr: Promise[]; +let barPromArr: Promise[]; // - - - - - - - - - - - - - - - - - -var numThenArr: PromiseLike[]; -var strThenArr: PromiseLike[]; -var anyThenArr: PromiseLike[]; +let numThenArr: PromiseLike[]; +let strThenArr: PromiseLike[]; +let anyThenArr: PromiseLike[]; -var fooThenArr: PromiseLike[]; -var barThenArr: PromiseLike[]; +let fooThenArr: PromiseLike[]; +let barThenArr: PromiseLike[]; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // booya! -var fooThenArrThen: PromiseLike[]>; -var barThenArrThen: PromiseLike[]>; +let fooThenArrThen: PromiseLike[]>; +let barThenArrThen: PromiseLike[]>; -var fooResolver: Promise.Resolver; -var barResolver: Promise.Resolver; +let fooResolver: Promise.Resolver; +let barResolver: Promise.Resolver; -var fooInspection: Promise.Inspection; -var fooInspectionPromise: Promise>; +let fooInspection: Promise.Inspection; +let fooInspectionPromise: Promise>; -var fooInspectionArrProm: Promise[]>; -var barInspectionArrProm: Promise[]>; +let fooInspectionArrProm: Promise[]>; +let barInspectionArrProm: Promise[]>; -var BlueBird: typeof Promise; +let BlueBird: typeof Promise; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -var version: string = Promise.version; +let version: string = Promise.version; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -var nodeCallbackFunc = (callback: (err: any, result: string) => void) => {} -var nodeCallbackFuncErrorOnly = (callback: (err: any) => void) => {} +let nodeCallbackFunc = (callback: (err: any, result: string) => void) => {}; +let nodeCallbackFuncErrorOnly = (callback: (err: any) => void) => {}; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -200,9 +200,7 @@ fooResolver.resolve(foo); fooResolver.reject(err); -fooResolver.callback = (err: any, value: Foo) => { - -}; +fooResolver.callback = (err: any, value: Foo) => {}; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -239,7 +237,7 @@ barProm = fooProm.then((value: Foo) => { }); barProm = barProm.then((value: Bar) => { if (value) return value; - var b:Bar; + let b: Bar; return Promise.resolve(b); }); @@ -282,7 +280,7 @@ fooProm = fooProm.caught((error: any) => { }); fooProm = fooProm.catch((reason: any) => { - //handle multiple valid return types simultaneously + // handle multiple valid return types simultaneously if (foo === null) { return; } else if (!reason) { @@ -341,22 +339,22 @@ fooOrBarProm = fooProm.caught(Promise.CancellationError, (reason: any) => { // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - class CustomError extends Error { - public customField: number; + customField: number; } fooProm = fooProm.catch(CustomError, reason => { - let a: number = reason.customField -}) + let a: number = reason.customField; +}); { class CustomErrorWithConstructor extends Error { constructor(public arg1: boolean, public arg2: number) { super(); - }; + } } fooProm = fooProm.catch(CustomErrorWithConstructor, reason => { let a: boolean = reason.arg1; let b: number = reason.arg2; - }) + }); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -527,7 +525,7 @@ bool = fooProm.isResolved(); anyProm = fooProm.call(str); anyProm = fooProm.call(str, 1, 2, 3); -//TODO enable get() test when implemented +// TODO enable get() test when implemented // barProm = fooProm.get(str); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -573,7 +571,7 @@ barProm = fooArrProm.spread((one: Foo, two: Bar, twotwo: Foo) => { // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -//TODO fix collection inference +// TODO fix collection inference barArrProm = fooProm.all(); fooInspectionPromise = fooProm.reflect(); @@ -583,16 +581,16 @@ barProm = fooProm.race(); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -var propsValue: { num: number, str: string }; -Promise.resolve({ num: 1, str: Promise.resolve('a') }).props().then(val => { propsValue = val }); -Promise.props({ num: 1, str: Promise.resolve('a') }).then(val => { propsValue = val }); -Promise.props(Promise.props({ num: 1, str: Promise.resolve('a') })).then(val => { propsValue = val }); +let propsValue: { num: number, str: string }; +Promise.resolve({ num: 1, str: Promise.resolve('a') }).props().then(val => { propsValue = val; }); +Promise.props({ num: 1, str: Promise.resolve('a') }).then(val => { propsValue = val; }); +Promise.props(Promise.props({ num: 1, str: Promise.resolve('a') })).then(val => { propsValue = val; }); -var propsMapValue: Map; -Promise.resolve(new Map()).props().then(val => { propsMapValue = val }); -Promise.resolve(new Map>()).props().then(val => { propsMapValue = val }); -Promise.props(new Map()).then(val => { propsMapValue = val }); -Promise.props(new Map>()).then(val => { propsMapValue = val }); +let propsMapValue: Map; +Promise.resolve(new Map()).props().then(val => { propsMapValue = val; }); +Promise.resolve(new Map>()).props().then(val => { propsMapValue = val; }); +Promise.props(new Map()).then(val => { propsMapValue = val; }); +Promise.props(new Map>()).then(val => { propsMapValue = val; }); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -620,7 +618,7 @@ Promise.all([fooProm, barProm, fooProm]).then(result => { // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -//TODO fix collection inference +// TODO fix collection inference barArrProm = fooArrProm.map((item: Foo, index: number, arrayLength: number) => { return bar; @@ -649,7 +647,6 @@ barArrProm = fooArrProm.mapSeries((item: Foo) => { return bar; }); - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - barProm = fooArrProm.reduce((memo: Bar, item: Foo, index: number, arrayLength: number) => { @@ -755,9 +752,7 @@ fooProm = Promise.attempt(() => { // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -asyncfunc = Promise.method(function () { - -}); +asyncfunc = Promise.method(() => {}); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -785,7 +780,7 @@ Promise.longStackTraces(); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -//TODO enable delay +// TODO enable delay fooProm = Promise.delay(num, fooThen); fooProm = Promise.delay(num, foo); @@ -809,7 +804,7 @@ anyProm = Promise.fromCallback(callback => nodeCallbackFuncErrorOnly(callback), // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -declare var util: any; +declare let util: any; function defaultFilter(name: string, func: Function) { return util.isIdentifier(name) && @@ -820,11 +815,11 @@ function defaultFilter(name: string, func: Function) { function DOMPromisifier(originalMethod: Function) { // return a function return function promisified() { - var args = [].slice.call(arguments); + let args = [].slice.call(arguments); // Needed so that the original method can be called with the correct receiver - var self = this; + let self = this; // which returns a promise - return new Promise(function(resolve, reject) { + return new Promise((resolve, reject) => { args.push(resolve, reject); originalMethod.apply(self, args); }); @@ -839,11 +834,11 @@ obj = Promise.promisifyAll(obj, { // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -const generator = function* (a: number, b: string) {return "string"} +const generator = function*(a: number, b: string) { return "string"; }; const coroutine = Promise.coroutine(generator); coroutine(5, "foo").then((x: string) => {}); -const coroutineCustomYield = Promise.coroutine(generator, { yieldHandler: (value) => "whatever" }) +const coroutineCustomYield = Promise.coroutine(generator, { yieldHandler: (value) => "whatever" }); /* barProm = Promise.spawn(f); */ @@ -852,13 +847,11 @@ const coroutineCustomYield = Promise.coroutine(generator, { yieldHandler: (value BlueBird = Promise.getNewLibraryCopy(); BlueBird = Promise.noConflict(); -Promise.onPossiblyUnhandledRejection((reason: any) => { - -}); +Promise.onPossiblyUnhandledRejection((reason: any) => {}); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -//TODO expand tests to overloads +// TODO expand tests to overloads fooArrProm = Promise.all(fooThenArrThen); fooArrProm = Promise.all(fooArrProm); fooArrProm = Promise.all(fooThenArr); @@ -871,7 +864,7 @@ objProm = Promise.props(obj); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -//TODO expand tests to overloads +// TODO expand tests to overloads fooProm = Promise.any(fooThenArrThen); fooProm = Promise.any(fooArrProm); fooProm = Promise.any(fooThenArr); @@ -879,7 +872,7 @@ fooProm = Promise.any(fooArr); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -//TODO expand tests to overloads +// TODO expand tests to overloads fooProm = Promise.race(fooThenArrThen); fooProm = Promise.race(fooArrProm); fooProm = Promise.race(fooThenArr); @@ -887,7 +880,7 @@ fooProm = Promise.race(fooArr); // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -//TODO expand tests to overloads +// TODO expand tests to overloads fooArrProm = Promise.some(fooThenArrThen, num); fooArrProm = Promise.some(fooThenArr, num); fooArrProm = Promise.some(fooArr, num); @@ -1090,7 +1083,6 @@ barArrProm = Promise.mapSeries(fooArrThen, (item: Foo, index: number, arrayLengt return barThen; }); - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // fooThenArr @@ -1108,7 +1100,6 @@ barArrProm = Promise.mapSeries(fooThenArr, (item: Foo, index: number, arrayLengt return barThen; }); - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // fooArr @@ -1126,7 +1117,6 @@ barArrProm = Promise.mapSeries(fooArr, (item: Foo, index: number, arrayLength: n return barThen; }); - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // reduce() diff --git a/types/bluebird/index.d.ts b/types/bluebird/index.d.ts index b9a9d35e4d..8baef9caf9 100644 --- a/types/bluebird/index.d.ts +++ b/types/bluebird/index.d.ts @@ -1,4 +1,4 @@ -// Type definitions for bluebird 3.5.0 +// Type definitions for bluebird 3.5 // Project: https://github.com/petkaantonov/bluebird // Definitions by: Leonard Hecker // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped @@ -1006,7 +1006,7 @@ declare class Bluebird implements PromiseLike, Bluebird.Inspection { * Create a new promise. The passed in function will receive functions `resolve` and `reject` as its arguments which can be called to seal the fate of the created promise. * If promise cancellation is enabled, passed in function will receive one more function argument `onCancel` that allows to register an optional cancellation callback. */ - static Promise: typeof Bluebird + static Promise: typeof Bluebird; /** * The version number of the library @@ -1030,12 +1030,12 @@ declare namespace Bluebird { } export interface PromisifyAllOptions extends PromisifyOptions { suffix?: string; - filter?: (name: string, func: (...args: any[]) => any, target?: any, passesDefaultFilter?: boolean) => boolean; + filter?(name: string, func: (...args: any[]) => any, target?: any, passesDefaultFilter?: boolean): boolean; // The promisifier gets a reference to the original method and should return a function which returns a promise - promisifier?: (originalMethod: (...args: any[]) => any, defaultPromisifer: (...args: any[]) => (...args: any[]) => Bluebird) => () => PromiseLike; + promisifier?(originalMethod: (...args: any[]) => any, defaultPromisifer: (...args: any[]) => (...args: any[]) => Bluebird): () => PromiseLike; } export interface CoroutineOptions { - yieldHandler: (value: any) => any; + yieldHandler(value: any): any; } /** @@ -1088,7 +1088,6 @@ declare namespace Bluebird { reverse(): AggregateError; } - /** * returned by `Bluebird.disposer()`. */ @@ -1123,7 +1122,7 @@ declare namespace Bluebird { * If the the callback is called with multiple success values, the resolver fullfills its promise with an array of the values. */ // TODO specify resolver callback - callback: (err: any, value: R, ...values: R[]) => void; + callback(err: any, value: R, ...values: R[]): void; } export interface Inspection { diff --git a/types/bluebird/tslint.json b/types/bluebird/tslint.json index 55713db673..d2d5c00bef 100644 --- a/types/bluebird/tslint.json +++ b/types/bluebird/tslint.json @@ -4,26 +4,14 @@ "adjacent-overload-signatures": false, "array-type": false, "ban-types": false, - "comment-format": false, - "dt-header": false, "max-line-length": false, - "member-access": false, - "no-consecutive-blank-lines": false, - "no-padding": false, "no-unnecessary-callback-wrapper": false, "no-unnecessary-generics": false, - "no-var-keyword": false, "no-void-expression": false, "one-line": false, - "only-arrow-functions": false, "prefer-const": false, - "prefer-method-signature": false, - "semicolon": false, - "space-before-function-paren": false, "strict-export-declare-modifiers": false, - "typedef-whitespace": false, "unified-signatures": false, - "void-return": false, - "whitespace": false + "void-return": false } -} \ No newline at end of file +}