Examples for tslint-documentation

src/rules/arrowReturnShorthandRule.ts

@@ -41,6 +41,40 @@ export class Rule extends Lint.Rules.AbstractRule {
         ],
         type: "style",
         typescriptOnly: false,
+        codeExamples: [
+            {
+                description: "Enforces to use shorthand for return.",
+                config: Lint.Utils.dedent`
+                    "rules": { "arrow-return-shorthand": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    const calc = (x: number, y: number) => ({ add: x + y, sub: x - y, mul: x * y });
+                    const calc2 = (x: number, y: number) => {
+                        return { add: x + y, sub: x - y, mul: x * y }
+                    };
+                `,
+                fail: Lint.Utils.dedent`
+                    const calc = (x: number, y: number) => { return { add: x + y, sub: x - y, mul: x * y } };
+               `,
+            },
+            {
+                description: "Enforces to use shorthand for return also for multiline.",
+                config: Lint.Utils.dedent`
+                    "rules": { "arrow-return-shorthand": [true, "multiline"] }
+                `,
+                pass: Lint.Utils.dedent`
+                    const calc = (x: number, y: number) => ({ add: x + y, sub: x - y, mul: x * y });
+                    const calc2 = (x: number, y: number) =>
+                        ({ add: x + y, sub: x - y, mul: x * y });
+                `,
+                fail: Lint.Utils.dedent`
+                    const calc = (x: number, y: number) => { return { add: x + y, sub: x - y, mul: x * y } };
+                    const calc = (x: number, y: number) => {
+                        return { add: x + y, sub: x - y, mul: x * y }
+                    };
+               `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/classNameRule.ts

@@ -32,6 +32,22 @@ export class Rule extends Lint.Rules.AbstractRule {
         optionExamples: [true],
         type: "style",
         typescriptOnly: false,
+        codeExamples: [
+            {
+                description: "Enforces PascalCased class and interface names.",
+                config: Lint.Utils.dedent`
+                    "rules": { "class-name": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    class MyClass { }
+                    interface MyInterface { }
+                `,
+                fail: Lint.Utils.dedent`
+                    class myClass { }
+                    interface myInterface { }
+               `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/noAnyRule.ts

@@ -31,6 +31,20 @@ export class Rule extends Lint.Rules.AbstractRule {
         optionExamples: [true],
         type: "typescript",
         typescriptOnly: true,
+        codeExamples: [
+            {
+                description: "Disallows usages of `any` as a type declaration.",
+                config: Lint.Utils.dedent`
+                    "rules": { "no-any": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    let foo: object;
+                `,
+                fail: Lint.Utils.dedent`
+                    let foo: any;
+                `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/noEmptyInterfaceRule.ts

@@ -30,6 +30,22 @@ export class Rule extends Lint.Rules.AbstractRule {
         options: null,
         type: "typescript",
         typescriptOnly: true,
+        codeExamples: [
+            {
+                description: "Disallows an empty interface.",
+                config: Lint.Utils.dedent`
+                    "rules": { "no-empty-interface": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    interface I {
+                        foo: string;
+                    }
+                `,
+                fail: Lint.Utils.dedent`
+                    interface I { }
+                `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/noSparseArraysRule.ts

@@ -31,6 +31,20 @@ export class Rule extends Lint.Rules.AbstractRule {
         optionExamples: [true],
         type: "functionality",
         typescriptOnly: false,
+        codeExamples: [
+            {
+                description: "Disallow sparse arrays",
+                config: Lint.Utils.dedent`
+                    "rules": { "no-sparse-arrays": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    const arr: string[] = ['elemenet1', 'element2'];
+                `,
+                fail: Lint.Utils.dedent`
+                    const arr: string[] = ['elemenet1',, 'element2'];
+                `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/noUnnecessaryCallbackWrapperRule.ts

@@ -32,6 +32,24 @@ export class Rule extends Lint.Rules.AbstractRule {
         optionExamples: [true],
         type: "style",
         typescriptOnly: false,
+        codeExamples: [
+            {
+                description: "Disallow unnecessary callback wrappers",
+                config: Lint.Utils.dedent`
+                    "rules": { "no-unnecessary-callback-wrapper": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    const handleContent = (content) => console.log('Handle content:', content);
+                    const handleError = (error) => console.log('Handle error:', error);
+                    promise.then(handleContent).catch(handleError);
+                `,
+                fail: Lint.Utils.dedent`
+                    const handleContent = (content) => console.log('Handle content:', content);
+                    const handleError = (error) => console.log('Handle error:', error);
+                    promise.then((content) => handleContent(content)).catch((error) => handleError(error));
+                `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/objectLiteralSortKeysRule.ts

@@ -61,6 +61,58 @@ export class Rule extends Lint.Rules.OptionallyTypedRule {
         ],
         type: "maintainability",
         typescriptOnly: false,
+        codeExamples: [
+            {
+                description: "Forces to sort keys in an object by alphabetical order",
+                config: Lint.Utils.dedent`
+                    "rules": { "object-literal-sort-keys": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    let o = {
+                        bar: 2,
+                        foo: 1
+                    };
+                `,
+                fail: Lint.Utils.dedent`
+                    let o = {
+                        foo: 1,
+                        bar: 2
+                    };
+                `,
+            },
+            {
+                description: "Forces to sort keys in an object by alphabetical order",
+                config: Lint.Utils.dedent`
+                    "rules": {
+                        "object-literal-sort-keys": {
+                            "options": "match-declaration-order"
+                        }
+                    }
+                `,
+                pass: Lint.Utils.dedent`
+                    interface I {
+                        foo: number;
+                        bar: number;
+                    }
+
+                    let o: I = {
+                        foo: 1,
+                        bar: 2
+                    };
+                `,
+                fail: Lint.Utils.dedent`
+                    interface I {
+                        foo: number;
+                        bar: number;
+                    }
+
+                    let o: I = {
+                        bar: 2,
+                        foo: 1
+                    };
+                `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/oneVariablePerDeclarationRule.ts

@@ -43,6 +43,32 @@ export class Rule extends Lint.Rules.AbstractRule {
         optionExamples: [true, [true, OPTION_IGNORE_FOR_LOOP]],
         type: "style",
         typescriptOnly: false,
+        codeExamples: [
+            {
+                description: "Disallows multiple variable definitions in the same declaration statement.",
+                config: Lint.Utils.dedent`
+                    "rules": { "one-variable-per-declaration": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    const foo = 1;
+                    const bar = '2';
+                `,
+                fail: Lint.Utils.dedent`
+                    const foo = 1, bar = '2';
+               `,
+            },
+            {
+                description: "Disallows multiple variable definitions in the same declaration statement but allows them in for-loops.",
+                config: Lint.Utils.dedent`
+                    "rules": { "one-variable-per-declaration": [true, "ignore-for-loop"] }
+                `,
+                pass: Lint.Utils.dedent`
+                    for (let i = 0, j = 10; i < 10; i++) {
+                        doSomething(j, i);
+                    }
+                `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/onlyArrowFunctionsRule.ts

@@ -47,6 +47,28 @@ export class Rule extends Lint.Rules.AbstractRule {
         optionExamples: [true, [true, OPTION_ALLOW_DECLARATIONS, OPTION_ALLOW_NAMED_FUNCTIONS]],
         type: "typescript",
         typescriptOnly: false,
+        codeExamples: [
+            {
+                description: "Disallow functions with the function keyword",
+                config: Lint.Utils.dedent`
+                    "rules": { "only-arrow-functions": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    const myFunc = () => {
+                        // do something ...
+                    };
+                `,
+                fail: Lint.Utils.dedent`
+                    function myFunc() {
+                        // do something ...
+                    };
+
+                    const myFunc = function() {
+                        // do something ...
+                    };
+                `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/preferTemplateRule.ts

@@ -40,6 +40,41 @@ export class Rule extends Lint.Rules.AbstractRule {
         optionExamples: [true, [true, OPTION_SINGLE_CONCAT]],
         type: "style",
         typescriptOnly: false,
+        codeExamples: [
+            {
+                description: "Forces to use template-strings",
+                config: Lint.Utils.dedent`
+                    "rules": { "prefer-template": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    const x: number = 1;
+                    const y: number = 1;
+                    const myString: string = \`\${x} is equals \${y}\`;
+                `,
+                fail: Lint.Utils.dedent`
+                    const x: number = 1;
+                    const y: number = 1;
+                    const myString: string = x + ' is equals ' + y;
+                `,
+            },
+            {
+                description: "Forces to use template-strings but allows up to one concatenation",
+                config: Lint.Utils.dedent`
+                    "rules": { "prefer-template": [true, "allow-single-concat"] }
+                `,
+                pass: Lint.Utils.dedent`
+                    const x: number = 1;
+                    const y: number = 1;
+                    const myString: string = x + ' is equals 1';
+                    const myString: string = \`\${x} is equals \${y}\`;
+                `,
+                fail: Lint.Utils.dedent`
+                    const x: number = 1;
+                    const y: number = 1;
+                    const myString: string = x + ' is equals ' + y;
+                `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/radixRule.ts

@@ -34,6 +34,26 @@ export class Rule extends Lint.Rules.AbstractRule {
         optionExamples: [true],
         type: "functionality",
         typescriptOnly: false,
+        codeExamples: [
+            {
+                description: "Requires the radix parameter to be specified when calling `parseInt`.",
+                config: Lint.Utils.dedent`
+                    "rules": { "radix": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    const x: string = '11';
+                    const dec: number = parseInt(x, 10);
+                    const bin: number = parseInt(x, 2);
+                    const hex: number = parseInt(x, 16);
+                `,
+                fail: Lint.Utils.dedent`
+                    const x: string = '11';
+                    const dec: number = parseInt(x);
+                    const bin: number = parseInt(x, 2);
+                    const hex: number = parseInt(x, 16);
+                `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */
 

src/rules/switchDefaultRule.ts

@@ -30,6 +30,39 @@ export class Rule extends Lint.Rules.AbstractRule {
         optionExamples: [true],
         type: "functionality",
         typescriptOnly: false,
+        codeExamples: [
+            {
+                description: "Require a `default` case in `switch` statements.",
+                config: Lint.Utils.dedent`
+                    "rules": { "switch-default": true }
+                `,
+                pass: Lint.Utils.dedent`
+                    let foo: number = 1;
+                    switch (foo) {
+                        case 1:
+                            doSomething();
+                            break;
+                        case 2:
+                            doSomething2();
+                            break;
+                        default:
+                            console.log('default');
+                            break;
+                    }
+                `,
+                fail: Lint.Utils.dedent`
+                    let foo: number = 1;
+                    switch (foo) {
+                        case 1:
+                            doSomething();
+                            break;
+                        case 2:
+                            doSomething2();
+                            break;
+                    }
+                `,
+            },
+        ],
     };
     /* tslint:enable:object-literal-sort-keys */