From 84016d2ede3fde0e18b0865ea3f85528f97e4e73 Mon Sep 17 00:00:00 2001 From: asponda Date: Thu, 3 Oct 2019 12:17:21 -0300 Subject: [PATCH 1/2] feat: add converter for max-line-length --- src/rules/converters.ts | 3 +- src/rules/converters/max-line-length.ts | 43 ++++ .../converters/tests/max-line-length.test.ts | 194 ++++++++++++++++++ 3 files changed, 239 insertions(+), 1 deletion(-) create mode 100644 src/rules/converters/max-line-length.ts create mode 100644 src/rules/converters/tests/max-line-length.test.ts diff --git a/src/rules/converters.ts b/src/rules/converters.ts index 782e17f47..0c61bc0bd 100644 --- a/src/rules/converters.ts +++ b/src/rules/converters.ts @@ -23,6 +23,7 @@ import { convertLabelPosition } from "./converters/label-position"; import { convertLinebreakStyle } from "./converters/linebreak-style"; import { convertMaxClassesPerFile } from "./converters/max-classes-per-file"; import { convertMaxFileLineCount } from "./converters/max-file-line-count"; +import { convertMaxLineLength } from "./converters/max-line-length"; import { convertMemberOrdering } from "./converters/member-ordering"; import { convertNewlinePerChainedCall } from "./converters/newline-per-chained-call"; import { convertNewParens } from "./converters/new-parens"; @@ -184,6 +185,7 @@ export const converters = new Map([ ["linebreak-style", convertLinebreakStyle], ["max-classes-per-file", convertMaxClassesPerFile], ["max-file-line-count", convertMaxFileLineCount], + ["max-line-length", convertMaxLineLength], ["no-consecutive-blank-lines", convertNoConsecutiveBlankLines], ["no-console", convertNoConsole], ["no-empty", convertNoEmpty], @@ -216,7 +218,6 @@ export const converters = new Map([ // TSLint core rules: // ["ban", convertBan], // no-restricted-properties // ["import-blacklist", convertImportBlacklist], // no-restricted-imports - // ["max-line-length", convertMaxLineLength], // max-len // ["newline-before-return", convertNewlineBeforeReturn], // ["no-duplicate-variable", convertNoDuplicateVariable], // no-redeclare // ["no-shadowed-variable", convertNoShadowedVariable], // no-shadow diff --git a/src/rules/converters/max-line-length.ts b/src/rules/converters/max-line-length.ts new file mode 100644 index 000000000..24ad4b17a --- /dev/null +++ b/src/rules/converters/max-line-length.ts @@ -0,0 +1,43 @@ +import { RuleConverter } from "../converter"; + +export const convertMaxLineLength: RuleConverter = tslintRule => { + return { + rules: [ + { + ...collectArguments(tslintRule.ruleArguments), + ruleName: "max-len", + }, + ], + }; +}; + +const collectArguments = (ruleArguments: any[]) => { + if (ruleArguments.length === 0 || ruleArguments[0] === false || ruleArguments.length < 2) { + return undefined; + } + + if (ruleArguments.length === 2 && typeof ruleArguments[1] === "number") { + return { + ruleArguments: [ + { + code: ruleArguments[1], + }, + ], + }; + } + + const argument = ruleArguments[1]; + + return { + ruleArguments: [ + { + ...("limit" in argument && { code: argument.limit }), + ...("ignore-pattern" in argument && { ignorePattern: argument["ignore-pattern"] }), + ...("check-strings" in argument && { ignoreStrings: !argument["check-strings"] }), + ...("check-regex" in argument && { + ignoreRegExpLiterals: !argument["check-regex"], + }), + }, + ], + }; +}; diff --git a/src/rules/converters/tests/max-line-length.test.ts b/src/rules/converters/tests/max-line-length.test.ts new file mode 100644 index 000000000..94b3e83a2 --- /dev/null +++ b/src/rules/converters/tests/max-line-length.test.ts @@ -0,0 +1,194 @@ +import { convertMaxLineLength } from "../max-line-length"; + +describe(convertMaxLineLength, () => { + test("conversion without arguments", () => { + const result = convertMaxLineLength({ + ruleArguments: [], + }); + + expect(result).toEqual({ + rules: [ + { + ruleName: "max-len", + }, + ], + }); + }); + + test("conversion with one argument true value", () => { + const result = convertMaxLineLength({ + ruleArguments: [true], + }); + + expect(result).toEqual({ + rules: [ + { + ruleName: "max-len", + }, + ], + }); + }); + + test("conversion with two argument and first is false", () => { + const result = convertMaxLineLength({ + ruleArguments: [false, 123], + }); + + expect(result).toEqual({ + rules: [ + { + ruleName: "max-len", + }, + ], + }); + }); + + test("conversion with two arguments and second is number", () => { + const result = convertMaxLineLength({ + ruleArguments: [true, 123], + }); + + expect(result).toEqual({ + rules: [ + { + ruleArguments: [{ code: 123 }], + ruleName: "max-len", + }, + ], + }); + }); + + test("conversion with two arguments and second is object", () => { + const result = convertMaxLineLength({ + ruleArguments: [ + true, + { + limit: 123, + "ignore-pattern": "^import |^export {(.*?)}", + "check-strings": true, + "check-regex": true, + }, + ], + }); + + expect(result).toEqual({ + rules: [ + { + ruleArguments: [ + { + code: 123, + ignorePattern: "^import |^export {(.*?)}", + ignoreStrings: false, + ignoreRegExpLiterals: false, + }, + ], + ruleName: "max-len", + }, + ], + }); + }); + + test("conversion with check-strings inverting value true to false", () => { + const result = convertMaxLineLength({ + ruleArguments: [ + true, + { + limit: 123, + "check-strings": true, + }, + ], + }); + + expect(result).toEqual({ + rules: [ + { + ruleArguments: [ + { + code: 123, + ignoreStrings: false, + }, + ], + ruleName: "max-len", + }, + ], + }); + }); + + test("conversion with check-strings inverting value false to true", () => { + const result = convertMaxLineLength({ + ruleArguments: [ + true, + { + limit: 123, + "check-strings": false, + }, + ], + }); + + expect(result).toEqual({ + rules: [ + { + ruleArguments: [ + { + code: 123, + ignoreStrings: true, + }, + ], + ruleName: "max-len", + }, + ], + }); + }); + + test("conversion with check-regex inverting value true to false", () => { + const result = convertMaxLineLength({ + ruleArguments: [ + true, + { + limit: 123, + "check-regex": true, + }, + ], + }); + + expect(result).toEqual({ + rules: [ + { + ruleArguments: [ + { + code: 123, + ignoreRegExpLiterals: false, + }, + ], + ruleName: "max-len", + }, + ], + }); + }); + + test("conversion with check-regex inverting value false to true", () => { + const result = convertMaxLineLength({ + ruleArguments: [ + true, + { + limit: 123, + "check-regex": false, + }, + ], + }); + + expect(result).toEqual({ + rules: [ + { + ruleArguments: [ + { + code: 123, + ignoreRegExpLiterals: true, + }, + ], + ruleName: "max-len", + }, + ], + }); + }); +}); From 2bf57fc28d792af067ec8039a7f55121e72b2e6f Mon Sep 17 00:00:00 2001 From: Josh Goldberg Date: Fri, 4 Oct 2019 12:03:14 +0900 Subject: [PATCH 2/2] Update max-line-length.test.ts --- src/rules/converters/tests/max-line-length.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/rules/converters/tests/max-line-length.test.ts b/src/rules/converters/tests/max-line-length.test.ts index 94b3e83a2..17332a21b 100644 --- a/src/rules/converters/tests/max-line-length.test.ts +++ b/src/rules/converters/tests/max-line-length.test.ts @@ -29,7 +29,7 @@ describe(convertMaxLineLength, () => { }); }); - test("conversion with two argument and first is false", () => { + test("conversion with two arguments and first is false", () => { const result = convertMaxLineLength({ ruleArguments: [false, 123], });